From 8bdd52c8f3595128cbc1da4f23cdb10ff861a6ef Mon Sep 17 00:00:00 2001 From: Tom Stellard Date: Mon, 7 Nov 2016 18:35:09 +0000 Subject: [PATCH] gallivm: Fix build after removal of deprecated attribute API v3 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit v2: Fix adding parameter attributes with LLVM < 4.0. v3: Fix typo. Fix parameter index. Add a gallivm enum for function attributes. Reviewed-by: Nicolai Hähnle --- src/gallium/auxiliary/draw/draw_llvm.c | 6 +- src/gallium/auxiliary/gallivm/lp_bld_intr.c | 70 ++++++++++++++++++- src/gallium/auxiliary/gallivm/lp_bld_intr.h | 17 ++++- .../auxiliary/gallivm/lp_bld_sample_soa.c | 4 +- src/gallium/drivers/radeonsi/si_shader.c | 69 +++++++++--------- .../drivers/radeonsi/si_shader_tgsi_alu.c | 24 +++---- 6 files changed, 138 insertions(+), 52 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index 5b4e2a14aef..ba86b11b178 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -1568,8 +1568,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, LLVMSetFunctionCallConv(variant_func, LLVMCCallConv); for (i = 0; i < num_arg_types; ++i) if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - LLVMAddAttribute(LLVMGetParam(variant_func, i), - LLVMNoAliasAttribute); + lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); context_ptr = LLVMGetParam(variant_func, 0); io_ptr = LLVMGetParam(variant_func, 1); @@ -2193,8 +2192,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, for (i = 0; i < ARRAY_SIZE(arg_types); ++i) if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - LLVMAddAttribute(LLVMGetParam(variant_func, i), - LLVMNoAliasAttribute); + lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); context_ptr = LLVMGetParam(variant_func, 0); input_array = LLVMGetParam(variant_func, 1); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_intr.c b/src/gallium/auxiliary/gallivm/lp_bld_intr.c index f12e735b5ee..049671a09f2 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_intr.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_intr.c @@ -46,6 +46,7 @@ #include "util/u_debug.h" #include "util/u_string.h" +#include "util/bitscan.h" #include "lp_bld_const.h" #include "lp_bld_intr.h" @@ -120,13 +121,73 @@ lp_declare_intrinsic(LLVMModuleRef module, } +#if HAVE_LLVM < 0x0400 +static LLVMAttribute lp_attr_to_llvm_attr(enum lp_func_attr attr) +{ + switch (attr) { + case LP_FUNC_ATTR_ALWAYSINLINE: return LLVMAlwaysInlineAttribute; + case LP_FUNC_ATTR_BYVAL: return LLVMByValAttribute; + case LP_FUNC_ATTR_INREG: return LLVMInRegAttribute; + case LP_FUNC_ATTR_NOALIAS: return LLVMNoAliasAttribute; + case LP_FUNC_ATTR_NOUNWIND: return LLVMNoUnwindAttribute; + case LP_FUNC_ATTR_READNONE: return LLVMReadNoneAttribute; + case LP_FUNC_ATTR_READONLY: return LLVMReadOnlyAttribute; + default: + _debug_printf("Unhandled function attribute: %x\n", attr); + return 0; + } +} + +#else + +static const char *attr_to_str(enum lp_func_attr attr) +{ + switch (attr) { + case LP_FUNC_ATTR_ALWAYSINLINE: return "alwaysinline"; + case LP_FUNC_ATTR_BYVAL: return "byval"; + case LP_FUNC_ATTR_INREG: return "inreg"; + case LP_FUNC_ATTR_NOALIAS: return "noalias"; + case LP_FUNC_ATTR_NOUNWIND: return "nounwind"; + case LP_FUNC_ATTR_READNONE: return "readnone"; + case LP_FUNC_ATTR_READONLY: return "readonly"; + default: + _debug_printf("Unhandled function attribute: %x\n", attr); + return 0; + } +} + +#endif + +void +lp_add_function_attr(LLVMValueRef function, + int attr_idx, + enum lp_func_attr attr) +{ + +#if HAVE_LLVM < 0x0400 + LLVMAttribute llvm_attr = lp_attr_to_llvm_attr(attr); + if (attr_idx == -1) { + LLVMAddFunctionAttr(function, llvm_attr); + } else { + LLVMAddAttribute(LLVMGetParam(function, attr_idx - 1), llvm_attr); + } +#else + LLVMContextRef context = LLVMGetModuleContext(LLVMGetGlobalParent(function)); + const char *attr_name = attr_to_str(attr); + unsigned kind_id = LLVMGetEnumAttributeKindForName(attr_name, + strlen(attr_name)); + LLVMAttributeRef llvm_attr = LLVMCreateEnumAttribute(context, kind_id, 0); + LLVMAddAttributeAtIndex(function, attr_idx, llvm_attr); +#endif +} + LLVMValueRef lp_build_intrinsic(LLVMBuilderRef builder, const char *name, LLVMTypeRef ret_type, LLVMValueRef *args, unsigned num_args, - LLVMAttribute attr) + unsigned attr_mask) { LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder))); LLVMValueRef function; @@ -148,7 +209,12 @@ lp_build_intrinsic(LLVMBuilderRef builder, /* NoUnwind indicates that the intrinsic never raises a C++ exception. * Set it for all intrinsics. */ - LLVMAddFunctionAttr(function, attr | LLVMNoUnwindAttribute); + attr_mask |= LP_FUNC_ATTR_NOUNWIND; + + while (attr_mask) { + enum lp_func_attr attr = 1 << u_bit_scan(&attr_mask); + lp_add_function_attr(function, -1, attr); + } if (gallivm_debug & GALLIVM_DEBUG_IR) { lp_debug_dump_value(function); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_intr.h b/src/gallium/auxiliary/gallivm/lp_bld_intr.h index 7d80ac28f70..f1e075a9b9b 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_intr.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_intr.h @@ -46,6 +46,16 @@ */ #define LP_MAX_FUNC_ARGS 32 +enum lp_func_attr { + LP_FUNC_ATTR_ALWAYSINLINE = (1 << 0), + LP_FUNC_ATTR_BYVAL = (1 << 1), + LP_FUNC_ATTR_INREG = (1 << 2), + LP_FUNC_ATTR_NOALIAS = (1 << 3), + LP_FUNC_ATTR_NOUNWIND = (1 << 4), + LP_FUNC_ATTR_READNONE = (1 << 5), + LP_FUNC_ATTR_READONLY = (1 << 6), + LP_FUNC_ATTR_LAST = (1 << 7) +}; void lp_format_intrinsic(char *name, @@ -60,13 +70,18 @@ lp_declare_intrinsic(LLVMModuleRef module, LLVMTypeRef *arg_types, unsigned num_args); +void +lp_add_function_attr(LLVMValueRef function, + int attr_idx, + enum lp_func_attr attr); + LLVMValueRef lp_build_intrinsic(LLVMBuilderRef builder, const char *name, LLVMTypeRef ret_type, LLVMValueRef *args, unsigned num_args, - LLVMAttribute attr); + unsigned attr_mask); LLVMValueRef diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c index 1477a72d601..939cd43ac48 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c @@ -60,6 +60,7 @@ #include "lp_bld_struct.h" #include "lp_bld_quad.h" #include "lp_bld_pack.h" +#include "lp_bld_intr.h" /** @@ -3316,7 +3317,8 @@ lp_build_sample_soa_func(struct gallivm_state *gallivm, for (i = 0; i < num_param; ++i) { if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) { - LLVMAddAttribute(LLVMGetParam(function, i), LLVMNoAliasAttribute); + + lp_add_function_attr(function, i + 1, LP_FUNC_ATTR_NOALIAS); } } diff --git a/src/gallium/drivers/radeonsi/si_shader.c b/src/gallium/drivers/radeonsi/si_shader.c index b170eb97d48..287b22fad9f 100644 --- a/src/gallium/drivers/radeonsi/si_shader.c +++ b/src/gallium/drivers/radeonsi/si_shader.c @@ -407,7 +407,7 @@ static void declare_input_vs( args[2] = buffer_index; input = lp_build_intrinsic(gallivm->builder, "llvm.SI.vs.load.input", ctx->v4f32, args, 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* Break up the vec4 into individual components */ for (chan = 0; chan < 4; chan++) { @@ -841,7 +841,7 @@ static LLVMValueRef build_buffer_load(struct si_shader_context *ctx, type_names[func]); return lp_build_intrinsic(gallivm->builder, name, types[func], args, - ARRAY_SIZE(args), LLVMReadOnlyAttribute); + ARRAY_SIZE(args), LP_FUNC_ATTR_READONLY); } else { LLVMValueRef args[] = { LLVMBuildBitCast(gallivm->builder, rsrc, ctx->v16i8, ""), @@ -872,7 +872,7 @@ static LLVMValueRef build_buffer_load(struct si_shader_context *ctx, type_names[func], arg_type); return lp_build_intrinsic(gallivm->builder, name, types[func], args, - ARRAY_SIZE(args), LLVMReadOnlyAttribute); + ARRAY_SIZE(args), LP_FUNC_ATTR_READONLY); } } @@ -1159,14 +1159,14 @@ static LLVMValueRef fetch_input_gs( value = lp_build_intrinsic(gallivm->builder, "llvm.SI.buffer.load.dword.i32.i32", ctx->i32, args, 9, - LLVMReadOnlyAttribute); + LP_FUNC_ATTR_READONLY); if (tgsi_type_is_64bit(type)) { LLVMValueRef value2; args[2] = lp_build_const_int32(gallivm, (param * 4 + swizzle + 1) * 256); value2 = lp_build_intrinsic(gallivm->builder, "llvm.SI.buffer.load.dword.i32.i32", ctx->i32, args, 9, - LLVMReadOnlyAttribute); + LP_FUNC_ATTR_READONLY); return si_llvm_emit_fetch_64bit(bld_base, type, value, value2); } @@ -1279,12 +1279,12 @@ static void interp_fs_input(struct si_shader_context *ctx, args[1] = attr_number; front = lp_build_intrinsic(gallivm->builder, intr_name, ctx->f32, args, args[3] ? 4 : 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); args[1] = back_attr_number; back = lp_build_intrinsic(gallivm->builder, intr_name, ctx->f32, args, args[3] ? 4 : 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); result[chan] = LLVMBuildSelect(gallivm->builder, is_face_positive, @@ -1301,7 +1301,7 @@ static void interp_fs_input(struct si_shader_context *ctx, args[3] = interp_param; result[0] = lp_build_intrinsic(gallivm->builder, intr_name, ctx->f32, args, args[3] ? 4 : 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); result[1] = result[2] = lp_build_const_float(gallivm, 0.0f); result[3] = lp_build_const_float(gallivm, 1.0f); @@ -1316,7 +1316,7 @@ static void interp_fs_input(struct si_shader_context *ctx, args[3] = interp_param; result[chan] = lp_build_intrinsic(gallivm->builder, intr_name, ctx->f32, args, args[3] ? 4 : 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } } } @@ -1404,18 +1404,18 @@ static LLVMValueRef get_thread_id(struct si_shader_context *ctx) if (HAVE_LLVM < 0x0308) { tid = lp_build_intrinsic(gallivm->builder, "llvm.SI.tid", - ctx->i32, NULL, 0, LLVMReadNoneAttribute); + ctx->i32, NULL, 0, LP_FUNC_ATTR_READNONE); } else { LLVMValueRef tid_args[2]; tid_args[0] = lp_build_const_int32(gallivm, 0xffffffff); tid_args[1] = lp_build_const_int32(gallivm, 0); tid_args[1] = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.mbcnt.lo", ctx->i32, - tid_args, 2, LLVMReadNoneAttribute); + tid_args, 2, LP_FUNC_ATTR_READNONE); tid = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.mbcnt.hi", ctx->i32, - tid_args, 2, LLVMReadNoneAttribute); + tid_args, 2, LP_FUNC_ATTR_READNONE); } set_range_metadata(ctx, tid, 0, 64); return tid; @@ -1432,7 +1432,7 @@ static LLVMValueRef buffer_load_const(struct si_shader_context *ctx, LLVMValueRef args[2] = {resource, offset}; return lp_build_intrinsic(builder, "llvm.SI.load.const", ctx->f32, args, 2, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } static LLVMValueRef load_sample_position(struct si_shader_context *radeon_bld, LLVMValueRef sample_id) @@ -1670,7 +1670,7 @@ static void declare_system_value( value = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.ps.live", ctx->i1, NULL, 0, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); value = LLVMBuildNot(gallivm->builder, value, ""); value = LLVMBuildSExt(gallivm->builder, value, ctx->i32, ""); break; @@ -1883,7 +1883,7 @@ static void si_llvm_init_export_args(struct lp_build_tgsi_context *bld_base, packed = lp_build_intrinsic(base->gallivm->builder, "llvm.SI.packf16", ctx->i32, pack_args, 2, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); args[chan + 5] = LLVMBuildBitCast(base->gallivm->builder, packed, ctx->f32, ""); @@ -2028,7 +2028,7 @@ static LLVMValueRef si_scale_alpha_by_sample_mask(struct lp_build_tgsi_context * coverage = lp_build_intrinsic(gallivm->builder, "llvm.ctpop.i32", ctx->i32, - &coverage, 1, LLVMReadNoneAttribute); + &coverage, 1, LP_FUNC_ATTR_READNONE); coverage = LLVMBuildUIToFP(gallivm->builder, coverage, ctx->f32, ""); @@ -3469,7 +3469,7 @@ static void load_emit_buffer(struct si_shader_context *ctx, emit_data->output[emit_data->chan] = lp_build_intrinsic( builder, intrinsic_name, dst_type, emit_data->args, emit_data->arg_count, - LLVMReadOnlyAttribute); + LP_FUNC_ATTR_READONLY); } static LLVMValueRef get_memory_ptr(struct si_shader_context *ctx, @@ -3574,7 +3574,7 @@ static void load_emit( lp_build_intrinsic( builder, "llvm.amdgcn.buffer.load.format.v4f32", emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadOnlyAttribute); + LP_FUNC_ATTR_READONLY); } else { get_image_intr_name("llvm.amdgcn.image.load", emit_data->dst_type, /* vdata */ @@ -3586,7 +3586,7 @@ static void load_emit( lp_build_intrinsic( builder, intrinsic_name, emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadOnlyAttribute); + LP_FUNC_ATTR_READONLY); } } @@ -4014,7 +4014,7 @@ static void resq_emit( out = lp_build_intrinsic( builder, "llvm.SI.getresinfo.i32", emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* Divide the number of layers by 6 to get the number of cubes. */ if (inst->Memory.Texture == TGSI_TEXTURE_CUBE_ARRAY) { @@ -4248,7 +4248,7 @@ static void txq_emit(const struct lp_build_tgsi_action *action, emit_data->output[emit_data->chan] = lp_build_intrinsic( base->gallivm->builder, "llvm.SI.getresinfo.i32", emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* Divide the number of layers by 6 to get the number of cubes. */ if (target == TGSI_TEXTURE_CUBE_ARRAY || @@ -4666,7 +4666,7 @@ static void si_lower_gather4_integer(struct si_shader_context *ctx, emit_data->output[emit_data->chan] = lp_build_intrinsic(builder, intr_name, emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } static void build_tex_intrinsic(const struct lp_build_tgsi_action *action, @@ -4690,7 +4690,7 @@ static void build_tex_intrinsic(const struct lp_build_tgsi_action *action, base->gallivm->builder, "llvm.SI.vs.load.input", emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); return; } @@ -4767,7 +4767,7 @@ static void build_tex_intrinsic(const struct lp_build_tgsi_action *action, emit_data->output[emit_data->chan] = lp_build_intrinsic( base->gallivm->builder, intr_name, emit_data->dst_type, emit_data->args, emit_data->arg_count, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } static void si_llvm_emit_txqs( @@ -4865,13 +4865,13 @@ static void si_llvm_emit_ddxy( args[1] = val; tl = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.ds.bpermute", ctx->i32, - args, 2, LLVMReadNoneAttribute); + args, 2, LP_FUNC_ATTR_READNONE); args[0] = LLVMBuildMul(gallivm->builder, trbl_tid, lp_build_const_int32(gallivm, 4), ""); trbl = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.ds.bpermute", ctx->i32, - args, 2, LLVMReadNoneAttribute); + args, 2, LP_FUNC_ATTR_READNONE); } else { LLVMValueRef store_ptr, load_ptr0, load_ptr1; @@ -5054,7 +5054,7 @@ static void build_interp_intrinsic(const struct lp_build_tgsi_action *action, emit_data->output[chan] = lp_build_intrinsic(gallivm->builder, intr_name, ctx->f32, args, args[3] ? 4 : 3, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } } @@ -5223,10 +5223,10 @@ static void si_create_function(struct si_shader_context *ctx, * SGPR spilling significantly. */ if (LLVMGetTypeKind(LLVMTypeOf(P)) == LLVMPointerTypeKind) { - LLVMAddAttribute(P, LLVMByValAttribute); + lp_add_function_attr(ctx->main_fn, i + 1, LP_FUNC_ATTR_BYVAL); lp_add_attr_dereferenceable(P, UINT64_MAX); } else - LLVMAddAttribute(P, LLVMInRegAttribute); + lp_add_function_attr(ctx->main_fn, i + 1, LP_FUNC_ATTR_INREG); } if (ctx->screen->b.debug_flags & DBG_UNSAFE_MATH) { @@ -6177,7 +6177,7 @@ si_generate_gs_copy_shader(struct si_screen *sscreen, lp_build_intrinsic(gallivm->builder, "llvm.SI.buffer.load.dword.i32.i32", ctx.i32, args, 9, - LLVMReadOnlyAttribute), + LP_FUNC_ATTR_READONLY), ctx.f32, ""); } } @@ -6878,7 +6878,7 @@ static void si_build_wrapper_function(struct si_shader_context *ctx, unsigned gprs; for (unsigned i = 0; i < num_parts; ++i) { - LLVMAddFunctionAttr(parts[i], LLVMAlwaysInlineAttribute); + lp_add_function_attr(parts[i], -1, LP_FUNC_ATTR_ALWAYSINLINE); LLVMSetLinkage(parts[i], LLVMPrivateLinkage); } @@ -6989,8 +6989,13 @@ static void si_build_wrapper_function(struct si_shader_context *ctx, is_sgpr = ac_is_sgpr_param(param); if (is_sgpr) { +#if HAVE_LLVM < 0x0400 LLVMRemoveAttribute(param, LLVMByValAttribute); - LLVMAddAttribute(param, LLVMInRegAttribute); +#else + unsigned kind_id = LLVMGetEnumAttributeKindForName("byval", 5); + LLVMRemoveEnumAttributeAtIndex(parts[part], param_idx + 1, kind_id); +#endif + lp_add_function_attr(parts[part], param_idx + 1, LP_FUNC_ATTR_INREG); } assert(out_idx + param_size <= (is_sgpr ? num_out_sgpr : num_out)); diff --git a/src/gallium/drivers/radeonsi/si_shader_tgsi_alu.c b/src/gallium/drivers/radeonsi/si_shader_tgsi_alu.c index 18e905b275b..1966752cc0a 100644 --- a/src/gallium/drivers/radeonsi/si_shader_tgsi_alu.c +++ b/src/gallium/drivers/radeonsi/si_shader_tgsi_alu.c @@ -399,7 +399,7 @@ static void emit_frac(const struct lp_build_tgsi_action *action, LLVMValueRef floor = lp_build_intrinsic(builder, intr, emit_data->dst_type, &emit_data->args[0], 1, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); emit_data->output[emit_data->chan] = LLVMBuildFSub(builder, emit_data->args[0], floor, ""); } @@ -449,7 +449,7 @@ build_tgsi_intrinsic_nomem(const struct lp_build_tgsi_action *action, emit_data->output[emit_data->chan] = lp_build_intrinsic(base->gallivm->builder, action->intr_name, emit_data->dst_type, emit_data->args, - emit_data->arg_count, LLVMReadNoneAttribute); + emit_data->arg_count, LP_FUNC_ATTR_READNONE); } static void emit_bfi(const struct lp_build_tgsi_action *action, @@ -507,7 +507,7 @@ static void emit_bfe(const struct lp_build_tgsi_action *action, bfe_sm5 = lp_build_intrinsic(builder, action->intr_name, emit_data->dst_type, emit_data->args, - emit_data->arg_count, LLVMReadNoneAttribute); + emit_data->arg_count, LP_FUNC_ATTR_READNONE); /* Correct for GLSL semantics. */ cond = LLVMBuildICmp(builder, LLVMIntUGE, emit_data->args[2], @@ -539,7 +539,7 @@ static void emit_lsb(const struct lp_build_tgsi_action *action, LLVMValueRef lsb = lp_build_intrinsic(gallivm->builder, "llvm.cttz.i32", emit_data->dst_type, args, ARRAY_SIZE(args), - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* TODO: We need an intrinsic to skip this conditional. */ /* Check for zero: */ @@ -566,7 +566,7 @@ static void emit_umsb(const struct lp_build_tgsi_action *action, LLVMValueRef msb = lp_build_intrinsic(builder, "llvm.ctlz.i32", emit_data->dst_type, args, ARRAY_SIZE(args), - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* The HW returns the last bit index from MSB, but TGSI wants * the index from LSB. Invert it by doing "31 - msb". */ @@ -593,7 +593,7 @@ static void emit_imsb(const struct lp_build_tgsi_action *action, LLVMValueRef msb = lp_build_intrinsic(builder, "llvm.AMDGPU.flbit.i32", emit_data->dst_type, &arg, 1, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); /* The HW returns the last bit index from MSB, but TGSI wants * the index from LSB. Invert it by doing "31 - msb". */ @@ -917,13 +917,13 @@ static LLVMValueRef build_cube_intrinsic(struct gallivm_state *gallivm, LLVMValueRef out[4]; out[0] = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.cubetc", - f32, in, 3, LLVMReadNoneAttribute); + f32, in, 3, LP_FUNC_ATTR_READNONE); out[1] = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.cubesc", - f32, in, 3, LLVMReadNoneAttribute); + f32, in, 3, LP_FUNC_ATTR_READNONE); out[2] = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.cubema", - f32, in, 3, LLVMReadNoneAttribute); + f32, in, 3, LP_FUNC_ATTR_READNONE); out[3] = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.cubeid", - f32, in, 3, LLVMReadNoneAttribute); + f32, in, 3, LP_FUNC_ATTR_READNONE); return lp_build_gather_values(gallivm, out, 4); } else { @@ -937,7 +937,7 @@ static LLVMValueRef build_cube_intrinsic(struct gallivm_state *gallivm, return lp_build_intrinsic(gallivm->builder, "llvm.AMDGPU.cube", LLVMTypeOf(vec), &vec, 1, - LLVMReadNoneAttribute); + LP_FUNC_ATTR_READNONE); } } @@ -959,7 +959,7 @@ static void si_llvm_cube_to_2d_coords(struct lp_build_tgsi_context *bld_base, lp_build_const_int32(gallivm, i), ""); coords[2] = lp_build_intrinsic(builder, "llvm.fabs.f32", - type, &coords[2], 1, LLVMReadNoneAttribute); + type, &coords[2], 1, LP_FUNC_ATTR_READNONE); coords[2] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_RCP, coords[2]); mad_args[1] = coords[2];