From: Marek Safar Date: Tue, 29 Aug 2017 21:04:53 +0000 (+0200) Subject: Merge pull request #5469 from marek-safar/ilasm X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;h=6649f23b27e947abd19aeb8b12d3a204313ca9ec;hp=5b612c5dc5f2fad700c965ea8c52eb067baf0c02;p=mono.git Merge pull request #5469 from marek-safar/ilasm [ilasm] Adds AggressiveInlining support --- diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c index 364316037ca..8eb4fe5f24e 100644 --- a/mono/metadata/threads.c +++ b/mono/metadata/threads.c @@ -1801,7 +1801,7 @@ mono_join_uninterrupted (MonoThreadHandle* thread_to_join, gint32 ms, MonoError } gboolean -ves_icall_System_Threading_Thread_Join_internal (MonoThread *this_obj, int ms) +ves_icall_System_Threading_Thread_Join_internal(MonoThread *this_obj, int ms) { MonoInternalThread *thread = this_obj->internal_thread; MonoThreadHandle *handle = thread->handle; @@ -1821,39 +1821,30 @@ ves_icall_System_Threading_Thread_Join_internal (MonoThread *this_obj, int ms) return FALSE; } - MonoNativeThreadId tid = thread_get_tid (thread); - UNLOCK_THREAD (thread); - if (ms == -1) - ms = MONO_INFINITE_WAIT; + if(ms== -1) { + ms=MONO_INFINITE_WAIT; + } THREAD_DEBUG (g_message ("%s: joining thread handle %p, %d ms", __func__, handle, ms)); - + mono_thread_set_state (cur_thread, ThreadState_WaitSleepJoin); - ret = mono_join_uninterrupted (handle, ms, &error); + ret=mono_join_uninterrupted (handle, ms, &error); mono_thread_clr_state (cur_thread, ThreadState_WaitSleepJoin); mono_error_set_pending_exception (&error); - if (ret == MONO_THREAD_INFO_WAIT_RET_SUCCESS_0) { + if(ret==MONO_THREAD_INFO_WAIT_RET_SUCCESS_0) { THREAD_DEBUG (g_message ("%s: join successful", __func__)); - /* Wait for the thread to really exit */ - MONO_ENTER_GC_SAFE; - /* This shouldn't block */ - mono_threads_join_lock (); - mono_native_thread_join (tid); - mono_threads_join_unlock (); - MONO_EXIT_GC_SAFE; - - return TRUE; + return(TRUE); } THREAD_DEBUG (g_message ("%s: join failed", __func__)); - return FALSE; + return(FALSE); } #define MANAGED_WAIT_FAILED 0x7fffffff diff --git a/mono/mini/llvm-jit.cpp b/mono/mini/llvm-jit.cpp index e09d72e9192..e10f65766c9 100644 --- a/mono/mini/llvm-jit.cpp +++ b/mono/mini/llvm-jit.cpp @@ -32,13 +32,7 @@ #include "llvm/ExecutionEngine/Orc/CompileUtils.h" #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h" #include "llvm/ExecutionEngine/Orc/LambdaResolver.h" -#if LLVM_API_VERSION >= 500 -#include "llvm/ExecutionEngine/RTDyldMemoryManager.h" -#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h" -#include "llvm/ExecutionEngine/JITSymbol.h" -#else #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h" -#endif #include @@ -127,46 +121,21 @@ MonoJitMemoryManager::finalizeMemory(std::string *ErrMsg) class MonoLLVMJIT { public: /* We use our own trampoline infrastructure instead of the Orc one */ -#if LLVM_API_VERSION >= 500 - typedef RTDyldObjectLinkingLayer ObjLayerT; - typedef IRCompileLayer CompileLayerT; - typedef CompileLayerT::ModuleHandleT ModuleHandleT; -#else typedef ObjectLinkingLayer<> ObjLayerT; typedef IRCompileLayer CompileLayerT; typedef CompileLayerT::ModuleSetHandleT ModuleHandleT; -#endif - MonoLLVMJIT (TargetMachine *TM, MonoJitMemoryManager *mm) -#if LLVM_API_VERSION >= 500 - : TM(TM), ObjectLayer([=] { return std::shared_ptr (mm); }), -#else + MonoLLVMJIT (TargetMachine *TM) : TM(TM), -#endif - CompileLayer (ObjectLayer, SimpleCompiler (*TM)), - modules() { + CompileLayer (ObjectLayer, SimpleCompiler (*TM)) { } -#if LLVM_API_VERSION >= 500 - ModuleHandleT addModule(Function *F, std::shared_ptr M) { -#else - ModuleHandleT addModule(Function *F, Module *M) { -#endif + ModuleHandleT addModule(Module *M) { auto Resolver = createLambdaResolver( [&](const std::string &Name) { const char *name = Name.c_str (); -#if LLVM_API_VERSION >= 500 - JITSymbolFlags flags = JITSymbolFlags (); -#else - JITSymbolFlags flags = (JITSymbolFlags)0; -#endif - if (!strcmp (name, "___bzero")) { -#if LLVM_API_VERSION >= 500 - return JITSymbol((uint64_t)(gssize)(void*)bzero, flags); -#else - return RuntimeDyld::SymbolInfo((uint64_t)(gssize)(void*)bzero, flags); -#endif - } + if (!strcmp (name, "___bzero")) + return RuntimeDyld::SymbolInfo((uint64_t)(gssize)(void*)bzero, (JITSymbolFlags)0); MonoDl *current; char *err; @@ -181,11 +150,7 @@ public: if (!symbol) outs () << "R: " << Name << "\n"; assert (symbol); -#if LLVM_API_VERSION >= 500 - return JITSymbol((uint64_t)(gssize)symbol, flags); -#else - return RuntimeDyld::SymbolInfo((uint64_t)(gssize)symbol, flags); -#endif + return RuntimeDyld::SymbolInfo((uint64_t)(gssize)symbol, (JITSymbolFlags)0); }, [](const std::string &S) { outs () << "R2: " << S << "\n"; @@ -193,15 +158,9 @@ public: return nullptr; } ); -#if LLVM_API_VERSION >= 500 - ModuleHandleT m = CompileLayer.addModule(M, - std::move(Resolver)); - return m; -#else return CompileLayer.addModuleSet(singletonSet(M), make_unique(), std::move(Resolver)); -#endif } std::string mangle(const std::string &Name) { @@ -227,14 +186,8 @@ public: gpointer compile (Function *F, int nvars, LLVMValueRef *callee_vars, gpointer *callee_addrs, gpointer *eh_frame) { F->getParent ()->setDataLayout (TM->createDataLayout ()); -#if LLVM_API_VERSION >= 500 - // Orc uses a shared_ptr to refer to modules so we have to save them ourselves to keep a ref - std::shared_ptr m (F->getParent ()); - modules.push_back (m); - auto ModuleHandle = addModule (F, m); -#else - auto ModuleHandle = addModule (F, F->getParent ()); -#endif + auto ModuleHandle = addModule (F->getParent ()); + auto BodySym = CompileLayer.findSymbolIn(ModuleHandle, mangle (F), false); auto BodyAddr = BodySym.getAddress(); assert (BodyAddr); @@ -260,11 +213,9 @@ private: TargetMachine *TM; ObjLayerT ObjectLayer; CompileLayerT CompileLayer; - std::vector> modules; }; static MonoLLVMJIT *jit; -static MonoJitMemoryManager *mono_mm; MonoEERef mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, FunctionEmittedCb *emitted_cb, ExceptionTableCb *exception_cb, DlSymCb *dlsym_cb, LLVMExecutionEngineRef *ee) @@ -288,8 +239,7 @@ mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, Func auto TM = EB.selectTarget (); assert (TM); - mono_mm = new MonoJitMemoryManager (); - jit = new MonoLLVMJIT (TM, mono_mm); + jit = new MonoLLVMJIT (TM); return NULL; } diff --git a/mono/mini/mini-llvm-cpp.cpp b/mono/mini/mini-llvm-cpp.cpp index 6f05177546c..8ac2da6b607 100644 --- a/mono/mini/mini-llvm-cpp.cpp +++ b/mono/mini/mini-llvm-cpp.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include "mini-llvm-cpp.h" @@ -57,11 +56,7 @@ mono_llvm_build_alloca (LLVMBuilderRef builder, LLVMTypeRef Ty, LLVMValueRef ArraySize, int alignment, const char *Name) { -#if LLVM_API_VERSION >= 500 - return wrap (unwrap (builder)->Insert (new AllocaInst (unwrap (Ty), 0, unwrap (ArraySize), alignment), Name)); -#else return wrap (unwrap (builder)->Insert (new AllocaInst (unwrap (Ty), unwrap (ArraySize), alignment), Name)); -#endif } LLVMValueRef @@ -249,71 +244,6 @@ mono_llvm_set_call_notail (LLVMValueRef func) #endif } -static Attribute::AttrKind -convert_attr (AttrKind kind) -{ - switch (kind) { - case LLVM_ATTR_NO_UNWIND: - return Attribute::NoUnwind; - case LLVM_ATTR_NO_INLINE: - return Attribute::NoInline; - case LLVM_ATTR_OPTIMIZE_FOR_SIZE: - return Attribute::OptimizeForSize; - case LLVM_ATTR_IN_REG: - return Attribute::InReg; - case LLVM_ATTR_STRUCT_RET: - return Attribute::StructRet; - case LLVM_ATTR_NO_ALIAS: - return Attribute::NoAlias; - case LLVM_ATTR_BY_VAL: - return Attribute::ByVal; - case LLVM_ATTR_UW_TABLE: - return Attribute::UWTable; - default: - assert (0); - return Attribute::NoUnwind; - } -} - -void -mono_llvm_add_func_attr (LLVMValueRef func, AttrKind kind) -{ -#if LLVM_API_VERSION > 100 - unwrap (func)->addAttribute (AttributeList::FunctionIndex, convert_attr (kind)); -#else - unwrap (func)->addFnAttr (convert_attr (kind)); -#endif -} - -void -mono_llvm_add_param_attr (LLVMValueRef param, AttrKind kind) -{ -#if LLVM_API_VERSION > 100 - Function *func = unwrap (param)->getParent (); - int n = unwrap (param)->getArgNo (); - func->addParamAttr (n, convert_attr (kind)); -#else - Argument *A = unwrap(param); - AttrBuilder B(convert_attr (kind)); - A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); -#endif -} - -void -mono_llvm_add_instr_attr (LLVMValueRef val, int index, AttrKind kind) -{ -#if LLVM_API_VERSION > 100 - CallSite (unwrap (val)).addAttribute (index, convert_attr (kind)); -#else - CallSite Call = CallSite(unwrap(val)); - AttrBuilder B(convert_attr (kind)); - Call.setAttributes( - Call.getAttributes().addAttributes(Call->getContext(), index, - AttributeSet::get(Call->getContext(), - index, B))); -#endif -} - #if LLVM_API_VERSION > 100 void* @@ -327,14 +257,7 @@ mono_llvm_di_create_compile_unit (void *di_builder, const char *cu_name, const c { DIBuilder *builder = (DIBuilder*)di_builder; -#if LLVM_API_VERSION >= 500 - DIFile *di_file; - - di_file = builder->createFile (cu_name, dir); - return builder->createCompileUnit (dwarf::DW_LANG_C99, di_file, producer, true, "", 0); -#else return builder->createCompileUnit (dwarf::DW_LANG_C99, cu_name, dir, producer, true, "", 0); -#endif } void* diff --git a/mono/mini/mini-llvm-cpp.h b/mono/mini/mini-llvm-cpp.h index 53ecc02de1a..67dd9418a7d 100644 --- a/mono/mini/mini-llvm-cpp.h +++ b/mono/mini/mini-llvm-cpp.h @@ -35,17 +35,6 @@ typedef enum { LLVM_ATOMICRMW_OP_ADD = 1, } AtomicRMWOp; -typedef enum { - LLVM_ATTR_NO_UNWIND, - LLVM_ATTR_NO_INLINE, - LLVM_ATTR_OPTIMIZE_FOR_SIZE, - LLVM_ATTR_IN_REG, - LLVM_ATTR_STRUCT_RET, - LLVM_ATTR_NO_ALIAS, - LLVM_ATTR_BY_VAL, - LLVM_ATTR_UW_TABLE -} AttrKind; - void mono_llvm_dump_value (LLVMValueRef value); @@ -104,15 +93,6 @@ mono_llvm_set_call_preserveall_cc (LLVMValueRef call); void mono_llvm_set_call_notail (LLVMValueRef call); -void -mono_llvm_add_func_attr (LLVMValueRef func, AttrKind kind); - -void -mono_llvm_add_param_attr (LLVMValueRef param, AttrKind kind); - -void -mono_llvm_add_instr_attr (LLVMValueRef val, int index, AttrKind kind); - _Unwind_Reason_Code mono_debug_personality (int a, _Unwind_Action b, uint64_t c, struct _Unwind_Exception *d, struct _Unwind_Context *e); diff --git a/mono/mini/mini-llvm.c b/mono/mini/mini-llvm.c index 8a0b622da28..f072ac56c1e 100644 --- a/mono/mini/mini-llvm.c +++ b/mono/mini/mini-llvm.c @@ -2465,7 +2465,7 @@ emit_get_method (MonoLLVMModule *module) func = LLVMAddFunction (lmodule, module->get_method_symbol, LLVMFunctionType1 (rtype, LLVMInt32Type (), FALSE)); LLVMSetLinkage (func, LLVMExternalLinkage); LLVMSetVisibility (func, LLVMHiddenVisibility); - mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); + LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); module->get_method = func; entry_bb = LLVMAppendBasicBlock (func, "ENTRY"); @@ -2545,7 +2545,7 @@ emit_get_unbox_tramp (MonoLLVMModule *module) func = LLVMAddFunction (lmodule, module->get_unbox_tramp_symbol, LLVMFunctionType1 (rtype, LLVMInt32Type (), FALSE)); LLVMSetLinkage (func, LLVMExternalLinkage); LLVMSetVisibility (func, LLVMHiddenVisibility); - mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); + LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); module->get_unbox_tramp = func; entry_bb = LLVMAppendBasicBlock (func, "ENTRY"); @@ -2596,7 +2596,7 @@ emit_llvm_code_start (MonoLLVMModule *module) func = LLVMAddFunction (lmodule, "llvm_code_start", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE)); LLVMSetLinkage (func, LLVMInternalLinkage); - mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); + LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); module->code_start = func; entry_bb = LLVMAppendBasicBlock (func, "ENTRY"); builder = LLVMCreateBuilder (); @@ -2635,7 +2635,7 @@ emit_init_icall_wrapper (MonoLLVMModule *module, const char *name, const char *i g_assert_not_reached (); } LLVMSetLinkage (func, LLVMInternalLinkage); - mono_llvm_add_func_attr (func, LLVM_ATTR_NO_INLINE); + LLVMAddFunctionAttr (func, LLVMNoInlineAttribute); mono_llvm_set_preserveall_cc (func); entry_bb = LLVMAppendBasicBlock (func, "ENTRY"); builder = LLVMCreateBuilder (); @@ -2704,7 +2704,7 @@ emit_llvm_code_end (MonoLLVMModule *module) func = LLVMAddFunction (lmodule, "llvm_code_end", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE)); LLVMSetLinkage (func, LLVMInternalLinkage); - mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); + LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); module->code_end = func; entry_bb = LLVMAppendBasicBlock (func, "ENTRY"); builder = LLVMCreateBuilder (); @@ -2857,17 +2857,17 @@ emit_unbox_tramp (EmitContext *ctx, const char *method_name, LLVMTypeRef method_ tramp_name = g_strdup_printf ("ut_%s", method_name); tramp = LLVMAddFunction (ctx->module->lmodule, tramp_name, method_type); LLVMSetLinkage (tramp, LLVMInternalLinkage); - mono_llvm_add_func_attr (tramp, LLVM_ATTR_OPTIMIZE_FOR_SIZE); - //mono_llvm_add_func_attr (tramp, LLVM_ATTR_NO_UNWIND); + LLVMAddFunctionAttr (tramp, LLVMOptimizeForSizeAttribute); + //LLVMAddFunctionAttr (tramp, LLVMNoUnwindAttribute); linfo = ctx->linfo; // FIXME: Reduce code duplication with mono_llvm_compile_method () etc. if (!ctx->llvm_only && ctx->rgctx_arg_pindex != -1) - mono_llvm_add_param_attr (LLVMGetParam (tramp, ctx->rgctx_arg_pindex), LLVM_ATTR_IN_REG); + LLVMAddAttribute (LLVMGetParam (tramp, ctx->rgctx_arg_pindex), LLVMInRegAttribute); if (ctx->cfg->vret_addr) { LLVMSetValueName (LLVMGetParam (tramp, linfo->vret_arg_pindex), "vret"); if (linfo->ret.storage == LLVMArgVtypeByRef) { - mono_llvm_add_param_attr (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVM_ATTR_STRUCT_RET); - mono_llvm_add_param_attr (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVM_ATTR_NO_ALIAS); + LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMStructRetAttribute); + LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMNoAliasAttribute); } } @@ -2889,9 +2889,9 @@ emit_unbox_tramp (EmitContext *ctx, const char *method_name, LLVMTypeRef method_ } call = LLVMBuildCall (builder, method, args, nargs, ""); if (!ctx->llvm_only && ctx->rgctx_arg_pindex != -1) - mono_llvm_add_instr_attr (call, 1 + ctx->rgctx_arg_pindex, LLVM_ATTR_IN_REG); + LLVMAddInstrAttribute (call, 1 + ctx->rgctx_arg_pindex, LLVMInRegAttribute); if (linfo->ret.storage == LLVMArgVtypeByRef) - mono_llvm_add_instr_attr (call, 1 + linfo->vret_arg_pindex, LLVM_ATTR_STRUCT_RET); + LLVMAddInstrAttribute (call, 1 + linfo->vret_arg_pindex, LLVMStructRetAttribute); // FIXME: This causes assertions in clang //mono_llvm_set_must_tail (call); @@ -3541,18 +3541,18 @@ process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, mono_llvm_set_call_preserveall_cc (lcall); if (cinfo->ret.storage == LLVMArgVtypeByRef) - mono_llvm_add_instr_attr (lcall, 1 + cinfo->vret_arg_pindex, LLVM_ATTR_STRUCT_RET); + LLVMAddInstrAttribute (lcall, 1 + cinfo->vret_arg_pindex, LLVMStructRetAttribute); if (!ctx->llvm_only && call->rgctx_arg_reg) - mono_llvm_add_instr_attr (lcall, 1 + cinfo->rgctx_arg_pindex, LLVM_ATTR_IN_REG); + LLVMAddInstrAttribute (lcall, 1 + cinfo->rgctx_arg_pindex, LLVMInRegAttribute); if (call->imt_arg_reg) - mono_llvm_add_instr_attr (lcall, 1 + cinfo->imt_arg_pindex, LLVM_ATTR_IN_REG); + LLVMAddInstrAttribute (lcall, 1 + cinfo->imt_arg_pindex, LLVMInRegAttribute); /* Add byval attributes if needed */ for (i = 0; i < sig->param_count; ++i) { LLVMArgInfo *ainfo = &call->cinfo->args [i + sig->hasthis]; if (ainfo && ainfo->storage == LLVMArgVtypeByVal) - mono_llvm_add_instr_attr (lcall, 1 + ainfo->pindex, LLVM_ATTR_BY_VAL); + LLVMAddInstrAttribute (lcall, 1 + ainfo->pindex, LLVMByValAttribute); } /* @@ -4011,15 +4011,18 @@ emit_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef builder g_assert (personality); } else { #if LLVM_API_VERSION > 100 - /* Can't cache this as each method is in its own llvm module */ - LLVMTypeRef personality_type = LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE); - personality = LLVMAddFunction (ctx->lmodule, "mono_personality", personality_type); - mono_llvm_add_func_attr (personality, LLVM_ATTR_NO_UNWIND); - LLVMBasicBlockRef entry_bb = LLVMAppendBasicBlock (personality, "ENTRY"); - LLVMBuilderRef builder2 = LLVMCreateBuilder (); - LLVMPositionBuilderAtEnd (builder2, entry_bb); - LLVMBuildRet (builder2, LLVMConstInt (LLVMInt32Type (), 0, FALSE)); - LLVMDisposeBuilder (builder2); + personality = ctx->module->personality; + if (!personality) { + LLVMTypeRef personality_type = LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE); + personality = LLVMAddFunction (ctx->lmodule, "mono_personality", personality_type); + LLVMAddFunctionAttr (personality, LLVMNoUnwindAttribute); + LLVMBasicBlockRef entry_bb = LLVMAppendBasicBlock (personality, "ENTRY"); + LLVMBuilderRef builder2 = LLVMCreateBuilder (); + LLVMPositionBuilderAtEnd (builder2, entry_bb); + LLVMBuildRet (builder2, LLVMConstInt (LLVMInt32Type (), 0, FALSE)); + ctx->module->personality = personality; + LLVMDisposeBuilder (builder2); + } #else static gint32 mapping_inited; @@ -6463,11 +6466,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) args [0] = lhs; args [1] = rhs; /* 0xf1 == multiply all 4 elements, add them together, and store the result to the lowest element */ -#if LLVM_API_VERSION >= 500 - args [2] = LLVMConstInt (LLVMInt8Type (), 0xf1, FALSE); -#else args [2] = LLVMConstInt (LLVMInt32Type (), 0xf1, FALSE); -#endif values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 3, dname); break; @@ -6876,7 +6875,7 @@ mono_llvm_emit_method (MonoCompile *cfg) if (cfg->compile_aot) ctx->lmodule = ctx->module->lmodule; else - ctx->lmodule = LLVMModuleCreateWithName (g_strdup_printf ("jit-module-%s", cfg->method->name)); + ctx->lmodule = LLVMModuleCreateWithName ("jit-module"); #else ctx->lmodule = ctx->module->lmodule; #endif @@ -6977,7 +6976,7 @@ emit_method_inner (EmitContext *ctx) LLVMSetFunctionCallConv (method, LLVMMono1CallConv); LLVMSetLinkage (method, LLVMPrivateLinkage); - mono_llvm_add_func_attr (method, LLVM_ATTR_UW_TABLE); + LLVMAddFunctionAttr (method, LLVMUWTable); if (cfg->compile_aot) { LLVMSetLinkage (method, LLVMInternalLinkage); @@ -7017,7 +7016,7 @@ emit_method_inner (EmitContext *ctx) } if (header->num_clauses || (cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_NOINLINING) || cfg->no_inline) /* We can't handle inlined methods with clauses */ - mono_llvm_add_func_attr (method, LLVM_ATTR_NO_INLINE); + LLVMAddFunctionAttr (method, LLVMNoInlineAttribute); if (linfo->rgctx_arg) { ctx->rgctx_arg = LLVMGetParam (method, linfo->rgctx_arg_pindex); @@ -7028,7 +7027,7 @@ emit_method_inner (EmitContext *ctx) * CC_X86_64_Mono in X86CallingConv.td. */ if (!ctx->llvm_only) - mono_llvm_add_param_attr (ctx->rgctx_arg, LLVM_ATTR_IN_REG); + LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute); LLVMSetValueName (ctx->rgctx_arg, "rgctx"); } else { ctx->rgctx_arg_pindex = -1; @@ -7037,8 +7036,8 @@ emit_method_inner (EmitContext *ctx) values [cfg->vret_addr->dreg] = LLVMGetParam (method, linfo->vret_arg_pindex); LLVMSetValueName (values [cfg->vret_addr->dreg], "vret"); if (linfo->ret.storage == LLVMArgVtypeByRef) { - mono_llvm_add_param_attr (LLVMGetParam (method, linfo->vret_arg_pindex), LLVM_ATTR_STRUCT_RET); - mono_llvm_add_param_attr (LLVMGetParam (method, linfo->vret_arg_pindex), LLVM_ATTR_NO_ALIAS); + LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMStructRetAttribute); + LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMNoAliasAttribute); } } @@ -7083,7 +7082,7 @@ emit_method_inner (EmitContext *ctx) LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name); g_free (name); if (ainfo->storage == LLVMArgVtypeByVal) - mono_llvm_add_param_attr (LLVMGetParam (method, pindex), LLVM_ATTR_BY_VAL); + LLVMAddAttribute (LLVMGetParam (method, pindex), LLVMByValAttribute); if (ainfo->storage == LLVMArgVtypeByRef) { /* For OP_LDADDR */ @@ -8216,11 +8215,7 @@ add_intrinsic (LLVMModuleRef module, int id) ret_type = type_to_simd_type (MONO_TYPE_R4); arg_types [0] = type_to_simd_type (MONO_TYPE_R4); arg_types [1] = type_to_simd_type (MONO_TYPE_R4); -#if LLVM_API_VERSION >= 500 - arg_types [2] = LLVMInt8Type (); -#else arg_types [2] = LLVMInt32Type (); -#endif AddFunc (module, name, ret_type, arg_types, 3); break; #endif