Module.hpp

Go to the documentation of this file.

//===- Module.hpp -----------------------------------------------*- C++ -*-===//
//
//  Copyright (C) 2021 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_MODULE_H
#define GTIRB_MODULE_H
 
#include <gtirb/Addr.hpp>
#include <gtirb/AuxDataContainer.hpp>
#include <gtirb/DataBlock.hpp>
#include <gtirb/Export.hpp>
#include <gtirb/Node.hpp>
#include <gtirb/Observer.hpp>
#include <gtirb/Section.hpp>
#include <gtirb/Symbol.hpp>
#include <gtirb/SymbolicExpression.hpp>
#include <gtirb/Utility.hpp>
#include <gtirb/proto/Module.pb.h>
#include <algorithm>
#include <boost/icl/interval_map.hpp>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/transform_iterator.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/multi_index_container.hpp>
#include <boost/range/iterator_range.hpp>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
 
 
namespace gtirb {
class ByteInterval;
class IR;
class ModuleObserver;
 
template <class T> class ErrorOr;
 
enum class FileFormat : uint8_t {
  Undefined = proto::Format_Undefined, 
  COFF = proto::COFF,                  
  ELF = proto::ELF, 
  PE = proto::PE,   
  IdaProDb32 = proto::IdaProDb32, 
  IdaProDb64 = proto::IdaProDb64, 
  XCOFF = proto::XCOFF, 
  MACHO = proto::MACHO, 
  RAW = proto::RAW      
};
 
enum class ISA : uint8_t {
  Undefined = proto::ISA_Undefined, 
  IA32 = proto::IA32,   
  PPC32 = proto::PPC32, 
  X64 = proto::X64,     
  ARM = proto::ARM,     
  ValidButUnsupported = proto::ValidButUnsupported,
  PPC64 = proto::PPC64,     
  ARM64 = proto::ARM64,     
  MIPS32 = proto::MIPS32,   
  MIPS64 = proto::MIPS64,   
  RISCV32 = proto::RISCV32, 
  RISCV64 = proto::RISCV64  
};
 
enum class ByteOrder : uint8_t {
  Undefined = proto::ByteOrder_Undefined, 
  Big = proto::BigEndian,                 
  Little = proto::LittleEndian,           
};
 
class GTIRB_EXPORT_API Module : public AuxDataContainer {
  struct by_address {};
  struct by_name {};
  struct by_pointer {};
  struct by_referent {};
 
  // Helper function for extracting the referent of a Symbol.
  static const Node* get_symbol_referent(const Symbol& S) {
    if (std::optional<const Node*> Res =
            S.visit([](const Node* N) { return N; })) {
      return *Res;
    }
    return nullptr;
  }
 
  using ProxyBlockSet = std::unordered_set<ProxyBlock*>;
 
  using SectionSet = boost::multi_index::multi_index_container<
      Section*, boost::multi_index::indexed_by<
                    boost::multi_index::ordered_non_unique<
                        boost::multi_index::tag<by_address>,
                        boost::multi_index::identity<Section*>, AddressLess>,
                    boost::multi_index::ordered_non_unique<
                        boost::multi_index::tag<by_name>,
                        boost::multi_index::const_mem_fun<
                            Section, const std::string&, &Section::getName>>,
                    boost::multi_index::hashed_unique<
                        boost::multi_index::tag<by_pointer>,
                        boost::multi_index::identity<Section*>>>>;
  using SectionIntMap =
      boost::icl::interval_map<Addr, std::set<Section*, AddressLess>>;
 
  using SymbolSet = boost::multi_index::multi_index_container<
      Symbol*,
      boost::multi_index::indexed_by<
          boost::multi_index::ordered_non_unique<
              boost::multi_index::tag<by_address>,
              boost::multi_index::const_mem_fun<Symbol, std::optional<Addr>,
                                                &Symbol::getAddress>>,
          boost::multi_index::ordered_non_unique<
              boost::multi_index::tag<by_name>,
              boost::multi_index::const_mem_fun<Symbol, const std::string&,
                                                &Symbol::getName>>,
          boost::multi_index::hashed_unique<
              boost::multi_index::tag<by_pointer>,
              boost::multi_index::identity<Symbol*>>,
          boost::multi_index::hashed_non_unique<
              boost::multi_index::tag<by_referent>,
              boost::multi_index::global_fun<const Symbol&, const Node*,
                                             &get_symbol_referent>>>>;
 
