From f01f85481834e3d9cae2d6c757f9b694851c22aa Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Mon, 28 Aug 2017 21:42:39 -0400 Subject: [PATCH] [llvm] Add support for building with more recent versions of the mono llvm branch, in particular https://github.com/mono/llvm/tree/2017-07-06-5a1ffa96376e8a3ee895b782790591e5e7814ccf, which is based on llvm 5.0. (#5408) --- mono/mini/llvm-jit.cpp | 68 +++++++++++++++++++++++++++----- mono/mini/mini-llvm-cpp.cpp | 77 +++++++++++++++++++++++++++++++++++++ mono/mini/mini-llvm-cpp.h | 20 ++++++++++ mono/mini/mini-llvm.c | 75 +++++++++++++++++++----------------- 4 files changed, 196 insertions(+), 44 deletions(-) diff --git a/mono/mini/llvm-jit.cpp b/mono/mini/llvm-jit.cpp index e10f65766c9..e09d72e9192 100644 --- a/mono/mini/llvm-jit.cpp +++ b/mono/mini/llvm-jit.cpp @@ -32,7 +32,13 @@ #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 @@ -121,21 +127,46 @@ 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) + MonoLLVMJIT (TargetMachine *TM, MonoJitMemoryManager *mm) +#if LLVM_API_VERSION >= 500 + : TM(TM), ObjectLayer([=] { return std::shared_ptr (mm); }), +#else : TM(TM), - CompileLayer (ObjectLayer, SimpleCompiler (*TM)) { +#endif + CompileLayer (ObjectLayer, SimpleCompiler (*TM)), + modules() { } - ModuleHandleT addModule(Module *M) { +#if LLVM_API_VERSION >= 500 + ModuleHandleT addModule(Function *F, std::shared_ptr M) { +#else + ModuleHandleT addModule(Function *F, Module *M) { +#endif auto Resolver = createLambdaResolver( [&](const std::string &Name) { const char *name = Name.c_str (); - if (!strcmp (name, "___bzero")) - return RuntimeDyld::SymbolInfo((uint64_t)(gssize)(void*)bzero, (JITSymbolFlags)0); +#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 + } MonoDl *current; char *err; @@ -150,7 +181,11 @@ public: if (!symbol) outs () << "R: " << Name << "\n"; assert (symbol); - return RuntimeDyld::SymbolInfo((uint64_t)(gssize)symbol, (JITSymbolFlags)0); +#if LLVM_API_VERSION >= 500 + return JITSymbol((uint64_t)(gssize)symbol, flags); +#else + return RuntimeDyld::SymbolInfo((uint64_t)(gssize)symbol, flags); +#endif }, [](const std::string &S) { outs () << "R2: " << S << "\n"; @@ -158,9 +193,15 @@ 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) { @@ -186,8 +227,14 @@ public: gpointer compile (Function *F, int nvars, LLVMValueRef *callee_vars, gpointer *callee_addrs, gpointer *eh_frame) { F->getParent ()->setDataLayout (TM->createDataLayout ()); - auto ModuleHandle = addModule (F->getParent ()); - +#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 BodySym = CompileLayer.findSymbolIn(ModuleHandle, mangle (F), false); auto BodyAddr = BodySym.getAddress(); assert (BodyAddr); @@ -213,9 +260,11 @@ 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) @@ -239,7 +288,8 @@ mono_llvm_create_ee (LLVMModuleProviderRef MP, AllocCodeMemoryCb *alloc_cb, Func auto TM = EB.selectTarget (); assert (TM); - jit = new MonoLLVMJIT (TM); + mono_mm = new MonoJitMemoryManager (); + jit = new MonoLLVMJIT (TM, mono_mm); return NULL; } diff --git a/mono/mini/mini-llvm-cpp.cpp b/mono/mini/mini-llvm-cpp.cpp index 8ac2da6b607..6f05177546c 100644 --- a/mono/mini/mini-llvm-cpp.cpp +++ b/mono/mini/mini-llvm-cpp.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include "mini-llvm-cpp.h" @@ -56,7 +57,11 @@ 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 @@ -244,6 +249,71 @@ 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* @@ -257,7 +327,14 @@ 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 67dd9418a7d..53ecc02de1a 100644 --- a/mono/mini/mini-llvm-cpp.h +++ b/mono/mini/mini-llvm-cpp.h @@ -35,6 +35,17 @@ 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); @@ -93,6 +104,15 @@ 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 f072ac56c1e..8a0b622da28 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); - LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); + mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); 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); - LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); + mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); 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); - LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); + mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); 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); - LLVMAddFunctionAttr (func, LLVMNoInlineAttribute); + mono_llvm_add_func_attr (func, LLVM_ATTR_NO_INLINE); 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); - LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute); + mono_llvm_add_func_attr (func, LLVM_ATTR_NO_UNWIND); 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); - LLVMAddFunctionAttr (tramp, LLVMOptimizeForSizeAttribute); - //LLVMAddFunctionAttr (tramp, LLVMNoUnwindAttribute); + mono_llvm_add_func_attr (tramp, LLVM_ATTR_OPTIMIZE_FOR_SIZE); + //mono_llvm_add_func_attr (tramp, LLVM_ATTR_NO_UNWIND); linfo = ctx->linfo; // FIXME: Reduce code duplication with mono_llvm_compile_method () etc. if (!ctx->llvm_only && ctx->rgctx_arg_pindex != -1) - LLVMAddAttribute (LLVMGetParam (tramp, ctx->rgctx_arg_pindex), LLVMInRegAttribute); + mono_llvm_add_param_attr (LLVMGetParam (tramp, ctx->rgctx_arg_pindex), LLVM_ATTR_IN_REG); if (ctx->cfg->vret_addr) { LLVMSetValueName (LLVMGetParam (tramp, linfo->vret_arg_pindex), "vret"); if (linfo->ret.storage == LLVMArgVtypeByRef) { - LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMStructRetAttribute); - LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMNoAliasAttribute); + 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); } } @@ -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) - LLVMAddInstrAttribute (call, 1 + ctx->rgctx_arg_pindex, LLVMInRegAttribute); + mono_llvm_add_instr_attr (call, 1 + ctx->rgctx_arg_pindex, LLVM_ATTR_IN_REG); if (linfo->ret.storage == LLVMArgVtypeByRef) - LLVMAddInstrAttribute (call, 1 + linfo->vret_arg_pindex, LLVMStructRetAttribute); + mono_llvm_add_instr_attr (call, 1 + linfo->vret_arg_pindex, LLVM_ATTR_STRUCT_RET); // 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) - LLVMAddInstrAttribute (lcall, 1 + cinfo->vret_arg_pindex, LLVMStructRetAttribute); + mono_llvm_add_instr_attr (lcall, 1 + cinfo->vret_arg_pindex, LLVM_ATTR_STRUCT_RET); if (!ctx->llvm_only && call->rgctx_arg_reg) - LLVMAddInstrAttribute (lcall, 1 + cinfo->rgctx_arg_pindex, LLVMInRegAttribute); + mono_llvm_add_instr_attr (lcall, 1 + cinfo->rgctx_arg_pindex, LLVM_ATTR_IN_REG); if (call->imt_arg_reg) - LLVMAddInstrAttribute (lcall, 1 + cinfo->imt_arg_pindex, LLVMInRegAttribute); + mono_llvm_add_instr_attr (lcall, 1 + cinfo->imt_arg_pindex, LLVM_ATTR_IN_REG); /* 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) - LLVMAddInstrAttribute (lcall, 1 + ainfo->pindex, LLVMByValAttribute); + mono_llvm_add_instr_attr (lcall, 1 + ainfo->pindex, LLVM_ATTR_BY_VAL); } /* @@ -4011,18 +4011,15 @@ emit_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef builder g_assert (personality); } else { #if LLVM_API_VERSION > 100 - 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); - } + /* 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); #else static gint32 mapping_inited; @@ -6466,7 +6463,11 @@ 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; @@ -6875,7 +6876,7 @@ mono_llvm_emit_method (MonoCompile *cfg) if (cfg->compile_aot) ctx->lmodule = ctx->module->lmodule; else - ctx->lmodule = LLVMModuleCreateWithName ("jit-module"); + ctx->lmodule = LLVMModuleCreateWithName (g_strdup_printf ("jit-module-%s", cfg->method->name)); #else ctx->lmodule = ctx->module->lmodule; #endif @@ -6976,7 +6977,7 @@ emit_method_inner (EmitContext *ctx) LLVMSetFunctionCallConv (method, LLVMMono1CallConv); LLVMSetLinkage (method, LLVMPrivateLinkage); - LLVMAddFunctionAttr (method, LLVMUWTable); + mono_llvm_add_func_attr (method, LLVM_ATTR_UW_TABLE); if (cfg->compile_aot) { LLVMSetLinkage (method, LLVMInternalLinkage); @@ -7016,7 +7017,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 */ - LLVMAddFunctionAttr (method, LLVMNoInlineAttribute); + mono_llvm_add_func_attr (method, LLVM_ATTR_NO_INLINE); if (linfo->rgctx_arg) { ctx->rgctx_arg = LLVMGetParam (method, linfo->rgctx_arg_pindex); @@ -7027,7 +7028,7 @@ emit_method_inner (EmitContext *ctx) * CC_X86_64_Mono in X86CallingConv.td. */ if (!ctx->llvm_only) - LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute); + mono_llvm_add_param_attr (ctx->rgctx_arg, LLVM_ATTR_IN_REG); LLVMSetValueName (ctx->rgctx_arg, "rgctx"); } else { ctx->rgctx_arg_pindex = -1; @@ -7036,8 +7037,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) { - LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMStructRetAttribute); - LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMNoAliasAttribute); + 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); } } @@ -7082,7 +7083,7 @@ emit_method_inner (EmitContext *ctx) LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name); g_free (name); if (ainfo->storage == LLVMArgVtypeByVal) - LLVMAddAttribute (LLVMGetParam (method, pindex), LLVMByValAttribute); + mono_llvm_add_param_attr (LLVMGetParam (method, pindex), LLVM_ATTR_BY_VAL); if (ainfo->storage == LLVMArgVtypeByRef) { /* For OP_LDADDR */ @@ -8215,7 +8216,11 @@ 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 -- 2.25.1