unittests/ExecutionEngine/Orc/OrcTestCommon.h

   1 //===------ OrcTestCommon.h - Utilities for Orc Unit Tests ------*- 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 // Common utilities for the Orc unit tests.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14
  15 #ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
  16 #define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
  17
  18 #include "llvm/IR/Function.h"
  19 #include "llvm/IR/IRBuilder.h"
  20 #include "llvm/IR/LLVMContext.h"
  21 #include "llvm/IR/Module.h"
  22 #include "llvm/IR/TypeBuilder.h"
  23 #include "llvm/ExecutionEngine/ExecutionEngine.h"
  24 #include "llvm/ExecutionEngine/Orc/JITSymbol.h"
  25 #include "llvm/Support/TargetSelect.h"
  26 #include <memory>
  27
  28 namespace llvm {
  29
  30 // Base class for Orc tests that will execute code.
  31 class OrcExecutionTest {
  32 public:
  33
  34   OrcExecutionTest() {
  35     if (!NativeTargetInitialized) {
  36       InitializeNativeTarget();
  37       InitializeNativeTargetAsmParser();
  38       InitializeNativeTargetAsmPrinter();
  39       NativeTargetInitialized = true;
  40     }
  41   };
  42
  43   // Get a target machine for the host if it supports JIT execution.
  44   std::unique_ptr<TargetMachine> getHostTargetMachineIfSupported() {
  45     std::unique_ptr<TargetMachine> TM(EngineBuilder().selectTarget());
  46
  47     const Triple& TT = TM->getTargetTriple();
  48
  49     if (TT.getArch() == Triple::x86_64)
  50       return std::move(TM);
  51
  52     return nullptr;
  53   }
  54
  55 private:
  56   static bool NativeTargetInitialized;
  57 };
  58
  59 class ModuleBuilder {
  60 public:
  61   ModuleBuilder(LLVMContext &Context, StringRef Triple,
  62                 StringRef Name);
  63
  64   template <typename FuncType>
  65   Function* createFunctionDecl(StringRef Name) {
  66     return Function::Create(
  67              TypeBuilder<FuncType, false>::get(M->getContext()),
  68              GlobalValue::ExternalLinkage, Name, M.get());
  69   }
  70
  71   Module* getModule() { return M.get(); }
  72   const Module* getModule() const { return M.get(); }
  73   std::unique_ptr<Module> takeModule() { return std::move(M); }
  74
  75 private:
  76   std::unique_ptr<Module> M;
  77   IRBuilder<> Builder;
  78 };
  79
  80 // Dummy struct type.
  81 struct DummyStruct {
  82   int X[256];
  83 };
  84
  85 // TypeBuilder specialization for DummyStruct.
  86 template <bool XCompile>
  87 class TypeBuilder<DummyStruct, XCompile> {
  88 public:
  89   static StructType *get(LLVMContext &Context) {
  90     return StructType::get(
  91       TypeBuilder<types::i<32>[256], XCompile>::get(Context), nullptr);
  92   }
  93 };
  94
  95 template <typename HandleT,
  96           typename AddModuleSetFtor,
  97           typename RemoveModuleSetFtor,
  98           typename FindSymbolFtor,
  99           typename FindSymbolInFtor>
 100 class MockBaseLayer {
 101 public:
 102
 103   typedef HandleT ModuleSetHandleT;
 104
 105   MockBaseLayer(AddModuleSetFtor &&AddModuleSet,
 106                 RemoveModuleSetFtor &&RemoveModuleSet,
 107                 FindSymbolFtor &&FindSymbol,
 108                 FindSymbolInFtor &&FindSymbolIn)
 109       : AddModuleSet(AddModuleSet), RemoveModuleSet(RemoveModuleSet),
 110         FindSymbol(FindSymbol), FindSymbolIn(FindSymbolIn)
 111   {}
 112
 113   template <typename ModuleSetT, typename MemoryManagerPtrT,
 114             typename SymbolResolverPtrT>
 115   ModuleSetHandleT addModuleSet(ModuleSetT Ms, MemoryManagerPtrT MemMgr,
 116                                 SymbolResolverPtrT Resolver) {
 117     return AddModuleSet(std::move(Ms), std::move(MemMgr), std::move(Resolver));
 118   }
 119
 120   void removeModuleSet(ModuleSetHandleT H) {
 121     RemoveModuleSet(H);
 122   }
 123
 124   orc::JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
 125     return FindSymbol(Name, ExportedSymbolsOnly);
 126   }
 127
 128   orc::JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string &Name,
 129                          bool ExportedSymbolsOnly) {
 130     return FindSymbolIn(H, Name, ExportedSymbolsOnly);
 131   }
 132
 133 private:
 134   AddModuleSetFtor AddModuleSet;
 135   RemoveModuleSetFtor RemoveModuleSet;
 136   FindSymbolFtor FindSymbol;
 137   FindSymbolInFtor FindSymbolIn;
 138 };
 139
 140 template <typename ModuleSetHandleT,
 141           typename AddModuleSetFtor,
 142           typename RemoveModuleSetFtor,
 143           typename FindSymbolFtor,
 144           typename FindSymbolInFtor>
 145 MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor, RemoveModuleSetFtor,
 146               FindSymbolFtor, FindSymbolInFtor>
 147 createMockBaseLayer(AddModuleSetFtor &&AddModuleSet,
 148                     RemoveModuleSetFtor &&RemoveModuleSet,
 149                     FindSymbolFtor &&FindSymbol,
 150                     FindSymbolInFtor &&FindSymbolIn) {
 151   return MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor, RemoveModuleSetFtor,
 152                        FindSymbolFtor, FindSymbolInFtor>(
 153                          std::forward<AddModuleSetFtor>(AddModuleSet),
 154                          std::forward<RemoveModuleSetFtor>(RemoveModuleSet),
 155                          std::forward<FindSymbolFtor>(FindSymbol),
 156                          std::forward<FindSymbolInFtor>(FindSymbolIn));
 157 }
 158
 159 template <typename ReturnT>
 160 class DoNothingAndReturn {
 161 public:
 162   DoNothingAndReturn(ReturnT Val) : Val(Val) {}
 163
 164   template <typename... Args>
 165   ReturnT operator()(Args...) const { return Val; }
 166 private:
 167   ReturnT Val;
 168 };
 169
 170 template <>
 171 class DoNothingAndReturn<void> {
 172 public:
 173   template <typename... Args>
 174   void operator()(Args...) const { }
 175 };
 176
 177 } // namespace llvm
 178
 179 #endif