mono/mini/mini-llvm-cpp.cpp

   1 //
   2 // mini-llvm-cpp.cpp: C++ support classes for the mono LLVM integration
   3 //
   4 // (C) 2009-2011 Novell, Inc.
   5 // Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   6 //
   7
   8 //
   9 // We need to override some stuff in LLVM, but this cannot be done using the C
  10 // interface, so we have to use some C++ code here.
  11 // The things which we override are:
  12 // - the default JIT code manager used by LLVM doesn't allocate memory using
  13 //   MAP_32BIT, we require it.
  14 // - add some callbacks so we can obtain the size of methods and their exception
  15 //   tables.
  16 //
  17
  18 //
  19 // Mono's internal header files are not C++ clean, so avoid including them if
  20 // possible
  21 //
  22
  23 #include <stdint.h>
  24
  25 #include <llvm/Support/raw_ostream.h>
  26 #include <llvm/PassManager.h>
  27 #include <llvm/ExecutionEngine/ExecutionEngine.h>
  28 #include <llvm/ExecutionEngine/JITMemoryManager.h>
  29 #include <llvm/ExecutionEngine/JITEventListener.h>
  30 #include <llvm/Target/TargetOptions.h>
  31 #include <llvm/Target/TargetData.h>
  32 #include <llvm/Target/TargetRegisterInfo.h>
  33 #include <llvm/Analysis/Verifier.h>
  34 #include <llvm/Analysis/Passes.h>
  35 #include <llvm/Transforms/Scalar.h>
  36 #include <llvm/Support/CommandLine.h>
  37 #include "llvm/Support/PassNameParser.h"
  38 #include "llvm/Support/PrettyStackTrace.h"
  39 #include <llvm/CodeGen/Passes.h>
  40 #include <llvm/CodeGen/MachineFunctionPass.h>
  41 #include <llvm/CodeGen/MachineFunction.h>
  42 #include <llvm/CodeGen/MachineFrameInfo.h>
  43 //#include <llvm/LinkAllPasses.h>
  44
  45 #include "llvm-c/Core.h"
  46 #include "llvm-c/ExecutionEngine.h"
  47
  48 #include "mini-llvm-cpp.h"
  49
  50 #define LLVM_CHECK_VERSION(major,minor) \
  51         ((LLVM_MAJOR_VERSION > (major)) ||                                                                      \
  52          ((LLVM_MAJOR_VERSION == (major)) && (LLVM_MINOR_VERSION >= (minor))))
  53
  54 using namespace llvm;
  55
  56 class MonoJITMemoryManager : public JITMemoryManager
  57 {
  58 private:
  59         JITMemoryManager *mm;
  60
  61 public:
  62         /* Callbacks installed by mono */
  63         AllocCodeMemoryCb *alloc_cb;
  64
  65         MonoJITMemoryManager ();
  66         ~MonoJITMemoryManager ();
  67
  68         void setMemoryWritable (void);
  69
  70         void setMemoryExecutable (void);
  71
  72         void AllocateGOT();
  73
  74     unsigned char *getGOTBase() const {
  75                 return mm->getGOTBase ();
  76     }
  77
  78         void setPoisonMemory(bool) {
  79         }
  80
  81         unsigned char *startFunctionBody(const Function *F,
  82                                                                          uintptr_t &ActualSize);
  83
  84         unsigned char *allocateStub(const GlobalValue* F, unsigned StubSize,
  85                                                                  unsigned Alignment);
  86
  87         void endFunctionBody(const Function *F, unsigned char *FunctionStart,
  88                                                  unsigned char *FunctionEnd);
  89
  90         unsigned char *allocateSpace(intptr_t Size, unsigned Alignment);
  91
  92         uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment);
  93
  94         void deallocateMemForFunction(const Function *F);
  95
  96         unsigned char*startExceptionTable(const Function* F,
  97                                                                           uintptr_t &ActualSize);
  98
  99         void endExceptionTable(const Function *F, unsigned char *TableStart,
 100                                                    unsigned char *TableEnd,
 101                                                    unsigned char* FrameRegister);
 102
 103         virtual void deallocateFunctionBody(void*) {
 104         }
 105
 106         virtual void deallocateExceptionTable(void*) {
 107         }
 108 };
 109
 110 MonoJITMemoryManager::MonoJITMemoryManager ()
 111 {
 112         mm = JITMemoryManager::CreateDefaultMemManager ();
 113 }
 114
 115 MonoJITMemoryManager::~MonoJITMemoryManager ()
 116 {
 117         delete mm;
 118 }
 119
 120 void
 121 MonoJITMemoryManager::setMemoryWritable (void)
 122 {
 123 }
 124
 125 void
 126 MonoJITMemoryManager::setMemoryExecutable (void)
 127 {
 128 }
 129
 130 void
 131 MonoJITMemoryManager::AllocateGOT()
 132 {
 133         mm->AllocateGOT ();
 134 }
 135
 136 unsigned char *
 137 MonoJITMemoryManager::startFunctionBody(const Function *F,
 138                                         uintptr_t &ActualSize)
 139 {
 140         // FIXME: This leaks memory
 141         if (ActualSize == 0)
 142                 ActualSize = 128;
 143         return alloc_cb (wrap (F), ActualSize);
 144 }
 145
 146 unsigned char *
 147 MonoJITMemoryManager::allocateStub(const GlobalValue* F, unsigned StubSize,
 148                            unsigned Alignment)
 149 {
 150         return alloc_cb (wrap (F), StubSize);
 151 }
 152
 153 void
 154 MonoJITMemoryManager::endFunctionBody(const Function *F, unsigned char *FunctionStart,
 155                                   unsigned char *FunctionEnd)
 156 {
 157 }
 158
 159 unsigned char *
 160 MonoJITMemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
 161 {
 162         return new unsigned char [Size];
 163 }
 164
 165 uint8_t *
 166 MonoJITMemoryManager::allocateGlobal(uintptr_t Size, unsigned Alignment)
 167 {
 168         return new unsigned char [Size];
 169 }
 170
 171 void
 172 MonoJITMemoryManager::deallocateMemForFunction(const Function *F)
 173 {
 174 }
 175
 176 unsigned char*
 177 MonoJITMemoryManager::startExceptionTable(const Function* F,
 178                                           uintptr_t &ActualSize)
 179 {
 180         return startFunctionBody(F, ActualSize);
 181 }
 182
 183 void
 184 MonoJITMemoryManager::endExceptionTable(const Function *F, unsigned char *TableStart,
 185                                         unsigned char *TableEnd,
 186                                         unsigned char* FrameRegister)
 187 {
 188 }
 189
 190 class MonoJITEventListener : public JITEventListener {
 191
 192 public:
 193         FunctionEmittedCb *emitted_cb;
 194
 195         MonoJITEventListener (FunctionEmittedCb *cb) {
 196                 emitted_cb = cb;
 197         }
 198
 199         virtual void NotifyFunctionEmitted(const Function &F,
 200                                                                            void *Code, size_t Size,
 201                                                                            const EmittedFunctionDetails &Details) {
 202                 /*
 203                  * X86TargetMachine::setCodeModelForJIT() sets the code model to Large on amd64,
 204                  * which means the JIT will generate calls of the form
 205                  * mov reg, <imm>
 206                  * call *reg
 207                  * Our trampoline code can't patch this. Passing CodeModel::Small to createJIT
 208                  * doesn't seem to work, we need Default. A discussion is here:
 209                  * http://lists.cs.uiuc.edu/pipermail/llvmdev/2009-December/027999.html
 210                  * There seems to no way to get the TargeMachine used by an EE either, so we
 211                  * install a profiler hook and reset the code model here.
 212                  * This should be inside an ifdef, but we can't include our config.h either,
 213                  * since its definitions conflict with LLVM's config.h.
 214                  *
 215                  */
 216                 //#if defined(TARGET_X86) || defined(TARGET_AMD64)
 217 #ifndef LLVM_MONO_BRANCH
 218                 /* The LLVM mono branch contains a workaround, so this is not needed */
 219                 if (Details.MF->getTarget ().getCodeModel () == CodeModel::Large) {
 220                         Details.MF->getTarget ().setCodeModel (CodeModel::Default);
 221                 }
 222 #endif
 223                 //#endif
 224
 225                 emitted_cb (wrap (&F), Code, (char*)Code + Size);
 226         }
 227 };
 228
 229 static MonoJITMemoryManager *mono_mm;
 230 static MonoJITEventListener *mono_event_listener;
 231
 232 static FunctionPassManager *fpm;
 233
 234 void
 235 mono_llvm_optimize_method (LLVMValueRef method)
 236 {
 237         verifyFunction (*(unwrap<Function> (method)));
 238         fpm->run (*unwrap<Function> (method));
 239 }
 240
 241 void
 242 mono_llvm_dump_value (LLVMValueRef value)
 243 {
 244         /* Same as LLVMDumpValue (), but print to stdout */
 245         fflush (stdout);
 246         outs () << (*unwrap<Value> (value));
 247 }
 248
 249 /* Missing overload for building an alloca with an alignment */
 250 LLVMValueRef
 251 mono_llvm_build_alloca (LLVMBuilderRef builder, LLVMTypeRef Ty,
 252                                                 LLVMValueRef ArraySize,
 253                                                 int alignment, const char *Name)
 254 {
 255         return wrap (unwrap (builder)->Insert (new AllocaInst (unwrap (Ty), unwrap (ArraySize), alignment), Name));
 256 }
 257
 258 LLVMValueRef
 259 mono_llvm_build_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
 260                                           const char *Name, gboolean is_volatile)
 261 {
 262         return wrap(unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name));
 263 }
 264
 265 LLVMValueRef
 266 mono_llvm_build_aligned_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
 267                                                           const char *Name, gboolean is_volatile, int alignment)
 268 {
 269         LoadInst *ins;
 270
 271         ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
 272         ins->setAlignment (alignment);
 273
 274         return wrap(ins);
 275 }
 276
 277 LLVMValueRef
 278 mono_llvm_build_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 279                                           gboolean is_volatile)
 280 {
 281         return wrap(unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile));
 282 }
 283
 284 LLVMValueRef
 285 mono_llvm_build_aligned_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 286                                                            gboolean is_volatile, int alignment)
 287 {
 288         StoreInst *ins;
 289
 290         ins = unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile);
 291         ins->setAlignment (alignment);
 292
 293         return wrap (ins);
 294 }
 295
 296 LLVMValueRef
 297 mono_llvm_build_cmpxchg (LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp, LLVMValueRef val)
 298 {
 299         AtomicCmpXchgInst *ins;
 300
 301         ins = unwrap(builder)->CreateAtomicCmpXchg (unwrap(ptr), unwrap (cmp), unwrap (val), SequentiallyConsistent);
 302         return wrap (ins);
 303 }
 304
 305 LLVMValueRef
 306 mono_llvm_build_atomic_rmw (LLVMBuilderRef builder, AtomicRMWOp op, LLVMValueRef ptr, LLVMValueRef val)
 307 {
 308         AtomicRMWInst::BinOp aop = AtomicRMWInst::Xchg;
 309         AtomicRMWInst *ins;
 310
 311         switch (op) {
 312         case LLVM_ATOMICRMW_OP_XCHG:
 313                 aop = AtomicRMWInst::Xchg;
 314                 break;
 315         case LLVM_ATOMICRMW_OP_ADD:
 316                 aop = AtomicRMWInst::Add;
 317                 break;
 318         default:
 319                 g_assert_not_reached ();
 320                 break;
 321         }
 322
 323         ins = unwrap (builder)->CreateAtomicRMW (aop, unwrap (ptr), unwrap (val), AcquireRelease);
 324         return wrap (ins);
 325 }
 326
 327 LLVMValueRef
 328 mono_llvm_build_fence (LLVMBuilderRef builder)
 329 {
 330         FenceInst *ins;
 331
 332         ins = unwrap (builder)->CreateFence (AcquireRelease);
 333         return wrap (ins);
 334 }
 335
 336 void
 337 mono_llvm_replace_uses_of (LLVMValueRef var, LLVMValueRef v)
 338 {
 339         Value *V = ConstantExpr::getTruncOrBitCast (unwrap<Constant> (v), unwrap (var)->getType ());
 340         unwrap (var)->replaceAllUsesWith (V);
 341 }
 342
 343 static cl::list<const PassInfo*, bool, PassNameParser>
 344 PassList(cl::desc("Optimizations available:"));
 345
 346 static void
 347 force_pass_linking (void)
 348 {
 349         // Make sure the rest is linked in, but never executed
 350         if (getenv ("FOO") != (char*)-1)
 351                 return;
 352
 353         // This is a subset of the passes in LinkAllPasses.h
 354         // The utility passes and the interprocedural passes are commented out
 355
 356       (void) llvm::createAAEvalPass();
 357       (void) llvm::createAggressiveDCEPass();
 358       (void) llvm::createAliasAnalysisCounterPass();
 359       (void) llvm::createAliasDebugger();
 360           /*
 361       (void) llvm::createArgumentPromotionPass();
 362       (void) llvm::createStructRetPromotionPass();
 363           */
 364       (void) llvm::createBasicAliasAnalysisPass();
 365       (void) llvm::createLibCallAliasAnalysisPass(0);
 366       (void) llvm::createScalarEvolutionAliasAnalysisPass();
 367       (void) llvm::createBlockPlacementPass();
 368       (void) llvm::createBreakCriticalEdgesPass();
 369       (void) llvm::createCFGSimplificationPass();
 370           /*
 371       (void) llvm::createConstantMergePass();
 372       (void) llvm::createConstantPropagationPass();
 373           */
 374           /*
 375       (void) llvm::createDeadArgEliminationPass();
 376           */
 377       (void) llvm::createDeadCodeEliminationPass();
 378       (void) llvm::createDeadInstEliminationPass();
 379       (void) llvm::createDeadStoreEliminationPass();
 380           /*
 381       (void) llvm::createDeadTypeEliminationPass();
 382       (void) llvm::createDomOnlyPrinterPass();
 383       (void) llvm::createDomPrinterPass();
 384       (void) llvm::createDomOnlyViewerPass();
 385       (void) llvm::createDomViewerPass();
 386       (void) llvm::createEdgeProfilerPass();
 387       (void) llvm::createOptimalEdgeProfilerPass();
 388       (void) llvm::createFunctionInliningPass();
 389       (void) llvm::createAlwaysInlinerPass();
 390       (void) llvm::createGlobalDCEPass();
 391       (void) llvm::createGlobalOptimizerPass();
 392       (void) llvm::createGlobalsModRefPass();
 393       (void) llvm::createIPConstantPropagationPass();
 394       (void) llvm::createIPSCCPPass();
 395           */
 396       (void) llvm::createIndVarSimplifyPass();
 397       (void) llvm::createInstructionCombiningPass();
 398           /*
 399       (void) llvm::createInternalizePass(false);
 400           */
 401       (void) llvm::createLCSSAPass();
 402       (void) llvm::createLICMPass();
 403       (void) llvm::createLazyValueInfoPass();
 404       (void) llvm::createLoopDependenceAnalysisPass();
 405           /*
 406       (void) llvm::createLoopExtractorPass();
 407           */
 408       (void) llvm::createLoopSimplifyPass();
 409       (void) llvm::createLoopStrengthReducePass();
 410       (void) llvm::createLoopUnrollPass();
 411       (void) llvm::createLoopUnswitchPass();
 412       (void) llvm::createLoopRotatePass();
 413       (void) llvm::createLowerInvokePass();
 414           /*
 415       (void) llvm::createLowerSetJmpPass();
 416           */
 417       (void) llvm::createLowerSwitchPass();
 418       (void) llvm::createNoAAPass();
 419           /*
 420       (void) llvm::createNoProfileInfoPass();
 421       (void) llvm::createProfileEstimatorPass();
 422       (void) llvm::createProfileVerifierPass();
 423       (void) llvm::createProfileLoaderPass();
 424           */
 425       (void) llvm::createPromoteMemoryToRegisterPass();
 426       (void) llvm::createDemoteRegisterToMemoryPass();
 427           /*
 428       (void) llvm::createPruneEHPass();
 429       (void) llvm::createPostDomOnlyPrinterPass();
 430       (void) llvm::createPostDomPrinterPass();
 431       (void) llvm::createPostDomOnlyViewerPass();
 432       (void) llvm::createPostDomViewerPass();
 433           */
 434       (void) llvm::createReassociatePass();
 435       (void) llvm::createSCCPPass();
 436       (void) llvm::createScalarReplAggregatesPass();
 437       (void) llvm::createSimplifyLibCallsPass();
 438           /*
 439       (void) llvm::createSingleLoopExtractorPass();
 440       (void) llvm::createStripSymbolsPass();
 441       (void) llvm::createStripNonDebugSymbolsPass();
 442       (void) llvm::createStripDeadDebugInfoPass();
 443       (void) llvm::createStripDeadPrototypesPass();
 444       (void) llvm::createTailCallEliminationPass();
 445       (void) llvm::createTailDuplicationPass();
 446       (void) llvm::createJumpThreadingPass();
 447           */
 448           /*
 449       (void) llvm::createUnifyFunctionExitNodesPass();
 450           */
 451       (void) llvm::createInstCountPass();
 452       (void) llvm::createCodeGenPreparePass();
 453       (void) llvm::createGVNPass();
 454       (void) llvm::createMemCpyOptPass();
 455       (void) llvm::createLoopDeletionPass();
 456           /*
 457       (void) llvm::createPostDomTree();
 458       (void) llvm::createPostDomFrontier();
 459       (void) llvm::createInstructionNamerPass();
 460       (void) llvm::createPartialSpecializationPass();
 461       (void) llvm::createFunctionAttrsPass();
 462       (void) llvm::createMergeFunctionsPass();
 463       (void) llvm::createPrintModulePass(0);
 464       (void) llvm::createPrintFunctionPass("", 0);
 465       (void) llvm::createDbgInfoPrinterPass();
 466       (void) llvm::createModuleDebugInfoPrinterPass();
 467       (void) llvm::createPartialInliningPass();
 468       (void) llvm::createGEPSplitterPass();
 469       (void) llvm::createLintPass();
 470           */
 471       (void) llvm::createSinkingPass();
 472 }
 473
 474 LLVMExecutionEngineRef
 475 mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, FunctionEmittedCb *emitted_cb, ExceptionTableCb *exception_cb)
 476 {
 477   std::string Error;
 478
 479   force_pass_linking ();
 480
 481   LLVMInitializeX86Target ();
 482   LLVMInitializeX86TargetInfo ();
 483   LLVMInitializeX86TargetMC ();
 484
 485   mono_mm = new MonoJITMemoryManager ();
 486   mono_mm->alloc_cb = alloc_cb;
 487
 488   //JITExceptionHandling = true;
 489   // PrettyStackTrace installs signal handlers which trip up libgc
 490   DisablePrettyStackTrace = true;
 491
 492   /*
 493    * The Default code model doesn't seem to work on amd64,
 494    * test_0_fields_with_big_offsets (among others) crashes, because LLVM tries to call
 495    * memset using a normal pcrel code which is in 32bit memory, while memset isn't.
 496    */
 497
 498   TargetOptions opts;
 499   opts.JITExceptionHandling = 1;
 500
 501   EngineBuilder b (unwrap (MP));
 502   ExecutionEngine *EE = b.setJITMemoryManager (mono_mm).setTargetOptions (opts).setCodeModel (CodeModel::Large).setAllocateGVsWithCode (true).create ();
 503   g_assert (EE);
 504
 505 #if 0
 506   ExecutionEngine *EE = ExecutionEngine::createJIT (unwrap (MP), &Error, mono_mm, CodeGenOpt::Default, true, Reloc::Default, CodeModel::Large);
 507   if (!EE) {
 508           errs () << "Unable to create LLVM ExecutionEngine: " << Error << "\n";
 509           g_assert_not_reached ();
 510   }
 511 #endif
 512
 513   EE->InstallExceptionTableRegister (exception_cb);
 514   mono_event_listener = new MonoJITEventListener (emitted_cb);
 515   EE->RegisterJITEventListener (mono_event_listener);
 516
 517   fpm = new FunctionPassManager (unwrap (MP));
 518
 519   fpm->add(new TargetData(*EE->getTargetData()));
 520
 521   PassRegistry &Registry = *PassRegistry::getPassRegistry();
 522   initializeCore(Registry);
 523   initializeScalarOpts(Registry);
 524   //initializeIPO(Registry);
 525   initializeAnalysis(Registry);
 526   initializeIPA(Registry);
 527   initializeTransformUtils(Registry);
 528   initializeInstCombine(Registry);
 529   //initializeInstrumentation(Registry);
 530   initializeTarget(Registry);
 531
 532   llvm::cl::ParseEnvironmentOptions("mono", "MONO_LLVM", "", false);
 533
 534   if (PassList.size() > 0) {
 535           /* Use the passes specified by the env variable */
 536           /* Only the passes in force_pass_linking () can be used */
 537           for (unsigned i = 0; i < PassList.size(); ++i) {
 538                   const PassInfo *PassInf = PassList[i];
 539                   Pass *P = 0;
 540
 541                   if (PassInf->getNormalCtor())
 542                           P = PassInf->getNormalCtor()();
 543                   fpm->add (P);
 544           }
 545   } else {
 546           /* Use the same passes used by 'opt' by default, without the ipo passes */
 547           const char *opts = "-simplifycfg -domtree -domfrontier -scalarrepl -instcombine -simplifycfg -basiccg -domtree -domfrontier -scalarrepl -simplify-libcalls -instcombine -simplifycfg -instcombine -simplifycfg -reassociate -domtree -loops -loop-simplify -domfrontier -loop-simplify -lcssa -loop-rotate -licm -lcssa -loop-unswitch -instcombine -scalar-evolution -loop-simplify -lcssa -iv-users -indvars -loop-deletion -loop-simplify -lcssa -loop-unroll -instcombine -memdep -gvn -memdep -memcpyopt -sccp -instcombine -domtree -memdep -dse -adce -gvn -simplifycfg -preverify -domtree -verify";
 548           char **args;
 549           int i;
 550
 551           args = g_strsplit (opts, " ", 1000);
 552           for (i = 0; args [i]; i++)
 553                   ;
 554           llvm::cl::ParseCommandLineOptions (i, args, "", false);
 555           g_strfreev (args);
 556
 557           for (unsigned i = 0; i < PassList.size(); ++i) {
 558                   const PassInfo *PassInf = PassList[i];
 559                   Pass *P = 0;
 560
 561                   if (PassInf->getNormalCtor())
 562                           P = PassInf->getNormalCtor()();
 563                   fpm->add (P);
 564           }
 565
 566           /*
 567           fpm->add(createInstructionCombiningPass());
 568           fpm->add(createReassociatePass());
 569           fpm->add(createGVNPass());
 570           fpm->add(createCFGSimplificationPass());
 571           */
 572   }
 573
 574   return wrap(EE);
 575 }
 576
 577 void
 578 mono_llvm_dispose_ee (LLVMExecutionEngineRef ee)
 579 {
 580         delete unwrap (ee);
 581
 582         delete fpm;
 583 }