IR.hpp

Go to the documentation of this file.

//===- IR.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_IR_H
#define GTIRB_IR_H
 
#include <gtirb/Addr.hpp>
#include <gtirb/AuxData.hpp>
#include <gtirb/AuxDataContainer.hpp>
#include <gtirb/CFG.hpp>
#include <gtirb/ErrorOr.hpp>
#include <gtirb/Module.hpp>
#include <gtirb/Node.hpp>
#include <gtirb/Observer.hpp>
#include <gtirb/Utility.hpp>
#include <gtirb/version.h>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/range/iterator_range.hpp>
#include <map>
#include <string>
#include <vector>
 
 
namespace gtirb {
namespace proto {
class IR;
}
 
class GTIRB_EXPORT_API IR : public AuxDataContainer {
  IR(Context& C);
  IR(Context& C, const UUID& U);
 
  static IR* Create(Context& C, const UUID& U) { return C.Create<IR>(C, U); }
 
  struct by_name {};
  struct by_pointer {};
 
  using ModuleSet = boost::multi_index::multi_index_container<
      Module*, boost::multi_index::indexed_by<
                   boost::multi_index::ordered_non_unique<
                       boost::multi_index::tag<by_name>,
                       boost::multi_index::const_mem_fun<
                           Module, const std::string&, &Module::getName>>,
                   boost::multi_index::hashed_unique<
                       boost::multi_index::tag<by_pointer>,
                       boost::multi_index::identity<Module*>>>>;
 
  class ModuleObserverImpl;
 
public:
  static IR* Create(Context& C) { return C.Create<IR>(C); }
 
  const CFG& getCFG() const { return Cfg; }
 
  CFG& getCFG() { return Cfg; }
 
  using module_iterator = boost::indirect_iterator<ModuleSet::iterator>;
  using const_module_iterator =
      boost::indirect_iterator<ModuleSet::const_iterator, const Module>;
 
  module_iterator modules_begin() { return Modules.begin(); }
  module_iterator modules_end() { return Modules.end(); }
  const_module_iterator modules_begin() const { return Modules.begin(); }
  const_module_iterator modules_end() const { return Modules.end(); }
 
  using module_range = boost::iterator_range<module_iterator>;
  using const_module_range = boost::iterator_range<const_module_iterator>;
 
  module_range modules() {
    return boost::make_iterator_range(modules_begin(), modules_end());
  }
  const_module_range modules() const {
    return boost::make_iterator_range(modules_begin(), modules_end());
  }
 
  using module_name_iterator =
      boost::indirect_iterator<ModuleSet::index<by_name>::type::iterator>;
  using module_name_range = boost::iterator_range<module_name_iterator>;
  using const_module_name_iterator =
      boost::indirect_iterator<ModuleSet::index<by_name>::type::const_iterator,
                               const Module>;
  using const_module_name_range =
      boost::iterator_range<const_module_name_iterator>;
 
  bool removeModule(Module* M) {
    auto& Index = Modules.get<by_pointer>();
    if (auto Iter = Index.find(M); Iter != Index.end()) {
      MO->removeProxyBlocks(M, M->proxy_blocks());
      MO->removeCodeBlocks(M, M->code_blocks());
      Index.erase(Iter);
      M->setParent(nullptr, nullptr);
      return true;
    }
    return false;
  }
 
  Module* addModule(Module* M) {
    if (M->getIR()) {
      M->getIR()->removeModule(M);
    }
 
    MO->addProxyBlocks(M, M->proxy_blocks());
    MO->addCodeBlocks(M, M->code_blocks());
    Modules.emplace(M);
    M->setParent(this, MO.get());
    return M;
  }
 
  // FIXME: this API may wind up getting removed because we perhaps want to
  // support creating a Module that is not hooked up to any IR object and then
  // set the parent on the module later. Personally, I think that is a
  // dangerous design choice, but we can argue the merits of both approaches in
  // a code review.
  template <typename... Args> Module* addModule(Context& C, Args... A) {
    return addModule(Module::Create(C, A...));
  }
 
