ByteInterval.hpp

Go to the documentation of this file.

//===- ByteInterval.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_BYTE_INTERVAL_H
#define GTIRB_BYTE_INTERVAL_H
 
#include <gtirb/DecodeMode.hpp>
#include <gtirb/Export.hpp>
#include <gtirb/Node.hpp>
#include <gtirb/Observer.hpp>
#include <gtirb/SymbolicExpression.hpp>
#include <gtirb/Utility.hpp>
#include <array>
#include <boost/endian/conversion.hpp>
#include <boost/icl/interval_map.hpp>
#include <boost/iterator/filter_iterator.hpp>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/key_extractors.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/range/iterator_range.hpp>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <type_traits>
#include <variant>
#include <vector>
 
 
namespace gtirb {
namespace proto {
class ByteInterval;
} // namespace proto
 
class Section;   // Forward declared for the backpointer.
class CodeBlock; // Forward declared so Blocks can store CodeBlocks.
class DataBlock; // Forward declared so Blocks can store DataBlocks.
class ByteIntervalObserver;
 
template <class T> class ErrorOr;
 
 
class GTIRB_EXPORT_API CodeBlockObserver {
public:
  virtual ~CodeBlockObserver() = default;
 
  virtual ChangeStatus sizeChange(CodeBlock* B, uint64_t OldSize,
                                  uint64_t NewSize) = 0;
  virtual ChangeStatus decodeModeChange(CodeBlock* B, DecodeMode OldMode,
                                        DecodeMode NewMode) = 0;
};
 
 
class GTIRB_EXPORT_API DataBlockObserver {
public:
  virtual ~DataBlockObserver() = default;
 
  virtual ChangeStatus sizeChange(DataBlock* B, uint64_t OldSize,
                                  uint64_t NewSize) = 0;
};
 
class GTIRB_EXPORT_API ByteInterval : public Node {
  struct Block {
    uint64_t Offset;
    gtirb::Node* Node;
 
    Block(uint64_t Off, gtirb::Node* N) : Offset(Off), Node(N) {}
 
    uint64_t getOffset() const { return Offset; }
 
    gtirb::Node* getNode() const { return Node; }
  };
 
  template <Node::Kind K> struct BlockKindEquals {
    bool operator()(const Block& B) const {
      return B.getNode()->getKind() == K;
    }
  };
 
  template <typename NodeType> struct BlockToNode {
    BlockToNode() {}
 
    BlockToNode(const BlockToNode<std::remove_const_t<NodeType>>&) {}
 
    BlockToNode& operator=(const BlockToNode<std::remove_const_t<NodeType>>&) {
      return *this;
    }
 
    NodeType& operator()(const Block& B) const {
      // We avoid the call to cast() here because we use this function after
      // BlockKindEquals, which confirms the type of the Node for us
      // (and more importantly, we avoid having to include Code/DataBlock).
      return *reinterpret_cast<NodeType*>(B.Node);
    }
 
    NodeType& operator()(const Block* B) const { return *B->Node; }
  };
 
  struct GTIRB_EXPORT_API BlockOffsetLess {
    bool operator()(const Block* B1, const Block* B2) const {
      return BlockOffsetPairLess()({B1->Offset, B1->Node},
                                   {B2->Offset, B2->Node});
    }
    bool operator()(const Block& B1, const Block& B2) const {
      return operator()(&B1, &B2);
    }
  };
 
  struct GTIRB_EXPORT_API OffsetCmp {
    bool operator()(uint64_t Offset, const Block& B) const {
      return Offset < B.Offset;
    }
    bool operator()(const Block& B, uint64_t Offset) const {
      return B.Offset < Offset;
    }
  };
 
  struct by_offset {};
  struct by_pointer {};
  using BlockSet = boost::multi_index::multi_index_container<
      Block, boost::multi_index::indexed_by<
                 boost::multi_index::ordered_non_unique<
                     boost::multi_index::tag<by_offset>,
                     boost::multi_index::identity<Block>, BlockOffsetLess>,
                 boost::multi_index::hashed_unique<
                     boost::multi_index::tag<by_pointer>,
                     boost::multi_index::const_mem_fun<Block, Node*,
                                                       &Block::getNode>>>>;
  using BlockIntMap =
      boost::icl::interval_map<uint64_t,
                               std::multiset<const Block*, BlockOffsetLess>>;
  using SymbolicExpressionMap = std::map<uint64_t, SymbolicExpression>;
 
  const Block& nodeToBlock(const Node* N) const {
    auto& Index = Blocks.get<by_pointer>();
    auto It = Index.find(const_cast<Node*>(N));
    assert(It != Index.end() &&
           "ByteInterval::nodeToBlock called with block not in interval");
    return *It;
  }
 
  class CodeBlockObserverImpl;
  class DataBlockObserverImpl;
 
  void updateIntervalMap(Node* N, std::optional<uint64_t> OldSize,
                         std::optional<uint64_t> NewSize);
  void updateBlockSortOrder(Node* N);
 
  ChangeStatus sizeChange(Node* N, uint64_t OldSize, uint64_t NewSize);
  ChangeStatus decodeModeChange(CodeBlock* B, DecodeMode OldMode,
                                DecodeMode NewMode);
 
public:
  static ByteInterval* Create(Context& C) { return C.Create<ByteInterval>(C); }
 
  static ByteInterval* Create(Context& C, uint64_t Size,
                              std::optional<uint64_t> InitSize = std::nullopt) {
    return C.Create<ByteInterval>(C, std::nullopt, Size,
                                  InitSize.value_or(Size));
  }
 
  static ByteInterval* Create(Context& C, std::optional<Addr> Address,
                              uint64_t Size = 0,
                              std::optional<uint64_t> InitSize = std::nullopt) {
    return C.Create<ByteInterval>(C, Address, Size, InitSize.value_or(Size));
  }
 
