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