Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===------------ JITLink.h - JIT linker functionality ----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Contains generic JIT-linker types.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H

#define LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/Triple.h"

#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"

#include "llvm/ExecutionEngine/JITSymbol.h"

#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/BinaryStreamReader.h"

#include "llvm/Support/BinaryStreamWriter.h"

#include "llvm/Support/Endian.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/FormatVariadic.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/MemoryBuffer.h"

#include <optional>

#include <map>

#include <string>

#include <system_error>

namespace llvm {

namespace jitlink {

class LinkGraph;

class Symbol;

class Section;

/// Base class for errors originating in JIT linker, e.g. missing relocation

/// support.

class JITLinkError : public ErrorInfo<JITLinkError> {

public:

  static char ID;

  JITLinkError(Twine ErrMsg) : ErrMsg(ErrMsg.str()) {}

  void log(raw_ostream &OS) const override;

  const std::string &getErrorMessage() const { return ErrMsg; }

  std::error_code convertToErrorCode() const override;

private:

  std::string ErrMsg;

};

/// Represents fixups and constraints in the LinkGraph.

class Edge {

public:

  using Kind = uint8_t;

  enum GenericEdgeKind : Kind {

    Invalid,                    // Invalid edge value.

    FirstKeepAlive,             // Keeps target alive. Offset/addend zero.

    KeepAlive = FirstKeepAlive, // Tag first edge kind that preserves liveness.

    FirstRelocation             // First architecture specific relocation.

  };

  using OffsetT = uint32_t;

  using AddendT = int64_t;

  Edge(Kind K, OffsetT Offset, Symbol &Target, AddendT Addend)

      : Target(&Target), Offset(Offset), Addend(Addend), K(K) {}

  OffsetT getOffset() const { return Offset; }

  void setOffset(OffsetT Offset) { this->Offset = Offset; }

  Kind getKind() const { return K; }

  void setKind(Kind K) { this->K = K; }

  bool isRelocation() const { return K >= FirstRelocation; }

  Kind getRelocation() const {

    assert(isRelocation() && "Not a relocation edge");

    return K - FirstRelocation;

  }

  bool isKeepAlive() const { return K >= FirstKeepAlive; }

  Symbol &getTarget() const { return *Target; }

  void setTarget(Symbol &Target) { this->Target = &Target; }

  AddendT getAddend() const { return Addend; }

  void setAddend(AddendT Addend) { this->Addend = Addend; }

private:

  Symbol *Target = nullptr;

  OffsetT Offset = 0;

  AddendT Addend = 0;

  Kind K = 0;

};

/// Returns the string name of the given generic edge kind, or "unknown"

/// otherwise. Useful for debugging.

const char *getGenericEdgeKindName(Edge::Kind K);

/// Base class for Addressable entities (externals, absolutes, blocks).

class Addressable {

  friend class LinkGraph;

protected:

  Addressable(orc::ExecutorAddr Address, bool IsDefined)

      : Address(Address), IsDefined(IsDefined), IsAbsolute(false) {}

  Addressable(orc::ExecutorAddr Address)

      : Address(Address), IsDefined(false), IsAbsolute(true) {

    assert(!(IsDefined && IsAbsolute) &&

           "Block cannot be both defined and absolute");

  }

public:

  Addressable(const Addressable &) = delete;

  Addressable &operator=(const Addressable &) = default;

  Addressable(Addressable &&) = delete;

  Addressable &operator=(Addressable &&) = default;

  orc::ExecutorAddr getAddress() const { return Address; }

  void setAddress(orc::ExecutorAddr Address) { this->Address = Address; }

  /// Returns true if this is a defined addressable, in which case you

  /// can downcast this to a Block.

  bool isDefined() const { return static_cast<bool>(IsDefined); }

  bool isAbsolute() const { return static_cast<bool>(IsAbsolute); }

private:

  void setAbsolute(bool IsAbsolute) {

    assert(!IsDefined && "Cannot change the Absolute flag on a defined block");

    this->IsAbsolute = IsAbsolute;

  }

  orc::ExecutorAddr Address;

  uint64_t IsDefined : 1;

  uint64_t IsAbsolute : 1;

protected:

  // bitfields for Block, allocated here to improve packing.

  uint64_t ContentMutable : 1;

  uint64_t P2Align : 5;

  uint64_t AlignmentOffset : 56;

};

using SectionOrdinal = unsigned;

/// An Addressable with content and edges.

class Block : public Addressable {