  template <typename InputIterator>
  static ByteInterval* Create(Context& C, InputIterator Begin,
                              InputIterator End,
                              std::optional<uint64_t> Size = std::nullopt,
                              std::optional<uint64_t> InitSize = std::nullopt) {
    return C.Create<ByteInterval>(
        C, std::nullopt, Size ? *Size : std::distance(Begin, End),
        InitSize ? *InitSize : std::distance(Begin, End), Begin, End);
  }
 
  template <typename InputIterator>
  static ByteInterval* Create(Context& C, std::optional<Addr> Address,
                              InputIterator Begin, InputIterator End,
                              std::optional<uint64_t> Size = std::nullopt,
                              std::optional<uint64_t> InitSize = std::nullopt) {
    return C.Create<ByteInterval>(
        C, Address, Size ? *Size : std::distance(Begin, End),
        InitSize ? *InitSize : std::distance(Begin, End), Begin, End);
  }
 
  Section* getSection() { return Parent; }
  const Section* getSection() const { return Parent; }
 
  std::optional<Addr> getAddress() const { return Address; }
 
 
  using block_iterator =
      boost::transform_iterator<BlockToNode<Node>,
                                BlockSet::index<by_offset>::type::iterator>;
  using block_range = boost::iterator_range<block_iterator>;
  using block_subrange = boost::iterator_range<boost::transform_iterator<
      BlockToNode<Node>, BlockIntMap::codomain_type::iterator>>;
  using const_block_iterator = boost::transform_iterator<
      BlockToNode<const Node>,
      BlockSet::index<by_offset>::type::const_iterator>;
  using const_block_range = boost::iterator_range<const_block_iterator>;
  using const_block_subrange = boost::iterator_range<boost::transform_iterator<
      BlockToNode<const Node>, BlockIntMap::codomain_type::const_iterator>>;
 
  block_iterator blocks_begin() { return block_iterator(Blocks.begin()); }
  const_block_iterator blocks_begin() const {
    return const_block_iterator(Blocks.begin());
  }
  block_iterator blocks_end() { return block_iterator(Blocks.end()); }
  const_block_iterator blocks_end() const {
    return const_block_iterator(Blocks.end());
  }
  block_range blocks() {
    return boost::make_iterator_range(blocks_begin(), blocks_end());
  }
  const_block_range blocks() const {
    return boost::make_iterator_range(blocks_begin(), blocks_end());
  }
 
  block_subrange findBlocksOnOffset(uint64_t Off) {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      return block_subrange(It->second.begin(), It->second.end());
    }
    return {};
  }
 
