LLVM  15.0.0git
Core.h
Go to the documentation of this file.
1 //===------ Core.h -- Core ORC APIs (Layer, JITDylib, etc.) -----*- 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 core ORC APIs.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_EXECUTIONENGINE_ORC_CORE_H
14 #define LLVM_EXECUTIONENGINE_ORC_CORE_H
15 
16 #include "llvm/ADT/BitmaskEnum.h"
17 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/Support/Debug.h"
27 
28 #include <atomic>
29 #include <future>
30 #include <memory>
31 #include <vector>
32 
33 namespace llvm {
34 namespace orc {
35 
36 // Forward declare some classes.
37 class AsynchronousSymbolQuery;
38 class ExecutionSession;
39 class MaterializationUnit;
40 class MaterializationResponsibility;
41 class JITDylib;
42 class ResourceTracker;
43 class InProgressLookupState;
44 
45 enum class SymbolState : uint8_t;
46 
47 using ResourceTrackerSP = IntrusiveRefCntPtr<ResourceTracker>;
48 using JITDylibSP = IntrusiveRefCntPtr<JITDylib>;
49 
50 using ResourceKey = uintptr_t;
51 
52 /// API to remove / transfer ownership of JIT resources.
53 class ResourceTracker : public ThreadSafeRefCountedBase<ResourceTracker> {
54 private:
55  friend class ExecutionSession;
56  friend class JITDylib;
58 
59 public:
60  ResourceTracker(const ResourceTracker &) = delete;
61  ResourceTracker &operator=(const ResourceTracker &) = delete;
62  ResourceTracker(ResourceTracker &&) = delete;
63  ResourceTracker &operator=(ResourceTracker &&) = delete;
64 
65  ~ResourceTracker();
66 
67  /// Return the JITDylib targeted by this tracker.
68  JITDylib &getJITDylib() const {
69  return *reinterpret_cast<JITDylib *>(JDAndFlag.load() &
70  ~static_cast<uintptr_t>(1));
71  }
72 
73  /// Remove all resources associated with this key.
74  Error remove();
75 
76  /// Transfer all resources associated with this key to the given
77  /// tracker, which must target the same JITDylib as this one.
78  void transferTo(ResourceTracker &DstRT);
79 
80  /// Return true if this tracker has become defunct.
81  bool isDefunct() const { return JDAndFlag.load() & 0x1; }
82 
83  /// Returns the key associated with this tracker.
84  /// This method should not be used except for debug logging: there is no
85  /// guarantee that the returned value will remain valid.
86  ResourceKey getKeyUnsafe() const { return reinterpret_cast<uintptr_t>(this); }
87 
88 private:
90 
91  void makeDefunct();
92 
93  std::atomic_uintptr_t JDAndFlag;
94 };
95 
96 /// Listens for ResourceTracker operations.
98 public:
99  virtual ~ResourceManager();
100  virtual Error handleRemoveResources(ResourceKey K) = 0;
101  virtual void handleTransferResources(ResourceKey DstK, ResourceKey SrcK) = 0;
102 };
103 
104 /// A set of symbol names (represented by SymbolStringPtrs for
105 // efficiency).
107 
108 /// A vector of symbol names.
109 using SymbolNameVector = std::vector<SymbolStringPtr>;
110 
111 /// A map from symbol names (as SymbolStringPtrs) to JITSymbols
112 /// (address/flags pairs).
114 
115 /// A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags.
117 
118 /// A map from JITDylibs to sets of symbols.
120 
121 /// Lookup flags that apply to each dylib in the search order for a lookup.
122 ///
123 /// If MatchHiddenSymbolsOnly is used (the default) for a given dylib, then
124 /// only symbols in that Dylib's interface will be searched. If
125 /// MatchHiddenSymbols is used then symbols with hidden visibility will match
126 /// as well.
128 
129 /// Lookup flags that apply to each symbol in a lookup.
130 ///
131 /// If RequiredSymbol is used (the default) for a given symbol then that symbol
132 /// must be found during the lookup or the lookup will fail returning a
133 /// SymbolNotFound error. If WeaklyReferencedSymbol is used and the given
134 /// symbol is not found then the query will continue, and no result for the
135 /// missing symbol will be present in the result (assuming the rest of the
136 /// lookup succeeds).
138 
139 /// Describes the kind of lookup being performed. The lookup kind is passed to
140 /// symbol generators (if they're invoked) to help them determine what
141 /// definitions to generate.
142 ///
143 /// Static -- Lookup is being performed as-if at static link time (e.g.
144 /// generators representing static archives should pull in new
145 /// definitions).
146 ///
147 /// DLSym -- Lookup is being performed as-if at runtime (e.g. generators
148 /// representing static archives should not pull in new definitions).
149 enum class LookupKind { Static, DLSym };
150 
151 /// A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search
152 /// order during symbol lookup.
153 using JITDylibSearchOrder =
154  std::vector<std::pair<JITDylib *, JITDylibLookupFlags>>;
155 
156 /// Convenience function for creating a search order from an ArrayRef of
157 /// JITDylib*, all with the same flags.
162  O.reserve(JDs.size());
163  for (auto *JD : JDs)
164  O.push_back(std::make_pair(JD, Flags));
165  return O;
166 }
167 
168 /// A set of symbols to look up, each associated with a SymbolLookupFlags
169 /// value.
170 ///
171 /// This class is backed by a vector and optimized for fast insertion,
172 /// deletion and iteration. It does not guarantee a stable order between
173 /// operations, and will not automatically detect duplicate elements (they
174 /// can be manually checked by calling the validate method).
176 public:
177  using value_type = std::pair<SymbolStringPtr, SymbolLookupFlags>;
178  using UnderlyingVector = std::vector<value_type>;
179  using iterator = UnderlyingVector::iterator;
180  using const_iterator = UnderlyingVector::const_iterator;
181 
182  SymbolLookupSet() = default;
183 
184  explicit SymbolLookupSet(
187  add(std::move(Name), Flags);
188  }
189 
190  /// Construct a SymbolLookupSet from an initializer list of SymbolStringPtrs.
191  explicit SymbolLookupSet(
192  std::initializer_list<SymbolStringPtr> Names,
194  Symbols.reserve(Names.size());
195  for (auto &Name : Names)
196  add(std::move(Name), Flags);
197  }
198 
199  /// Construct a SymbolLookupSet from a SymbolNameSet with the given
200  /// Flags used for each value.
201  explicit SymbolLookupSet(
202  const SymbolNameSet &Names,
204  Symbols.reserve(Names.size());
205  for (const auto &Name : Names)
206  add(Name, Flags);
207  }
208 
209  /// Construct a SymbolLookupSet from a vector of symbols with the given Flags
210  /// used for each value.
211  /// If the ArrayRef contains duplicates it is up to the client to remove these
212  /// before using this instance for lookup.
213  explicit SymbolLookupSet(
216  Symbols.reserve(Names.size());
217  for (const auto &Name : Names)
218  add(Name, Flags);
219  }
220 
221  /// Construct a SymbolLookupSet from DenseMap keys.
222  template <typename KeyT>
223  static SymbolLookupSet
226  SymbolLookupSet Result;
227  Result.Symbols.reserve(M.size());
228  for (const auto &KV : M)
229  Result.add(KV.first, Flags);
230  return Result;
231  }
232 
233  /// Add an element to the set. The client is responsible for checking that
234  /// duplicates are not added.
238  Symbols.push_back(std::make_pair(std::move(Name), Flags));
239  return *this;
240  }
241 
242  /// Quickly append one lookup set to another.
244  Symbols.reserve(Symbols.size() + Other.size());
245  for (auto &KV : Other)
246  Symbols.push_back(std::move(KV));
247  return *this;
248  }
249 
250  bool empty() const { return Symbols.empty(); }
251  UnderlyingVector::size_type size() const { return Symbols.size(); }
252  iterator begin() { return Symbols.begin(); }
253  iterator end() { return Symbols.end(); }
254  const_iterator begin() const { return Symbols.begin(); }
255  const_iterator end() const { return Symbols.end(); }
256 
257  /// Removes the Ith element of the vector, replacing it with the last element.
258  void remove(UnderlyingVector::size_type I) {
259  std::swap(Symbols[I], Symbols.back());
260  Symbols.pop_back();
261  }
262 
263  /// Removes the element pointed to by the given iterator. This iterator and
264  /// all subsequent ones (including end()) are invalidated.
265  void remove(iterator I) { remove(I - begin()); }
266 
267  /// Removes all elements matching the given predicate, which must be callable
268  /// as bool(const SymbolStringPtr &, SymbolLookupFlags Flags).
269  template <typename PredFn> void remove_if(PredFn &&Pred) {
270  UnderlyingVector::size_type I = 0;
271  while (I != Symbols.size()) {
272  const auto &Name = Symbols[I].first;
273  auto Flags = Symbols[I].second;
274  if (Pred(Name, Flags))
275  remove(I);
276  else
277  ++I;
278  }
279  }
280 
281  /// Loop over the elements of this SymbolLookupSet, applying the Body function
282  /// to each one. Body must be callable as
283  /// bool(const SymbolStringPtr &, SymbolLookupFlags).
284  /// If Body returns true then the element just passed in is removed from the
285  /// set. If Body returns false then the element is retained.
286  template <typename BodyFn>
287  auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t<
288  std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
289  std::declval<SymbolLookupFlags>())),
290  bool>::value> {
291  UnderlyingVector::size_type I = 0;
292  while (I != Symbols.size()) {
293  const auto &Name = Symbols[I].first;
294  auto Flags = Symbols[I].second;
295  if (Body(Name, Flags))
296  remove(I);
297  else
298  ++I;
299  }
300  }
301 
302  /// Loop over the elements of this SymbolLookupSet, applying the Body function
303  /// to each one. Body must be callable as
304  /// Expected<bool>(const SymbolStringPtr &, SymbolLookupFlags).
305  /// If Body returns a failure value, the loop exits immediately. If Body
306  /// returns true then the element just passed in is removed from the set. If
307  /// Body returns false then the element is retained.
308  template <typename BodyFn>
309  auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t<
310  std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
311  std::declval<SymbolLookupFlags>())),
312  Expected<bool>>::value,
313  Error> {
314  UnderlyingVector::size_type I = 0;
315  while (I != Symbols.size()) {
316  const auto &Name = Symbols[I].first;
317  auto Flags = Symbols[I].second;
318  auto Remove = Body(Name, Flags);
319  if (!Remove)
320  return Remove.takeError();
321  if (*Remove)
322  remove(I);
323  else
324  ++I;
325  }
326  return Error::success();
327  }
328 
329  /// Construct a SymbolNameVector from this instance by dropping the Flags
330  /// values.
332  SymbolNameVector Names;
333  Names.reserve(Symbols.size());
334  for (auto &KV : Symbols)
335  Names.push_back(KV.first);
336  return Names;
337  }
338 
339  /// Sort the lookup set by pointer value. This sort is fast but sensitive to
340  /// allocation order and so should not be used where a consistent order is
341  /// required.
342  void sortByAddress() {
343  llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
344  return LHS.first < RHS.first;
345  });
346  }
347 
348  /// Sort the lookup set lexicographically. This sort is slow but the order
349  /// is unaffected by allocation order.
350  void sortByName() {
351  llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
352  return *LHS.first < *RHS.first;
353  });
354  }
355 
356  /// Remove any duplicate elements. If a SymbolLookupSet is not duplicate-free
357  /// by construction, this method can be used to turn it into a proper set.
359  sortByAddress();
360  auto LastI = std::unique(Symbols.begin(), Symbols.end());
361  Symbols.erase(LastI, Symbols.end());
362  }
363 
364 #ifndef NDEBUG
365  /// Returns true if this set contains any duplicates. This should only be used
366  /// in assertions.
368  if (Symbols.size() < 2)
369  return false;
370  sortByAddress();
371  for (UnderlyingVector::size_type I = 1; I != Symbols.size(); ++I)
372  if (Symbols[I].first == Symbols[I - 1].first)
373  return true;
374  return false;
375  }
376 #endif
377 
378 private:
379  UnderlyingVector Symbols;
380 };
381 
383  SymbolAliasMapEntry() = default;
386 
389 };
390 
391 /// A map of Symbols to (Symbol, Flags) pairs.
393 
394 /// Callback to notify client that symbols have been resolved.
396 
397 /// Callback to register the dependencies for a given query.
400 
401 /// This can be used as the value for a RegisterDependenciesFunction if there
402 /// are no dependants to register with.
404 
405 class ResourceTrackerDefunct : public ErrorInfo<ResourceTrackerDefunct> {
406 public:
407  static char ID;
408 
410  std::error_code convertToErrorCode() const override;
411  void log(raw_ostream &OS) const override;
412 
413 private:
415 };
416 
417 /// Used to notify a JITDylib that the given set of symbols failed to
418 /// materialize.
419 class FailedToMaterialize : public ErrorInfo<FailedToMaterialize> {
420 public:
421  static char ID;
422 
423  FailedToMaterialize(std::shared_ptr<SymbolStringPool> SSP,
424  std::shared_ptr<SymbolDependenceMap> Symbols);
426  std::error_code convertToErrorCode() const override;
427  void log(raw_ostream &OS) const override;
428  const SymbolDependenceMap &getSymbols() const { return *Symbols; }
429 
430 private:
431  std::shared_ptr<SymbolStringPool> SSP;
432  std::shared_ptr<SymbolDependenceMap> Symbols;
433 };
434 
435 /// Used to notify clients when symbols can not be found during a lookup.
436 class SymbolsNotFound : public ErrorInfo<SymbolsNotFound> {
437 public:
438  static char ID;
439 
440  SymbolsNotFound(std::shared_ptr<SymbolStringPool> SSP, SymbolNameSet Symbols);
441  SymbolsNotFound(std::shared_ptr<SymbolStringPool> SSP,
442  SymbolNameVector Symbols);
443  std::error_code convertToErrorCode() const override;
444  void log(raw_ostream &OS) const override;
445  std::shared_ptr<SymbolStringPool> getSymbolStringPool() { return SSP; }
446  const SymbolNameVector &getSymbols() const { return Symbols; }
447 
448 private:
449  std::shared_ptr<SymbolStringPool> SSP;
450  SymbolNameVector Symbols;
451 };
452 
453 /// Used to notify clients that a set of symbols could not be removed.
454 class SymbolsCouldNotBeRemoved : public ErrorInfo<SymbolsCouldNotBeRemoved> {
455 public:
456  static char ID;
457 
458  SymbolsCouldNotBeRemoved(std::shared_ptr<SymbolStringPool> SSP,
459  SymbolNameSet Symbols);
460  std::error_code convertToErrorCode() const override;
461  void log(raw_ostream &OS) const override;
462  std::shared_ptr<SymbolStringPool> getSymbolStringPool() { return SSP; }
463  const SymbolNameSet &getSymbols() const { return Symbols; }
464 
465 private:
466  std::shared_ptr<SymbolStringPool> SSP;
467  SymbolNameSet Symbols;
468 };
469 
470 /// Errors of this type should be returned if a module fails to include
471 /// definitions that are claimed by the module's associated
472 /// MaterializationResponsibility. If this error is returned it is indicative of
473 /// a broken transformation / compiler / object cache.
474 class MissingSymbolDefinitions : public ErrorInfo<MissingSymbolDefinitions> {
475 public:
476  static char ID;
477 
478  MissingSymbolDefinitions(std::shared_ptr<SymbolStringPool> SSP,
479  std::string ModuleName, SymbolNameVector Symbols)
480  : SSP(std::move(SSP)), ModuleName(std::move(ModuleName)),
481  Symbols(std::move(Symbols)) {}
482  std::error_code convertToErrorCode() const override;
483  void log(raw_ostream &OS) const override;
484  std::shared_ptr<SymbolStringPool> getSymbolStringPool() { return SSP; }
485  const std::string &getModuleName() const { return ModuleName; }
486  const SymbolNameVector &getSymbols() const { return Symbols; }
487 private:
488  std::shared_ptr<SymbolStringPool> SSP;
489  std::string ModuleName;
490  SymbolNameVector Symbols;
491 };
492 
493 /// Errors of this type should be returned if a module contains definitions for
494 /// symbols that are not claimed by the module's associated
495 /// MaterializationResponsibility. If this error is returned it is indicative of
496 /// a broken transformation / compiler / object cache.
497 class UnexpectedSymbolDefinitions : public ErrorInfo<UnexpectedSymbolDefinitions> {
498 public:
499  static char ID;
500 
501  UnexpectedSymbolDefinitions(std::shared_ptr<SymbolStringPool> SSP,
502  std::string ModuleName, SymbolNameVector Symbols)
503  : SSP(std::move(SSP)), ModuleName(std::move(ModuleName)),
504  Symbols(std::move(Symbols)) {}
505  std::error_code convertToErrorCode() const override;
506  void log(raw_ostream &OS) const override;
507  std::shared_ptr<SymbolStringPool> getSymbolStringPool() { return SSP; }
508  const std::string &getModuleName() const { return ModuleName; }
509  const SymbolNameVector &getSymbols() const { return Symbols; }
510 private:
511  std::shared_ptr<SymbolStringPool> SSP;
512  std::string ModuleName;
513  SymbolNameVector Symbols;
514 };
515 
516 /// Tracks responsibility for materialization, and mediates interactions between
517 /// MaterializationUnits and JDs.
518 ///
519 /// An instance of this class is passed to MaterializationUnits when their
520 /// materialize method is called. It allows MaterializationUnits to resolve and
521 /// emit symbols, or abandon materialization by notifying any unmaterialized
522 /// symbols of an error.
524  friend class ExecutionSession;
525  friend class JITDylib;
526 
527 public:
531 
532  /// Destruct a MaterializationResponsibility instance. In debug mode
533  /// this asserts that all symbols being tracked have been either
534  /// emitted or notified of an error.
536 
537  /// Returns the ResourceTracker for this instance.
538  template <typename Func> Error withResourceKeyDo(Func &&F) const;
539 
540  /// Returns the target JITDylib that these symbols are being materialized
541  /// into.
542  JITDylib &getTargetJITDylib() const { return JD; }
543 
544  /// Returns the ExecutionSession for this instance.
546 
547  /// Returns the symbol flags map for this responsibility instance.
548  /// Note: The returned flags may have transient flags (Lazy, Materializing)
549  /// set. These should be stripped with JITSymbolFlags::stripTransientFlags
550  /// before using.
551  const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
552 
553  /// Returns the initialization pseudo-symbol, if any. This symbol will also
554  /// be present in the SymbolFlagsMap for this MaterializationResponsibility
555  /// object.
556  const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
557 
558  /// Returns the names of any symbols covered by this
559  /// MaterializationResponsibility object that have queries pending. This
560  /// information can be used to return responsibility for unrequested symbols
561  /// back to the JITDylib via the delegate method.
563 
564  /// Notifies the target JITDylib that the given symbols have been resolved.
565  /// This will update the given symbols' addresses in the JITDylib, and notify
566  /// any pending queries on the given symbols of their resolution. The given
567  /// symbols must be ones covered by this MaterializationResponsibility
568  /// instance. Individual calls to this method may resolve a subset of the
569  /// symbols, but all symbols must have been resolved prior to calling emit.
570  ///
571  /// This method will return an error if any symbols being resolved have been
572  /// moved to the error state due to the failure of a dependency. If this
573  /// method returns an error then clients should log it and call
574  /// failMaterialize. If no dependencies have been registered for the
575  /// symbols covered by this MaterializationResponsibiility then this method
576  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
577  Error notifyResolved(const SymbolMap &Symbols);
578 
579  /// Notifies the target JITDylib (and any pending queries on that JITDylib)
580  /// that all symbols covered by this MaterializationResponsibility instance
581  /// have been emitted.
582  ///
583  /// This method will return an error if any symbols being resolved have been
584  /// moved to the error state due to the failure of a dependency. If this
585  /// method returns an error then clients should log it and call
586  /// failMaterialize. If no dependencies have been registered for the
587  /// symbols covered by this MaterializationResponsibiility then this method
588  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
590 
591  /// Attempt to claim responsibility for new definitions. This method can be
592  /// used to claim responsibility for symbols that are added to a
593  /// materialization unit during the compilation process (e.g. literal pool
594  /// symbols). Symbol linkage rules are the same as for symbols that are
595  /// defined up front: duplicate strong definitions will result in errors.
596  /// Duplicate weak definitions will be discarded (in which case they will
597  /// not be added to this responsibility instance).
598  ///
599  /// This method can be used by materialization units that want to add
600  /// additional symbols at materialization time (e.g. stubs, compile
601  /// callbacks, metadata).
603 
604  /// Define the given symbols as non-existent, removing it from the symbol
605  /// table and notifying any pending queries. Queries that lookup up the
606  /// symbol using the SymbolLookupFlags::WeaklyReferencedSymbol flag will
607  /// behave as if the symbol had not been matched in the first place. Queries
608  /// that required this symbol will fail with a missing symbol definition
609  /// error.
610  ///
611  /// This method is intended to support cleanup of special symbols like
612  /// initializer symbols: Queries using
613  /// SymbolLookupFlags::WeaklyReferencedSymbol can be used to trigger their
614  /// emission, and this method can be used to remove them from the JITDylib
615  /// once materialization is complete.
617 
618  /// Notify all not-yet-emitted covered by this MaterializationResponsibility
619  /// instance that an error has occurred.
620  /// This will remove all symbols covered by this MaterializationResponsibilty
621  /// from the target JITDylib, and send an error to any queries waiting on
622  /// these symbols.
623  void failMaterialization();
624 
625  /// Transfers responsibility to the given MaterializationUnit for all
626  /// symbols defined by that MaterializationUnit. This allows
627  /// materializers to break up work based on run-time information (e.g.
628  /// by introspecting which symbols have actually been looked up and
629  /// materializing only those).
630  Error replace(std::unique_ptr<MaterializationUnit> MU);
631 
632  /// Delegates responsibility for the given symbols to the returned
633  /// materialization responsibility. Useful for breaking up work between
634  /// threads, or different kinds of materialization processes.
636  delegate(const SymbolNameSet &Symbols);
637 
639  const SymbolDependenceMap &Dependencies);
640 
641  /// Add dependencies that apply to all symbols covered by this instance.
642  void addDependenciesForAll(const SymbolDependenceMap &Dependencies);
643 
644 private:
645  /// Create a MaterializationResponsibility for the given JITDylib and
646  /// initial symbols.
649  SymbolStringPtr InitSymbol)
650  : JD(RT->getJITDylib()), RT(std::move(RT)),
651  SymbolFlags(std::move(SymbolFlags)), InitSymbol(std::move(InitSymbol)) {
652  assert(!this->SymbolFlags.empty() && "Materializing nothing?");
653  }
654 
655  JITDylib &JD;
658  SymbolStringPtr InitSymbol;
659 };
660 
661 /// A MaterializationUnit represents a set of symbol definitions that can
662 /// be materialized as a group, or individually discarded (when
663 /// overriding definitions are encountered).
664 ///
665 /// MaterializationUnits are used when providing lazy definitions of symbols to
666 /// JITDylibs. The JITDylib will call materialize when the address of a symbol
667 /// is requested via the lookup method. The JITDylib will call discard if a
668 /// stronger definition is added or already present.
670  friend class ExecutionSession;
671  friend class JITDylib;
672 
673 public:
674  static char ID;
675 
676  struct Interface {
677  Interface() = default;
679  : SymbolFlags(std::move(InitalSymbolFlags)),
681  assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) &&
682  "If set, InitSymbol should appear in InitialSymbolFlags map");
683  }
684 
687  };
688 
692  virtual ~MaterializationUnit() = default;
693 
694  /// Return the name of this materialization unit. Useful for debugging
695  /// output.
696  virtual StringRef getName() const = 0;
697 
698  /// Return the set of symbols that this source provides.
699  const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
700 
701  /// Returns the initialization symbol for this MaterializationUnit (if any).
703 
704  /// Implementations of this method should materialize all symbols
705  /// in the materialzation unit, except for those that have been
706  /// previously discarded.
707  virtual void
708  materialize(std::unique_ptr<MaterializationResponsibility> R) = 0;
709 
710  /// Called by JITDylibs to notify MaterializationUnits that the given symbol
711  /// has been overridden.
712  void doDiscard(const JITDylib &JD, const SymbolStringPtr &Name) {
714  discard(JD, std::move(Name));
715  }
716 
717 protected:
720 
721 private:
722  virtual void anchor();
723 
724  /// Implementations of this method should discard the given symbol
725  /// from the source (e.g. if the source is an LLVM IR Module and the
726  /// symbol is a function, delete the function body or mark it available
727  /// externally).
728  virtual void discard(const JITDylib &JD, const SymbolStringPtr &Name) = 0;
729 };
730 
731 /// A MaterializationUnit implementation for pre-existing absolute symbols.
732 ///
733 /// All symbols will be resolved and marked ready as soon as the unit is
734 /// materialized.
736 public:
738 
739  StringRef getName() const override;
740 
741 private:
742  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
743  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
744  static MaterializationUnit::Interface extractFlags(const SymbolMap &Symbols);
745 
746  SymbolMap Symbols;
747 };
748 
749 /// Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
750 /// Useful for inserting absolute symbols into a JITDylib. E.g.:
751 /// \code{.cpp}
752 /// JITDylib &JD = ...;
753 /// SymbolStringPtr Foo = ...;
754 /// JITEvaluatedSymbol FooSym = ...;
755 /// if (auto Err = JD.define(absoluteSymbols({{Foo, FooSym}})))
756 /// return Err;
757 /// \endcode
758 ///
759 inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
761  return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
762  std::move(Symbols));
763 }
764 
765 /// A materialization unit for symbol aliases. Allows existing symbols to be
766 /// aliased with alternate flags.
768 public:
769  /// SourceJD is allowed to be nullptr, in which case the source JITDylib is
770  /// taken to be whatever JITDylib these definitions are materialized in (and
771  /// MatchNonExported has no effect). This is useful for defining aliases
772  /// within a JITDylib.
773  ///
774  /// Note: Care must be taken that no sets of aliases form a cycle, as such
775  /// a cycle will result in a deadlock when any symbol in the cycle is
776  /// resolved.
778  JITDylibLookupFlags SourceJDLookupFlags,
779  SymbolAliasMap Aliases);
780 
781  StringRef getName() const override;
782 
783 private:
784  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
785  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
787  extractFlags(const SymbolAliasMap &Aliases);
788 
789  JITDylib *SourceJD = nullptr;
790  JITDylibLookupFlags SourceJDLookupFlags;
791  SymbolAliasMap Aliases;
792 };
793 
794 /// Create a ReExportsMaterializationUnit with the given aliases.
795 /// Useful for defining symbol aliases.: E.g., given a JITDylib JD containing
796 /// symbols "foo" and "bar", we can define aliases "baz" (for "foo") and "qux"
797 /// (for "bar") with: \code{.cpp}
798 /// SymbolStringPtr Baz = ...;
799 /// SymbolStringPtr Qux = ...;
800 /// if (auto Err = JD.define(symbolAliases({
801 /// {Baz, { Foo, JITSymbolFlags::Exported }},
802 /// {Qux, { Bar, JITSymbolFlags::Weak }}}))
803 /// return Err;
804 /// \endcode
805 inline std::unique_ptr<ReExportsMaterializationUnit>
807  return std::make_unique<ReExportsMaterializationUnit>(
809 }
810 
811 /// Create a materialization unit for re-exporting symbols from another JITDylib
812 /// with alternative names/flags.
813 /// SourceJD will be searched using the given JITDylibLookupFlags.
814 inline std::unique_ptr<ReExportsMaterializationUnit>
815 reexports(JITDylib &SourceJD, SymbolAliasMap Aliases,
816  JITDylibLookupFlags SourceJDLookupFlags =
818  return std::make_unique<ReExportsMaterializationUnit>(
819  &SourceJD, SourceJDLookupFlags, std::move(Aliases));
820 }
821 
822 /// Build a SymbolAliasMap for the common case where you want to re-export
823 /// symbols from another JITDylib with the same linkage/flags.
825 buildSimpleReexportsAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols);
826 
827 /// Represents the state that a symbol has reached during materialization.
828 enum class SymbolState : uint8_t {
829  Invalid, /// No symbol should be in this state.
830  NeverSearched, /// Added to the symbol table, never queried.
831  Materializing, /// Queried, materialization begun.
832  Resolved, /// Assigned address, still materializing.
833  Emitted, /// Emitted to memory, but waiting on transitive dependencies.
834  Ready = 0x3f /// Ready and safe for clients to access.
835 };
836 
837 /// A symbol query that returns results via a callback when results are
838 /// ready.
839 ///
840 /// makes a callback when all symbols are available.
842  friend class ExecutionSession;
844  friend class JITDylib;
847 
848 public:
849  /// Create a query for the given symbols. The NotifyComplete
850  /// callback will be called once all queried symbols reach the given
851  /// minimum state.
853  SymbolState RequiredState,
854  SymbolsResolvedCallback NotifyComplete);
855 
856  /// Notify the query that a requested symbol has reached the required state.
858  JITEvaluatedSymbol Sym);
859 
860  /// Returns true if all symbols covered by this query have been
861  /// resolved.
862  bool isComplete() const { return OutstandingSymbolsCount == 0; }
863 
864 
865 private:
866  void handleComplete(ExecutionSession &ES);
867 
868  SymbolState getRequiredState() { return RequiredState; }
869 
870  void addQueryDependence(JITDylib &JD, SymbolStringPtr Name);
871 
872  void removeQueryDependence(JITDylib &JD, const SymbolStringPtr &Name);
873 
874  void dropSymbol(const SymbolStringPtr &Name);
875 
876  void handleFailed(Error Err);
877 
878  void detach();
879 
880  SymbolsResolvedCallback NotifyComplete;
881  SymbolDependenceMap QueryRegistrations;
882  SymbolMap ResolvedSymbols;
883  size_t OutstandingSymbolsCount;
884  SymbolState RequiredState;
885 };
886 
887 /// Wraps state for a lookup-in-progress.
888 /// DefinitionGenerators can optionally take ownership of a LookupState object
889 /// to suspend a lookup-in-progress while they search for definitions.
890 class LookupState {
891  friend class OrcV2CAPIHelper;
892  friend class ExecutionSession;
893 
894 public:
895  LookupState();
898  ~LookupState();
899 
900  /// Continue the lookup. This can be called by DefinitionGenerators
901  /// to re-start a captured query-application operation.
902  void continueLookup(Error Err);
903 
904 private:
905  LookupState(std::unique_ptr<InProgressLookupState> IPLS);
906 
907  // For C API.
908  void reset(InProgressLookupState *IPLS);
909 
910  std::unique_ptr<InProgressLookupState> IPLS;
911 };
912 
913 /// Definition generators can be attached to JITDylibs to generate new
914 /// definitions for otherwise unresolved symbols during lookup.
916 public:
917  virtual ~DefinitionGenerator();
918 
919  /// DefinitionGenerators should override this method to insert new
920  /// definitions into the parent JITDylib. K specifies the kind of this
921  /// lookup. JD specifies the target JITDylib being searched, and
922  /// JDLookupFlags specifies whether the search should match against
923  /// hidden symbols. Finally, Symbols describes the set of unresolved
924  /// symbols and their associated lookup flags.
926  JITDylibLookupFlags JDLookupFlags,
927  const SymbolLookupSet &LookupSet) = 0;
928 };
929 
930 /// Represents a JIT'd dynamic library.
931 ///
932 /// This class aims to mimic the behavior of a regular dylib or shared object,
933 /// but without requiring the contained program representations to be compiled
934 /// up-front. The JITDylib's content is defined by adding MaterializationUnits,
935 /// and contained MaterializationUnits will typically rely on the JITDylib's
936 /// links-against order to resolve external references (similar to a regular
937 /// dylib).
938 ///
939 /// The JITDylib object is a thin wrapper that references state held by the
940 /// ExecutionSession. JITDylibs can be removed, clearing this underlying state
941 /// and leaving the JITDylib object in a defunct state. In this state the
942 /// JITDylib's name is guaranteed to remain accessible. If the ExecutionSession
943 /// is still alive then other operations are callable but will return an Error
944 /// or null result (depending on the API). It is illegal to call any operation
945 /// other than getName on a JITDylib after the ExecutionSession has been torn
946 /// down.
947 ///
948 /// JITDylibs cannot be moved or copied. Their address is stable, and useful as
949 /// a key in some JIT data structures.
950 class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
951  public jitlink::JITLinkDylib {
953  friend class ExecutionSession;
954  friend class Platform;
956 public:
957 
958  JITDylib(const JITDylib &) = delete;
959  JITDylib &operator=(const JITDylib &) = delete;
960  JITDylib(JITDylib &&) = delete;
961  JITDylib &operator=(JITDylib &&) = delete;
962  ~JITDylib();
963 
964  /// Get a reference to the ExecutionSession for this JITDylib.
965  ///
966  /// It is legal to call this method on a defunct JITDylib, however the result
967  /// will only usable if the ExecutionSession is still alive. If this JITDylib
968  /// is held by an error that may have torn down the JIT then the result
969  /// should not be used.
970  ExecutionSession &getExecutionSession() const { return ES; }
971 
972  /// Dump current JITDylib state to OS.
973  ///
974  /// It is legal to call this method on a defunct JITDylib.
975  void dump(raw_ostream &OS);
976 
977  /// Calls remove on all trackers currently associated with this JITDylib.
978  /// Does not run static deinits.
979  ///
980  /// Note that removal happens outside the session lock, so new code may be
981  /// added concurrently while the clear is underway, and the newly added
982  /// code will *not* be cleared. Adding new code concurrently with a clear
983  /// is usually a bug and should be avoided.
984  ///
985  /// It is illegal to call this method on a defunct JITDylib and the client
986  /// is responsible for ensuring that they do not do so.
987  Error clear();
988 
989  /// Get the default resource tracker for this JITDylib.
990  ///
991  /// It is illegal to call this method on a defunct JITDylib and the client
992  /// is responsible for ensuring that they do not do so.
994 
995  /// Create a resource tracker for this JITDylib.
996  ///
997  /// It is illegal to call this method on a defunct JITDylib and the client
998  /// is responsible for ensuring that they do not do so.
1000 
1001  /// Adds a definition generator to this JITDylib and returns a referenece to
1002  /// it.
1003  ///
1004  /// When JITDylibs are searched during lookup, if no existing definition of
1005  /// a symbol is found, then any generators that have been added are run (in
1006  /// the order that they were added) to potentially generate a definition.
1007  ///
1008  /// It is illegal to call this method on a defunct JITDylib and the client
1009  /// is responsible for ensuring that they do not do so.
1010  template <typename GeneratorT>
1011  GeneratorT &addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
1012 
1013  /// Remove a definition generator from this JITDylib.
1014  ///
1015  /// The given generator must exist in this JITDylib's generators list (i.e.
1016  /// have been added and not yet removed).
1017  ///
1018  /// It is illegal to call this method on a defunct JITDylib and the client
1019  /// is responsible for ensuring that they do not do so.
1021 
1022  /// Set the link order to be used when fixing up definitions in JITDylib.
1023  /// This will replace the previous link order, and apply to any symbol
1024  /// resolutions made for definitions in this JITDylib after the call to
1025  /// setLinkOrder (even if the definition itself was added before the
1026  /// call).
1027  ///
1028  /// If LinkAgainstThisJITDylibFirst is true (the default) then this JITDylib
1029  /// will add itself to the beginning of the LinkOrder (Clients should not
1030  /// put this JITDylib in the list in this case, to avoid redundant lookups).
1031  ///
1032  /// If LinkAgainstThisJITDylibFirst is false then the link order will be used
1033  /// as-is. The primary motivation for this feature is to support deliberate
1034  /// shadowing of symbols in this JITDylib by a facade JITDylib. For example,
1035  /// the facade may resolve function names to stubs, and the stubs may compile
1036  /// lazily by looking up symbols in this dylib. Adding the facade dylib
1037  /// as the first in the link order (instead of this dylib) ensures that
1038  /// definitions within this dylib resolve to the lazy-compiling stubs,
1039  /// rather than immediately materializing the definitions in this dylib.
1040  ///
1041  /// It is illegal to call this method on a defunct JITDylib and the client
1042  /// is responsible for ensuring that they do not do so.
1043  void setLinkOrder(JITDylibSearchOrder NewSearchOrder,
1044  bool LinkAgainstThisJITDylibFirst = true);
1045 
1046  /// Add the given JITDylib to the link order for definitions in this
1047  /// JITDylib.
1048  ///
1049  /// It is illegal to call this method on a defunct JITDylib and the client
1050  /// is responsible for ensuring that they do not do so.
1051  void addToLinkOrder(JITDylib &JD,
1052  JITDylibLookupFlags JDLookupFlags =
1054 
1055  /// Replace OldJD with NewJD in the link order if OldJD is present.
1056  /// Otherwise this operation is a no-op.
1057  ///
1058  /// It is illegal to call this method on a defunct JITDylib and the client
1059  /// is responsible for ensuring that they do not do so.
1060  void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
1061  JITDylibLookupFlags JDLookupFlags =
1063 
1064  /// Remove the given JITDylib from the link order for this JITDylib if it is
1065  /// present. Otherwise this operation is a no-op.
1066  ///
1067  /// It is illegal to call this method on a defunct JITDylib and the client
1068  /// is responsible for ensuring that they do not do so.
1069  void removeFromLinkOrder(JITDylib &JD);
1070 
1071  /// Do something with the link order (run under the session lock).
1072  ///
1073  /// It is illegal to call this method on a defunct JITDylib and the client
1074  /// is responsible for ensuring that they do not do so.
1075  template <typename Func>
1076  auto withLinkOrderDo(Func &&F)
1077  -> decltype(F(std::declval<const JITDylibSearchOrder &>()));
1078 
1079  /// Define all symbols provided by the materialization unit to be part of this
1080  /// JITDylib.
1081  ///
1082  /// If RT is not specified then the default resource tracker will be used.
1083  ///
1084  /// This overload always takes ownership of the MaterializationUnit. If any
1085  /// errors occur, the MaterializationUnit consumed.
1086  ///
1087  /// It is illegal to call this method on a defunct JITDylib and the client
1088  /// is responsible for ensuring that they do not do so.
1089  template <typename MaterializationUnitType>
1090  Error define(std::unique_ptr<MaterializationUnitType> &&MU,
1091  ResourceTrackerSP RT = nullptr);
1092 
1093  /// Define all symbols provided by the materialization unit to be part of this
1094  /// JITDylib.
1095  ///
1096  /// This overload only takes ownership of the MaterializationUnit no error is
1097  /// generated. If an error occurs, ownership remains with the caller. This
1098  /// may allow the caller to modify the MaterializationUnit to correct the
1099  /// issue, then re-call define.
1100  ///
1101  /// It is illegal to call this method on a defunct JITDylib and the client
1102  /// is responsible for ensuring that they do not do so.
1103  template <typename MaterializationUnitType>
1104  Error define(std::unique_ptr<MaterializationUnitType> &MU,
1105  ResourceTrackerSP RT = nullptr);
1106 
1107  /// Tries to remove the given symbols.
1108  ///
1109  /// If any symbols are not defined in this JITDylib this method will return
1110  /// a SymbolsNotFound error covering the missing symbols.
1111  ///
1112  /// If all symbols are found but some symbols are in the process of being
1113  /// materialized this method will return a SymbolsCouldNotBeRemoved error.
1114  ///
1115  /// On success, all symbols are removed. On failure, the JITDylib state is
1116  /// left unmodified (no symbols are removed).
1117  ///
1118  /// It is illegal to call this method on a defunct JITDylib and the client
1119  /// is responsible for ensuring that they do not do so.
1120  Error remove(const SymbolNameSet &Names);
1121 
1122  /// Returns the given JITDylibs and all of their transitive dependencies in
1123  /// DFS order (based on linkage relationships). Each JITDylib will appear
1124  /// only once.
1125  ///
1126  /// If any JITDylib in the order is defunct then this method will return an
1127  /// error, otherwise returns the order.
1130 
1131  /// Returns the given JITDylibs and all of their transitive dependencies in
1132  /// reverse DFS order (based on linkage relationships). Each JITDylib will
1133  /// appear only once.
1134  ///
1135  /// If any JITDylib in the order is defunct then this method will return an
1136  /// error, otherwise returns the order.
1139 
1140  /// Return this JITDylib and its transitive dependencies in DFS order
1141  /// based on linkage relationships.
1142  ///
1143  /// If any JITDylib in the order is defunct then this method will return an
1144  /// error, otherwise returns the order.
1146 
1147  /// Rteurn this JITDylib and its transitive dependencies in reverse DFS order
1148  /// based on linkage relationships.
1149  ///
1150  /// If any JITDylib in the order is defunct then this method will return an
1151  /// error, otherwise returns the order.
1153 
1154 private:
1155  using AsynchronousSymbolQuerySet =
1156  std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
1157 
1158  using AsynchronousSymbolQueryList =
1159  std::vector<std::shared_ptr<AsynchronousSymbolQuery>>;
1160 
1161  struct UnmaterializedInfo {
1162  UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU,
1163  ResourceTracker *RT)
1164  : MU(std::move(MU)), RT(RT) {}
1165 
1166  std::unique_ptr<MaterializationUnit> MU;
1167  ResourceTracker *RT;
1168  };
1169 
1170  using UnmaterializedInfosMap =
1171  DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
1172 
1173  using UnmaterializedInfosList =
1174  std::vector<std::shared_ptr<UnmaterializedInfo>>;
1175 
1176  struct MaterializingInfo {
1177  SymbolDependenceMap Dependants;
1178  SymbolDependenceMap UnemittedDependencies;
1179 
1180  void addQuery(std::shared_ptr<AsynchronousSymbolQuery> Q);
1181  void removeQuery(const AsynchronousSymbolQuery &Q);
1182  AsynchronousSymbolQueryList takeQueriesMeeting(SymbolState RequiredState);
1183  AsynchronousSymbolQueryList takeAllPendingQueries() {
1184  return std::move(PendingQueries);
1185  }
1186  bool hasQueriesPending() const { return !PendingQueries.empty(); }
1187  const AsynchronousSymbolQueryList &pendingQueries() const {
1188  return PendingQueries;
1189  }
1190  private:
1191  AsynchronousSymbolQueryList PendingQueries;
1192  };
1193 
1194  using MaterializingInfosMap = DenseMap<SymbolStringPtr, MaterializingInfo>;
1195 
1196  class SymbolTableEntry {
1197  public:
1198  SymbolTableEntry() = default;
1199  SymbolTableEntry(JITSymbolFlags Flags)
1200  : Flags(Flags), State(static_cast<uint8_t>(SymbolState::NeverSearched)),
1201  MaterializerAttached(false), PendingRemoval(false) {}
1202 
1203  JITTargetAddress getAddress() const { return Addr; }
1204  JITSymbolFlags getFlags() const { return Flags; }
1205  SymbolState getState() const { return static_cast<SymbolState>(State); }
1206 
1207  bool hasMaterializerAttached() const { return MaterializerAttached; }
1208  bool isPendingRemoval() const { return PendingRemoval; }
1209 
1210  void setAddress(JITTargetAddress Addr) { this->Addr = Addr; }
1211  void setFlags(JITSymbolFlags Flags) { this->Flags = Flags; }
1212  void setState(SymbolState State) {
1213  assert(static_cast<uint8_t>(State) < (1 << 6) &&
1214  "State does not fit in bitfield");
1215  this->State = static_cast<uint8_t>(State);
1216  }
1217 
1218  void setMaterializerAttached(bool MaterializerAttached) {
1219  this->MaterializerAttached = MaterializerAttached;
1220  }
1221 
1222  void setPendingRemoval(bool PendingRemoval) {
1223  this->PendingRemoval = PendingRemoval;
1224  }
1225 
1226  JITEvaluatedSymbol getSymbol() const {
1227  return JITEvaluatedSymbol(Addr, Flags);
1228  }
1229 
1230  private:
1231  JITTargetAddress Addr = 0;
1232  JITSymbolFlags Flags;
1233  uint8_t State : 6;
1234  uint8_t MaterializerAttached : 1;
1235  uint8_t PendingRemoval : 1;
1236  };
1237 
1238  using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;
1239 
1240  JITDylib(ExecutionSession &ES, std::string Name);
1241 
1242  std::pair<AsynchronousSymbolQuerySet, std::shared_ptr<SymbolDependenceMap>>
1243  removeTracker(ResourceTracker &RT);
1244 
1245  void transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1246 
1247  Error defineImpl(MaterializationUnit &MU);
1248 
1249  void installMaterializationUnit(std::unique_ptr<MaterializationUnit> MU,
1250  ResourceTracker &RT);
1251 
1252  void detachQueryHelper(AsynchronousSymbolQuery &Q,
1253  const SymbolNameSet &QuerySymbols);
1254 
1255  void transferEmittedNodeDependencies(MaterializingInfo &DependantMI,
1256  const SymbolStringPtr &DependantName,
1257  MaterializingInfo &EmittedMI);
1258 
1259  Expected<SymbolFlagsMap> defineMaterializing(SymbolFlagsMap SymbolFlags);
1260 
1261  Error replace(MaterializationResponsibility &FromMR,
1262  std::unique_ptr<MaterializationUnit> MU);
1263 
1264  Expected<std::unique_ptr<MaterializationResponsibility>>
1266  SymbolStringPtr InitSymbol);
1267 
1268  SymbolNameSet getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) const;
1269 
1270  void addDependencies(const SymbolStringPtr &Name,
1271  const SymbolDependenceMap &Dependants);
1272 
1273  Error resolve(MaterializationResponsibility &MR, const SymbolMap &Resolved);
1274 
1275  Error emit(MaterializationResponsibility &MR, const SymbolFlagsMap &Emitted);
1276 
1277  void unlinkMaterializationResponsibility(MaterializationResponsibility &MR);
1278 
1279  using FailedSymbolsWorklist =
1280  std::vector<std::pair<JITDylib *, SymbolStringPtr>>;
1281 
1282  static std::pair<AsynchronousSymbolQuerySet,
1283  std::shared_ptr<SymbolDependenceMap>>
1284  failSymbols(FailedSymbolsWorklist);
1285 
1286  ExecutionSession &ES;
1287  enum { Open, Closing, Closed } State = Open;
1288  std::mutex GeneratorsMutex;
1289  SymbolTable Symbols;
1290  UnmaterializedInfosMap UnmaterializedInfos;
1291  MaterializingInfosMap MaterializingInfos;
1292  std::vector<std::shared_ptr<DefinitionGenerator>> DefGenerators;
1293  JITDylibSearchOrder LinkOrder;
1294  ResourceTrackerSP DefaultTracker;
1295 
1296  // Map trackers to sets of symbols tracked.
1297  DenseMap<ResourceTracker *, SymbolNameVector> TrackerSymbols;
1298  DenseMap<ResourceTracker *, DenseSet<MaterializationResponsibility *>>
1299  TrackerMRs;
1300 };
1301 
1302 /// Platforms set up standard symbols and mediate interactions between dynamic
1303 /// initializers (e.g. C++ static constructors) and ExecutionSession state.
1304 /// Note that Platforms do not automatically run initializers: clients are still
1305 /// responsible for doing this.
1306 class Platform {
1307 public:
1308  virtual ~Platform();
1309 
1310  /// This method will be called outside the session lock each time a JITDylib
1311  /// is created (unless it is created with EmptyJITDylib set) to allow the
1312  /// Platform to install any JITDylib specific standard symbols (e.g
1313  /// __dso_handle).
1314  virtual Error setupJITDylib(JITDylib &JD) = 0;
1315 
1316  /// This method will be called outside the session lock each time a JITDylib
1317  /// is removed to allow the Platform to remove any JITDylib-specific data.
1318  virtual Error teardownJITDylib(JITDylib &JD) = 0;
1319 
1320  /// This method will be called under the ExecutionSession lock each time a
1321  /// MaterializationUnit is added to a JITDylib.
1322  virtual Error notifyAdding(ResourceTracker &RT,
1323  const MaterializationUnit &MU) = 0;
1324 
1325  /// This method will be called under the ExecutionSession lock when a
1326  /// ResourceTracker is removed.
1327  virtual Error notifyRemoving(ResourceTracker &RT) = 0;
1328 
1329  /// A utility function for looking up initializer symbols. Performs a blocking
1330  /// lookup for the given symbols in each of the given JITDylibs.
1331  ///
1332  /// Note: This function is deprecated and will be removed in the near future.
1335  const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
1336 
1337  /// Performs an async lookup for the given symbols in each of the given
1338  /// JITDylibs, calling the given handler once all lookups have completed.
1339  static void
1340  lookupInitSymbolsAsync(unique_function<void(Error)> OnComplete,
1341  ExecutionSession &ES,
1342  const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
1343 };
1344 
1345 /// A materialization task.
1346 class MaterializationTask : public RTTIExtends<MaterializationTask, Task> {
1347 public:
1348  static char ID;
1349 
1350  MaterializationTask(std::unique_ptr<MaterializationUnit> MU,
1351  std::unique_ptr<MaterializationResponsibility> MR)
1352  : MU(std::move(MU)), MR(std::move(MR)) {}
1353  void printDescription(raw_ostream &OS) override;
1354  void run() override;
1355 
1356 private:
1357  std::unique_ptr<MaterializationUnit> MU;
1358  std::unique_ptr<MaterializationResponsibility> MR;
1359 };
1360 
1361 /// An ExecutionSession represents a running JIT program.
1365  friend class JITDylib;
1366  friend class LookupState;
1368  friend class ResourceTracker;
1369 
1370 public:
1371  /// For reporting errors.
1373 
1374  /// Send a result to the remote.
1376 
1377  /// For dispatching ORC tasks (typically materialization tasks).
1378  using DispatchTaskFunction = unique_function<void(std::unique_ptr<Task> T)>;
1379 
1380  /// An asynchronous wrapper-function callable from the executor via
1381  /// jit-dispatch.
1383  SendResultFunction SendResult,
1384  const char *ArgData, size_t ArgSize)>;
1385 
1386  /// A map associating tag names with asynchronous wrapper function
1387  /// implementations in the JIT.
1390 
1391  /// Construct an ExecutionSession with the given ExecutorProcessControl
1392  /// object.
1393  ExecutionSession(std::unique_ptr<ExecutorProcessControl> EPC);
1394 
1395  /// Destroy an ExecutionSession. Verifies that endSession was called prior to
1396  /// destruction.
1398 
1399  /// End the session. Closes all JITDylibs and disconnects from the
1400  /// executor. Clients must call this method before destroying the session.
1401  Error endSession();
1402 
1403  /// Get the ExecutorProcessControl object associated with this
1404  /// ExecutionSession.
1406 
1407  /// Get the SymbolStringPool for this instance.
1408  std::shared_ptr<SymbolStringPool> getSymbolStringPool() {
1409  return EPC->getSymbolStringPool();
1410  }
1411 
1412  /// Add a symbol name to the SymbolStringPool and return a pointer to it.
1413  SymbolStringPtr intern(StringRef SymName) { return EPC->intern(SymName); }
1414 
1415  /// Set the Platform for this ExecutionSession.
1416  void setPlatform(std::unique_ptr<Platform> P) { this->P = std::move(P); }
1417 
1418  /// Get the Platform for this session.
1419  /// Will return null if no Platform has been set for this ExecutionSession.
1420  Platform *getPlatform() { return P.get(); }
1421 
1422  /// Run the given lambda with the session mutex locked.
1423  template <typename Func> decltype(auto) runSessionLocked(Func &&F) {
1424  std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
1425  return F();
1426  }
1427 
1428  /// Register the given ResourceManager with this ExecutionSession.
1429  /// Managers will be notified of events in reverse order of registration.
1431 
1432  /// Deregister the given ResourceManager with this ExecutionSession.
1433  /// Manager must have been previously registered.
1435 
1436  /// Return a pointer to the "name" JITDylib.
1437  /// Ownership of JITDylib remains within Execution Session
1439 
1440  /// Add a new bare JITDylib to this ExecutionSession.
1441  ///
1442  /// The JITDylib Name is required to be unique. Clients should verify that
1443  /// names are not being re-used (E.g. by calling getJITDylibByName) if names
1444  /// are based on user input.
1445  ///
1446  /// This call does not install any library code or symbols into the newly
1447  /// created JITDylib. The client is responsible for all configuration.
1448  JITDylib &createBareJITDylib(std::string Name);
1449 
1450  /// Add a new JITDylib to this ExecutionSession.
1451  ///
1452  /// The JITDylib Name is required to be unique. Clients should verify that
1453  /// names are not being re-used (e.g. by calling getJITDylibByName) if names
1454  /// are based on user input.
1455  ///
1456  /// If a Platform is attached then Platform::setupJITDylib will be called to
1457  /// install standard platform symbols (e.g. standard library interposes).
1458  /// If no Platform is attached this call is equivalent to createBareJITDylib.
1460 
1461  /// Closes the given JITDylib.
1462  ///
1463  /// This method clears all resources held for the JITDylib, puts it in the
1464  /// closed state, and clears all references held by the ExecutionSession and
1465  /// other JITDylibs. No further code can be added to the JITDylib, and the
1466  /// object will be freed once any remaining JITDylibSPs to it are destroyed.
1467  ///
1468  /// This method does *not* run static destructors.
1469  ///
1470  /// This method can only be called once for each JITDylib.
1472 
1473  /// Set the error reporter function.
1475  this->ReportError = std::move(ReportError);
1476  return *this;
1477  }
1478 
1479  /// Report a error for this execution session.
1480  ///
1481  /// Unhandled errors can be sent here to log them.
1482  void reportError(Error Err) { ReportError(std::move(Err)); }
1483 
1484  /// Set the task dispatch function.
1486  this->DispatchTask = std::move(DispatchTask);
1487  return *this;
1488  }
1489 
1490  /// Search the given JITDylibs to find the flags associated with each of the
1491  /// given symbols.
1492  void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder,
1493  SymbolLookupSet Symbols,
1494  unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
1495 
1496  /// Blocking version of lookupFlags.
1498  JITDylibSearchOrder SearchOrder,
1499  SymbolLookupSet Symbols);
1500 
1501  /// Search the given JITDylibs for the given symbols.
1502  ///
1503  /// SearchOrder lists the JITDylibs to search. For each dylib, the associated
1504  /// boolean indicates whether the search should match against non-exported
1505  /// (hidden visibility) symbols in that dylib (true means match against
1506  /// non-exported symbols, false means do not match).
1507  ///
1508  /// The NotifyComplete callback will be called once all requested symbols
1509  /// reach the required state.
1510  ///
1511  /// If all symbols are found, the RegisterDependencies function will be called
1512  /// while the session lock is held. This gives clients a chance to register
1513  /// dependencies for on the queried symbols for any symbols they are
1514  /// materializing (if a MaterializationResponsibility instance is present,
1515  /// this can be implemented by calling
1516  /// MaterializationResponsibility::addDependencies). If there are no
1517  /// dependenant symbols for this query (e.g. it is being made by a top level
1518  /// client to get an address to call) then the value NoDependenciesToRegister
1519  /// can be used.
1520  void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder,
1521  SymbolLookupSet Symbols, SymbolState RequiredState,
1522  SymbolsResolvedCallback NotifyComplete,
1523  RegisterDependenciesFunction RegisterDependencies);
1524 
1525  /// Blocking version of lookup above. Returns the resolved symbol map.
1526  /// If WaitUntilReady is true (the default), will not return until all
1527  /// requested symbols are ready (or an error occurs). If WaitUntilReady is
1528  /// false, will return as soon as all requested symbols are resolved,
1529  /// or an error occurs. If WaitUntilReady is false and an error occurs
1530  /// after resolution, the function will return a success value, but the
1531  /// error will be reported via reportErrors.
1532  Expected<SymbolMap> lookup(const JITDylibSearchOrder &SearchOrder,
1533  SymbolLookupSet Symbols,
1535  SymbolState RequiredState = SymbolState::Ready,
1536  RegisterDependenciesFunction RegisterDependencies =
1538 
1539  /// Convenience version of blocking lookup.
1540  /// Searches each of the JITDylibs in the search order in turn for the given
1541  /// symbol.
1543  lookup(const JITDylibSearchOrder &SearchOrder, SymbolStringPtr Symbol,
1544  SymbolState RequiredState = SymbolState::Ready);
1545 
1546  /// Convenience version of blocking lookup.
1547  /// Searches each of the JITDylibs in the search order in turn for the given
1548  /// symbol. The search will not find non-exported symbols.
1551  SymbolState RequiredState = SymbolState::Ready);
1552 
1553  /// Convenience version of blocking lookup.
1554  /// Searches each of the JITDylibs in the search order in turn for the given
1555  /// symbol. The search will not find non-exported symbols.
1558  SymbolState RequiredState = SymbolState::Ready);
1559 
1560  /// Materialize the given unit.
1561  void dispatchTask(std::unique_ptr<Task> T) {
1562  assert(T && "T must be non-null");
1563  DEBUG_WITH_TYPE("orc", dumpDispatchInfo(*T));
1564  DispatchTask(std::move(T));
1565  }
1566 
1567  /// Run a wrapper function in the executor.
1568  ///
1569  /// The wrapper function should be callable as:
1570  ///
1571  /// \code{.cpp}
1572  /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
1573  /// \endcode{.cpp}
1574  ///
1575  /// The given OnComplete function will be called to return the result.
1576  template <typename... ArgTs>
1577  void callWrapperAsync(ArgTs &&... Args) {
1578  EPC->callWrapperAsync(std::forward<ArgTs>(Args)...);
1579  }
1580 
1581  /// Run a wrapper function in the executor. The wrapper function should be
1582  /// callable as:
1583  ///
1584  /// \code{.cpp}
1585  /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
1586  /// \endcode{.cpp}
1588  ArrayRef<char> ArgBuffer) {
1589  return EPC->callWrapper(WrapperFnAddr, ArgBuffer);
1590  }
1591 
1592  /// Run a wrapper function using SPS to serialize the arguments and
1593  /// deserialize the results.
1594  template <typename SPSSignature, typename SendResultT, typename... ArgTs>
1595  void callSPSWrapperAsync(ExecutorAddr WrapperFnAddr, SendResultT &&SendResult,
1596  const ArgTs &...Args) {
1597  EPC->callSPSWrapperAsync<SPSSignature, SendResultT, ArgTs...>(
1598  WrapperFnAddr, std::forward<SendResultT>(SendResult), Args...);
1599  }
1600 
1601  /// Run a wrapper function using SPS to serialize the arguments and
1602  /// deserialize the results.
1603  ///
1604  /// If SPSSignature is a non-void function signature then the second argument
1605  /// (the first in the Args list) should be a reference to a return value.
1606  template <typename SPSSignature, typename... WrapperCallArgTs>
1608  WrapperCallArgTs &&...WrapperCallArgs) {
1609  return EPC->callSPSWrapper<SPSSignature, WrapperCallArgTs...>(
1610  WrapperFnAddr, std::forward<WrapperCallArgTs>(WrapperCallArgs)...);
1611  }
1612 
1613  /// Wrap a handler that takes concrete argument types (and a sender for a
1614  /// concrete return type) to produce an AsyncHandlerWrapperFunction. Uses SPS
1615  /// to unpack the arguments and pack the result.
1616  ///
1617  /// This function is intended to support easy construction of
1618  /// AsyncHandlerWrapperFunctions that can be associated with a tag
1619  /// (using registerJITDispatchHandler) and called from the executor.
1620  template <typename SPSSignature, typename HandlerT>
1622  return [H = std::forward<HandlerT>(H)](
1623  SendResultFunction SendResult,
1624  const char *ArgData, size_t ArgSize) mutable {
1626  std::move(SendResult));
1627  };
1628  }
1629 
1630  /// Wrap a class method that takes concrete argument types (and a sender for
1631  /// a concrete return type) to produce an AsyncHandlerWrapperFunction. Uses
1632  /// SPS to unpack teh arguments and pack the result.
1633  ///
1634  /// This function is intended to support easy construction of
1635  /// AsyncHandlerWrapperFunctions that can be associated with a tag
1636  /// (using registerJITDispatchHandler) and called from the executor.
1637  template <typename SPSSignature, typename ClassT, typename... MethodArgTs>
1639  wrapAsyncWithSPS(ClassT *Instance, void (ClassT::*Method)(MethodArgTs...)) {
1640  return wrapAsyncWithSPS<SPSSignature>(
1641  [Instance, Method](MethodArgTs &&...MethodArgs) {
1642  (Instance->*Method)(std::forward<MethodArgTs>(MethodArgs)...);
1643  });
1644  }
1645 
1646  /// For each tag symbol name, associate the corresponding
1647  /// AsyncHandlerWrapperFunction with the address of that symbol. The
1648  /// handler becomes callable from the executor using the ORC runtime
1649  /// __orc_rt_jit_dispatch function and the given tag.
1650  ///
1651  /// Tag symbols will be looked up in JD using LookupKind::Static,
1652  /// JITDylibLookupFlags::MatchAllSymbols (hidden tags will be found), and
1653  /// LookupFlags::WeaklyReferencedSymbol. Missing tag definitions will not
1654  /// cause an error, the handler will simply be dropped.
1657 
1658  /// Run a registered jit-side wrapper function.
1659  /// This should be called by the ExecutorProcessControl instance in response
1660  /// to incoming jit-dispatch requests from the executor.
1661  void
1663  JITTargetAddress HandlerFnTagAddr,
1664  ArrayRef<char> ArgBuffer);
1665 
1666  /// Dump the state of all the JITDylibs in this session.
1667  void dump(raw_ostream &OS);
1668 
1669 private:
1670  static void logErrorsToStdErr(Error Err) {
1671  logAllUnhandledErrors(std::move(Err), errs(), "JIT session error: ");
1672  }
1673 
1674  static void runOnCurrentThread(std::unique_ptr<Task> T) { T->run(); }
1675 
1676  void dispatchOutstandingMUs();
1677 
1678  static std::unique_ptr<MaterializationResponsibility>
1679  createMaterializationResponsibility(ResourceTracker &RT,
1680  SymbolFlagsMap Symbols,
1681  SymbolStringPtr InitSymbol) {
1682  auto &JD = RT.getJITDylib();
1683  std::unique_ptr<MaterializationResponsibility> MR(
1684  new MaterializationResponsibility(&RT, std::move(Symbols),
1685  std::move(InitSymbol)));
1686  JD.TrackerMRs[&RT].insert(MR.get());
1687  return MR;
1688  }
1689 
1690  Error removeResourceTracker(ResourceTracker &RT);
1691  void transferResourceTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1692  void destroyResourceTracker(ResourceTracker &RT);
1693 
1694  // State machine functions for query application..
1695 
1696  /// IL_updateCandidatesFor is called to remove already-defined symbols that
1697  /// match a given query from the set of candidate symbols to generate
1698  /// definitions for (no need to generate a definition if one already exists).
1699  Error IL_updateCandidatesFor(JITDylib &JD, JITDylibLookupFlags JDLookupFlags,
1700  SymbolLookupSet &Candidates,
1701  SymbolLookupSet *NonCandidates);
1702 
1703  /// OL_applyQueryPhase1 is an optionally re-startable loop for triggering
1704  /// definition generation. It is called when a lookup is performed, and again
1705  /// each time that LookupState::continueLookup is called.
1706  void OL_applyQueryPhase1(std::unique_ptr<InProgressLookupState> IPLS,
1707  Error Err);
1708 
1709  /// OL_completeLookup is run once phase 1 successfully completes for a lookup
1710  /// call. It attempts to attach the symbol to all symbol table entries and
1711  /// collect all MaterializationUnits to dispatch. If this method fails then
1712  /// all MaterializationUnits will be left un-materialized.
1713  void OL_completeLookup(std::unique_ptr<InProgressLookupState> IPLS,
1714  std::shared_ptr<AsynchronousSymbolQuery> Q,
1715  RegisterDependenciesFunction RegisterDependencies);
1716 
1717  /// OL_completeLookupFlags is run once phase 1 successfully completes for a
1718  /// lookupFlags call.
1719  void OL_completeLookupFlags(
1720  std::unique_ptr<InProgressLookupState> IPLS,
1721  unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
1722 
1723  // State machine functions for MaterializationResponsibility.
1724  void OL_destroyMaterializationResponsibility(
1726  SymbolNameSet OL_getRequestedSymbols(const MaterializationResponsibility &MR);
1727  Error OL_notifyResolved(MaterializationResponsibility &MR,
1728  const SymbolMap &Symbols);
1729  Error OL_notifyEmitted(MaterializationResponsibility &MR);
1730  Error OL_defineMaterializing(MaterializationResponsibility &MR,
1732  void OL_notifyFailed(MaterializationResponsibility &MR);
1733  Error OL_replace(MaterializationResponsibility &MR,
1734  std::unique_ptr<MaterializationUnit> MU);
1735  Expected<std::unique_ptr<MaterializationResponsibility>>
1736  OL_delegate(MaterializationResponsibility &MR, const SymbolNameSet &Symbols);
1737  void OL_addDependencies(MaterializationResponsibility &MR,
1738  const SymbolStringPtr &Name,
1739  const SymbolDependenceMap &Dependencies);
1740  void OL_addDependenciesForAll(MaterializationResponsibility &MR,
1741  const SymbolDependenceMap &Dependencies);
1742 
1743 #ifndef NDEBUG
1744  void dumpDispatchInfo(Task &T);
1745 #endif // NDEBUG
1746 
1747  mutable std::recursive_mutex SessionMutex;
1748  bool SessionOpen = true;
1749  std::unique_ptr<ExecutorProcessControl> EPC;
1750  std::unique_ptr<Platform> P;
1751  ErrorReporter ReportError = logErrorsToStdErr;
1752  DispatchTaskFunction DispatchTask = runOnCurrentThread;
1753 
1754  std::vector<ResourceManager *> ResourceManagers;
1755 
1756  std::vector<JITDylibSP> JDs;
1757 
1758  // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
1759  // with callbacks from asynchronous queries.
1760  mutable std::recursive_mutex OutstandingMUsMutex;
1761  std::vector<std::pair<std::unique_ptr<MaterializationUnit>,
1762  std::unique_ptr<MaterializationResponsibility>>>
1763  OutstandingMUs;
1764 
1765  mutable std::mutex JITDispatchHandlersMutex;
1766  DenseMap<JITTargetAddress, std::shared_ptr<JITDispatchHandlerFunction>>
1767  JITDispatchHandlers;
1768 };
1769 
1770 inline ExecutionSession &
1772  return JD.getExecutionSession();
1773 }
1774 
1775 template <typename Func>
1777  return JD.getExecutionSession().runSessionLocked([&]() -> Error {
1778  if (RT->isDefunct())
1779  return make_error<ResourceTrackerDefunct>(RT);
1780  F(RT->getKeyUnsafe());
1781  return Error::success();
1782  });
1783 }
1784 
1785 template <typename GeneratorT>
1786 GeneratorT &JITDylib::addGenerator(std::unique_ptr<GeneratorT> DefGenerator) {
1787  auto &G = *DefGenerator;
1788  ES.runSessionLocked([&] {
1789  assert(State == Open && "Cannot add generator to closed JITDylib");
1790  DefGenerators.push_back(std::move(DefGenerator));
1791  });
1792  return G;
1793 }
1794 
1795 template <typename Func>
1797  -> decltype(F(std::declval<const JITDylibSearchOrder &>())) {
1798  assert(State == Open && "Cannot use link order of closed JITDylib");
1799  return ES.runSessionLocked([&]() { return F(LinkOrder); });
1800 }
1801 
1802 template <typename MaterializationUnitType>
1803 Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &&MU,
1804  ResourceTrackerSP RT) {
1805  assert(MU && "Can not define with a null MU");
1806 
1807  if (MU->getSymbols().empty()) {
1808  // Empty MUs are allowable but pathological, so issue a warning.
1809  DEBUG_WITH_TYPE("orc", {
1810  dbgs() << "Warning: Discarding empty MU " << MU->getName() << " for "
1811  << getName() << "\n";
1812  });
1813  return Error::success();
1814  } else
1815  DEBUG_WITH_TYPE("orc", {
1816  dbgs() << "Defining MU " << MU->getName() << " for " << getName()
1817  << " (tracker: ";
1818  if (RT == getDefaultResourceTracker())
1819  dbgs() << "default)";
1820  else if (RT)
1821  dbgs() << RT.get() << ")\n";
1822  else
1823  dbgs() << "0x0, default will be used)\n";
1824  });
1825 
1826  return ES.runSessionLocked([&, this]() -> Error {
1827  assert(State == Open && "JD is defunct");
1828 
1829  if (auto Err = defineImpl(*MU))
1830  return Err;
1831 
1832  if (!RT)
1834 
1835  if (auto *P = ES.getPlatform()) {
1836  if (auto Err = P->notifyAdding(*RT, *MU))
1837  return Err;
1838  }
1839 
1840  installMaterializationUnit(std::move(MU), *RT);
1841  return Error::success();
1842  });
1843 }
1844 
1845 template <typename MaterializationUnitType>
1846 Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &MU,
1847  ResourceTrackerSP RT) {
1848  assert(MU && "Can not define with a null MU");
1849 
1850  if (MU->getSymbols().empty()) {
1851  // Empty MUs are allowable but pathological, so issue a warning.
1852  DEBUG_WITH_TYPE("orc", {
1853  dbgs() << "Warning: Discarding empty MU " << MU->getName() << getName()
1854  << "\n";
1855  });
1856  return Error::success();
1857  } else
1858  DEBUG_WITH_TYPE("orc", {
1859  dbgs() << "Defining MU " << MU->getName() << " for " << getName()
1860  << " (tracker: ";
1861  if (RT == getDefaultResourceTracker())
1862  dbgs() << "default)";
1863  else if (RT)
1864  dbgs() << RT.get() << ")\n";
1865  else
1866  dbgs() << "0x0, default will be used)\n";
1867  });
1868 
1869  return ES.runSessionLocked([&, this]() -> Error {
1870  assert(State == Open && "JD is defunct");
1871 
1872  if (auto Err = defineImpl(*MU))
1873  return Err;
1874 
1875  if (!RT)
1877 
1878  if (auto *P = ES.getPlatform()) {
1879  if (auto Err = P->notifyAdding(*RT, *MU))
1880  return Err;
1881  }
1882 
1883  installMaterializationUnit(std::move(MU), *RT);
1884  return Error::success();
1885  });
1886 }
1887 
1888 /// ReexportsGenerator can be used with JITDylib::addGenerator to automatically
1889 /// re-export a subset of the source JITDylib's symbols in the target.
1891 public:
1893 
1894  /// Create a reexports generator. If an Allow predicate is passed, only
1895  /// symbols for which the predicate returns true will be reexported. If no
1896  /// Allow predicate is passed, all symbols will be exported.
1897  ReexportsGenerator(JITDylib &SourceJD,
1898  JITDylibLookupFlags SourceJDLookupFlags,
1899  SymbolPredicate Allow = SymbolPredicate());
1900 
1902  JITDylibLookupFlags JDLookupFlags,
1903  const SymbolLookupSet &LookupSet) override;
1904 
1905 private:
1906  JITDylib &SourceJD;
1907  JITDylibLookupFlags SourceJDLookupFlags;
1908  SymbolPredicate Allow;
1909 };
1910 
1911 // --------------- IMPLEMENTATION --------------
1912 // Implementations for inline functions/methods.
1913 // ---------------------------------------------
1914 
1916  getExecutionSession().OL_destroyMaterializationResponsibility(*this);
1917 }
1918 
1920  return getExecutionSession().OL_getRequestedSymbols(*this);
1921 }
1922 
1924  const SymbolMap &Symbols) {
1925  return getExecutionSession().OL_notifyResolved(*this, Symbols);
1926 }
1927 
1929  return getExecutionSession().OL_notifyEmitted(*this);
1930 }
1931 
1934  return getExecutionSession().OL_defineMaterializing(*this,
1935  std::move(SymbolFlags));
1936 }
1937 
1939  getExecutionSession().OL_notifyFailed(*this);
1940 }
1941 
1943  std::unique_ptr<MaterializationUnit> MU) {
1944  return getExecutionSession().OL_replace(*this, std::move(MU));
1945 }
1946 
1949  return getExecutionSession().OL_delegate(*this, Symbols);
1950 }
1951 
1953  const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies) {
1954  getExecutionSession().OL_addDependencies(*this, Name, Dependencies);
1955 }
1956 
1958  const SymbolDependenceMap &Dependencies) {
1959  getExecutionSession().OL_addDependenciesForAll(*this, Dependencies);
1960 }
1961 
1962 } // End namespace orc
1963 } // End namespace llvm
1964 
1965 #endif // LLVM_EXECUTIONENGINE_ORC_CORE_H
llvm::orc::ExecutorAddr
Represents an address in the executor process.
Definition: ExecutorAddress.h:30
llvm::orc::ResourceKey
uintptr_t ResourceKey
Definition: Core.h:50
llvm::orc::MaterializationResponsibility::replace
Error replace(std::unique_ptr< MaterializationUnit > MU)
Transfers responsibility to the given MaterializationUnit for all symbols defined by that Materializa...
Definition: Core.h:1942
llvm::orc::SymbolLookupSet::fromMapKeys
static SymbolLookupSet fromMapKeys(const DenseMap< SymbolStringPtr, KeyT > &M, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from DenseMap keys.
Definition: Core.h:224
llvm::orc::MaterializationTask
A materialization task.
Definition: Core.h:1346
llvm::orc::MaterializationResponsibility
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Definition: Core.h:523
llvm::orc::MaterializationTask::MaterializationTask
MaterializationTask(std::unique_ptr< MaterializationUnit > MU, std::unique_ptr< MaterializationResponsibility > MR)
Definition: Core.h:1350
llvm::orc::JITDylib::withLinkOrderDo
auto withLinkOrderDo(Func &&F) -> decltype(F(std::declval< const JITDylibSearchOrder & >()))
Do something with the link order (run under the session lock).
Definition: Core.h:1796
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::orc::SymbolsNotFound::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:122
llvm::orc::JITDylib
Represents a JIT'd dynamic library.
Definition: Core.h:950
llvm::orc::ReexportsGenerator::tryToGenerate
Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &LookupSet) override
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
Definition: Core.cpp:598
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
JITSymbol.h
llvm::lltok::Error
@ Error
Definition: LLToken.h:21
FunctionExtras.h
llvm::orc::SymbolLookupSet::remove_if
void remove_if(PredFn &&Pred)
Removes all elements matching the given predicate, which must be callable as bool(const SymbolStringP...
Definition: Core.h:269
llvm::orc::AsynchronousSymbolQuery::notifySymbolMetRequiredState
void notifySymbolMetRequiredState(const SymbolStringPtr &Name, JITEvaluatedSymbol Sym)
Notify the query that a requested symbol has reached the required state.
Definition: Core.cpp:172
llvm::orc::SymbolLookupSet::UnderlyingVector
std::vector< value_type > UnderlyingVector
Definition: Core.h:178
llvm::orc::SymbolState::Materializing
@ Materializing
Added to the symbol table, never queried.
llvm::orc::JITDylib::setLinkOrder
void setLinkOrder(JITDylibSearchOrder NewSearchOrder, bool LinkAgainstThisJITDylibFirst=true)
Set the link order to be used when fixing up definitions in JITDylib.
Definition: Core.cpp:1316
llvm::orc::ExecutionSession::callSPSWrapperAsync
void callSPSWrapperAsync(ExecutorAddr WrapperFnAddr, SendResultT &&SendResult, const ArgTs &...Args)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: Core.h:1595
llvm::orc::DefinitionGenerator::~DefinitionGenerator
virtual ~DefinitionGenerator()
llvm::orc::ExecutionSession::reportError
void reportError(Error Err)
Report a error for this execution session.
Definition: Core.h:1482
llvm::orc::InProgressLookupState
Definition: Core.cpp:510
llvm::orc::ExecutionSession::callWrapperAsync
void callWrapperAsync(ArgTs &&... Args)
Run a wrapper function in the executor.
Definition: Core.h:1577
llvm::unique_function< void(Expected< SymbolMap >)>
llvm::orc::ExecutionSession::DispatchTaskFunction
unique_function< void(std::unique_ptr< Task > T)> DispatchTaskFunction
For dispatching ORC tasks (typically materialization tasks).
Definition: Core.h:1378
llvm::orc::MaterializationUnit::materialize
virtual void materialize(std::unique_ptr< MaterializationResponsibility > R)=0
Implementations of this method should materialize all symbols in the materialzation unit,...
llvm::orc::SymbolsCouldNotBeRemoved::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:132
llvm::orc::ResourceTrackerDefunct
Definition: Core.h:405
llvm::orc::JITDylib::addToLinkOrder
void addToLinkOrder(JITDylib &JD, JITDylibLookupFlags JDLookupFlags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Add the given JITDylib to the link order for definitions in this JITDylib.
Definition: Core.cpp:1331
llvm::orc::ExecutionSession::getJITDylibByName
JITDylib * getJITDylibByName(StringRef Name)
Return a pointer to the "name" JITDylib.
Definition: Core.cpp:1931
llvm::orc::LookupState::operator=
LookupState & operator=(LookupState &&)
llvm::orc::ResourceTrackerDefunct::ID
static char ID
Definition: Core.h:407
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::orc::JITDylib::dump
void dump(raw_ostream &OS)
Dump current JITDylib state to OS.
Definition: Core.cpp:1418
llvm::orc::JITDylib::getDefaultResourceTracker
ResourceTrackerSP getDefaultResourceTracker()
Get the default resource tracker for this JITDylib.
Definition: Core.cpp:660
llvm::orc::JITDylib::ExecutionSession
friend class ExecutionSession
Definition: Core.h:953
llvm::orc::AbsoluteSymbolsMaterializationUnit
A MaterializationUnit implementation for pre-existing absolute symbols.
Definition: Core.h:735
llvm::orc::ResourceTrackerDefunct::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:74
llvm::orc::SymbolAliasMapEntry::SymbolAliasMapEntry
SymbolAliasMapEntry(SymbolStringPtr Aliasee, JITSymbolFlags AliasFlags)
Definition: Core.h:384
llvm::orc::MaterializationResponsibility::notifyResolved
Error notifyResolved(const SymbolMap &Symbols)
Notifies the target JITDylib that the given symbols have been resolved.
Definition: Core.h:1923
llvm::orc::MaterializationUnit::doDiscard
void doDiscard(const JITDylib &JD, const SymbolStringPtr &Name)
Called by JITDylibs to notify MaterializationUnits that the given symbol has been overridden.
Definition: Core.h:712
llvm::orc::ExecutionSession::removeJITDylib
Error removeJITDylib(JITDylib &JD)
Closes the given JITDylib.
Definition: Core.cpp:1956
llvm::orc::SymbolLookupSet
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Definition: Core.h:175
llvm::orc::Platform::~Platform
virtual ~Platform()
llvm::orc::LookupKind::Static
@ Static
llvm::orc::SymbolsCouldNotBeRemoved::getSymbols
const SymbolNameSet & getSymbols() const
Definition: Core.h:463
llvm::orc::SymbolStringPtr
Pointer to a pooled string representing a symbol name.
Definition: SymbolStringPool.h:50
llvm::orc::ReExportsMaterializationUnit::getName
StringRef getName() const override
Return the name of this materialization unit.
Definition: Core.cpp:303
llvm::orc::MaterializationResponsibility::defineNonExistent
void defineNonExistent(ArrayRef< SymbolStringPtr > Symbols)
Define the given symbols as non-existent, removing it from the symbol table and notifying any pending...
llvm::orc::shared::WrapperFunction
Definition: WrapperFunctionUtils.h:434
llvm::orc::ResourceManager::~ResourceManager
virtual ~ResourceManager()
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::orc::JITDylib::clear
Error clear()
Calls remove on all trackers currently associated with this JITDylib.
Definition: Core.cpp:645
llvm::orc::ExecutionSession::ResourceTracker
friend class ResourceTracker
Definition: Core.h:1368
llvm::orc::UnexpectedSymbolDefinitions::UnexpectedSymbolDefinitions
UnexpectedSymbolDefinitions(std::shared_ptr< SymbolStringPool > SSP, std::string ModuleName, SymbolNameVector Symbols)
Definition: Core.h:501
llvm::orc::ReExportsMaterializationUnit
A materialization unit for symbol aliases.
Definition: Core.h:767
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:304
llvm::orc::SymbolsCouldNotBeRemoved
Used to notify clients that a set of symbols could not be removed.
Definition: Core.h:454
WrapperFunctionUtils.h
llvm::orc::FailedToMaterialize::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:96
llvm::orc::SymbolsNotFound::getSymbolStringPool
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Definition: Core.h:445
llvm::orc::LookupState::~LookupState
~LookupState()
llvm::orc::ExecutorProcessControl
ExecutorProcessControl supports interaction with a JIT target process.
Definition: ExecutorProcessControl.h:38
llvm::orc::SymbolState::Invalid
@ Invalid
llvm::orc::ResourceTracker
API to remove / transfer ownership of JIT resources.
Definition: Core.h:53
llvm::orc::JITDylib::~JITDylib
~JITDylib()
Definition: Core.cpp:641
llvm::orc::SymbolLookupSet::end
const_iterator end() const
Definition: Core.h:255
llvm::orc::MaterializationResponsibility::defineMaterializing
Error defineMaterializing(SymbolFlagsMap SymbolFlags)
Attempt to claim responsibility for new definitions.
Definition: Core.h:1932
llvm::orc::ExecutionSession::registerResourceManager
void registerResourceManager(ResourceManager &RM)
Register the given ResourceManager with this ExecutionSession.
Definition: Core.cpp:1914
llvm::orc::MaterializationTask::run
void run() override
Definition: Core.cpp:1881
llvm::DenseMapBase::count
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:147
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::orc::MaterializationUnit::Interface::InitSymbol
SymbolStringPtr InitSymbol
Definition: Core.h:686
llvm::orc::SymbolsCouldNotBeRemoved::SymbolsCouldNotBeRemoved
SymbolsCouldNotBeRemoved(std::shared_ptr< SymbolStringPool > SSP, SymbolNameSet Symbols)
Definition: Core.cpp:126
llvm::orc::FailedToMaterialize::getSymbols
const SymbolDependenceMap & getSymbols() const
Definition: Core.h:428
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::orc::LookupState::continueLookup
void continueLookup(Error Err)
Continue the lookup.
Definition: Core.cpp:633
llvm::orc::UnexpectedSymbolDefinitions::getSymbolStringPool
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Definition: Core.h:507
llvm::orc::Platform::lookupInitSymbolsAsync
static void lookupInitSymbolsAsync(unique_function< void(Error)> OnComplete, ExecutionSession &ES, const DenseMap< JITDylib *, SymbolLookupSet > &InitSyms)
Performs an async lookup for the given symbols in each of the given JITDylibs, calling the given hand...
Definition: Core.cpp:1833
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::orc::UnexpectedSymbolDefinitions
Errors of this type should be returned if a module contains definitions for symbols that are not clai...
Definition: Core.h:497
llvm::orc::SymbolsNotFound::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:118
llvm::orc::SymbolsCouldNotBeRemoved::getSymbolStringPool
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Definition: Core.h:462
IntrusiveRefCntPtr.h
llvm::orc::LookupKind
LookupKind
Describes the kind of lookup being performed.
Definition: Core.h:149
ExtensibleRTTI.h
llvm::JITSymbolFlags
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
llvm::MachO::SymbolFlags
SymbolFlags
Symbol flags.
Definition: Symbol.h:24
llvm::orc::MaterializationUnit
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
Definition: Core.h:669
llvm::orc::ExecutionSession::runJITDispatchHandler
void runJITDispatchHandler(SendResultFunction SendResult, JITTargetAddress HandlerFnTagAddr, ArrayRef< char > ArgBuffer)
Run a registered jit-side wrapper function.
Definition: Core.cpp:2217
llvm::orc::ExecutionSession::dispatchTask
void dispatchTask(std::unique_ptr< Task > T)
Materialize the given unit.
Definition: Core.h:1561
llvm::orc::ExecutionSession::JITDylib
friend class JITDylib
Definition: Core.h:1365
llvm::orc::SymbolLookupSet::sortByName
void sortByName()
Sort the lookup set lexicographically.
Definition: Core.h:350
llvm::orc::MissingSymbolDefinitions::getModuleName
const std::string & getModuleName() const
Definition: Core.h:485
llvm::JITEvaluatedSymbol
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:229
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::orc::JITDylib::createResourceTracker
ResourceTrackerSP createResourceTracker()
Create a resource tracker for this JITDylib.
Definition: Core.cpp:669
llvm::orc::buildSimpleReexportsAliasMap
Expected< SymbolAliasMap > buildSimpleReexportsAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols)
Build a SymbolAliasMap for the common case where you want to re-export symbols from another JITDylib ...
llvm::orc::FailedToMaterialize::ID
static char ID
Definition: Core.h:421
llvm::orc::MaterializationUnit::getName
virtual StringRef getName() const =0
Return the name of this materialization unit.
llvm::orc::Platform::notifyRemoving
virtual Error notifyRemoving(ResourceTracker &RT)=0
This method will be called under the ExecutionSession lock when a ResourceTracker is removed.
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::Lock
static sys::Mutex Lock
Definition: NVPTXUtilities.cpp:39
llvm::orc::RegisterDependenciesFunction
std::function< void(const SymbolDependenceMap &)> RegisterDependenciesFunction
Callback to register the dependencies for a given query.
Definition: Core.h:399
llvm::orc::JITDylib::replaceInLinkOrder
void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD, JITDylibLookupFlags JDLookupFlags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Replace OldJD with NewJD in the link order if OldJD is present.
Definition: Core.cpp:1335
llvm::orc::JITDylib::JITDylib
JITDylib(const JITDylib &)=delete
llvm::orc::ExecutionSession::SendResultFunction
unique_function< void(shared::WrapperFunctionResult)> SendResultFunction
Send a result to the remote.
Definition: Core.h:1375
llvm::orc::ResourceTracker::getJITDylib
JITDylib & getJITDylib() const
Return the JITDylib targeted by this tracker.
Definition: Core.h:68
llvm::orc::ExecutionSession::dump
void dump(raw_ostream &OS)
Dump the state of all the JITDylibs in this session.
Definition: Core.cpp:2238
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::orc::ExecutionSession::registerJITDispatchHandlers
Error registerJITDispatchHandlers(JITDylib &JD, JITDispatchHandlerAssociationMap WFs)
For each tag symbol name, associate the corresponding AsyncHandlerWrapperFunction with the address of...
Definition: Core.cpp:2186
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet(SymbolStringPtr Name, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Definition: Core.h:184
llvm::orc::SymbolState
SymbolState
Represents the state that a symbol has reached during materialization.
Definition: Core.h:828
DEBUG_WITH_TYPE
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
Definition: Debug.h:64
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet(std::initializer_list< SymbolStringPtr > Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from an initializer list of SymbolStringPtrs.
Definition: Core.h:191
llvm::orc::MissingSymbolDefinitions::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:144
llvm::orc::SymbolLookupFlags
SymbolLookupFlags
Lookup flags that apply to each symbol in a lookup.
Definition: Core.h:137
llvm::orc::MaterializationResponsibility::getSymbols
const SymbolFlagsMap & getSymbols() const
Returns the symbol flags map for this responsibility instance.
Definition: Core.h:551
llvm::orc::SymbolLookupSet::forEachWithRemoval
auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t< std::is_same< decltype(Body(std::declval< const SymbolStringPtr & >(), std::declval< SymbolLookupFlags >())), bool >::value >
Loop over the elements of this SymbolLookupSet, applying the Body function to each one.
Definition: Core.h:287
llvm::orc::UnexpectedSymbolDefinitions::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:153
llvm::orc::UnexpectedSymbolDefinitions::getModuleName
const std::string & getModuleName() const
Definition: Core.h:508
llvm::orc::Platform::setupJITDylib
virtual Error setupJITDylib(JITDylib &JD)=0
This method will be called outside the session lock each time a JITDylib is created (unless it is cre...
llvm::orc::SymbolLookupSet::end
iterator end()
Definition: Core.h:253
llvm::orc::Platform::lookupInitSymbols
static Expected< DenseMap< JITDylib *, SymbolMap > > lookupInitSymbols(ExecutionSession &ES, const DenseMap< JITDylib *, SymbolLookupSet > &InitSyms)
A utility function for looking up initializer symbols.
Definition: Core.cpp:1784
llvm::orc::SymbolLookupSet::containsDuplicates
bool containsDuplicates()
Returns true if this set contains any duplicates.
Definition: Core.h:367
llvm::orc::SymbolsNotFound
Used to notify clients when symbols can not be found during a lookup.
Definition: Core.h:436
llvm::orc::Platform::notifyAdding
virtual Error notifyAdding(ResourceTracker &RT, const MaterializationUnit &MU)=0
This method will be called under the ExecutionSession lock each time a MaterializationUnit is added t...
llvm::orc::UnexpectedSymbolDefinitions::ID
static char ID
Definition: Core.h:499
llvm::orc::SymbolLookupSet::remove
void remove(iterator I)
Removes the element pointed to by the given iterator.
Definition: Core.h:265
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet(ArrayRef< SymbolStringPtr > Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from a vector of symbols with the given Flags used for each value.
Definition: Core.h:213
llvm::orc::NoDependenciesToRegister
RegisterDependenciesFunction NoDependenciesToRegister
This can be used as the value for a RegisterDependenciesFunction if there are no dependants to regist...
Definition: Core.cpp:34
llvm::orc::AsynchronousSymbolQuery::JITSymbolResolverAdapter
friend class JITSymbolResolverAdapter
Definition: Core.h:845
llvm::orc::MaterializationResponsibility::notifyEmitted
Error notifyEmitted()
Notifies the target JITDylib (and any pending queries on that JITDylib) that all symbols covered by t...
Definition: Core.h:1928
DenseSet.h
false
Definition: StackSlotColoring.cpp:141
llvm::orc::SymbolMap
DenseMap< SymbolStringPtr, JITEvaluatedSymbol > SymbolMap
A map from symbol names (as SymbolStringPtrs) to JITSymbols (address/flags pairs).
Definition: Core.h:113
llvm::orc::MaterializationResponsibility::addDependenciesForAll
void addDependenciesForAll(const SymbolDependenceMap &Dependencies)
Add dependencies that apply to all symbols covered by this instance.
Definition: Core.h:1957
llvm::orc::FailedToMaterialize::~FailedToMaterialize
~FailedToMaterialize()
Definition: Core.cpp:91
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet(const SymbolNameSet &Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from a SymbolNameSet with the given Flags used for each value.
Definition: Core.h:201
llvm::orc::ExecutionSession::intern
SymbolStringPtr intern(StringRef SymName)
Add a symbol name to the SymbolStringPool and return a pointer to it.
Definition: Core.h:1413
llvm::detail::DenseSetImpl::size
size_type size() const
Definition: DenseSet.h:81
llvm::ThreadSafeRefCountedBase
A thread-safe version of RefCountedBase.
Definition: IntrusiveRefCntPtr.h:106
llvm::orc::JITDylib::addGenerator
GeneratorT & addGenerator(std::unique_ptr< GeneratorT > DefGenerator)
Adds a definition generator to this JITDylib and returns a referenece to it.
Definition: Core.h:1786
llvm::orc::AsynchronousSymbolQuery
A symbol query that returns results via a callback when results are ready.
Definition: Core.h:841
llvm::orc::ExecutionSession::runSessionLocked
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
Definition: Core.h:1423
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::LookupKind::DLSym
@ DLSym
llvm::orc::MaterializationUnit::Interface
Definition: Core.h:676
llvm::orc::SymbolLookupSet::add
SymbolLookupSet & add(SymbolStringPtr Name, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Add an element to the set.
Definition: Core.h:236
llvm::orc::AbsoluteSymbolsMaterializationUnit::getName
StringRef getName() const override
Return the name of this materialization unit.
Definition: Core.cpp:260
llvm::orc::MaterializationResponsibility::operator=
MaterializationResponsibility & operator=(MaterializationResponsibility &&)=delete
llvm::orc::SymbolsNotFound::ID
static char ID
Definition: Core.h:438
llvm::RTTIExtends
Inheritance utility for extensible RTTI.
Definition: ExtensibleRTTI.h:114
llvm::orc::ExecutionSession::setPlatform
void setPlatform(std::unique_ptr< Platform > P)
Set the Platform for this ExecutionSession.
Definition: Core.h:1416
llvm::orc::SymbolLookupFlags::WeaklyReferencedSymbol
@ WeaklyReferencedSymbol
llvm::orc::SymbolsNotFound::SymbolsNotFound
SymbolsNotFound(std::shared_ptr< SymbolStringPool > SSP, SymbolNameSet Symbols)
Definition: Core.cpp:104
llvm::orc::SymbolLookupSet::remove
void remove(UnderlyingVector::size_type I)
Removes the Ith element of the vector, replacing it with the last element.
Definition: Core.h:258
llvm::orc::MaterializationResponsibility::getRequestedSymbols
SymbolNameSet getRequestedSymbols() const
Returns the names of any symbols covered by this MaterializationResponsibility object that have queri...
Definition: Core.h:1919
llvm::orc::UnexpectedSymbolDefinitions::getSymbols
const SymbolNameVector & getSymbols() const
Definition: Core.h:509
llvm::orc::ExecutionSession::createBareJITDylib
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
Definition: Core.cpp:1940
llvm::orc::ExecutionSession::endSession
Error endSession()
End the session.
Definition: Core.cpp:1895
llvm::orc::SymbolLookupSet::size
UnderlyingVector::size_type size() const
Definition: Core.h:251
llvm::orc::MaterializationResponsibility::getInitializerSymbol
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization pseudo-symbol, if any.
Definition: Core.h:556
llvm::orc::MaterializationResponsibility::withResourceKeyDo
Error withResourceKeyDo(Func &&F) const
Returns the ResourceTracker for this instance.
Definition: Core.h:1776
llvm::orc::MaterializationTask::printDescription
void printDescription(raw_ostream &OS) override
Definition: Core.cpp:1876
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:200
llvm::DenseSet< SymbolStringPtr >
llvm::orc::InProgressLookupFlagsState
Definition: Core.cpp:538
llvm::orc::ExecutionSession::callWrapper
shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
Definition: Core.h:1587
llvm::orc::shared::WrapperFunctionResult
C++ wrapper function result: Same as CWrapperFunctionResult but auto-releases memory.
Definition: WrapperFunctionUtils.h:40
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::orc::ExecutionSession::JITDispatchHandlerAssociationMap
DenseMap< SymbolStringPtr, JITDispatchHandlerFunction > JITDispatchHandlerAssociationMap
A map associating tag names with asynchronous wrapper function implementations in the JIT.
Definition: Core.h:1389
llvm::orc::MissingSymbolDefinitions
Errors of this type should be returned if a module fails to include definitions that are claimed by t...
Definition: Core.h:474
llvm::orc::JITDylib::MaterializationResponsibility
friend class MaterializationResponsibility
Definition: Core.h:955
llvm::orc::JITDylib::getDFSLinkOrder
Expected< std::vector< JITDylibSP > > getDFSLinkOrder()
Return this JITDylib and its transitive dependencies in DFS order based on linkage relationships.
Definition: Core.cpp:2043
llvm::orc::ExecutionSession::~ExecutionSession
~ExecutionSession()
Destroy an ExecutionSession.
Definition: Core.cpp:1889
llvm::orc::MaterializationResponsibility::getTargetJITDylib
JITDylib & getTargetJITDylib() const
Returns the target JITDylib that these symbols are being materialized into.
Definition: Core.h:542
llvm::orc::SymbolLookupSet::value_type
std::pair< SymbolStringPtr, SymbolLookupFlags > value_type
Definition: Core.h:177
llvm::orc::ExecutionSession::setDispatchTask
ExecutionSession & setDispatchTask(DispatchTaskFunction DispatchTask)
Set the task dispatch function.
Definition: Core.h:1485
llvm::orc::MissingSymbolDefinitions::MissingSymbolDefinitions
MissingSymbolDefinitions(std::shared_ptr< SymbolStringPool > SSP, std::string ModuleName, SymbolNameVector Symbols)
Definition: Core.h:478
llvm::orc::SymbolLookupSet::append
SymbolLookupSet & append(SymbolLookupSet Other)
Quickly append one lookup set to another.
Definition: Core.h:243
llvm::orc::MaterializationUnit::getInitializerSymbol
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization symbol for this MaterializationUnit (if any).
Definition: Core.h:702
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::orc::JITDylib::getReverseDFSLinkOrder
Expected< std::vector< JITDylibSP > > getReverseDFSLinkOrder()
Rteurn this JITDylib and its transitive dependencies in reverse DFS order based on linkage relationsh...
Definition: Core.cpp:2047
llvm::orc::ExecutionSession::lookupFlags
void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder, SymbolLookupSet Symbols, unique_function< void(Expected< SymbolFlagsMap >)> OnComplete)
Search the given JITDylibs to find the flags associated with each of the given symbols.
Definition: Core.cpp:2051
llvm::orc::ResourceTracker::isDefunct
bool isDefunct() const
Return true if this tracker has become defunct.
Definition: Core.h:81
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< SymbolStringPtr, JITEvaluatedSymbol >
llvm::orc::ExecutionSession::wrapAsyncWithSPS
static JITDispatchHandlerFunction wrapAsyncWithSPS(ClassT *Instance, void(ClassT::*Method)(MethodArgTs...))
Wrap a class method that takes concrete argument types (and a sender for a concrete return type) to p...
Definition: Core.h:1639
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::orc::MaterializationUnit::getSymbols
const SymbolFlagsMap & getSymbols() const
Return the set of symbols that this source provides.
Definition: Core.h:699
llvm::orc::SymbolLookupSet::forEachWithRemoval
auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t< std::is_same< decltype(Body(std::declval< const SymbolStringPtr & >(), std::declval< SymbolLookupFlags >())), Expected< bool >>::value, Error >
Loop over the elements of this SymbolLookupSet, applying the Body function to each one.
Definition: Core.h:309
llvm::orc::MaterializationResponsibility::addDependencies
void addDependencies(const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies)
Definition: Core.h:1952
llvm::orc::SymbolState::NeverSearched
@ NeverSearched
No symbol should be in this state.
llvm::orc::ResourceTrackerSP
uint8_t IntrusiveRefCntPtr< ResourceTracker > ResourceTrackerSP
Definition: Core.h:47
llvm::orc::ExecutionSession::JITDispatchHandlerFunction
unique_function< void(SendResultFunction SendResult, const char *ArgData, size_t ArgSize)> JITDispatchHandlerFunction
An asynchronous wrapper-function callable from the executor via jit-dispatch.
Definition: Core.h:1384
llvm::orc::ReexportsGenerator::ReexportsGenerator
ReexportsGenerator(JITDylib &SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolPredicate Allow=SymbolPredicate())
Create a reexports generator.
Definition: Core.cpp:592
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::orc::AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit
AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols)
Definition: Core.cpp:256
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:1665
llvm::orc::ResourceTracker::getKeyUnsafe
ResourceKey getKeyUnsafe() const
Returns the key associated with this tracker.
Definition: Core.h:86
llvm::orc::JITDylib::AsynchronousSymbolQuery
friend class AsynchronousSymbolQuery
Definition: Core.h:952
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
llvm::orc::ExecutionSession::ExecutionSession
ExecutionSession(std::unique_ptr< ExecutorProcessControl > EPC)
Construct an ExecutionSession with the given ExecutorProcessControl object.
Definition: Core.cpp:1883
ModuleName
Definition: ItaniumDemangle.h:989
llvm::orc::MaterializationUnit::MaterializationUnit
MaterializationUnit(Interface I)
Definition: Core.h:689
llvm::orc::SymbolAliasMapEntry::SymbolAliasMapEntry
SymbolAliasMapEntry()=default
llvm::orc::ExecutionSession::callSPSWrapper
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: Core.h:1607
llvm::orc::JITDylib::remove
Error remove(const SymbolNameSet &Names)
Tries to remove the given symbols.
Definition: Core.cpp:1359
llvm::orc::SymbolLookupSet::begin
const_iterator begin() const
Definition: Core.h:254
llvm::orc::MaterializationResponsibility::JITDylib
friend class JITDylib
Definition: Core.h:525
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::orc::MaterializationUnit::Interface::Interface
Interface(SymbolFlagsMap InitalSymbolFlags, SymbolStringPtr InitSymbol)
Definition: Core.h:678
llvm::orc::SymbolLookupSet::empty
bool empty() const
Definition: Core.h:250
llvm::orc::JITDylibSearchOrder
std::vector< std::pair< JITDylib *, JITDylibLookupFlags > > JITDylibSearchOrder
A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search order during symbol lookup.
Definition: Core.h:154
llvm::orc::ResourceManager::handleRemoveResources
virtual Error handleRemoveResources(ResourceKey K)=0
llvm::orc::DefinitionGenerator
Definition generators can be attached to JITDylibs to generate new definitions for otherwise unresolv...
Definition: Core.h:915
llvm::orc::ExecutionSession::getExecutorProcessControl
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
Definition: Core.h:1405
llvm::ErrorInfo
Base class for user error types.
Definition: Error.h:347
llvm::orc::MaterializationUnit::~MaterializationUnit
virtual ~MaterializationUnit()=default
llvm::orc::JITDylib::operator=
JITDylib & operator=(const JITDylib &)=delete
llvm::orc::MaterializationResponsibility::getExecutionSession
ExecutionSession & getExecutionSession() const
Returns the ExecutionSession for this instance.
Definition: Core.h:1771
llvm::orc::SymbolAliasMapEntry::Aliasee
SymbolStringPtr Aliasee
Definition: Core.h:387
llvm::orc::MaterializationUnit::Interface::Interface
Interface()=default
llvm::orc::reexports
std::unique_ptr< ReExportsMaterializationUnit > reexports(JITDylib &SourceJD, SymbolAliasMap Aliases, JITDylibLookupFlags SourceJDLookupFlags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Create a materialization unit for re-exporting symbols from another JITDylib with alternative names/f...
Definition: Core.h:815
llvm::orc::ExecutionSession::deregisterResourceManager
void deregisterResourceManager(ResourceManager &RM)
Deregister the given ResourceManager with this ExecutionSession.
Definition: Core.cpp:1918
llvm::orc::ResourceManager::handleTransferResources
virtual void handleTransferResources(ResourceKey DstK, ResourceKey SrcK)=0
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
llvm::AArch64::RM
@ RM
Definition: AArch64ISelLowering.h:481
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet()=default
llvm::orc::MaterializationResponsibility::~MaterializationResponsibility
~MaterializationResponsibility()
Destruct a MaterializationResponsibility instance.
Definition: Core.h:1915
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::orc::ExecutionSession::MaterializationResponsibility
friend class MaterializationResponsibility
Definition: Core.h:1367
llvm::orc::ReexportsGenerator::SymbolPredicate
std::function< bool(SymbolStringPtr)> SymbolPredicate
Definition: Core.h:1892
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm::orc::Platform
Platforms set up standard symbols and mediate interactions between dynamic initializers (e....
Definition: Core.h:1306
llvm::orc::SymbolState::Ready
@ Ready
Emitted to memory, but waiting on transitive dependencies.
BitmaskEnum.h
llvm::orc::SymbolLookupSet::begin
iterator begin()
Definition: Core.h:252
llvm::orc::Platform::teardownJITDylib
virtual Error teardownJITDylib(JITDylib &JD)=0
This method will be called outside the session lock each time a JITDylib is removed to allow the Plat...
llvm::orc::MaterializationResponsibility::MaterializationResponsibility
MaterializationResponsibility(MaterializationResponsibility &&)=delete
llvm::orc::LookupState
Wraps state for a lookup-in-progress.
Definition: Core.h:890
llvm::orc::SymbolLookupSet::iterator
UnderlyingVector::iterator iterator
Definition: Core.h:179
llvm::orc::MaterializationUnit::ID
static char ID
Definition: Core.h:674
llvm::orc::SymbolLookupSet::getSymbolNames
SymbolNameVector getSymbolNames() const
Construct a SymbolNameVector from this instance by dropping the Flags values.
Definition: Core.h:331
llvm::orc::SymbolLookupSet::sortByAddress
void sortByAddress()
Sort the lookup set by pointer value.
Definition: Core.h:342
llvm::orc::SymbolAliasMapEntry
Definition: Core.h:382
llvm::orc::InProgressFullLookupState
Definition: Core.cpp:562
llvm::orc::ExecutionSession::createJITDylib
Expected< JITDylib & > createJITDylib(std::string Name)
Add a new JITDylib to this ExecutionSession.
Definition: Core.cpp:1948
llvm::orc::SymbolDependenceMap
DenseMap< JITDylib *, SymbolNameSet > SymbolDependenceMap
A map from JITDylibs to sets of symbols.
Definition: Core.h:119
llvm::orc::ResourceTrackerDefunct::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:70
llvm::orc::SymbolFlagsMap
DenseMap< SymbolStringPtr, JITSymbolFlags > SymbolFlagsMap
A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags.
Definition: Core.h:116
llvm::DenseMapBase::empty
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:98
llvm::logAllUnhandledErrors
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:61
llvm::orc::AsynchronousSymbolQuery::AsynchronousSymbolQuery
AsynchronousSymbolQuery(const SymbolLookupSet &Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete)
Create a query for the given symbols.
Definition: Core.cpp:158
llvm::orc::ResourceManager
Listens for ResourceTracker operations.
Definition: Core.h:97
llvm::orc::ExecutionSession::getSymbolStringPool
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Get the SymbolStringPool for this instance.
Definition: Core.h:1408
llvm::orc::MaterializationResponsibility::failMaterialization
void failMaterialization()
Notify all not-yet-emitted covered by this MaterializationResponsibility instance that an error has o...
Definition: Core.h:1938
llvm::orc::ReexportsGenerator
ReexportsGenerator can be used with JITDylib::addGenerator to automatically re-export a subset of the...
Definition: Core.h:1890
llvm::orc::ExecutionSession::getPlatform
Platform * getPlatform()
Get the Platform for this session.
Definition: Core.h:1420
llvm::orc::ExecutionSession::ErrorReporter
std::function< void(Error)> ErrorReporter
For reporting errors.
Definition: Core.h:1372
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:851
H
#define H(x, y, z)
Definition: MD5.cpp:57
llvm::orc::SymbolLookupSet::const_iterator
UnderlyingVector::const_iterator const_iterator
Definition: Core.h:180
llvm::orc::JITDylib::removeFromLinkOrder
void removeFromLinkOrder(JITDylib &JD)
Remove the given JITDylib from the link order for this JITDylib if it is present.
Definition: Core.cpp:1347
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:27
llvm::orc::OrcV2CAPIHelper
Definition: OrcV2CBindings.cpp:28
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::orc::MissingSymbolDefinitions::getSymbolStringPool
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Definition: Core.h:484
llvm::orc::DefinitionGenerator::tryToGenerate
virtual Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &LookupSet)=0
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
llvm::orc::SymbolLookupSet::removeDuplicates
void removeDuplicates()
Remove any duplicate elements.
Definition: Core.h:358
llvm::orc::ExecutionSession
An ExecutionSession represents a running JIT program.
Definition: Core.h:1362
llvm::orc::JITDylibLookupFlags::MatchExportedSymbolsOnly
@ MatchExportedSymbolsOnly
llvm::AArch64CC::LS
@ LS
Definition: AArch64BaseInfo.h:264
llvm::orc::FailedToMaterialize
Used to notify a JITDylib that the given set of symbols failed to materialize.
Definition: Core.h:419
llvm::orc::MissingSymbolDefinitions::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:140
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1552
llvm::orc::symbolAliases
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
Definition: Core.h:806
llvm::unique
auto unique(Range &&R, Predicate P)
Definition: STLExtras.h:1769
llvm::orc::absoluteSymbols
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Definition: Core.h:760
llvm::orc::FailedToMaterialize::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:100
llvm::JITTargetAddress
uint64_t JITTargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:42
llvm::orc::SymbolsNotFound::getSymbols
const SymbolNameVector & getSymbols() const
Definition: Core.h:446
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::orc::ResourceTrackerDefunct::ResourceTrackerDefunct
ResourceTrackerDefunct(ResourceTrackerSP RT)
Definition: Core.cpp:67
llvm::orc::MaterializationResponsibility::delegate
Expected< std::unique_ptr< MaterializationResponsibility > > delegate(const SymbolNameSet &Symbols)
Delegates responsibility for the given symbols to the returned materialization responsibility.
Definition: Core.h:1948
JITLinkDylib.h
llvm::orc::JITDylib::define
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
Definition: Core.h:1803
llvm::orc::SymbolAliasMapEntry::AliasFlags
JITSymbolFlags AliasFlags
Definition: Core.h:388
llvm::orc::ExecutionSession::lookup
void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder, SymbolLookupSet Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete, RegisterDependenciesFunction RegisterDependencies)
Search the given JITDylibs for the given symbols.
Definition: Core.cpp:2077
llvm::orc::AsynchronousSymbolQuery::JITDylib
friend class JITDylib
Definition: Core.h:844
llvm::orc::JITDylib::getExecutionSession
ExecutionSession & getExecutionSession() const
Get a reference to the ExecutionSession for this JITDylib.
Definition: Core.h:970
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
TaskDispatch.h
llvm::orc::MissingSymbolDefinitions::getSymbols
const SymbolNameVector & getSymbols() const
Definition: Core.h:486
llvm::orc::MissingSymbolDefinitions::ID
static char ID
Definition: Core.h:476
llvm::orc::MaterializationUnit::Interface::SymbolFlags
SymbolFlagsMap SymbolFlags
Definition: Core.h:685
llvm::orc::SymbolState::Emitted
@ Emitted
Assigned address, still materializing.
ExecutorProcessControl.h
llvm::orc::SymbolNameSet
DenseSet< SymbolStringPtr > SymbolNameSet
A set of symbol names (represented by SymbolStringPtrs for.
Definition: Core.h:106
llvm::orc::JITDylibLookupFlags
JITDylibLookupFlags
Lookup flags that apply to each dylib in the search order for a lookup.
Definition: Core.h:127
llvm::orc::SymbolState::Resolved
@ Resolved
Queried, materialization begun.
llvm::orc::ExecutionSession::wrapAsyncWithSPS
static JITDispatchHandlerFunction wrapAsyncWithSPS(HandlerT &&H)
Wrap a handler that takes concrete argument types (and a sender for a concrete return type) to produc...
Definition: Core.h:1621
llvm::orc::MaterializationTask::ID
static char ID
Definition: Core.h:1348
llvm::orc::ReExportsMaterializationUnit::ReExportsMaterializationUnit
ReExportsMaterializationUnit(JITDylib *SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolAliasMap Aliases)
SourceJD is allowed to be nullptr, in which case the source JITDylib is taken to be whatever JITDylib...
Definition: Core.cpp:297
llvm::orc::FailedToMaterialize::FailedToMaterialize
FailedToMaterialize(std::shared_ptr< SymbolStringPool > SSP, std::shared_ptr< SymbolDependenceMap > Symbols)
Definition: Core.cpp:78
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::orc::MaterializationUnit::SymbolFlags
SymbolFlagsMap SymbolFlags
Definition: Core.h:718
llvm::orc::UnexpectedSymbolDefinitions::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:149
llvm::orc::LookupState::LookupState
LookupState()
llvm::orc::JITDylibLookupFlags::MatchAllSymbols
@ MatchAllSymbols
llvm::orc::SymbolLookupFlags::RequiredSymbol
@ RequiredSymbol
llvm::orc::SymbolsResolvedCallback
unique_function< void(Expected< SymbolMap >)> SymbolsResolvedCallback
Callback to notify client that symbols have been resolved.
Definition: Core.h:395
llvm::orc::SymbolNameVector
std::vector< SymbolStringPtr > SymbolNameVector
A vector of symbol names.
Definition: Core.h:109
Debug.h
llvm::orc::ExecutionSession::setErrorReporter
ExecutionSession & setErrorReporter(ErrorReporter ReportError)
Set the error reporter function.
Definition: Core.h:1474
llvm::IntrusiveRefCntPtr
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Definition: IntrusiveRefCntPtr.h:168
llvm::orc::makeJITDylibSearchOrder
JITDylibSearchOrder makeJITDylibSearchOrder(ArrayRef< JITDylib * > JDs, JITDylibLookupFlags Flags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Convenience function for creating a search order from an ArrayRef of JITDylib*, all with the same fla...
Definition: Core.h:158
llvm::orc::SymbolsCouldNotBeRemoved::ID
static char ID
Definition: Core.h:456
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1225
llvm::orc::AsynchronousSymbolQuery::isComplete
bool isComplete() const
Returns true if all symbols covered by this query have been resolved.
Definition: Core.h:862
llvm::orc::SymbolsCouldNotBeRemoved::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:136
llvm::orc::MaterializationUnit::InitSymbol
SymbolStringPtr InitSymbol
Definition: Core.h:719
llvm::orc::JITDylib::removeGenerator
void removeGenerator(DefinitionGenerator &G)
Remove a definition generator from this JITDylib.
Definition: Core.cpp:677