  class SectionObserverImpl;
  class SymbolObserverImpl;
 
  Module(Context& C, const std::string& N);
  Module(Context& C, const std::string& N, const UUID& U);
 
  static Module* Create(Context& C, const std::string& N, const UUID& U) {
    return C.Create<Module>(C, N, U);
  }
 
public:
  static Module* Create(Context& C, const std::string& Name) {
    return C.Create<Module>(C, Name);
  }
 
  const IR* getIR() const { return Parent; }
  IR* getIR() { return Parent; }
 
  void setBinaryPath(const std::string& X) { BinaryPath = X; }
 
  const std::string& getBinaryPath() const { return BinaryPath; }
 
  void setFileFormat(gtirb::FileFormat X) { this->FileFormat = X; }
 
  gtirb::FileFormat getFileFormat() const { return this->FileFormat; }
 
  void setRebaseDelta(int64_t X) { RebaseDelta = X; }
 
  int64_t getRebaseDelta() const { return RebaseDelta; }
 
  void setPreferredAddr(gtirb::Addr X) { PreferredAddr = X; }
 
  gtirb::Addr getPreferredAddr() const { return PreferredAddr; }
 
  bool isRelocated() const { return RebaseDelta != 0; }
 
  void setISA(gtirb::ISA X) { Isa = X; }
 
  gtirb::ISA getISA() const { return Isa; }
 
  void setByteOrder(gtirb::ByteOrder X) { ByteOrder = X; }
 
  gtirb::ByteOrder getByteOrder() const { return ByteOrder; }
 
  const CodeBlock* getEntryPoint() const { return EntryPoint; }
  CodeBlock* getEntryPoint() { return EntryPoint; }
 
  void setEntryPoint(CodeBlock* CB) { EntryPoint = CB; }
 
 
  using proxy_block_iterator =
      boost::indirect_iterator<ProxyBlockSet::iterator>;
  using proxy_block_range = boost::iterator_range<proxy_block_iterator>;
  using const_proxy_block_iterator =
      boost::indirect_iterator<ProxyBlockSet::const_iterator, const ProxyBlock>;
  using const_proxy_block_range =
      boost::iterator_range<const_proxy_block_iterator>;
 
  proxy_block_iterator proxy_blocks_begin() {
    return proxy_block_iterator(ProxyBlocks.begin());
  }
  const_proxy_block_iterator proxy_blocks_begin() const {
    return const_proxy_block_iterator(ProxyBlocks.begin());
  }
  proxy_block_iterator proxy_blocks_end() {
    return proxy_block_iterator(ProxyBlocks.end());
  }
  const_proxy_block_iterator proxy_blocks_end() const {
    return const_proxy_block_iterator(ProxyBlocks.end());
  }
  proxy_block_range proxy_blocks() {
    return boost::make_iterator_range(proxy_blocks_begin(), proxy_blocks_end());
  }
  const_proxy_block_range proxy_blocks() const {
    return boost::make_iterator_range(proxy_blocks_begin(), proxy_blocks_end());
  }
 
  ChangeStatus removeProxyBlock(ProxyBlock* B);
 
  ChangeStatus addProxyBlock(ProxyBlock* PB);
 
  template <typename... Args>
  ProxyBlock* addProxyBlock(Context& C, Args&&... A) {
    ProxyBlock* PB = ProxyBlock::Create(C, std::forward<Args>(A)...);
    [[maybe_unused]] ChangeStatus status = addProxyBlock(PB);
    // addProxyBlock(ProxyBlock*) does not currently reject any changes and,
    // because we just created the ProxyBlock to add, it cannot result in
    // NoChange.
    assert(status == ChangeStatus::Accepted &&
           "unexpected result when inserting ProxyBlock");
    return PB;
  }
 
  // (end of ProxyBlock-Related Public Types and Functions)
 
 
  using symbol_iterator =
      boost::indirect_iterator<SymbolSet::index<by_pointer>::type::iterator>;
  using symbol_range = boost::iterator_range<symbol_iterator>;
  using const_symbol_iterator = boost::indirect_iterator<
      SymbolSet::index<by_pointer>::type::const_iterator, const Symbol>;
  using const_symbol_range = boost::iterator_range<const_symbol_iterator>;
 
  using symbol_name_iterator =
      boost::indirect_iterator<SymbolSet::index<by_name>::type::iterator>;
  using symbol_name_range = boost::iterator_range<symbol_name_iterator>;
  using const_symbol_name_iterator =
      boost::indirect_iterator<SymbolSet::index<by_name>::type::const_iterator,
                               const Symbol>;
  using const_symbol_name_range =
      boost::iterator_range<const_symbol_name_iterator>;
 