  const_block_subrange findBlocksOnOffset(uint64_t Off) const {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      return const_block_subrange(It->second.begin(), It->second.end());
    }
    return {};
  }
 
  block_subrange findBlocksOn(Addr A) {
    if (Address) {
      return findBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  const_block_subrange findBlocksOn(Addr A) const {
    if (Address) {
      return findBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  block_range findBlocksAtOffset(uint64_t Off) {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(block_iterator(Pair.first),
                                      block_iterator(Pair.second));
  }
 
  block_range findBlocksAtOffset(uint64_t Low, uint64_t High) {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(block_iterator(LowIt),
                                      block_iterator(HighIt));
  }
 
  block_range findBlocksAt(Addr A) {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findBlocksAtOffset(0, 0);
    }
    return findBlocksAtOffset(A - *Address);
  }
 
  block_range findBlocksAt(Addr Low, Addr High) {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findBlocksAtOffset(0, 0);
    }
    return findBlocksAtOffset(Low - std::min(*Address, Low),
                              High - std::min(*Address, High));
  }
 
  const_block_range findBlocksAtOffset(uint64_t Off) const {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(const_block_iterator(Pair.first),
                                      const_block_iterator(Pair.second));
  }
 
  const_block_range findBlocksAtOffset(uint64_t Low, uint64_t High) const {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(const_block_iterator(LowIt),
                                      const_block_iterator(HighIt));
  }
 
  const_block_range findBlocksAt(Addr A) const {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findBlocksAtOffset(0, 0);
    }
    return findBlocksAtOffset(A - *Address);
  }
 
  const_block_range findBlocksAt(Addr Low, Addr High) const {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findBlocksAtOffset(0, 0);
    }
    return findBlocksAtOffset(Low - std::min(*Address, Low),
                              High - std::min(*Address, High));
  }
 
  using code_block_iterator = boost::transform_iterator<
      BlockToNode<CodeBlock>,
      boost::filter_iterator<BlockKindEquals<Node::Kind::CodeBlock>,
                             BlockSet::index<by_offset>::type::iterator>>;
  using code_block_range = boost::iterator_range<code_block_iterator>;
  using code_block_subrange = boost::iterator_range<boost::transform_iterator<
      BlockToNode<CodeBlock>,
      boost::filter_iterator<
          BlockKindEquals<Node::Kind::CodeBlock>,
          boost::indirect_iterator<BlockIntMap::codomain_type::iterator>>>>;
  using const_code_block_iterator = boost::transform_iterator<
      BlockToNode<const CodeBlock>,
      boost::filter_iterator<BlockKindEquals<Node::Kind::CodeBlock>,
                             BlockSet::index<by_offset>::type::const_iterator>>;
  using const_code_block_range =
      boost::iterator_range<const_code_block_iterator>;
  using const_code_block_subrange =
      boost::iterator_range<boost::transform_iterator<
          BlockToNode<const CodeBlock>,
          boost::filter_iterator<
              BlockKindEquals<Node::Kind::CodeBlock>,
              boost::indirect_iterator<
                  BlockIntMap::codomain_type::const_iterator>>>>;
 
  code_block_iterator code_blocks_begin() {
    return code_block_iterator(
        code_block_iterator::base_type(Blocks.begin(), Blocks.end()));
  }
  const_code_block_iterator code_blocks_begin() const {
    return const_code_block_iterator(
        const_code_block_iterator::base_type(Blocks.begin(), Blocks.end()));
  }
  code_block_iterator code_blocks_end() {
    return code_block_iterator(
        code_block_iterator::base_type(Blocks.end(), Blocks.end()));
  }
  const_code_block_iterator code_blocks_end() const {
    return const_code_block_iterator(
        const_code_block_iterator::base_type(Blocks.end(), Blocks.end()));
  }
  code_block_range code_blocks() {
    return boost::make_iterator_range(code_blocks_begin(), code_blocks_end());
  }
  const_code_block_range code_blocks() const {
    return boost::make_iterator_range(code_blocks_begin(), code_blocks_end());
  }
 
  code_block_subrange findCodeBlocksOnOffset(uint64_t Off) {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      auto End = boost::make_indirect_iterator(It->second.end());
      return code_block_subrange(
          code_block_subrange::iterator::base_type(
              boost::make_indirect_iterator(It->second.begin()), End),
          code_block_subrange::iterator::base_type(End, End));
    }
    return {};
  }
 
  const_code_block_subrange findCodeBlocksOnOffset(uint64_t Off) const {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      auto End = boost::make_indirect_iterator(It->second.end());
      return const_code_block_subrange(
          const_code_block_subrange::iterator::base_type(
              boost::make_indirect_iterator(It->second.begin()), End),
          const_code_block_subrange::iterator::base_type(End, End));
    }
    return {};
  }
 
  code_block_subrange findCodeBlocksOn(Addr A) {
    if (Address) {
      return findCodeBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  const_code_block_subrange findCodeBlocksOn(Addr A) const {
    if (Address) {
      return findCodeBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  code_block_range findCodeBlocksAtOffset(uint64_t Off) {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(
        code_block_iterator(
            code_block_iterator::base_type(Pair.first, Pair.second)),
        code_block_iterator(
            code_block_iterator::base_type(Pair.second, Pair.second)));
  }
 
  code_block_range findCodeBlocksAtOffset(uint64_t Low, uint64_t High) {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(
        code_block_iterator(code_block_iterator::base_type(LowIt, HighIt)),
        code_block_iterator(code_block_iterator::base_type(HighIt, HighIt)));
  }
 
  code_block_range findCodeBlocksAt(Addr A) {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findCodeBlocksAtOffset(0, 0);
    }
    return findCodeBlocksAtOffset(A - *Address);
  }
 
  code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findCodeBlocksAtOffset(0, 0);
    }
    return findCodeBlocksAtOffset(Low - std::min(*Address, Low),
                                  High - std::min(*Address, High));
  }
 
  const_code_block_range findCodeBlocksAtOffset(uint64_t Off) const {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(
        const_code_block_iterator(
            const_code_block_iterator::base_type(Pair.first, Pair.second)),
        const_code_block_iterator(
            const_code_block_iterator::base_type(Pair.second, Pair.second)));
  }
 
  const_code_block_range findCodeBlocksAtOffset(uint64_t Low,
                                                uint64_t High) const {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(
        const_code_block_iterator(
            const_code_block_iterator::base_type(LowIt, HighIt)),
        const_code_block_iterator(
            const_code_block_iterator::base_type(HighIt, HighIt)));
  }
 
  const_code_block_range findCodeBlocksAt(Addr A) const {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findCodeBlocksAtOffset(0, 0);
    }
    return findCodeBlocksAtOffset(A - *Address);
  }
 
  const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findCodeBlocksAtOffset(0, 0);
    }
    return findCodeBlocksAtOffset(Low - std::min(*Address, Low),
                                  High - std::min(*Address, High));
  }
 
  using data_block_iterator = boost::transform_iterator<
      BlockToNode<DataBlock>,
      boost::filter_iterator<BlockKindEquals<Node::Kind::DataBlock>,
                             BlockSet::index<by_offset>::type::iterator>>;
  using data_block_range = boost::iterator_range<data_block_iterator>;
  using data_block_subrange = boost::iterator_range<boost::transform_iterator<
      BlockToNode<DataBlock>,
      boost::filter_iterator<
          BlockKindEquals<Node::Kind::DataBlock>,
          boost::indirect_iterator<BlockIntMap::codomain_type::iterator>>>>;
  using const_data_block_iterator = boost::transform_iterator<
      BlockToNode<const DataBlock>,
      boost::filter_iterator<BlockKindEquals<Node::Kind::DataBlock>,
                             BlockSet::index<by_offset>::type::const_iterator>>;
  using const_data_block_range =
      boost::iterator_range<const_data_block_iterator>;
  using const_data_block_subrange =
      boost::iterator_range<boost::transform_iterator<
          BlockToNode<const DataBlock>,
          boost::filter_iterator<
              BlockKindEquals<Node::Kind::DataBlock>,
              boost::indirect_iterator<
                  BlockIntMap::codomain_type::const_iterator>>>>;
 
  data_block_iterator data_blocks_begin() {
    return data_block_iterator(
        data_block_iterator::base_type(Blocks.begin(), Blocks.end()));
  }
  const_data_block_iterator data_blocks_begin() const {
    return const_data_block_iterator(
        const_data_block_iterator::base_type(Blocks.begin(), Blocks.end()));
  }
  data_block_iterator data_blocks_end() {
    return data_block_iterator(
        data_block_iterator::base_type(Blocks.end(), Blocks.end()));
  }
  const_data_block_iterator data_blocks_end() const {
    return const_data_block_iterator(
        const_data_block_iterator::base_type(Blocks.end(), Blocks.end()));
  }
  data_block_range data_blocks() {
    return boost::make_iterator_range(data_blocks_begin(), data_blocks_end());
  }
  const_data_block_range data_blocks() const {
    return boost::make_iterator_range(data_blocks_begin(), data_blocks_end());
  }
 
  data_block_subrange findDataBlocksOnOffset(uint64_t Off) {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      auto End = boost::make_indirect_iterator(It->second.end());
      return data_block_subrange(
          data_block_subrange::iterator::base_type(
              boost::make_indirect_iterator(It->second.begin()), End),
          data_block_subrange::iterator::base_type(End, End));
    }
    return {};
  }
 
  const_data_block_subrange findDataBlocksOnOffset(uint64_t Off) const {
    if (auto It = BlockOffsets.find(Off); It != BlockOffsets.end()) {
      auto End = boost::make_indirect_iterator(It->second.end());
      return const_data_block_subrange(
          const_data_block_subrange::iterator::base_type(
              boost::make_indirect_iterator(It->second.begin()), End),
          const_data_block_subrange::iterator::base_type(End, End));
    }
    return {};
  }
 
  data_block_subrange findDataBlocksOn(Addr A) {
    if (Address) {
      return findDataBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  const_data_block_subrange findDataBlocksOn(Addr A) const {
    if (Address) {
      return findDataBlocksOnOffset(A - *Address);
    }
    return {};
  }
 
  data_block_range findDataBlocksAtOffset(uint64_t Off) {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(
        data_block_iterator(
            data_block_iterator::base_type(Pair.first, Pair.second)),
        data_block_iterator(
            data_block_iterator::base_type(Pair.second, Pair.second)));
  }
 
  data_block_range findDataBlocksAtOffset(uint64_t Low, uint64_t High) {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(
        data_block_iterator(data_block_iterator::base_type(LowIt, HighIt)),
        data_block_iterator(data_block_iterator::base_type(HighIt, HighIt)));
  }
 
  data_block_range findDataBlocksAt(Addr A) {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findDataBlocksAtOffset(0, 0);
    }
    return findDataBlocksAtOffset(A - *Address);
  }
 
  data_block_range findDataBlocksAt(Addr Low, Addr High) {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findDataBlocksAtOffset(0, 0);
    }
    return findDataBlocksAtOffset(Low - std::min(*Address, Low),
                                  High - std::min(*Address, High));
  }
 
  const_data_block_range findDataBlocksAtOffset(uint64_t Off) const {
    auto Pair = Blocks.get<by_offset>().equal_range(Off, OffsetCmp());
    return boost::make_iterator_range(
        const_data_block_iterator(
            const_data_block_iterator::base_type(Pair.first, Pair.second)),
        const_data_block_iterator(
            const_data_block_iterator::base_type(Pair.second, Pair.second)));
  }
 
  const_data_block_range findDataBlocksAtOffset(uint64_t Low,
                                                uint64_t High) const {
    auto& Index = Blocks.get<by_offset>();
    auto LowIt = Index.lower_bound(Low, OffsetCmp());
    auto HighIt = Index.lower_bound(std::max(Low, High), OffsetCmp());
    return boost::make_iterator_range(
        const_data_block_iterator(
            const_data_block_iterator::base_type(LowIt, HighIt)),
        const_data_block_iterator(
            const_data_block_iterator::base_type(HighIt, HighIt)));
  }
 
  const_data_block_range findDataBlocksAt(Addr A) const {
    if (!Address || A < *Address) {
      // Return an empty range without default-constructing the iterators.
      return findDataBlocksAtOffset(0, 0);
    }
    return findDataBlocksAtOffset(A - *Address);
  }
 
  const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    if (!Address) {
      // Return an empty range without default-constructing the iterators.
      return findDataBlocksAtOffset(0, 0);
    }
    return findDataBlocksAtOffset(Low - std::min(*Address, Low),
                                  High - std::min(*Address, High));
  }
 
