Section.hpp

Go to the documentation of this file.

//===- Section.hpp ----------------------------------------------*- C++ -*-===//
//
//  Copyright (C) 2020 GrammaTech, Inc.
//
//  This code is licensed under the MIT license. See the LICENSE file in the
//  project root for license terms.
//
//  This project is sponsored by the Office of Naval Research, One Liberty
//  Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
//  N68335-17-C-0700.  The content of the information does not necessarily
//  reflect the position or policy of the Government and no official
//  endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_SECTION_H
#define GTIRB_SECTION_H
 
#include <gtirb/Addr.hpp>
#include <gtirb/ByteInterval.hpp>
#include <gtirb/CodeBlock.hpp>
#include <gtirb/DataBlock.hpp>
#include <gtirb/Node.hpp>
#include <gtirb/Observer.hpp>
#include <gtirb/Utility.hpp>
#include <gtirb/proto/Section.pb.h>
#include <algorithm>
#include <boost/icl/interval_map.hpp>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/key_extractors.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/range/iterator_range.hpp>
#include <cstdint>
#include <functional>
#include <set>
 
 
namespace gtirb {
class Module; // Forward declared for the backpointer.
class SectionObserver;
template <typename T> class ErrorOr;
 
enum class SectionFlag : uint8_t {
  Undefined = proto::SectionFlag::Section_Undefined,
  Readable = proto::SectionFlag::Readable,
  Writable = proto::SectionFlag::Writable,
  Executable = proto::SectionFlag::Executable,
  Loaded = proto::SectionFlag::Loaded,
  Initialized = proto::SectionFlag::Initialized,
  ThreadLocal = proto::SectionFlag::ThreadLocal,
};
 
class GTIRB_EXPORT_API Section : public Node {
  Section(Context& C);
  Section(Context& C, const std::string& N);
  Section(Context& C, const std::string& N, const UUID& U);
 
  static Section* Create(Context& C, const std::string& Name, const UUID& U) {
    return C.Create<Section>(C, Name, U);
  }
 
  struct by_address {};
  struct by_pointer {};
 
  using ByteIntervalSet = boost::multi_index::multi_index_container<
      ByteInterval*,
      boost::multi_index::indexed_by<
          boost::multi_index::ordered_non_unique<
              boost::multi_index::tag<by_address>,
              boost::multi_index::identity<ByteInterval*>, AddressLess>,
          boost::multi_index::hashed_unique<
              boost::multi_index::tag<by_pointer>,
              boost::multi_index::identity<ByteInterval*>>>>;
  using ByteIntervalIntMap =
      boost::icl::interval_map<Addr, std::set<ByteInterval*, AddressLess>>;
 
  class ByteIntervalObserverImpl;
 
public:
  static Section* Create(Context& C) { return C.Create<Section>(C); }
 
  static Section* Create(Context& C, const std::string& Name) {
    return C.Create<Section>(C, Name);
  }
 
  bool operator==(const Section& Other) const;
 
  bool operator!=(const Section& Other) const;
 
  Module* getModule() { return Parent; }
  const Module* getModule() const { return Parent; }
 
  const std::string& getName() const { return Name; }
 
  void addFlag(SectionFlag F) { Flags.insert(F); }
 
  template <typename... Fs> void addFlags(Fs... F) { (addFlag(F), ...); }
 
  void removeFlag(SectionFlag F) { Flags.erase(F); }
 
  bool isFlagSet(SectionFlag F) const {
    return std::find(Flags.begin(), Flags.end(), F) != Flags.end();
  }
 
  using const_section_flag_iterator = std::set<SectionFlag>::const_iterator;
  using const_section_flag_range =
      boost::iterator_range<const_section_flag_iterator>;
 
  const_section_flag_iterator flags_begin() const { return Flags.begin(); }
  const_section_flag_iterator flags_end() const { return Flags.end(); }
  const_section_flag_range flags() const {
    return boost::make_iterator_range(flags_begin(), flags_end());
  }
 
