LLVM  15.0.0git
ExecutionUtils.h
Go to the documentation of this file.
1 //===- ExecutionUtils.h - Utilities for executing code in Orc ---*- 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 utilities for executing code in Orc.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
14 #define LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
15 
16 #include "llvm/ADT/StringMap.h"
23 #include "llvm/Object/Archive.h"
25 #include <algorithm>
26 #include <cstdint>
27 #include <utility>
28 #include <vector>
29 
30 namespace llvm {
31 
32 class ConstantArray;
33 class GlobalVariable;
34 class Function;
35 class Module;
36 class Value;
37 
38 namespace orc {
39 
40 class ObjectLayer;
41 
42 /// This iterator provides a convenient way to iterate over the elements
43 /// of an llvm.global_ctors/llvm.global_dtors instance.
44 ///
45 /// The easiest way to get hold of instances of this class is to use the
46 /// getConstructors/getDestructors functions.
48 public:
49  /// Accessor for an element of the global_ctors/global_dtors array.
50  ///
51  /// This class provides a read-only view of the element with any casts on
52  /// the function stripped away.
53  struct Element {
56 
57  unsigned Priority;
60  };
61 
62  /// Construct an iterator instance. If End is true then this iterator
63  /// acts as the end of the range, otherwise it is the beginning.
64  CtorDtorIterator(const GlobalVariable *GV, bool End);
65 
66  /// Test iterators for equality.
67  bool operator==(const CtorDtorIterator &Other) const;
68 
69  /// Test iterators for inequality.
70  bool operator!=(const CtorDtorIterator &Other) const;
71 
72  /// Pre-increment iterator.
74 
75  /// Post-increment iterator.
77 
78  /// Dereference iterator. The resulting value provides a read-only view
79  /// of this element of the global_ctors/global_dtors list.
80  Element operator*() const;
81 
82 private:
83  const ConstantArray *InitList;
84  unsigned I;
85 };
86 
87 /// Create an iterator range over the entries of the llvm.global_ctors
88 /// array.
90 
91 /// Create an iterator range over the entries of the llvm.global_ctors
92 /// array.
94 
95 /// This iterator provides a convenient way to iterate over GlobalValues that
96 /// have initialization effects.
98 public:
99  StaticInitGVIterator() = default;
100 
102  : I(M.global_values().begin()), E(M.global_values().end()),
103  ObjFmt(Triple(M.getTargetTriple()).getObjectFormat()) {
104  if (I != E) {
105  if (!isStaticInitGlobal(*I))
106  moveToNextStaticInitGlobal();
107  } else
109  }
110 
111  bool operator==(const StaticInitGVIterator &O) const { return I == O.I; }
112  bool operator!=(const StaticInitGVIterator &O) const { return I != O.I; }
113 
115  assert(I != E && "Increment past end of range");
116  moveToNextStaticInitGlobal();
117  return *this;
118  }
119 
120  GlobalValue &operator*() { return *I; }
121 
122 private:
123  bool isStaticInitGlobal(GlobalValue &GV);
124  void moveToNextStaticInitGlobal() {
125  ++I;
126  while (I != E && !isStaticInitGlobal(*I))
127  ++I;
128  if (I == E)
130  }
131 
134 };
135 
136 /// Create an iterator range over the GlobalValues that contribute to static
137 /// initialization.
140 }
141 
143 public:
144  CtorDtorRunner(JITDylib &JD) : JD(JD) {}
145  void add(iterator_range<CtorDtorIterator> CtorDtors);
146  Error run();
147 
148 private:
149  using CtorDtorList = std::vector<SymbolStringPtr>;
150  using CtorDtorPriorityMap = std::map<unsigned, CtorDtorList>;
151 
152  JITDylib &JD;
153  CtorDtorPriorityMap CtorDtorsByPriority;
154 };
155 
156 /// Support class for static dtor execution. For hosted (in-process) JITs
157 /// only!
158 ///
159 /// If a __cxa_atexit function isn't found C++ programs that use static
160 /// destructors will fail to link. However, we don't want to use the host
161 /// process's __cxa_atexit, because it will schedule JIT'd destructors to run
162 /// after the JIT has been torn down, which is no good. This class makes it easy
163 /// to override __cxa_atexit (and the related __dso_handle).
164 ///
165 /// To use, clients should manually call searchOverrides from their symbol
166 /// resolver. This should generally be done after attempting symbol resolution
167 /// inside the JIT, but before searching the host process's symbol table. When
168 /// the client determines that destructors should be run (generally at JIT
169 /// teardown or after a return from main), the runDestructors method should be
170 /// called.
172 public:
173  /// Run any destructors recorded by the overriden __cxa_atexit function
174  /// (CXAAtExitOverride).
175  void runDestructors();
176 
177 protected:
178  template <typename PtrTy> JITTargetAddress toTargetAddress(PtrTy *P) {
179  return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(P));
180  }
181 
182  using DestructorPtr = void (*)(void *);
183  using CXXDestructorDataPair = std::pair<DestructorPtr, void *>;
184  using CXXDestructorDataPairList = std::vector<CXXDestructorDataPair>;
186  static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg,
187  void *DSOHandle);
188 };
189 
191 public:
193 };
194 
195 /// An interface for Itanium __cxa_atexit interposer implementations.
197 public:
198  struct AtExitRecord {
199  void (*F)(void *);
200  void *Ctx;
201  };
202 
203  void registerAtExit(void (*F)(void *), void *Ctx, void *DSOHandle);
204  void runAtExits(void *DSOHandle);
205 
206 private:
207  std::mutex AtExitsMutex;
209 };
210 
211 /// A utility class to expose symbols found via dlsym to the JIT.
212 ///
213 /// If an instance of this class is attached to a JITDylib as a fallback
214 /// definition generator, then any symbol found in the given DynamicLibrary that
215 /// passes the 'Allow' predicate will be added to the JITDylib.
217 public:
219 
220  /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
221  /// given sys::DynamicLibrary.
222  ///
223  /// If the Allow predicate is given then only symbols matching the predicate
224  /// will be searched for. If the predicate is not given then all symbols will
225  /// be searched for.
226  DynamicLibrarySearchGenerator(sys::DynamicLibrary Dylib, char GlobalPrefix,
227  SymbolPredicate Allow = SymbolPredicate());
228 
229  /// Permanently loads the library at the given path and, on success, returns
230  /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
231  /// in the library. On failure returns the reason the library failed to load.
233  Load(const char *FileName, char GlobalPrefix,
234  SymbolPredicate Allow = SymbolPredicate());
235 
236  /// Creates a DynamicLibrarySearchGenerator that searches for symbols in
237  /// the current process.
239  GetForCurrentProcess(char GlobalPrefix,
240  SymbolPredicate Allow = SymbolPredicate()) {
241  return Load(nullptr, GlobalPrefix, std::move(Allow));
242  }
243 
245  JITDylibLookupFlags JDLookupFlags,
246  const SymbolLookupSet &Symbols) override;
247 
248 private:
249  sys::DynamicLibrary Dylib;
250  SymbolPredicate Allow;
251  char GlobalPrefix;
252 };
253 
254 /// A utility class to expose symbols from a static library.
255 ///
256 /// If an instance of this class is attached to a JITDylib as a fallback
257 /// definition generator, then any symbol found in the archive will result in
258 /// the containing object being added to the JITDylib.
260 public:
261  // Interface builder function for objects loaded from this archive.
262  using GetObjectFileInterface =
265 
266  /// Try to create a StaticLibraryDefinitionGenerator from the given path.
267  ///
268  /// This call will succeed if the file at the given path is a static library
269  /// is a valid archive, otherwise it will return an error.
271  Load(ObjectLayer &L, const char *FileName,
272  GetObjectFileInterface GetObjFileInterface = GetObjectFileInterface());
273 
274  /// Try to create a StaticLibraryDefinitionGenerator from the given path.
275  ///
276  /// This call will succeed if the file at the given path is a static library
277  /// or a MachO universal binary containing a static library that is compatible
278  /// with the given triple. Otherwise it will return an error.
280  Load(ObjectLayer &L, const char *FileName, const Triple &TT,
281  GetObjectFileInterface GetObjFileInterface = GetObjectFileInterface());
282 
283  /// Try to create a StaticLibrarySearchGenerator from the given memory buffer.
284  /// This call will succeed if the buffer contains a valid archive, otherwise
285  /// it will return an error.
287  Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
288  GetObjectFileInterface GetObjFileInterface = GetObjectFileInterface());
289 
291  JITDylibLookupFlags JDLookupFlags,
292  const SymbolLookupSet &Symbols) override;
293 
294 private:
296  std::unique_ptr<MemoryBuffer> ArchiveBuffer,
297  GetObjectFileInterface GetObjFileInterface,
298  Error &Err);
299 
300  ObjectLayer &L;
301  GetObjectFileInterface GetObjFileInterface;
302  std::unique_ptr<MemoryBuffer> ArchiveBuffer;
303  std::unique_ptr<object::Archive> Archive;
304 };
305 
306 } // end namespace orc
307 } // end namespace llvm
308 
309 #endif // LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
llvm::orc::CtorDtorIterator::Element::Func
Function * Func
Definition: ExecutionUtils.h:58
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::orc::JITDylib
Represents a JIT'd dynamic library.
Definition: Core.h:950
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::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::orc::CtorDtorRunner::add
void add(iterator_range< CtorDtorIterator > CtorDtors)
Definition: ExecutionUtils.cpp:113
llvm::unique_function< Expected< MaterializationUnit::Interface >(ExecutionSession &ES, MemoryBufferRef ObjBuffer)>
llvm::orc::getConstructors
iterator_range< CtorDtorIterator > getConstructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
Definition: ExecutionUtils.cpp:81
llvm::Function
Definition: Function.h:60
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::SymbolLookupSet
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Definition: Core.h:175
llvm::orc::SymbolStringPtr
Pointer to a pooled string representing a symbol name.
Definition: SymbolStringPool.h:50
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
GlobalPrefix
@ GlobalPrefix
Definition: AsmWriter.cpp:343
DynamicLibrary.h
llvm::orc::StaticInitGVIterator::StaticInitGVIterator
StaticInitGVIterator(Module &M)
Definition: ExecutionUtils.h:101
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:235
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:226
llvm::orc::ItaniumCXAAtExitSupport::AtExitRecord::F
void(* F)(void *)
Definition: ExecutionUtils.h:199
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::orc::LocalCXXRuntimeOverridesBase::DSOHandleOverride
CXXDestructorDataPairList DSOHandleOverride
Definition: ExecutionUtils.h:185
llvm::Mangler
Definition: Mangler.h:27
llvm::concat_iterator< GlobalValue, iterator, global_iterator, alias_iterator, ifunc_iterator >
llvm::orc::LookupKind
LookupKind
Describes the kind of lookup being performed.
Definition: Core.h:149
RuntimeDyld.h
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::orc::CtorDtorIterator::operator==
bool operator==(const CtorDtorIterator &Other) const
Test iterators for equality.
Definition: ExecutionUtils.cpp:31
llvm::sys::DynamicLibrary
This class provides a portable interface to dynamic libraries which also might be known as shared lib...
Definition: DynamicLibrary.h:36
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::orc::CtorDtorIterator
This iterator provides a convenient way to iterate over the elements of an llvm.global_ctors/llvm....
Definition: ExecutionUtils.h:47
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:186
llvm::orc::DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator
DynamicLibrarySearchGenerator(sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow=SymbolPredicate())
Create a DynamicLibrarySearchGenerator that searches for symbols in the given sys::DynamicLibrary.
Definition: ExecutionUtils.cpp:222
llvm::orc::CtorDtorIterator::Element::Data
Value * Data
Definition: ExecutionUtils.h:59
llvm::orc::StaticInitGVIterator
This iterator provides a convenient way to iterate over GlobalValues that have initialization effects...
Definition: ExecutionUtils.h:97
llvm::orc::LocalCXXRuntimeOverrides::enable
Error enable(JITDylib &JD, MangleAndInterner &Mangler)
Definition: ExecutionUtils.cpp:185
llvm::orc::DynamicLibrarySearchGenerator
A utility class to expose symbols found via dlsym to the JIT.
Definition: ExecutionUtils.h:216
llvm::ConstantArray
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
llvm::orc::StaticInitGVIterator::StaticInitGVIterator
StaticInitGVIterator()=default
llvm::orc::ObjectLayer
Interface for Layers that accept object files.
Definition: Layer.h:133
llvm::orc::ItaniumCXAAtExitSupport
An interface for Itanium __cxa_atexit interposer implementations.
Definition: ExecutionUtils.h:196
StringMap.h
llvm::orc::CtorDtorIterator::Element::Priority
unsigned Priority
Definition: ExecutionUtils.h:57
llvm::orc::getStaticInitGVs
iterator_range< StaticInitGVIterator > getStaticInitGVs(Module &M)
Create an iterator range over the GlobalValues that contribute to static initialization.
Definition: ExecutionUtils.h:138
llvm::orc::LocalCXXRuntimeOverridesBase::runDestructors
void runDestructors()
Run any destructors recorded by the overriden __cxa_atexit function (CXAAtExitOverride).
Definition: ExecutionUtils.cpp:169
llvm::orc::DynamicLibrarySearchGenerator::tryToGenerate
Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) override
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
Definition: ExecutionUtils.cpp:238
llvm::orc::LocalCXXRuntimeOverridesBase::CXXDestructorDataPairList
std::vector< CXXDestructorDataPair > CXXDestructorDataPairList
Definition: ExecutionUtils.h:184
llvm::orc::LocalCXXRuntimeOverridesBase::DestructorPtr
void(*)(void *) DestructorPtr
Definition: ExecutionUtils.h:182
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::orc::getDestructors
iterator_range< CtorDtorIterator > getDestructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
Definition: ExecutionUtils.cpp:87
uint64_t
llvm::orc::ItaniumCXAAtExitSupport::AtExitRecord::Ctx
void * Ctx
Definition: ExecutionUtils.h:200
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::DenseMap
Definition: DenseMap.h:716
llvm::orc::LocalCXXRuntimeOverridesBase::CXAAtExitOverride
static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg, void *DSOHandle)
Definition: ExecutionUtils.cpp:176
llvm::orc::StaticLibraryDefinitionGenerator::GetObjectFileInterface
unique_function< Expected< MaterializationUnit::Interface >(ExecutionSession &ES, MemoryBufferRef ObjBuffer)> GetObjectFileInterface
Definition: ExecutionUtils.h:264
llvm::orc::CtorDtorIterator::Element
Accessor for an element of the global_ctors/global_dtors array.
Definition: ExecutionUtils.h:53
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::orc::CtorDtorIterator::operator!=
bool operator!=(const CtorDtorIterator &Other) const
Test iterators for inequality.
Definition: ExecutionUtils.cpp:36
iterator_range.h
llvm::orc::StaticLibraryDefinitionGenerator
A utility class to expose symbols from a static library.
Definition: ExecutionUtils.h:259
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::orc::DefinitionGenerator
Definition generators can be attached to JITDylibs to generate new definitions for otherwise unresolv...
Definition: Core.h:915
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::orc::StaticInitGVIterator::operator==
bool operator==(const StaticInitGVIterator &O) const
Definition: ExecutionUtils.h:111
llvm::orc::CtorDtorIterator::operator++
CtorDtorIterator & operator++()
Pre-increment iterator.
Definition: ExecutionUtils.cpp:40
llvm::orc::StaticInitGVIterator::operator!=
bool operator!=(const StaticInitGVIterator &O) const
Definition: ExecutionUtils.h:112
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::orc::LookupState
Wraps state for a lookup-in-progress.
Definition: Core.h:890
llvm::orc::StaticLibraryDefinitionGenerator::Load
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Load(ObjectLayer &L, const char *FileName, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibraryDefinitionGenerator from the given path.
Definition: ExecutionUtils.cpp:273
Archive.h
llvm::orc::ItaniumCXAAtExitSupport::runAtExits
void runAtExits(void *DSOHandle)
Definition: ExecutionUtils.cpp:204
llvm::Triple::ObjectFormatType
ObjectFormatType
Definition: Triple.h:269
llvm::orc::ItaniumCXAAtExitSupport::registerAtExit
void registerAtExit(void(*F)(void *), void *Ctx, void *DSOHandle)
Definition: ExecutionUtils.cpp:198
llvm::orc::MangleAndInterner
Mangles symbol names then uniques them in the context of an ExecutionSession.
Definition: Mangling.h:26
llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess
static Expected< std::unique_ptr< DynamicLibrarySearchGenerator > > GetForCurrentProcess(char GlobalPrefix, SymbolPredicate Allow=SymbolPredicate())
Creates a DynamicLibrarySearchGenerator that searches for symbols in the current process.
Definition: ExecutionUtils.h:239
llvm::orc::StaticInitGVIterator::operator*
GlobalValue & operator*()
Definition: ExecutionUtils.h:120
Mangling.h
llvm::orc::ItaniumCXAAtExitSupport::AtExitRecord
Definition: ExecutionUtils.h:198
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::orc::ExecutionSession
An ExecutionSession represents a running JIT program.
Definition: Core.h:1362
llvm::AArch64CC::LS
@ LS
Definition: AArch64BaseInfo.h:264
llvm::orc::StaticLibraryDefinitionGenerator::tryToGenerate
Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) override
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
Definition: ExecutionUtils.cpp:350
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::orc::CtorDtorIterator::Element::Element
Element(unsigned Priority, Function *Func, Value *Data)
Definition: ExecutionUtils.h:54
llvm::orc::LocalCXXRuntimeOverridesBase
Support class for static dtor execution.
Definition: ExecutionUtils.h:171
llvm::orc::StaticInitGVIterator::operator++
StaticInitGVIterator & operator++()
Definition: ExecutionUtils.h:114
llvm::orc::CtorDtorIterator::CtorDtorIterator
CtorDtorIterator(const GlobalVariable *GV, bool End)
Construct an iterator instance.
Definition: ExecutionUtils.cpp:25
Core.h
llvm::orc::CtorDtorIterator::operator*
Element operator*() const
Dereference iterator.
Definition: ExecutionUtils.cpp:51
llvm::orc::DynamicLibrarySearchGenerator::SymbolPredicate
std::function< bool(const SymbolStringPtr &)> SymbolPredicate
Definition: ExecutionUtils.h:218
llvm::orc::LocalCXXRuntimeOverridesBase::CXXDestructorDataPair
std::pair< DestructorPtr, void * > CXXDestructorDataPair
Definition: ExecutionUtils.h:183
llvm::orc::DynamicLibrarySearchGenerator::Load
static Expected< std::unique_ptr< DynamicLibrarySearchGenerator > > Load(const char *FileName, char GlobalPrefix, SymbolPredicate Allow=SymbolPredicate())
Permanently loads the library at the given path and, on success, returns a DynamicLibrarySearchGenera...
Definition: ExecutionUtils.cpp:228
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::orc::LocalCXXRuntimeOverridesBase::toTargetAddress
JITTargetAddress toTargetAddress(PtrTy *P)
Definition: ExecutionUtils.h:178
llvm::orc::LocalCXXRuntimeOverrides
Definition: ExecutionUtils.h:190
llvm::orc::StaticLibraryDefinitionGenerator::Create
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Create(ObjectLayer &L, std::unique_ptr< MemoryBuffer > ArchiveBuffer, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibrarySearchGenerator from the given memory buffer.
Definition: ExecutionUtils.cpp:335
llvm::orc::JITDylibLookupFlags
JITDylibLookupFlags
Lookup flags that apply to each dylib in the search order for a lookup.
Definition: Core.h:127
llvm::Module::global_value_iterator
concat_iterator< GlobalValue, iterator, global_iterator, alias_iterator, ifunc_iterator > global_value_iterator
Definition: Module.h:694
llvm::orc::CtorDtorRunner::run
Error run()
Definition: ExecutionUtils.cpp:141
OrcError.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::orc::CtorDtorRunner
Definition: ExecutionUtils.h:142
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::orc::CtorDtorRunner::CtorDtorRunner
CtorDtorRunner(JITDylib &JD)
Definition: ExecutionUtils.h:144