  using symbol_addr_iterator =
      boost::indirect_iterator<SymbolSet::index<by_address>::type::iterator>;
  using symbol_addr_range = boost::iterator_range<symbol_addr_iterator>;
  using const_symbol_addr_iterator = boost::indirect_iterator<
      SymbolSet::index<by_address>::type::const_iterator, const Symbol>;
  using const_symbol_addr_range =
      boost::iterator_range<const_symbol_addr_iterator>;
 
  using symbol_ref_iterator =
      boost::indirect_iterator<SymbolSet::index<by_referent>::type::iterator>;
  using symbol_ref_range = boost::iterator_range<symbol_ref_iterator>;
  using const_symbol_ref_iterator = boost::indirect_iterator<
      SymbolSet::index<by_referent>::type::const_iterator, const Symbol>;
  using const_symbol_ref_range =
      boost::iterator_range<const_symbol_ref_iterator>;
 
  symbol_iterator symbols_begin() {
    return symbol_iterator(Symbols.get<by_pointer>().begin());
  }
  const_symbol_iterator symbols_begin() const {
    return const_symbol_iterator(Symbols.get<by_pointer>().begin());
  }
  symbol_iterator symbols_end() {
    return symbol_iterator(Symbols.get<by_pointer>().end());
  }
  const_symbol_iterator symbols_end() const {
    return const_symbol_iterator(Symbols.get<by_pointer>().end());
  }
  symbol_range symbols() {
    return boost::make_iterator_range(symbols_begin(), symbols_end());
  }
  const_symbol_range symbols() const {
    return boost::make_iterator_range(symbols_begin(), symbols_end());
  }
 
  symbol_name_iterator symbols_by_name_begin() {
    return symbol_name_iterator(Symbols.get<by_name>().begin());
  }
  const_symbol_name_iterator symbols_by_name_begin() const {
    return const_symbol_name_iterator(Symbols.get<by_name>().begin());
  }
  symbol_name_iterator symbols_by_name_end() {
    return symbol_name_iterator(Symbols.get<by_name>().end());
  }
  const_symbol_name_iterator symbols_by_name_end() const {
    return const_symbol_name_iterator(Symbols.get<by_name>().end());
  }
  symbol_name_range symbols_by_name() {
    return boost::make_iterator_range(symbols_by_name_begin(),
                                      symbols_by_name_end());
  }
  const_symbol_name_range symbols_by_name() const {
    return boost::make_iterator_range(symbols_by_name_begin(),
                                      symbols_by_name_end());
  }
 
  symbol_addr_iterator symbols_by_addr_begin() {
    return symbol_addr_iterator(Symbols.get<by_address>().begin());
  }
  const_symbol_addr_iterator symbols_by_addr_begin() const {
    return const_symbol_addr_iterator(Symbols.get<by_address>().begin());
  }
  symbol_addr_iterator symbols_by_addr_end() {
    return symbol_addr_iterator(Symbols.get<by_address>().end());
  }
  const_symbol_addr_iterator symbols_by_addr_end() const {
    return const_symbol_addr_iterator(Symbols.get<by_address>().end());
  }
  symbol_addr_range symbols_by_addr() {
    return boost::make_iterator_range(symbols_by_addr_begin(),
                                      symbols_by_addr_end());
  }
  const_symbol_addr_range symbols_by_addr() const {
    return boost::make_iterator_range(symbols_by_addr_begin(),
                                      symbols_by_addr_end());
  }
 
  bool removeSymbol(Symbol* S) {
    auto& Index = Symbols.get<by_pointer>();
    if (auto Iter = Index.find(S); Iter != Index.end()) {
      Index.erase(Iter);
      S->setParent(nullptr, nullptr);
      return true;
    }
    return false;
  }
 
  Symbol* addSymbol(Symbol* S) {
    if (S->getModule()) {
      S->getModule()->removeSymbol(S);
    }
    Symbols.emplace(S);
    S->setParent(this, SymObs.get());
    return S;
  }
 
  template <typename... Args> Symbol* addSymbol(Context& C, Args... A) {
    return addSymbol(Symbol::Create(C, A...));
  }
 