  module_name_range findModules(const std::string& N) {
    auto Found = Modules.get<by_name>().equal_range(N);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  const_module_name_range findModules(const std::string& N) const {
    auto Found = Modules.get<by_name>().equal_range(N);
    return boost::make_iterator_range(Found.first, Found.second);
  }
 
  // (end Module-Related Public Types and Functions)
 
  void save(std::ostream& Out) const;
 
  void saveJSON(std::ostream& Out) const;
 
  enum class load_error {
    IncorrectVersion = 1, 
    CorruptFile, 
    CorruptModule,
    CorruptSection,
    CorruptByteInterval,
    CorruptCFG,  
    BadUUID,     
    MissingUUID, 
    NotGTIRB,    
  };
 
  static ErrorOr<IR*> load(Context& C, std::istream& In);
 
  static ErrorOr<IR*> loadJSON(Context& C, std::istream& In);
 
 
  using proxy_block_iterator = MergeSortedIterator<Module::proxy_block_iterator,
                                                   ArbitraryLess<ProxyBlock>>;
  using proxy_block_range = boost::iterator_range<proxy_block_iterator>;
  using const_proxy_block_iterator =
      MergeSortedIterator<Module::const_proxy_block_iterator,
                          ArbitraryLess<ProxyBlock>>;
  using const_proxy_block_range =
      boost::iterator_range<const_proxy_block_iterator>;
 
  proxy_block_iterator proxy_blocks_begin() {
    return proxy_block_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToProxyBlockRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToProxyBlockRange<Module>()));
  }
 
  proxy_block_iterator proxy_blocks_end() { return proxy_block_iterator(); }
 
  proxy_block_range proxy_blocks() {
    return boost::make_iterator_range(proxy_blocks_begin(), proxy_blocks_end());
  }
 
