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