LLVM  4.0.0
MCJIT.cpp
Go to the documentation of this file.
1 //===-- MCJIT.cpp - MC-based Just-in-Time Compiler ------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "MCJIT.h"
11 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/DataLayout.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/IR/Function.h"
20 #include "llvm/IR/Mangler.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/Object/Archive.h"
24 #include "llvm/Object/ObjectFile.h"
29 
30 using namespace llvm;
31 
32 namespace {
33 
34 static struct RegisterJIT {
35  RegisterJIT() { MCJIT::Register(); }
36 } JITRegistrator;
37 
38 }
39 
40 extern "C" void LLVMLinkInMCJIT() {
41 }
42 
44 MCJIT::createJIT(std::unique_ptr<Module> M,
45  std::string *ErrorStr,
46  std::shared_ptr<MCJITMemoryManager> MemMgr,
47  std::shared_ptr<JITSymbolResolver> Resolver,
48  std::unique_ptr<TargetMachine> TM) {
49  // Try to register the program as a source of symbols to resolve against.
50  //
51  // FIXME: Don't do this here.
53 
54  if (!MemMgr || !Resolver) {
55  auto RTDyldMM = std::make_shared<SectionMemoryManager>();
56  if (!MemMgr)
57  MemMgr = RTDyldMM;
58  if (!Resolver)
59  Resolver = RTDyldMM;
60  }
61 
62  return new MCJIT(std::move(M), std::move(TM), std::move(MemMgr),
63  std::move(Resolver));
64 }
65 
66 MCJIT::MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> TM,
67  std::shared_ptr<MCJITMemoryManager> MemMgr,
68  std::shared_ptr<JITSymbolResolver> Resolver)
69  : ExecutionEngine(TM->createDataLayout(), std::move(M)), TM(std::move(TM)),
70  Ctx(nullptr), MemMgr(std::move(MemMgr)),
71  Resolver(*this, std::move(Resolver)), Dyld(*this->MemMgr, this->Resolver),
72  ObjCache(nullptr) {
73  // FIXME: We are managing our modules, so we do not want the base class
74  // ExecutionEngine to manage them as well. To avoid double destruction
75  // of the first (and only) module added in ExecutionEngine constructor
76  // we remove it from EE and will destruct it ourselves.
77  //
78  // It may make sense to move our module manager (based on SmallStPtr) back
79  // into EE if the JIT and Interpreter can live with it.
80  // If so, additional functions: addModule, removeModule, FindFunctionNamed,
81  // runStaticConstructorsDestructors could be moved back to EE as well.
82  //
83  std::unique_ptr<Module> First = std::move(Modules[0]);
84  Modules.clear();
85 
86  if (First->getDataLayout().isDefault())
87  First->setDataLayout(getDataLayout());
88 
89  OwnedModules.addModule(std::move(First));
91 }
92 
94  MutexGuard locked(lock);
95 
96  Dyld.deregisterEHFrames();
97 
98  for (auto &Obj : LoadedObjects)
99  if (Obj)
100  NotifyFreeingObject(*Obj);
101 
102  Archives.clear();
103 }
104 
105 void MCJIT::addModule(std::unique_ptr<Module> M) {
106  MutexGuard locked(lock);
107 
108  if (M->getDataLayout().isDefault())
109  M->setDataLayout(getDataLayout());
110 
111  OwnedModules.addModule(std::move(M));
112 }
113 
115  MutexGuard locked(lock);
116  return OwnedModules.removeModule(M);
117 }
118 
119 void MCJIT::addObjectFile(std::unique_ptr<object::ObjectFile> Obj) {
120  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> L = Dyld.loadObject(*Obj);
121  if (Dyld.hasError())
123 
124  NotifyObjectEmitted(*Obj, *L);
125 
126  LoadedObjects.push_back(std::move(Obj));
127 }
128 
130  std::unique_ptr<object::ObjectFile> ObjFile;
131  std::unique_ptr<MemoryBuffer> MemBuf;
132  std::tie(ObjFile, MemBuf) = Obj.takeBinary();
133  addObjectFile(std::move(ObjFile));
134  Buffers.push_back(std::move(MemBuf));
135 }
136 
138  Archives.push_back(std::move(A));
139 }
140 
142  MutexGuard locked(lock);
143  ObjCache = NewCache;
144 }
145 
146 std::unique_ptr<MemoryBuffer> MCJIT::emitObject(Module *M) {
147  MutexGuard locked(lock);
148 
149  // This must be a module which has already been added but not loaded to this
150  // MCJIT instance, since these conditions are tested by our caller,
151  // generateCodeForModule.
152 
154 
155  // The RuntimeDyld will take ownership of this shortly
156  SmallVector<char, 4096> ObjBufferSV;
157  raw_svector_ostream ObjStream(ObjBufferSV);
158 
159  // Turn the machine code intermediate representation into bytes in memory
160  // that may be executed.
161  if (TM->addPassesToEmitMC(PM, Ctx, ObjStream, !getVerifyModules()))
162  report_fatal_error("Target does not support MC emission!");
163 
164  // Initialize passes.
165  PM.run(*M);
166  // Flush the output buffer to get the generated code into memory
167 
168  std::unique_ptr<MemoryBuffer> CompiledObjBuffer(
169  new ObjectMemoryBuffer(std::move(ObjBufferSV)));
170 
171  // If we have an object cache, tell it about the new object.
172  // Note that we're using the compiled image, not the loaded image (as below).
173  if (ObjCache) {
174  // MemoryBuffer is a thin wrapper around the actual memory, so it's OK
175  // to create a temporary object here and delete it after the call.
176  MemoryBufferRef MB = CompiledObjBuffer->getMemBufferRef();
177  ObjCache->notifyObjectCompiled(M, MB);
178  }
179 
180  return CompiledObjBuffer;
181 }
182 
184  // Get a thread lock to make sure we aren't trying to load multiple times
185  MutexGuard locked(lock);
186 
187  // This must be a module which has already been added to this MCJIT instance.
188  assert(OwnedModules.ownsModule(M) &&
189  "MCJIT::generateCodeForModule: Unknown module.");
190 
191  // Re-compilation is not supported
192  if (OwnedModules.hasModuleBeenLoaded(M))
193  return;
194 
195  std::unique_ptr<MemoryBuffer> ObjectToLoad;
196  // Try to load the pre-compiled object from cache if possible
197  if (ObjCache)
198  ObjectToLoad = ObjCache->getObject(M);
199 
200  assert(M->getDataLayout() == getDataLayout() && "DataLayout Mismatch");
201 
202  // If the cache did not contain a suitable object, compile the object
203  if (!ObjectToLoad) {
204  ObjectToLoad = emitObject(M);
205  assert(ObjectToLoad && "Compilation did not produce an object.");
206  }
207 
208  // Load the object into the dynamic linker.
209  // MCJIT now owns the ObjectImage pointer (via its LoadedObjects list).
211  object::ObjectFile::createObjectFile(ObjectToLoad->getMemBufferRef());
212  if (!LoadedObject) {
213  std::string Buf;
214  raw_string_ostream OS(Buf);
215  logAllUnhandledErrors(LoadedObject.takeError(), OS, "");
216  OS.flush();
217  report_fatal_error(Buf);
218  }
219  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> L =
220  Dyld.loadObject(*LoadedObject.get());
221 
222  if (Dyld.hasError())
224 
225  NotifyObjectEmitted(*LoadedObject.get(), *L);
226 
227  Buffers.push_back(std::move(ObjectToLoad));
228  LoadedObjects.push_back(std::move(*LoadedObject));
229 
230  OwnedModules.markModuleAsLoaded(M);
231 }
232 
234  MutexGuard locked(lock);
235 
236  // Resolve any outstanding relocations.
237  Dyld.resolveRelocations();
238 
239  OwnedModules.markAllLoadedModulesAsFinalized();
240 
241  // Register EH frame data for any module we own which has been loaded
242  Dyld.registerEHFrames();
243 
244  // Set page permissions.
245  MemMgr->finalizeMemory();
246 }
247 
248 // FIXME: Rename this.
250  MutexGuard locked(lock);
251 
252  // Generate code for module is going to move objects out of the 'added' list,
253  // so we need to copy that out before using it:
254  SmallVector<Module*, 16> ModsToAdd;
255  for (auto M : OwnedModules.added())
256  ModsToAdd.push_back(M);
257 
258  for (auto M : ModsToAdd)
260 
262 }
263 
265  MutexGuard locked(lock);
266 
267  // This must be a module which has already been added to this MCJIT instance.
268  assert(OwnedModules.ownsModule(M) && "MCJIT::finalizeModule: Unknown module.");
269 
270  // If the module hasn't been compiled, just do that.
271  if (!OwnedModules.hasModuleBeenLoaded(M))
273 
275 }
276 
278  if (void *Addr = getPointerToGlobalIfAvailable(Name))
279  return JITSymbol(static_cast<uint64_t>(
280  reinterpret_cast<uintptr_t>(Addr)),
282 
283  return Dyld.getSymbol(Name);
284 }
285 
287  bool CheckFunctionsOnly) {
288  StringRef DemangledName = Name;
289  if (DemangledName[0] == getDataLayout().getGlobalPrefix())
290  DemangledName = DemangledName.substr(1);
291 
292  MutexGuard locked(lock);
293 
294  // If it hasn't already been generated, see if it's in one of our modules.
295  for (ModulePtrSet::iterator I = OwnedModules.begin_added(),
296  E = OwnedModules.end_added();
297  I != E; ++I) {
298  Module *M = *I;
299  Function *F = M->getFunction(DemangledName);
300  if (F && !F->isDeclaration())
301  return M;
302  if (!CheckFunctionsOnly) {
303  GlobalVariable *G = M->getGlobalVariable(DemangledName);
304  if (G && !G->isDeclaration())
305  return M;
306  // FIXME: Do we need to worry about global aliases?
307  }
308  }
309  // We didn't find the symbol in any of our modules.
310  return nullptr;
311 }
312 
313 uint64_t MCJIT::getSymbolAddress(const std::string &Name,
314  bool CheckFunctionsOnly) {
315  std::string MangledName;
316  {
317  raw_string_ostream MangledNameStream(MangledName);
318  Mangler::getNameWithPrefix(MangledNameStream, Name, getDataLayout());
319  }
320  return findSymbol(MangledName, CheckFunctionsOnly).getAddress();
321 }
322 
323 JITSymbol MCJIT::findSymbol(const std::string &Name,
324  bool CheckFunctionsOnly) {
325  MutexGuard locked(lock);
326 
327  // First, check to see if we already have this symbol.
328  if (auto Sym = findExistingSymbol(Name))
329  return Sym;
330 
331  for (object::OwningBinary<object::Archive> &OB : Archives) {
332  object::Archive *A = OB.getBinary();
333  // Look for our symbols in each Archive
334  auto OptionalChildOrErr = A->findSym(Name);
335  if (!OptionalChildOrErr)
336  report_fatal_error(OptionalChildOrErr.takeError());
337  auto &OptionalChild = *OptionalChildOrErr;
338  if (OptionalChild) {
339  // FIXME: Support nested archives?
341  OptionalChild->getAsBinary();
342  if (!ChildBinOrErr) {
343  // TODO: Actually report errors helpfully.
344  consumeError(ChildBinOrErr.takeError());
345  continue;
346  }
347  std::unique_ptr<object::Binary> &ChildBin = ChildBinOrErr.get();
348  if (ChildBin->isObject()) {
349  std::unique_ptr<object::ObjectFile> OF(
350  static_cast<object::ObjectFile *>(ChildBin.release()));
351  // This causes the object file to be loaded.
352  addObjectFile(std::move(OF));
353  // The address should be here now.
354  if (auto Sym = findExistingSymbol(Name))
355  return Sym;
356  }
357  }
358  }
359 
360  // If it hasn't already been generated, see if it's in one of our modules.
361  Module *M = findModuleForSymbol(Name, CheckFunctionsOnly);
362  if (M) {
364 
365  // Check the RuntimeDyld table again, it should be there now.
366  return findExistingSymbol(Name);
367  }
368 
369  // If a LazyFunctionCreator is installed, use it to get/create the function.
370  // FIXME: Should we instead have a LazySymbolCreator callback?
371  if (LazyFunctionCreator) {
372  auto Addr = static_cast<uint64_t>(
373  reinterpret_cast<uintptr_t>(LazyFunctionCreator(Name)));
374  return JITSymbol(Addr, JITSymbolFlags::Exported);
375  }
376 
377  return nullptr;
378 }
379 
380 uint64_t MCJIT::getGlobalValueAddress(const std::string &Name) {
381  MutexGuard locked(lock);
382  uint64_t Result = getSymbolAddress(Name, false);
383  if (Result != 0)
385  return Result;
386 }
387 
388 uint64_t MCJIT::getFunctionAddress(const std::string &Name) {
389  MutexGuard locked(lock);
390  uint64_t Result = getSymbolAddress(Name, true);
391  if (Result != 0)
393  return Result;
394 }
395 
396 // Deprecated. Use getFunctionAddress instead.
398  MutexGuard locked(lock);
399 
400  Mangler Mang;
402  TM->getNameWithPrefix(Name, F, Mang);
403 
404  if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
405  bool AbortOnFailure = !F->hasExternalWeakLinkage();
406  void *Addr = getPointerToNamedFunction(Name, AbortOnFailure);
407  updateGlobalMapping(F, Addr);
408  return Addr;
409  }
410 
411  Module *M = F->getParent();
412  bool HasBeenAddedButNotLoaded = OwnedModules.hasModuleBeenAddedButNotLoaded(M);
413 
414  // Make sure the relevant module has been compiled and loaded.
415  if (HasBeenAddedButNotLoaded)
417  else if (!OwnedModules.hasModuleBeenLoaded(M)) {
418  // If this function doesn't belong to one of our modules, we're done.
419  // FIXME: Asking for the pointer to a function that hasn't been registered,
420  // and isn't a declaration (which is handled above) should probably
421  // be an assertion.
422  return nullptr;
423  }
424 
425  // FIXME: Should the Dyld be retaining module information? Probably not.
426  //
427  // This is the accessor for the target address, so make sure to check the
428  // load address of the symbol, not the local address.
429  return (void*)Dyld.getSymbol(Name).getAddress();
430 }
431 
432 void MCJIT::runStaticConstructorsDestructorsInModulePtrSet(
433  bool isDtors, ModulePtrSet::iterator I, ModulePtrSet::iterator E) {
434  for (; I != E; ++I) {
436  }
437 }
438 
440  // Execute global ctors/dtors for each module in the program.
441  runStaticConstructorsDestructorsInModulePtrSet(
442  isDtors, OwnedModules.begin_added(), OwnedModules.end_added());
443  runStaticConstructorsDestructorsInModulePtrSet(
444  isDtors, OwnedModules.begin_loaded(), OwnedModules.end_loaded());
445  runStaticConstructorsDestructorsInModulePtrSet(
446  isDtors, OwnedModules.begin_finalized(), OwnedModules.end_finalized());
447 }
448 
449 Function *MCJIT::FindFunctionNamedInModulePtrSet(StringRef FnName,
450  ModulePtrSet::iterator I,
451  ModulePtrSet::iterator E) {
452  for (; I != E; ++I) {
453  Function *F = (*I)->getFunction(FnName);
454  if (F && !F->isDeclaration())
455  return F;
456  }
457  return nullptr;
458 }
459 
460 GlobalVariable *MCJIT::FindGlobalVariableNamedInModulePtrSet(StringRef Name,
461  bool AllowInternal,
462  ModulePtrSet::iterator I,
463  ModulePtrSet::iterator E) {
464  for (; I != E; ++I) {
465  GlobalVariable *GV = (*I)->getGlobalVariable(Name, AllowInternal);
466  if (GV && !GV->isDeclaration())
467  return GV;
468  }
469  return nullptr;
470 }
471 
472 
474  Function *F = FindFunctionNamedInModulePtrSet(
475  FnName, OwnedModules.begin_added(), OwnedModules.end_added());
476  if (!F)
477  F = FindFunctionNamedInModulePtrSet(FnName, OwnedModules.begin_loaded(),
478  OwnedModules.end_loaded());
479  if (!F)
480  F = FindFunctionNamedInModulePtrSet(FnName, OwnedModules.begin_finalized(),
481  OwnedModules.end_finalized());
482  return F;
483 }
484 
486  GlobalVariable *GV = FindGlobalVariableNamedInModulePtrSet(
487  Name, AllowInternal, OwnedModules.begin_added(), OwnedModules.end_added());
488  if (!GV)
489  GV = FindGlobalVariableNamedInModulePtrSet(Name, AllowInternal, OwnedModules.begin_loaded(),
490  OwnedModules.end_loaded());
491  if (!GV)
492  GV = FindGlobalVariableNamedInModulePtrSet(Name, AllowInternal, OwnedModules.begin_finalized(),
493  OwnedModules.end_finalized());
494  return GV;
495 }
496 
498  assert(F && "Function *F was null at entry to run()");
499 
500  void *FPtr = getPointerToFunction(F);
502  assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
503  FunctionType *FTy = F->getFunctionType();
504  Type *RetTy = FTy->getReturnType();
505 
506  assert((FTy->getNumParams() == ArgValues.size() ||
507  (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
508  "Wrong number of arguments passed into function!");
509  assert(FTy->getNumParams() == ArgValues.size() &&
510  "This doesn't support passing arguments through varargs (yet)!");
511 
512  // Handle some common cases first. These cases correspond to common `main'
513  // prototypes.
514  if (RetTy->isIntegerTy(32) || RetTy->isVoidTy()) {
515  switch (ArgValues.size()) {
516  case 3:
517  if (FTy->getParamType(0)->isIntegerTy(32) &&
518  FTy->getParamType(1)->isPointerTy() &&
519  FTy->getParamType(2)->isPointerTy()) {
520  int (*PF)(int, char **, const char **) =
521  (int(*)(int, char **, const char **))(intptr_t)FPtr;
522 
523  // Call the function.
524  GenericValue rv;
525  rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
526  (char **)GVTOP(ArgValues[1]),
527  (const char **)GVTOP(ArgValues[2])));
528  return rv;
529  }
530  break;
531  case 2:
532  if (FTy->getParamType(0)->isIntegerTy(32) &&
533  FTy->getParamType(1)->isPointerTy()) {
534  int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr;
535 
536  // Call the function.
537  GenericValue rv;
538  rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
539  (char **)GVTOP(ArgValues[1])));
540  return rv;
541  }
542  break;
543  case 1:
544  if (FTy->getNumParams() == 1 &&
545  FTy->getParamType(0)->isIntegerTy(32)) {
546  GenericValue rv;
547  int (*PF)(int) = (int(*)(int))(intptr_t)FPtr;
548  rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
549  return rv;
550  }
551  break;
552  }
553  }
554 
555  // Handle cases where no arguments are passed first.
556  if (ArgValues.empty()) {
557  GenericValue rv;
558  switch (RetTy->getTypeID()) {
559  default: llvm_unreachable("Unknown return type for function call!");
560  case Type::IntegerTyID: {
561  unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth();
562  if (BitWidth == 1)
563  rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
564  else if (BitWidth <= 8)
565  rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
566  else if (BitWidth <= 16)
567  rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
568  else if (BitWidth <= 32)
569  rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
570  else if (BitWidth <= 64)
571  rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
572  else
573  llvm_unreachable("Integer types > 64 bits not supported");
574  return rv;
575  }
576  case Type::VoidTyID:
577  rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
578  return rv;
579  case Type::FloatTyID:
580  rv.FloatVal = ((float(*)())(intptr_t)FPtr)();
581  return rv;
582  case Type::DoubleTyID:
583  rv.DoubleVal = ((double(*)())(intptr_t)FPtr)();
584  return rv;
585  case Type::X86_FP80TyID:
586  case Type::FP128TyID:
587  case Type::PPC_FP128TyID:
588  llvm_unreachable("long double not supported yet");
589  case Type::PointerTyID:
590  return PTOGV(((void*(*)())(intptr_t)FPtr)());
591  }
592  }
593 
594  report_fatal_error("MCJIT::runFunction does not support full-featured "
595  "argument passing. Please use "
596  "ExecutionEngine::getFunctionAddress and cast the result "
597  "to the desired function pointer type.");
598 }
599 
600 void *MCJIT::getPointerToNamedFunction(StringRef Name, bool AbortOnFailure) {
601  if (!isSymbolSearchingDisabled()) {
602  void *ptr =
603  reinterpret_cast<void*>(
604  static_cast<uintptr_t>(Resolver.findSymbol(Name).getAddress()));
605  if (ptr)
606  return ptr;
607  }
608 
609  /// If a LazyFunctionCreator is installed, use it to get/create the function.
611  if (void *RP = LazyFunctionCreator(Name))
612  return RP;
613 
614  if (AbortOnFailure) {
615  report_fatal_error("Program used external function '"+Name+
616  "' which could not be resolved!");
617  }
618  return nullptr;
619 }
620 
622  if (!L)
623  return;
624  MutexGuard locked(lock);
625  EventListeners.push_back(L);
626 }
627 
629  if (!L)
630  return;
631  MutexGuard locked(lock);
632  auto I = find(reverse(EventListeners), L);
633  if (I != EventListeners.rend()) {
634  std::swap(*I, EventListeners.back());
635  EventListeners.pop_back();
636  }
637 }
638 
641  MutexGuard locked(lock);
642  MemMgr->notifyObjectLoaded(this, Obj);
643  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
644  EventListeners[I]->NotifyObjectEmitted(Obj, L);
645  }
646 }
647 
649  MutexGuard locked(lock);
650  for (JITEventListener *L : EventListeners)
651  L->NotifyFreeingObject(Obj);
652 }
653 
654 JITSymbol
655 LinkingSymbolResolver::findSymbol(const std::string &Name) {
656  auto Result = ParentEngine.findSymbol(Name, false);
657  if (Result)
658  return Result;
659  if (ParentEngine.isSymbolSearchingDisabled())
660  return nullptr;
661  return ClientResolver->findSymbol(Name);
662 }
MachineLoop * L
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
Function * FindFunctionNamed(StringRef FnName) override
FindFunctionNamed - Search all of the active modules to find the function that defines FnName...
Definition: MCJIT.cpp:473
static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)
Create ObjectFile from path.
Definition: ObjectFile.cpp:116
Information about the loaded object.
Definition: RuntimeDyld.h:67
void setObjectCache(ObjectCache *manager) override
Sets the object manager that MCJIT should use to avoid compilation.
Definition: MCJIT.cpp:141
std::unique_ptr< LoadedObjectInfo > loadObject(const object::ObjectFile &O)
Add the referenced object file to the list of objects to be loaded and relocated. ...
void registerEHFrames()
Register any EH frame sections that have been loaded but not previously registered with the memory ma...
JITTargetAddress getAddress()
Get the address of the symbol in the target address space.
Definition: JITSymbol.h:147
Represents a symbol in the JIT.
Definition: JITSymbol.h:113
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Expected< Optional< Child > > findSym(StringRef name) const
Definition: Archive.cpp:957
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:137
2: 32-bit floating point type
Definition: Type.h:58
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner)
Log all errors (if any) in E to OS.
virtual std::unique_ptr< MemoryBuffer > getObject(const Module *M)=0
Returns a pointer to a newly allocated MemoryBuffer that contains the object which corresponds with M...
void * getPointerToGlobalIfAvailable(StringRef S)
getPointerToGlobalIfAvailable - This returns the address of the specified global value if it is has a...
sys::Mutex lock
lock - This lock protects the ExecutionEngine and MCJIT classes.
static ExecutionEngine * createJIT(std::unique_ptr< Module > M, std::string *ErrorStr, std::shared_ptr< MCJITMemoryManager > MemMgr, std::shared_ptr< JITSymbolResolver > Resolver, std::unique_ptr< TargetMachine > TM)
Definition: MCJIT.cpp:44
uint64_t updateGlobalMapping(const GlobalValue *GV, void *Addr)
updateGlobalMapping - Replace an existing mapping for GV with a new address.
JITEventListener - Abstract interface for use by the JIT to notify clients about significant events d...
StringRef getErrorString()
static JITEventListener * createGDBRegistrationListener()
This class is the base class for all object file types.
Definition: ObjectFile.h:178
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:402
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:490
void generateCodeForModule(Module *M) override
generateCodeForModule - Run code generation for the specified module and load it into memory...
Definition: MCJIT.cpp:183
4: 80-bit floating point type (X87)
Definition: Type.h:60
Error takeError()
Take ownership of the stored error.
15: Pointers
Definition: Type.h:74
void UnregisterJITEventListener(JITEventListener *L) override
Definition: MCJIT.cpp:628
const DataLayout & getDataLayout() const
virtual void runStaticConstructorsDestructors(bool isDtors)
runStaticConstructorsDestructors - This method is used to execute all of the static constructors or d...
static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)
This function permanently loads the dynamic library at the given path.
Tagged union holding either a T or a Error.
void runStaticConstructorsDestructors(bool isDtors) override
runStaticConstructorsDestructors - This method is used to execute all of the static constructors or d...
Definition: MCJIT.cpp:439
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:241
uint64_t getGlobalValueAddress(const std::string &Name) override
getGlobalValueAddress - Return the address of the specified global value.
Definition: MCJIT.cpp:380
Class to represent function types.
Definition: DerivedTypes.h:102
virtual void finalizeModule(Module *)
Definition: MCJIT.cpp:264
#define F(x, y, z)
Definition: MD5.cpp:51
GlobalVariable * FindGlobalVariableNamed(StringRef Name, bool AllowInternal=false) override
FindGlobalVariableNamed - Search all of the active modules to find the global variable that defines N...
Definition: MCJIT.cpp:485
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:136
void * getPointerToFunction(Function *F) override
getPointerToFunction - The different EE's represent function bodies in different ways.
Definition: MCJIT.cpp:397
JITSymbol findSymbol(const std::string &Name) override
This method returns the address of the specified function or variable.
Definition: MCJIT.cpp:655
JITEvaluatedSymbol getSymbol(StringRef Name) const
Get the target address and flags for the named symbol.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:141
JITSymbol findExistingSymbol(const std::string &Name)
Definition: MCJIT.cpp:277
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:196
void finalizeObject() override
finalizeObject - ensure the module is fully processed and is usable.
Definition: MCJIT.cpp:249
11: Arbitrary bit width integers
Definition: Type.h:70
PassManager manages ModulePassManagers.
Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruct...
Definition: MutexGuard.h:27
0: type with no size
Definition: Type.h:56
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:133
void addModule(std::unique_ptr< Module > M) override
Add a Module to the list of modules that we can JIT from.
Definition: MCJIT.cpp:105
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
bool removeModule(Module *M) override
removeModule - Removes a Module from the list of modules, but does not free the module's memory...
Definition: MCJIT.cpp:114
void * getPointerToNamedFunction(StringRef Name, bool AbortOnFailure=true) override
getPointerToNamedFunction - This method returns the address of the specified function by using the dl...
Definition: MCJIT.cpp:600
void LLVMLinkInMCJIT()
Definition: MCJIT.cpp:40
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:587
uint64_t getFunctionAddress(const std::string &Name) override
getFunctionAddress - Return the address of the specified function.
Definition: MCJIT.cpp:388
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:62
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:136
JITSymbol findSymbol(const std::string &Name, bool CheckFunctionsOnly)
Definition: MCJIT.cpp:323
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
void consumeError(Error Err)
Consume a Error without doing anything.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
virtual void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj)=0
notifyObjectCompiled - Provides a pointer to compiled code for Module M.
void * GVTOP(const GenericValue &GV)
Definition: GenericValue.h:51
std::pair< std::unique_ptr< T >, std::unique_ptr< MemoryBuffer > > takeBinary()
Definition: Binary.h:180
void addArchive(object::OwningBinary< object::Archive > O) override
addArchive - Add an Archive to the execution engine.
Definition: MCJIT.cpp:137
SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
Definition: SmallPtrSet.h:275
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:416
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:757
Module.h This file contains the declarations for the Module class.
const DataFlowGraph & G
Definition: RDFGraph.cpp:206
reference get()
Returns a reference to the stored T value.
uint64_t getSymbolAddress(const std::string &Name, bool CheckFunctionsOnly)
Definition: MCJIT.cpp:313
void RegisterJITEventListener(JITEventListener *L) override
Registers a listener to be called back on various events within the JIT.
Definition: MCJIT.cpp:621
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:586
GenericValue PTOGV(void *P)
Definition: GenericValue.h:50
Class for arbitrary precision integers.
Definition: APInt.h:77
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
Module * findModuleForSymbol(const std::string &Name, bool CheckFunctionsOnly)
Definition: MCJIT.cpp:286
GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues) override
runFunction - Execute the specified function with the specified arguments, and return the result...
Definition: MCJIT.cpp:497
std::unique_ptr< MemoryBuffer > emitObject(Module *M)
emitObject – Generate a JITed object in memory from the specified module Currently, MCJIT only supports a single module and the module passed to this function call is expected to be the contained module.
Definition: MCJIT.cpp:146
SmallVector< std::unique_ptr< Module >, 1 > Modules
The list of Modules that we are JIT'ing from.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
JITTargetAddress getAddress() const
Return the address of this symbol.
Definition: JITSymbol.h:102
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:108
#define I(x, y, z)
Definition: MD5.cpp:54
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.cpp:230
SmallVector-backed MemoryBuffer instance.
This is the base ObjectCache type which can be provided to an ExecutionEngine for the purpose of avoi...
Definition: ObjectCache.h:23
void resolveRelocations()
Resolve the relocations for all symbols we currently know about.
bool isVarArg() const
Definition: DerivedTypes.h:122
3: 64-bit floating point type
Definition: Type.h:59
~MCJIT() override
Definition: MCJIT.cpp:93
Type * getReturnType() const
Definition: DerivedTypes.h:123
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
FunctionCreator LazyFunctionCreator
LazyFunctionCreator - If an unknown function is needed, this function pointer is invoked to create it...
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:463
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
void NotifyFreeingObject(const object::ObjectFile &Obj)
Definition: MCJIT.cpp:648
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
void NotifyObjectEmitted(const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &L)
Definition: MCJIT.cpp:639
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
void finalizeLoadedModules()
Definition: MCJIT.cpp:233
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:344
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:61
void addObjectFile(std::unique_ptr< object::ObjectFile > O) override
addObjectFile - Add an ObjectFile to the execution engine.
Definition: MCJIT.cpp:119