  const_proxy_block_iterator proxy_blocks_begin() const {
    return const_proxy_block_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToProxyBlockRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToProxyBlockRange<const Module>()));
  }
 
  const_proxy_block_iterator proxy_blocks_end() const {
    return const_proxy_block_iterator();
  }
 
  const_proxy_block_range proxy_blocks() const {
    return boost::make_iterator_range(proxy_blocks_begin(), proxy_blocks_end());
  }
  // (end ProxyBlock-Related Public Types and Functions)
 
 
  using symbol_iterator =
      MergeSortedIterator<Module::symbol_iterator, ArbitraryLess<Symbol>>;
  using symbol_range = boost::iterator_range<symbol_iterator>;
  using const_symbol_iterator =
      MergeSortedIterator<Module::const_symbol_iterator, ArbitraryLess<Symbol>>;
  using const_symbol_range = boost::iterator_range<const_symbol_iterator>;
 
  symbol_iterator symbols_begin() {
    return symbol_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToSymbolRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToSymbolRange<Module>()));
  }
 
  symbol_iterator symbols_end() { return symbol_iterator(); }
 
  symbol_range symbols() {
    return boost::make_iterator_range(symbols_begin(), symbols_end());
  }
 
  const_symbol_iterator symbols_begin() const {
    return const_symbol_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToSymbolRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToSymbolRange<const Module>()));
  }
 
  const_symbol_iterator symbols_end() const { return const_symbol_iterator(); }
 
  const_symbol_range symbols() const {
    return boost::make_iterator_range(symbols_begin(), symbols_end());
  }
  // (end Symbol-Related Public Types and Functions)
 
 
  using section_iterator =
      MergeSortedIterator<Module::section_iterator, AddressLess>;
  using section_range = boost::iterator_range<section_iterator>;
  using section_subrange = boost::iterator_range<
      MergeSortedIterator<Module::section_subrange::iterator, AddressLess>>;
  using const_section_iterator =
      MergeSortedIterator<Module::const_section_iterator, AddressLess>;
  using const_section_range = boost::iterator_range<const_section_iterator>;
  using const_section_subrange = boost::iterator_range<MergeSortedIterator<
      Module::const_section_subrange::iterator, AddressLess>>;
  using section_name_iterator =
      MergeSortedIterator<Module::section_name_iterator, AddressLess>;
  using section_name_range = boost::iterator_range<section_name_iterator>;
  using const_section_name_iterator =
      MergeSortedIterator<Module::const_section_name_iterator, AddressLess>;
  using const_section_name_range =
      boost::iterator_range<const_section_name_iterator>;
 
  section_iterator sections_begin() {
    return section_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToSectionRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToSectionRange<Module>()));
  }
 
  section_iterator sections_end() { return section_iterator(); }
 
  section_range sections() {
    return boost::make_iterator_range(sections_begin(), sections_end());
  }
 
  const_section_iterator sections_begin() const {
    return const_section_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToSectionRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToSectionRange<const Module>()));
  }
 
  const_section_iterator sections_end() const {
    return const_section_iterator();
  }
 
  const_section_range sections() const {
    return boost::make_iterator_range(sections_begin(), sections_end());
  }
 
  section_subrange findSectionsOn(Addr A) {
    return section_subrange(
        section_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSectionsIn<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSectionsIn<Module>(A))),
        section_subrange::iterator());
  }
 
  const_section_subrange findSectionsOn(Addr A) const {
    return const_section_subrange(
        const_section_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSectionsIn<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSectionsIn<const Module>(A))),
        const_section_subrange::iterator());
  }
 
  section_range findSectionsAt(Addr A) {
    return section_range(
        section_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSectionsAt<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSectionsAt<Module>(A))),
        section_range::iterator());
  }
 
  section_range findSectionsAt(Addr Low, Addr High) {
    return section_range(
        section_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(), FindSectionsBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(), FindSectionsBetween<Module>(Low, High))),
        section_range::iterator());
  }
 
  const_section_range findSectionsAt(Addr A) const {
    return const_section_range(
        const_section_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSectionsAt<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSectionsAt<const Module>(A))),
        const_section_range::iterator());
  }
 
  const_section_range findSectionsAt(Addr Low, Addr High) const {
    return const_section_range(
        const_section_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindSectionsBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindSectionsBetween<const Module>(Low, High))),
        const_section_range::iterator());
  }
  section_name_range findSections(const std::string& X) {
    return section_name_range(
        section_name_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSections<Module>(X)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSections<Module>(X))),
        section_name_range::iterator());
  }
 
  const_section_name_range findSections(const std::string& X) const {
    return const_section_name_range(
        const_section_name_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindSections<const Module>(X)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSections<const Module>(X))),
        const_section_name_range::iterator());
  }
  // (end Section-Related Public Types and Functions)
 
 
  using byte_interval_iterator =
      MergeSortedIterator<Module::byte_interval_iterator, AddressLess>;
  using byte_interval_range = boost::iterator_range<byte_interval_iterator>;
  using byte_interval_subrange = boost::iterator_range<MergeSortedIterator<
      Module::byte_interval_subrange::iterator, AddressLess>>;
  using const_byte_interval_iterator =
      MergeSortedIterator<Module::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<
          Module::const_byte_interval_subrange::iterator, AddressLess>>;
 
  byte_interval_iterator byte_intervals_begin() {
    return byte_interval_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToByteIntervalRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToByteIntervalRange<Module>()));
  }
 
  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->modules_begin(),
                                       NodeToByteIntervalRange<const Module>()),
        boost::make_transform_iterator(
            this->modules_end(), NodeToByteIntervalRange<const Module>()));
  }
 
  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) {
    return byte_interval_subrange(
        byte_interval_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindByteIntervalsIn<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindByteIntervalsIn<Module>(A))),
        byte_interval_subrange::iterator());
  }
 
  const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    return const_byte_interval_subrange(
        const_byte_interval_subrange::iterator(
            boost::make_transform_iterator(
                this->modules_begin(), FindByteIntervalsIn<const Module>(A)),
            boost::make_transform_iterator(
                this->modules_end(), FindByteIntervalsIn<const Module>(A))),
        const_byte_interval_subrange::iterator());
  }
 
  byte_interval_range findByteIntervalsAt(Addr A) {
    return byte_interval_range(
        byte_interval_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindByteIntervalsAt<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindByteIntervalsAt<Module>(A))),
        byte_interval_range::iterator());
  }
 
  byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    return byte_interval_range(
        byte_interval_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindByteIntervalsBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindByteIntervalsBetween<Module>(Low, High))),
        byte_interval_range::iterator());
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr A) const {
    return const_byte_interval_range(
        const_byte_interval_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(), FindByteIntervalsAt<const Module>(A)),
            boost::make_transform_iterator(
                this->modules_end(), FindByteIntervalsAt<const Module>(A))),
        const_byte_interval_range::iterator());
  }
 
  const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) const {
    return const_byte_interval_range(
        const_byte_interval_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindByteIntervalsBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindByteIntervalsBetween<const Module>(Low, High))),
        const_byte_interval_range::iterator());
  }
  // (end group of ByteInterval-related types and functions)
 
 
  using block_iterator =
      MergeSortedIterator<Module::block_iterator, BlockAddressLess>;
  using block_range = boost::iterator_range<block_iterator>;
  using block_subrange = boost::iterator_range<
      MergeSortedIterator<Module::block_subrange::iterator, BlockAddressLess>>;
  using const_block_iterator =
      MergeSortedIterator<Module::const_block_iterator, BlockAddressLess>;
  using const_block_range = boost::iterator_range<const_block_iterator>;
  using const_block_subrange = boost::iterator_range<MergeSortedIterator<
      Module::const_block_subrange::iterator, BlockAddressLess>>;
 
  block_iterator blocks_begin() {
    return block_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToBlockRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToBlockRange<Module>()));
  }
 
  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->modules_begin(),
                                       NodeToBlockRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToBlockRange<const Module>()));
  }
 
  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) {
    return block_subrange(
        block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindBlocksIn<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindBlocksIn<Module>(A))),
        block_subrange::iterator());
  }
 
  const_block_subrange findBlocksOn(Addr A) const {
    return const_block_subrange(
        const_block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindBlocksIn<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindBlocksIn<const Module>(A))),
        const_block_subrange::iterator());
  }
 
  block_range findBlocksAt(Addr A) {
    return block_range(block_range::iterator(
                           boost::make_transform_iterator(
                               this->modules_begin(), FindBlocksAt<Module>(A)),
                           boost::make_transform_iterator(
                               this->modules_end(), FindBlocksAt<Module>(A))),
                       block_range::iterator());
  }
 
  block_range findBlocksAt(Addr Low, Addr High) {
    return block_range(
        block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(), FindBlocksBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(), FindBlocksBetween<Module>(Low, High))),
        block_range::iterator());
  }
 
  const_block_range findBlocksAt(Addr A) const {
    return const_block_range(
        const_block_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindBlocksAt<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindBlocksAt<const Module>(A))),
        const_block_range::iterator());
  }
 
  const_block_range findBlocksAt(Addr Low, Addr High) const {
    return const_block_range(
        const_block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindBlocksBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindBlocksBetween<const Module>(Low, High))),
        const_block_range::iterator());
  }
  // (end group of Block-related types and functions)
 
 
  using code_block_iterator =
      MergeSortedIterator<Module::code_block_iterator, AddressLess>;
  using code_block_range = boost::iterator_range<code_block_iterator>;
  using code_block_subrange = boost::iterator_range<
      MergeSortedIterator<Module::code_block_subrange::iterator, AddressLess>>;
  using const_code_block_iterator =
      MergeSortedIterator<Module::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<
      Module::const_code_block_subrange::iterator, AddressLess>>;
 
  code_block_iterator code_blocks_begin() {
    return code_block_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToCodeBlockRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToCodeBlockRange<Module>()));
  }
 
  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->modules_begin(),
                                       NodeToCodeBlockRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToCodeBlockRange<const Module>()));
  }
 
  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) {
    return code_block_subrange(
        code_block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindCodeBlocksIn<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindCodeBlocksIn<Module>(A))),
        code_block_subrange::iterator());
  }
 
  const_code_block_subrange findCodeBlocksOn(Addr A) const {
    return const_code_block_subrange(
        const_code_block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindCodeBlocksIn<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindCodeBlocksIn<const Module>(A))),
        const_code_block_subrange::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr A) {
    return code_block_range(
        code_block_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindCodeBlocksAt<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindCodeBlocksAt<Module>(A))),
        code_block_range::iterator());
  }
 
  code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    return code_block_range(
        code_block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindCodeBlocksBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(), FindCodeBlocksBetween<Module>(Low, High))),
        code_block_range::iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr A) const {
    return const_code_block_range(
        const_code_block_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindCodeBlocksAt<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindCodeBlocksAt<const Module>(A))),
        const_code_block_range::iterator());
  }
 
  const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    return const_code_block_range(
        const_code_block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindCodeBlocksBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindCodeBlocksBetween<const Module>(Low, High))),
        const_code_block_range::iterator());
  }
  // (end group of CodeBlock-related types and functions)
 
 
  using data_block_iterator =
      MergeSortedIterator<Module::data_block_iterator, AddressLess>;
  using data_block_range = boost::iterator_range<data_block_iterator>;
  using data_block_subrange = boost::iterator_range<
      MergeSortedIterator<Module::data_block_subrange::iterator, AddressLess>>;
  using const_data_block_iterator =
      MergeSortedIterator<Module::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<
      Module::const_data_block_subrange::iterator, AddressLess>>;
 
  data_block_iterator data_blocks_begin() {
    return data_block_iterator(
        boost::make_transform_iterator(this->modules_begin(),
                                       NodeToDataBlockRange<Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToDataBlockRange<Module>()));
  }
 
  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->modules_begin(),
                                       NodeToDataBlockRange<const Module>()),
        boost::make_transform_iterator(this->modules_end(),
                                       NodeToDataBlockRange<const Module>()));
  }
 
  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) {
    return data_block_subrange(
        data_block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindDataBlocksIn<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindDataBlocksIn<Module>(A))),
        data_block_subrange::iterator());
  }
 
  const_data_block_subrange findDataBlocksOn(Addr A) const {
    return const_data_block_subrange(
        const_data_block_subrange::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindDataBlocksIn<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindDataBlocksIn<const Module>(A))),
        const_data_block_subrange::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr A) {
    return data_block_range(
        data_block_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindDataBlocksAt<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindDataBlocksAt<Module>(A))),
        data_block_range::iterator());
  }
 
  data_block_range findDataBlocksAt(Addr Low, Addr High) {
    return data_block_range(
        data_block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindDataBlocksBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(), FindDataBlocksBetween<Module>(Low, High))),
        data_block_range::iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr A) const {
    return const_data_block_range(
        const_data_block_range::iterator(
            boost::make_transform_iterator(this->modules_begin(),
                                           FindDataBlocksAt<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindDataBlocksAt<const Module>(A))),
        const_data_block_range::iterator());
  }
 
  const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    return const_data_block_range(
        const_data_block_range::iterator(
            boost::make_transform_iterator(
                this->modules_begin(),
                FindDataBlocksBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindDataBlocksBetween<const Module>(Low, High))),
        const_data_block_range::iterator());
  }
  // (end group of DataBlock-related types and functions)
 
 
  using symbolic_expression_iterator =
      MergeSortedIterator<Module::symbolic_expression_iterator,
                          ByteInterval::SymbolicExpressionElement::AddressLess>;
  using symbolic_expression_range =
      boost::iterator_range<symbolic_expression_iterator>;
  using const_symbolic_expression_iterator = MergeSortedIterator<
      Module::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->modules_begin(),
                                       NodeToSymbolicExpressionRange<Module>()),
        boost::make_transform_iterator(
            this->modules_end(), NodeToSymbolicExpressionRange<Module>()));
  }
 
  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->modules_begin(),
            NodeToSymbolicExpressionRange<const Module>()),
        boost::make_transform_iterator(
            this->modules_end(),
            NodeToSymbolicExpressionRange<const Module>()));
  }
 
  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->modules_begin(),
                                           FindSymExprsAt<Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSymExprsAt<Module>(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->modules_begin(), FindSymExprsBetween<Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(), FindSymExprsBetween<Module>(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->modules_begin(),
                                           FindSymExprsAt<const Module>(A)),
            boost::make_transform_iterator(this->modules_end(),
                                           FindSymExprsAt<const Module>(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->modules_begin(),
                FindSymExprsBetween<const Module>(Low, High)),
            boost::make_transform_iterator(
                this->modules_end(),
                FindSymExprsBetween<const Module>(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::IR; }
 
  uint32_t getVersion() const { return Version; }
 
  void setVersion(uint32_t V) { Version = V; }
 
private:
  using MessageType = proto::IR;
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<IR*> fromProtobuf(Context& C, const MessageType& Message);
 
  ModuleSet Modules;
  uint32_t Version{GTIRB_PROTOBUF_VERSION};
  CFG Cfg;
 
  std::unique_ptr<ModuleObserver> MO;
 
  friend class Context; // Allow Context to construct new IRs.
};
 
GTIRB_EXPORT_API const std::error_category& loadErrorCategory();
 
inline std::error_code make_error_code(gtirb::IR::load_error e) {
  return std::error_code(static_cast<int>(e), loadErrorCategory());
}
 
} // namespace gtirb
 
namespace std {
template <>
struct is_error_code_enum<gtirb::IR::load_error> : std::true_type {};
} // namespace std
 
#endif // GTIRB_IR_H