private:
  template <typename ByteIntervalType> class SymbolicExpressionElementBase {
  public:
    SymbolicExpressionElementBase(ByteIntervalType* BI_, uint64_t Off_,
                                  const SymbolicExpression& SE_)
        : BI{BI_}, Off{Off_}, SE{SE_} {}
 
    ByteIntervalType* getByteInterval() { return BI; }
 
    const ByteIntervalType* getByteInterval() const { return BI; }
 
    uint64_t getOffset() const { return Off; }
 
    const SymbolicExpression& getSymbolicExpression() const { return SE; }
 
    operator SymbolicExpressionElementBase<const ByteIntervalType>() const {
      return SymbolicExpressionElementBase<const ByteIntervalType>(BI, Off, SE);
    }
 
    struct AddressLess {
      using key_type = std::optional<Addr>;
      static key_type
      key(const SymbolicExpressionElementBase<ByteIntervalType>& SEE) {
        if (auto A = SEE.getByteInterval()->getAddress(); A) {
          return *A + SEE.getOffset();
        }
        return std::nullopt;
      };
      bool operator()(
          const SymbolicExpressionElementBase<ByteIntervalType>& SEE1,
          const SymbolicExpressionElementBase<ByteIntervalType>& SEE2) const {
        return key(SEE1) < key(SEE2);
      }
    };
 
  private:
    ByteIntervalType* BI;
    uint64_t Off;
    SymbolicExpression SE;
  };
 
  template <typename SymExprElementType> class SymExprPairToElement {
    using ByteIntervalType =
        decltype(std::declval<SymExprElementType>().getByteInterval());
    ByteIntervalType BI;
 
  public:
    explicit SymExprPairToElement(ByteIntervalType BI_) : BI{BI_} {}
 
    SymExprElementType
    operator()(const SymbolicExpressionMap::value_type& Pair) const {
      return SymExprElementType(BI, Pair.first, Pair.second);
    }
  };
 