  using byte_interval_iterator =
      boost::indirect_iterator<ByteIntervalSet::iterator>;
  using byte_interval_range = boost::iterator_range<byte_interval_iterator>;
  using byte_interval_subrange = boost::iterator_range<
      boost::indirect_iterator<ByteIntervalIntMap::codomain_type::iterator>>;
  using const_byte_interval_iterator =
      boost::indirect_iterator<ByteIntervalSet::const_iterator,
                               const ByteInterval>;
  using const_byte_interval_range =
      boost::iterator_range<const_byte_interval_iterator>;
  using const_byte_interval_subrange =
      boost::iterator_range<boost::indirect_iterator<
          ByteIntervalIntMap::codomain_type::const_iterator>>;
 
  byte_interval_iterator byte_intervals_begin() {
    return ByteIntervals.begin();
  }
  const_byte_interval_iterator byte_intervals_begin() const {
    return ByteIntervals.begin();
  }
  byte_interval_iterator byte_intervals_end() { return ByteIntervals.end(); }
  const_byte_interval_iterator byte_intervals_end() const {
    return ByteIntervals.end();
  }
  byte_interval_range byte_intervals() {
    return boost::make_iterator_range(byte_intervals_begin(),
                                      byte_intervals_end());
  }
  const_byte_interval_range byte_intervals() const {
    return boost::make_iterator_range(byte_intervals_begin(),
                                      byte_intervals_end());
  }
 
  byte_interval_subrange findByteIntervalsOn(Addr A) {
    if (auto It = ByteIntervalAddrs.find(A); It != ByteIntervalAddrs.end()) {
      return boost::make_iterator_range(
          boost::make_indirect_iterator(It->second.begin()),
          boost::make_indirect_iterator(It->second.end()));
    }
    return {};
  }
 
  const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    if (auto It = ByteIntervalAddrs.find(A); It != ByteIntervalAddrs.end()) {
      return boost::make_iterator_range(
          boost::make_indirect_iterator(It->second.begin()),
          boost::make_indirect_iterator(It->second.end()));
    }
    return {};
  }
 
  byte_interval_range findByteIntervalsAt(Addr A) {
    auto Pair = ByteIntervals.get<by_address>().equal_range(A);
    return boost::make_iterator_range(byte_interval_iterator(Pair.first),
                                      byte_interval_iterator(Pair.second));
  }
 
  byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    auto& Index = ByteIntervals.get<by_address>();
    if (High < Low) {
      return boost::make_iterator_range(Index.end(), Index.end());
    }
    return boost::make_iterator_range(
        byte_interval_iterator(Index.lower_bound(Low)),
        byte_interval_iterator(Index.lower_bound(High)));
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr A) const {
    auto Pair = ByteIntervals.get<by_address>().equal_range(A);
    return boost::make_iterator_range(
        const_byte_interval_iterator(Pair.first),
        const_byte_interval_iterator(Pair.second));
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) const {
    auto& Index = ByteIntervals.get<by_address>();
    if (High < Low) {
      return boost::make_iterator_range(Index.end(), Index.end());
    }
    return boost::make_iterator_range(
        const_byte_interval_iterator(Index.lower_bound(Low)),
        const_byte_interval_iterator(Index.lower_bound(High)));
  }
 
  std::optional<Addr> getAddress() const {
    if (Extent) {
      return Extent->lower();
    }
    return std::nullopt;
  }
 
  std::optional<uint64_t> getSize() const {
    if (Extent) {
      return Extent->size();
    }
    return std::nullopt;
  }
 
  ChangeStatus removeByteInterval(ByteInterval* N);
 
  ChangeStatus addByteInterval(ByteInterval* BI);
 
  template <typename... Args>
  ByteInterval* addByteInterval(Context& C, Args&&... A) {
    ByteInterval* BI = ByteInterval::Create(C, std::forward<Args>(A)...);
    [[maybe_unused]] ChangeStatus status = addByteInterval(BI);
    // addByteInterval(ByteInterval*) does not currently reject any insertions
    // and the result cannot be NoChange because we just inserted a newly
    // created ByteInterval.
    assert(status == ChangeStatus::Accepted &&
           "unexpected result when inserting ByteInterval");
    return BI;
  }
 
  void setName(const std::string& N);
 
  using block_iterator =
      MergeSortedIterator<ByteInterval::block_iterator, BlockAddressLess>;
  using block_range = boost::iterator_range<block_iterator>;
  using block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::block_subrange::iterator, BlockAddressLess>>;
  using const_block_iterator =
      MergeSortedIterator<ByteInterval::const_block_iterator, BlockAddressLess>;
  using const_block_range = boost::iterator_range<const_block_iterator>;
  using const_block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::const_block_subrange::iterator, BlockAddressLess>>;
 
  block_iterator blocks_begin() {
    return block_iterator(
        boost::make_transform_iterator(this->byte_intervals_begin(),
                                       NodeToBlockRange<ByteInterval>()),
        boost::make_transform_iterator(this->byte_intervals_end(),
                                       NodeToBlockRange<ByteInterval>()));
  }
 
  block_iterator blocks_end() { return block_iterator(); }
 
  block_range blocks() {
    return boost::make_iterator_range(blocks_begin(), blocks_end());
  }
 
  const_block_iterator blocks_begin() const {
    return const_block_iterator(
        boost::make_transform_iterator(this->byte_intervals_begin(),
                                       NodeToBlockRange<const ByteInterval>()),
        boost::make_transform_iterator(this->byte_intervals_end(),
                                       NodeToBlockRange<const ByteInterval>()));
  }
 
  const_block_iterator blocks_end() const { return const_block_iterator(); }
 
  const_block_range blocks() const {
    return boost::make_iterator_range(blocks_begin(), blocks_end());
  }
 
  block_subrange findBlocksOn(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return block_subrange(
        block_subrange::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindBlocksIn<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindBlocksIn<ByteInterval>(A))),
        block_subrange::iterator());
  }
 
  const_block_subrange findBlocksOn(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_block_subrange(
        const_block_subrange::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindBlocksIn<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindBlocksIn<const ByteInterval>(A))),
        const_block_subrange::iterator());
  }
 
  block_range findBlocksAt(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return block_range(
        block_range::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindBlocksAt<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindBlocksAt<ByteInterval>(A))),
        block_range::iterator());
  }
 
  block_range findBlocksAt(Addr Low, Addr High) {
    std::vector<ByteInterval::block_range> Ranges;
    for (ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findBlocksAt(Low, High));
    for (ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findBlocksAt(Low, High));
    return block_range(block_iterator(Ranges), block_iterator());
  }
 
  const_block_range findBlocksAt(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_block_range(
        const_block_range::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindBlocksAt<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindBlocksAt<const ByteInterval>(A))),
        const_block_range::iterator());
  }
 
  const_block_range findBlocksAt(Addr Low, Addr High) const {
    std::vector<ByteInterval::const_block_range> Ranges;
    for (const ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findBlocksAt(Low, High));
    for (const ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findBlocksAt(Low, High));
    return const_block_range(const_block_iterator(Ranges),
                             const_block_iterator());
  }
 
  using code_block_iterator =
      MergeSortedIterator<ByteInterval::code_block_iterator, AddressLess>;
  using code_block_range = boost::iterator_range<code_block_iterator>;
  using code_block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::code_block_subrange::iterator, AddressLess>>;
  using const_code_block_iterator =
      MergeSortedIterator<ByteInterval::const_code_block_iterator, AddressLess>;
  using const_code_block_range =
      boost::iterator_range<const_code_block_iterator>;
  using const_code_block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::const_code_block_subrange::iterator, AddressLess>>;
 
private:
  code_block_range makeCodeBlockRange(ByteIntervalSet::iterator Begin,
                                      ByteIntervalSet::iterator End) {
    NodeToCodeBlockRange<ByteInterval> Transformer;
    return boost::make_iterator_range(
        code_block_iterator(boost::make_transform_iterator(
                                byte_interval_iterator(Begin), Transformer),
                            boost::make_transform_iterator(
                                byte_interval_iterator(End), Transformer)),
        code_block_iterator());
  }
 
