Home | History | Annotate | Download | only in MCJIT 
      1 //===- MCJITTestBase.h - Common base class for MCJIT Unit tests  ----------===//
      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 // This class implements common functionality required by the MCJIT unit tests,
     11 // as well as logic to skip tests on unsupported architectures and operating
     12 // systems.
     13 //
     14 //===----------------------------------------------------------------------===//
     15 
     16 
     17 #ifndef MCJIT_TEST_BASE_H
     18 #define MCJIT_TEST_BASE_H
     19 
     20 #include "llvm/ADT/SmallVector.h"
     21 #include "llvm/ADT/Triple.h"
     22 #include "llvm/Config/config.h"
     23 #include "llvm/ExecutionEngine/ExecutionEngine.h"
     24 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
     25 #include "llvm/IR/Function.h"
     26 #include "llvm/IR/IRBuilder.h"
     27 #include "llvm/IR/LLVMContext.h"
     28 #include "llvm/IR/Module.h"
     29 #include "llvm/IR/TypeBuilder.h"
     30 #include "llvm/Support/CodeGen.h"
     31 #include "llvm/Support/Host.h"
     32 #include "llvm/Support/TargetSelect.h"
     33 
     34 // Used to skip tests on unsupported architectures and operating systems.
     35 // To skip a test, add this macro at the top of a test-case in a suite that
     36 // inherits from MCJITTestBase. See MCJITTest.cpp for examples.
     37 #define SKIP_UNSUPPORTED_PLATFORM \
     38   do \
     39     if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) \
     40       return; \
     41   while(0);
     42 
     43 namespace llvm {
     44 
     45 class MCJITTestBase {
     46 protected:
     47 
     48   MCJITTestBase()
     49     : OptLevel(CodeGenOpt::None)
     50     , RelocModel(Reloc::Default)
     51     , CodeModel(CodeModel::Default)
     52     , MArch("")
     53     , Builder(Context)
     54     , MM(new SectionMemoryManager)
     55     , HostTriple(sys::getProcessTriple())
     56   {
     57     InitializeNativeTarget();
     58     InitializeNativeTargetAsmPrinter();
     59 
     60 #ifdef LLVM_ON_WIN32
     61     // On Windows, generate ELF objects by specifying "-elf" in triple
     62     HostTriple += "-elf";
     63 #endif // LLVM_ON_WIN32
     64     HostTriple = Triple::normalize(HostTriple);
     65 
     66     // The architectures below are known to be compatible with MCJIT as they
     67     // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
     68     // kept in sync.
     69     SupportedArchs.push_back(Triple::arm);
     70     SupportedArchs.push_back(Triple::mips);
     71     SupportedArchs.push_back(Triple::x86);
     72     SupportedArchs.push_back(Triple::x86_64);
     73 
     74     // The operating systems below are known to be incompatible with MCJIT as
     75     // they are copied from the test/ExecutionEngine/MCJIT/lit.local.cfg and
     76     // should be kept in sync.
     77     UnsupportedOSs.push_back(Triple::Cygwin);
     78     UnsupportedOSs.push_back(Triple::Darwin);
     79   }
     80 
     81   /// Returns true if the host architecture is known to support MCJIT
     82   bool ArchSupportsMCJIT() {
     83     Triple Host(HostTriple);
     84     if (std::find(SupportedArchs.begin(), SupportedArchs.end(), Host.getArch())
     85         == SupportedArchs.end()) {
     86       return false;
     87     }
     88     return true;
     89   }
     90 
     91   /// Returns true if the host OS is known to support MCJIT
     92   bool OSSupportsMCJIT() {
     93     Triple Host(HostTriple);
     94     if (std::find(UnsupportedOSs.begin(), UnsupportedOSs.end(), Host.getOS())
     95         == UnsupportedOSs.end()) {
     96       return true;
     97     }
     98     return false;
     99   }
    100 
    101   Module *createEmptyModule(StringRef Name) {
    102     Module * M = new Module(Name, Context);
    103     M->setTargetTriple(Triple::normalize(HostTriple));
    104     return M;
    105   }
    106 
    107   template<typename FuncType>
    108   Function *startFunction(Module *M, StringRef Name) {
    109     Function *Result = Function::Create(
    110       TypeBuilder<FuncType, false>::get(Context),
    111       GlobalValue::ExternalLinkage, Name, M);
    112 
    113     BasicBlock *BB = BasicBlock::Create(Context, Name, Result);
    114     Builder.SetInsertPoint(BB);
    115 
    116     return Result;
    117   }
    118 
    119   void endFunctionWithRet(Function *Func, Value *RetValue) {
    120     Builder.CreateRet(RetValue);
    121   }
    122 
    123   // Inserts a simple function that invokes Callee and takes the same arguments:
    124   //    int Caller(...) { return Callee(...); }
    125   template<typename Signature>
    126   Function *insertSimpleCallFunction(Module *M, Function *Callee) {
    127     Function *Result = startFunction<Signature>(M, "caller");
    128 
    129     SmallVector<Value*, 1> CallArgs;
    130 
    131     Function::arg_iterator arg_iter = Result->arg_begin();
    132     for(;arg_iter != Result->arg_end(); ++arg_iter)
    133       CallArgs.push_back(arg_iter);
    134 
    135     Value *ReturnCode = Builder.CreateCall(Callee, CallArgs);
    136     Builder.CreateRet(ReturnCode);
    137     return Result;
    138   }
    139 
    140   // Inserts a function named 'main' that returns a uint32_t:
    141   //    int32_t main() { return X; }
    142   // where X is given by returnCode
    143   Function *insertMainFunction(Module *M, uint32_t returnCode) {
    144     Function *Result = startFunction<int32_t(void)>(M, "main");
    145 
    146     Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode));
    147     endFunctionWithRet(Result, ReturnVal);
    148 
    149     return Result;
    150   }
    151 
    152   // Inserts a function
    153   //    int32_t add(int32_t a, int32_t b) { return a + b; }
    154   // in the current module and returns a pointer to it.
    155   Function *insertAddFunction(Module *M, StringRef Name = "add") {
    156     Function *Result = startFunction<int32_t(int32_t, int32_t)>(M, Name);
    157 
    158     Function::arg_iterator args = Result->arg_begin();
    159     Value *Arg1 = args;
    160     Value *Arg2 = ++args;
    161     Value *AddResult = Builder.CreateAdd(Arg1, Arg2);
    162 
    163     endFunctionWithRet(Result, AddResult);
    164 
    165     return Result;
    166   }
    167 
    168   // Inserts an declaration to a function defined elsewhere
    169   Function *insertExternalReferenceToFunction(Module *M, StringRef Name,
    170                                               FunctionType *FuncTy) {
    171     Function *Result = Function::Create(FuncTy,
    172                                         GlobalValue::ExternalLinkage,
    173                                         Name, M);
    174     return Result;
    175   }
    176 
    177   // Inserts an declaration to a function defined elsewhere
    178   Function *insertExternalReferenceToFunction(Module *M, Function *Func) {
    179     Function *Result = Function::Create(Func->getFunctionType(),
    180                                         GlobalValue::AvailableExternallyLinkage,
    181                                         Func->getName(), M);
    182     return Result;
    183   }
    184 
    185   // Inserts a global variable of type int32
    186   GlobalVariable *insertGlobalInt32(Module *M,
    187                                     StringRef name,
    188                                     int32_t InitialValue) {
    189     Type *GlobalTy = TypeBuilder<types::i<32>, true>::get(Context);
    190     Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue));
    191     GlobalVariable *Global = new GlobalVariable(*M,
    192                                                 GlobalTy,
    193                                                 false,
    194                                                 GlobalValue::ExternalLinkage,
    195                                                 IV,
    196                                                 name);
    197     return Global;
    198   }
    199 
    200   void createJIT(Module *M) {
    201 
    202     // Due to the EngineBuilder constructor, it is required to have a Module
    203     // in order to construct an ExecutionEngine (i.e. MCJIT)
    204     assert(M != 0 && "a non-null Module must be provided to create MCJIT");
    205 
    206     EngineBuilder EB(M);
    207     std::string Error;
    208     TheJIT.reset(EB.setEngineKind(EngineKind::JIT)
    209                  .setUseMCJIT(true) /* can this be folded into the EngineKind enum? */
    210                  .setJITMemoryManager(MM)
    211                  .setErrorStr(&Error)
    212                  .setOptLevel(CodeGenOpt::None)
    213                  .setAllocateGVsWithCode(false) /*does this do anything?*/
    214                  .setCodeModel(CodeModel::JITDefault)
    215                  .setRelocationModel(Reloc::Default)
    216                  .setMArch(MArch)
    217                  .setMCPU(sys::getHostCPUName())
    218                  //.setMAttrs(MAttrs)
    219                  .create());
    220     // At this point, we cannot modify the module any more.
    221     assert(TheJIT.get() != NULL && "error creating MCJIT with EngineBuilder");
    222   }
    223 
    224   LLVMContext Context;
    225   CodeGenOpt::Level OptLevel;
    226   Reloc::Model RelocModel;
    227   CodeModel::Model CodeModel;
    228   StringRef MArch;
    229   SmallVector<std::string, 1> MAttrs;
    230   OwningPtr<TargetMachine> TM;
    231   OwningPtr<ExecutionEngine> TheJIT;
    232   IRBuilder<> Builder;
    233   JITMemoryManager *MM;
    234 
    235   std::string HostTriple;
    236   SmallVector<Triple::ArchType, 4> SupportedArchs;
    237   SmallVector<Triple::OSType, 4> UnsupportedOSs;
    238 
    239   OwningPtr<Module> M;
    240 };
    241 
    242 } // namespace llvm
    243 
    244 #endif // MCJIT_TEST_H
    245