LLVM  15.0.0git
JITLink.h
Go to the documentation of this file.
1 //===------------ JITLink.h - JIT linker functionality ----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Contains generic JIT-linker types.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H
14 #define LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H
15 
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/Optional.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Triple.h"
24 #include "llvm/Support/Allocator.h"
25 #include "llvm/Support/Endian.h"
26 #include "llvm/Support/Error.h"
30 
31 #include <map>
32 #include <string>
33 #include <system_error>
34 
35 namespace llvm {
36 namespace jitlink {
37 
38 class LinkGraph;
39 class Symbol;
40 class Section;
41 
42 /// Base class for errors originating in JIT linker, e.g. missing relocation
43 /// support.
44 class JITLinkError : public ErrorInfo<JITLinkError> {
45 public:
46  static char ID;
47 
48  JITLinkError(Twine ErrMsg) : ErrMsg(ErrMsg.str()) {}
49 
50  void log(raw_ostream &OS) const override;
51  const std::string &getErrorMessage() const { return ErrMsg; }
52  std::error_code convertToErrorCode() const override;
53 
54 private:
55  std::string ErrMsg;
56 };
57 
58 /// Represents fixups and constraints in the LinkGraph.
59 class Edge {
60 public:
61  using Kind = uint8_t;
62 
64  Invalid, // Invalid edge value.
65  FirstKeepAlive, // Keeps target alive. Offset/addend zero.
66  KeepAlive = FirstKeepAlive, // Tag first edge kind that preserves liveness.
67  FirstRelocation // First architecture specific relocation.
68  };
69 
70  using OffsetT = uint32_t;
71  using AddendT = int64_t;
72 
73  Edge(Kind K, OffsetT Offset, Symbol &Target, AddendT Addend)
74  : Target(&Target), Offset(Offset), Addend(Addend), K(K) {}
75 
76  OffsetT getOffset() const { return Offset; }
77  void setOffset(OffsetT Offset) { this->Offset = Offset; }
78  Kind getKind() const { return K; }
79  void setKind(Kind K) { this->K = K; }
80  bool isRelocation() const { return K >= FirstRelocation; }
81  Kind getRelocation() const {
82  assert(isRelocation() && "Not a relocation edge");
83  return K - FirstRelocation;
84  }
85  bool isKeepAlive() const { return K >= FirstKeepAlive; }
86  Symbol &getTarget() const { return *Target; }
87  void setTarget(Symbol &Target) { this->Target = &Target; }
88  AddendT getAddend() const { return Addend; }
89  void setAddend(AddendT Addend) { this->Addend = Addend; }
90 
91 private:
92  Symbol *Target = nullptr;
93  OffsetT Offset = 0;
94  AddendT Addend = 0;
95  Kind K = 0;
96 };
97 
98 /// Returns the string name of the given generic edge kind, or "unknown"
99 /// otherwise. Useful for debugging.
100 const char *getGenericEdgeKindName(Edge::Kind K);
101 
102 /// Base class for Addressable entities (externals, absolutes, blocks).
103 class Addressable {
104  friend class LinkGraph;
105 
106 protected:
107  Addressable(orc::ExecutorAddr Address, bool IsDefined)
108  : Address(Address), IsDefined(IsDefined), IsAbsolute(false) {}
109 
111  : Address(Address), IsDefined(false), IsAbsolute(true) {
112  assert(!(IsDefined && IsAbsolute) &&
113  "Block cannot be both defined and absolute");
114  }
115 
116 public:
117  Addressable(const Addressable &) = delete;
118  Addressable &operator=(const Addressable &) = default;
119  Addressable(Addressable &&) = delete;
120  Addressable &operator=(Addressable &&) = default;
121 
122  orc::ExecutorAddr getAddress() const { return Address; }
123  void setAddress(orc::ExecutorAddr Address) { this->Address = Address; }
124 
125  /// Returns true if this is a defined addressable, in which case you
126  /// can downcast this to a Block.
127  bool isDefined() const { return static_cast<bool>(IsDefined); }
128  bool isAbsolute() const { return static_cast<bool>(IsAbsolute); }
129 
130 private:
131  void setAbsolute(bool IsAbsolute) {
132  assert(!IsDefined && "Cannot change the Absolute flag on a defined block");
133  this->IsAbsolute = IsAbsolute;
134  }
135 
136  orc::ExecutorAddr Address;
137  uint64_t IsDefined : 1;
138  uint64_t IsAbsolute : 1;
139 
140 protected:
141  // bitfields for Block, allocated here to improve packing.
145 };
146 
147 using SectionOrdinal = unsigned;
148 
149 /// An Addressable with content and edges.
150 class Block : public Addressable {
151  friend class LinkGraph;
152 
153 private:
154  /// Create a zero-fill defined addressable.
156  uint64_t Alignment, uint64_t AlignmentOffset)
157  : Addressable(Address, true), Parent(&Parent), Size(Size) {
158  assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
159  assert(AlignmentOffset < Alignment &&
160  "Alignment offset cannot exceed alignment");
161  assert(AlignmentOffset <= MaxAlignmentOffset &&
162  "Alignment offset exceeds maximum");
163  ContentMutable = false;
164  P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
165  this->AlignmentOffset = AlignmentOffset;
166  }
167 
168  /// Create a defined addressable for the given content.
169  /// The Content is assumed to be non-writable, and will be copied when
170  /// mutations are required.
172  uint64_t Alignment, uint64_t AlignmentOffset)
173  : Addressable(Address, true), Parent(&Parent), Data(Content.data()),
174  Size(Content.size()) {
175  assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
176  assert(AlignmentOffset < Alignment &&
177  "Alignment offset cannot exceed alignment");
178  assert(AlignmentOffset <= MaxAlignmentOffset &&
179  "Alignment offset exceeds maximum");
180  ContentMutable = false;
181  P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
182  this->AlignmentOffset = AlignmentOffset;
183  }
184 
185  /// Create a defined addressable for the given content.
186  /// The content is assumed to be writable, and the caller is responsible
187  /// for ensuring that it lives for the duration of the Block's lifetime.
188  /// The standard way to achieve this is to allocate it on the Graph's
189  /// allocator.
190  Block(Section &Parent, MutableArrayRef<char> Content,
192  : Addressable(Address, true), Parent(&Parent), Data(Content.data()),
193  Size(Content.size()) {
194  assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
195  assert(AlignmentOffset < Alignment &&
196  "Alignment offset cannot exceed alignment");
197  assert(AlignmentOffset <= MaxAlignmentOffset &&
198  "Alignment offset exceeds maximum");
199  ContentMutable = true;
200  P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
201  this->AlignmentOffset = AlignmentOffset;
202  }
203 
204 public:
205  using EdgeVector = std::vector<Edge>;
206  using edge_iterator = EdgeVector::iterator;
207  using const_edge_iterator = EdgeVector::const_iterator;
208 
209  Block(const Block &) = delete;
210  Block &operator=(const Block &) = delete;
211  Block(Block &&) = delete;
212  Block &operator=(Block &&) = delete;
213 
214  /// Return the parent section for this block.
215  Section &getSection() const { return *Parent; }
216 
217  /// Returns true if this is a zero-fill block.
218  ///
219  /// If true, getSize is callable but getContent is not (the content is
220  /// defined to be a sequence of zero bytes of length Size).
221  bool isZeroFill() const { return !Data; }
222 
223  /// Returns the size of this defined addressable.
224  size_t getSize() const { return Size; }
225 
226  /// Returns the address range of this defined addressable.
229  }
230 
231  /// Get the content for this block. Block must not be a zero-fill block.
233  assert(Data && "Block does not contain content");
234  return ArrayRef<char>(Data, Size);
235  }
236 
237  /// Set the content for this block.
238  /// Caller is responsible for ensuring the underlying bytes are not
239  /// deallocated while pointed to by this block.
241  assert(Content.data() && "Setting null content");
242  Data = Content.data();
243  Size = Content.size();
244  ContentMutable = false;
245  }
246 
247  /// Get mutable content for this block.
248  ///
249  /// If this Block's content is not already mutable this will trigger a copy
250  /// of the existing immutable content to a new, mutable buffer allocated using
251  /// LinkGraph::allocateContent.
253 
254  /// Get mutable content for this block.
255  ///
256  /// This block's content must already be mutable. It is a programmatic error
257  /// to call this on a block with immutable content -- consider using
258  /// getMutableContent instead.
260  assert(Data && "Block does not contain content");
261  assert(ContentMutable && "Content is not mutable");
262  return MutableArrayRef<char>(const_cast<char *>(Data), Size);
263  }
264 
265  /// Set mutable content for this block.
266  ///
267  /// The caller is responsible for ensuring that the memory pointed to by
268  /// MutableContent is not deallocated while pointed to by this block.
270  assert(MutableContent.data() && "Setting null content");
271  Data = MutableContent.data();
272  Size = MutableContent.size();
273  ContentMutable = true;
274  }
275 
276  /// Returns true if this block's content is mutable.
277  ///
278  /// This is primarily useful for asserting that a block is already in a
279  /// mutable state prior to modifying the content. E.g. when applying
280  /// fixups we expect the block to already be mutable as it should have been
281  /// copied to working memory.
282  bool isContentMutable() const { return ContentMutable; }
283 
284  /// Get the alignment for this content.
285  uint64_t getAlignment() const { return 1ull << P2Align; }
286 
287  /// Set the alignment for this content.
288  void setAlignment(uint64_t Alignment) {
289  assert(isPowerOf2_64(Alignment) && "Alignment must be a power of two");
290  P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
291  }
292 
293  /// Get the alignment offset for this content.
295 
296  /// Set the alignment offset for this content.
298  assert(AlignmentOffset < (1ull << P2Align) &&
299  "Alignment offset can't exceed alignment");
300  this->AlignmentOffset = AlignmentOffset;
301  }
302 
303  /// Add an edge to this block.
305  Edge::AddendT Addend) {
306  assert(!isZeroFill() && "Adding edge to zero-fill block?");
307  Edges.push_back(Edge(K, Offset, Target, Addend));
308  }
309 
310  /// Add an edge by copying an existing one. This is typically used when
311  /// moving edges between blocks.
312  void addEdge(const Edge &E) { Edges.push_back(E); }
313 
314  /// Return the list of edges attached to this content.
316  return make_range(Edges.begin(), Edges.end());
317  }
318 
319  /// Returns the list of edges attached to this content.
321  return make_range(Edges.begin(), Edges.end());
322  }
323 
324  /// Return the size of the edges list.
325  size_t edges_size() const { return Edges.size(); }
326 
327  /// Returns true if the list of edges is empty.
328  bool edges_empty() const { return Edges.empty(); }
329 
330  /// Remove the edge pointed to by the given iterator.
331  /// Returns an iterator to the new next element.
332  edge_iterator removeEdge(edge_iterator I) { return Edges.erase(I); }
333 
334  /// Returns the address of the fixup for the given edge, which is equal to
335  /// this block's address plus the edge's offset.
337  return getAddress() + E.getOffset();
338  }
339 
340 private:
341  static constexpr uint64_t MaxAlignmentOffset = (1ULL << 56) - 1;
342 
343  void setSection(Section &Parent) { this->Parent = &Parent; }
344 
345  Section *Parent;
346  const char *Data = nullptr;
347  size_t Size = 0;
348  std::vector<Edge> Edges;
349 };
350 
351 // Align an address to conform with block alignment requirements.
353  uint64_t Delta = (B.getAlignmentOffset() - Addr) % B.getAlignment();
354  return Addr + Delta;
355 }
356 
357 // Align a orc::ExecutorAddr to conform with block alignment requirements.
359  return orc::ExecutorAddr(alignToBlock(Addr.getValue(), B));
360 }
361 
362 /// Describes symbol linkage. This can be used to make resolve definition
363 /// clashes.
364 enum class Linkage : uint8_t {
365  Strong,
366  Weak,
367 };
368 
369 /// For errors and debugging output.
370 const char *getLinkageName(Linkage L);
371 
372 /// Defines the scope in which this symbol should be visible:
373 /// Default -- Visible in the public interface of the linkage unit.
374 /// Hidden -- Visible within the linkage unit, but not exported from it.
375 /// Local -- Visible only within the LinkGraph.
376 enum class Scope : uint8_t {
377  Default,
378  Hidden,
379  Local
380 };
381 
382 /// For debugging output.
383 const char *getScopeName(Scope S);
384 
385 raw_ostream &operator<<(raw_ostream &OS, const Block &B);
386 
387 /// Symbol representation.
388 ///
389 /// Symbols represent locations within Addressable objects.
390 /// They can be either Named or Anonymous.
391 /// Anonymous symbols have neither linkage nor visibility, and must point at
392 /// ContentBlocks.
393 /// Named symbols may be in one of four states:
394 /// - Null: Default initialized. Assignable, but otherwise unusable.
395 /// - Defined: Has both linkage and visibility and points to a ContentBlock
396 /// - Common: Has both linkage and visibility, points to a null Addressable.
397 /// - External: Has neither linkage nor visibility, points to an external
398 /// Addressable.
399 ///
400 class Symbol {
401  friend class LinkGraph;
402 
403 private:
405  orc::ExecutorAddrDiff Size, Linkage L, Scope S, bool IsLive,
406  bool IsCallable)
407  : Name(Name), Base(&Base), Offset(Offset), Size(Size) {
408  assert(Offset <= MaxOffset && "Offset out of range");
409  setLinkage(L);
410  setScope(S);
411  setLive(IsLive);
412  setCallable(IsCallable);
413  }
414 
415  static Symbol &constructCommon(void *SymStorage, Block &Base, StringRef Name,
417  bool IsLive) {
418  assert(SymStorage && "Storage cannot be null");
419  assert(!Name.empty() && "Common symbol name cannot be empty");
420  assert(Base.isDefined() &&
421  "Cannot create common symbol from undefined block");
422  assert(static_cast<Block &>(Base).getSize() == Size &&
423  "Common symbol size should match underlying block size");
424  auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
425  new (Sym) Symbol(Base, 0, Name, Size, Linkage::Weak, S, IsLive, false);
426  return *Sym;
427  }
428 
429  static Symbol &constructExternal(void *SymStorage, Addressable &Base,
431  Linkage L) {
432  assert(SymStorage && "Storage cannot be null");
433  assert(!Base.isDefined() &&
434  "Cannot create external symbol from defined block");
435  assert(!Name.empty() && "External symbol name cannot be empty");
436  auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
437  new (Sym) Symbol(Base, 0, Name, Size, L, Scope::Default, false, false);
438  return *Sym;
439  }
440 
441  static Symbol &constructAbsolute(void *SymStorage, Addressable &Base,
442  StringRef Name, orc::ExecutorAddrDiff Size,
443  Linkage L, Scope S, bool IsLive) {
444  assert(SymStorage && "Storage cannot be null");
445  assert(!Base.isDefined() &&
446  "Cannot create absolute symbol from a defined block");
447  auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
448  new (Sym) Symbol(Base, 0, Name, Size, L, S, IsLive, false);
449  return *Sym;
450  }
451 
452  static Symbol &constructAnonDef(void *SymStorage, Block &Base,
454  orc::ExecutorAddrDiff Size, bool IsCallable,
455  bool IsLive) {
456  assert(SymStorage && "Storage cannot be null");
457  assert((Offset + Size) <= Base.getSize() &&
458  "Symbol extends past end of block");
459  auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
460  new (Sym) Symbol(Base, Offset, StringRef(), Size, Linkage::Strong,
461  Scope::Local, IsLive, IsCallable);
462  return *Sym;
463  }
464 
465  static Symbol &constructNamedDef(void *SymStorage, Block &Base,
466  orc::ExecutorAddrDiff Offset, StringRef Name,
468  Scope S, bool IsLive, bool IsCallable) {
469  assert(SymStorage && "Storage cannot be null");
470  assert((Offset + Size) <= Base.getSize() &&
471  "Symbol extends past end of block");
472  assert(!Name.empty() && "Name cannot be empty");
473  auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
474  new (Sym) Symbol(Base, Offset, Name, Size, L, S, IsLive, IsCallable);
475  return *Sym;
476  }
477 
478 public:
479  /// Create a null Symbol. This allows Symbols to be default initialized for
480  /// use in containers (e.g. as map values). Null symbols are only useful for
481  /// assigning to.
482  Symbol() = default;
483 
484  // Symbols are not movable or copyable.
485  Symbol(const Symbol &) = delete;
486  Symbol &operator=(const Symbol &) = delete;
487  Symbol(Symbol &&) = delete;
488  Symbol &operator=(Symbol &&) = delete;
489 
490  /// Returns true if this symbol has a name.
491  bool hasName() const { return !Name.empty(); }
492 
493  /// Returns the name of this symbol (empty if the symbol is anonymous).
494  StringRef getName() const {
495  assert((!Name.empty() || getScope() == Scope::Local) &&
496  "Anonymous symbol has non-local scope");
497  return Name;
498  }
499 
500  /// Rename this symbol. The client is responsible for updating scope and
501  /// linkage if this name-change requires it.
502  void setName(StringRef Name) { this->Name = Name; }
503 
504  /// Returns true if this Symbol has content (potentially) defined within this
505  /// object file (i.e. is anything but an external or absolute symbol).
506  bool isDefined() const {
507  assert(Base && "Attempt to access null symbol");
508  return Base->isDefined();
509  }
510 
511  /// Returns true if this symbol is live (i.e. should be treated as a root for
512  /// dead stripping).
513  bool isLive() const {
514  assert(Base && "Attempting to access null symbol");
515  return IsLive;
516  }
517 
518  /// Set this symbol's live bit.
519  void setLive(bool IsLive) { this->IsLive = IsLive; }
520 
521  /// Returns true is this symbol is callable.
522  bool isCallable() const { return IsCallable; }
523 
524  /// Set this symbol's callable bit.
525  void setCallable(bool IsCallable) { this->IsCallable = IsCallable; }
526 
527  /// Returns true if the underlying addressable is an unresolved external.
528  bool isExternal() const {
529  assert(Base && "Attempt to access null symbol");
530  return !Base->isDefined() && !Base->isAbsolute();
531  }
532 
533  /// Returns true if the underlying addressable is an absolute symbol.
534  bool isAbsolute() const {
535  assert(Base && "Attempt to access null symbol");
536  return Base->isAbsolute();
537  }
538 
539  /// Return the addressable that this symbol points to.
541  assert(Base && "Cannot get underlying addressable for null symbol");
542  return *Base;
543  }
544 
545  /// Return the addressable that thsi symbol points to.
546  const Addressable &getAddressable() const {
547  assert(Base && "Cannot get underlying addressable for null symbol");
548  return *Base;
549  }
550 
551  /// Return the Block for this Symbol (Symbol must be defined).
553  assert(Base && "Cannot get block for null symbol");
554  assert(Base->isDefined() && "Not a defined symbol");
555  return static_cast<Block &>(*Base);
556  }
557 
558  /// Return the Block for this Symbol (Symbol must be defined).
559  const Block &getBlock() const {
560  assert(Base && "Cannot get block for null symbol");
561  assert(Base->isDefined() && "Not a defined symbol");
562  return static_cast<const Block &>(*Base);
563  }
564 
565  /// Returns the offset for this symbol within the underlying addressable.
567 
568  /// Returns the address of this symbol.
569  orc::ExecutorAddr getAddress() const { return Base->getAddress() + Offset; }
570 
571  /// Returns the size of this symbol.
572  orc::ExecutorAddrDiff getSize() const { return Size; }
573 
574  /// Set the size of this symbol.
576  assert(Base && "Cannot set size for null Symbol");
577  assert((Size == 0 || Base->isDefined()) &&
578  "Non-zero size can only be set for defined symbols");
579  assert((Offset + Size <= static_cast<const Block &>(*Base).getSize()) &&
580  "Symbol size cannot extend past the end of its containing block");
581  this->Size = Size;
582  }
583 
584  /// Returns the address range of this symbol.
587  }
588 
589  /// Returns true if this symbol is backed by a zero-fill block.
590  /// This method may only be called on defined symbols.
591  bool isSymbolZeroFill() const { return getBlock().isZeroFill(); }
592 
593  /// Returns the content in the underlying block covered by this symbol.
594  /// This method may only be called on defined non-zero-fill symbols.
596  return getBlock().getContent().slice(Offset, Size);
597  }
598 
599  /// Get the linkage for this Symbol.
600  Linkage getLinkage() const { return static_cast<Linkage>(L); }
601 
602  /// Set the linkage for this Symbol.
603  void setLinkage(Linkage L) {
604  assert((L == Linkage::Strong || (!Base->isAbsolute() && !Name.empty())) &&
605  "Linkage can only be applied to defined named symbols");
606  this->L = static_cast<uint8_t>(L);
607  }
608 
609  /// Get the visibility for this Symbol.
610  Scope getScope() const { return static_cast<Scope>(S); }
611 
612  /// Set the visibility for this Symbol.
613  void setScope(Scope S) {
614  assert((!Name.empty() || S == Scope::Local) &&
615  "Can not set anonymous symbol to non-local scope");
616  assert((S == Scope::Default || Base->isDefined() || Base->isAbsolute()) &&
617  "Invalid visibility for symbol type");
618  this->S = static_cast<uint8_t>(S);
619  }
620 
621 private:
622  void makeExternal(Addressable &A) {
623  assert(!A.isDefined() && !A.isAbsolute() &&
624  "Attempting to make external with defined or absolute block");
625  Base = &A;
626  Offset = 0;
628  IsLive = 0;
629  // note: Size, Linkage and IsCallable fields left unchanged.
630  }
631 
632  void makeAbsolute(Addressable &A) {
633  assert(!A.isDefined() && A.isAbsolute() &&
634  "Attempting to make absolute with defined or external block");
635  Base = &A;
636  Offset = 0;
637  }
638 
639  void setBlock(Block &B) { Base = &B; }
640 
641  void setOffset(orc::ExecutorAddrDiff NewOffset) {
642  assert(NewOffset <= MaxOffset && "Offset out of range");
643  Offset = NewOffset;
644  }
645 
646  static constexpr uint64_t MaxOffset = (1ULL << 59) - 1;
647 
648  // FIXME: A char* or SymbolStringPtr may pack better.
649  StringRef Name;
650  Addressable *Base = nullptr;
651  uint64_t Offset : 59;
652  uint64_t L : 1;
653  uint64_t S : 2;
654  uint64_t IsLive : 1;
655  uint64_t IsCallable : 1;
657 };
658 
659 raw_ostream &operator<<(raw_ostream &OS, const Symbol &A);
660 
661 void printEdge(raw_ostream &OS, const Block &B, const Edge &E,
662  StringRef EdgeKindName);
663 
664 /// Represents an object file section.
665 class Section {
666  friend class LinkGraph;
667 
668 private:
669  Section(StringRef Name, MemProt Prot, SectionOrdinal SecOrdinal)
670  : Name(Name), Prot(Prot), SecOrdinal(SecOrdinal) {}
671 
672  using SymbolSet = DenseSet<Symbol *>;
673  using BlockSet = DenseSet<Block *>;
674 
675 public:
678 
681 
682  ~Section();
683 
684  // Sections are not movable or copyable.
685  Section(const Section &) = delete;
686  Section &operator=(const Section &) = delete;
687  Section(Section &&) = delete;
688  Section &operator=(Section &&) = delete;
689 
690  /// Returns the name of this section.
691  StringRef getName() const { return Name; }
692 
693  /// Returns the protection flags for this section.
694  MemProt getMemProt() const { return Prot; }
695 
696  /// Set the protection flags for this section.
697  void setMemProt(MemProt Prot) { this->Prot = Prot; }
698 
699  /// Get the deallocation policy for this section.
700  MemDeallocPolicy getMemDeallocPolicy() const { return MDP; }
701 
702  /// Set the deallocation policy for this section.
703  void setMemDeallocPolicy(MemDeallocPolicy MDP) { this->MDP = MDP; }
704 
705  /// Returns the ordinal for this section.
706  SectionOrdinal getOrdinal() const { return SecOrdinal; }
707 
708  /// Returns an iterator over the blocks defined in this section.
710  return make_range(Blocks.begin(), Blocks.end());
711  }
712 
713  /// Returns an iterator over the blocks defined in this section.
715  return make_range(Blocks.begin(), Blocks.end());
716  }
717 
718  /// Returns the number of blocks in this section.
719  BlockSet::size_type blocks_size() const { return Blocks.size(); }
720 
721  /// Returns an iterator over the symbols defined in this section.
723  return make_range(Symbols.begin(), Symbols.end());
724  }
725 
726  /// Returns an iterator over the symbols defined in this section.
728  return make_range(Symbols.begin(), Symbols.end());
729  }
730 
731  /// Return the number of symbols in this section.
732  SymbolSet::size_type symbols_size() const { return Symbols.size(); }
733 
734 private:
735  void addSymbol(Symbol &Sym) {
736  assert(!Symbols.count(&Sym) && "Symbol is already in this section");
737  Symbols.insert(&Sym);
738  }
739 
740  void removeSymbol(Symbol &Sym) {
741  assert(Symbols.count(&Sym) && "symbol is not in this section");
742  Symbols.erase(&Sym);
743  }
744 
745  void addBlock(Block &B) {
746  assert(!Blocks.count(&B) && "Block is already in this section");
747  Blocks.insert(&B);
748  }
749 
750  void removeBlock(Block &B) {
751  assert(Blocks.count(&B) && "Block is not in this section");
752  Blocks.erase(&B);
753  }
754 
755  void transferContentTo(Section &DstSection) {
756  if (&DstSection == this)
757  return;
758  for (auto *S : Symbols)
759  DstSection.addSymbol(*S);
760  for (auto *B : Blocks)
761  DstSection.addBlock(*B);
762  Symbols.clear();
763  Blocks.clear();
764  }
765 
766  StringRef Name;
767  MemProt Prot;
769  SectionOrdinal SecOrdinal = 0;
770  BlockSet Blocks;
771  SymbolSet Symbols;
772 };
773 
774 /// Represents a section address range via a pair of Block pointers
775 /// to the first and last Blocks in the section.
777 public:
778  SectionRange() = default;
779  SectionRange(const Section &Sec) {
780  if (llvm::empty(Sec.blocks()))
781  return;
782  First = Last = *Sec.blocks().begin();
783  for (auto *B : Sec.blocks()) {
784  if (B->getAddress() < First->getAddress())
785  First = B;
786  if (B->getAddress() > Last->getAddress())
787  Last = B;
788  }
789  }
790  Block *getFirstBlock() const {
791  assert((!Last || First) && "First can not be null if end is non-null");
792  return First;
793  }
794  Block *getLastBlock() const {
795  assert((First || !Last) && "Last can not be null if start is non-null");
796  return Last;
797  }
798  bool empty() const {
799  assert((First || !Last) && "Last can not be null if start is non-null");
800  return !First;
801  }
803  return First ? First->getAddress() : orc::ExecutorAddr();
804  }
806  return Last ? Last->getAddress() + Last->getSize() : orc::ExecutorAddr();
807  }
808  orc::ExecutorAddrDiff getSize() const { return getEnd() - getStart(); }
809 
812  }
813 
814 private:
815  Block *First = nullptr;
816  Block *Last = nullptr;
817 };
818 
819 class LinkGraph {
820 private:
821  using SectionList = std::vector<std::unique_ptr<Section>>;
823  using BlockSet = DenseSet<Block *>;
824 
825  template <typename... ArgTs>
826  Addressable &createAddressable(ArgTs &&... Args) {
827  Addressable *A =
828  reinterpret_cast<Addressable *>(Allocator.Allocate<Addressable>());
829  new (A) Addressable(std::forward<ArgTs>(Args)...);
830  return *A;
831  }
832 
833  void destroyAddressable(Addressable &A) {
834  A.~Addressable();
835  Allocator.Deallocate(&A);
836  }
837 
838  template <typename... ArgTs> Block &createBlock(ArgTs &&... Args) {
839  Block *B = reinterpret_cast<Block *>(Allocator.Allocate<Block>());
840  new (B) Block(std::forward<ArgTs>(Args)...);
841  B->getSection().addBlock(*B);
842  return *B;
843  }
844 
845  void destroyBlock(Block &B) {
846  B.~Block();
847  Allocator.Deallocate(&B);
848  }
849 
850  void destroySymbol(Symbol &S) {
851  S.~Symbol();
852  Allocator.Deallocate(&S);
853  }
854 
855  static iterator_range<Section::block_iterator> getSectionBlocks(Section &S) {
856  return S.blocks();
857  }
858 
860  getSectionConstBlocks(Section &S) {
861  return S.blocks();
862  }
863 
865  getSectionSymbols(Section &S) {
866  return S.symbols();
867  }
868 
870  getSectionConstSymbols(Section &S) {
871  return S.symbols();
872  }
873 
874 public:
876 
879 
880  template <typename OuterItrT, typename InnerItrT, typename T,
881  iterator_range<InnerItrT> getInnerRange(
882  typename OuterItrT::reference)>
884  : public iterator_facade_base<
885  nested_collection_iterator<OuterItrT, InnerItrT, T, getInnerRange>,
886  std::forward_iterator_tag, T> {
887  public:
888  nested_collection_iterator() = default;
889 
890  nested_collection_iterator(OuterItrT OuterI, OuterItrT OuterE)
891  : OuterI(OuterI), OuterE(OuterE),
892  InnerI(getInnerBegin(OuterI, OuterE)) {
893  moveToNonEmptyInnerOrEnd();
894  }
895 
897  return (OuterI == RHS.OuterI) && (InnerI == RHS.InnerI);
898  }
899 
900  T operator*() const {
901  assert(InnerI != getInnerRange(*OuterI).end() && "Dereferencing end?");
902  return *InnerI;
903  }
904 
906  ++InnerI;
907  moveToNonEmptyInnerOrEnd();
908  return *this;
909  }
910 
911  private:
912  static InnerItrT getInnerBegin(OuterItrT OuterI, OuterItrT OuterE) {
913  return OuterI != OuterE ? getInnerRange(*OuterI).begin() : InnerItrT();
914  }
915 
916  void moveToNonEmptyInnerOrEnd() {
917  while (OuterI != OuterE && InnerI == getInnerRange(*OuterI).end()) {
918  ++OuterI;
919  InnerI = getInnerBegin(OuterI, OuterE);
920  }
921  }
922 
923  OuterItrT OuterI, OuterE;
924  InnerItrT InnerI;
925  };
926 
928  nested_collection_iterator<const_section_iterator,
930  getSectionSymbols>;
931 
935  getSectionConstSymbols>;
936 
939  Block *, getSectionBlocks>;
940 
941  using const_block_iterator =
944  getSectionConstBlocks>;
945 
946  using GetEdgeKindNameFunction = const char *(*)(Edge::Kind);
947 
948  LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
949  support::endianness Endianness,
950  GetEdgeKindNameFunction GetEdgeKindName)
951  : Name(std::move(Name)), TT(TT), PointerSize(PointerSize),
952  Endianness(Endianness), GetEdgeKindName(std::move(GetEdgeKindName)) {}
953 
954  LinkGraph(const LinkGraph &) = delete;
955  LinkGraph &operator=(const LinkGraph &) = delete;
956  LinkGraph(LinkGraph &&) = delete;
957  LinkGraph &operator=(LinkGraph &&) = delete;
958 
959  /// Returns the name of this graph (usually the name of the original
960  /// underlying MemoryBuffer).
961  const std::string &getName() const { return Name; }
962 
963  /// Returns the target triple for this Graph.
964  const Triple &getTargetTriple() const { return TT; }
965 
966  /// Returns the pointer size for use in this graph.
967  unsigned getPointerSize() const { return PointerSize; }
968 
969  /// Returns the endianness of content in this graph.
970  support::endianness getEndianness() const { return Endianness; }
971 
972  const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); }
973 
974  /// Allocate a mutable buffer of the given size using the LinkGraph's
975  /// allocator.
977  return {Allocator.Allocate<char>(Size), Size};
978  }
979 
980  /// Allocate a copy of the given string using the LinkGraph's allocator.
981  /// This can be useful when renaming symbols or adding new content to the
982  /// graph.
984  auto *AllocatedBuffer = Allocator.Allocate<char>(Source.size());
985  llvm::copy(Source, AllocatedBuffer);
986  return MutableArrayRef<char>(AllocatedBuffer, Source.size());
987  }
988 
989  /// Allocate a copy of the given string using the LinkGraph's allocator.
990  /// This can be useful when renaming symbols or adding new content to the
991  /// graph.
992  ///
993  /// Note: This Twine-based overload requires an extra string copy and an
994  /// extra heap allocation for large strings. The ArrayRef<char> overload
995  /// should be preferred where possible.
997  SmallString<256> TmpBuffer;
998  auto SourceStr = Source.toStringRef(TmpBuffer);
999  auto *AllocatedBuffer = Allocator.Allocate<char>(SourceStr.size());
1000  llvm::copy(SourceStr, AllocatedBuffer);
1001  return MutableArrayRef<char>(AllocatedBuffer, SourceStr.size());
1002  }
1003 
1004  /// Create a section with the given name, protection flags, and alignment.
1006  assert(llvm::find_if(Sections,
1007  [&](std::unique_ptr<Section> &Sec) {
1008  return Sec->getName() == Name;
1009  }) == Sections.end() &&
1010  "Duplicate section name");
1011  std::unique_ptr<Section> Sec(new Section(Name, Prot, Sections.size()));
1012  Sections.push_back(std::move(Sec));
1013  return *Sections.back();
1014  }
1015 
1016  /// Create a content block.
1018  orc::ExecutorAddr Address, uint64_t Alignment,
1019  uint64_t AlignmentOffset) {
1020  return createBlock(Parent, Content, Address, Alignment, AlignmentOffset);
1021  }
1022 
1023  /// Create a content block with initially mutable data.
1025  MutableArrayRef<char> MutableContent,
1026  orc::ExecutorAddr Address,
1027  uint64_t Alignment,
1028  uint64_t AlignmentOffset) {
1029  return createBlock(Parent, MutableContent, Address, Alignment,
1030  AlignmentOffset);
1031  }
1032 
1033  /// Create a zero-fill block.
1035  orc::ExecutorAddr Address, uint64_t Alignment,
1036  uint64_t AlignmentOffset) {
1037  return createBlock(Parent, Size, Address, Alignment, AlignmentOffset);
1038  }
1039 
1040  /// Cache type for the splitBlock function.
1042 
1043  /// Splits block B at the given index which must be greater than zero.
1044  /// If SplitIndex == B.getSize() then this function is a no-op and returns B.
1045  /// If SplitIndex < B.getSize() then this function returns a new block
1046  /// covering the range [ 0, SplitIndex ), and B is modified to cover the range
1047  /// [ SplitIndex, B.size() ).
1048  ///
1049  /// The optional Cache parameter can be used to speed up repeated calls to
1050  /// splitBlock for a single block. If the value is None the cache will be
1051  /// treated as uninitialized and splitBlock will populate it. Otherwise it
1052  /// is assumed to contain the list of Symbols pointing at B, sorted in
1053  /// descending order of offset.
1054  ///
1055  /// Notes:
1056  ///
1057  /// 1. splitBlock must be used with care. Splitting a block may cause
1058  /// incoming edges to become invalid if the edge target subexpression
1059  /// points outside the bounds of the newly split target block (E.g. an
1060  /// edge 'S + 10 : Pointer64' where S points to a newly split block
1061  /// whose size is less than 10). No attempt is made to detect invalidation
1062  /// of incoming edges, as in general this requires context that the
1063  /// LinkGraph does not have. Clients are responsible for ensuring that
1064  /// splitBlock is not used in a way that invalidates edges.
1065  ///
1066  /// 2. The newly introduced block will have a new ordinal which will be
1067  /// higher than any other ordinals in the section. Clients are responsible
1068  /// for re-assigning block ordinals to restore a compatible order if
1069  /// needed.
1070  ///
1071  /// 3. The cache is not automatically updated if new symbols are introduced
1072  /// between calls to splitBlock. Any newly introduced symbols may be
1073  /// added to the cache manually (descending offset order must be
1074  /// preserved), or the cache can be set to None and rebuilt by
1075  /// splitBlock on the next call.
1076  Block &splitBlock(Block &B, size_t SplitIndex,
1077  SplitBlockCache *Cache = nullptr);
1078 
1079  /// Add an external symbol.
1080  /// Some formats (e.g. ELF) allow Symbols to have sizes. For Symbols whose
1081  /// size is not known, you should substitute '0'.
1082  /// For external symbols Linkage determines whether the symbol must be
1083  /// present during lookup: Externals with strong linkage must be found or
1084  /// an error will be emitted. Externals with weak linkage are permitted to
1085  /// be undefined, in which case they are assigned a value of 0.
1087  Linkage L) {
1088  assert(llvm::count_if(ExternalSymbols,
1089  [&](const Symbol *Sym) {
1090  return Sym->getName() == Name;
1091  }) == 0 &&
1092  "Duplicate external symbol");
1093  auto &Sym = Symbol::constructExternal(
1094  Allocator.Allocate<Symbol>(),
1095  createAddressable(orc::ExecutorAddr(), false), Name, Size, L);
1096  ExternalSymbols.insert(&Sym);
1097  return Sym;
1098  }
1099 
1100  /// Add an absolute symbol.
1103  bool IsLive) {
1104  assert(llvm::count_if(AbsoluteSymbols,
1105  [&](const Symbol *Sym) {
1106  return Sym->getName() == Name;
1107  }) == 0 &&
1108  "Duplicate absolute symbol");
1109  auto &Sym = Symbol::constructAbsolute(Allocator.Allocate<Symbol>(),
1110  createAddressable(Address), Name,
1111  Size, L, S, IsLive);
1112  AbsoluteSymbols.insert(&Sym);
1113  return Sym;
1114  }
1115 
1116  /// Convenience method for adding a weak zero-fill symbol.
1119  uint64_t Alignment, bool IsLive) {
1121  [&](const Symbol *Sym) {
1122  return Sym->getName() == Name;
1123  }) == 0 &&
1124  "Duplicate defined symbol");
1125  auto &Sym = Symbol::constructCommon(
1126  Allocator.Allocate<Symbol>(),
1127  createBlock(Section, Size, Address, Alignment, 0), Name, Size, S,
1128  IsLive);
1129  Section.addSymbol(Sym);
1130  return Sym;
1131  }
1132 
1133  /// Add an anonymous symbol.
1135  orc::ExecutorAddrDiff Size, bool IsCallable,
1136  bool IsLive) {
1137  auto &Sym = Symbol::constructAnonDef(Allocator.Allocate<Symbol>(), Content,
1138  Offset, Size, IsCallable, IsLive);
1139  Content.getSection().addSymbol(Sym);
1140  return Sym;
1141  }
1142 
1143  /// Add a named symbol.
1145  StringRef Name, orc::ExecutorAddrDiff Size,
1146  Linkage L, Scope S, bool IsCallable, bool IsLive) {
1148  [&](const Symbol *Sym) {
1149  return Sym->getName() == Name;
1150  }) == 0) &&
1151  "Duplicate defined symbol");
1152  auto &Sym =
1153  Symbol::constructNamedDef(Allocator.Allocate<Symbol>(), Content, Offset,
1154  Name, Size, L, S, IsLive, IsCallable);
1155  Content.getSection().addSymbol(Sym);
1156  return Sym;
1157  }
1158 
1160  return make_range(section_iterator(Sections.begin()),
1161  section_iterator(Sections.end()));
1162  }
1163 
1164  SectionList::size_type sections_size() const { return Sections.size(); }
1165 
1166  /// Returns the section with the given name if it exists, otherwise returns
1167  /// null.
1169  for (auto &S : sections())
1170  if (S.getName() == Name)
1171  return &S;
1172  return nullptr;
1173  }
1174 
1176  return make_range(block_iterator(Sections.begin(), Sections.end()),
1177  block_iterator(Sections.end(), Sections.end()));
1178  }
1179 
1181  return make_range(const_block_iterator(Sections.begin(), Sections.end()),
1182  const_block_iterator(Sections.end(), Sections.end()));
1183  }
1184 
1186  return make_range(ExternalSymbols.begin(), ExternalSymbols.end());
1187  }
1188 
1190  return make_range(AbsoluteSymbols.begin(), AbsoluteSymbols.end());
1191  }
1192 
1194  return make_range(defined_symbol_iterator(Sections.begin(), Sections.end()),
1195  defined_symbol_iterator(Sections.end(), Sections.end()));
1196  }
1197 
1199  return make_range(
1200  const_defined_symbol_iterator(Sections.begin(), Sections.end()),
1201  const_defined_symbol_iterator(Sections.end(), Sections.end()));
1202  }
1203 
1204  /// Make the given symbol external (must not already be external).
1205  ///
1206  /// Symbol size, linkage and callability will be left unchanged. Symbol scope
1207  /// will be set to Default, and offset will be reset to 0.
1208  void makeExternal(Symbol &Sym) {
1209  assert(!Sym.isExternal() && "Symbol is already external");
1210  if (Sym.isAbsolute()) {
1211  assert(AbsoluteSymbols.count(&Sym) &&
1212  "Sym is not in the absolute symbols set");
1213  assert(Sym.getOffset() == 0 && "Absolute not at offset 0");
1214  AbsoluteSymbols.erase(&Sym);
1215  Sym.getAddressable().setAbsolute(false);
1216  } else {
1217  assert(Sym.isDefined() && "Sym is not a defined symbol");
1218  Section &Sec = Sym.getBlock().getSection();
1219  Sec.removeSymbol(Sym);
1220  Sym.makeExternal(createAddressable(orc::ExecutorAddr(), false));
1221  }
1222  ExternalSymbols.insert(&Sym);
1223  }
1224 
1225  /// Make the given symbol an absolute with the given address (must not already
1226  /// be absolute).
1227  ///
1228  /// The symbol's size, linkage, and callability, and liveness will be left
1229  /// unchanged, and its offset will be reset to 0.
1230  ///
1231  /// If the symbol was external then its scope will be set to local, otherwise
1232  /// it will be left unchanged.
1233  void makeAbsolute(Symbol &Sym, orc::ExecutorAddr Address) {
1234  assert(!Sym.isAbsolute() && "Symbol is already absolute");
1235  if (Sym.isExternal()) {
1236  assert(ExternalSymbols.count(&Sym) &&
1237  "Sym is not in the absolute symbols set");
1238  assert(Sym.getOffset() == 0 && "External is not at offset 0");
1239  ExternalSymbols.erase(&Sym);
1240  Sym.getAddressable().setAbsolute(true);
1241  Sym.setScope(Scope::Local);
1242  } else {
1243  assert(Sym.isDefined() && "Sym is not a defined symbol");
1244  Section &Sec = Sym.getBlock().getSection();
1245  Sec.removeSymbol(Sym);
1246  Sym.makeAbsolute(createAddressable(Address));
1247  }
1248  AbsoluteSymbols.insert(&Sym);
1249  }
1250 
1251  /// Turn an absolute or external symbol into a defined one by attaching it to
1252  /// a block. Symbol must not already be defined.
1255  bool IsLive) {
1256  assert(!Sym.isDefined() && "Sym is already a defined symbol");
1257  if (Sym.isAbsolute()) {
1258  assert(AbsoluteSymbols.count(&Sym) &&
1259  "Symbol is not in the absolutes set");
1260  AbsoluteSymbols.erase(&Sym);
1261  } else {
1262  assert(ExternalSymbols.count(&Sym) &&
1263  "Symbol is not in the externals set");
1264  ExternalSymbols.erase(&Sym);
1265  }
1266  Addressable &OldBase = *Sym.Base;
1267  Sym.setBlock(Content);
1268  Sym.setOffset(Offset);
1269  Sym.setSize(Size);
1270  Sym.setLinkage(L);
1271  Sym.setScope(S);
1272  Sym.setLive(IsLive);
1273  Content.getSection().addSymbol(Sym);
1274  destroyAddressable(OldBase);
1275  }
1276 
1277  /// Transfer a defined symbol from one block to another.
1278  ///
1279  /// The symbol's offset within DestBlock is set to NewOffset.
1280  ///
1281  /// If ExplicitNewSize is given as None then the size of the symbol will be
1282  /// checked and auto-truncated to at most the size of the remainder (from the
1283  /// given offset) of the size of the new block.
1284  ///
1285  /// All other symbol attributes are unchanged.
1286  void transferDefinedSymbol(Symbol &Sym, Block &DestBlock,
1287  orc::ExecutorAddrDiff NewOffset,
1288  Optional<orc::ExecutorAddrDiff> ExplicitNewSize) {
1289  auto &OldSection = Sym.getBlock().getSection();
1290  Sym.setBlock(DestBlock);
1291  Sym.setOffset(NewOffset);
1292  if (ExplicitNewSize)
1293  Sym.setSize(*ExplicitNewSize);
1294  else {
1295  auto RemainingBlockSize = DestBlock.getSize() - NewOffset;
1296  if (Sym.getSize() > RemainingBlockSize)
1297  Sym.setSize(RemainingBlockSize);
1298  }
1299  if (&DestBlock.getSection() != &OldSection) {
1300  OldSection.removeSymbol(Sym);
1301  DestBlock.getSection().addSymbol(Sym);
1302  }
1303  }
1304 
1305  /// Transfers the given Block and all Symbols pointing to it to the given
1306  /// Section.
1307  ///
1308  /// No attempt is made to check compatibility of the source and destination
1309  /// sections. Blocks may be moved between sections with incompatible
1310  /// permissions (e.g. from data to text). The client is responsible for
1311  /// ensuring that this is safe.
1312  void transferBlock(Block &B, Section &NewSection) {
1313  auto &OldSection = B.getSection();
1314  if (&OldSection == &NewSection)
1315  return;
1316  SmallVector<Symbol *> AttachedSymbols;
1317  for (auto *S : OldSection.symbols())
1318  if (&S->getBlock() == &B)
1319  AttachedSymbols.push_back(S);
1320  for (auto *S : AttachedSymbols) {
1321  OldSection.removeSymbol(*S);
1322  NewSection.addSymbol(*S);
1323  }
1324  OldSection.removeBlock(B);
1325  NewSection.addBlock(B);
1326  }
1327 
1328  /// Move all blocks and symbols from the source section to the destination
1329  /// section.
1330  ///
1331  /// If PreserveSrcSection is true (or SrcSection and DstSection are the same)
1332  /// then SrcSection is preserved, otherwise it is removed (the default).
1333  void mergeSections(Section &DstSection, Section &SrcSection,
1334  bool PreserveSrcSection = false) {
1335  if (&DstSection == &SrcSection)
1336  return;
1337  for (auto *B : SrcSection.blocks())
1338  B->setSection(DstSection);
1339  SrcSection.transferContentTo(DstSection);
1340  if (!PreserveSrcSection)
1341  removeSection(SrcSection);
1342  }
1343 
1344  /// Removes an external symbol. Also removes the underlying Addressable.
1346  assert(!Sym.isDefined() && !Sym.isAbsolute() &&
1347  "Sym is not an external symbol");
1348  assert(ExternalSymbols.count(&Sym) && "Symbol is not in the externals set");
1349  ExternalSymbols.erase(&Sym);
1350  Addressable &Base = *Sym.Base;
1351  assert(llvm::find_if(ExternalSymbols,
1352  [&](Symbol *AS) { return AS->Base == &Base; }) ==
1353  ExternalSymbols.end() &&
1354  "Base addressable still in use");
1355  destroySymbol(Sym);
1356  destroyAddressable(Base);
1357  }
1358 
1359  /// Remove an absolute symbol. Also removes the underlying Addressable.
1361  assert(!Sym.isDefined() && Sym.isAbsolute() &&
1362  "Sym is not an absolute symbol");
1363  assert(AbsoluteSymbols.count(&Sym) &&
1364  "Symbol is not in the absolute symbols set");
1365  AbsoluteSymbols.erase(&Sym);
1366  Addressable &Base = *Sym.Base;
1367  assert(llvm::find_if(ExternalSymbols,
1368  [&](Symbol *AS) { return AS->Base == &Base; }) ==
1369  ExternalSymbols.end() &&
1370  "Base addressable still in use");
1371  destroySymbol(Sym);
1372  destroyAddressable(Base);
1373  }
1374 
1375  /// Removes defined symbols. Does not remove the underlying block.
1377  assert(Sym.isDefined() && "Sym is not a defined symbol");
1378  Sym.getBlock().getSection().removeSymbol(Sym);
1379  destroySymbol(Sym);
1380  }
1381 
1382  /// Remove a block. The block reference is defunct after calling this
1383  /// function and should no longer be used.
1385  assert(llvm::none_of(B.getSection().symbols(),
1386  [&](const Symbol *Sym) {
1387  return &Sym->getBlock() == &B;
1388  }) &&
1389  "Block still has symbols attached");
1390  B.getSection().removeBlock(B);
1391  destroyBlock(B);
1392  }
1393 
1394  /// Remove a section. The section reference is defunct after calling this
1395  /// function and should no longer be used.
1396  void removeSection(Section &Sec) {
1397  auto I = llvm::find_if(Sections, [&Sec](const std::unique_ptr<Section> &S) {
1398  return S.get() == &Sec;
1399  });
1400  assert(I != Sections.end() && "Section does not appear in this graph");
1401  Sections.erase(I);
1402  }
1403 
1404  /// Accessor for the AllocActions object for this graph. This can be used to
1405  /// register allocation action calls prior to finalization.
1406  ///
1407  /// Accessing this object after finalization will result in undefined
1408  /// behavior.
1410 
1411  /// Dump the graph.
1412  void dump(raw_ostream &OS);
1413 
1414 private:
1415  // Put the BumpPtrAllocator first so that we don't free any of the underlying
1416  // memory until the Symbol/Addressable destructors have been run.
1417  BumpPtrAllocator Allocator;
1418 
1419  std::string Name;
1420  Triple TT;
1421  unsigned PointerSize;
1422  support::endianness Endianness;
1423  GetEdgeKindNameFunction GetEdgeKindName = nullptr;
1424  SectionList Sections;
1425  ExternalSymbolSet ExternalSymbols;
1426  ExternalSymbolSet AbsoluteSymbols;
1428 };
1429 
1431  if (!ContentMutable)
1432  setMutableContent(G.allocateContent({Data, Size}));
1433  return MutableArrayRef<char>(const_cast<char *>(Data), Size);
1434 }
1435 
1436 /// Enables easy lookup of blocks by addresses.
1438 public:
1439  using AddrToBlockMap = std::map<orc::ExecutorAddr, Block *>;
1440  using const_iterator = AddrToBlockMap::const_iterator;
1441 
1442  /// A block predicate that always adds all blocks.
1443  static bool includeAllBlocks(const Block &B) { return true; }
1444 
1445  /// A block predicate that always includes blocks with non-null addresses.
1446  static bool includeNonNull(const Block &B) { return !!B.getAddress(); }
1447 
1448  BlockAddressMap() = default;
1449 
1450  /// Add a block to the map. Returns an error if the block overlaps with any
1451  /// existing block.
1452  template <typename PredFn = decltype(includeAllBlocks)>
1454  if (!Pred(B))
1455  return Error::success();
1456 
1457  auto I = AddrToBlock.upper_bound(B.getAddress());
1458 
1459  // If we're not at the end of the map, check for overlap with the next
1460  // element.
1461  if (I != AddrToBlock.end()) {
1462  if (B.getAddress() + B.getSize() > I->second->getAddress())
1463  return overlapError(B, *I->second);
1464  }
1465 
1466  // If we're not at the start of the map, check for overlap with the previous
1467  // element.
1468  if (I != AddrToBlock.begin()) {
1469  auto &PrevBlock = *std::prev(I)->second;
1470  if (PrevBlock.getAddress() + PrevBlock.getSize() > B.getAddress())
1471  return overlapError(B, PrevBlock);
1472  }
1473 
1474  AddrToBlock.insert(I, std::make_pair(B.getAddress(), &B));
1475  return Error::success();
1476  }
1477 
1478  /// Add a block to the map without checking for overlap with existing blocks.
1479  /// The client is responsible for ensuring that the block added does not
1480  /// overlap with any existing block.
1481  void addBlockWithoutChecking(Block &B) { AddrToBlock[B.getAddress()] = &B; }
1482 
1483  /// Add a range of blocks to the map. Returns an error if any block in the
1484  /// range overlaps with any other block in the range, or with any existing
1485  /// block in the map.
1486  template <typename BlockPtrRange,
1487  typename PredFn = decltype(includeAllBlocks)>
1488  Error addBlocks(BlockPtrRange &&Blocks, PredFn Pred = includeAllBlocks) {
1489  for (auto *B : Blocks)
1490  if (auto Err = addBlock(*B, Pred))
1491  return Err;
1492  return Error::success();
1493  }
1494 
1495  /// Add a range of blocks to the map without checking for overlap with
1496  /// existing blocks. The client is responsible for ensuring that the block
1497  /// added does not overlap with any existing block.
1498  template <typename BlockPtrRange>
1499  void addBlocksWithoutChecking(BlockPtrRange &&Blocks) {
1500  for (auto *B : Blocks)
1502  }
1503 
1504  /// Iterates over (Address, Block*) pairs in ascending order of address.
1505  const_iterator begin() const { return AddrToBlock.begin(); }
1506  const_iterator end() const { return AddrToBlock.end(); }
1507 
1508  /// Returns the block starting at the given address, or nullptr if no such
1509  /// block exists.
1511  auto I = AddrToBlock.find(Addr);
1512  if (I == AddrToBlock.end())
1513  return nullptr;
1514  return I->second;
1515  }
1516 
1517  /// Returns the block covering the given address, or nullptr if no such block
1518  /// exists.
1520  auto I = AddrToBlock.upper_bound(Addr);
1521  if (I == AddrToBlock.begin())
1522  return nullptr;
1523  auto *B = std::prev(I)->second;
1524  if (Addr < B->getAddress() + B->getSize())
1525  return B;
1526  return nullptr;
1527  }
1528 
1529 private:
1530  Error overlapError(Block &NewBlock, Block &ExistingBlock) {
1531  auto NewBlockEnd = NewBlock.getAddress() + NewBlock.getSize();
1532  auto ExistingBlockEnd =
1533  ExistingBlock.getAddress() + ExistingBlock.getSize();
1534  return make_error<JITLinkError>(
1535  "Block at " +
1536  formatv("{0:x16} -- {1:x16}", NewBlock.getAddress().getValue(),
1537  NewBlockEnd.getValue()) +
1538  " overlaps " +
1539  formatv("{0:x16} -- {1:x16}", ExistingBlock.getAddress().getValue(),
1540  ExistingBlockEnd.getValue()));
1541  }
1542 
1543  AddrToBlockMap AddrToBlock;
1544 };
1545 
1546 /// A map of addresses to Symbols.
1548 public:
1550 
1551  /// Add a symbol to the SymbolAddressMap.
1552  void addSymbol(Symbol &Sym) {
1553  AddrToSymbols[Sym.getAddress()].push_back(&Sym);
1554  }
1555 
1556  /// Add all symbols in a given range to the SymbolAddressMap.
1557  template <typename SymbolPtrCollection>
1558  void addSymbols(SymbolPtrCollection &&Symbols) {
1559  for (auto *Sym : Symbols)
1560  addSymbol(*Sym);
1561  }
1562 
1563  /// Returns the list of symbols that start at the given address, or nullptr if
1564  /// no such symbols exist.
1566  auto I = AddrToSymbols.find(Addr);
1567  if (I == AddrToSymbols.end())
1568  return nullptr;
1569  return &I->second;
1570  }
1571 
1572 private:
1573  std::map<orc::ExecutorAddr, SymbolVector> AddrToSymbols;
1574 };
1575 
1576 /// A function for mutating LinkGraphs.
1578 
1579 /// A list of LinkGraph passes.
1580 using LinkGraphPassList = std::vector<LinkGraphPassFunction>;
1581 
1582 /// An LinkGraph pass configuration, consisting of a list of pre-prune,
1583 /// post-prune, and post-fixup passes.
1585 
1586  /// Pre-prune passes.
1587  ///
1588  /// These passes are called on the graph after it is built, and before any
1589  /// symbols have been pruned. Graph nodes still have their original vmaddrs.
1590  ///
1591  /// Notable use cases: Marking symbols live or should-discard.
1593 
1594  /// Post-prune passes.
1595  ///
1596  /// These passes are called on the graph after dead stripping, but before
1597  /// memory is allocated or nodes assigned their final addresses.
1598  ///
1599  /// Notable use cases: Building GOT, stub, and TLV symbols.
1601 
1602  /// Post-allocation passes.
1603  ///
1604  /// These passes are called on the graph after memory has been allocated and
1605  /// defined nodes have been assigned their final addresses, but before the
1606  /// context has been notified of these addresses. At this point externals
1607  /// have not been resolved, and symbol content has not yet been copied into
1608  /// working memory.
1609  ///
1610  /// Notable use cases: Setting up data structures associated with addresses
1611  /// of defined symbols (e.g. a mapping of __dso_handle to JITDylib* for the
1612  /// JIT runtime) -- using a PostAllocationPass for this ensures that the
1613  /// data structures are in-place before any query for resolved symbols
1614  /// can complete.
1616 
1617  /// Pre-fixup passes.
1618  ///
1619  /// These passes are called on the graph after memory has been allocated,
1620  /// content copied into working memory, and all nodes (including externals)
1621  /// have been assigned their final addresses, but before any fixups have been
1622  /// applied.
1623  ///
1624  /// Notable use cases: Late link-time optimizations like GOT and stub
1625  /// elimination.
1627 
1628  /// Post-fixup passes.
1629  ///
1630  /// These passes are called on the graph after block contents has been copied
1631  /// to working memory, and fixups applied. Blocks have been updated to point
1632  /// to their fixed up content.
1633  ///
1634  /// Notable use cases: Testing and validation.
1636 };
1637 
1638 /// Flags for symbol lookup.
1639 ///
1640 /// FIXME: These basically duplicate orc::SymbolLookupFlags -- We should merge
1641 /// the two types once we have an OrcSupport library.
1643 
1645 
1646 /// A map of symbol names to resolved addresses.
1648 
1649 /// A function object to call with a resolved symbol map (See AsyncLookupResult)
1650 /// or an error if resolution failed.
1652 public:
1653  virtual ~JITLinkAsyncLookupContinuation() = default;
1654  virtual void run(Expected<AsyncLookupResult> LR) = 0;
1655 
1656 private:
1657  virtual void anchor();
1658 };
1659 
1660 /// Create a lookup continuation from a function object.
1661 template <typename Continuation>
1662 std::unique_ptr<JITLinkAsyncLookupContinuation>
1663 createLookupContinuation(Continuation Cont) {
1664 
1665  class Impl final : public JITLinkAsyncLookupContinuation {
1666  public:
1667  Impl(Continuation C) : C(std::move(C)) {}
1668  void run(Expected<AsyncLookupResult> LR) override { C(std::move(LR)); }
1669 
1670  private:
1671  Continuation C;
1672  };
1673 
1674  return std::make_unique<Impl>(std::move(Cont));
1675 }
1676 
1677 /// Holds context for a single jitLink invocation.
1679 public:
1681 
1682  /// Create a JITLinkContext.
1683  JITLinkContext(const JITLinkDylib *JD) : JD(JD) {}
1684 
1685  /// Destroy a JITLinkContext.
1686  virtual ~JITLinkContext();
1687 
1688  /// Return the JITLinkDylib that this link is targeting, if any.
1689  const JITLinkDylib *getJITLinkDylib() const { return JD; }
1690 
1691  /// Return the MemoryManager to be used for this link.
1692  virtual JITLinkMemoryManager &getMemoryManager() = 0;
1693 
1694  /// Notify this context that linking failed.
1695  /// Called by JITLink if linking cannot be completed.
1696  virtual void notifyFailed(Error Err) = 0;
1697 
1698  /// Called by JITLink to resolve external symbols. This method is passed a
1699  /// lookup continutation which it must call with a result to continue the
1700  /// linking process.
1701  virtual void lookup(const LookupMap &Symbols,
1702  std::unique_ptr<JITLinkAsyncLookupContinuation> LC) = 0;
1703 
1704  /// Called by JITLink once all defined symbols in the graph have been assigned
1705  /// their final memory locations in the target process. At this point the
1706  /// LinkGraph can be inspected to build a symbol table, however the block
1707  /// content will not generally have been copied to the target location yet.
1708  ///
1709  /// If the client detects an error in the LinkGraph state (e.g. unexpected or
1710  /// missing symbols) they may return an error here. The error will be
1711  /// propagated to notifyFailed and the linker will bail out.
1712  virtual Error notifyResolved(LinkGraph &G) = 0;
1713 
1714  /// Called by JITLink to notify the context that the object has been
1715  /// finalized (i.e. emitted to memory and memory permissions set). If all of
1716  /// this objects dependencies have also been finalized then the code is ready
1717  /// to run.
1718  virtual void notifyFinalized(JITLinkMemoryManager::FinalizedAlloc Alloc) = 0;
1719 
1720  /// Called by JITLink prior to linking to determine whether default passes for
1721  /// the target should be added. The default implementation returns true.
1722  /// If subclasses override this method to return false for any target then
1723  /// they are required to fully configure the pass pipeline for that target.
1724  virtual bool shouldAddDefaultTargetPasses(const Triple &TT) const;
1725 
1726  /// Returns the mark-live pass to be used for this link. If no pass is
1727  /// returned (the default) then the target-specific linker implementation will
1728  /// choose a conservative default (usually marking all symbols live).
1729  /// This function is only called if shouldAddDefaultTargetPasses returns true,
1730  /// otherwise the JITContext is responsible for adding a mark-live pass in
1731  /// modifyPassConfig.
1732  virtual LinkGraphPassFunction getMarkLivePass(const Triple &TT) const;
1733 
1734  /// Called by JITLink to modify the pass pipeline prior to linking.
1735  /// The default version performs no modification.
1736  virtual Error modifyPassConfig(LinkGraph &G, PassConfiguration &Config);
1737 
1738 private:
1739  const JITLinkDylib *JD = nullptr;
1740 };
1741 
1742 /// Marks all symbols in a graph live. This can be used as a default,
1743 /// conservative mark-live implementation.
1744 Error markAllSymbolsLive(LinkGraph &G);
1745 
1746 /// Create an out of range error for the given edge in the given block.
1747 Error makeTargetOutOfRangeError(const LinkGraph &G, const Block &B,
1748  const Edge &E);
1749 
1751  const Edge &E);
1752 
1753 /// Base case for edge-visitors where the visitor-list is empty.
1754 inline void visitEdge(LinkGraph &G, Block *B, Edge &E) {}
1755 
1756 /// Applies the first visitor in the list to the given edge. If the visitor's
1757 /// visitEdge method returns true then we return immediately, otherwise we
1758 /// apply the next visitor.
1759 template <typename VisitorT, typename... VisitorTs>
1760 void visitEdge(LinkGraph &G, Block *B, Edge &E, VisitorT &&V,
1761  VisitorTs &&...Vs) {
1762  if (!V.visitEdge(G, B, E))
1763  visitEdge(G, B, E, std::forward<VisitorTs>(Vs)...);
1764 }
1765 
1766 /// For each edge in the given graph, apply a list of visitors to the edge,
1767 /// stopping when the first visitor's visitEdge method returns true.
1768 ///
1769 /// Only visits edges that were in the graph at call time: if any visitor
1770 /// adds new edges those will not be visited. Visitors are not allowed to
1771 /// remove edges (though they can change their kind, target, and addend).
1772 template <typename... VisitorTs>
1773 void visitExistingEdges(LinkGraph &G, VisitorTs &&...Vs) {
1774  // We may add new blocks during this process, but we don't want to iterate
1775  // over them, so build a worklist.
1776  std::vector<Block *> Worklist(G.blocks().begin(), G.blocks().end());
1777 
1778  for (auto *B : Worklist)
1779  for (auto &E : B->edges())
1780  visitEdge(G, B, E, std::forward<VisitorTs>(Vs)...);
1781 }
1782 
1783 /// Create a LinkGraph from the given object buffer.
1784 ///
1785 /// Note: The graph does not take ownership of the underlying buffer, nor copy
1786 /// its contents. The caller is responsible for ensuring that the object buffer
1787 /// outlives the graph.
1790 
1791 /// Link the given graph.
1792 void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx);
1793 
1794 } // end namespace jitlink
1795 } // end namespace llvm
1796 
1797 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
llvm::orc::ExecutorAddr
Represents an address in the executor process.
Definition: ExecutorAddress.h:30
MemoryBuffer.h
MathExtras.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
JITSymbol.h
llvm::none_of
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1631
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
Optional.h
MemoryFlags.h
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:145
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
Allocator.h
Content
T Content
Definition: ELFObjHandler.cpp:88
Error.h
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::orc::ExecutorAddr::getValue
uint64_t getValue() const
Definition: ExecutorAddress.h:62
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1886
DenseMap.h
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1668
llvm::Optional
Definition: APInt.h:33
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:79
makeAbsolute
static void makeAbsolute(SmallVectorImpl< char > &Path)
Make Path absolute.
Definition: FileCollector.cpp:89
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
STLExtras.h
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::detail::DenseSetImpl::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::detail::DenseSetImpl::count
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:97
llvm::count_if
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
Definition: STLExtras.h:1716
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
llvm::detail::DenseSetImpl::end
iterator end()
Definition: DenseSet.h:174
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:251
llvm::MutableArrayRef< char >
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
DenseSet.h
false
Definition: StackSlotColoring.cpp:141
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::detail::DenseSetImpl::size
size_type size() const
Definition: DenseSet.h:81
llvm::orc::ExecutorAddrDiff
uint64_t ExecutorAddrDiff
Definition: ExecutorAddress.h:27
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::orc::ExecutorAddrRange
Represents an address range in the exceutor process.
Definition: ExecutorAddress.h:148
llvm::detail::DenseSetImpl< Block *, DenseMap< Block *, detail::DenseSetEmpty, DenseMapInfo< Block * >, detail::DenseSetPair< Block * > >, DenseMapInfo< Block * > >::size_type
unsigned size_type
Definition: DenseSet.h:65
FormatVariadic.h
llvm::ArrayRef::slice
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:194
llvm::SmallString< 256 >
llvm::dxil::PointerTypeAnalysis::run
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
Definition: PointerTypeAnalysis.cpp:101
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:200
llvm::DenseSet< Symbol * >
uint64_t
llvm::detail::DenseSetImpl< Symbol *, DenseMap< Symbol *, detail::DenseSetEmpty, DenseMapInfo< Symbol * >, detail::DenseSetPair< Symbol * > >, DenseMapInfo< Symbol * > >::const_iterator
ConstIterator const_iterator
Definition: DenseSet.h:171
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::DenseMap
Definition: DenseMap.h:716
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::iterator_facade_base
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:80
llvm::detail::DenseSetImpl::begin
iterator begin()
Definition: DenseSet.h:173
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1675
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::ErrorInfo
Base class for user error types.
Definition: Error.h:347
Triple.h
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1598
llvm::Sched::Source
@ Source
Definition: TargetLowering.h:99
llvm::ArrayRef< char >
llvm::countTrailingZeros
unsigned countTrailingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the least significant bit to the most stopping at the first 1.
Definition: MathExtras.h:156
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::orc::shared::AllocActions
std::vector< AllocActionCallPair > AllocActions
A vector of allocation actions to be run for this allocation.
Definition: AllocationActions.h:44
A
* A
Definition: README_ALTIVEC.txt:89
uint32_t
JITLinkMemoryManager.h
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MutableArrayRef::data
T * data() const
Definition: ArrayRef.h:353
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1644
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::empty
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:268
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:851
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::BumpPtrAllocatorImpl::Allocate
LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:146
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
N
#define N
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
addSymbol
static void addSymbol(Object &Obj, const NewSymbolInfo &SymInfo, uint8_t DefaultVisibility)
Definition: ELFObjcopy.cpp:531
llvm::support::endianness
endianness
Definition: Endian.h:27
llvm::detail::DenseSetImpl::erase
bool erase(const ValueT &V)
Definition: DenseSet.h:101
llvm::pointee_iterator
An iterator type that allows iterating over the pointees via some other iterator.
Definition: iterator.h:320
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
Endian.h
llvm::isPowerOf2_64
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
Definition: MathExtras.h:496
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::BumpPtrAllocatorImpl::Deallocate
void Deallocate(const void *Ptr, size_t Size, size_t)
Definition: Allocator.h:216
llvm::detail::DenseSetImpl< Symbol *, DenseMap< Symbol *, detail::DenseSetEmpty, DenseMapInfo< Symbol * >, detail::DenseSetPair< Symbol * > >, DenseMapInfo< Symbol * > >::iterator
Iterator iterator
Definition: DenseSet.h:170
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58