mono/mini/mini-llvm-cpp.cpp

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