  symbol_name_range findSymbols(const std::string& N) {
    auto Found = Symbols.get<by_name>().equal_range(N);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  const_symbol_name_range findSymbols(const std::string& N) const {
    auto Found = Symbols.get<by_name>().equal_range(N);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  symbol_addr_range findSymbols(Addr X) {
    auto Found = Symbols.get<by_address>().equal_range(X);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  const_symbol_addr_range findSymbols(Addr X) const {
    auto Found = Symbols.get<by_address>().equal_range(X);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  symbol_addr_range findSymbols(Addr Lower, Addr Upper) {
    auto& Index = Symbols.get<by_address>();
    return boost::make_iterator_range(Index.lower_bound(Lower),
                                      Index.lower_bound(Upper));
  }
 
  const_symbol_addr_range findSymbols(Addr Lower, Addr Upper) const {
    auto& Index = Symbols.get<by_address>();
    return boost::make_iterator_range(Index.lower_bound(Lower),
                                      Index.lower_bound(Upper));
  }
 
  symbol_ref_range findSymbols(const Node& Referent) {
    return Symbols.get<by_referent>().equal_range(&Referent);
  }
 
  const_symbol_ref_range findSymbols(const Node& Referent) const {
    return Symbols.get<by_referent>().equal_range(&Referent);
  }
 
  // (end group of symbol-related type aliases and functions)
 
  const std::string& getName() const { return Name; }
 
  void setName(const std::string& X);
 
 
  using section_iterator = boost::indirect_iterator<SectionSet::iterator>;
  using section_range = boost::iterator_range<section_iterator>;
  using section_subrange = boost::iterator_range<
      boost::indirect_iterator<SectionIntMap::codomain_type::iterator>>;
  using section_name_iterator =
      boost::indirect_iterator<SectionSet::index<by_name>::type::iterator>;
  using section_name_range = boost::iterator_range<section_name_iterator>;
  using const_section_iterator =
      boost::indirect_iterator<SectionSet::const_iterator, const Section&>;
  using const_section_range = boost::iterator_range<const_section_iterator>;
  using const_section_subrange = boost::iterator_range<boost::indirect_iterator<
      SectionIntMap::codomain_type::const_iterator, const Section&>>;
  using const_section_name_iterator =
      boost::indirect_iterator<SectionSet::index<by_name>::type::const_iterator,
                               const Section&>;
  using const_section_name_range =
      boost::iterator_range<const_section_name_iterator>;
 
  section_iterator sections_begin() { return Sections.begin(); }
  const_section_iterator sections_begin() const { return Sections.begin(); }
  section_name_iterator sections_by_name_begin() {
    return Sections.get<by_name>().begin();
  }
  const_section_name_iterator sections_by_name_begin() const {
    return Sections.get<by_name>().begin();
  }
  section_iterator sections_end() { return Sections.end(); }
  const_section_iterator sections_end() const { return Sections.end(); }
  section_name_iterator sections_by_name_end() {
    return Sections.get<by_name>().end();
  }
  const_section_name_iterator sections_by_name_end() const {
    return Sections.get<by_name>().end();
  }
  section_range sections() {
    return boost::make_iterator_range(sections_begin(), sections_end());
  }
  const_section_range sections() const {
    return boost::make_iterator_range(sections_begin(), sections_end());
  }
 
  ChangeStatus removeSection(Section* S);
 
  // Section (\c NoChange), or could not be completed (\c Rejected).
  ChangeStatus addSection(Section* S);
 
  template <typename... Args> Section* addSection(Context& C, Args&&... A) {
    Section* S = Section::Create(C, std::forward<Args>(A)...);
    [[maybe_unused]] ChangeStatus status = addSection(S);
    // addSection(Section*) does not currently reject any changes and, because
    // we just created the Section to add, it cannot result in NoChange.
    assert(status == ChangeStatus::Accepted &&
           "unexpected result when inserting Section");
    return S;
  }
 
  section_subrange findSectionsOn(Addr X) {
    if (auto It = SectionAddrs.find(X); It != SectionAddrs.end()) {
      return boost::make_iterator_range(It->second.begin(), It->second.end());
    }
    return {};
  }
 
  const_section_subrange findSectionsOn(Addr X) const {
    if (auto It = SectionAddrs.find(X); It != SectionAddrs.end()) {
      return boost::make_iterator_range(It->second.begin(), It->second.end());
    }
    return {};
  }
 
  section_range findSectionsAt(Addr A) {
    auto Pair = Sections.get<by_address>().equal_range(A);
    return boost::make_iterator_range(section_iterator(Pair.first),
                                      section_iterator(Pair.second));
  }
 
  section_range findSectionsAt(Addr Low, Addr High) {
    auto& Index = Sections.get<by_address>();
    return boost::make_iterator_range(
        section_iterator(Index.lower_bound(Low)),
        section_iterator(Index.lower_bound(High)));
  }
 
  const_section_range findSectionsAt(Addr A) const {
    auto Pair = Sections.get<by_address>().equal_range(A);
    return boost::make_iterator_range(const_section_iterator(Pair.first),
                                      const_section_iterator(Pair.second));
  }
 
  const_section_range findSectionsAt(Addr Low, Addr High) const {
    auto& Index = Sections.get<by_address>();
    return boost::make_iterator_range(
        const_section_iterator(Index.lower_bound(Low)),
        const_section_iterator(Index.lower_bound(High)));
  }
 
 
  section_name_range findSections(const std::string& X) {
    auto Pair = Sections.get<by_name>().equal_range(X);
    return boost::make_iterator_range(section_name_iterator(Pair.first),
                                      section_name_iterator(Pair.second));
  }
 
  const_section_name_range findSections(const std::string& X) const {
    auto Pair = Sections.get<by_name>().equal_range(X);
    return boost::make_iterator_range(const_section_name_iterator(Pair.first),
                                      const_section_name_iterator(Pair.second));
  }
 
  // (end group of Section-related types and functions)
 
 
  using byte_interval_iterator =
      MergeSortedIterator<Section::byte_interval_iterator, AddressLess>;
  using byte_interval_range = boost::iterator_range<byte_interval_iterator>;
  using byte_interval_subrange = boost::iterator_range<MergeSortedIterator<
      Section::byte_interval_subrange::iterator, AddressLess>>;
  using const_byte_interval_iterator =
      MergeSortedIterator<Section::const_byte_interval_iterator, AddressLess>;
  using const_byte_interval_range =
      boost::iterator_range<const_byte_interval_iterator>;
  using const_byte_interval_subrange =
      boost::iterator_range<MergeSortedIterator<
          Section::const_byte_interval_subrange::iterator, AddressLess>>;
 
  byte_interval_iterator byte_intervals_begin() {
    return byte_interval_iterator(
        boost::make_transform_iterator(this->sections_begin(),
                                       NodeToByteIntervalRange<Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToByteIntervalRange<Section>()));
  }
 
  byte_interval_iterator byte_intervals_end() {
    return byte_interval_iterator();
  }
 
  byte_interval_range byte_intervals() {
    return boost::make_iterator_range(byte_intervals_begin(),
                                      byte_intervals_end());
  }
 
  const_byte_interval_iterator byte_intervals_begin() const {
    return const_byte_interval_iterator(
        boost::make_transform_iterator(
            this->sections_begin(), NodeToByteIntervalRange<const Section>()),
        boost::make_transform_iterator(
            this->sections_end(), NodeToByteIntervalRange<const Section>()));
  }
 
  const_byte_interval_iterator byte_intervals_end() const {
    return const_byte_interval_iterator();
  }
 
  const_byte_interval_range byte_intervals() const {
    return boost::make_iterator_range(byte_intervals_begin(),
                                      byte_intervals_end());
  }
 
  byte_interval_subrange findByteIntervalsOn(Addr A) {
    section_subrange Range = findSectionsOn(A);
    return byte_interval_subrange(
        byte_interval_subrange::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindByteIntervalsIn<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindByteIntervalsIn<Section>(A))),
        byte_interval_subrange::iterator());
  }
 
  const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_byte_interval_subrange(
        const_byte_interval_subrange::iterator(
            boost::make_transform_iterator(
                Range.begin(), FindByteIntervalsIn<const Section>(A)),
            boost::make_transform_iterator(
                Range.end(), FindByteIntervalsIn<const Section>(A))),
        const_byte_interval_subrange::iterator());
  }
 
  byte_interval_range findByteIntervalsAt(Addr A) {
    section_subrange Range = findSectionsOn(A);
    return byte_interval_range(
        byte_interval_range::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindByteIntervalsAt<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindByteIntervalsAt<Section>(A))),
        byte_interval_range::iterator());
  }
 
  byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    std::vector<Section::byte_interval_range> Ranges;
    for (Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findByteIntervalsAt(Low, High));
    for (Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findByteIntervalsAt(Low, High));
    return byte_interval_range(byte_interval_iterator(Ranges),
                               byte_interval_iterator());
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_byte_interval_range(
        const_byte_interval_range::iterator(
            boost::make_transform_iterator(
                Range.begin(), FindByteIntervalsAt<const Section>(A)),
            boost::make_transform_iterator(
                Range.end(), FindByteIntervalsAt<const Section>(A))),
        const_byte_interval_range::iterator());
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) const {
    std::vector<Section::const_byte_interval_range> Ranges;
    for (const Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findByteIntervalsAt(Low, High));
    for (const Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findByteIntervalsAt(Low, High));
    return const_byte_interval_range(const_byte_interval_iterator(Ranges),
                                     const_byte_interval_iterator());
  }
  // (end group of ByteInterval-related types and functions)
 
 
  using block_iterator =
      MergeSortedIterator<Section::block_iterator, BlockAddressLess>;
  using block_range = boost::iterator_range<block_iterator>;
  using block_subrange = boost::iterator_range<
      MergeSortedIterator<Section::block_subrange::iterator, BlockAddressLess>>;
  using const_block_iterator =
      MergeSortedIterator<Section::const_block_iterator, BlockAddressLess>;
  using const_block_range = boost::iterator_range<const_block_iterator>;
  using const_block_subrange = boost::iterator_range<MergeSortedIterator<
      Section::const_block_subrange::iterator, BlockAddressLess>>;
 
  block_iterator blocks_begin() {
    return block_iterator(
        boost::make_transform_iterator(this->sections_begin(),
                                       NodeToBlockRange<Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToBlockRange<Section>()));
  }
 
  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->sections_begin(),
                                       NodeToBlockRange<const Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToBlockRange<const Section>()));
  }
 
  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) {
    section_subrange SectionRange = findSectionsOn(A);
    return block_subrange(
        block_subrange::iterator(
            boost::make_transform_iterator(SectionRange.begin(),
                                           FindBlocksIn<Section>(A)),
            boost::make_transform_iterator(SectionRange.end(),
                                           FindBlocksIn<Section>(A))),
        block_subrange::iterator());
  }
 
  const_block_subrange findBlocksOn(Addr A) const {
    const_section_subrange SectionRange = findSectionsOn(A);
    return const_block_subrange(
        const_block_subrange::iterator(
            boost::make_transform_iterator(SectionRange.begin(),
                                           FindBlocksIn<const Section>(A)),
            boost::make_transform_iterator(SectionRange.end(),
                                           FindBlocksIn<const Section>(A))),
        const_block_subrange::iterator());
  }
 
  block_range findBlocksAt(Addr A) {
    section_subrange SectionRange = findSectionsOn(A);
    return block_range(block_range::iterator(
                           boost::make_transform_iterator(
                               SectionRange.begin(), FindBlocksAt<Section>(A)),
                           boost::make_transform_iterator(
                               SectionRange.end(), FindBlocksAt<Section>(A))),
                       block_range::iterator());
  }
 
  block_range findBlocksAt(Addr Low, Addr High) {
    std::vector<Section::block_range> Ranges;
    for (Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findBlocksAt(Low, High));
    for (Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findBlocksAt(Low, High));
    return block_range(block_iterator(Ranges), block_iterator());
  }
 
  const_block_range findBlocksAt(Addr A) const {
    const_section_subrange SectionRange = findSectionsOn(A);
    return const_block_range(
        const_block_range::iterator(
            boost::make_transform_iterator(SectionRange.begin(),
                                           FindBlocksAt<const Section>(A)),
            boost::make_transform_iterator(SectionRange.end(),
                                           FindBlocksAt<const Section>(A))),
        const_block_range::iterator());
  }
 
  const_block_range findBlocksAt(Addr Low, Addr High) const {
    std::vector<Section::const_block_range> Ranges;
    for (const Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findBlocksAt(Low, High));
    for (const Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findBlocksAt(Low, High));
    return const_block_range(const_block_iterator(Ranges),
                             const_block_iterator());
  }
  // (end group of Block-related types and functions)
 
 
  using code_block_iterator =
      MergeSortedIterator<Section::code_block_iterator, AddressLess>;
  using code_block_range = boost::iterator_range<code_block_iterator>;
  using code_block_subrange = boost::iterator_range<
      MergeSortedIterator<Section::code_block_subrange::iterator, AddressLess>>;
  using const_code_block_iterator =
      MergeSortedIterator<Section::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<
      Section::const_code_block_subrange::iterator, AddressLess>>;
 
