LLVM  14.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<SymbolDependenceMap> Symbols);
424  std::error_code convertToErrorCode() const override;
425  void log(raw_ostream &OS) const override;
426  const SymbolDependenceMap &getSymbols() const { return *Symbols; }
427 
428 private:
429  std::shared_ptr<SymbolDependenceMap> Symbols;
430 };
431 
432 /// Used to notify clients when symbols can not be found during a lookup.
433 class SymbolsNotFound : public ErrorInfo<SymbolsNotFound> {
434 public:
435  static char ID;
436 
439  std::error_code convertToErrorCode() const override;
440  void log(raw_ostream &OS) const override;
441  const SymbolNameVector &getSymbols() const { return Symbols; }
442 
443 private:
444  SymbolNameVector Symbols;
445 };
446 
447 /// Used to notify clients that a set of symbols could not be removed.
448 class SymbolsCouldNotBeRemoved : public ErrorInfo<SymbolsCouldNotBeRemoved> {
449 public:
450  static char ID;
451 
453  std::error_code convertToErrorCode() const override;
454  void log(raw_ostream &OS) const override;
455  const SymbolNameSet &getSymbols() const { return Symbols; }
456 
457 private:
458  SymbolNameSet Symbols;
459 };
460 
461 /// Errors of this type should be returned if a module fails to include
462 /// definitions that are claimed by the module's associated
463 /// MaterializationResponsibility. If this error is returned it is indicative of
464 /// a broken transformation / compiler / object cache.
465 class MissingSymbolDefinitions : public ErrorInfo<MissingSymbolDefinitions> {
466 public:
467  static char ID;
468 
469  MissingSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
470  : ModuleName(std::move(ModuleName)), Symbols(std::move(Symbols)) {}
471  std::error_code convertToErrorCode() const override;
472  void log(raw_ostream &OS) const override;
473  const std::string &getModuleName() const { return ModuleName; }
474  const SymbolNameVector &getSymbols() const { return Symbols; }
475 private:
476  std::string ModuleName;
477  SymbolNameVector Symbols;
478 };
479 
480 /// Errors of this type should be returned if a module contains definitions for
481 /// symbols that are not claimed by the module's associated
482 /// MaterializationResponsibility. If this error is returned it is indicative of
483 /// a broken transformation / compiler / object cache.
484 class UnexpectedSymbolDefinitions : public ErrorInfo<UnexpectedSymbolDefinitions> {
485 public:
486  static char ID;
487 
488  UnexpectedSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
489  : ModuleName(std::move(ModuleName)), Symbols(std::move(Symbols)) {}
490  std::error_code convertToErrorCode() const override;
491  void log(raw_ostream &OS) const override;
492  const std::string &getModuleName() const { return ModuleName; }
493  const SymbolNameVector &getSymbols() const { return Symbols; }
494 private:
495  std::string ModuleName;
496  SymbolNameVector Symbols;
497 };
498 
499 /// Tracks responsibility for materialization, and mediates interactions between
500 /// MaterializationUnits and JDs.
501 ///
502 /// An instance of this class is passed to MaterializationUnits when their
503 /// materialize method is called. It allows MaterializationUnits to resolve and
504 /// emit symbols, or abandon materialization by notifying any unmaterialized
505 /// symbols of an error.
507  friend class ExecutionSession;
508 
509 public:
513 
514  /// Destruct a MaterializationResponsibility instance. In debug mode
515  /// this asserts that all symbols being tracked have been either
516  /// emitted or notified of an error.
518 
519  /// Returns the ResourceTracker for this instance.
520  template <typename Func> Error withResourceKeyDo(Func &&F) const;
521 
522  /// Returns the target JITDylib that these symbols are being materialized
523  /// into.
524  JITDylib &getTargetJITDylib() const { return *JD; }
525 
526  /// Returns the ExecutionSession for this instance.
528 
529  /// Returns the symbol flags map for this responsibility instance.
530  /// Note: The returned flags may have transient flags (Lazy, Materializing)
531  /// set. These should be stripped with JITSymbolFlags::stripTransientFlags
532  /// before using.
533  const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
534 
535  /// Returns the initialization pseudo-symbol, if any. This symbol will also
536  /// be present in the SymbolFlagsMap for this MaterializationResponsibility
537  /// object.
538  const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
539 
540  /// Returns the names of any symbols covered by this
541  /// MaterializationResponsibility object that have queries pending. This
542  /// information can be used to return responsibility for unrequested symbols
543  /// back to the JITDylib via the delegate method.
545 
546  /// Notifies the target JITDylib that the given symbols have been resolved.
547  /// This will update the given symbols' addresses in the JITDylib, and notify
548  /// any pending queries on the given symbols of their resolution. The given
549  /// symbols must be ones covered by this MaterializationResponsibility
550  /// instance. Individual calls to this method may resolve a subset of the
551  /// symbols, but all symbols must have been resolved prior to calling emit.
552  ///
553  /// This method will return an error if any symbols being resolved have been
554  /// moved to the error state due to the failure of a dependency. If this
555  /// method returns an error then clients should log it and call
556  /// failMaterialize. If no dependencies have been registered for the
557  /// symbols covered by this MaterializationResponsibiility then this method
558  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
559  Error notifyResolved(const SymbolMap &Symbols);
560 
561  /// Notifies the target JITDylib (and any pending queries on that JITDylib)
562  /// that all symbols covered by this MaterializationResponsibility instance
563  /// have been emitted.
564  ///
565  /// This method will return an error if any symbols being resolved have been
566  /// moved to the error state due to the failure of a dependency. If this
567  /// method returns an error then clients should log it and call
568  /// failMaterialize. If no dependencies have been registered for the
569  /// symbols covered by this MaterializationResponsibiility then this method
570  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
572 
573  /// Attempt to claim responsibility for new definitions. This method can be
574  /// used to claim responsibility for symbols that are added to a
575  /// materialization unit during the compilation process (e.g. literal pool
576  /// symbols). Symbol linkage rules are the same as for symbols that are
577  /// defined up front: duplicate strong definitions will result in errors.
578  /// Duplicate weak definitions will be discarded (in which case they will
579  /// not be added to this responsibility instance).
580  ///
581  /// This method can be used by materialization units that want to add
582  /// additional symbols at materialization time (e.g. stubs, compile
583  /// callbacks, metadata).
585 
586  /// Define the given symbols as non-existent, removing it from the symbol
587  /// table and notifying any pending queries. Queries that lookup up the
588  /// symbol using the SymbolLookupFlags::WeaklyReferencedSymbol flag will
589  /// behave as if the symbol had not been matched in the first place. Queries
590  /// that required this symbol will fail with a missing symbol definition
591  /// error.
592  ///
593  /// This method is intended to support cleanup of special symbols like
594  /// initializer symbols: Queries using
595  /// SymbolLookupFlags::WeaklyReferencedSymbol can be used to trigger their
596  /// emission, and this method can be used to remove them from the JITDylib
597  /// once materialization is complete.
599 
600  /// Notify all not-yet-emitted covered by this MaterializationResponsibility
601  /// instance that an error has occurred.
602  /// This will remove all symbols covered by this MaterializationResponsibilty
603  /// from the target JITDylib, and send an error to any queries waiting on
604  /// these symbols.
605  void failMaterialization();
606 
607  /// Transfers responsibility to the given MaterializationUnit for all
608  /// symbols defined by that MaterializationUnit. This allows
609  /// materializers to break up work based on run-time information (e.g.
610  /// by introspecting which symbols have actually been looked up and
611  /// materializing only those).
612  Error replace(std::unique_ptr<MaterializationUnit> MU);
613 
614  /// Delegates responsibility for the given symbols to the returned
615  /// materialization responsibility. Useful for breaking up work between
616  /// threads, or different kinds of materialization processes.
618  delegate(const SymbolNameSet &Symbols);
619 
621  const SymbolDependenceMap &Dependencies);
622 
623  /// Add dependencies that apply to all symbols covered by this instance.
624  void addDependenciesForAll(const SymbolDependenceMap &Dependencies);
625 
626 private:
627  /// Create a MaterializationResponsibility for the given JITDylib and
628  /// initial symbols.
630  SymbolStringPtr InitSymbol)
631  : JD(std::move(JD)), SymbolFlags(std::move(SymbolFlags)),
632  InitSymbol(std::move(InitSymbol)) {
633  assert(this->JD && "Cannot initialize with null JITDylib");
634  assert(!this->SymbolFlags.empty() && "Materializing nothing?");
635  }
636 
637  JITDylibSP JD;
639  SymbolStringPtr InitSymbol;
640 };
641 
642 /// A MaterializationUnit represents a set of symbol definitions that can
643 /// be materialized as a group, or individually discarded (when
644 /// overriding definitions are encountered).
645 ///
646 /// MaterializationUnits are used when providing lazy definitions of symbols to
647 /// JITDylibs. The JITDylib will call materialize when the address of a symbol
648 /// is requested via the lookup method. The JITDylib will call discard if a
649 /// stronger definition is added or already present.
651  friend class ExecutionSession;
652  friend class JITDylib;
653 
654 public:
655  static char ID;
656 
659  : SymbolFlags(std::move(InitalSymbolFlags)),
661  assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) &&
662  "If set, InitSymbol should appear in InitialSymbolFlags map");
663  }
664 
665  virtual ~MaterializationUnit() {}
666 
667  /// Return the name of this materialization unit. Useful for debugging
668  /// output.
669  virtual StringRef getName() const = 0;
670 
671  /// Return the set of symbols that this source provides.
672  const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
673 
674  /// Returns the initialization symbol for this MaterializationUnit (if any).
676 
677  /// Implementations of this method should materialize all symbols
678  /// in the materialzation unit, except for those that have been
679  /// previously discarded.
680  virtual void
681  materialize(std::unique_ptr<MaterializationResponsibility> R) = 0;
682 
683  /// Called by JITDylibs to notify MaterializationUnits that the given symbol
684  /// has been overridden.
685  void doDiscard(const JITDylib &JD, const SymbolStringPtr &Name) {
687  discard(JD, std::move(Name));
688  }
689 
690 protected:
693 
694 private:
695  virtual void anchor();
696 
697  /// Implementations of this method should discard the given symbol
698  /// from the source (e.g. if the source is an LLVM IR Module and the
699  /// symbol is a function, delete the function body or mark it available
700  /// externally).
701  virtual void discard(const JITDylib &JD, const SymbolStringPtr &Name) = 0;
702 };
703 
704 /// A MaterializationUnit implementation for pre-existing absolute symbols.
705 ///
706 /// All symbols will be resolved and marked ready as soon as the unit is
707 /// materialized.
709 public:
711 
712  StringRef getName() const override;
713 
714 private:
715  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
716  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
717  static SymbolFlagsMap extractFlags(const SymbolMap &Symbols);
718 
719  SymbolMap Symbols;
720 };
721 
722 /// Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
723 /// Useful for inserting absolute symbols into a JITDylib. E.g.:
724 /// \code{.cpp}
725 /// JITDylib &JD = ...;
726 /// SymbolStringPtr Foo = ...;
727 /// JITEvaluatedSymbol FooSym = ...;
728 /// if (auto Err = JD.define(absoluteSymbols({{Foo, FooSym}})))
729 /// return Err;
730 /// \endcode
731 ///
732 inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
734  return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
735  std::move(Symbols));
736 }
737 
738 /// A materialization unit for symbol aliases. Allows existing symbols to be
739 /// aliased with alternate flags.
741 public:
742  /// SourceJD is allowed to be nullptr, in which case the source JITDylib is
743  /// taken to be whatever JITDylib these definitions are materialized in (and
744  /// MatchNonExported has no effect). This is useful for defining aliases
745  /// within a JITDylib.
746  ///
747  /// Note: Care must be taken that no sets of aliases form a cycle, as such
748  /// a cycle will result in a deadlock when any symbol in the cycle is
749  /// resolved.
751  JITDylibLookupFlags SourceJDLookupFlags,
752  SymbolAliasMap Aliases);
753 
754  StringRef getName() const override;
755 
756 private:
757  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
758  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
759  static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);
760 
761  JITDylib *SourceJD = nullptr;
762  JITDylibLookupFlags SourceJDLookupFlags;
763  SymbolAliasMap Aliases;
764 };
765 
766 /// Create a ReExportsMaterializationUnit with the given aliases.
767 /// Useful for defining symbol aliases.: E.g., given a JITDylib JD containing
768 /// symbols "foo" and "bar", we can define aliases "baz" (for "foo") and "qux"
769 /// (for "bar") with: \code{.cpp}
770 /// SymbolStringPtr Baz = ...;
771 /// SymbolStringPtr Qux = ...;
772 /// if (auto Err = JD.define(symbolAliases({
773 /// {Baz, { Foo, JITSymbolFlags::Exported }},
774 /// {Qux, { Bar, JITSymbolFlags::Weak }}}))
775 /// return Err;
776 /// \endcode
777 inline std::unique_ptr<ReExportsMaterializationUnit>
779  return std::make_unique<ReExportsMaterializationUnit>(
781 }
782 
783 /// Create a materialization unit for re-exporting symbols from another JITDylib
784 /// with alternative names/flags.
785 /// SourceJD will be searched using the given JITDylibLookupFlags.
786 inline std::unique_ptr<ReExportsMaterializationUnit>
787 reexports(JITDylib &SourceJD, SymbolAliasMap Aliases,
788  JITDylibLookupFlags SourceJDLookupFlags =
790  return std::make_unique<ReExportsMaterializationUnit>(
791  &SourceJD, SourceJDLookupFlags, std::move(Aliases));
792 }
793 
794 /// Build a SymbolAliasMap for the common case where you want to re-export
795 /// symbols from another JITDylib with the same linkage/flags.
797 buildSimpleReexportsAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols);
798 
799 /// Represents the state that a symbol has reached during materialization.
800 enum class SymbolState : uint8_t {
801  Invalid, /// No symbol should be in this state.
802  NeverSearched, /// Added to the symbol table, never queried.
803  Materializing, /// Queried, materialization begun.
804  Resolved, /// Assigned address, still materializing.
805  Emitted, /// Emitted to memory, but waiting on transitive dependencies.
806  Ready = 0x3f /// Ready and safe for clients to access.
807 };
808 
809 /// A symbol query that returns results via a callback when results are
810 /// ready.
811 ///
812 /// makes a callback when all symbols are available.
814  friend class ExecutionSession;
816  friend class JITDylib;
819 
820 public:
821  /// Create a query for the given symbols. The NotifyComplete
822  /// callback will be called once all queried symbols reach the given
823  /// minimum state.
825  SymbolState RequiredState,
826  SymbolsResolvedCallback NotifyComplete);
827 
828  /// Notify the query that a requested symbol has reached the required state.
830  JITEvaluatedSymbol Sym);
831 
832  /// Returns true if all symbols covered by this query have been
833  /// resolved.
834  bool isComplete() const { return OutstandingSymbolsCount == 0; }
835 
836 
837 private:
838  void handleComplete(ExecutionSession &ES);
839 
840  SymbolState getRequiredState() { return RequiredState; }
841 
842  void addQueryDependence(JITDylib &JD, SymbolStringPtr Name);
843 
844  void removeQueryDependence(JITDylib &JD, const SymbolStringPtr &Name);
845 
846  void dropSymbol(const SymbolStringPtr &Name);
847 
848  void handleFailed(Error Err);
849 
850  void detach();
851 
852  SymbolsResolvedCallback NotifyComplete;
853  SymbolDependenceMap QueryRegistrations;
854  SymbolMap ResolvedSymbols;
855  size_t OutstandingSymbolsCount;
856  SymbolState RequiredState;
857 };
858 
859 /// Wraps state for a lookup-in-progress.
860 /// DefinitionGenerators can optionally take ownership of a LookupState object
861 /// to suspend a lookup-in-progress while they search for definitions.
862 class LookupState {
863  friend class OrcV2CAPIHelper;
864  friend class ExecutionSession;
865 
866 public:
867  LookupState();
870  ~LookupState();
871 
872  /// Continue the lookup. This can be called by DefinitionGenerators
873  /// to re-start a captured query-application operation.
874  void continueLookup(Error Err);
875 
876 private:
877  LookupState(std::unique_ptr<InProgressLookupState> IPLS);
878 
879  // For C API.
880  void reset(InProgressLookupState *IPLS);
881 
882  std::unique_ptr<InProgressLookupState> IPLS;
883 };
884 
885 /// Definition generators can be attached to JITDylibs to generate new
886 /// definitions for otherwise unresolved symbols during lookup.
888 public:
889  virtual ~DefinitionGenerator();
890 
891  /// DefinitionGenerators should override this method to insert new
892  /// definitions into the parent JITDylib. K specifies the kind of this
893  /// lookup. JD specifies the target JITDylib being searched, and
894  /// JDLookupFlags specifies whether the search should match against
895  /// hidden symbols. Finally, Symbols describes the set of unresolved
896  /// symbols and their associated lookup flags.
898  JITDylibLookupFlags JDLookupFlags,
899  const SymbolLookupSet &LookupSet) = 0;
900 };
901 
902 /// A symbol table that supports asynchoronous symbol queries.
903 ///
904 /// Represents a virtual shared object. Instances can not be copied or moved, so
905 /// their addresses may be used as keys for resource management.
906 /// JITDylib state changes must be made via an ExecutionSession to guarantee
907 /// that they are synchronized with respect to other JITDylib operations.
908 class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
909  public jitlink::JITLinkDylib {
911  friend class ExecutionSession;
912  friend class Platform;
914 public:
915 
917  std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
918 
919  JITDylib(const JITDylib &) = delete;
920  JITDylib &operator=(const JITDylib &) = delete;
921  JITDylib(JITDylib &&) = delete;
922  JITDylib &operator=(JITDylib &&) = delete;
923 
924  /// Get the name for this JITDylib.
925  const std::string &getName() const { return JITDylibName; }
926 
927  /// Get a reference to the ExecutionSession for this JITDylib.
928  ExecutionSession &getExecutionSession() const { return ES; }
929 
930  /// Calls remove on all trackers currently associated with this JITDylib.
931  /// Does not run static deinits.
932  ///
933  /// Note that removal happens outside the session lock, so new code may be
934  /// added concurrently while the clear is underway, and the newly added
935  /// code will *not* be cleared. Adding new code concurrently with a clear
936  /// is usually a bug and should be avoided.
937  Error clear();
938 
939  /// Get the default resource tracker for this JITDylib.
941 
942  /// Create a resource tracker for this JITDylib.
944 
945  /// Adds a definition generator to this JITDylib and returns a referenece to
946  /// it.
947  ///
948  /// When JITDylibs are searched during lookup, if no existing definition of
949  /// a symbol is found, then any generators that have been added are run (in
950  /// the order that they were added) to potentially generate a definition.
951  template <typename GeneratorT>
952  GeneratorT &addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
953 
954  /// Remove a definition generator from this JITDylib.
955  ///
956  /// The given generator must exist in this JITDylib's generators list (i.e.
957  /// have been added and not yet removed).
959 
960  /// Set the link order to be used when fixing up definitions in JITDylib.
961  /// This will replace the previous link order, and apply to any symbol
962  /// resolutions made for definitions in this JITDylib after the call to
963  /// setLinkOrder (even if the definition itself was added before the
964  /// call).
965  ///
966  /// If LinkAgainstThisJITDylibFirst is true (the default) then this JITDylib
967  /// will add itself to the beginning of the LinkOrder (Clients should not
968  /// put this JITDylib in the list in this case, to avoid redundant lookups).
969  ///
970  /// If LinkAgainstThisJITDylibFirst is false then the link order will be used
971  /// as-is. The primary motivation for this feature is to support deliberate
972  /// shadowing of symbols in this JITDylib by a facade JITDylib. For example,
973  /// the facade may resolve function names to stubs, and the stubs may compile
974  /// lazily by looking up symbols in this dylib. Adding the facade dylib
975  /// as the first in the link order (instead of this dylib) ensures that
976  /// definitions within this dylib resolve to the lazy-compiling stubs,
977  /// rather than immediately materializing the definitions in this dylib.
978  void setLinkOrder(JITDylibSearchOrder NewSearchOrder,
979  bool LinkAgainstThisJITDylibFirst = true);
980 
981  /// Add the given JITDylib to the link order for definitions in this
982  /// JITDylib.
983  void addToLinkOrder(JITDylib &JD,
984  JITDylibLookupFlags JDLookupFlags =
986 
987  /// Replace OldJD with NewJD in the link order if OldJD is present.
988  /// Otherwise this operation is a no-op.
989  void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
990  JITDylibLookupFlags JDLookupFlags =
992 
993  /// Remove the given JITDylib from the link order for this JITDylib if it is
994  /// present. Otherwise this operation is a no-op.
995  void removeFromLinkOrder(JITDylib &JD);
996 
997  /// Do something with the link order (run under the session lock).
998  template <typename Func>
999  auto withLinkOrderDo(Func &&F)
1000  -> decltype(F(std::declval<const JITDylibSearchOrder &>()));
1001 
1002  /// Define all symbols provided by the materialization unit to be part of this
1003  /// JITDylib.
1004  ///
1005  /// If RT is not specified then the default resource tracker will be used.
1006  ///
1007  /// This overload always takes ownership of the MaterializationUnit. If any
1008  /// errors occur, the MaterializationUnit consumed.
1009  template <typename MaterializationUnitType>
1010  Error define(std::unique_ptr<MaterializationUnitType> &&MU,
1011  ResourceTrackerSP RT = nullptr);
1012 
1013  /// Define all symbols provided by the materialization unit to be part of this
1014  /// JITDylib.
1015  ///
1016  /// This overload only takes ownership of the MaterializationUnit no error is
1017  /// generated. If an error occurs, ownership remains with the caller. This
1018  /// may allow the caller to modify the MaterializationUnit to correct the
1019  /// issue, then re-call define.
1020  template <typename MaterializationUnitType>
1021  Error define(std::unique_ptr<MaterializationUnitType> &MU,
1022  ResourceTrackerSP RT = nullptr);
1023 
1024  /// Tries to remove the given symbols.
1025  ///
1026  /// If any symbols are not defined in this JITDylib this method will return
1027  /// a SymbolsNotFound error covering the missing symbols.
1028  ///
1029  /// If all symbols are found but some symbols are in the process of being
1030  /// materialized this method will return a SymbolsCouldNotBeRemoved error.
1031  ///
1032  /// On success, all symbols are removed. On failure, the JITDylib state is
1033  /// left unmodified (no symbols are removed).
1034  Error remove(const SymbolNameSet &Names);
1035 
1036  /// Dump current JITDylib state to OS.
1037  void dump(raw_ostream &OS);
1038 
1039  /// Returns the given JITDylibs and all of their transitive dependencies in
1040  /// DFS order (based on linkage relationships). Each JITDylib will appear
1041  /// only once.
1042  static std::vector<JITDylibSP> getDFSLinkOrder(ArrayRef<JITDylibSP> JDs);
1043 
1044  /// Returns the given JITDylibs and all of their transitive dependensies in
1045  /// reverse DFS order (based on linkage relationships). Each JITDylib will
1046  /// appear only once.
1047  static std::vector<JITDylibSP>
1049 
1050  /// Return this JITDylib and its transitive dependencies in DFS order
1051  /// based on linkage relationships.
1052  std::vector<JITDylibSP> getDFSLinkOrder();
1053 
1054  /// Rteurn this JITDylib and its transitive dependencies in reverse DFS order
1055  /// based on linkage relationships.
1056  std::vector<JITDylibSP> getReverseDFSLinkOrder();
1057 
1058 private:
1059  using AsynchronousSymbolQueryList =
1060  std::vector<std::shared_ptr<AsynchronousSymbolQuery>>;
1061 
1062  struct UnmaterializedInfo {
1063  UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU,
1064  ResourceTracker *RT)
1065  : MU(std::move(MU)), RT(RT) {}
1066 
1067  std::unique_ptr<MaterializationUnit> MU;
1068  ResourceTracker *RT;
1069  };
1070 
1071  using UnmaterializedInfosMap =
1072  DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
1073 
1074  using UnmaterializedInfosList =
1075  std::vector<std::shared_ptr<UnmaterializedInfo>>;
1076 
1077  struct MaterializingInfo {
1078  SymbolDependenceMap Dependants;
1079  SymbolDependenceMap UnemittedDependencies;
1080 
1081  void addQuery(std::shared_ptr<AsynchronousSymbolQuery> Q);
1082  void removeQuery(const AsynchronousSymbolQuery &Q);
1083  AsynchronousSymbolQueryList takeQueriesMeeting(SymbolState RequiredState);
1084  AsynchronousSymbolQueryList takeAllPendingQueries() {
1085  return std::move(PendingQueries);
1086  }
1087  bool hasQueriesPending() const { return !PendingQueries.empty(); }
1088  const AsynchronousSymbolQueryList &pendingQueries() const {
1089  return PendingQueries;
1090  }
1091  private:
1092  AsynchronousSymbolQueryList PendingQueries;
1093  };
1094 
1095  using MaterializingInfosMap = DenseMap<SymbolStringPtr, MaterializingInfo>;
1096 
1097  class SymbolTableEntry {
1098  public:
1099  SymbolTableEntry() = default;
1100  SymbolTableEntry(JITSymbolFlags Flags)
1101  : Flags(Flags), State(static_cast<uint8_t>(SymbolState::NeverSearched)),
1102  MaterializerAttached(false), PendingRemoval(false) {}
1103 
1104  JITTargetAddress getAddress() const { return Addr; }
1105  JITSymbolFlags getFlags() const { return Flags; }
1106  SymbolState getState() const { return static_cast<SymbolState>(State); }
1107 
1108  bool hasMaterializerAttached() const { return MaterializerAttached; }
1109  bool isPendingRemoval() const { return PendingRemoval; }
1110 
1111  void setAddress(JITTargetAddress Addr) { this->Addr = Addr; }
1112  void setFlags(JITSymbolFlags Flags) { this->Flags = Flags; }
1113  void setState(SymbolState State) {
1114  assert(static_cast<uint8_t>(State) < (1 << 6) &&
1115  "State does not fit in bitfield");
1116  this->State = static_cast<uint8_t>(State);
1117  }
1118 
1119  void setMaterializerAttached(bool MaterializerAttached) {
1120  this->MaterializerAttached = MaterializerAttached;
1121  }
1122 
1123  void setPendingRemoval(bool PendingRemoval) {
1124  this->PendingRemoval = PendingRemoval;
1125  }
1126 
1127  JITEvaluatedSymbol getSymbol() const {
1128  return JITEvaluatedSymbol(Addr, Flags);
1129  }
1130 
1131  private:
1132  JITTargetAddress Addr = 0;
1133  JITSymbolFlags Flags;
1134  uint8_t State : 6;
1135  uint8_t MaterializerAttached : 1;
1136  uint8_t PendingRemoval : 1;
1137  };
1138 
1139  using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;
1140 
1141  JITDylib(ExecutionSession &ES, std::string Name);
1142 
1144  std::pair<AsynchronousSymbolQuerySet, std::shared_ptr<SymbolDependenceMap>>
1145  removeTracker(ResourceTracker &RT);
1146 
1147  void transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1148 
1149  Error defineImpl(MaterializationUnit &MU);
1150 
1151  void installMaterializationUnit(std::unique_ptr<MaterializationUnit> MU,
1152  ResourceTracker &RT);
1153 
1154  void detachQueryHelper(AsynchronousSymbolQuery &Q,
1155  const SymbolNameSet &QuerySymbols);
1156 
1157  void transferEmittedNodeDependencies(MaterializingInfo &DependantMI,
1158  const SymbolStringPtr &DependantName,
1159  MaterializingInfo &EmittedMI);
1160 
1161  Expected<SymbolFlagsMap> defineMaterializing(SymbolFlagsMap SymbolFlags);
1162 
1163  Error replace(MaterializationResponsibility &FromMR,
1164  std::unique_ptr<MaterializationUnit> MU);
1165 
1166  Expected<std::unique_ptr<MaterializationResponsibility>>
1168  SymbolStringPtr InitSymbol);
1169 
1170  SymbolNameSet getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) const;
1171 
1172  void addDependencies(const SymbolStringPtr &Name,
1173  const SymbolDependenceMap &Dependants);
1174 
1175  Error resolve(MaterializationResponsibility &MR, const SymbolMap &Resolved);
1176 
1177  Error emit(MaterializationResponsibility &MR, const SymbolFlagsMap &Emitted);
1178 
1179  void unlinkMaterializationResponsibility(MaterializationResponsibility &MR);
1180 
1181  using FailedSymbolsWorklist =
1182  std::vector<std::pair<JITDylib *, SymbolStringPtr>>;
1183 
1184  static std::pair<AsynchronousSymbolQuerySet,
1185  std::shared_ptr<SymbolDependenceMap>>
1186  failSymbols(FailedSymbolsWorklist);
1187 
1188  ExecutionSession &ES;
1189  std::string JITDylibName;
1190  std::mutex GeneratorsMutex;
1191  bool Open = true;
1192  SymbolTable Symbols;
1193  UnmaterializedInfosMap UnmaterializedInfos;
1194  MaterializingInfosMap MaterializingInfos;
1195  std::vector<std::shared_ptr<DefinitionGenerator>> DefGenerators;
1196  JITDylibSearchOrder LinkOrder;
1197  ResourceTrackerSP DefaultTracker;
1198 
1199  // Map trackers to sets of symbols tracked.
1200  DenseMap<ResourceTracker *, SymbolNameVector> TrackerSymbols;
1201  DenseMap<MaterializationResponsibility *, ResourceTracker *> MRTrackers;
1202 };
1203 
1204 /// Platforms set up standard symbols and mediate interactions between dynamic
1205 /// initializers (e.g. C++ static constructors) and ExecutionSession state.
1206 /// Note that Platforms do not automatically run initializers: clients are still
1207 /// responsible for doing this.
1208 class Platform {
1209 public:
1210  virtual ~Platform();
1211 
1212  /// This method will be called outside the session lock each time a JITDylib
1213  /// is created (unless it is created with EmptyJITDylib set) to allow the
1214  /// Platform to install any JITDylib specific standard symbols (e.g
1215  /// __dso_handle).
1216  virtual Error setupJITDylib(JITDylib &JD) = 0;
1217 
1218  /// This method will be called under the ExecutionSession lock each time a
1219  /// MaterializationUnit is added to a JITDylib.
1220  virtual Error notifyAdding(ResourceTracker &RT,
1221  const MaterializationUnit &MU) = 0;
1222 
1223  /// This method will be called under the ExecutionSession lock when a
1224  /// ResourceTracker is removed.
1225  virtual Error notifyRemoving(ResourceTracker &RT) = 0;
1226 
1227  /// A utility function for looking up initializer symbols. Performs a blocking
1228  /// lookup for the given symbols in each of the given JITDylibs.
1229  ///
1230  /// Note: This function is deprecated and will be removed in the near future.
1233  const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
1234 
1235  /// Performs an async lookup for the the given symbols in each of the given
1236  /// JITDylibs, calling the given handler with the compound result map once
1237  /// all lookups have completed.
1238  static void
1239  lookupInitSymbolsAsync(unique_function<void(Error)> OnComplete,
1240  ExecutionSession &ES,
1241  const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
1242 };
1243 
1244 /// Represents an abstract task for ORC to run.
1245 class Task : public RTTIExtends<Task, RTTIRoot> {
1246 public:
1247  static char ID;
1248 
1249  /// Description of the task to be performed. Used for logging.
1250  virtual void printDescription(raw_ostream &OS) = 0;
1251 
1252  /// Run the task.
1253  virtual void run() = 0;
1254 
1255 private:
1256  void anchor() override;
1257 };
1258 
1259 /// A materialization task.
1260 class MaterializationTask : public RTTIExtends<MaterializationTask, Task> {
1261 public:
1262  static char ID;
1263 
1264  MaterializationTask(std::unique_ptr<MaterializationUnit> MU,
1265  std::unique_ptr<MaterializationResponsibility> MR)
1266  : MU(std::move(MU)), MR(std::move(MR)) {}
1267  void printDescription(raw_ostream &OS) override;
1268  void run() override;
1269 
1270 private:
1271  std::unique_ptr<MaterializationUnit> MU;
1272  std::unique_ptr<MaterializationResponsibility> MR;
1273 };
1274 
1275 /// An ExecutionSession represents a running JIT program.
1279  friend class JITDylib;
1280  friend class LookupState;
1282  friend class ResourceTracker;
1283 
1284 public:
1285  /// For reporting errors.
1287 
1288  /// For dispatching ORC tasks (typically materialization tasks).
1289  using DispatchTaskFunction = unique_function<void(std::unique_ptr<Task> T)>;
1290 
1291  /// An asynchronous wrapper-function callable from the executor via
1292  /// jit-dispatch.
1295  const char *ArgData, size_t ArgSize)>;
1296 
1297  /// A map associating tag names with asynchronous wrapper function
1298  /// implementations in the JIT.
1301 
1302  /// Construct an ExecutionSession with the given ExecutorProcessControl
1303  /// object.
1304  ExecutionSession(std::unique_ptr<ExecutorProcessControl> EPC);
1305 
1306  /// End the session. Closes all JITDylibs.
1307  Error endSession();
1308 
1309  /// Get the ExecutorProcessControl object associated with this
1310  /// ExecutionSession.
1312 
1313  /// Add a symbol name to the SymbolStringPool and return a pointer to it.
1314  SymbolStringPtr intern(StringRef SymName) { return EPC->intern(SymName); }
1315 
1316  /// Set the Platform for this ExecutionSession.
1317  void setPlatform(std::unique_ptr<Platform> P) { this->P = std::move(P); }
1318 
1319  /// Get the Platform for this session.
1320  /// Will return null if no Platform has been set for this ExecutionSession.
1321  Platform *getPlatform() { return P.get(); }
1322 
1323  /// Run the given lambda with the session mutex locked.
1324  template <typename Func> decltype(auto) runSessionLocked(Func &&F) {
1325  std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
1326  return F();
1327  }
1328 
1329  /// Register the given ResourceManager with this ExecutionSession.
1330  /// Managers will be notified of events in reverse order of registration.
1332 
1333  /// Deregister the given ResourceManager with this ExecutionSession.
1334  /// Manager must have been previously registered.
1336 
1337  /// Return a pointer to the "name" JITDylib.
1338  /// Ownership of JITDylib remains within Execution Session
1340 
1341  /// Add a new bare JITDylib to this ExecutionSession.
1342  ///
1343  /// The JITDylib Name is required to be unique. Clients should verify that
1344  /// names are not being re-used (E.g. by calling getJITDylibByName) if names
1345  /// are based on user input.
1346  ///
1347  /// This call does not install any library code or symbols into the newly
1348  /// created JITDylib. The client is responsible for all configuration.
1349  JITDylib &createBareJITDylib(std::string Name);
1350 
1351  /// Add a new JITDylib to this ExecutionSession.
1352  ///
1353  /// The JITDylib Name is required to be unique. Clients should verify that
1354  /// names are not being re-used (e.g. by calling getJITDylibByName) if names
1355  /// are based on user input.
1356  ///
1357  /// If a Platform is attached then Platform::setupJITDylib will be called to
1358  /// install standard platform symbols (e.g. standard library interposes).
1359  /// If no Platform is attached this call is equivalent to createBareJITDylib.
1361 
1362  /// Set the error reporter function.
1364  this->ReportError = std::move(ReportError);
1365  return *this;
1366  }
1367 
1368  /// Report a error for this execution session.
1369  ///
1370  /// Unhandled errors can be sent here to log them.
1371  void reportError(Error Err) { ReportError(std::move(Err)); }
1372 
1373  /// Set the task dispatch function.
1375  this->DispatchTask = std::move(DispatchTask);
1376  return *this;
1377  }
1378 
1379  /// Search the given JITDylibs to find the flags associated with each of the
1380  /// given symbols.
1381  void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder,
1382  SymbolLookupSet Symbols,
1383  unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
1384 
1385  /// Blocking version of lookupFlags.
1387  JITDylibSearchOrder SearchOrder,
1388  SymbolLookupSet Symbols);
1389 
1390  /// Search the given JITDylibs for the given symbols.
1391  ///
1392  /// SearchOrder lists the JITDylibs to search. For each dylib, the associated
1393  /// boolean indicates whether the search should match against non-exported
1394  /// (hidden visibility) symbols in that dylib (true means match against
1395  /// non-exported symbols, false means do not match).
1396  ///
1397  /// The NotifyComplete callback will be called once all requested symbols
1398  /// reach the required state.
1399  ///
1400  /// If all symbols are found, the RegisterDependencies function will be called
1401  /// while the session lock is held. This gives clients a chance to register
1402  /// dependencies for on the queried symbols for any symbols they are
1403  /// materializing (if a MaterializationResponsibility instance is present,
1404  /// this can be implemented by calling
1405  /// MaterializationResponsibility::addDependencies). If there are no
1406  /// dependenant symbols for this query (e.g. it is being made by a top level
1407  /// client to get an address to call) then the value NoDependenciesToRegister
1408  /// can be used.
1409  void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder,
1410  SymbolLookupSet Symbols, SymbolState RequiredState,
1411  SymbolsResolvedCallback NotifyComplete,
1412  RegisterDependenciesFunction RegisterDependencies);
1413 
1414  /// Blocking version of lookup above. Returns the resolved symbol map.
1415  /// If WaitUntilReady is true (the default), will not return until all
1416  /// requested symbols are ready (or an error occurs). If WaitUntilReady is
1417  /// false, will return as soon as all requested symbols are resolved,
1418  /// or an error occurs. If WaitUntilReady is false and an error occurs
1419  /// after resolution, the function will return a success value, but the
1420  /// error will be reported via reportErrors.
1421  Expected<SymbolMap> lookup(const JITDylibSearchOrder &SearchOrder,
1422  const SymbolLookupSet &Symbols,
1424  SymbolState RequiredState = SymbolState::Ready,
1425  RegisterDependenciesFunction RegisterDependencies =
1427 
1428  /// Convenience version of blocking lookup.
1429  /// Searches each of the JITDylibs in the search order in turn for the given
1430  /// symbol.
1432  lookup(const JITDylibSearchOrder &SearchOrder, SymbolStringPtr Symbol,
1433  SymbolState RequiredState = SymbolState::Ready);
1434 
1435  /// Convenience version of blocking lookup.
1436  /// Searches each of the JITDylibs in the search order in turn for the given
1437  /// symbol. The search will not find non-exported symbols.
1440  SymbolState RequiredState = SymbolState::Ready);
1441 
1442  /// Convenience version of blocking lookup.
1443  /// Searches each of the JITDylibs in the search order in turn for the given
1444  /// symbol. The search will not find non-exported symbols.
1447  SymbolState RequiredState = SymbolState::Ready);
1448 
1449  /// Materialize the given unit.
1450  void dispatchTask(std::unique_ptr<Task> T) {
1451  assert(T && "T must be non-null");
1452  DEBUG_WITH_TYPE("orc", dumpDispatchInfo(*T));
1453  DispatchTask(std::move(T));
1454  }
1455 
1456  /// Run a wrapper function in the executor.
1457  ///
1458  /// The wrapper function should be callable as:
1459  ///
1460  /// \code{.cpp}
1461  /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
1462  /// \endcode{.cpp}
1463  ///
1464  /// The given OnComplete function will be called to return the result.
1466  JITTargetAddress WrapperFnAddr,
1467  ArrayRef<char> ArgBuffer) {
1468  EPC->callWrapperAsync(std::move(OnComplete), WrapperFnAddr, ArgBuffer);
1469  }
1470 
1471  /// Run a wrapper function in the executor. The wrapper function should be
1472  /// callable as:
1473  ///
1474  /// \code{.cpp}
1475  /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
1476  /// \endcode{.cpp}
1478  ArrayRef<char> ArgBuffer) {
1479  std::promise<shared::WrapperFunctionResult> RP;
1480  auto RF = RP.get_future();
1482  [&](shared::WrapperFunctionResult R) { RP.set_value(std::move(R)); },
1483  WrapperFnAddr, ArgBuffer);
1484  return RF.get();
1485  }
1486 
1487  /// Run a wrapper function using SPS to serialize the arguments and
1488  /// deserialize the results.
1489  template <typename SPSSignature, typename SendResultT, typename... ArgTs>
1490  void callSPSWrapperAsync(SendResultT &&SendResult,
1491  JITTargetAddress WrapperFnAddr,
1492  const ArgTs &...Args) {
1494  [this,
1495  WrapperFnAddr](ExecutorProcessControl::SendResultFunction SendResult,
1496  const char *ArgData, size_t ArgSize) {
1497  callWrapperAsync(std::move(SendResult), WrapperFnAddr,
1498  ArrayRef<char>(ArgData, ArgSize));
1499  },
1500  std::move(SendResult), Args...);
1501  }
1502 
1503  /// Run a wrapper function using SPS to serialize the arguments and
1504  /// deserialize the results.
1505  ///
1506  /// If SPSSignature is a non-void function signature then the second argument
1507  /// (the first in the Args list) should be a reference to a return value.
1508  template <typename SPSSignature, typename... WrapperCallArgTs>
1510  WrapperCallArgTs &&...WrapperCallArgs) {
1512  [this, WrapperFnAddr](const char *ArgData, size_t ArgSize) {
1513  return callWrapper(WrapperFnAddr, ArrayRef<char>(ArgData, ArgSize));
1514  },
1515  std::forward<WrapperCallArgTs>(WrapperCallArgs)...);
1516  }
1517 
1518  /// Wrap a handler that takes concrete argument types (and a sender for a
1519  /// concrete return type) to produce an AsyncHandlerWrapperFunction. Uses SPS
1520  /// to unpack the arguments and pack the result.
1521  ///
1522  /// This function is intended to support easy construction of
1523  /// AsyncHandlerWrapperFunctions that can be associated with a tag
1524  /// (using registerJITDispatchHandler) and called from the executor.
1525  template <typename SPSSignature, typename HandlerT>
1527  return [H = std::forward<HandlerT>(H)](
1529  const char *ArgData, size_t ArgSize) mutable {
1531  std::move(SendResult));
1532  };
1533  }
1534 
1535  /// Wrap a class method that takes concrete argument types (and a sender for
1536  /// a concrete return type) to produce an AsyncHandlerWrapperFunction. Uses
1537  /// SPS to unpack teh arguments and pack the result.
1538  ///
1539  /// This function is intended to support easy construction of
1540  /// AsyncHandlerWrapperFunctions that can be associated with a tag
1541  /// (using registerJITDispatchHandler) and called from the executor.
1542  template <typename SPSSignature, typename ClassT, typename... MethodArgTs>
1544  wrapAsyncWithSPS(ClassT *Instance, void (ClassT::*Method)(MethodArgTs...)) {
1545  return wrapAsyncWithSPS<SPSSignature>(
1546  [Instance, Method](MethodArgTs &&...MethodArgs) {
1547  (Instance->*Method)(std::forward<MethodArgTs>(MethodArgs)...);
1548  });
1549  }
1550 
1551  /// For each tag symbol name, associate the corresponding
1552  /// AsyncHandlerWrapperFunction with the address of that symbol. The
1553  /// handler becomes callable from the executor using the ORC runtime
1554  /// __orc_rt_jit_dispatch function and the given tag.
1555  ///
1556  /// Tag symbols will be looked up in JD using LookupKind::Static,
1557  /// JITDylibLookupFlags::MatchAllSymbols (hidden tags will be found), and
1558  /// LookupFlags::WeaklyReferencedSymbol. Missing tag definitions will not
1559  /// cause an error, the handler will simply be dropped.
1562 
1563  /// Run a registered jit-side wrapper function.
1564  /// This should be called by the ExecutorProcessControl instance in response
1565  /// to incoming jit-dispatch requests from the executor.
1566  void
1568  JITTargetAddress HandlerFnTagAddr,
1569  ArrayRef<char> ArgBuffer);
1570 
1571  /// Dump the state of all the JITDylibs in this session.
1572  void dump(raw_ostream &OS);
1573 
1574 private:
1575  static void logErrorsToStdErr(Error Err) {
1576  logAllUnhandledErrors(std::move(Err), errs(), "JIT session error: ");
1577  }
1578 
1579  static void runOnCurrentThread(std::unique_ptr<Task> T) { T->run(); }
1580 
1581  void dispatchOutstandingMUs();
1582 
1583  static std::unique_ptr<MaterializationResponsibility>
1584  createMaterializationResponsibility(ResourceTracker &RT,
1585  SymbolFlagsMap Symbols,
1586  SymbolStringPtr InitSymbol) {
1587  auto &JD = RT.getJITDylib();
1588  std::unique_ptr<MaterializationResponsibility> MR(
1589  new MaterializationResponsibility(&JD, std::move(Symbols),
1590  std::move(InitSymbol)));
1591  JD.MRTrackers[MR.get()] = &RT;
1592  return MR;
1593  }
1594 
1595  Error removeResourceTracker(ResourceTracker &RT);
1596  void transferResourceTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1597  void destroyResourceTracker(ResourceTracker &RT);
1598 
1599  // State machine functions for query application..
1600 
1601  /// IL_updateCandidatesFor is called to remove already-defined symbols that
1602  /// match a given query from the set of candidate symbols to generate
1603  /// definitions for (no need to generate a definition if one already exists).
1604  Error IL_updateCandidatesFor(JITDylib &JD, JITDylibLookupFlags JDLookupFlags,
1605  SymbolLookupSet &Candidates,
1606  SymbolLookupSet *NonCandidates);
1607 
1608  /// OL_applyQueryPhase1 is an optionally re-startable loop for triggering
1609  /// definition generation. It is called when a lookup is performed, and again
1610  /// each time that LookupState::continueLookup is called.
1611  void OL_applyQueryPhase1(std::unique_ptr<InProgressLookupState> IPLS,
1612  Error Err);
1613 
1614  /// OL_completeLookup is run once phase 1 successfully completes for a lookup
1615  /// call. It attempts to attach the symbol to all symbol table entries and
1616  /// collect all MaterializationUnits to dispatch. If this method fails then
1617  /// all MaterializationUnits will be left un-materialized.
1618  void OL_completeLookup(std::unique_ptr<InProgressLookupState> IPLS,
1619  std::shared_ptr<AsynchronousSymbolQuery> Q,
1620  RegisterDependenciesFunction RegisterDependencies);
1621 
1622  /// OL_completeLookupFlags is run once phase 1 successfully completes for a
1623  /// lookupFlags call.
1624  void OL_completeLookupFlags(
1625  std::unique_ptr<InProgressLookupState> IPLS,
1626  unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
1627 
1628  // State machine functions for MaterializationResponsibility.
1629  void OL_destroyMaterializationResponsibility(
1631  SymbolNameSet OL_getRequestedSymbols(const MaterializationResponsibility &MR);
1632  Error OL_notifyResolved(MaterializationResponsibility &MR,
1633  const SymbolMap &Symbols);
1634  Error OL_notifyEmitted(MaterializationResponsibility &MR);
1635  Error OL_defineMaterializing(MaterializationResponsibility &MR,
1637  void OL_notifyFailed(MaterializationResponsibility &MR);
1638  Error OL_replace(MaterializationResponsibility &MR,
1639  std::unique_ptr<MaterializationUnit> MU);
1640  Expected<std::unique_ptr<MaterializationResponsibility>>
1641  OL_delegate(MaterializationResponsibility &MR, const SymbolNameSet &Symbols);
1642  void OL_addDependencies(MaterializationResponsibility &MR,
1643  const SymbolStringPtr &Name,
1644  const SymbolDependenceMap &Dependencies);
1645  void OL_addDependenciesForAll(MaterializationResponsibility &MR,
1646  const SymbolDependenceMap &Dependencies);
1647 
1648 #ifndef NDEBUG
1649  void dumpDispatchInfo(Task &T);
1650 #endif // NDEBUG
1651 
1652  mutable std::recursive_mutex SessionMutex;
1653  bool SessionOpen = true;
1654  std::unique_ptr<ExecutorProcessControl> EPC;
1655  std::unique_ptr<Platform> P;
1656  ErrorReporter ReportError = logErrorsToStdErr;
1657  DispatchTaskFunction DispatchTask = runOnCurrentThread;
1658 
1659  std::vector<ResourceManager *> ResourceManagers;
1660 
1661  std::vector<JITDylibSP> JDs;
1662 
1663  // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
1664  // with callbacks from asynchronous queries.
1665  mutable std::recursive_mutex OutstandingMUsMutex;
1666  std::vector<std::pair<std::unique_ptr<MaterializationUnit>,
1667  std::unique_ptr<MaterializationResponsibility>>>
1668  OutstandingMUs;
1669 
1670  mutable std::mutex JITDispatchHandlersMutex;
1671  DenseMap<JITTargetAddress, std::shared_ptr<JITDispatchHandlerFunction>>
1672  JITDispatchHandlers;
1673 };
1674 
1676  return JD->getExecutionSession();
1677 }
1678 
1679 template <typename Func>
1681  return JD->getExecutionSession().runSessionLocked([&]() -> Error {
1682  auto I = JD->MRTrackers.find(this);
1683  assert(I != JD->MRTrackers.end() && "No tracker for this MR");
1684  if (I->second->isDefunct())
1685  return make_error<ResourceTrackerDefunct>(I->second);
1686  F(I->second->getKeyUnsafe());
1687  return Error::success();
1688  });
1689 }
1690 
1691 template <typename GeneratorT>
1692 GeneratorT &JITDylib::addGenerator(std::unique_ptr<GeneratorT> DefGenerator) {
1693  auto &G = *DefGenerator;
1694  std::lock_guard<std::mutex> Lock(GeneratorsMutex);
1695  DefGenerators.push_back(std::move(DefGenerator));
1696  return G;
1697 }
1698 
1699 template <typename Func>
1701  -> decltype(F(std::declval<const JITDylibSearchOrder &>())) {
1702  return ES.runSessionLocked([&]() { return F(LinkOrder); });
1703 }
1704 
1705 template <typename MaterializationUnitType>
1706 Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &&MU,
1707  ResourceTrackerSP RT) {
1708  assert(MU && "Can not define with a null MU");
1709 
1710  if (MU->getSymbols().empty()) {
1711  // Empty MUs are allowable but pathological, so issue a warning.
1712  DEBUG_WITH_TYPE("orc", {
1713  dbgs() << "Warning: Discarding empty MU " << MU->getName() << " for "
1714  << getName() << "\n";
1715  });
1716  return Error::success();
1717  } else
1718  DEBUG_WITH_TYPE("orc", {
1719  dbgs() << "Defining MU " << MU->getName() << " for " << getName()
1720  << " (tracker: ";
1721  if (RT == getDefaultResourceTracker())
1722  dbgs() << "default)";
1723  else if (RT)
1724  dbgs() << RT.get() << ")\n";
1725  else
1726  dbgs() << "0x0, default will be used)\n";
1727  });
1728 
1729  return ES.runSessionLocked([&, this]() -> Error {
1730  if (auto Err = defineImpl(*MU))
1731  return Err;
1732 
1733  if (!RT)
1735 
1736  if (auto *P = ES.getPlatform()) {
1737  if (auto Err = P->notifyAdding(*RT, *MU))
1738  return Err;
1739  }
1740 
1741  installMaterializationUnit(std::move(MU), *RT);
1742  return Error::success();
1743  });
1744 }
1745 
1746 template <typename MaterializationUnitType>
1747 Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &MU,
1748  ResourceTrackerSP RT) {
1749  assert(MU && "Can not define with a null MU");
1750 
1751  if (MU->getSymbols().empty()) {
1752  // Empty MUs are allowable but pathological, so issue a warning.
1753  DEBUG_WITH_TYPE("orc", {
1754  dbgs() << "Warning: Discarding empty MU " << MU->getName() << getName()
1755  << "\n";
1756  });
1757  return Error::success();
1758  } else
1759  DEBUG_WITH_TYPE("orc", {
1760  dbgs() << "Defining MU " << MU->getName() << " for " << getName()
1761  << " (tracker: ";
1762  if (RT == getDefaultResourceTracker())
1763  dbgs() << "default)";
1764  else if (RT)
1765  dbgs() << RT.get() << ")\n";
1766  else
1767  dbgs() << "0x0, default will be used)\n";
1768  });
1769 
1770  return ES.runSessionLocked([&, this]() -> Error {
1771  if (auto Err = defineImpl(*MU))
1772  return Err;
1773 
1774  if (!RT)
1776 
1777  if (auto *P = ES.getPlatform()) {
1778  if (auto Err = P->notifyAdding(*RT, *MU))
1779  return Err;
1780  }
1781 
1782  installMaterializationUnit(std::move(MU), *RT);
1783  return Error::success();
1784  });
1785 }
1786 
1787 /// ReexportsGenerator can be used with JITDylib::addGenerator to automatically
1788 /// re-export a subset of the source JITDylib's symbols in the target.
1790 public:
1792 
1793  /// Create a reexports generator. If an Allow predicate is passed, only
1794  /// symbols for which the predicate returns true will be reexported. If no
1795  /// Allow predicate is passed, all symbols will be exported.
1796  ReexportsGenerator(JITDylib &SourceJD,
1797  JITDylibLookupFlags SourceJDLookupFlags,
1798  SymbolPredicate Allow = SymbolPredicate());
1799 
1801  JITDylibLookupFlags JDLookupFlags,
1802  const SymbolLookupSet &LookupSet) override;
1803 
1804 private:
1805  JITDylib &SourceJD;
1806  JITDylibLookupFlags SourceJDLookupFlags;
1807  SymbolPredicate Allow;
1808 };
1809 
1810 // --------------- IMPLEMENTATION --------------
1811 // Implementations for inline functions/methods.
1812 // ---------------------------------------------
1813 
1815  JD->getExecutionSession().OL_destroyMaterializationResponsibility(*this);
1816 }
1817 
1819  return JD->getExecutionSession().OL_getRequestedSymbols(*this);
1820 }
1821 
1823  const SymbolMap &Symbols) {
1824  return JD->getExecutionSession().OL_notifyResolved(*this, Symbols);
1825 }
1826 
1828  return JD->getExecutionSession().OL_notifyEmitted(*this);
1829 }
1830 
1833  return JD->getExecutionSession().OL_defineMaterializing(
1834  *this, std::move(SymbolFlags));
1835 }
1836 
1838  JD->getExecutionSession().OL_notifyFailed(*this);
1839 }
1840 
1842  std::unique_ptr<MaterializationUnit> MU) {
1843  return JD->getExecutionSession().OL_replace(*this, std::move(MU));
1844 }
1845 
1848  return JD->getExecutionSession().OL_delegate(*this, Symbols);
1849 }
1850 
1852  const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies) {
1853  JD->getExecutionSession().OL_addDependencies(*this, Name, Dependencies);
1854 }
1855 
1857  const SymbolDependenceMap &Dependencies) {
1858  JD->getExecutionSession().OL_addDependenciesForAll(*this, Dependencies);
1859 }
1860 
1861 } // End namespace orc
1862 } // End namespace llvm
1863 
1864 #endif // LLVM_EXECUTIONENGINE_ORC_CORE_H
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:1841
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:1260
llvm::orc::MaterializationResponsibility
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Definition: Core.h:506
llvm::orc::MaterializationTask::MaterializationTask
MaterializationTask(std::unique_ptr< MaterializationUnit > MU, std::unique_ptr< MaterializationResponsibility > MR)
Definition: Core.h:1264
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:1700
llvm::orc::Task::ID
static char ID
Definition: Core.h:1247
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::orc::SymbolsNotFound::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:108
llvm::orc::JITDylib
A symbol table that supports asynchoronous symbol queries.
Definition: Core.h:908
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:569
llvm::orc::MaterializationUnit::MaterializationUnit
MaterializationUnit(SymbolFlagsMap InitalSymbolFlags, SymbolStringPtr InitSymbol)
Definition: Core.h:657
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:157
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:1264
llvm::orc::DefinitionGenerator::~DefinitionGenerator
virtual ~DefinitionGenerator()
Definition: Core.cpp:610
llvm::orc::ExecutionSession::reportError
void reportError(Error Err)
Report a error for this execution session.
Definition: Core.h:1371
llvm::orc::InProgressLookupState
Definition: Core.cpp:484
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:1289
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:117
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:1278
llvm::orc::ExecutionSession::getJITDylibByName
JITDylib * getJITDylibByName(StringRef Name)
Return a pointer to the "name" JITDylib.
Definition: Core.cpp:1847
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:1360
llvm::orc::JITDylib::getDefaultResourceTracker
ResourceTrackerSP getDefaultResourceTracker()
Get the default resource tracker for this JITDylib.
Definition: Core.cpp:626
llvm::orc::JITDylib::ExecutionSession
friend class ExecutionSession
Definition: Core.h:911
llvm::orc::AbsoluteSymbolsMaterializationUnit
A MaterializationUnit implementation for pre-existing absolute symbols.
Definition: Core.h:708
llvm::orc::ResourceTrackerDefunct::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:75
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:1822
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:685
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()
Definition: Core.cpp:1702
llvm::orc::LookupKind::Static
@ Static
llvm::orc::SymbolsCouldNotBeRemoved::getSymbols
const SymbolNameSet & getSymbols() const
Definition: Core.h:455
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:277
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:429
llvm::orc::ResourceManager::~ResourceManager
virtual ~ResourceManager()
Definition: Core.cpp:66
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::orc::JITDylib::clear
Error clear()
Calls remove on all trackers currently associated with this JITDylib.
Definition: Core.cpp:612
llvm::orc::ExecutionSession::ResourceTracker
friend class ResourceTracker
Definition: Core.h:1282
llvm::orc::ReExportsMaterializationUnit
A materialization unit for symbol aliases.
Definition: Core.h:740
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
llvm::orc::SymbolsCouldNotBeRemoved
Used to notify clients that a set of symbols could not be removed.
Definition: Core.h:448
WrapperFunctionUtils.h
llvm::orc::FailedToMaterialize::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:85
llvm::orc::LookupState::~LookupState
~LookupState()
llvm::orc::ExecutionSession::callWrapperAsync
void callWrapperAsync(ExecutorProcessControl::SendResultFunction OnComplete, JITTargetAddress WrapperFnAddr, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
Definition: Core.h:1465
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::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:1831
llvm::orc::ExecutionSession::registerResourceManager
void registerResourceManager(ResourceManager &RM)
Register the given ResourceManager with this ExecutionSession.
Definition: Core.cpp:1830
llvm::orc::MaterializationTask::run
void run() override
Definition: Core.cpp:1803
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:145
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::orc::UnexpectedSymbolDefinitions::UnexpectedSymbolDefinitions
UnexpectedSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
Definition: Core.h:488
llvm::orc::FailedToMaterialize::getSymbols
const SymbolDependenceMap & getSymbols() const
Definition: Core.h:426
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::orc::LookupState::continueLookup
void continueLookup(Error Err)
Continue the lookup.
Definition: Core.cpp:604
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 the given symbols in each of the given JITDylibs,...
Definition: Core.cpp:1753
llvm::orc::UnexpectedSymbolDefinitions
Errors of this type should be returned if a module contains definitions for symbols that are not clai...
Definition: Core.h:484
llvm::orc::SymbolsNotFound::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:104
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:25
llvm::orc::MaterializationUnit
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
Definition: Core.h:650
llvm::orc::ExecutionSession::dispatchTask
void dispatchTask(std::unique_ptr< Task > T)
Materialize the given unit.
Definition: Core.h:1450
llvm::orc::ExecutionSession::JITDylib
friend class JITDylib
Definition: Core.h:1279
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:473
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:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:180
llvm::orc::JITDylib::createResourceTracker
ResourceTrackerSP createResourceTracker()
Create a resource tracker for this JITDylib.
Definition: Core.cpp:634
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:1282
llvm::orc::JITDylib::JITDylib
JITDylib(const JITDylib &)=delete
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:2109
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:2057
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet(SymbolStringPtr Name, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Definition: Core.h:184
llvm::orc::Task::printDescription
virtual void printDescription(raw_ostream &OS)=0
Description of the task to be performed. Used for logging.
llvm::orc::SymbolState
SymbolState
Represents the state that a symbol has reached during materialization.
Definition: Core.h:800
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:129
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:533
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:138
llvm::orc::UnexpectedSymbolDefinitions::getModuleName
const std::string & getModuleName() const
Definition: Core.h:492
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::AArch64::RP
@ RP
Definition: AArch64ISelLowering.h:471
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:1704
llvm::orc::SymbolLookupSet::containsDuplicates
bool containsDuplicates()
Returns true if this set contains any duplicates.
Definition: Core.h:367
llvm::orc::ExecutionSession::callSPSWrapper
Error callSPSWrapper(JITTargetAddress WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: Core.h:1509
llvm::orc::SymbolsNotFound
Used to notify clients when symbols can not be found during a lookup.
Definition: Core.h:433
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:486
llvm::orc::ExecutionSession::JITDispatchHandlerFunction
unique_function< void(ExecutorProcessControl::SendResultFunction SendResult, const char *ArgData, size_t ArgSize)> JITDispatchHandlerFunction
An asynchronous wrapper-function callable from the executor via jit-dispatch.
Definition: Core.h:1295
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:35
llvm::orc::AsynchronousSymbolQuery::JITSymbolResolverAdapter
friend class JITSymbolResolverAdapter
Definition: Core.h:817
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:1827
DenseSet.h
false
Definition: StackSlotColoring.cpp:142
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:1856
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::callSPSWrapperAsync
void callSPSWrapperAsync(SendResultT &&SendResult, JITTargetAddress WrapperFnAddr, const ArgTs &...Args)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: Core.h:1490
llvm::orc::ExecutionSession::intern
SymbolStringPtr intern(StringRef SymName)
Add a symbol name to the SymbolStringPool and return a pointer to it.
Definition: Core.h:1314
llvm::detail::DenseSetImpl::size
size_type size() const
Definition: DenseSet.h:81
llvm::ThreadSafeRefCountedBase
A thread-safe version of RefCountedBase.
Definition: IntrusiveRefCntPtr.h:101
llvm::orc::MaterializationUnit::~MaterializationUnit
virtual ~MaterializationUnit()
Definition: Core.h:665
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:1692
llvm::orc::AsynchronousSymbolQuery
A symbol query that returns results via a callback when results are ready.
Definition: Core.h:813
llvm::orc::ExecutionSession::runSessionLocked
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
Definition: Core.h:1324
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::orc::LookupKind::DLSym
@ DLSym
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:246
llvm::orc::MaterializationResponsibility::operator=
MaterializationResponsibility & operator=(MaterializationResponsibility &&)=delete
llvm::orc::FailedToMaterialize::FailedToMaterialize
FailedToMaterialize(std::shared_ptr< SymbolDependenceMap > Symbols)
Definition: Core.cpp:79
llvm::orc::SymbolsNotFound::ID
static char ID
Definition: Core.h:435
llvm::RTTIExtends
Inheritance utility for extensible RTTI.
Definition: ExtensibleRTTI.h:66
llvm::orc::ExecutionSession::setPlatform
void setPlatform(std::unique_ptr< Platform > P)
Set the Platform for this ExecutionSession.
Definition: Core.h:1317
llvm::orc::Task::run
virtual void run()=0
Run the task.
llvm::orc::SymbolLookupFlags::WeaklyReferencedSymbol
@ WeaklyReferencedSymbol
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:1818
llvm::orc::UnexpectedSymbolDefinitions::getSymbols
const SymbolNameVector & getSymbols() const
Definition: Core.h:493
llvm::orc::ExecutionSession::createBareJITDylib
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
Definition: Core.cpp:1856
llvm::orc::ExecutionSession::endSession
Error endSession()
End the session. Closes all JITDylibs.
Definition: Core.cpp:1811
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:538
llvm::orc::MaterializationResponsibility::withResourceKeyDo
Error withResourceKeyDo(Func &&F) const
Returns the ResourceTracker for this instance.
Definition: Core.h:1680
llvm::orc::MaterializationTask::printDescription
void printDescription(raw_ostream &OS) override
Definition: Core.cpp:1798
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::DenseSet< SymbolStringPtr >
llvm::orc::InProgressLookupFlagsState
Definition: Core.cpp:509
llvm::orc::shared::WrapperFunctionResult
C++ wrapper function result: Same as CWrapperFunctionResult but auto-releases memory.
Definition: WrapperFunctionUtils.h:45
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:179
llvm::orc::ExecutionSession::JITDispatchHandlerAssociationMap
DenseMap< SymbolStringPtr, JITDispatchHandlerFunction > JITDispatchHandlerAssociationMap
A map associating tag names with asynchronous wrapper function implementations in the JIT.
Definition: Core.h:1300
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:465
llvm::orc::JITDylib::MaterializationResponsibility
friend class MaterializationResponsibility
Definition: Core.h:913
llvm::orc::MaterializationResponsibility::getTargetJITDylib
JITDylib & getTargetJITDylib() const
Returns the target JITDylib that these symbols are being materialized into.
Definition: Core.h:524
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:1374
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:675
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
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:1922
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::MissingSymbolDefinitions::MissingSymbolDefinitions
MissingSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
Definition: Core.h:469
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:1544
I
#define I(x, y, z)
Definition: MD5.cpp:59
call
S is passed via registers r2 But gcc stores them to the and then reload them to and r3 before issuing the call(r0 contains the address of the format string)
Definition: README.txt:190
llvm::orc::JITDylib::AsynchronousSymbolQuerySet
std::set< std::shared_ptr< AsynchronousSymbolQuery > > AsynchronousSymbolQuerySet
Definition: Core.h:917
llvm::orc::MaterializationUnit::getSymbols
const SymbolFlagsMap & getSymbols() const
Return the set of symbols that this source provides.
Definition: Core.h:672
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:1851
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::ReexportsGenerator::ReexportsGenerator
ReexportsGenerator(JITDylib &SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolPredicate Allow=SymbolPredicate())
Create a reexports generator.
Definition: Core.cpp:563
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::orc::AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit
AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols)
Definition: Core.cpp:241
OrcV1Deprecation.h
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:1605
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:910
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:840
llvm::orc::ExecutionSession::ExecutionSession
ExecutionSession(std::unique_ptr< ExecutorProcessControl > EPC)
Construct an ExecutionSession with the given ExecutorProcessControl object.
Definition: Core.cpp:1805
llvm::orc::JITDylibSP
IntrusiveRefCntPtr< JITDylib > JITDylibSP
Definition: Core.h:48
llvm::orc::SymbolAliasMapEntry::SymbolAliasMapEntry
SymbolAliasMapEntry()=default
llvm::orc::JITDylib::remove
Error remove(const SymbolNameSet &Names)
Tries to remove the given symbols.
Definition: Core.cpp:1304
llvm::orc::SymbolLookupSet::begin
const_iterator begin() const
Definition: Core.h:254
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
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::JITDylib::getReverseDFSLinkOrder
std::vector< JITDylibSP > getReverseDFSLinkOrder()
Rteurn this JITDylib and its transitive dependencies in reverse DFS order based on linkage relationsh...
Definition: Core.cpp:1918
llvm::orc::DefinitionGenerator
Definition generators can be attached to JITDylibs to generate new definitions for otherwise unresolv...
Definition: Core.h:887
llvm::orc::ExecutionSession::getExecutorProcessControl
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
Definition: Core.h:1311
llvm::ErrorInfo
Base class for user error types.
Definition: Error.h:349
llvm::orc::JITDylib::operator=
JITDylib & operator=(const JITDylib &)=delete
llvm::orc::SymbolAliasMapEntry::Aliasee
SymbolStringPtr Aliasee
Definition: Core.h:387
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:787
llvm::orc::ExecutionSession::deregisterResourceManager
void deregisterResourceManager(ResourceManager &RM)
Deregister the given ResourceManager with this ExecutionSession.
Definition: Core.cpp:1834
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:472
llvm::orc::SymbolLookupSet::SymbolLookupSet
SymbolLookupSet()=default
llvm::orc::MaterializationResponsibility::~MaterializationResponsibility
~MaterializationResponsibility()
Destruct a MaterializationResponsibility instance.
Definition: Core.h:1814
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:1281
llvm::orc::ReexportsGenerator::SymbolPredicate
std::function< bool(SymbolStringPtr)> SymbolPredicate
Definition: Core.h:1791
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:1208
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::MaterializationResponsibility::MaterializationResponsibility
MaterializationResponsibility(MaterializationResponsibility &&)=delete
llvm::orc::LookupState
Wraps state for a lookup-in-progress.
Definition: Core.h:862
llvm::orc::JITDylib::getDFSLinkOrder
std::vector< JITDylibSP > getDFSLinkOrder()
Return this JITDylib and its transitive dependencies in DFS order based on linkage relationships.
Definition: Core.cpp:1914
llvm::orc::SymbolLookupSet::iterator
UnderlyingVector::iterator iterator
Definition: Core.h:179
llvm::orc::MaterializationUnit::ID
static char ID
Definition: Core.h:655
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:533
llvm::orc::ExecutionSession::createJITDylib
Expected< JITDylib & > createJITDylib(std::string Name)
Add a new JITDylib to this ExecutionSession.
Definition: Core.cpp:1864
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:71
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:97
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:143
llvm::orc::ResourceManager
Listens for ResourceTracker operations.
Definition: Core.h:97
llvm::orc::MaterializationResponsibility::failMaterialization
void failMaterialization()
Notify all not-yet-emitted covered by this MaterializationResponsibility instance that an error has o...
Definition: Core.h:1837
llvm::orc::ReexportsGenerator
ReexportsGenerator can be used with JITDylib::addGenerator to automatically re-export a subset of the...
Definition: Core.h:1789
llvm::orc::ExecutionSession::getPlatform
Platform * getPlatform()
Get the Platform for this session.
Definition: Core.h:1321
llvm::orc::ExecutionSession::ErrorReporter
std::function< void(Error)> ErrorReporter
For reporting errors.
Definition: Core.h:1286
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::orc::MaterializationResponsibility::getExecutionSession
ExecutionSession & getExecutionSession()
Returns the ExecutionSession for this instance.
Definition: Core.h:1675
H
#define H(x, y, z)
Definition: MD5.cpp:58
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:1293
llvm::orc::SymbolsNotFound::SymbolsNotFound
SymbolsNotFound(SymbolNameSet Symbols)
Definition: Core.cpp:93
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:23
llvm::orc::OrcV2CAPIHelper
Definition: OrcV2CBindings.cpp:28
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::orc::Task
Represents an abstract task for ORC to run.
Definition: Core.h:1245
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:1276
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:125
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1488
llvm::orc::symbolAliases
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
Definition: Core.h:778
llvm::unique
auto unique(Range &&R, Predicate P)
Definition: STLExtras.h:1700
llvm::orc::absoluteSymbols
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Definition: Core.h:733
llvm::orc::FailedToMaterialize::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:89
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:441
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:79
llvm::orc::ResourceTrackerDefunct::ResourceTrackerDefunct
ResourceTrackerDefunct(ResourceTrackerSP RT)
Definition: Core.cpp:68
llvm::orc::JITDylib::getName
const std::string & getName() const
Get the name for this JITDylib.
Definition: Core.h:925
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:1847
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:1706
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:1948
llvm::orc::AsynchronousSymbolQuery::JITDylib
friend class JITDylib
Definition: Core.h:816
llvm::orc::JITDylib::getExecutionSession
ExecutionSession & getExecutionSession() const
Get a reference to the ExecutionSession for this JITDylib.
Definition: Core.h:928
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::orc::MissingSymbolDefinitions::getSymbols
const SymbolNameVector & getSymbols() const
Definition: Core.h:474
llvm::orc::MissingSymbolDefinitions::ID
static char ID
Definition: Core.h:467
llvm::orc::ExecutionSession::runJITDispatchHandler
void runJITDispatchHandler(ExecutorProcessControl::SendResultFunction SendResult, JITTargetAddress HandlerFnTagAddr, ArrayRef< char > ArgBuffer)
Run a registered jit-side wrapper function.
Definition: Core.cpp:2088
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:1526
llvm::orc::MaterializationTask::ID
static char ID
Definition: Core.h:1262
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:271
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::orc::MaterializationUnit::SymbolFlags
SymbolFlagsMap SymbolFlags
Definition: Core.h:691
llvm::orc::UnexpectedSymbolDefinitions::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Core.cpp:134
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::SymbolsCouldNotBeRemoved::SymbolsCouldNotBeRemoved
SymbolsCouldNotBeRemoved(SymbolNameSet Symbols)
Definition: Core.cpp:112
llvm::orc::ExecutionSession::callWrapper
shared::WrapperFunctionResult callWrapper(JITTargetAddress WrapperFnAddr, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
Definition: Core.h:1477
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:1363
llvm::IntrusiveRefCntPtr
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Definition: IntrusiveRefCntPtr.h:163
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:450
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1172
llvm::orc::AsynchronousSymbolQuery::isComplete
bool isComplete() const
Returns true if all symbols covered by this query have been resolved.
Definition: Core.h:834
llvm::orc::SymbolsCouldNotBeRemoved::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Core.cpp:121
llvm::orc::MaterializationUnit::InitSymbol
SymbolStringPtr InitSymbol
Definition: Core.h:692
llvm::orc::JITDylib::removeGenerator
void removeGenerator(DefinitionGenerator &G)
Remove a definition generator from this JITDylib.
Definition: Core.cpp:641