public:
  code_block_iterator code_blocks_begin() {
    return code_block_iterator(
        boost::make_transform_iterator(this->byte_intervals_begin(),
                                       NodeToCodeBlockRange<ByteInterval>()),
        boost::make_transform_iterator(this->byte_intervals_end(),
                                       NodeToCodeBlockRange<ByteInterval>()));
  }
 
  code_block_iterator code_blocks_end() { return code_block_iterator(); }
 
  code_block_range code_blocks() {
    return boost::make_iterator_range(code_blocks_begin(), code_blocks_end());
  }
 
  const_code_block_iterator code_blocks_begin() const {
    return const_code_block_iterator(
        boost::make_transform_iterator(
            this->byte_intervals_begin(),
            NodeToCodeBlockRange<const ByteInterval>()),
        boost::make_transform_iterator(
            this->byte_intervals_end(),
            NodeToCodeBlockRange<const ByteInterval>()));
  }
 
  const_code_block_iterator code_blocks_end() const {
    return const_code_block_iterator();
  }
 
  const_code_block_range code_blocks() const {
    return boost::make_iterator_range(code_blocks_begin(), code_blocks_end());
  }
 
  code_block_subrange findCodeBlocksOn(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return code_block_subrange(
        code_block_subrange::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindCodeBlocksIn<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindCodeBlocksIn<ByteInterval>(A))),
        code_block_subrange::iterator());
  }
 
  const_code_block_subrange findCodeBlocksOn(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_code_block_subrange(
        const_code_block_subrange::iterator(
            boost::make_transform_iterator(
                Intervals.begin(), FindCodeBlocksIn<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindCodeBlocksIn<const ByteInterval>(A))),
        const_code_block_subrange::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return code_block_range(
        code_block_range::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindCodeBlocksAt<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindCodeBlocksAt<ByteInterval>(A))),
        code_block_range::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    std::vector<ByteInterval::code_block_range> Ranges;
    for (ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findCodeBlocksAt(Low, High));
    for (ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findCodeBlocksAt(Low, High));
    return code_block_range(code_block_iterator(Ranges), code_block_iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_code_block_range(
        const_code_block_range::iterator(
            boost::make_transform_iterator(
                Intervals.begin(), FindCodeBlocksAt<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindCodeBlocksAt<const ByteInterval>(A))),
        const_code_block_range::iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    std::vector<ByteInterval::const_code_block_range> Ranges;
    for (const ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findCodeBlocksAt(Low, High));
    for (const ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findCodeBlocksAt(Low, High));
    return const_code_block_range(const_code_block_iterator(Ranges),
                                  const_code_block_iterator());
  }
 
  using data_block_iterator =
      MergeSortedIterator<ByteInterval::data_block_iterator, AddressLess>;
  using data_block_range = boost::iterator_range<data_block_iterator>;
  using data_block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::data_block_subrange::iterator, AddressLess>>;
  using const_data_block_iterator =
      MergeSortedIterator<ByteInterval::const_data_block_iterator, AddressLess>;
  using const_data_block_range =
      boost::iterator_range<const_data_block_iterator>;
  using const_data_block_subrange = boost::iterator_range<MergeSortedIterator<
      ByteInterval::const_data_block_subrange::iterator, AddressLess>>;
 
  data_block_iterator data_blocks_begin() {
    return data_block_iterator(
        boost::make_transform_iterator(this->byte_intervals_begin(),
                                       NodeToDataBlockRange<ByteInterval>()),
        boost::make_transform_iterator(this->byte_intervals_end(),
                                       NodeToDataBlockRange<ByteInterval>()));
  }
 
  data_block_iterator data_blocks_end() { return data_block_iterator(); }
 
  data_block_range data_blocks() {
    return boost::make_iterator_range(data_blocks_begin(), data_blocks_end());
  }
 
  const_data_block_iterator data_blocks_begin() const {
    return const_data_block_iterator(
        boost::make_transform_iterator(
            this->byte_intervals_begin(),
            NodeToDataBlockRange<const ByteInterval>()),
        boost::make_transform_iterator(
            this->byte_intervals_end(),
            NodeToDataBlockRange<const ByteInterval>()));
  }
 
  const_data_block_iterator data_blocks_end() const {
    return const_data_block_iterator();
  }
 
  const_data_block_range data_blocks() const {
    return boost::make_iterator_range(data_blocks_begin(), data_blocks_end());
  }
 
  data_block_subrange findDataBlocksOn(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return data_block_subrange(
        data_block_subrange::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindDataBlocksIn<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindDataBlocksIn<ByteInterval>(A))),
        data_block_subrange::iterator());
  }
 
  const_data_block_subrange findDataBlocksOn(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_data_block_subrange(
        const_data_block_subrange::iterator(
            boost::make_transform_iterator(
                Intervals.begin(), FindDataBlocksIn<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindDataBlocksIn<const ByteInterval>(A))),
        const_data_block_subrange::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr A) {
    byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return data_block_range(
        data_block_range::iterator(
            boost::make_transform_iterator(Intervals.begin(),
                                           FindDataBlocksAt<ByteInterval>(A)),
            boost::make_transform_iterator(Intervals.end(),
                                           FindDataBlocksAt<ByteInterval>(A))),
        data_block_range::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr Low, Addr High) {
    std::vector<ByteInterval::data_block_range> Ranges;
    for (ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findDataBlocksAt(Low, High));
    for (ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findDataBlocksAt(Low, High));
    return data_block_range(data_block_iterator(Ranges), data_block_iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr A) const {
    const_byte_interval_subrange Intervals = findByteIntervalsOn(A);
    return const_data_block_range(
        const_data_block_range::iterator(
            boost::make_transform_iterator(
                Intervals.begin(), FindDataBlocksAt<const ByteInterval>(A)),
            boost::make_transform_iterator(
                Intervals.end(), FindDataBlocksAt<const ByteInterval>(A))),
        const_data_block_range::iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    std::vector<ByteInterval::const_data_block_range> Ranges;
    for (const ByteInterval& BI : findByteIntervalsOn(Low))
      Ranges.push_back(BI.findDataBlocksAt(Low, High));
    for (const ByteInterval& BI : findByteIntervalsAt(Low + 1, High))
      Ranges.push_back(BI.findDataBlocksAt(Low, High));
    return const_data_block_range(const_data_block_iterator(Ranges),
                                  const_data_block_iterator());
  }
 
  using symbolic_expression_iterator =
      MergeSortedIterator<ByteInterval::symbolic_expression_iterator,
                          ByteInterval::SymbolicExpressionElement::AddressLess>;
  using symbolic_expression_range =
      boost::iterator_range<symbolic_expression_iterator>;
  using const_symbolic_expression_iterator = MergeSortedIterator<
      ByteInterval::const_symbolic_expression_iterator,
      ByteInterval::ConstSymbolicExpressionElement::AddressLess>;
  using const_symbolic_expression_range =
      boost::iterator_range<const_symbolic_expression_iterator>;
 
  symbolic_expression_iterator symbolic_expressions_begin() {
    return symbolic_expression_iterator(
        boost::make_transform_iterator(
            this->byte_intervals_begin(),
            NodeToSymbolicExpressionRange<ByteInterval>()),
        boost::make_transform_iterator(
            this->byte_intervals_end(),
            NodeToSymbolicExpressionRange<ByteInterval>()));
  }
 
  symbolic_expression_iterator symbolic_expressions_end() {
    return symbolic_expression_iterator();
  }
 
  symbolic_expression_range symbolic_expressions() {
    return boost::make_iterator_range(symbolic_expressions_begin(),
                                      symbolic_expressions_end());
  }
 
  const_symbolic_expression_iterator symbolic_expressions_begin() const {
    return const_symbolic_expression_iterator(
        boost::make_transform_iterator(
            this->byte_intervals_begin(),
            NodeToSymbolicExpressionRange<const ByteInterval>()),
        boost::make_transform_iterator(
            this->byte_intervals_end(),
            NodeToSymbolicExpressionRange<const ByteInterval>()));
  }
 
  const_symbolic_expression_iterator symbolic_expressions_end() const {
    return const_symbolic_expression_iterator();
  }
 
  const_symbolic_expression_range symbolic_expressions() const {
    return boost::make_iterator_range(symbolic_expressions_begin(),
                                      symbolic_expressions_end());
  }
 
  symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
    return symbolic_expression_range(
        symbolic_expression_range::iterator(
            boost::make_transform_iterator(this->byte_intervals_begin(),
                                           FindSymExprsAt<ByteInterval>(A)),
            boost::make_transform_iterator(this->byte_intervals_end(),
                                           FindSymExprsAt<ByteInterval>(A))),
        symbolic_expression_range::iterator());
  }
 
  symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr High) {
    return symbolic_expression_range(
        symbolic_expression_range::iterator(
            boost::make_transform_iterator(
                this->byte_intervals_begin(),
                FindSymExprsBetween<ByteInterval>(Low, High)),
            boost::make_transform_iterator(
                this->byte_intervals_end(),
                FindSymExprsBetween<ByteInterval>(Low, High))),
        symbolic_expression_range::iterator());
  }
 
  const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
    return const_symbolic_expression_range(
        const_symbolic_expression_range::iterator(
            boost::make_transform_iterator(
                this->byte_intervals_begin(),
                FindSymExprsAt<const ByteInterval>(A)),
            boost::make_transform_iterator(
                this->byte_intervals_end(),
                FindSymExprsAt<const ByteInterval>(A))),
        const_symbolic_expression_range::iterator());
  }
 
  const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
                                                            Addr High) const {
    return const_symbolic_expression_range(
        const_symbolic_expression_range::iterator(
            boost::make_transform_iterator(
                this->byte_intervals_begin(),
                FindSymExprsBetween<const ByteInterval>(Low, High)),
            boost::make_transform_iterator(
                this->byte_intervals_end(),
                FindSymExprsBetween<const ByteInterval>(Low, High))),
        const_symbolic_expression_range::iterator());
  }
 
  static bool classof(const Node* N) { return N->getKind() == Kind::Section; }
 