  friend class LinkGraph;

private:

  /// Create a zero-fill defined addressable.

  Block(Section &Parent, orc::ExecutorAddrDiff Size, orc::ExecutorAddr Address,

        uint64_t Alignment, uint64_t AlignmentOffset)

      : Addressable(Address, true), Parent(&Parent), Size(Size) {

    assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");

    assert(AlignmentOffset < Alignment &&

           "Alignment offset cannot exceed alignment");

    assert(AlignmentOffset <= MaxAlignmentOffset &&

           "Alignment offset exceeds maximum");

    ContentMutable = false;

    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;

    this->AlignmentOffset = AlignmentOffset;

  }

  /// Create a defined addressable for the given content.

  /// The Content is assumed to be non-writable, and will be copied when

  /// mutations are required.

  Block(Section &Parent, ArrayRef<char> Content, orc::ExecutorAddr Address,

        uint64_t Alignment, uint64_t AlignmentOffset)

      : Addressable(Address, true), Parent(&Parent), Data(Content.data()),

        Size(Content.size()) {

    assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");

    assert(AlignmentOffset < Alignment &&

           "Alignment offset cannot exceed alignment");

    assert(AlignmentOffset <= MaxAlignmentOffset &&

           "Alignment offset exceeds maximum");

    ContentMutable = false;

    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;

    this->AlignmentOffset = AlignmentOffset;

  }

  /// Create a defined addressable for the given content.

  /// The content is assumed to be writable, and the caller is responsible

  /// for ensuring that it lives for the duration of the Block's lifetime.

  /// The standard way to achieve this is to allocate it on the Graph's

  /// allocator.

  Block(Section &Parent, MutableArrayRef<char> Content,

        orc::ExecutorAddr Address, uint64_t Alignment, uint64_t AlignmentOffset)

      : Addressable(Address, true), Parent(&Parent), Data(Content.data()),

        Size(Content.size()) {

    assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");

    assert(AlignmentOffset < Alignment &&

           "Alignment offset cannot exceed alignment");

    assert(AlignmentOffset <= MaxAlignmentOffset &&

           "Alignment offset exceeds maximum");

    ContentMutable = true;

    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;

    this->AlignmentOffset = AlignmentOffset;

  }

public:

  using EdgeVector = std::vector<Edge>;

  using edge_iterator = EdgeVector::iterator;

  using const_edge_iterator = EdgeVector::const_iterator;

  Block(const Block &) = delete;

  Block &operator=(const Block &) = delete;

  Block(Block &&) = delete;

  Block &operator=(Block &&) = delete;

  /// Return the parent section for this block.

  Section &getSection() const { return *Parent; }

  /// Returns true if this is a zero-fill block.

  ///

  /// If true, getSize is callable but getContent is not (the content is

  /// defined to be a sequence of zero bytes of length Size).

  bool isZeroFill() const { return !Data; }

  /// Returns the size of this defined addressable.

  size_t getSize() const { return Size; }

  /// Returns the address range of this defined addressable.

  orc::ExecutorAddrRange getRange() const {

    return orc::ExecutorAddrRange(getAddress(), getSize());

  }

  /// Get the content for this block. Block must not be a zero-fill block.

  ArrayRef<char> getContent() const {

    assert(Data && "Block does not contain content");

    return ArrayRef<char>(Data, Size);

  }

  /// Set the content for this block.

  /// Caller is responsible for ensuring the underlying bytes are not

  /// deallocated while pointed to by this block.

  void setContent(ArrayRef<char> Content) {

    assert(Content.data() && "Setting null content");

    Data = Content.data();

    Size = Content.size();

    ContentMutable = false;

  }

  /// Get mutable content for this block.

  ///

  /// If this Block's content is not already mutable this will trigger a copy

  /// of the existing immutable content to a new, mutable buffer allocated using

  /// LinkGraph::allocateContent.

  MutableArrayRef<char> getMutableContent(LinkGraph &G);

  /// Get mutable content for this block.

  ///

  /// This block's content must already be mutable. It is a programmatic error

  /// to call this on a block with immutable content -- consider using

  /// getMutableContent instead.

  MutableArrayRef<char> getAlreadyMutableContent() {

    assert(Data && "Block does not contain content");

    assert(ContentMutable && "Content is not mutable");

    return MutableArrayRef<char>(const_cast<char *>(Data), Size);

  }

  /// Set mutable content for this block.

  ///

  /// The caller is responsible for ensuring that the memory pointed to by

