LLVM  10.0.0svn
ExecutionUtils.cpp
Go to the documentation of this file.
1 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
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 
10 
12 #include "llvm/IR/Constants.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/GlobalVariable.h"
15 #include "llvm/IR/Module.h"
18 
19 namespace llvm {
20 namespace orc {
21 
23  : InitList(
24  GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
25  I((InitList && End) ? InitList->getNumOperands() : 0) {
26 }
27 
29  assert(InitList == Other.InitList && "Incomparable iterators.");
30  return I == Other.I;
31 }
32 
34  return !(*this == Other);
35 }
36 
38  ++I;
39  return *this;
40 }
41 
43  CtorDtorIterator Temp = *this;
44  ++I;
45  return Temp;
46 }
47 
49  ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
50  assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
51 
52  Constant *FuncC = CS->getOperand(1);
53  Function *Func = nullptr;
54 
55  // Extract function pointer, pulling off any casts.
56  while (FuncC) {
57  if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
58  Func = F;
59  break;
60  } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
61  if (CE->isCast())
62  FuncC = dyn_cast_or_null<ConstantExpr>(CE->getOperand(0));
63  else
64  break;
65  } else {
66  // This isn't anything we recognize. Bail out with Func left set to null.
67  break;
68  }
69  }
70 
71  ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
72  Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
73  if (Data && !isa<GlobalValue>(Data))
74  Data = nullptr;
75  return Element(Priority->getZExtValue(), Func, Data);
76 }
77 
79  const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
80  return make_range(CtorDtorIterator(CtorsList, false),
81  CtorDtorIterator(CtorsList, true));
82 }
83 
85  const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
86  return make_range(CtorDtorIterator(DtorsList, false),
87  CtorDtorIterator(DtorsList, true));
88 }
89 
91  if (empty(CtorDtors))
92  return;
93 
94  MangleAndInterner Mangle(
95  JD.getExecutionSession(),
96  (*CtorDtors.begin()).Func->getParent()->getDataLayout());
97 
98  for (const auto &CtorDtor : CtorDtors) {
99  assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
100  "Ctor/Dtor function must be named to be runnable under the JIT");
101 
102  // FIXME: Maybe use a symbol promoter here instead.
103  if (CtorDtor.Func->hasLocalLinkage()) {
104  CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
105  CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
106  }
107 
108  if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
109  dbgs() << " Skipping because why now?\n";
110  continue;
111  }
112 
113  CtorDtorsByPriority[CtorDtor.Priority].push_back(
114  Mangle(CtorDtor.Func->getName()));
115  }
116 }
117 
119  using CtorDtorTy = void (*)();
120 
121  SymbolNameSet Names;
122 
123  for (auto &KV : CtorDtorsByPriority) {
124  for (auto &Name : KV.second) {
125  auto Added = Names.insert(Name).second;
126  (void)Added;
127  assert(Added && "Ctor/Dtor names clashed");
128  }
129  }
130 
131  auto &ES = JD.getExecutionSession();
132  if (auto CtorDtorMap =
133  ES.lookup(JITDylibSearchList({{&JD, true}}), std::move(Names))) {
134  for (auto &KV : CtorDtorsByPriority) {
135  for (auto &Name : KV.second) {
136  assert(CtorDtorMap->count(Name) && "No entry for Name");
137  auto CtorDtor = reinterpret_cast<CtorDtorTy>(
138  static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
139  CtorDtor();
140  }
141  }
142  CtorDtorsByPriority.clear();
143  return Error::success();
144  } else
145  return CtorDtorMap.takeError();
146 }
147 
149  auto& CXXDestructorDataPairs = DSOHandleOverride;
150  for (auto &P : CXXDestructorDataPairs)
151  P.first(P.second);
152  CXXDestructorDataPairs.clear();
153 }
154 
156  void *Arg,
157  void *DSOHandle) {
158  auto& CXXDestructorDataPairs =
159  *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
160  CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
161  return 0;
162 }
163 
165  MangleAndInterner &Mangle) {
166  SymbolMap RuntimeInterposes;
167  RuntimeInterposes[Mangle("__dso_handle")] =
168  JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
170  RuntimeInterposes[Mangle("__cxa_atexit")] =
171  JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
173 
174  return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
175 }
176 
179  : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
180  GlobalPrefix(GlobalPrefix) {}
181 
183 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix,
184  SymbolPredicate Allow) {
185  std::string ErrMsg;
186  auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
187  if (!Lib.isValid())
188  return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
189  return std::make_unique<DynamicLibrarySearchGenerator>(
190  std::move(Lib), GlobalPrefix, std::move(Allow));
191 }
192 
195  const SymbolNameSet &Names) {
196  orc::SymbolNameSet Added;
197  orc::SymbolMap NewSymbols;
198 
199  bool HasGlobalPrefix = (GlobalPrefix != '\0');
200 
201  for (auto &Name : Names) {
202  if ((*Name).empty())
203  continue;
204 
205  if (Allow && !Allow(Name))
206  continue;
207 
208  if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
209  continue;
210 
211  std::string Tmp((*Name).data() + HasGlobalPrefix,
212  (*Name).size() - HasGlobalPrefix);
213  if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
214  Added.insert(Name);
215  NewSymbols[Name] = JITEvaluatedSymbol(
216  static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
218  }
219  }
220 
221  // Add any new symbols to JD. Since the generator is only called for symbols
222  // that are not already defined, this will never trigger a duplicate
223  // definition error, so we can wrap this call in a 'cantFail'.
224  if (!NewSymbols.empty())
225  cantFail(JD.define(absoluteSymbols(std::move(NewSymbols))));
226 
227  return Added;
228 }
229 
232  auto ArchiveBuffer = errorOrToExpected(MemoryBuffer::getFile(FileName));
233 
234  if (!ArchiveBuffer)
235  return ArchiveBuffer.takeError();
236 
237  return Create(L, std::move(*ArchiveBuffer));
238 }
239 
242  ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer) {
243  Error Err = Error::success();
244 
245  std::unique_ptr<StaticLibraryDefinitionGenerator> ADG(
246  new StaticLibraryDefinitionGenerator(L, std::move(ArchiveBuffer), Err));
247 
248  if (Err)
249  return std::move(Err);
250 
251  return std::move(ADG);
252 }
253 
256  const SymbolNameSet &Names) {
257 
259  SymbolNameSet NewDefs;
260 
261  for (const auto &Name : Names) {
262  auto Child = Archive.findSym(*Name);
263  if (!Child)
264  return Child.takeError();
265  if (*Child == None)
266  continue;
267  auto ChildBuffer = (*Child)->getMemoryBufferRef();
268  if (!ChildBuffer)
269  return ChildBuffer.takeError();
270  ChildBufferInfos.insert(
271  {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()});
272  NewDefs.insert(Name);
273  }
274 
275  for (auto ChildBufferInfo : ChildBufferInfos) {
276  MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
277  ChildBufferInfo.second);
278 
279  if (auto Err =
280  L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef), VModuleKey()))
281  return std::move(Err);
282 
283  --UnrealizedObjects;
284  }
285 
286  return NewDefs;
287 }
288 
289 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
290  ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, Error &Err)
291  : L(L), ArchiveBuffer(std::move(ArchiveBuffer)),
292  Archive(*this->ArchiveBuffer, Err) {
293 
294  if (Err)
295  return;
296 
297  Error Err2 = Error::success();
298  for (auto _ : Archive.children(Err2)) {
299  (void)_;
300  ++UnrealizedObjects;
301  }
302 
303  // No need to check this: We will leave it to the caller.
304  Err = std::move(Err2);
305 }
306 
307 } // End namespace orc.
308 } // End namespace llvm.
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...
const NoneType None
Definition: None.h:23
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:703
Accessor for an element of the global_ctors/global_dtors array.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool operator==(const CtorDtorIterator &Other) const
Test iterators for equality.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
const GlobalVariable * getNamedGlobal(StringRef Name) const
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:405
Externally visible function.
Definition: GlobalValue.h:48
F(f)
Expected< SymbolNameSet > tryToGenerate(JITDylib &JD, const SymbolNameSet &Names) override
std::vector< CXXDestructorDataPair > CXXDestructorDataPairList
Error enable(JITDylib &JD, MangleAndInterner &Mangler)
CtorDtorIterator & operator++()
Pre-increment iterator.
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols, VModuleKey K=VModuleKey())
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Definition: Core.h:348
Definition: BitVector.h:937
A utility class to expose symbols from a static library.
std::vector< std::pair< JITDylib *, bool > > JITDylibSearchList
A list of (JITDylib*, bool) pairs.
Definition: Core.h:59
Error define(std::unique_ptr< MaterializationUnitType > &&MU)
Define all symbols provided by the materialization unit to be part of this JITDylib.
Definition: Core.h:941
Mangles symbol names then uniques them in the context of an ExecutionSession.
Definition: Core.h:996
void * getAddressOfSymbol(const char *symbolName)
Searches through the library for the symbol symbolName.
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
void add(iterator_range< CtorDtorIterator > CtorDtors)
This class provides a portable interface to dynamic libraries which also might be known as shared lib...
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:888
std::function< bool(SymbolStringPtr)> SymbolPredicate
iterator_range< CtorDtorIterator > getDestructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
CtorDtorIterator(const GlobalVariable *GV, bool End)
Construct an iterator instance.
DynamicLibrarySearchGenerator(sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow=SymbolPredicate())
Create a DynamicLibrarySearchGenerator that searches for symbols in the given sys::DynamicLibrary.
Value * getOperand(unsigned i) const
Definition: User.h:169
#define P(N)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:148
This is an important base class in LLVM.
Definition: Constant.h:41
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:187
Expected< T > errorOrToExpected(ErrorOr< T > &&EO)
Convert an ErrorOr<T> to an Expected<T>.
Definition: Error.h:1103
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg=nullptr)
This function permanently loads the dynamic library at the given path.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast_or_null(const Y &Val)
Definition: Casting.h:353
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:209
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
unsigned getNumOperands() const
Definition: User.h:191
static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg, void *DSOHandle)
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
This iterator provides a convenient way to iterate over the elements of an llvm.global_ctors/llvm.global_dtors instance.
Module.h This file contains the declarations for the Module class.
static Constant * getInitializer(Constant *C)
Definition: Evaluator.cpp:205
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
A range adaptor for a pair of iterators.
ConstantArray - Constant Array Declarations.
Definition: Constants.h:413
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:189
void runDestructors()
Run any destructors recorded by the overriden __cxa_atexit function (CXAAtExitOverride).
uint8_t uint64_t VModuleKey
VModuleKey provides a unique identifier (allocated and managed by ExecutionSessions) for a module add...
Definition: Core.h:41
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Load(ObjectLayer &L, const char *FileName)
Try to create a StaticLibraryDefinitionGenerator from the given path.
iterator_range< CtorDtorIterator > getConstructors(const Module &M)
Create an iterator range over the entries of the llvm.global_ctors array.
#define I(x, y, z)
Definition: MD5.cpp:58
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:122
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
Element operator*() const
Dereference iterator.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
IteratorT begin() const
Interface for Layers that accept object files.
Definition: Layer.h:113
Expected< SymbolNameSet > tryToGenerate(JITDylib &JD, const SymbolNameSet &Names) override
bool operator!=(const CtorDtorIterator &Other) const
Test iterators for inequality.
#define _
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Create(ObjectLayer &L, std::unique_ptr< MemoryBuffer > ArchiveBuffer)
Try to create a StaticLibrarySearchGenerator from the given memory buffer.
A symbol table that supports asynchoronous symbol queries.
Definition: Core.h:480
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77