2 // jit-llvm.cpp: Support code for using LLVM as a JIT backend
4 // (C) 2009-2011 Novell, Inc.
5 // Copyright 2011-2015 Xamarin, Inc (http://www.xamarin.com)
7 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
9 // Mono's internal header files are not C++ clean, so avoid including them if
15 #include <llvm-c/Core.h>
16 #include <llvm-c/ExecutionEngine.h>
18 #include "mini-llvm-cpp.h"
21 #if !defined(MONO_CROSS_COMPILE) && LLVM_API_VERSION > 100
24 * LLVM 3.9 uses the OrcJIT APIs
27 #include <llvm/Support/raw_ostream.h>
28 #include <llvm/Support/Host.h>
29 #include <llvm/Support/TargetSelect.h>
30 #include <llvm/IR/Mangler.h>
31 #include <llvm/ExecutionEngine/ExecutionEngine.h>
32 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
33 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
34 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
35 #if LLVM_API_VERSION >= 500
36 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
37 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
38 #include "llvm/ExecutionEngine/JITSymbol.h"
40 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
46 #include <mono/utils/mono-dl.h>
50 using namespace llvm::orc;
52 extern cl::opt<bool> EnableMonoEH;
53 extern cl::opt<std::string> MonoEHFrameSymbol;
56 mono_llvm_set_unhandled_exception_handler (void)
61 static std::vector<T> singletonSet(T t) {
63 Vec.push_back(std::move(t));
70 extern void *memset(void *, int, size_t);
71 void bzero (void *to, size_t count) { memset (to, 0, count); }
75 static AllocCodeMemoryCb *alloc_code_mem_cb;
77 class MonoJitMemoryManager : public RTDyldMemoryManager
80 ~MonoJitMemoryManager() override;
82 uint8_t *allocateDataSection(uintptr_t Size,
85 StringRef SectionName,
86 bool IsReadOnly) override;
88 uint8_t *allocateCodeSection(uintptr_t Size,
91 StringRef SectionName) override;
93 bool finalizeMemory(std::string *ErrMsg = nullptr) override;
96 MonoJitMemoryManager::~MonoJitMemoryManager()
101 MonoJitMemoryManager::allocateDataSection(uintptr_t Size,
104 StringRef SectionName,
106 uint8_t *res = (uint8_t*)malloc (Size);
108 memset (res, 0, Size);
113 MonoJitMemoryManager::allocateCodeSection(uintptr_t Size,
116 StringRef SectionName)
118 return alloc_code_mem_cb (NULL, Size);
122 MonoJitMemoryManager::finalizeMemory(std::string *ErrMsg)
129 /* We use our own trampoline infrastructure instead of the Orc one */
130 #if LLVM_API_VERSION >= 500
131 typedef RTDyldObjectLinkingLayer ObjLayerT;
132 typedef IRCompileLayer<ObjLayerT, SimpleCompiler> CompileLayerT;
133 typedef CompileLayerT::ModuleHandleT ModuleHandleT;
135 typedef ObjectLinkingLayer<> ObjLayerT;
136 typedef IRCompileLayer<ObjLayerT> CompileLayerT;
137 typedef CompileLayerT::ModuleSetHandleT ModuleHandleT;
140 MonoLLVMJIT (TargetMachine *TM, MonoJitMemoryManager *mm)
141 #if LLVM_API_VERSION >= 500
142 : TM(TM), ObjectLayer([=] { return std::shared_ptr<RuntimeDyld::MemoryManager> (mm); }),
146 CompileLayer (ObjectLayer, SimpleCompiler (*TM)),
150 #if LLVM_API_VERSION >= 500
151 ModuleHandleT addModule(Function *F, std::shared_ptr<Module> M) {
153 ModuleHandleT addModule(Function *F, Module *M) {
155 auto Resolver = createLambdaResolver(
156 [&](const std::string &Name) {
157 const char *name = Name.c_str ();
158 #if LLVM_API_VERSION >= 500
159 JITSymbolFlags flags = JITSymbolFlags ();
161 JITSymbolFlags flags = (JITSymbolFlags)0;
163 if (!strcmp (name, "___bzero")) {
164 #if LLVM_API_VERSION >= 500
165 return JITSymbol((uint64_t)(gssize)(void*)bzero, flags);
167 return RuntimeDyld::SymbolInfo((uint64_t)(gssize)(void*)bzero, flags);
174 current = mono_dl_open (NULL, 0, NULL);
177 err = mono_dl_symbol (current, name + 1, &symbol);
179 err = mono_dl_symbol (current, name, &symbol);
180 mono_dl_close (current);
182 outs () << "R: " << Name << "\n";
184 #if LLVM_API_VERSION >= 500
185 return JITSymbol((uint64_t)(gssize)symbol, flags);
187 return RuntimeDyld::SymbolInfo((uint64_t)(gssize)symbol, flags);
190 [](const std::string &S) {
191 outs () << "R2: " << S << "\n";
196 #if LLVM_API_VERSION >= 500
197 ModuleHandleT m = CompileLayer.addModule(M,
198 std::move(Resolver));
201 return CompileLayer.addModuleSet(singletonSet(M),
202 make_unique<MonoJitMemoryManager>(),
203 std::move(Resolver));
207 std::string mangle(const std::string &Name) {
208 std::string MangledName;
210 raw_string_ostream MangledNameStream(MangledName);
211 Mangler::getNameWithPrefix(MangledNameStream, Name,
212 TM->createDataLayout());
217 std::string mangle(const GlobalValue *GV) {
218 std::string MangledName;
222 raw_string_ostream MangledNameStream(MangledName);
223 Mang.getNameWithPrefix(MangledNameStream, GV, false);
228 gpointer compile (Function *F, int nvars, LLVMValueRef *callee_vars, gpointer *callee_addrs, gpointer *eh_frame) {
229 F->getParent ()->setDataLayout (TM->createDataLayout ());
230 #if LLVM_API_VERSION >= 500
231 // Orc uses a shared_ptr to refer to modules so we have to save them ourselves to keep a ref
232 std::shared_ptr<Module> m (F->getParent ());
233 modules.push_back (m);
234 auto ModuleHandle = addModule (F, m);
236 auto ModuleHandle = addModule (F, F->getParent ());
238 auto BodySym = CompileLayer.findSymbolIn(ModuleHandle, mangle (F), false);
239 auto BodyAddr = BodySym.getAddress();
242 for (int i = 0; i < nvars; ++i) {
243 GlobalVariable *var = unwrap<GlobalVariable>(callee_vars [i]);
245 auto sym = CompileLayer.findSymbolIn (ModuleHandle, mangle (var->getName ()), true);
246 auto addr = sym.getAddress ();
248 callee_addrs [i] = (gpointer)addr;
251 auto ehsym = CompileLayer.findSymbolIn(ModuleHandle, "mono_eh_frame", false);
252 auto ehaddr = ehsym.getAddress ();
254 *eh_frame = (gpointer)ehaddr;
256 return (gpointer)BodyAddr;
261 ObjLayerT ObjectLayer;
262 CompileLayerT CompileLayer;
263 std::vector<std::shared_ptr<Module>> modules;
266 static MonoLLVMJIT *jit;
267 static MonoJitMemoryManager *mono_mm;
270 mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, FunctionEmittedCb *emitted_cb, ExceptionTableCb *exception_cb, DlSymCb *dlsym_cb, LLVMExecutionEngineRef *ee)
272 alloc_code_mem_cb = alloc_cb;
274 InitializeNativeTarget ();
275 InitializeNativeTargetAsmPrinter();
278 MonoEHFrameSymbol = "mono_eh_frame";
281 #if defined(TARGET_AMD64) || defined(TARGET_X86)
282 std::vector<std::string> attrs;
283 // FIXME: Autodetect this
284 attrs.push_back("sse3");
285 attrs.push_back("sse4.1");
286 EB.setMAttrs (attrs);
288 auto TM = EB.selectTarget ();
291 mono_mm = new MonoJitMemoryManager ();
292 jit = new MonoLLVMJIT (TM, mono_mm);
298 * mono_llvm_compile_method:
300 * Compile METHOD to native code. Compute the addresses of the variables in CALLEE_VARS and store them into
301 * CALLEE_ADDRS. Return the EH frame address in EH_FRAME.
304 mono_llvm_compile_method (MonoEERef mono_ee, LLVMValueRef method, int nvars, LLVMValueRef *callee_vars, gpointer *callee_addrs, gpointer *eh_frame)
306 return jit->compile (unwrap<Function> (method), nvars, callee_vars, callee_addrs, eh_frame);
310 mono_llvm_dispose_ee (MonoEERef *eeref)
315 LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
318 g_assert_not_reached ();
322 LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global)
324 g_assert_not_reached ();
328 #elif !defined(MONO_CROSS_COMPILE) && LLVM_API_VERSION < 100
332 #include <llvm/Support/raw_ostream.h>
333 #include <llvm/Support/Host.h>
334 #include <llvm/PassManager.h>
335 #include <llvm/ExecutionEngine/ExecutionEngine.h>
336 #include <llvm/ExecutionEngine/JITMemoryManager.h>
337 #include <llvm/ExecutionEngine/JITEventListener.h>
338 #include <llvm/Target/TargetOptions.h>
339 #include <llvm/Target/TargetRegisterInfo.h>
340 #include <llvm/IR/Verifier.h>
341 #include <llvm/Analysis/Passes.h>
342 #include <llvm/Transforms/Scalar.h>
343 #include <llvm/Support/CommandLine.h>
344 #include <llvm/IR/LegacyPassNameParser.h>
345 #include <llvm/Support/PrettyStackTrace.h>
346 #include <llvm/CodeGen/Passes.h>
347 #include <llvm/CodeGen/MachineFunctionPass.h>
348 #include <llvm/CodeGen/MachineFunction.h>
349 #include <llvm/CodeGen/MachineFrameInfo.h>
350 #include <llvm/IR/Function.h>
351 #include <llvm/IR/IRBuilder.h>
352 #include <llvm/IR/Module.h>
354 using namespace llvm;
356 static void (*unhandled_exception)() = default_mono_llvm_unhandled_exception;
359 mono_llvm_set_unhandled_exception_handler (void)
361 std::set_terminate (unhandled_exception);
364 class MonoJITMemoryManager : public JITMemoryManager
367 JITMemoryManager *mm;
370 /* Callbacks installed by mono */
371 AllocCodeMemoryCb *alloc_cb;
373 ExceptionTableCb *exception_cb;
375 MonoJITMemoryManager ();
376 ~MonoJITMemoryManager ();
378 void setMemoryWritable (void);
380 void setMemoryExecutable (void);
384 unsigned char *getGOTBase() const {
385 return mm->getGOTBase ();
388 void setPoisonMemory(bool) {
391 unsigned char *startFunctionBody(const Function *F,
392 uintptr_t &ActualSize);
394 unsigned char *allocateStub(const GlobalValue* F, unsigned StubSize,
397 void endFunctionBody(const Function *F, unsigned char *FunctionStart,
398 unsigned char *FunctionEnd);
400 unsigned char *allocateSpace(intptr_t Size, unsigned Alignment);
402 uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment);
404 void deallocateMemForFunction(const Function *F);
406 unsigned char*startExceptionTable(const Function* F,
407 uintptr_t &ActualSize);
409 void endExceptionTable(const Function *F, unsigned char *TableStart,
410 unsigned char *TableEnd,
411 unsigned char* FrameRegister);
413 virtual void deallocateFunctionBody(void*) {
416 virtual void deallocateExceptionTable(void*) {
419 virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID,
420 StringRef SectionName) {
426 virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID,
427 StringRef SectionName, bool IsReadOnly) {
433 virtual bool applyPermissions(std::string*) {
439 virtual bool finalizeMemory(std::string *ErrMsg = 0) {
445 virtual void* getPointerToNamedFunction(const std::string &Name, bool AbortOnFailure) {
449 err = dlsym_cb (Name.c_str (), &res);
451 outs () << "Unable to resolve: " << Name << ": " << err << "\n";
459 MonoJITMemoryManager::MonoJITMemoryManager ()
461 mm = JITMemoryManager::CreateDefaultMemManager ();
464 MonoJITMemoryManager::~MonoJITMemoryManager ()
470 MonoJITMemoryManager::setMemoryWritable (void)
475 MonoJITMemoryManager::setMemoryExecutable (void)
480 MonoJITMemoryManager::AllocateGOT()
486 MonoJITMemoryManager::startFunctionBody(const Function *F,
487 uintptr_t &ActualSize)
489 // FIXME: This leaks memory
492 return alloc_cb (wrap (F), ActualSize);
496 MonoJITMemoryManager::allocateStub(const GlobalValue* F, unsigned StubSize,
499 return alloc_cb (wrap (F), StubSize);
503 MonoJITMemoryManager::endFunctionBody(const Function *F, unsigned char *FunctionStart,
504 unsigned char *FunctionEnd)
509 MonoJITMemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
511 return new unsigned char [Size];
515 MonoJITMemoryManager::allocateGlobal(uintptr_t Size, unsigned Alignment)
517 return new unsigned char [Size];
521 MonoJITMemoryManager::deallocateMemForFunction(const Function *F)
526 MonoJITMemoryManager::startExceptionTable(const Function* F,
527 uintptr_t &ActualSize)
529 return startFunctionBody(F, ActualSize);
533 MonoJITMemoryManager::endExceptionTable(const Function *F, unsigned char *TableStart,
534 unsigned char *TableEnd,
535 unsigned char* FrameRegister)
537 exception_cb (FrameRegister);
540 class MonoJITEventListener : public JITEventListener {
543 FunctionEmittedCb *emitted_cb;
545 MonoJITEventListener (FunctionEmittedCb *cb) {
549 virtual void NotifyFunctionEmitted(const Function &F,
550 void *Code, size_t Size,
551 const EmittedFunctionDetails &Details) {
552 emitted_cb (wrap (&F), Code, (char*)Code + Size);
559 MonoJITMemoryManager *mm;
560 MonoJITEventListener *listener;
561 FunctionPassManager *fpm;
565 mono_llvm_optimize_method (MonoEERef eeref, LLVMValueRef method)
567 MonoEE *mono_ee = (MonoEE*)eeref;
570 * The verifier does some checks on the whole module, leading to quadratic behavior.
572 //verifyFunction (*(unwrap<Function> (method)));
573 mono_ee->fpm->run (*unwrap<Function> (method));
576 static cl::list<const PassInfo*, bool, PassNameParser>
577 PassList(cl::desc("Optimizations available:"));
580 force_pass_linking (void)
582 // Make sure the rest is linked in, but never executed
583 char *foo = g_getenv ("FOO");
584 gboolean ret = (foo != (char*)-1);
590 // This is a subset of the passes in LinkAllPasses.h
591 // The utility passes and the interprocedural passes are commented out
593 (void) llvm::createAAEvalPass();
594 (void) llvm::createAggressiveDCEPass();
595 (void) llvm::createAliasAnalysisCounterPass();
596 (void) llvm::createAliasDebugger();
598 (void) llvm::createArgumentPromotionPass();
599 (void) llvm::createStructRetPromotionPass();
601 (void) llvm::createBasicAliasAnalysisPass();
602 (void) llvm::createLibCallAliasAnalysisPass(0);
603 (void) llvm::createScalarEvolutionAliasAnalysisPass();
604 //(void) llvm::createBlockPlacementPass();
605 (void) llvm::createBreakCriticalEdgesPass();
606 (void) llvm::createCFGSimplificationPass();
608 (void) llvm::createConstantMergePass();
609 (void) llvm::createConstantPropagationPass();
612 (void) llvm::createDeadArgEliminationPass();
614 (void) llvm::createDeadCodeEliminationPass();
615 (void) llvm::createDeadInstEliminationPass();
616 (void) llvm::createDeadStoreEliminationPass();
618 (void) llvm::createDeadTypeEliminationPass();
619 (void) llvm::createDomOnlyPrinterPass();
620 (void) llvm::createDomPrinterPass();
621 (void) llvm::createDomOnlyViewerPass();
622 (void) llvm::createDomViewerPass();
623 (void) llvm::createEdgeProfilerPass();
624 (void) llvm::createOptimalEdgeProfilerPass();
625 (void) llvm::createFunctionInliningPass();
626 (void) llvm::createAlwaysInlinerPass();
627 (void) llvm::createGlobalDCEPass();
628 (void) llvm::createGlobalOptimizerPass();
629 (void) llvm::createGlobalsModRefPass();
630 (void) llvm::createIPConstantPropagationPass();
631 (void) llvm::createIPSCCPPass();
633 (void) llvm::createIndVarSimplifyPass();
634 (void) llvm::createInstructionCombiningPass();
636 (void) llvm::createInternalizePass(false);
638 (void) llvm::createLCSSAPass();
639 (void) llvm::createLICMPass();
640 (void) llvm::createLazyValueInfoPass();
641 //(void) llvm::createLoopDependenceAnalysisPass();
643 (void) llvm::createLoopExtractorPass();
645 (void) llvm::createLoopSimplifyPass();
646 (void) llvm::createLoopStrengthReducePass();
647 (void) llvm::createLoopUnrollPass();
648 (void) llvm::createLoopUnswitchPass();
649 (void) llvm::createLoopRotatePass();
650 (void) llvm::createLowerInvokePass();
652 (void) llvm::createLowerSetJmpPass();
654 (void) llvm::createLowerSwitchPass();
655 (void) llvm::createNoAAPass();
657 (void) llvm::createNoProfileInfoPass();
658 (void) llvm::createProfileEstimatorPass();
659 (void) llvm::createProfileVerifierPass();
660 (void) llvm::createProfileLoaderPass();
662 (void) llvm::createPromoteMemoryToRegisterPass();
663 (void) llvm::createDemoteRegisterToMemoryPass();
665 (void) llvm::createPruneEHPass();
666 (void) llvm::createPostDomOnlyPrinterPass();
667 (void) llvm::createPostDomPrinterPass();
668 (void) llvm::createPostDomOnlyViewerPass();
669 (void) llvm::createPostDomViewerPass();
671 (void) llvm::createReassociatePass();
672 (void) llvm::createSCCPPass();
673 (void) llvm::createScalarReplAggregatesPass();
674 //(void) llvm::createSimplifyLibCallsPass();
676 (void) llvm::createSingleLoopExtractorPass();
677 (void) llvm::createStripSymbolsPass();
678 (void) llvm::createStripNonDebugSymbolsPass();
679 (void) llvm::createStripDeadDebugInfoPass();
680 (void) llvm::createStripDeadPrototypesPass();
681 (void) llvm::createTailCallEliminationPass();
682 (void) llvm::createTailDuplicationPass();
683 (void) llvm::createJumpThreadingPass();
686 (void) llvm::createUnifyFunctionExitNodesPass();
688 (void) llvm::createInstCountPass();
689 (void) llvm::createCodeGenPreparePass();
690 (void) llvm::createGVNPass();
691 (void) llvm::createMemCpyOptPass();
692 (void) llvm::createLoopDeletionPass();
694 (void) llvm::createPostDomTree();
695 (void) llvm::createPostDomFrontier();
696 (void) llvm::createInstructionNamerPass();
697 (void) llvm::createPartialSpecializationPass();
698 (void) llvm::createFunctionAttrsPass();
699 (void) llvm::createMergeFunctionsPass();
700 (void) llvm::createPrintModulePass(0);
701 (void) llvm::createPrintFunctionPass("", 0);
702 (void) llvm::createDbgInfoPrinterPass();
703 (void) llvm::createModuleDebugInfoPrinterPass();
704 (void) llvm::createPartialInliningPass();
705 (void) llvm::createGEPSplitterPass();
706 (void) llvm::createLintPass();
708 (void) llvm::createSinkingPass();
711 static gboolean inited;
719 force_pass_linking ();
722 LLVMInitializeARMTarget ();
723 LLVMInitializeARMTargetInfo ();
724 LLVMInitializeARMTargetMC ();
725 #elif defined(TARGET_X86) || defined(TARGET_AMD64)
726 LLVMInitializeX86Target ();
727 LLVMInitializeX86TargetInfo ();
728 LLVMInitializeX86TargetMC ();
729 #elif defined(TARGET_POWERPC)
730 LLVMInitializePowerPCTarget ();
731 LLVMInitializePowerPCTargetInfo ();
732 LLVMInitializePowerPCTargetMC ();
734 #error Unsupported mono-llvm target
737 PassRegistry &Registry = *PassRegistry::getPassRegistry();
738 initializeCore(Registry);
739 initializeScalarOpts(Registry);
740 initializeAnalysis(Registry);
741 initializeIPA(Registry);
742 initializeTransformUtils(Registry);
743 initializeInstCombine(Registry);
744 initializeTarget(Registry);
746 llvm::cl::ParseEnvironmentOptions("mono", "MONO_LLVM", "");
752 mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, FunctionEmittedCb *emitted_cb, ExceptionTableCb *exception_cb, DlSymCb *dlsym_cb, LLVMExecutionEngineRef *ee)
759 mono_ee = new MonoEE ();
761 MonoJITMemoryManager *mono_mm = new MonoJITMemoryManager ();
762 mono_mm->alloc_cb = alloc_cb;
763 mono_mm->dlsym_cb = dlsym_cb;
764 mono_mm->exception_cb = exception_cb;
765 mono_ee->mm = mono_mm;
768 * The Default code model doesn't seem to work on amd64,
769 * test_0_fields_with_big_offsets (among others) crashes, because LLVM tries to call
770 * memset using a normal pcrel code which is in 32bit memory, while memset isn't.
774 opts.JITExceptionHandling = 1;
776 StringRef cpu_name = sys::getHostCPUName ();
778 // EngineBuilder no longer has a copy assignment operator (?)
779 std::unique_ptr<Module> Owner(unwrap(MP));
780 EngineBuilder b (std::move(Owner));
781 ExecutionEngine *EE = b.setJITMemoryManager (mono_mm).setTargetOptions (opts).setAllocateGVsWithCode (true).setMCPU (cpu_name).create ();
786 MonoJITEventListener *listener = new MonoJITEventListener (emitted_cb);
787 EE->RegisterJITEventListener (listener);
788 mono_ee->listener = listener;
790 FunctionPassManager *fpm = new FunctionPassManager (unwrap (MP));
793 fpm->add(new DataLayoutPass(*EE->getDataLayout()));
795 if (PassList.size() > 0) {
796 /* Use the passes specified by the env variable */
797 /* Only the passes in force_pass_linking () can be used */
798 for (unsigned i = 0; i < PassList.size(); ++i) {
799 const PassInfo *PassInf = PassList[i];
802 if (PassInf->getNormalCtor())
803 P = PassInf->getNormalCtor()();
807 /* Use the same passes used by 'opt' by default, without the ipo passes */
808 const char *opts = "-simplifycfg -domtree -domfrontier -scalarrepl -instcombine -simplifycfg -domtree -domfrontier -scalarrepl -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";
812 args = g_strsplit (opts, " ", 1000);
813 for (i = 0; args [i]; i++)
815 llvm::cl::ParseCommandLineOptions (i, args, "");
818 for (unsigned i = 0; i < PassList.size(); ++i) {
819 const PassInfo *PassInf = PassList[i];
822 if (PassInf->getNormalCtor())
823 P = PassInf->getNormalCtor()();
824 g_assert (P->getPassKind () == llvm::PT_Function || P->getPassKind () == llvm::PT_Loop);
829 fpm->add(createInstructionCombiningPass());
830 fpm->add(createReassociatePass());
831 fpm->add(createGVNPass());
832 fpm->add(createCFGSimplificationPass());
842 mono_llvm_dispose_ee (MonoEERef *eeref)
844 MonoEE *mono_ee = (MonoEE*)eeref;
848 //delete mono_ee->mm;
849 delete mono_ee->listener;
853 #else /* MONO_CROSS_COMPILE */
856 mono_llvm_set_unhandled_exception_handler (void)
861 mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, FunctionEmittedCb *emitted_cb, ExceptionTableCb *exception_cb, DlSymCb *dlsym_cb, LLVMExecutionEngineRef *ee)
863 g_assert_not_reached ();
868 mono_llvm_optimize_method (MonoEERef eeref, LLVMValueRef method)
870 g_assert_not_reached ();
874 mono_llvm_compile_method (MonoEERef mono_ee, LLVMValueRef method, int nvars, LLVMValueRef *callee_vars, gpointer *callee_addrs, gpointer *eh_frame)
876 g_assert_not_reached ();
881 mono_llvm_dispose_ee (MonoEERef *eeref)
883 g_assert_not_reached ();
888 LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
891 g_assert_not_reached ();
895 LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global)
897 g_assert_not_reached ();
901 #endif /* !MONO_CROSS_COMPILE */