private:
  code_block_range makeCodeBlockRange(SectionSet::iterator Begin,
                                      SectionSet::iterator End) {
    NodeToCodeBlockRange<Section> Transformer;
    return boost::make_iterator_range(
        code_block_iterator(
            boost::make_transform_iterator(section_iterator(Begin),
                                           Transformer),
            boost::make_transform_iterator(section_iterator(End), Transformer)),
        code_block_iterator());
  }
 
public:
  code_block_iterator code_blocks_begin() {
    return code_block_iterator(
        boost::make_transform_iterator(this->sections_begin(),
                                       NodeToCodeBlockRange<Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToCodeBlockRange<Section>()));
  }
 
  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->sections_begin(),
                                       NodeToCodeBlockRange<const Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToCodeBlockRange<const Section>()));
  }
 
  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) {
    section_subrange Range = findSectionsOn(A);
    return code_block_subrange(
        code_block_subrange::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindCodeBlocksIn<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindCodeBlocksIn<Section>(A))),
        code_block_subrange::iterator());
  }
 
  const_code_block_subrange findCodeBlocksOn(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_code_block_subrange(
        const_code_block_subrange::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindCodeBlocksIn<const Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindCodeBlocksIn<const Section>(A))),
        const_code_block_subrange::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr A) {
    section_subrange Range = findSectionsOn(A);
    return code_block_range(
        code_block_range::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindCodeBlocksAt<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindCodeBlocksAt<Section>(A))),
        code_block_range::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    std::vector<Section::code_block_range> Ranges;
    for (Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findCodeBlocksAt(Low, High));
    for (Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findCodeBlocksAt(Low, High));
    return code_block_range(code_block_iterator(Ranges), code_block_iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_code_block_range(
        const_code_block_range::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindCodeBlocksAt<const Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindCodeBlocksAt<const Section>(A))),
        const_code_block_range::iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    std::vector<Section::const_code_block_range> Ranges;
    for (const Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findCodeBlocksAt(Low, High));
    for (const Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findCodeBlocksAt(Low, High));
    return const_code_block_range(const_code_block_iterator(Ranges),
                                  const_code_block_iterator());
  }
  // (end group of CodeBlock-related types and functions)
 
 
  using data_block_iterator =
      MergeSortedIterator<Section::data_block_iterator, AddressLess>;
  using data_block_range = boost::iterator_range<data_block_iterator>;
  using data_block_subrange = boost::iterator_range<
      MergeSortedIterator<Section::data_block_subrange::iterator, AddressLess>>;
  using const_data_block_iterator =
      MergeSortedIterator<Section::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<
      Section::const_data_block_subrange::iterator, AddressLess>>;
 
  data_block_iterator data_blocks_begin() {
    return data_block_iterator(
        boost::make_transform_iterator(this->sections_begin(),
                                       NodeToDataBlockRange<Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToDataBlockRange<Section>()));
  }
 
  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->sections_begin(),
                                       NodeToDataBlockRange<const Section>()),
        boost::make_transform_iterator(this->sections_end(),
                                       NodeToDataBlockRange<const Section>()));
  }
 
  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) {
    section_subrange Range = findSectionsOn(A);
    return data_block_subrange(
        data_block_subrange::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindDataBlocksIn<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindDataBlocksIn<Section>(A))),
        data_block_subrange::iterator());
  }
 
  const_data_block_subrange findDataBlocksOn(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_data_block_subrange(
        const_data_block_subrange::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindDataBlocksIn<const Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindDataBlocksIn<const Section>(A))),
        const_data_block_subrange::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr A) {
    section_subrange Range = findSectionsOn(A);
    return data_block_range(
        data_block_range::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindDataBlocksAt<Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindDataBlocksAt<Section>(A))),
        data_block_range::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr Low, Addr High) {
    std::vector<Section::data_block_range> Ranges;
    for (Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findDataBlocksAt(Low, High));
    for (Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findDataBlocksAt(Low, High));
    return data_block_range(data_block_iterator(Ranges), data_block_iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr A) const {
    const_section_subrange Range = findSectionsOn(A);
    return const_data_block_range(
        const_data_block_range::iterator(
            boost::make_transform_iterator(Range.begin(),
                                           FindDataBlocksAt<const Section>(A)),
            boost::make_transform_iterator(Range.end(),
                                           FindDataBlocksAt<const Section>(A))),
        const_data_block_range::iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    std::vector<Section::const_data_block_range> Ranges;
    for (const Section& S : findSectionsOn(Low))
      Ranges.push_back(S.findDataBlocksAt(Low, High));
    for (const Section& S : findSectionsAt(Low + 1, High))
      Ranges.push_back(S.findDataBlocksAt(Low, High));
    return const_data_block_range(const_data_block_iterator(Ranges),
                                  const_data_block_iterator());
  }
  // (end group of DataBlock-related types and functions)
 
 
  using symbolic_expression_iterator =
      MergeSortedIterator<Section::symbolic_expression_iterator,
                          ByteInterval::SymbolicExpressionElement::AddressLess>;
  using symbolic_expression_range =
      boost::iterator_range<symbolic_expression_iterator>;
  using const_symbolic_expression_iterator = MergeSortedIterator<
      Section::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->sections_begin(), NodeToSymbolicExpressionRange<Section>()),
        boost::make_transform_iterator(
            this->sections_end(), NodeToSymbolicExpressionRange<Section>()));
  }
 
  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->sections_begin(),
            NodeToSymbolicExpressionRange<const Section>()),
        boost::make_transform_iterator(
            this->sections_end(),
            NodeToSymbolicExpressionRange<const Section>()));
  }
 
  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->sections_begin(),
                                           FindSymExprsAt<Section>(A)),
            boost::make_transform_iterator(this->sections_end(),
                                           FindSymExprsAt<Section>(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->sections_begin(),
                FindSymExprsBetween<Section>(Low, High)),
            boost::make_transform_iterator(
                this->sections_end(), FindSymExprsBetween<Section>(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->sections_begin(),
                                           FindSymExprsAt<const Section>(A)),
            boost::make_transform_iterator(this->sections_end(),
                                           FindSymExprsAt<const Section>(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->sections_begin(),
                FindSymExprsBetween<const Section>(Low, High)),
            boost::make_transform_iterator(
                this->sections_end(),
                FindSymExprsBetween<const Section>(Low, High))),
        const_symbolic_expression_range::iterator());
  }
  // (end group of SymbolicExpression-related types and functions)
 
  static bool classof(const Node* N) { return N->getKind() == Kind::Module; }
 