public:
  using SymbolicExpressionElement = SymbolicExpressionElementBase<ByteInterval>;
 
  using ConstSymbolicExpressionElement =
      SymbolicExpressionElementBase<const ByteInterval>;
 
  using symbolic_expression_iterator =
      boost::transform_iterator<SymExprPairToElement<SymbolicExpressionElement>,
                                SymbolicExpressionMap::iterator>;
  using symbolic_expression_range =
      boost::iterator_range<symbolic_expression_iterator>;
  using const_symbolic_expression_iterator = boost::transform_iterator<
      SymExprPairToElement<ConstSymbolicExpressionElement>,
      SymbolicExpressionMap::const_iterator>;
  using const_symbolic_expression_range =
      boost::iterator_range<const_symbolic_expression_iterator>;
 
  symbolic_expression_iterator symbolic_expressions_begin() {
    return boost::make_transform_iterator(
        SymbolicExpressions.begin(),
        SymExprPairToElement<SymbolicExpressionElement>(this));
  }
  const_symbolic_expression_iterator symbolic_expressions_begin() const {
    return boost::make_transform_iterator(
        SymbolicExpressions.begin(),
        SymExprPairToElement<ConstSymbolicExpressionElement>(this));
  }
  symbolic_expression_iterator symbolic_expressions_end() {
    return boost::make_transform_iterator(
        SymbolicExpressions.end(),
        SymExprPairToElement<SymbolicExpressionElement>(this));
  }
  const_symbolic_expression_iterator symbolic_expressions_end() const {
    return boost::make_transform_iterator(
        SymbolicExpressions.end(),
        SymExprPairToElement<ConstSymbolicExpressionElement>(this));
  }
  symbolic_expression_range symbolic_expressions() {
    return boost::make_iterator_range(symbolic_expressions_begin(),
                                      symbolic_expressions_end());
  }
  const_symbolic_expression_range symbolic_expressions() const {
    return boost::make_iterator_range(symbolic_expressions_begin(),
                                      symbolic_expressions_end());
  }
 
  symbolic_expression_range findSymbolicExpressionsAtOffset(uint64_t Off) {
    auto Pair = SymbolicExpressions.equal_range(Off);
    return boost::make_iterator_range(
        boost::make_transform_iterator(
            Pair.first, SymExprPairToElement<SymbolicExpressionElement>(this)),
        boost::make_transform_iterator(
            Pair.second,
            SymExprPairToElement<SymbolicExpressionElement>(this)));
  }
 
  symbolic_expression_range findSymbolicExpressionsAtOffset(uint64_t Low,
                                                            uint64_t High) {
    return boost::make_iterator_range(
        boost::make_transform_iterator(
            SymbolicExpressions.lower_bound(Low),
            SymExprPairToElement<SymbolicExpressionElement>(this)),
        boost::make_transform_iterator(
            SymbolicExpressions.lower_bound(High),
            SymExprPairToElement<SymbolicExpressionElement>(this)));
  }
 
  symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
    if (!Address) {
      return boost::make_iterator_range(symbolic_expressions_end(),
                                        symbolic_expressions_end());
    }
    return findSymbolicExpressionsAtOffset(A - *Address);
  }
 
  symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr High) {
    if (!Address) {
      return boost::make_iterator_range(symbolic_expressions_end(),
                                        symbolic_expressions_end());
    }
    return findSymbolicExpressionsAtOffset(Low - *Address, High - *Address);
  }
 
  const_symbolic_expression_range
  findSymbolicExpressionsAtOffset(uint64_t Off) const {
    auto Pair = SymbolicExpressions.equal_range(Off);
    return boost::make_iterator_range(
        boost::make_transform_iterator(
            Pair.first,
            SymExprPairToElement<ConstSymbolicExpressionElement>(this)),
        boost::make_transform_iterator(
            Pair.second,
            SymExprPairToElement<ConstSymbolicExpressionElement>(this)));
  }
 
  const_symbolic_expression_range
  findSymbolicExpressionsAtOffset(uint64_t Low, uint64_t High) const {
    return boost::make_iterator_range(
        boost::make_transform_iterator(
            SymbolicExpressions.lower_bound(Low),
            SymExprPairToElement<ConstSymbolicExpressionElement>(this)),
        boost::make_transform_iterator(
            SymbolicExpressions.lower_bound(High),
            SymExprPairToElement<ConstSymbolicExpressionElement>(this)));
  }
 
  const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
    if (!Address) {
      return boost::make_iterator_range(symbolic_expressions_end(),
                                        symbolic_expressions_end());
    }
    return findSymbolicExpressionsAtOffset(A - *Address);
  }
 
  const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
                                                            Addr High) const {
    if (!Address) {
      return boost::make_iterator_range(symbolic_expressions_end(),
                                        symbolic_expressions_end());
    }
    return findSymbolicExpressionsAtOffset(Low - *Address, High - *Address);
  }
 
  ChangeStatus removeBlock(CodeBlock* B);
 
  ChangeStatus removeBlock(DataBlock* B);
 
  ChangeStatus addBlock(uint64_t Off, CodeBlock* N);
 
  ChangeStatus addBlock(uint64_t Off, DataBlock* N);
 
  template <typename BlockType, typename... Args>
  BlockType* addBlock(Context& C, uint64_t O, Args&&... A) {
    BlockType* B = BlockType::Create(C, std::forward<Args>(A)...);
    [[maybe_unused]] ChangeStatus Status = addBlock(O, B);
    // addBlock(uint64_t, BlockType*) 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 B;
  }
 
  SymbolicExpression& addSymbolicExpression(uint64_t Off,
                                            const SymbolicExpression& SymExpr) {
    SymbolicExpressions[Off] = SymExpr;
    return SymbolicExpressions[Off];
  }
 
  template <class ExprType, class... Args>
  SymbolicExpression& addSymbolicExpression(uint64_t Off, Args... A) {
    SymbolicExpressions[Off] = ExprType{A...};
    return SymbolicExpressions[Off];
  }
 
  bool removeSymbolicExpression(uint64_t Off) {
    std::size_t N;
    N = SymbolicExpressions.erase(Off);
    return N != 0;
  }
 
  SymbolicExpression* getSymbolicExpression(uint64_t Off) {
    if (auto It = SymbolicExpressions.find(Off);
        It != SymbolicExpressions.end()) {
      return &It->second;
    }
    return nullptr;
  }
 
  const SymbolicExpression* getSymbolicExpression(uint64_t Off) const {
    if (auto It = SymbolicExpressions.find(Off);
        It != SymbolicExpressions.end()) {
      return &It->second;
    }
    return nullptr;
  }
 
  void setAddress(std::optional<Addr> A);
 
  uint64_t getSize() const { return Size; }
 
  void setSize(uint64_t S);
 
  uint64_t getInitializedSize() const { return Bytes.size(); }
 
  void setInitializedSize(uint64_t S) {
    Bytes.resize(S);
    if (S > getSize()) {
      setSize(S);
    }
  }
 
