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