private:
  using MessageType = proto::Module;
 
  void removeSectionAddrs(Section* S);
 
  void insertSectionAddrs(Section* S);
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<Module*> fromProtobuf(Context& C, const MessageType& Message);
 
  // Present for testing purposes only.
  void save(std::ostream& Out) const;
 
  // Present for testing purposes only.
  static Module* load(Context& C, std::istream& In);
 
  void setParent(IR* I, ModuleObserver* O) {
    Parent = I;
    Observer = O;
  }
 
  IR* Parent{nullptr};
  ModuleObserver* Observer{nullptr};
  std::string BinaryPath;
  Addr PreferredAddr;
  int64_t RebaseDelta{0};
  gtirb::FileFormat FileFormat{FileFormat::Undefined};
  gtirb::ISA Isa{ISA::Undefined};
  gtirb::ByteOrder ByteOrder{ByteOrder::Undefined};
  std::string Name;
  CodeBlock* EntryPoint{nullptr};
  ProxyBlockSet ProxyBlocks;
  SectionSet Sections;
  SectionIntMap SectionAddrs;
  SymbolSet Symbols;
 
  std::unique_ptr<SectionObserver> SecObs;
  std::unique_ptr<SymbolObserver> SymObs;
 
  friend class Context; // Allow Context to construct new Modules.
  friend class IR;      // Allow IRs to call setIR, Create, etc.
  // Allow serialization from IR via containerToProtobuf.
  template <typename T> friend typename T::MessageType toProtobuf(const T&);
  friend class SerializationTestHarness; // Testing support.
};
 
 
class GTIRB_EXPORT_API ModuleObserver {
public:
  virtual ~ModuleObserver() = default;
 
  virtual ChangeStatus nameChange(Module* M, const std::string& OldName,
                                  const std::string& NewName) = 0;
 
  virtual ChangeStatus addProxyBlocks(Module* M,
                                      Module::proxy_block_range Blocks) = 0;
 
  virtual ChangeStatus removeProxyBlocks(Module* M,
                                         Module::proxy_block_range Blocks) = 0;
 
  virtual ChangeStatus addCodeBlocks(Module* M,
                                     Module::code_block_range Blocks) = 0;
 
  virtual ChangeStatus removeCodeBlocks(Module* M,
                                        Module::code_block_range Blocks) = 0;
};
 
inline void Module::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_MODULE_H