LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/Orc - ExecutionUtils.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 79 95 83.2 %
Date: 2018-07-13 00:08:38 Functions: 18 19 94.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
       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 "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
      11             : 
      12             : #include "llvm/IR/Constants.h"
      13             : #include "llvm/IR/Function.h"
      14             : #include "llvm/IR/GlobalVariable.h"
      15             : #include "llvm/IR/Module.h"
      16             : #include "llvm/Support/TargetRegistry.h"
      17             : #include "llvm/Target/TargetMachine.h"
      18             : 
      19             : namespace llvm {
      20             : namespace orc {
      21             : 
      22           7 : JITTargetMachineBuilder::JITTargetMachineBuilder(Triple TT)
      23          21 :     : TT(std::move(TT)) {}
      24             : 
      25           7 : Expected<JITTargetMachineBuilder> JITTargetMachineBuilder::detectHost() {
      26          35 :   return JITTargetMachineBuilder(Triple(sys::getProcessTriple()));
      27             : }
      28             : 
      29             : Expected<std::unique_ptr<TargetMachine>>
      30           7 : JITTargetMachineBuilder::createTargetMachine() {
      31           7 :   if (!Arch.empty()) {
      32           0 :     Triple::ArchType Type = Triple::getArchTypeForLLVMName(Arch);
      33             : 
      34           0 :     if (Type == Triple::UnknownArch)
      35           0 :       return make_error<StringError>(std::string("Unknown arch: ") + Arch,
      36           0 :                                      inconvertibleErrorCode());
      37             :   }
      38             : 
      39             :   std::string ErrMsg;
      40           7 :   auto *TheTarget = TargetRegistry::lookupTarget(TT.getTriple(), ErrMsg);
      41           7 :   if (!TheTarget)
      42           0 :     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
      43             : 
      44             :   auto *TM =
      45          28 :       TheTarget->createTargetMachine(TT.getTriple(), CPU, Features.getString(),
      46           7 :                                      Options, RM, CM, OptLevel, /*JIT*/ true);
      47           7 :   if (!TM)
      48             :     return make_error<StringError>("Could not allocate target machine",
      49           0 :                                    inconvertibleErrorCode());
      50             : 
      51             :   return std::unique_ptr<TargetMachine>(TM);
      52             : }
      53             : 
      54           7 : JITTargetMachineBuilder &JITTargetMachineBuilder::addFeatures(
      55             :     const std::vector<std::string> &FeatureVec) {
      56           7 :   for (const auto &F : FeatureVec)
      57           0 :     Features.AddFeature(F);
      58           7 :   return *this;
      59             : }
      60             : 
      61         404 : CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
      62             :   : InitList(
      63         404 :       GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
      64         407 :     I((InitList && End) ? InitList->getNumOperands() : 0) {
      65         404 : }
      66             : 
      67         206 : bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
      68             :   assert(InitList == Other.InitList && "Incomparable iterators.");
      69         206 :   return I == Other.I;
      70             : }
      71             : 
      72         190 : bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
      73         190 :   return !(*this == Other);
      74             : }
      75             : 
      76           3 : CtorDtorIterator& CtorDtorIterator::operator++() {
      77           3 :   ++I;
      78           3 :   return *this;
      79             : }
      80             : 
      81           0 : CtorDtorIterator CtorDtorIterator::operator++(int) {
      82           0 :   CtorDtorIterator Temp = *this;
      83           0 :   ++I;
      84           0 :   return Temp;
      85             : }
      86             : 
      87           4 : CtorDtorIterator::Element CtorDtorIterator::operator*() const {
      88           4 :   ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
      89             :   assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
      90             : 
      91           4 :   Constant *FuncC = CS->getOperand(1);
      92             :   Function *Func = nullptr;
      93             : 
      94             :   // Extract function pointer, pulling off any casts.
      95           4 :   while (FuncC) {
      96             :     if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
      97             :       Func = F;
      98             :       break;
      99             :     } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
     100           0 :       if (CE->isCast())
     101             :         FuncC = dyn_cast_or_null<ConstantExpr>(CE->getOperand(0));
     102             :       else
     103             :         break;
     104             :     } else {
     105             :       // This isn't anything we recognize. Bail out with Func left set to null.
     106             :       break;
     107             :     }
     108             :   }
     109             : 
     110             :   ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
     111           4 :   Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
     112             :   if (Data && !isa<GlobalValue>(Data))
     113             :     Data = nullptr;
     114           8 :   return Element(Priority->getZExtValue(), Func, Data);
     115             : }
     116             : 
     117         101 : iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
     118             :   const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
     119             :   return make_range(CtorDtorIterator(CtorsList, false),
     120         202 :                     CtorDtorIterator(CtorsList, true));
     121             : }
     122             : 
     123         101 : iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
     124             :   const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
     125             :   return make_range(CtorDtorIterator(DtorsList, false),
     126         202 :                     CtorDtorIterator(DtorsList, true));
     127             : }
     128             : 
     129          16 : void CtorDtorRunner2::add(iterator_range<CtorDtorIterator> CtorDtors) {
     130          16 :   if (CtorDtors.begin() == CtorDtors.end())
     131          15 :     return;
     132             : 
     133             :   MangleAndInterner Mangle(
     134           1 :       V.getExecutionSession(),
     135           2 :       (*CtorDtors.begin()).Func->getParent()->getDataLayout());
     136             : 
     137           2 :   for (const auto &CtorDtor : CtorDtors) {
     138             :     assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
     139             :            "Ctor/Dtor function must be named to be runnable under the JIT");
     140             : 
     141           1 :     if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
     142           0 :       dbgs() << "  Skipping because why now?\n";
     143           0 :       continue;
     144             :     }
     145             : 
     146           1 :     CtorDtorsByPriority[CtorDtor.Priority].push_back(
     147           2 :         Mangle(CtorDtor.Func->getName()));
     148             :   }
     149             : }
     150             : 
     151          14 : Error CtorDtorRunner2::run() {
     152             :   using CtorDtorTy = void (*)();
     153             : 
     154             :   SymbolNameSet Names;
     155             : 
     156          15 :   for (auto &KV : CtorDtorsByPriority) {
     157           2 :     for (auto &Name : KV.second) {
     158             :       auto Added = Names.insert(Name).second;
     159             :       (void)Added;
     160             :       assert(Added && "Ctor/Dtor names clashed");
     161             :     }
     162             :   }
     163             : 
     164          84 :   if (auto CtorDtorMap = lookup({&V}, std::move(Names))) {
     165          15 :     for (auto &KV : CtorDtorsByPriority) {
     166           2 :       for (auto &Name : KV.second) {
     167             :         assert(CtorDtorMap->count(Name) && "No entry for Name");
     168             :         auto CtorDtor = reinterpret_cast<CtorDtorTy>(
     169           1 :             static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
     170           1 :         CtorDtor();
     171             :       }
     172             :     }
     173             :     return Error::success();
     174             :   } else
     175             :     return CtorDtorMap.takeError();
     176             : 
     177             :   CtorDtorsByPriority.clear();
     178             : 
     179             :   return Error::success();
     180             : }
     181             : 
     182          11 : void LocalCXXRuntimeOverridesBase::runDestructors() {
     183             :   auto& CXXDestructorDataPairs = DSOHandleOverride;
     184          12 :   for (auto &P : CXXDestructorDataPairs)
     185           1 :     P.first(P.second);
     186             :   CXXDestructorDataPairs.clear();
     187          11 : }
     188             : 
     189           1 : int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
     190             :                                                     void *Arg,
     191             :                                                     void *DSOHandle) {
     192             :   auto& CXXDestructorDataPairs =
     193             :     *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
     194           2 :   CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
     195           1 :   return 0;
     196             : }
     197             : 
     198           7 : Error LocalCXXRuntimeOverrides2::enable(VSO &V, MangleAndInterner &Mangle) {
     199             :   SymbolMap RuntimeInterposes(
     200          14 :       {{Mangle("__dso_handle"),
     201           7 :         JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
     202             :                            JITSymbolFlags::Exported)},
     203          14 :        {Mangle("__cxa_atexit"),
     204             :         JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
     205          21 :                            JITSymbolFlags::Exported)}});
     206             : 
     207          28 :   return V.define(absoluteSymbols(std::move(RuntimeInterposes)));
     208             : }
     209             : 
     210           7 : DynamicLibraryFallbackGenerator::DynamicLibraryFallbackGenerator(
     211           7 :     sys::DynamicLibrary Dylib, const DataLayout &DL, SymbolPredicate Allow)
     212             :     : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
     213          21 :       GlobalPrefix(DL.getGlobalPrefix()) {}
     214             : 
     215           2 : SymbolNameSet DynamicLibraryFallbackGenerator::
     216             : operator()(VSO &V, const SymbolNameSet &Names) {
     217             :   orc::SymbolNameSet Added;
     218             :   orc::SymbolMap NewSymbols;
     219             : 
     220           2 :   bool HasGlobalPrefix = (GlobalPrefix != '\0');
     221             : 
     222           4 :   for (auto &Name : Names) {
     223           6 :     if (!Allow(Name) || (*Name).empty())
     224           0 :       continue;
     225             : 
     226           2 :     if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
     227           0 :       continue;
     228             : 
     229           2 :     std::string Tmp((*Name).data() + (HasGlobalPrefix ? 1 : 0), (*Name).size());
     230           4 :     if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
     231             :       Added.insert(Name);
     232           2 :       NewSymbols[Name] = JITEvaluatedSymbol(
     233             :           static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
     234             :           JITSymbolFlags::Exported);
     235             :     }
     236             :   }
     237             : 
     238             :   // Add any new symbols to V. Since the fallback generator is only called for
     239             :   // symbols that are not already defined, this will never trigger a duplicate
     240             :   // definition error, so we can wrap this call in a 'cantFail'.
     241           2 :   if (!NewSymbols.empty())
     242           8 :     cantFail(V.define(absoluteSymbols(std::move(NewSymbols))));
     243             : 
     244           2 :   return Added;
     245             : }
     246             : 
     247             : } // End namespace orc.
     248             : } // End namespace llvm.

Generated by: LCOV version 1.13