LCOV - code coverage report
Current view: top level - include/llvm/ExecutionEngine/Orc - ExecutionUtils.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 29 31 93.5 %
Date: 2018-07-13 00:08:38 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ExecutionUtils.h - Utilities for executing code in Orc ---*- C++ -*-===//
       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             : // Contains utilities for executing code in Orc.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
      15             : #define LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
      16             : 
      17             : #include "llvm/ADT/StringMap.h"
      18             : #include "llvm/ADT/iterator_range.h"
      19             : #include "llvm/ExecutionEngine/JITSymbol.h"
      20             : #include "llvm/ExecutionEngine/Orc/Core.h"
      21             : #include "llvm/ExecutionEngine/Orc/OrcError.h"
      22             : #include "llvm/ExecutionEngine/RuntimeDyld.h"
      23             : #include "llvm/Support/DynamicLibrary.h"
      24             : #include "llvm/Target/TargetOptions.h"
      25             : #include <algorithm>
      26             : #include <cstdint>
      27             : #include <string>
      28             : #include <utility>
      29             : #include <vector>
      30             : 
      31             : namespace llvm {
      32             : 
      33             : class ConstantArray;
      34             : class GlobalVariable;
      35             : class Function;
      36             : class Module;
      37             : class TargetMachine;
      38             : class Value;
      39             : 
      40             : namespace orc {
      41             : 
      42             : /// A utility class for building TargetMachines for JITs.
      43          84 : class JITTargetMachineBuilder {
      44             : public:
      45             :   JITTargetMachineBuilder(Triple TT);
      46             :   static Expected<JITTargetMachineBuilder> detectHost();
      47             :   Expected<std::unique_ptr<TargetMachine>> createTargetMachine();
      48             : 
      49             :   JITTargetMachineBuilder &setArch(std::string Arch) {
      50           7 :     this->Arch = std::move(Arch);
      51             :     return *this;
      52             :   }
      53             :   JITTargetMachineBuilder &setCPU(std::string CPU) {
      54           7 :     this->CPU = std::move(CPU);
      55             :     return *this;
      56             :   }
      57             :   JITTargetMachineBuilder &setRelocationModel(Optional<Reloc::Model> RM) {
      58             :     this->RM = std::move(RM);
      59             :     return *this;
      60             :   }
      61             :   JITTargetMachineBuilder &setCodeModel(Optional<CodeModel::Model> CM) {
      62             :     this->CM = std::move(CM);
      63             :     return *this;
      64             :   }
      65             :   JITTargetMachineBuilder &
      66             :   addFeatures(const std::vector<std::string> &FeatureVec);
      67             :   SubtargetFeatures &getFeatures() { return Features; }
      68             :   TargetOptions &getOptions() { return Options; }
      69             : 
      70             : private:
      71             :   Triple TT;
      72             :   std::string Arch;
      73             :   std::string CPU;
      74             :   SubtargetFeatures Features;
      75             :   TargetOptions Options;
      76             :   Optional<Reloc::Model> RM;
      77             :   Optional<CodeModel::Model> CM;
      78             :   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
      79             : };
      80             : 
      81             : /// This iterator provides a convenient way to iterate over the elements
      82             : ///        of an llvm.global_ctors/llvm.global_dtors instance.
      83             : ///
      84             : ///   The easiest way to get hold of instances of this class is to use the
      85             : /// getConstructors/getDestructors functions.
      86             : class CtorDtorIterator {
      87             : public:
      88             :   /// Accessor for an element of the global_ctors/global_dtors array.
      89             :   ///
      90             :   ///   This class provides a read-only view of the element with any casts on
      91             :   /// the function stripped away.
      92             :   struct Element {
      93             :     Element(unsigned Priority, Function *Func, Value *Data)
      94           4 :       : Priority(Priority), Func(Func), Data(Data) {}
      95             : 
      96             :     unsigned Priority;
      97             :     Function *Func;
      98             :     Value *Data;
      99             :   };
     100             : 
     101             :   /// Construct an iterator instance. If End is true then this iterator
     102             :   ///        acts as the end of the range, otherwise it is the beginning.
     103             :   CtorDtorIterator(const GlobalVariable *GV, bool End);
     104             : 
     105             :   /// Test iterators for equality.
     106             :   bool operator==(const CtorDtorIterator &Other) const;
     107             : 
     108             :   /// Test iterators for inequality.
     109             :   bool operator!=(const CtorDtorIterator &Other) const;
     110             : 
     111             :   /// Pre-increment iterator.
     112             :   CtorDtorIterator& operator++();
     113             : 
     114             :   /// Post-increment iterator.
     115             :   CtorDtorIterator operator++(int);
     116             : 
     117             :   /// Dereference iterator. The resulting value provides a read-only view
     118             :   ///        of this element of the global_ctors/global_dtors list.
     119             :   Element operator*() const;
     120             : 
     121             : private:
     122             :   const ConstantArray *InitList;
     123             :   unsigned I;
     124             : };
     125             : 
     126             : /// Create an iterator range over the entries of the llvm.global_ctors
     127             : ///        array.
     128             : iterator_range<CtorDtorIterator> getConstructors(const Module &M);
     129             : 
     130             : /// Create an iterator range over the entries of the llvm.global_ctors
     131             : ///        array.
     132             : iterator_range<CtorDtorIterator> getDestructors(const Module &M);
     133             : 
     134             : /// Convenience class for recording constructor/destructor names for
     135             : ///        later execution.
     136             : template <typename JITLayerT>
     137         155 : class CtorDtorRunner {
     138             : public:
     139             :   /// Construct a CtorDtorRunner for the given range using the given
     140             :   ///        name mangling function.
     141         155 :   CtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
     142         155 :       : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
     143             : 
     144             :   /// Run the recorded constructors/destructors through the given JIT
     145             :   ///        layer.
     146         155 :   Error runViaLayer(JITLayerT &JITLayer) const {
     147             :     using CtorDtorTy = void (*)();
     148             : 
     149         155 :     for (const auto &CtorDtorName : CtorDtorNames) {
     150           4 :       if (auto CtorDtorSym = JITLayer.findSymbolIn(K, CtorDtorName, false)) {
     151           4 :         if (auto AddrOrErr = CtorDtorSym.getAddress()) {
     152           2 :           CtorDtorTy CtorDtor =
     153             :             reinterpret_cast<CtorDtorTy>(static_cast<uintptr_t>(*AddrOrErr));
     154           2 :           CtorDtor();
     155             :         } else
     156             :           return AddrOrErr.takeError();
     157             :       } else {
     158           0 :         if (auto Err = CtorDtorSym.takeError())
     159             :           return Err;
     160             :         else
     161             :           return make_error<JITSymbolNotFound>(CtorDtorName);
     162             :       }
     163             :     }
     164             :     return Error::success();
     165             :   }
     166             : 
     167             : private:
     168             :   std::vector<std::string> CtorDtorNames;
     169             :   orc::VModuleKey K;
     170             : };
     171             : 
     172          14 : class CtorDtorRunner2 {
     173             : public:
     174          14 :   CtorDtorRunner2(VSO &V) : V(V) {}
     175             :   void add(iterator_range<CtorDtorIterator> CtorDtors);
     176             :   Error run();
     177             : 
     178             : private:
     179             :   using CtorDtorList = std::vector<SymbolStringPtr>;
     180             :   using CtorDtorPriorityMap = std::map<unsigned, CtorDtorList>;
     181             : 
     182             :   VSO &V;
     183             :   CtorDtorPriorityMap CtorDtorsByPriority;
     184             : };
     185             : 
     186             : /// Support class for static dtor execution. For hosted (in-process) JITs
     187             : ///        only!
     188             : ///
     189             : ///   If a __cxa_atexit function isn't found C++ programs that use static
     190             : /// destructors will fail to link. However, we don't want to use the host
     191             : /// process's __cxa_atexit, because it will schedule JIT'd destructors to run
     192             : /// after the JIT has been torn down, which is no good. This class makes it easy
     193             : /// to override __cxa_atexit (and the related __dso_handle).
     194             : ///
     195             : ///   To use, clients should manually call searchOverrides from their symbol
     196             : /// resolver. This should generally be done after attempting symbol resolution
     197             : /// inside the JIT, but before searching the host process's symbol table. When
     198             : /// the client determines that destructors should be run (generally at JIT
     199             : /// teardown or after a return from main), the runDestructors method should be
     200             : /// called.
     201             : class LocalCXXRuntimeOverridesBase {
     202             : public:
     203             :   /// Run any destructors recorded by the overriden __cxa_atexit function
     204             :   /// (CXAAtExitOverride).
     205             :   void runDestructors();
     206             : 
     207             : protected:
     208             :   template <typename PtrTy> JITTargetAddress toTargetAddress(PtrTy *P) {
     209          22 :     return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(P));
     210             :   }
     211             : 
     212             :   using DestructorPtr = void (*)(void *);
     213             :   using CXXDestructorDataPair = std::pair<DestructorPtr, void *>;
     214             :   using CXXDestructorDataPairList = std::vector<CXXDestructorDataPair>;
     215             :   CXXDestructorDataPairList DSOHandleOverride;
     216             :   static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg,
     217             :                                void *DSOHandle);
     218             : };
     219             : 
     220           8 : class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
     221             : public:
     222             :   /// Create a runtime-overrides class.
     223             :   template <typename MangleFtorT>
     224           4 :   LocalCXXRuntimeOverrides(const MangleFtorT &Mangle) {
     225          20 :     addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride));
     226          16 :     addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride));
     227           4 :   }
     228             : 
     229             :   /// Search overrided symbols.
     230           4 :   JITEvaluatedSymbol searchOverrides(const std::string &Name) {
     231           8 :     auto I = CXXRuntimeOverrides.find(Name);
     232           8 :     if (I != CXXRuntimeOverrides.end())
     233           0 :       return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);
     234             :     return nullptr;
     235             :   }
     236             : 
     237             : private:
     238           8 :   void addOverride(const std::string &Name, JITTargetAddress Addr) {
     239          16 :     CXXRuntimeOverrides.insert(std::make_pair(Name, Addr));
     240           8 :   }
     241             : 
     242             :   StringMap<JITTargetAddress> CXXRuntimeOverrides;
     243             : };
     244             : 
     245           7 : class LocalCXXRuntimeOverrides2 : public LocalCXXRuntimeOverridesBase {
     246             : public:
     247             :   Error enable(VSO &V, MangleAndInterner &Mangler);
     248             : };
     249             : 
     250             : /// A utility class to expose symbols found via dlsym to the JIT.
     251             : ///
     252             : /// If an instance of this class is attached to a VSO as a fallback definition
     253             : /// generator, then any symbol found in the given DynamicLibrary that passes
     254             : /// the 'Allow' predicate will be added to the VSO.
     255          21 : class DynamicLibraryFallbackGenerator {
     256             : public:
     257             :   using SymbolPredicate = std::function<bool(SymbolStringPtr)>;
     258             :   DynamicLibraryFallbackGenerator(sys::DynamicLibrary Dylib,
     259             :                                   const DataLayout &DL, SymbolPredicate Allow);
     260             :   SymbolNameSet operator()(VSO &V, const SymbolNameSet &Names);
     261             : 
     262             : private:
     263             :   sys::DynamicLibrary Dylib;
     264             :   SymbolPredicate Allow;
     265             :   char GlobalPrefix;
     266             : };
     267             : 
     268             : } // end namespace orc
     269             : } // end namespace llvm
     270             : 
     271             : #endif // LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H

Generated by: LCOV version 1.13