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