  /// MutableContent is not deallocated while pointed to by this block.

  void setMutableContent(MutableArrayRef<char> MutableContent) {

    assert(MutableContent.data() && "Setting null content");

    Data = MutableContent.data();

    Size = MutableContent.size();

    ContentMutable = true;

  }

  /// Returns true if this block's content is mutable.

  ///

  /// This is primarily useful for asserting that a block is already in a

  /// mutable state prior to modifying the content. E.g. when applying

  /// fixups we expect the block to already be mutable as it should have been

  /// copied to working memory.

  bool isContentMutable() const { return ContentMutable; }

  /// Get the alignment for this content.

  uint64_t getAlignment() const { return 1ull << P2Align; }

  /// Set the alignment for this content.

  void setAlignment(uint64_t Alignment) {

    assert(isPowerOf2_64(Alignment) && "Alignment must be a power of two");

    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;

  }

  /// Get the alignment offset for this content.

  uint64_t getAlignmentOffset() const { return AlignmentOffset; }

  /// Set the alignment offset for this content.

  void setAlignmentOffset(uint64_t AlignmentOffset) {

    assert(AlignmentOffset < (1ull << P2Align) &&

           "Alignment offset can't exceed alignment");

    this->AlignmentOffset = AlignmentOffset;

  }

  /// Add an edge to this block.

  void addEdge(Edge::Kind K, Edge::OffsetT Offset, Symbol &Target,

               Edge::AddendT Addend) {

    assert((K == Edge::KeepAlive || !isZeroFill()) &&

           "Adding edge to zero-fill block?");

    Edges.push_back(Edge(K, Offset, Target, Addend));

  }

  /// Add an edge by copying an existing one. This is typically used when

  /// moving edges between blocks.

  void addEdge(const Edge &E) { Edges.push_back(E); }

  /// Return the list of edges attached to this content.

  iterator_range<edge_iterator> edges() {

    return make_range(Edges.begin(), Edges.end());

  }

  /// Returns the list of edges attached to this content.

  iterator_range<const_edge_iterator> edges() const {

    return make_range(Edges.begin(), Edges.end());

  }

  /// Return the size of the edges list.

  size_t edges_size() const { return Edges.size(); }

  /// Returns true if the list of edges is empty.

  bool edges_empty() const { return Edges.empty(); }

  /// Remove the edge pointed to by the given iterator.

  /// Returns an iterator to the new next element.

  edge_iterator removeEdge(edge_iterator I) { return Edges.erase(I); }

  /// Returns the address of the fixup for the given edge, which is equal to

  /// this block's address plus the edge's offset.

  orc::ExecutorAddr getFixupAddress(const Edge &E) const {

    return getAddress() + E.getOffset();

  }

private:

  static constexpr uint64_t MaxAlignmentOffset = (1ULL << 56) - 1;

  void setSection(Section &Parent) { this->Parent = &Parent; }

  Section *Parent;

  const char *Data = nullptr;

  size_t Size = 0;

  std::vector<Edge> Edges;

};

// Align an address to conform with block alignment requirements.

inline uint64_t alignToBlock(uint64_t Addr, Block &B) {

  uint64_t Delta = (B.getAlignmentOffset() - Addr) % B.getAlignment();

  return Addr + Delta;

}

// Align a orc::ExecutorAddr to conform with block alignment requirements.

inline orc::ExecutorAddr alignToBlock(orc::ExecutorAddr Addr, Block &B) {

  return orc::ExecutorAddr(alignToBlock(Addr.getValue(), B));

}

/// Describes symbol linkage. This can be used to make resolve definition

/// clashes.

enum class Linkage : uint8_t {

  Strong,

  Weak,

};

/// For errors and debugging output.

const char *getLinkageName(Linkage L);

/// Defines the scope in which this symbol should be visible:

///   Default -- Visible in the public interface of the linkage unit.

///   Hidden -- Visible within the linkage unit, but not exported from it.

///   Local -- Visible only within the LinkGraph.

enum class Scope : uint8_t {

  Default,

  Hidden,

  Local

};

/// For debugging output.

const char *getScopeName(Scope S);

raw_ostream &operator<<(raw_ostream &OS, const Block &B);

/// Symbol representation.

///

/// Symbols represent locations within Addressable objects.

/// They can be either Named or Anonymous.

/// Anonymous symbols have neither linkage nor visibility, and must point at

/// ContentBlocks.

/// Named symbols may be in one of four states:

///   - Null: Default initialized. Assignable, but otherwise unusable.

///   - Defined: Has both linkage and visibility and points to a ContentBlock

///   - Common: Has both linkage and visibility, points to a null Addressable.

///   - External: Has neither linkage nor visibility, points to an external

///     Addressable.

///

class Symbol {

