llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h

   1 //===------ OrcTestCommon.h - Utilities for Orc Unit Tests ------*- C++ -*-===//
   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 // Common utilities for the Orc unit tests.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13
  14 #ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
  15 #define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
  16
  17 #include "llvm/ExecutionEngine/JITSymbol.h"
  18 #include "llvm/ExecutionEngine/Orc/Core.h"
  19 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
  20 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
  21 #include "llvm/IR/Function.h"
  22 #include "llvm/IR/IRBuilder.h"
  23 #include "llvm/IR/LLVMContext.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/Object/ObjectFile.h"
  26 #include "llvm/Support/TargetRegistry.h"
  27 #include "llvm/Support/TargetSelect.h"
  28 #include "gtest/gtest.h"
  29
  30 #include <memory>
  31
  32 namespace llvm {
  33
  34 namespace orc {
  35 // CoreAPIsStandardTest that saves a bunch of boilerplate by providing the
  36 // following:
  37 //
  38 // (1) ES -- An ExecutionSession
  39 // (2) Foo, Bar, Baz, Qux -- SymbolStringPtrs for strings "foo", "bar", "baz",
  40 //     and "qux" respectively.
  41 // (3) FooAddr, BarAddr, BazAddr, QuxAddr -- Dummy addresses. Guaranteed
  42 //     distinct and non-null.
  43 // (4) FooSym, BarSym, BazSym, QuxSym -- JITEvaluatedSymbols with FooAddr,
  44 //     BarAddr, BazAddr, and QuxAddr respectively. All with default strong,
  45 //     linkage and non-hidden visibility.
  46 // (5) V -- A JITDylib associated with ES.
  47 class CoreAPIsBasedStandardTest : public testing::Test {
  48 public:
  49   ~CoreAPIsBasedStandardTest() {
  50     if (auto Err = ES.endSession())
  51       ES.reportError(std::move(Err));
  52   }
  53
  54 protected:
  55   std::shared_ptr<SymbolStringPool> SSP = std::make_shared<SymbolStringPool>();
  56   ExecutionSession ES{std::make_unique<UnsupportedExecutorProcessControl>(SSP)};
  57   JITDylib &JD = ES.createBareJITDylib("JD");
  58   SymbolStringPtr Foo = ES.intern("foo");
  59   SymbolStringPtr Bar = ES.intern("bar");
  60   SymbolStringPtr Baz = ES.intern("baz");
  61   SymbolStringPtr Qux = ES.intern("qux");
  62   static const JITTargetAddress FooAddr = 1U;
  63   static const JITTargetAddress BarAddr = 2U;
  64   static const JITTargetAddress BazAddr = 3U;
  65   static const JITTargetAddress QuxAddr = 4U;
  66   JITEvaluatedSymbol FooSym =
  67       JITEvaluatedSymbol(FooAddr, JITSymbolFlags::Exported);
  68   JITEvaluatedSymbol BarSym =
  69       JITEvaluatedSymbol(BarAddr, JITSymbolFlags::Exported);
  70   JITEvaluatedSymbol BazSym =
  71       JITEvaluatedSymbol(BazAddr, JITSymbolFlags::Exported);
  72   JITEvaluatedSymbol QuxSym =
  73       JITEvaluatedSymbol(QuxAddr, JITSymbolFlags::Exported);
  74 };
  75
  76 } // end namespace orc
  77
  78 class OrcNativeTarget {
  79 public:
  80   static void initialize() {
  81     if (!NativeTargetInitialized) {
  82       InitializeNativeTarget();
  83       InitializeNativeTargetAsmParser();
  84       InitializeNativeTargetAsmPrinter();
  85       NativeTargetInitialized = true;
  86     }
  87   }
  88
  89 private:
  90   static bool NativeTargetInitialized;
  91 };
  92
  93 class SimpleMaterializationUnit : public orc::MaterializationUnit {
  94 public:
  95   using MaterializeFunction =
  96       std::function<void(std::unique_ptr<orc::MaterializationResponsibility>)>;
  97   using DiscardFunction =
  98       std::function<void(const orc::JITDylib &, orc::SymbolStringPtr)>;
  99   using DestructorFunction = std::function<void()>;
 100
 101   SimpleMaterializationUnit(
 102       orc::SymbolFlagsMap SymbolFlags, MaterializeFunction Materialize,
 103       orc::SymbolStringPtr InitSym = nullptr,
 104       DiscardFunction Discard = DiscardFunction(),
 105       DestructorFunction Destructor = DestructorFunction())
 106       : MaterializationUnit(std::move(SymbolFlags), std::move(InitSym)),
 107         Materialize(std::move(Materialize)), Discard(std::move(Discard)),
 108         Destructor(std::move(Destructor)) {}
 109
 110   ~SimpleMaterializationUnit() override {
 111     if (Destructor)
 112       Destructor();
 113   }
 114
 115   StringRef getName() const override { return "<Simple>"; }
 116
 117   void
 118   materialize(std::unique_ptr<orc::MaterializationResponsibility> R) override {
 119     Materialize(std::move(R));
 120   }
 121
 122   void discard(const orc::JITDylib &JD,
 123                const orc::SymbolStringPtr &Name) override {
 124     if (Discard)
 125       Discard(JD, std::move(Name));
 126     else
 127       llvm_unreachable("Discard not supported");
 128   }
 129
 130 private:
 131   MaterializeFunction Materialize;
 132   DiscardFunction Discard;
 133   DestructorFunction Destructor;
 134 };
 135
 136 class ModuleBuilder {
 137 public:
 138   ModuleBuilder(LLVMContext &Context, StringRef Triple,
 139                 StringRef Name);
 140
 141   Function *createFunctionDecl(FunctionType *FTy, StringRef Name) {
 142     return Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M.get());
 143   }
 144
 145   Module* getModule() { return M.get(); }
 146   const Module* getModule() const { return M.get(); }
 147   std::unique_ptr<Module> takeModule() { return std::move(M); }
 148
 149 private:
 150   std::unique_ptr<Module> M;
 151 };
 152
 153 // Dummy struct type.
 154 struct DummyStruct {
 155   int X[256];
 156 };
 157
 158 inline StructType *getDummyStructTy(LLVMContext &Context) {
 159   return StructType::get(ArrayType::get(Type::getInt32Ty(Context), 256));
 160 }
 161
 162 } // namespace llvm
 163
 164 #endif