private:
  Module* Parent{nullptr};
  SectionObserver* Observer{nullptr};
  std::string Name;
  ByteIntervalSet ByteIntervals;
  ByteIntervalIntMap ByteIntervalAddrs;
  std::optional<AddrRange> Extent;
  std::set<SectionFlag> Flags;
 
  std::unique_ptr<ByteIntervalObserver> BIO;
 
  void removeByteIntervalAddrs(ByteInterval* BI);
 
  void insertByteIntervalAddrs(ByteInterval* BI);
 
  ChangeStatus updateExtent();
 
  void setParent(Module* M, SectionObserver* O) {
    Parent = M;
    Observer = O;
  }
 
  using MessageType = proto::Section;
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<Section*> fromProtobuf(Context& C, const MessageType& Message);
 
  // Present for testing purposes only.
  void save(std::ostream& Out) const;
 
  // Present for testing purposes only.
  static Section* load(Context& C, std::istream& In);
 
  friend class Context; // Allow Context to construct sections.
  friend class Module;  // Allow Module to call setModule, Create, etc.
  // Allows serializaton from Module via sequenceToProtobuf.
  template <typename T> friend typename T::MessageType toProtobuf(const T&);
  friend class SerializationTestHarness; // Testing support.
};
 
 
class GTIRB_EXPORT_API SectionObserver {
public:
  virtual ~SectionObserver() = default;
 