  friend class LinkGraph;

private:

  Symbol(Addressable &Base, orc::ExecutorAddrDiff Offset, StringRef Name,

         orc::ExecutorAddrDiff Size, Linkage L, Scope S, bool IsLive,

         bool IsCallable)

      : Name(Name), Base(&Base), Offset(Offset), WeakRef(0), Size(Size) {

    assert(Offset <= MaxOffset && "Offset out of range");

    setLinkage(L);

    setScope(S);

    setLive(IsLive);

    setCallable(IsCallable);

  }

  static Symbol &constructExternal(BumpPtrAllocator &Allocator,

                                   Addressable &Base, StringRef Name,

                                   orc::ExecutorAddrDiff Size, Linkage L,

                                   bool WeaklyReferenced) {

    assert(!Base.isDefined() &&

           "Cannot create external symbol from defined block");

    assert(!Name.empty() && "External symbol name cannot be empty");

    auto *Sym = Allocator.Allocate<Symbol>();

    new (Sym) Symbol(Base, 0, Name, Size, L, Scope::Default, false, false);

    Sym->setWeaklyReferenced(WeaklyReferenced);

    return *Sym;

  }

  static Symbol &constructAbsolute(BumpPtrAllocator &Allocator,

                                   Addressable &Base, StringRef Name,

                                   orc::ExecutorAddrDiff Size, Linkage L,

                                   Scope S, bool IsLive) {

    assert(!Base.isDefined() &&

           "Cannot create absolute symbol from a defined block");

    auto *Sym = Allocator.Allocate<Symbol>();

    new (Sym) Symbol(Base, 0, Name, Size, L, S, IsLive, false);

    return *Sym;

  }

  static Symbol &constructAnonDef(BumpPtrAllocator &Allocator, Block &Base,

                                  orc::ExecutorAddrDiff Offset,

                                  orc::ExecutorAddrDiff Size, bool IsCallable,

                                  bool IsLive) {

    assert((Offset + Size) <= Base.getSize() &&

           "Symbol extends past end of block");

    auto *Sym = Allocator.Allocate<Symbol>();

    new (Sym) Symbol(Base, Offset, StringRef(), Size, Linkage::Strong,

                     Scope::Local, IsLive, IsCallable);

    return *Sym;

  }

  static Symbol &constructNamedDef(BumpPtrAllocator &Allocator, Block &Base,

                                   orc::ExecutorAddrDiff Offset, StringRef Name,

                                   orc::ExecutorAddrDiff Size, Linkage L,

                                   Scope S, bool IsLive, bool IsCallable) {

    assert((Offset + Size) <= Base.getSize() &&

           "Symbol extends past end of block");

    assert(!Name.empty() && "Name cannot be empty");

    auto *Sym = Allocator.Allocate<Symbol>();

    new (Sym) Symbol(Base, Offset, Name, Size, L, S, IsLive, IsCallable);

    return *Sym;

  }

public:

  /// Create a null Symbol. This allows Symbols to be default initialized for

  /// use in containers (e.g. as map values). Null symbols are only useful for

  /// assigning to.

  Symbol() = default;

  // Symbols are not movable or copyable.

  Symbol(const Symbol &) = delete;

  Symbol &operator=(const Symbol &) = delete;

  Symbol(Symbol &&) = delete;

  Symbol &operator=(Symbol &&) = delete;

  /// Returns true if this symbol has a name.

  bool hasName() const { return !Name.empty(); }

  /// Returns the name of this symbol (empty if the symbol is anonymous).

  StringRef getName() const {

    assert((!Name.empty() || getScope() == Scope::Local) &&

           "Anonymous symbol has non-local scope");

    return Name;

  }

  /// Rename this symbol. The client is responsible for updating scope and

  /// linkage if this name-change requires it.

  void setName(StringRef Name) { this->Name = Name; }

  /// Returns true if this Symbol has content (potentially) defined within this

  /// object file (i.e. is anything but an external or absolute symbol).

  bool isDefined() const {

    assert(Base && "Attempt to access null symbol");

    return Base->isDefined();

  }

  /// Returns true if this symbol is live (i.e. should be treated as a root for

  /// dead stripping).