private:
  // Wrapper to boost::endian::conditional_reverse which skips the call for
  // 1-byte types (char, [un]signed char, [u]int8_t).
  // This layer was added to work around a bug in boost 1.67 (fixed as of 1.74)
  // which gave wrong results for T=char.
  // It also allows BytesReference to work for std::byte.
  template <typename T>
  static inline std::enable_if_t<sizeof(T) != 1, T>
  endian_flip(T From, boost::endian::order In, boost::endian::order Out) {
    return boost::endian::conditional_reverse(From, In, Out);
  }
  template <typename T>
  static inline std::enable_if_t<sizeof(T) == 1, T>
  endian_flip(T From, boost::endian::order, boost::endian::order) {
    return From;
  }
 
  template <typename ByteIntervalType, typename T> class BytesReference {
  public:
    BytesReference(ByteIntervalType* BI_, size_t I_,
                   boost::endian::order InputOrder_,
                   boost::endian::order OutputOrder_)
        : BI(BI_), I(I_), InputOrder(InputOrder_), OutputOrder(OutputOrder_) {}
 
    operator T() const {
      assert(I + sizeof(T) <= BI->Size &&
             "read into interval's bytes out of bounds!");
 
      auto S = BI->Bytes.size();
 
      if (I >= S) {
        // anything this far past the end of initialized bytes is composed of
        // all zero bytes, so we return what T would have been interpreted as
        // if all bytes are zero.
        //
        // (note that you may be tempted to replace this with "return T{};",
        // but beware: T might be a non-scalar type whose default constructor
        // differs from the value returned when all bytes are re-interpeted as
        // zeroes. A similar argument exists for "return T{0};".)
        const std::array<uint8_t, sizeof(T)> Array{};
        return *reinterpret_cast<const T*>(Array.data());
      }
 
      if (I + sizeof(T) > S) {
        // Here, I < S < I + sizeof(T), so we need to partially fill the
        // initialized bytes and combine it with zeroes for the uninitialized
        // bytes.
        std::array<uint8_t, sizeof(T)> Array{};
        // Thanks to math, 0 < S - I < sizeof(T).
        std::copy_n(BI->Bytes.begin() + I, S - I, Array.begin());
        return endian_flip(*reinterpret_cast<const T*>(Array.data()),
                           InputOrder, OutputOrder);
      }
 
      return endian_flip(*reinterpret_cast<const T*>(BI->Bytes.data() + I),
                         InputOrder, OutputOrder);
    }
 
    BytesReference<ByteIntervalType, T>& operator=(const T& rhs) {
      assert(I + sizeof(T) <= BI->Size &&
             "write into interval's bytes out of bounds!");
 
      if (I + sizeof(T) > BI->Bytes.size()) {
        BI->Bytes.resize(I + sizeof(T));
      }
 
      *reinterpret_cast<T*>(BI->Bytes.data() + I) =
          endian_flip(rhs, OutputOrder, InputOrder);
      return *this;
    }
 
    ByteIntervalType* BI;
    size_t I;
    boost::endian::order InputOrder;
    boost::endian::order OutputOrder;
  };
 
  template <typename ByteIntervalType, typename T>
  class BytesBaseIterator
      : public boost::iterator_facade<BytesBaseIterator<ByteIntervalType, T>, T,
                                      boost::random_access_traversal_tag,
                                      BytesReference<ByteIntervalType, T>> {
  private:
    using self = BytesBaseIterator<ByteIntervalType, T>;
 
    BytesBaseIterator(ByteIntervalType* BI_, size_t I_,
                      boost::endian::order InputOrder_,
                      boost::endian::order OutputOrder_)
        : BI(BI_), I(I_), InputOrder(InputOrder_), OutputOrder(OutputOrder_) {}
 
  public:
    using reference = BytesReference<ByteIntervalType, T>;
 
    BytesBaseIterator() = default;
 
    // Beginning of functions for iterator facade compatibility.
    reference dereference() const {
      assert(BI && "attempt to dereference default-constructed byte iterator!");
      return reference(BI, I, InputOrder, OutputOrder);
    }
 
    bool equal(const self& other) const {
      return BI == other.BI && I == other.I;
    }
 
    void increment() {
      assert(BI && "attempt to increment default-constructed byte iterator!");
      I += sizeof(T);
    }
 
    void decrement() {
      assert(BI && "attempt to decrement default-constructed byte iterator!");
      I -= sizeof(T);
    }
 
    void advance(typename self::difference_type n) {
      assert(BI && "attempt to advance default-constructed byte iterator!");
      I += n * sizeof(T);
    }
 
    typename self::difference_type distance_to(const self& other) const {
      return (other.I - I) / sizeof(T);
    }
    // End of functions for iterator facade compatibility.
 
    operator BytesBaseIterator<const ByteIntervalType, T>() const {
      return BytesBaseIterator<const ByteIntervalType, T>(BI, I, InputOrder,
                                                          OutputOrder);
    }
 
  private:
    ByteIntervalType* BI{nullptr};
    size_t I{0};
    boost::endian::order InputOrder{boost::endian::order::native};
    boost::endian::order OutputOrder{boost::endian::order::native};
 
    friend class ByteInterval;
  };
 