  virtual ChangeStatus nameChange(Section* S, const std::string& OldName,
                                  const std::string& NewName) = 0;
 
  virtual ChangeStatus addCodeBlocks(Section* S,
                                     Section::code_block_range Blocks) = 0;
 
  virtual ChangeStatus moveCodeBlocks(Section* S,
                                      Section::code_block_range Blocks) = 0;
 
  virtual ChangeStatus removeCodeBlocks(Section* S,
                                        Section::code_block_range Blocks) = 0;
 
  virtual ChangeStatus addDataBlocks(Section* S,
                                     Section::data_block_range Blocks) = 0;
 
  virtual ChangeStatus moveDataBlocks(Section* S,
                                      Section::data_block_range Blocks) = 0;
 
  virtual ChangeStatus removeDataBlocks(Section* S,
                                        Section::data_block_range Blocks) = 0;
 
  virtual ChangeStatus changeExtent(Section* S,
                                    std::function<void(Section*)> Callback) = 0;
};
 
inline void Section::setName(const std::string& X) {
  if (Observer) {
    std::string OldName = X;
    std::swap(Name, OldName);
    [[maybe_unused]] ChangeStatus status =
        Observer->nameChange(this, OldName, Name);
    // The known observers do not reject insertions. If that changes, this
    // method must be updated.
    assert(status != ChangeStatus::Rejected &&
           "recovering from rejected name change is unimplemented");
  } else {
    Name = X;
  }
}
} // namespace gtirb
 
#endif // GTIRB_SECTION_H