  bool isLive() const {

    assert(Base && "Attempting to access null symbol");

    return IsLive;

  }

  /// Set this symbol's live bit.

  void setLive(bool IsLive) { this->IsLive = IsLive; }

  /// Returns true is this symbol is callable.

  bool isCallable() const { return IsCallable; }

  /// Set this symbol's callable bit.

  void setCallable(bool IsCallable) { this->IsCallable = IsCallable; }

  /// Returns true if the underlying addressable is an unresolved external.

  bool isExternal() const {

    assert(Base && "Attempt to access null symbol");

    return !Base->isDefined() && !Base->isAbsolute();

  }

  /// Returns true if the underlying addressable is an absolute symbol.

  bool isAbsolute() const {

    assert(Base && "Attempt to access null symbol");

    return Base->isAbsolute();

  }

  /// Return the addressable that this symbol points to.

  Addressable &getAddressable() {

    assert(Base && "Cannot get underlying addressable for null symbol");

    return *Base;

  }

  /// Return the addressable that this symbol points to.

  const Addressable &getAddressable() const {

    assert(Base && "Cannot get underlying addressable for null symbol");

    return *Base;

  }

  /// Return the Block for this Symbol (Symbol must be defined).

  Block &getBlock() {

    assert(Base && "Cannot get block for null symbol");

    assert(Base->isDefined() && "Not a defined symbol");

    return static_cast<Block &>(*Base);

  }

  /// Return the Block for this Symbol (Symbol must be defined).

  const Block &getBlock() const {

    assert(Base && "Cannot get block for null symbol");

    assert(Base->isDefined() && "Not a defined symbol");

    return static_cast<const Block &>(*Base);

  }

  /// Returns the offset for this symbol within the underlying addressable.

  orc::ExecutorAddrDiff getOffset() const { return Offset; }

  /// Returns the address of this symbol.

  orc::ExecutorAddr getAddress() const { return Base->getAddress() + Offset; }

  /// Returns the size of this symbol.

  orc::ExecutorAddrDiff getSize() const { return Size; }

  /// Set the size of this symbol.

  void setSize(orc::ExecutorAddrDiff Size) {

    assert(Base && "Cannot set size for null Symbol");

    assert((Size == 0 || Base->isDefined()) &&

           "Non-zero size can only be set for defined symbols");

    assert((Offset + Size <= static_cast<const Block &>(*Base).getSize()) &&

           "Symbol size cannot extend past the end of its containing block");

    this->Size = Size;

  }

  /// Returns the address range of this symbol.

  orc::ExecutorAddrRange getRange() const {

    return orc::ExecutorAddrRange(getAddress(), getSize());

  }

  /// Returns true if this symbol is backed by a zero-fill block.

  /// This method may only be called on defined symbols.

  bool isSymbolZeroFill() const { return getBlock().isZeroFill(); }

  /// Returns the content in the underlying block covered by this symbol.

  /// This method may only be called on defined non-zero-fill symbols.

  ArrayRef<char> getSymbolContent() const {

    return getBlock().getContent().slice(Offset, Size);

  }

  /// Get the linkage for this Symbol.

  Linkage getLinkage() const { return static_cast<Linkage>(L); }

  /// Set the linkage for this Symbol.

  void setLinkage(Linkage L) {

    assert((L == Linkage::Strong || (!Base->isAbsolute() && !Name.empty())) &&

           "Linkage can only be applied to defined named symbols");

    this->L = static_cast<uint8_t>(L);

  }

  /// Get the visibility for this Symbol.

  Scope getScope() const { return static_cast<Scope>(S); }

  /// Set the visibility for this Symbol.

  void setScope(Scope S) {

    assert((!Name.empty() || S == Scope::Local) &&

           "Can not set anonymous symbol to non-local scope");

    assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) &&

           "Invalid visibility for symbol type");

    this->S = static_cast<uint8_t>(S);

  }

  /// Returns true if this is a weakly referenced external symbol.

  /// This method may only be called on external symbols.

  bool isWeaklyReferenced() const {

    assert(isExternal() && "isWeaklyReferenced called on non-external");

    return WeakRef;

  }

  /// Set the WeaklyReferenced value for this symbol.

  /// This method may only be called on external symbols.

  void setWeaklyReferenced(bool WeakRef) {

    assert(isExternal() && "setWeaklyReferenced called on non-external");

    this->WeakRef = WeakRef;

  }

private:

  void makeExternal(Addressable &A) {

    assert(!A.isDefined() && !A.isAbsolute() &&

           "Attempting to make external with defined or absolute block");

    Base = &A;

    Offset = 0;

    setScope(Scope::Default);

    IsLive = 0;

    // note: Size, Linkage and IsCallable fields left unchanged.

  }

  void makeAbsolute(Addressable &A) {

    assert(!A.isDefined() && A.isAbsolute() &&

           "Attempting to make absolute with defined or external block");

    Base = &A;

    Offset = 0;

  }

  void setBlock(Block &B) { Base = &B; }

  void setOffset(orc::ExecutorAddrDiff NewOffset) {

    assert(NewOffset <= MaxOffset && "Offset out of range");

    Offset = NewOffset;

  }

  static constexpr uint64_t MaxOffset = (1ULL << 59) - 1;

  // FIXME: A char* or SymbolStringPtr may pack better.

  StringRef Name;

  Addressable *Base = nullptr;

  uint64_t Offset : 58;

  uint64_t L : 1;

  uint64_t S : 2;

  uint64_t IsLive : 1;

  uint64_t IsCallable : 1;

  uint64_t WeakRef : 1;

  size_t Size = 0;

};

raw_ostream &operator<<(raw_ostream &OS, const Symbol &A);

void printEdge(raw_ostream &OS, const Block &B, const Edge &E,

               StringRef EdgeKindName);

/// Represents an object file section.

class Section {

  friend class LinkGraph;

private:

  Section(StringRef Name, orc::MemProt Prot, SectionOrdinal SecOrdinal)

      : Name(Name), Prot(Prot), SecOrdinal(SecOrdinal) {}

  using SymbolSet = DenseSet<Symbol *>;

  using BlockSet = DenseSet<Block *>;

public:

  using symbol_iterator = SymbolSet::iterator;

  using const_symbol_iterator = SymbolSet::const_iterator;

  using block_iterator = BlockSet::iterator;

  using const_block_iterator = BlockSet::const_iterator;

  ~Section();

  // Sections are not movable or copyable.

  Section(const Section &) = delete;

  Section &operator=(const Section &) = delete;

  Section(Section &&) = delete;

  Section &operator=(Section &&) = delete;

  /// Returns the name of this section.

  StringRef getName() const { return Name; }

  /// Returns the protection flags for this section.

  orc::MemProt getMemProt() const { return Prot; }

  /// Set the protection flags for this section.

  void setMemProt(orc::MemProt Prot) { this->Prot = Prot; }

  /// Get the deallocation policy for this section.

  orc::MemDeallocPolicy getMemDeallocPolicy() const { return MDP; }

  /// Set the deallocation policy for this section.

  void setMemDeallocPolicy(orc::MemDeallocPolicy MDP) { this->MDP = MDP; }

  /// Returns the ordinal for this section.

  SectionOrdinal getOrdinal() const { return SecOrdinal; }

  /// Returns an iterator over the blocks defined in this section.

  iterator_range<block_iterator> blocks() {

    return make_range(Blocks.begin(), Blocks.end());

  }

  /// Returns an iterator over the blocks defined in this section.

  iterator_range<const_block_iterator> blocks() const {

    return make_range(Blocks.begin(), Blocks.end());

  }

  /// Returns the number of blocks in this section.

  BlockSet::size_type blocks_size() const { return Blocks.size(); }

  /// Returns an iterator over the symbols defined in this section.

  iterator_range<symbol_iterator> symbols() {

    return make_range(Symbols.begin(), Symbols.end());

  }

  /// Returns an iterator over the symbols defined in this section.

  iterator_range<const_symbol_iterator> symbols() const {

    return make_range(Symbols.begin(), Symbols.end());

  }

  /// Return the number of symbols in this section.

  SymbolSet::size_type symbols_size() const { return Symbols.size(); }

private:

  void addSymbol(Symbol &Sym) {

    assert(!Symbols.count(&Sym) && "Symbol is already in this section");

    Symbols.insert(&Sym);

  }

  void removeSymbol(Symbol &Sym) {

    assert(Symbols.count(&Sym) && "symbol is not in this section");

    Symbols.erase(&Sym);

  }

  void addBlock(Block &B) {

    assert(!Blocks.count(&B) && "Block is already in this section");

    Blocks.insert(&B);

  }

  void removeBlock(Block &B) {

    assert(Blocks.count(&B) && "Block is not in this section");

    Blocks.erase(&B);

  }

  void transferContentTo(Section &DstSection) {

    if (&DstSection == this)