public:
  template <typename T>
  using bytes_iterator = BytesBaseIterator<ByteInterval, T>;
  template <typename T>
  using bytes_range = boost::iterator_range<bytes_iterator<T>>;
  template <typename T>
  using const_bytes_iterator = BytesBaseIterator<const ByteInterval, T>;
  template <typename T>
  using const_bytes_range = boost::iterator_range<const_bytes_iterator<T>>;
 
  template <typename T> bytes_iterator<T> bytes_begin() {
    return bytes_begin<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_begin(boost::endian::order InputOrder,
              boost::endian::order OutputOrder = boost::endian::order::native) {
    return bytes_iterator<T>(this, 0, InputOrder, OutputOrder);
  }
 
  template <typename T> bytes_iterator<T> bytes_end() {
    return bytes_end<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_end(boost::endian::order InputOrder,
            boost::endian::order OutputOrder = boost::endian::order::native) {
    return bytes_iterator<T>(this, Size, InputOrder, OutputOrder);
  }
 
  template <typename T> bytes_range<T> bytes() {
    return bytes<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) {
    return bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                          bytes_end<T>(InputOrder, OutputOrder));
  }
 
  template <typename T> const_bytes_iterator<T> bytes_begin() const {
    return bytes_begin<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_begin(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    return const_bytes_iterator<T>(this, 0, InputOrder, OutputOrder);
  }
 
  template <typename T> const_bytes_iterator<T> bytes_end() const {
    return bytes_end<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_end(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    return const_bytes_iterator<T>(this, Size, InputOrder, OutputOrder);
  }
 
  template <typename T> const_bytes_range<T> bytes() const {
    return bytes<T>(getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) const {
    return const_bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                                bytes_end<T>(InputOrder, OutputOrder));
  }
 
private:
  template <typename T, typename BytesIterator, typename InputIterator>
  BytesIterator insertByteVec(
      BytesIterator Pos, InputIterator Begin, InputIterator End,
      boost::endian::order VectorOrder,
      boost::endian::order ElementsOrder = boost::endian::order::native) {
    static_assert(
        std::is_same<BytesIterator, bytes_iterator<T>>::value ||
            std::is_same<BytesIterator, const_bytes_iterator<T>>::value,
        "Pos must be a byte_iterator<T> or a const_byte_iterator<T>");
 
    auto N = std::distance(Begin, End) * sizeof(T);
    setSize(Size + N);
    // If the position to insert is currently outside the initilized bytes,
    // we let the iterator's operator= handle resizing the byte vector,
    // otherwise we insert zeroes and then overwrite them via said operator=.
    if (Pos.I < Bytes.size()) {
      Bytes.insert(Bytes.begin() + Pos.I, N, 0);
    }
    // std::copy calls operator= one time for every element in the input iter.
    std::copy(Begin, End,
              bytes_iterator<T>(this, Pos.I, VectorOrder, ElementsOrder));
    return Pos;
  }
 
  template <typename T, typename BytesIterator>
  BytesIterator insertSingleByte(
      BytesIterator Pos, const T& X, boost::endian::order VectorOrder,
      boost::endian::order ElementOrder = boost::endian::order::native) {
    return insertByteVec<T>(Pos, &X, &X + 1, VectorOrder, ElementOrder);
  }
 
public:
  template <typename T>
  const_bytes_iterator<T> insertBytes(const const_bytes_iterator<T> Pos,
                                      const T& X) {
    return insertBytes<T>(Pos, X, getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T> insertBytes(bytes_iterator<T> Pos, const T& X) {
    return insertBytes<T>(Pos, X, getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> insertBytes(
      const const_bytes_iterator<T> Pos, const T& X,
      boost::endian::order VectorOrder,
      boost::endian::order ElementOrder = boost::endian::order::native) {
    return insertSingleByte<T>(Pos, X, VectorOrder, ElementOrder);
  }
 
  template <typename T>
  bytes_iterator<T> insertBytes(
      bytes_iterator<T> Pos, const T& X, boost::endian::order VectorOrder,
      boost::endian::order ElementOrder = boost::endian::order::native) {
    return insertSingleByte<T>(Pos, X, VectorOrder, ElementOrder);
  }
 
 
  template <typename T, typename InputIterator>
  const_bytes_iterator<T> insertBytes(const const_bytes_iterator<T> Pos,
                                      InputIterator Begin, InputIterator End) {
    return insertBytes<T>(Pos, Begin, End, getBoostEndianOrder());
  }
  template <typename T, typename InputIterator>
  bytes_iterator<T> insertBytes(bytes_iterator<T> Pos, InputIterator Begin,
                                InputIterator End) {
    return insertBytes<T>(Pos, Begin, End, getBoostEndianOrder());
  }
 
  template <typename T, typename InputIterator>
  const_bytes_iterator<T> insertBytes(
      const const_bytes_iterator<T> Pos, InputIterator Begin, InputIterator End,
      boost::endian::order VectorOrder,
      boost::endian::order ElementsOrder = boost::endian::order::native) {
    return insertByteVec<T>(Pos, Begin, End, VectorOrder, ElementsOrder);
  }
 
  template <typename T, typename InputIterator>
  bytes_iterator<T> insertBytes(
      bytes_iterator<T> Pos, InputIterator Begin, InputIterator End,
      boost::endian::order VectorOrder,
      boost::endian::order ElementsOrder = boost::endian::order::native) {
    return insertByteVec<T>(Pos, Begin, End, VectorOrder, ElementsOrder);
  }
 
 
  template <typename T>
  const_bytes_iterator<T> eraseBytes(const const_bytes_iterator<T> Begin,
                                     const const_bytes_iterator<T> End) {
    assert(Begin.I <= End.I && "eraseBytes: Begin > End!");
    assert(Begin.I <= Size && "eraseBytes: Begin out of range!");
    assert(End.I <= Size && "eraseBytes: End out of range!");
 
    // If the beginning iter is outside the init vector, nothing need be done.
    if (Begin.I < Bytes.size()) {
      if (End.I < Bytes.size()) {
        // All positions are within the initilized vector.
        Bytes.erase(Bytes.begin() + Begin.I, Bytes.begin() + End.I);
      } else {
        // The beginning is within vector, the end isn't; clamp to
        // Bytes.end().
        Bytes.erase(Bytes.begin() + Begin.I, Bytes.end());
      }
    }
 
    setSize(Size - (End.I - Begin.I));
    return Begin;
  }
 
  template <typename T> T* rawBytes() {
    return reinterpret_cast<T*>(Bytes.data());
  }
 
  template <typename T> const T* rawBytes() const {
    return reinterpret_cast<const T*>(Bytes.data());
  }
 
  static bool classof(const Node* N) {
    return N->getKind() == Kind::ByteInterval;
  }
 
  boost::endian::order getBoostEndianOrder() const;
 
private:
  ByteInterval(Context& C);
 
  ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t InitSize,
               const UUID& U);
 
  ByteInterval(Context& C, std::optional<Addr> A, uint64_t S,
               uint64_t InitSize);
 
  template <typename InputIterator>
  ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t InitSize,
               InputIterator Begin, InputIterator End)
      : ByteInterval(C, A, S, 0) {
    Bytes.insert(Bytes.end(), Begin, End);
    Bytes.resize(InitSize);
  }
 
  template <typename InputIterator>
  ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t InitSize,
               InputIterator Begin, InputIterator End, const UUID& U)
      : ByteInterval(C, A, S, 0, U) {
    Bytes.insert(Bytes.end(), Begin, End);
    Bytes.resize(InitSize);
  }
 
  void setParent(Section* S, ByteIntervalObserver* O) {
    Parent = S;
    Observer = O;
  }
 
  template <typename InputIterator>
  static ByteInterval* Create(Context& C, std::optional<Addr> Address,
                              InputIterator Begin, InputIterator End,
                              std::optional<uint64_t> Size,
                              std::optional<uint64_t> InitSize, const UUID& U) {
    return C.Create<ByteInterval>(
        C, Address, Size ? *Size : std::distance(Begin, End),
        InitSize ? *InitSize : std::distance(Begin, End), Begin, End, U);
  }
 
  using MessageType = proto::ByteInterval;
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<ByteInterval*> fromProtobuf(Context& C,
                                             const MessageType& Message);
 
  bool symbolicExpressionsFromProtobuf(Context& C, const MessageType& Message);
 
  // Present for testing purposes only.
  void save(std::ostream& Out) const;
 
  // Present for testing purposes only.
  static ByteInterval* load(Context& C, std::istream& In);
 
  // Present for testing purposes only.
  bool loadSymbolicExpressions(Context& C, std::istream& In);
 
  // Shared implementation for adding CodeBlocks and DataBlocks.
  template <typename BlockType, typename IterType>
  ChangeStatus addBlock(uint64_t Off, BlockType* B);
 
  // Shared implementation for removing CodeBlocks and DataBlocks.
  template <typename BlockType, typename IterType>
  ChangeStatus removeBlock(BlockType* B);
 
  Section* Parent{nullptr};
  ByteIntervalObserver* Observer{nullptr};
  std::optional<Addr> Address;
  uint64_t Size{0};
  BlockSet Blocks;
  BlockIntMap BlockOffsets;
  SymbolicExpressionMap SymbolicExpressions;
  std::vector<uint8_t> Bytes;
 
  std::unique_ptr<CodeBlockObserver> CBO;
  std::unique_ptr<DataBlockObserver> DBO;
 
  friend class Context;   // Friend to enable Context::Create.
  friend class Section;   // Friend to enable Section::(re)moveByteInterval,
                          // Create, etc.
  friend class CodeBlock; // Friend to enable CodeBlock::getAddress.
  friend class DataBlock; // Friend to enable DataBlock::getAddress.
  friend class Module;    // Allow Module::fromProtobuf to deserialize symbolic
                          // expressions.
  friend struct BlockOffsetLess;
  friend class SerializationTestHarness; // Testing support.
};
 
 
class GTIRB_EXPORT_API ByteIntervalObserver {
public:
  virtual ~ByteIntervalObserver() = default;
 
  virtual ChangeStatus addCodeBlocks(ByteInterval* BI,
                                     ByteInterval::code_block_range Blocks) = 0;
 
  virtual ChangeStatus
  moveCodeBlocks(ByteInterval* BI, ByteInterval::code_block_range Blocks) = 0;
 
  virtual ChangeStatus
  removeCodeBlocks(ByteInterval* BI, ByteInterval::code_block_range Blocks) = 0;
 
  virtual ChangeStatus addDataBlocks(ByteInterval* BI,
                                     ByteInterval::data_block_range Blocks) = 0;
 
  virtual ChangeStatus
  moveDataBlocks(ByteInterval* BI, ByteInterval::data_block_range Blocks) = 0;
 
  virtual ChangeStatus
  removeDataBlocks(ByteInterval* BI, ByteInterval::data_block_range Blocks) = 0;
 
  virtual ChangeStatus
  changeExtent(ByteInterval* BI,
               std::function<void(ByteInterval*)> Callback) = 0;
};
 
} // namespace gtirb
 
#endif // GTIRB_BYTE_INTERVAL_H