From af20d46a39e4431b85d593f56912a185a157554e Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:14:48 +0300 Subject: [PATCH 01/22] gallium: add opaque pointers shim for LLVM < 8.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit LLVM is transitioning to "opaque pointers", and as such deprecates LLVMBuildGEP, LLVMBuildCall, LLVMBuildLoad, replacing them with LLVMBuildGEP2, LLVMBuildCall2, LLVMBuildLoad2 respectivelly. These new functions were added in LLVM 8.0; so for LLVM before 8.0 we simply forward to the non-opaque-pointer variants. Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld.h | 42 ++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/src/gallium/auxiliary/gallivm/lp_bld.h b/src/gallium/auxiliary/gallivm/lp_bld.h index 9144428c8e162..5846afa3ce065 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld.h +++ b/src/gallium/auxiliary/gallivm/lp_bld.h @@ -87,4 +87,46 @@ #define GALLIVM_HAVE_CORO 0 #endif +/* LLVM is transitioning to "opaque pointers", and as such deprecates + * LLVMBuildGEP, LLVMBuildCall, LLVMBuildLoad, replacing them with + * LLVMBuildGEP2, LLVMBuildCall2, LLVMBuildLoad2 respectivelly. + * These new functions were added in LLVM 8.0; so for LLVM before 8.0 we + * simply forward to the non-opaque-pointer variants. + */ +#if LLVM_VERSION_MAJOR < 8 + +static inline LLVMValueRef +LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, + LLVMValueRef Pointer, LLVMValueRef *Indices, + unsigned NumIndices, const char *Name) +{ + return LLVMBuildGEP(B, Pointer, Indices, NumIndices, Name); +} + +static inline LLVMValueRef +LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, + LLVMValueRef Pointer, LLVMValueRef *Indices, + unsigned NumIndices, const char *Name) +{ + return LLVMBuildInBoundsGEP(B, Pointer, Indices, NumIndices, Name); +} + +static inline LLVMValueRef +LLVMBuildLoad2(LLVMBuilderRef B, LLVMTypeRef Ty, + LLVMValueRef PointerVal, const char *Name) +{ + LLVMValueRef val = LLVMBuildLoad(B, PointerVal, Name); + return LLVMTypeOf(val) == Ty ? val : LLVMBuildBitCast(B, val, Ty, Name); +} + +static inline LLVMValueRef +LLVMBuildCall2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn, + LLVMValueRef *Args, unsigned NumArgs, + const char *Name) +{ + return LLVMBuildCall(B, Fn, Args, NumArgs, Name); +} + +#endif /* LLVM_VERSION_MAJOR < 8 */ + #endif /* LP_BLD_H */ -- GitLab From eb9a65c91422eb765df80693b2220f625404468c Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:20:01 +0300 Subject: [PATCH 02/22] gallium: use LLVM opaque pointers in draw_llvm.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/draw/draw_llvm.c | 150 ++++++++++++------------- src/gallium/auxiliary/draw/draw_llvm.h | 7 ++ 2 files changed, 81 insertions(+), 76 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index 5e5ce53a3ab79..1f68170d99e03 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -639,14 +639,13 @@ create_tcs_jit_output_type(struct gallivm_state *gallivm) } static LLVMTypeRef -create_tes_jit_input_type(struct gallivm_state *gallivm) +create_tes_jit_input_deref_type(struct gallivm_state *gallivm) { LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); LLVMTypeRef input_array; input_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */ input_array = LLVMArrayType(input_array, PIPE_MAX_SHADER_INPUTS); /* num attrs per vertex */ - input_array = LLVMPointerType(input_array, 0); /* num vertices per prim */ return input_array; } @@ -721,8 +720,7 @@ static void create_jit_types(struct draw_llvm_variant *variant) { struct gallivm_state *gallivm = variant->gallivm; - LLVMTypeRef texture_type, sampler_type, context_type, buffer_type, - vb_type, image_type; + LLVMTypeRef texture_type, sampler_type, context_type, image_type; texture_type = create_jit_texture_type(gallivm, "texture"); sampler_type = create_jit_sampler_type(gallivm, "sampler"); @@ -733,11 +731,11 @@ create_jit_types(struct draw_llvm_variant *variant) "draw_jit_context"); variant->context_ptr_type = LLVMPointerType(context_type, 0); - buffer_type = create_jit_dvbuffer_type(gallivm, "draw_vertex_buffer"); - variant->buffer_ptr_type = LLVMPointerType(buffer_type, 0); + variant->buffer_type = create_jit_dvbuffer_type(gallivm, "draw_vertex_buffer"); + variant->buffer_ptr_type = LLVMPointerType(variant->buffer_type, 0); - vb_type = create_jit_vertex_buffer_type(gallivm, "pipe_vertex_buffer"); - variant->vb_ptr_type = LLVMPointerType(vb_type, 0); + variant->vb_type = create_jit_vertex_buffer_type(gallivm, "pipe_vertex_buffer"); + variant->vb_ptr_type = LLVMPointerType(variant->vb_type, 0); } @@ -770,8 +768,7 @@ get_vb_ptr_type(struct draw_llvm_variant *variant) static LLVMTypeRef get_vertex_header_ptr_type(struct draw_llvm_variant *variant) { - if (!variant->vertex_header_ptr_type) - create_jit_types(variant); + assert(variant->vertex_header_ptr_type); return variant->vertex_header_ptr_type; } @@ -871,7 +868,6 @@ draw_llvm_create_variant(struct draw_llvm *llvm, struct draw_llvm_variant *variant; struct llvm_vertex_shader *shader = llvm_vertex_shader(llvm->draw->vs.vertex_shader); - LLVMTypeRef vertex_header; char module_name[64]; unsigned char ir_sha1_cache_key[20]; struct lp_cached_code cached = { 0 }; @@ -914,9 +910,8 @@ draw_llvm_create_variant(struct draw_llvm *llvm, draw_llvm_dump_variant_key(&variant->key); } - vertex_header = create_jit_vertex_header(variant->gallivm, num_inputs); - - variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0); + variant->vertex_header_type = create_jit_vertex_header(variant->gallivm, num_inputs); + variant->vertex_header_ptr_type = LLVMPointerType(variant->vertex_header_type, 0); draw_llvm_generate(llvm, variant); @@ -957,7 +952,7 @@ do_clamp_vertex_color(struct gallivm_state *gallivm, switch (info->output_semantic_name[attrib]) { case TGSI_SEMANTIC_COLOR: case TGSI_SEMANTIC_BCOLOR: - out = LLVMBuildLoad(builder, outputs[attrib][chan], ""); + out = LLVMBuildLoad2(builder, LLVMTypeOf(bld.zero), outputs[attrib][chan], ""); out = lp_build_clamp(&bld, out, bld.zero, bld.one); LLVMBuildStore(builder, out, outputs[attrib][chan]); break; @@ -1393,7 +1388,6 @@ store_clip(struct gallivm_state *gallivm, LLVMBuilderRef builder = gallivm->builder; LLVMValueRef soa[4]; LLVMValueRef aos[LP_MAX_VECTOR_LENGTH]; - LLVMValueRef indices[2]; LLVMValueRef io_ptrs[LP_MAX_VECTOR_WIDTH / 32]; LLVMValueRef inds[LP_MAX_VECTOR_WIDTH / 32]; LLVMValueRef clip_ptrs[LP_MAX_VECTOR_WIDTH / 32]; @@ -1402,9 +1396,6 @@ store_clip(struct gallivm_state *gallivm, 4), 0); int i, j; - indices[0] = - indices[1] = lp_build_const_int32(gallivm, 0); - for (i = 0; i < vs_type.length; i++) { inds[i] = lp_build_const_int32(gallivm, i); io_ptrs[i] = LLVMBuildGEP(builder, io_ptr, &inds[i], 1, ""); @@ -1430,8 +1421,7 @@ store_clip(struct gallivm_state *gallivm, for (j = 0; j < vs_type.length; j++) { LLVMValueRef clip_ptr; - clip_ptr = LLVMBuildGEP(builder, clip_ptrs[j], indices, 2, "clipo"); - clip_ptr = LLVMBuildPointerCast(builder, clip_ptr, clip_ptr_type, ""); + clip_ptr = LLVMBuildPointerCast(builder, clip_ptrs[j], clip_ptr_type, ""); /* Unaligned store */ LLVMSetAlignment(LLVMBuildStore(builder, aos[j], clip_ptr), sizeof(float)); @@ -1454,7 +1444,7 @@ generate_viewport(struct draw_llvm_variant *variant, struct lp_type f32_type = vs_type; const unsigned pos = variant->llvm->draw->vs.position_output; LLVMTypeRef vs_type_llvm = lp_build_vec_type(gallivm, vs_type); - LLVMValueRef out3 = LLVMBuildLoad(builder, outputs[pos][3], ""); /*w0 w1 .. wn*/ + LLVMValueRef out3 = LLVMBuildLoad2(builder, vs_type_llvm, outputs[pos][3], ""); /*w0 w1 .. wn*/ LLVMValueRef const1 = lp_build_const_vec(gallivm, f32_type, 1.0); /*1.0 1.0 1.0 1.0*/ LLVMValueRef vp_ptr = draw_jit_context_viewports(gallivm, context_ptr); @@ -1466,9 +1456,11 @@ generate_viewport(struct draw_llvm_variant *variant, out3 = LLVMBuildFDiv(builder, const1, out3, ""); LLVMBuildStore(builder, out3, outputs[pos][3]); + LLVMTypeRef elem_type = lp_build_elem_type(gallivm, vs_type); + /* Viewport Mapping */ for (i=0; i<3; i++) { - LLVMValueRef out = LLVMBuildLoad(builder, outputs[pos][i], ""); /*x0 x1 .. xn*/ + LLVMValueRef out = LLVMBuildLoad2(builder, vs_type_llvm, outputs[pos][i], ""); /*x0 x1 .. xn*/ LLVMValueRef scale; LLVMValueRef trans; LLVMValueRef scale_i; @@ -1476,15 +1468,15 @@ generate_viewport(struct draw_llvm_variant *variant, LLVMValueRef index; index = lp_build_const_int32(gallivm, i + scale_index_offset); - scale_i = LLVMBuildGEP(builder, vp_ptr, &index, 1, ""); + scale_i = LLVMBuildGEP2(builder, elem_type, vp_ptr, &index, 1, ""); index = lp_build_const_int32(gallivm, i + trans_index_offset); - trans_i = LLVMBuildGEP(builder, vp_ptr, &index, 1, ""); + trans_i = LLVMBuildGEP2(builder, elem_type, vp_ptr, &index, 1, ""); scale = lp_build_broadcast(gallivm, vs_type_llvm, - LLVMBuildLoad(builder, scale_i, "scale")); + LLVMBuildLoad2(builder, elem_type, scale_i, "scale")); trans = lp_build_broadcast(gallivm, vs_type_llvm, - LLVMBuildLoad(builder, trans_i, "trans")); + LLVMBuildLoad2(builder, elem_type, trans_i, "trans")); /* divide by w */ out = LLVMBuildFMul(builder, out, out3, ""); @@ -1543,20 +1535,22 @@ generate_clipmask(struct draw_llvm *llvm, zero = lp_build_const_vec(gallivm, f32_type, 0); /* 0.0f 0.0f 0.0f 0.0f */ shift = lp_build_const_int_vec(gallivm, i32_type, 1); /* 1 1 1 1 */ + LLVMTypeRef vec_type = LLVMTypeOf(zero); + /* * load clipvertex and position from correct locations. * if they are the same just load them once. */ - pos_x = LLVMBuildLoad(builder, outputs[pos][0], ""); /*x0 x1 .. xn */ - pos_y = LLVMBuildLoad(builder, outputs[pos][1], ""); /*y0 y1 .. yn */ - pos_z = LLVMBuildLoad(builder, outputs[pos][2], ""); /*z0 z1 .. zn */ - pos_w = LLVMBuildLoad(builder, outputs[pos][3], ""); /*w0 w1 .. wn */ + pos_x = LLVMBuildLoad2(builder, vec_type, outputs[pos][0], ""); /*x0 x1 .. xn */ + pos_y = LLVMBuildLoad2(builder, vec_type, outputs[pos][1], ""); /*y0 y1 .. yn */ + pos_z = LLVMBuildLoad2(builder, vec_type, outputs[pos][2], ""); /*z0 z1 .. zn */ + pos_w = LLVMBuildLoad2(builder, vec_type, outputs[pos][3], ""); /*w0 w1 .. wn */ if (clip_user && cv != pos) { - cv_x = LLVMBuildLoad(builder, outputs[cv][0], ""); /*x0 x1 .. xn */ - cv_y = LLVMBuildLoad(builder, outputs[cv][1], ""); /*y0 y1 .. yn */ - cv_z = LLVMBuildLoad(builder, outputs[cv][2], ""); /*z0 z1 .. zn */ - cv_w = LLVMBuildLoad(builder, outputs[cv][3], ""); /*w0 w1 .. wn */ + cv_x = LLVMBuildLoad2(builder, vec_type, outputs[cv][0], ""); /*x0 x1 .. xn */ + cv_y = LLVMBuildLoad2(builder, vec_type, outputs[cv][1], ""); /*y0 y1 .. yn */ + cv_z = LLVMBuildLoad2(builder, vec_type, outputs[cv][2], ""); /*z0 z1 .. zn */ + cv_w = LLVMBuildLoad2(builder, vec_type, outputs[cv][3], ""); /*w0 w1 .. wn */ } else { cv_x = pos_x; cv_y = pos_y; @@ -1641,9 +1635,9 @@ generate_clipmask(struct draw_llvm *llvm, *have_clipdist = TRUE; if (i < 4) { - clipdist = LLVMBuildLoad(builder, outputs[cd[0]][i], ""); + clipdist = LLVMBuildLoad2(builder, vec_type, outputs[cd[0]][i], ""); } else { - clipdist = LLVMBuildLoad(builder, outputs[cd[1]][i-4], ""); + clipdist = LLVMBuildLoad2(builder, vec_type, outputs[cd[1]][i-4], ""); } test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_GREATER, zero, clipdist); is_nan_or_inf = lp_build_is_inf_or_nan(gallivm, vs_type, clipdist); @@ -1652,31 +1646,32 @@ generate_clipmask(struct draw_llvm *llvm, test = LLVMBuildAnd(builder, test, temp, ""); mask = LLVMBuildOr(builder, mask, test, ""); } else { + LLVMTypeRef vs_elem_type = lp_build_elem_type(gallivm, vs_type); LLVMTypeRef vs_type_llvm = lp_build_vec_type(gallivm, vs_type); indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, plane_idx); indices[2] = lp_build_const_int32(gallivm, 0); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_x"); + plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_x"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); sum = LLVMBuildFMul(builder, planes, cv_x, ""); indices[2] = lp_build_const_int32(gallivm, 1); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_y"); + plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_y"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); sum = lp_build_fmuladd(builder, planes, cv_y, sum); indices[2] = lp_build_const_int32(gallivm, 2); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_z"); + plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_z"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); sum = lp_build_fmuladd(builder, planes, cv_z, sum); indices[2] = lp_build_const_int32(gallivm, 3); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_w"); + plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_w"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); sum = lp_build_fmuladd(builder, planes, cv_w, sum); @@ -1694,7 +1689,7 @@ generate_clipmask(struct draw_llvm *llvm, */ unsigned edge_attr = llvm->draw->vs.edgeflag_output; LLVMValueRef one = lp_build_const_vec(gallivm, f32_type, 1.0); - LLVMValueRef edgeflag = LLVMBuildLoad(builder, outputs[edge_attr][0], ""); + LLVMValueRef edgeflag = LLVMBuildLoad2(builder, vec_type, outputs[edge_attr][0], ""); test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_EQUAL, one, edgeflag); temp = lp_build_const_int_vec(gallivm, i32_type, 1LL << DRAW_TOTAL_CLIP_PLANES); @@ -2062,7 +2057,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) LLVMVectorType(LLVMInt64TypeInContext(context), 4), ""); fake_buf = LLVMBuildBitCast(builder, fake_buf, LLVMPointerType(LLVMInt8TypeInContext(context), 0), ""); - fake_buf_ptr = LLVMBuildGEP(builder, fake_buf, &bld.zero, 1, ""); + fake_buf_ptr = LLVMBuildGEP2(builder, LLVMInt8TypeInContext(context), fake_buf, &bld.zero, 1, ""); /* code generated texture sampling */ sampler = draw_llvm_sampler_soa_create(draw_llvm_variant_key_samplers(key), key->nr_samplers); @@ -2104,8 +2099,8 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) struct lp_build_if_state if_ctx; if (velem->src_format != PIPE_FORMAT_NONE) { - vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr, &vb_index, 1, ""); - vb_info = LLVMBuildGEP(builder, vb_ptr, &vb_index, 1, ""); + vbuffer_ptr = LLVMBuildGEP2(builder, variant->buffer_type, vbuffers_ptr, &vb_index, 1, ""); + vb_info = LLVMBuildGEP2(builder, variant->vb_type, vb_ptr, &vb_index, 1, ""); vb_stride[j] = draw_jit_vbuffer_stride(gallivm, vb_info); vb_stride[j] = LLVMBuildZExt(gallivm->builder, vb_stride[j], LLVMInt32TypeInContext(context), ""); @@ -2157,8 +2152,9 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) buffer_size_adj[j] = LLVMBuildSelect(builder, ofbit, bld.zero, buffer_size_adj[j], ""); - temp_ptr = lp_build_alloca_undef(gallivm, - LLVMPointerType(LLVMInt8TypeInContext(context), 0), ""); + LLVMTypeRef byte_type = LLVMInt8TypeInContext(context); + LLVMTypeRef byte_ptr_type = LLVMPointerType(byte_type, 0); + temp_ptr = lp_build_alloca_undef(gallivm, byte_ptr_type, ""); lp_build_if(&if_ctx, gallivm, ofbit); { @@ -2166,11 +2162,11 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) } lp_build_else(&if_ctx); { - map_ptr[j] = LLVMBuildGEP(builder, map_ptr[j], &buf_offset, 1, ""); + map_ptr[j] = LLVMBuildGEP2(builder, byte_type, map_ptr[j], &buf_offset, 1, ""); LLVMBuildStore(builder, map_ptr[j], temp_ptr); } lp_build_endif(&if_ctx); - map_ptr[j] = LLVMBuildLoad(builder, temp_ptr, "map_ptr"); + map_ptr[j] = LLVMBuildLoad2(builder, byte_ptr_type, temp_ptr, "map_ptr"); if (0) { lp_build_printf(gallivm, "velem %d, vbuf index = %u, vb_stride = %u\n", @@ -2196,7 +2192,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) io_itr = lp_loop.counter; - io = LLVMBuildGEP(builder, io_ptr, &io_itr, 1, ""); + io = LLVMBuildGEP2(builder, variant->vertex_header_type, io_ptr, &io_itr, 1, ""); #if DEBUG_STORE lp_build_printf(gallivm, " --- io %d = %p, loop counter %d\n", io_itr, io, lp_loop.counter); @@ -2259,7 +2255,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) } lp_build_endif(&if_ctx); - true_index_array = LLVMBuildLoad(builder, index_store, ""); + true_index_array = LLVMBuildLoad2(builder, blduivec.vec_type, index_store, ""); for (j = 0; j < key->nr_vertex_elements; ++j) { struct pipe_vertex_element *velem = &key->vertex_element[j]; @@ -2329,7 +2325,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) /* do cliptest */ if (enable_cliptest) { - LLVMValueRef temp = LLVMBuildLoad(builder, clipmask_bool_ptr, ""); + LLVMValueRef temp = LLVMBuildLoad2(builder, blduivec.vec_type, clipmask_bool_ptr, ""); /* allocate clipmask, assign it integer type */ clipmask = generate_clipmask(llvm, gallivm, @@ -2788,13 +2784,13 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, assert(variant->vertex_header_ptr_type); + LLVMTypeRef prim_id_type = LLVMVectorType(int32_type, vector_length); arg_types[0] = get_gs_context_ptr_type(variant); /* context */ arg_types[1] = variant->input_array_type; /* input */ arg_types[2] = LLVMPointerType(variant->vertex_header_ptr_type, 0); /* vertex_header */ arg_types[3] = int32_type; /* num_prims */ arg_types[4] = int32_type; /* instance_id */ - arg_types[5] = LLVMPointerType( - LLVMVectorType(int32_type, vector_length), 0); /* prim_id_ptr */ + arg_types[5] = LLVMPointerType(prim_id_type, 0); /* prim_id_ptr */ arg_types[6] = int32_type; arg_types[7] = int32_type; @@ -2874,7 +2870,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, lp_build_mask_begin(&mask, gallivm, gs_type, mask_val); if (gs_info->uses_primid) { - system_values.prim_id = LLVMBuildLoad(builder, prim_id_ptr, "prim_id"); + system_values.prim_id = LLVMBuildLoad2(builder, prim_id_type, prim_id_ptr, "prim_id"); } if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { @@ -3459,15 +3455,15 @@ draw_tcs_llvm_generate(struct draw_llvm *llvm, args[4] = patch_vertices_in; args[5] = view_index; args[6] = loop_state[0].counter; - LLVMValueRef coro_entry = LLVMBuildGEP(builder, coro_hdls, &loop_state[0].counter, 1, ""); - LLVMValueRef coro_hdl = LLVMBuildLoad(builder, coro_entry, "coro_hdl"); + LLVMValueRef coro_entry = LLVMBuildGEP2(builder, hdl_ptr_type, coro_hdls, &loop_state[0].counter, 1, ""); + LLVMValueRef coro_hdl = LLVMBuildLoad2(builder, hdl_ptr_type, coro_entry, "coro_hdl"); struct lp_build_if_state ifstate; LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntEQ, loop_state[1].counter, lp_build_const_int32(gallivm, 0), ""); /* first time here - call the coroutine function entry point */ lp_build_if(&ifstate, gallivm, cmp); - LLVMValueRef coro_ret = LLVMBuildCall(builder, variant_coro, args, 7, ""); + LLVMValueRef coro_ret = LLVMBuildCall2(builder, coro_func_type, variant_coro, args, 7, ""); LLVMBuildStore(builder, coro_ret, coro_entry); lp_build_else(&ifstate); /* subsequent calls for this invocation - check if done. */ @@ -3762,7 +3758,8 @@ create_tes_jit_types(struct draw_tes_llvm_variant *var) "draw_tes_jit_context"); var->context_ptr_type = LLVMPointerType(context_type, 0); - var->input_array_type = create_tes_jit_input_type(gallivm); + var->input_array_deref_type = create_tes_jit_input_deref_type(gallivm); + var->input_array_type = LLVMPointerType(var->input_array_deref_type, 0); /* num vertices per prim */ } static LLVMTypeRef @@ -3841,8 +3838,8 @@ draw_tes_llvm_fetch_vertex_input(const struct lp_build_tes_iface *tes_iface, indices[1] = attr_chan_index; indices[2] = swiz_chan_index; - channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); + channel_vec = LLVMBuildGEP2(builder, tes->variant->input_array_deref_type, tes->input, indices, 3, ""); + channel_vec = LLVMBuildLoad2(builder, LLVMFloatTypeInContext(gallivm->context), channel_vec, ""); res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); } @@ -3851,8 +3848,8 @@ draw_tes_llvm_fetch_vertex_input(const struct lp_build_tes_iface *tes_iface, indices[1] = attrib_index; indices[2] = swizzle_index; - res = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); + res = LLVMBuildGEP2(builder, tes->variant->input_array_deref_type, tes->input, indices, 3, ""); + res = LLVMBuildLoad2(builder, LLVMFloatTypeInContext(gallivm->context), res, ""); res = lp_build_broadcast_scalar(bld, res); } return res; @@ -3891,8 +3888,8 @@ draw_tes_llvm_fetch_patch_input(const struct lp_build_tes_iface *tes_iface, indices[1] = attr_chan_index; indices[2] = swizzle_index; - channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); + channel_vec = LLVMBuildGEP2(builder, tes->variant->input_array_deref_type, tes->input, indices, 3, ""); + channel_vec = LLVMBuildLoad2(builder, LLVMFloatTypeInContext(gallivm->context), channel_vec, ""); res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); } @@ -3901,8 +3898,8 @@ draw_tes_llvm_fetch_patch_input(const struct lp_build_tes_iface *tes_iface, indices[1] = attrib_index; indices[2] = swizzle_index; - res = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); + res = LLVMBuildGEP2(builder, tes->variant->input_array_deref_type, tes->input, indices, 3, ""); + res = LLVMBuildLoad2(builder, LLVMFloatTypeInContext(gallivm->context), res, ""); res = lp_build_broadcast_scalar(bld, res); } return res; @@ -3946,6 +3943,9 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, snprintf(func_name, sizeof(func_name), "draw_llvm_tes_variant"); + LLVMTypeRef tess_outer_deref_type = LLVMArrayType(flt_type, 4); + LLVMTypeRef tess_inner_deref_type = LLVMArrayType(flt_type, 2); + arg_types[0] = get_tes_context_ptr_type(variant); /* context */ arg_types[1] = variant->input_array_type; /* input */ arg_types[2] = variant->vertex_header_ptr_type; @@ -3953,8 +3953,8 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, arg_types[4] = int32_type; arg_types[5] = LLVMPointerType(flt_type, 0); arg_types[6] = LLVMPointerType(flt_type, 0); - arg_types[7] = LLVMPointerType(LLVMArrayType(flt_type, 4), 0); - arg_types[8] = LLVMPointerType(LLVMArrayType(flt_type, 2), 0); + arg_types[7] = LLVMPointerType(tess_outer_deref_type, 0); + arg_types[8] = LLVMPointerType(tess_inner_deref_type, 0); arg_types[9] = int32_type; arg_types[10] = int32_type; @@ -4025,8 +4025,8 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, variant->key.nr_images); step = lp_build_const_int32(gallivm, vector_length); - system_values.tess_outer = LLVMBuildLoad(builder, tess_outer, ""); - system_values.tess_inner = LLVMBuildLoad(builder, tess_inner, ""); + system_values.tess_outer = LLVMBuildLoad2(builder, tess_outer_deref_type, tess_outer, ""); + system_values.tess_inner = LLVMBuildLoad2(builder, tess_inner_deref_type, tess_inner, ""); system_values.prim_id = lp_build_broadcast_scalar(&bldvec, prim_id); @@ -4046,7 +4046,7 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, { LLVMValueRef io; - io = LLVMBuildGEP(builder, io_ptr, &lp_loop.counter, 1, ""); + io = LLVMBuildGEP2(builder, variant->vertex_header_type, io_ptr, &lp_loop.counter, 1, ""); mask_val = generate_tes_mask_value(variant, tes_type, num_tess_coord, lp_loop.counter); lp_build_mask_begin(&mask, gallivm, tes_type, mask_val); @@ -4122,7 +4122,6 @@ draw_tes_llvm_create_variant(struct draw_llvm *llvm, { struct draw_tes_llvm_variant *variant; struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(llvm->draw->tes.tess_eval_shader); - LLVMTypeRef vertex_header; char module_name[64]; unsigned char ir_sha1_cache_key[20]; struct lp_cached_code cached = { 0 }; @@ -4157,9 +4156,8 @@ draw_tes_llvm_create_variant(struct draw_llvm *llvm, create_tes_jit_types(variant); - vertex_header = create_jit_vertex_header(variant->gallivm, num_outputs); - - variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0); + variant->vertex_header_type = create_jit_vertex_header(variant->gallivm, num_outputs); + variant->vertex_header_ptr_type = LLVMPointerType(variant->vertex_header_type, 0); if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { nir_print_shader(llvm->draw->tes.tess_eval_shader->state.ir.nir, stderr); diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h index 7506a87161ee8..4e118bef091b9 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.h +++ b/src/gallium/auxiliary/draw/draw_llvm.h @@ -681,6 +681,10 @@ struct draw_llvm_variant LLVMTypeRef vb_ptr_type; LLVMTypeRef vertex_header_ptr_type; + LLVMTypeRef buffer_type; + LLVMTypeRef vb_type; + LLVMTypeRef vertex_header_type; + LLVMValueRef function; draw_jit_vert_func jit_func; @@ -755,6 +759,9 @@ struct draw_tes_llvm_variant LLVMTypeRef input_array_type; LLVMTypeRef patch_input_array_type; + LLVMTypeRef input_array_deref_type; + LLVMTypeRef vertex_header_type; + LLVMValueRef context_ptr; LLVMValueRef io_ptr; LLVMValueRef num_prims; -- GitLab From f90d71f51831cc04e09466553afa56f5f62aed5d Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:26:25 +0300 Subject: [PATCH 03/22] gallium/llvmpipe: use LLVM opaque pointers in lp_bld_interp.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/drivers/llvmpipe/lp_bld_interp.c | 60 +++++++++++--------- src/gallium/drivers/llvmpipe/lp_bld_interp.h | 1 + 2 files changed, 34 insertions(+), 27 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.c b/src/gallium/drivers/llvmpipe/lp_bld_interp.c index a93879c9382f9..e0a57116c5d9d 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.c +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.c @@ -191,6 +191,20 @@ calc_centroid_offsets(struct lp_build_interp_soa_context *bld, *centroid_y = lp_build_select(coeff_bld, s_mask_and, pix_center_offset, centroid_y_offset); } +/* Note: this assumes the pointer to elem_type is in address space 0 */ +static LLVMValueRef +load_casted(LLVMBuilderRef builder, LLVMTypeRef elem_type, LLVMValueRef ptr, const char *name) { + ptr = LLVMBuildBitCast(builder, ptr, LLVMPointerType(elem_type, 0), name); + return LLVMBuildLoad2(builder, elem_type, ptr, name); +} + +static LLVMValueRef +indexed_load(LLVMBuilderRef builder, LLVMTypeRef gep_type, + LLVMTypeRef elem_type, LLVMValueRef ptr, LLVMValueRef index, const char *name) { + ptr = LLVMBuildGEP2(builder, gep_type, ptr, &index, 1, name); + return load_casted(builder, elem_type, ptr, name); +} + /* Much easier, and significantly less instructions in the per-stamp * part (less than half) but overall more instructions so a loss if * most quads are active. Might be a win though with larger vectors. @@ -224,36 +238,27 @@ coeffs_init_simple(struct lp_build_interp_soa_context *bld, const unsigned interp = bld->interp[attrib]; LLVMValueRef index = lp_build_const_int32(gallivm, attrib * TGSI_NUM_CHANNELS); - LLVMValueRef ptr; LLVMValueRef dadxaos = setup_bld->zero; LLVMValueRef dadyaos = setup_bld->zero; LLVMValueRef a0aos = setup_bld->zero; + /* See: lp_state_fs.c / generate_fragment() / fs_elem_type */ + LLVMTypeRef fs_elem_type = LLVMFloatTypeInContext(gallivm->context); + switch (interp) { case LP_INTERP_PERSPECTIVE: FALLTHROUGH; case LP_INTERP_LINEAR: - ptr = LLVMBuildGEP(builder, dadx_ptr, &index, 1, ""); - ptr = LLVMBuildBitCast(builder, ptr, - LLVMPointerType(setup_bld->vec_type, 0), ""); - dadxaos = LLVMBuildLoad(builder, ptr, ""); - - ptr = LLVMBuildGEP(builder, dady_ptr, &index, 1, ""); - ptr = LLVMBuildBitCast(builder, ptr, - LLVMPointerType(setup_bld->vec_type, 0), ""); - dadyaos = LLVMBuildLoad(builder, ptr, ""); - + dadxaos = indexed_load(builder, fs_elem_type, setup_bld->vec_type, dadx_ptr, index, ""); + dadyaos = indexed_load(builder, fs_elem_type, setup_bld->vec_type, dady_ptr, index, ""); attrib_name(dadxaos, attrib, 0, ".dadxaos"); attrib_name(dadyaos, attrib, 0, ".dadyaos"); FALLTHROUGH; case LP_INTERP_CONSTANT: case LP_INTERP_FACING: - ptr = LLVMBuildGEP(builder, a0_ptr, &index, 1, ""); - ptr = LLVMBuildBitCast(builder, ptr, - LLVMPointerType(setup_bld->vec_type, 0), ""); - a0aos = LLVMBuildLoad(builder, ptr, ""); + a0aos = indexed_load(builder, fs_elem_type, setup_bld->vec_type, a0_ptr, index, ""); attrib_name(a0aos, attrib, 0, ".a0aos"); break; @@ -297,10 +302,10 @@ attribs_update_simple(struct lp_build_interp_soa_context *bld, /* could do this with code-generated passed in pixel offsets too */ assert(loop_iter); - ptr = LLVMBuildGEP(builder, bld->xoffset_store, &loop_iter, 1, ""); - pixoffx = LLVMBuildLoad(builder, ptr, ""); - ptr = LLVMBuildGEP(builder, bld->yoffset_store, &loop_iter, 1, ""); - pixoffy = LLVMBuildLoad(builder, ptr, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->xoffset_store, &loop_iter, 1, ""); + pixoffx = LLVMBuildLoad2(builder, bld->store_elem_type, ptr, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->yoffset_store, &loop_iter, 1, ""); + pixoffy = LLVMBuildLoad2(builder, bld->store_elem_type, ptr, ""); pixoffx = LLVMBuildFAdd(builder, pixoffx, lp_build_broadcast_scalar(coeff_bld, bld->x), ""); @@ -529,10 +534,10 @@ lp_build_interp_soa(struct lp_build_interp_soa_context *bld, /* could do this with code-generated passed in pixel offsets too */ assert(loop_iter); - ptr = LLVMBuildGEP(builder, bld->xoffset_store, &loop_iter, 1, ""); - pixoffx = LLVMBuildLoad(builder, ptr, ""); - ptr = LLVMBuildGEP(builder, bld->yoffset_store, &loop_iter, 1, ""); - pixoffy = LLVMBuildLoad(builder, ptr, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->xoffset_store, &loop_iter, 1, ""); + pixoffx = LLVMBuildLoad2(builder, bld->store_elem_type, ptr, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->yoffset_store, &loop_iter, 1, ""); + pixoffy = LLVMBuildLoad2(builder, bld->store_elem_type, ptr, ""); pixoffx = LLVMBuildFAdd(builder, pixoffx, lp_build_broadcast_scalar(coeff_bld, bld->x), ""); @@ -769,20 +774,21 @@ lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld, LLVMValueRef pixoffx, pixoffy, index; LLVMValueRef ptr; + bld->store_elem_type = lp_build_vec_type(gallivm, type); bld->xoffset_store = lp_build_array_alloca(gallivm, - lp_build_vec_type(gallivm, type), + bld->store_elem_type, lp_build_const_int32(gallivm, num_loops), ""); bld->yoffset_store = lp_build_array_alloca(gallivm, - lp_build_vec_type(gallivm, type), + bld->store_elem_type, lp_build_const_int32(gallivm, num_loops), ""); for (i = 0; i < num_loops; i++) { index = lp_build_const_int32(gallivm, i); calc_offsets(&bld->coeff_bld, i*type.length/4, &pixoffx, &pixoffy); - ptr = LLVMBuildGEP(builder, bld->xoffset_store, &index, 1, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->xoffset_store, &index, 1, ""); LLVMBuildStore(builder, pixoffx, ptr); - ptr = LLVMBuildGEP(builder, bld->yoffset_store, &index, 1, ""); + ptr = LLVMBuildGEP2(builder, bld->store_elem_type, bld->yoffset_store, &index, 1, ""); LLVMBuildStore(builder, pixoffy, ptr); } } diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.h b/src/gallium/drivers/llvmpipe/lp_bld_interp.h index f77d2192258a6..6525ffb0bf038 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.h +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.h @@ -107,6 +107,7 @@ struct lp_build_interp_soa_context LLVMValueRef xoffset_store; LLVMValueRef yoffset_store; + LLVMTypeRef store_elem_type; /* * Convenience pointers. Callers may access this one. -- GitLab From d53fe793c38344382a71a89e3790249a31e3d4f3 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:28:22 +0300 Subject: [PATCH 04/22] gallium/llvmpipe: use LLVM opaque pointers in lp_bld_depth.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/drivers/llvmpipe/lp_bld_depth.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_bld_depth.c b/src/gallium/drivers/llvmpipe/lp_bld_depth.c index dc559bc3ffb10..cb4a727fa3cf8 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_depth.c +++ b/src/gallium/drivers/llvmpipe/lp_bld_depth.c @@ -510,7 +510,7 @@ lp_build_occlusion_count(struct gallivm_state *gallivm, count = LLVMBuildZExt(builder, count, LLVMIntTypeInContext(context, 64), ""); } } - newcount = LLVMBuildLoad(builder, counter, "origcount"); + newcount = LLVMBuildLoad2(builder, LLVMTypeOf(count), counter, "origcount"); newcount = LLVMBuildAdd(builder, newcount, count, "newcount"); LLVMBuildStore(builder, newcount, counter); } @@ -551,7 +551,8 @@ lp_build_depth_stencil_load_swizzled(struct gallivm_state *gallivm, struct lp_type zs_load_type = zs_type; zs_load_type.length = zs_load_type.length / 2; - load_ptr_type = LLVMPointerType(lp_build_vec_type(gallivm, zs_load_type), 0); + LLVMTypeRef zs_dst_type = lp_build_vec_type(gallivm, zs_load_type); + load_ptr_type = LLVMPointerType(zs_dst_type, 0); if (z_src_type.length == 4) { unsigned i; @@ -590,14 +591,14 @@ lp_build_depth_stencil_load_swizzled(struct gallivm_state *gallivm, /* Load current z/stencil values from z/stencil buffer */ zs_dst_ptr = LLVMBuildGEP(builder, depth_ptr, &depth_offset1, 1, ""); zs_dst_ptr = LLVMBuildBitCast(builder, zs_dst_ptr, load_ptr_type, ""); - zs_dst1 = LLVMBuildLoad(builder, zs_dst_ptr, ""); + zs_dst1 = LLVMBuildLoad2(builder, zs_dst_type, zs_dst_ptr, ""); if (is_1d) { zs_dst2 = lp_build_undef(gallivm, zs_load_type); } else { zs_dst_ptr = LLVMBuildGEP(builder, depth_ptr, &depth_offset2, 1, ""); zs_dst_ptr = LLVMBuildBitCast(builder, zs_dst_ptr, load_ptr_type, ""); - zs_dst2 = LLVMBuildLoad(builder, zs_dst_ptr, ""); + zs_dst2 = LLVMBuildLoad2(builder, zs_dst_type, zs_dst_ptr, ""); } *z_fb = LLVMBuildShuffleVector(builder, zs_dst1, zs_dst2, -- GitLab From 1e1ebbe6df456a4677d64a535bbb553ba4f702ea Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:31:29 +0300 Subject: [PATCH 05/22] gallivm: use LLVM opaque pointers in lp_bld_arit.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_arit.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_arit.c b/src/gallium/auxiliary/gallivm/lp_bld_arit.c index 9cff0162b2334..2061902a215a3 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_arit.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_arit.c @@ -3757,7 +3757,7 @@ lp_build_fpstate_set_denorms_zero(struct gallivm_state *gallivm, LLVMBuilderRef builder = gallivm->builder; LLVMValueRef mxcsr_ptr = lp_build_fpstate_get(gallivm); LLVMValueRef mxcsr = - LLVMBuildLoad(builder, mxcsr_ptr, "mxcsr"); + LLVMBuildLoad2(builder, LLVMInt32TypeInContext(gallivm->context), mxcsr_ptr, "mxcsr"); if (util_get_cpu_caps()->has_daz) { /* Enable denormals are zero mode */ -- GitLab From 70e9db951d5134546d0115cf773593ec33d5b5d2 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:32:25 +0300 Subject: [PATCH 06/22] gallivm: use LLVM opaque pointers in lp_bld_assert.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_assert.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_assert.c b/src/gallium/auxiliary/gallivm/lp_bld_assert.c index 02755765c0eac..f50da3c127e61 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_assert.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_assert.c @@ -75,9 +75,11 @@ lp_build_assert(struct gallivm_state *gallivm, arg_types[0] = LLVMInt32TypeInContext(context); arg_types[1] = LLVMPointerType(LLVMInt8TypeInContext(context), 0); - function = lp_build_const_func_pointer(gallivm, + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, 2, 0); + + function = lp_build_const_func_pointer_from_type(gallivm, func_to_pointer((func_pointer)lp_assert), - ret_type, arg_types, ARRAY_SIZE(arg_types), + function_type, "assert"); /* build function call param list */ @@ -87,6 +89,5 @@ lp_build_assert(struct gallivm_state *gallivm, /* check arg types */ assert(LLVMTypeOf(args[0]) == arg_types[0]); assert(LLVMTypeOf(args[1]) == arg_types[1]); - - LLVMBuildCall(builder, function, args, ARRAY_SIZE(args), ""); + LLVMBuildCall2(builder, function_type, function, args, ARRAY_SIZE(args), ""); } -- GitLab From 6867b184cac892e3f6aaf3fab3e0453bd784aaf7 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:41:12 +0300 Subject: [PATCH 07/22] gallivm: use LLVM opaque pointers in lp_bld_format_aos.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Also extract lp_build_const_func_pointer_from_type() in lp_bld_const.h taking explicit function type. Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_const.c | 25 ++++++----- src/gallium/auxiliary/gallivm/lp_bld_const.h | 6 +++ .../auxiliary/gallivm/lp_bld_format_aos.c | 45 +++++++++---------- 3 files changed, 40 insertions(+), 36 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_const.c b/src/gallium/auxiliary/gallivm/lp_bld_const.c index 4f4bddf44b813..7d9f3176ec1bd 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_const.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_const.c @@ -455,6 +455,17 @@ lp_build_const_string(struct gallivm_state *gallivm, return string; } +LLVMValueRef +lp_build_const_func_pointer_from_type(struct gallivm_state *gallivm, + const void *ptr, + LLVMTypeRef function_type, + const char *name) +{ + return LLVMBuildBitCast(gallivm->builder, + lp_build_const_int_pointer(gallivm, ptr), + LLVMPointerType(function_type, 0), + name); +} /** * Build a callable function pointer. @@ -470,16 +481,6 @@ lp_build_const_func_pointer(struct gallivm_state *gallivm, unsigned num_args, const char *name) { - LLVMTypeRef function_type; - LLVMValueRef function; - - function_type = LLVMFunctionType(ret_type, arg_types, num_args, 0); - - function = lp_build_const_int_pointer(gallivm, ptr); - - function = LLVMBuildBitCast(gallivm->builder, function, - LLVMPointerType(function_type, 0), - name); - - return function; + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, num_args, 0); + return lp_build_const_func_pointer_from_type(gallivm, ptr, function_type, name); } diff --git a/src/gallium/auxiliary/gallivm/lp_bld_const.h b/src/gallium/auxiliary/gallivm/lp_bld_const.h index 385b5b02d038e..d4098765f5e7a 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_const.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_const.h @@ -176,4 +176,10 @@ lp_build_const_func_pointer(struct gallivm_state *gallivm, const char *name); +LLVMValueRef +lp_build_const_func_pointer_from_type(struct gallivm_state *gallivm, + const void *ptr, + LLVMTypeRef function_type, + const char *name); + #endif /* !LP_BLD_CONST_H */ diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_format_aos.c index 74fe1672b27f8..86cca0bb0e8f1 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_aos.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_aos.c @@ -820,6 +820,7 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, * Declare and bind format_desc->fetch_rgba_8unorm(). */ + LLVMTypeRef function_type; { /* * Function to call looks like: @@ -827,7 +828,6 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, */ LLVMTypeRef ret_type; LLVMTypeRef arg_types[4]; - LLVMTypeRef function_type; ret_type = LLVMVoidTypeInContext(gallivm->context); arg_types[0] = pi8t; @@ -836,19 +836,16 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, arg_types[3] = i32t; function_type = LLVMFunctionType(ret_type, arg_types, ARRAY_SIZE(arg_types), 0); - - if (gallivm->cache) - gallivm->cache->dont_cache = true; - /* make const pointer for the C fetch_rgba_8unorm function */ - function = lp_build_const_int_pointer(gallivm, - func_to_pointer((func_pointer) unpack->fetch_rgba_8unorm)); - - /* cast the callee pointer to the function's type */ - function = LLVMBuildBitCast(builder, function, - LLVMPointerType(function_type, 0), - "cast callee"); } + if (gallivm->cache) + gallivm->cache->dont_cache = true; + /* make const pointer for the C fetch_rgba_8unorm function */ + function = lp_build_const_int_pointer(gallivm, + func_to_pointer((func_pointer) unpack->fetch_rgba_8unorm)); + /* cast the callee pointer to the function's type */ + function = LLVMBuildBitCast(builder, function, LLVMPointerType(function_type, 0), "cast callee"); + tmp_ptr = lp_build_alloca(gallivm, i32t, ""); res = LLVMGetUndef(LLVMVectorType(i32t, num_pixels)); @@ -875,9 +872,9 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, args[3] = LLVMBuildExtractElement(builder, j, index, ""); } - LLVMBuildCall(builder, function, args, ARRAY_SIZE(args), ""); + LLVMBuildCall2(builder, function_type, function, args, ARRAY_SIZE(args), ""); - tmp = LLVMBuildLoad(builder, tmp_ptr, ""); + tmp = LLVMBuildLoad2(builder, i32t, tmp_ptr, ""); if (num_pixels == 1) { res = tmp; @@ -929,6 +926,7 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, * Declare and bind unpack->fetch_rgba_float(). */ + LLVMTypeRef function_type = NULL; { /* * Function to call looks like: @@ -942,15 +940,14 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, arg_types[1] = pi8t; arg_types[2] = i32t; arg_types[3] = i32t; - - if (gallivm->cache) - gallivm->cache->dont_cache = true; - function = lp_build_const_func_pointer(gallivm, - func_to_pointer((func_pointer) fetch_rgba), - ret_type, - arg_types, ARRAY_SIZE(arg_types), - format_desc->short_name); + function_type = LLVMFunctionType(ret_type, arg_types, ARRAY_SIZE(arg_types), 0); } + if (gallivm->cache) + gallivm->cache->dont_cache = true; + function = lp_build_const_func_pointer_from_type(gallivm, + func_to_pointer((func_pointer) fetch_rgba), + function_type, + format_desc->short_name); tmp_ptr = lp_build_alloca(gallivm, f32x4t, ""); @@ -976,9 +973,9 @@ lp_build_fetch_rgba_aos(struct gallivm_state *gallivm, args[3] = LLVMBuildExtractElement(builder, j, index, ""); } - LLVMBuildCall(builder, function, args, ARRAY_SIZE(args), ""); + LLVMBuildCall2(builder, function_type, function, args, ARRAY_SIZE(args), ""); - tmps[k] = LLVMBuildLoad(builder, tmp_ptr, ""); + tmps[k] = LLVMBuildLoad2(builder, f32x4t, tmp_ptr, ""); } lp_build_conv(gallivm, -- GitLab From f1fc0bb567e5fdc92abd121a43fe2a632150c91c Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:44:19 +0300 Subject: [PATCH 08/22] gallivm: use LLVM opaque pointers in lp_bld_conv.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_conv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_conv.c b/src/gallium/auxiliary/gallivm/lp_bld_conv.c index 1073ff4fa66c3..69494ed22aaed 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_conv.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_conv.c @@ -229,7 +229,7 @@ lp_build_float_to_half(struct gallivm_state *gallivm, */ LLVMValueRef f16 = lp_build_intrinsic_unary(builder, "llvm.convert.to.fp16", i16t, f32); #else - LLVMValueRef f16 = LLVMBuildCall(builder, func, &f32, 1, ""); + LLVMValueRef f16 = LLVMBuildCall2(builder, func_type, func, &f32, 1, ""); #endif ref_result = LLVMBuildInsertElement(builder, ref_result, f16, index, ""); } -- GitLab From 2a6e9d13fb9e02e88cb9bfc3a89864f72156a91e Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:51:30 +0300 Subject: [PATCH 09/22] gallivm: use LLVM opaque pointers in lp_bld_coro.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_coro.c | 15 +++++++++++---- src/gallium/auxiliary/gallivm/lp_bld_init.h | 3 +++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_coro.c b/src/gallium/auxiliary/gallivm/lp_bld_coro.c index d3d5e6dc9693c..a423f60d939a6 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_coro.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_coro.c @@ -169,8 +169,10 @@ void lp_build_coro_declare_malloc_hooks(struct gallivm_state *gallivm) LLVMTypeRef int32_type = LLVMInt32TypeInContext(gallivm->context); LLVMTypeRef mem_ptr_type = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0); LLVMTypeRef malloc_type = LLVMFunctionType(mem_ptr_type, &int32_type, 1, 0); + gallivm->coro_malloc_hook_type = malloc_type; gallivm->coro_malloc_hook = LLVMAddFunction(gallivm->module, "coro_malloc", malloc_type); LLVMTypeRef free_type = LLVMFunctionType(LLVMVoidTypeInContext(gallivm->context), &mem_ptr_type, 1, 0); + gallivm->coro_free_hook_type = free_type; gallivm->coro_free_hook = LLVMAddFunction(gallivm->module, "coro_free", free_type); } @@ -184,7 +186,10 @@ LLVMValueRef lp_build_coro_begin_alloc_mem(struct gallivm_state *gallivm, LLVMVa LLVMValueRef alloc_mem; assert(gallivm->coro_malloc_hook); - alloc_mem = LLVMBuildCall(gallivm->builder, gallivm->coro_malloc_hook, &coro_size, 1, ""); + LLVMTypeRef malloc_type = + LLVMFunctionType(mem_ptr_type, + (LLVMTypeRef[]){LLVMInt32TypeInContext(gallivm->context)}, 1, 0); + alloc_mem = LLVMBuildCall2(gallivm->builder, malloc_type, gallivm->coro_malloc_hook, &coro_size, 1, ""); lp_build_endif(&if_state_coro); LLVMValueRef phi = LLVMBuildPhi(gallivm->builder, mem_ptr_type, ""); @@ -212,7 +217,8 @@ LLVMValueRef lp_build_coro_alloc_mem_array(struct gallivm_state *gallivm, LLVMValueRef alloc_mem; LLVMValueRef alloc_size = LLVMBuildMul(gallivm->builder, coro_num_hdls, coro_size, ""); assert(gallivm->coro_malloc_hook); - alloc_mem = LLVMBuildCall(gallivm->builder, gallivm->coro_malloc_hook, &alloc_size, 1, ""); + assert(gallivm->coro_malloc_hook_type); + alloc_mem = LLVMBuildCall2(gallivm->builder, gallivm->coro_malloc_hook_type, gallivm->coro_malloc_hook, &alloc_size, 1, ""); LLVMBuildStore(gallivm->builder, alloc_mem, coro_hdl_ptr); lp_build_endif(&if_state_coro); @@ -223,8 +229,9 @@ void lp_build_coro_free_mem(struct gallivm_state *gallivm, LLVMValueRef coro_id, { LLVMValueRef alloc_mem = lp_build_coro_free(gallivm, coro_id, coro_hdl); - assert(gallivm->coro_malloc_hook); - alloc_mem = LLVMBuildCall(gallivm->builder, gallivm->coro_free_hook, &alloc_mem, 1, ""); + assert(gallivm->coro_free_hook); + assert(gallivm->coro_free_hook_type); + alloc_mem = LLVMBuildCall2(gallivm->builder, gallivm->coro_free_hook_type, gallivm->coro_free_hook, &alloc_mem, 1, ""); } void lp_build_coro_suspend_switch(struct gallivm_state *gallivm, const struct lp_build_coro_suspend_info *sus_info, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_init.h b/src/gallium/auxiliary/gallivm/lp_bld_init.h index 7c516b2b266d6..7eaaa31745b8f 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_init.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_init.h @@ -57,6 +57,9 @@ struct gallivm_state LLVMValueRef coro_malloc_hook; LLVMValueRef coro_free_hook; LLVMValueRef debug_printf_hook; + + LLVMTypeRef coro_malloc_hook_type; + LLVMTypeRef coro_free_hook_type; }; -- GitLab From 1e0ddda79679955f2a3ad9487ce4eab84b0ec7b1 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:53:10 +0300 Subject: [PATCH 10/22] gallivm: use LLVM opaque pointers in lp_bld_printf.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_printf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_printf.c b/src/gallium/auxiliary/gallivm/lp_bld_printf.c index 4db2c09423114..5e08a0c2fe6dc 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_printf.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_printf.c @@ -63,11 +63,11 @@ lp_build_print_args(struct gallivm_state* gallivm, args[i] = LLVMBuildFPExt(builder, args[i], LLVMDoubleTypeInContext(context), ""); } + LLVMTypeRef printf_type = LLVMFunctionType(LLVMInt32TypeInContext(context), NULL, 0, 1); if (!gallivm->debug_printf_hook) { - LLVMTypeRef printf_type = LLVMFunctionType(LLVMInt32TypeInContext(context), NULL, 0, 1); gallivm->debug_printf_hook = LLVMAddFunction(gallivm->module, "debug_printf", printf_type); } - return LLVMBuildCall(builder, gallivm->debug_printf_hook, args, argcount, ""); + return LLVMBuildCall2(builder, printf_type, gallivm->debug_printf_hook, args, argcount, ""); } -- GitLab From 3143f871ac948cda9608579f08ca059e063882fa Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:54:57 +0300 Subject: [PATCH 11/22] gallivm: use LLVM opaque pointers in lp_bld_flow.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_flow.c | 19 +++++++++++-------- src/gallium/auxiliary/gallivm/lp_bld_flow.h | 7 +++++-- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_flow.c b/src/gallium/auxiliary/gallivm/lp_bld_flow.c index d5d903f66f237..8858aac9cb4ff 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_flow.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_flow.c @@ -168,8 +168,9 @@ lp_build_mask_begin(struct lp_build_mask_context *mask, memset(mask, 0, sizeof *mask); mask->reg_type = LLVMIntTypeInContext(gallivm->context, type.width * type.length); + mask->var_type = lp_build_int_vec_type(gallivm, type); mask->var = lp_build_alloca(gallivm, - lp_build_int_vec_type(gallivm, type), + mask->var_type, "execution_mask"); LLVMBuildStore(gallivm->builder, value, mask->var); @@ -181,7 +182,7 @@ lp_build_mask_begin(struct lp_build_mask_context *mask, LLVMValueRef lp_build_mask_value(struct lp_build_mask_context *mask) { - return LLVMBuildLoad(mask->skip.gallivm->builder, mask->var, ""); + return LLVMBuildLoad2(mask->skip.gallivm->builder, mask->var_type, mask->var, ""); } @@ -233,7 +234,8 @@ lp_build_loop_begin(struct lp_build_loop_state *state, state->block = lp_build_insert_new_block(gallivm, "loop_begin"); - state->counter_var = lp_build_alloca(gallivm, LLVMTypeOf(start), "loop_counter"); + state->counter_type = LLVMTypeOf(start); + state->counter_var = lp_build_alloca(gallivm, state->counter_type, "loop_counter"); state->gallivm = gallivm; LLVMBuildStore(builder, start, state->counter_var); @@ -242,7 +244,7 @@ lp_build_loop_begin(struct lp_build_loop_state *state, LLVMPositionBuilderAtEnd(builder, state->block); - state->counter = LLVMBuildLoad(builder, state->counter_var, ""); + state->counter = LLVMBuildLoad2(builder, state->counter_type, state->counter_var, ""); } @@ -272,7 +274,7 @@ lp_build_loop_end_cond(struct lp_build_loop_state *state, LLVMPositionBuilderAtEnd(builder, after_block); - state->counter = LLVMBuildLoad(builder, state->counter_var, ""); + state->counter = LLVMBuildLoad2(builder, state->counter_type, state->counter_var, ""); } void @@ -287,7 +289,7 @@ void lp_build_loop_force_reload_counter(struct lp_build_loop_state *state) { LLVMBuilderRef builder = state->gallivm->builder; - state->counter = LLVMBuildLoad(builder, state->counter_var, ""); + state->counter = LLVMBuildLoad2(builder, state->counter_type, state->counter_var, ""); } void @@ -324,7 +326,8 @@ lp_build_for_loop_begin(struct lp_build_for_loop_state *state, state->begin = lp_build_insert_new_block(gallivm, "loop_begin"); state->step = step; - state->counter_var = lp_build_alloca(gallivm, LLVMTypeOf(start), "loop_counter"); + state->counter_type = LLVMTypeOf(start); + state->counter_var = lp_build_alloca(gallivm, state->counter_type, "loop_counter"); state->gallivm = gallivm; state->cond = cmp_op; state->end = end; @@ -333,7 +336,7 @@ lp_build_for_loop_begin(struct lp_build_for_loop_state *state, LLVMBuildBr(builder, state->begin); LLVMPositionBuilderAtEnd(builder, state->begin); - state->counter = LLVMBuildLoad(builder, state->counter_var, ""); + state->counter = LLVMBuildLoad2(builder, state->counter_type, state->counter_var, ""); state->body = lp_build_insert_new_block(gallivm, "loop_body"); LLVMPositionBuilderAtEnd(builder, state->body); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_flow.h b/src/gallium/auxiliary/gallivm/lp_bld_flow.h index c4ffa833e2add..c79502af5c4de 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_flow.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_flow.h @@ -73,7 +73,8 @@ struct lp_build_mask_context struct lp_build_skip_context skip; LLVMTypeRef reg_type; - + LLVMTypeRef var_type; + /* 'var' is a pointer (alloca) pointing to 'var_type' */ LLVMValueRef var; }; @@ -107,7 +108,7 @@ lp_build_mask_end(struct lp_build_mask_context *mask); /** * LLVM's IR doesn't represent for-loops directly. Furthermore it - * it requires creating code blocks, branches, phi variables, so it + * requires creating code blocks, branches, phi variables, so it * requires a fair amount of code. * * @sa http://www.llvm.org/docs/tutorial/LangImpl5.html#for @@ -117,6 +118,7 @@ struct lp_build_loop_state LLVMBasicBlockRef block; LLVMValueRef counter_var; LLVMValueRef counter; + LLVMTypeRef counter_type; struct gallivm_state *gallivm; }; @@ -154,6 +156,7 @@ struct lp_build_for_loop_state LLVMBasicBlockRef exit; LLVMValueRef counter_var; LLVMValueRef counter; + LLVMTypeRef counter_type; LLVMValueRef step; LLVMIntPredicate cond; LLVMValueRef end; -- GitLab From 84ba15ac06285b5851e4363837ba57380c12d07a Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:56:33 +0300 Subject: [PATCH 12/22] gallivm: use LLVM opaque pointers in lp_bld_intr.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_intr.c | 50 ++++++++++++--------- src/gallium/auxiliary/gallivm/lp_bld_intr.h | 5 +++ 2 files changed, 34 insertions(+), 21 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_intr.c b/src/gallium/auxiliary/gallivm/lp_bld_intr.c index 2ce723c7e5ddc..99f5c77c4f03a 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_intr.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_intr.c @@ -103,19 +103,13 @@ lp_format_intrinsic(char *name, LLVMValueRef -lp_declare_intrinsic(LLVMModuleRef module, - const char *name, - LLVMTypeRef ret_type, - LLVMTypeRef *arg_types, - unsigned num_args) +lp_declare_intrinsic_with_type(LLVMModuleRef module, + const char *name, + LLVMTypeRef function_type) { - LLVMTypeRef function_type; - LLVMValueRef function; - assert(!LLVMGetNamedFunction(module, name)); - function_type = LLVMFunctionType(ret_type, arg_types, num_args, 0); - function = LLVMAddFunction(module, name, function_type); + LLVMValueRef function = LLVMAddFunction(module, name, function_type); LLVMSetFunctionCallConv(function, LLVMCCallConv); LLVMSetLinkage(function, LLVMExternalLinkage); @@ -126,6 +120,18 @@ lp_declare_intrinsic(LLVMModuleRef module, } +LLVMValueRef +lp_declare_intrinsic(LLVMModuleRef module, + const char *name, + LLVMTypeRef ret_type, + LLVMTypeRef *arg_types, + unsigned num_args) +{ + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, num_args, 0); + return lp_declare_intrinsic_with_type(module, name, function_type); +} + + #if LLVM_VERSION_MAJOR < 4 static LLVMAttribute lp_attr_to_llvm_attr(enum lp_func_attr attr) { @@ -232,19 +238,21 @@ lp_build_intrinsic(LLVMBuilderRef builder, bool set_callsite_attrs = LLVM_VERSION_MAJOR >= 4 && !(attr_mask & LP_FUNC_ATTR_LEGACY); - function = LLVMGetNamedFunction(module, name); - if(!function) { - LLVMTypeRef arg_types[LP_MAX_FUNC_ARGS]; - unsigned i; + LLVMTypeRef arg_types[LP_MAX_FUNC_ARGS]; + + assert(num_args <= LP_MAX_FUNC_ARGS); - assert(num_args <= LP_MAX_FUNC_ARGS); + for(unsigned i = 0; i < num_args; ++i) { + assert(args[i]); + arg_types[i] = LLVMTypeOf(args[i]); + } - for(i = 0; i < num_args; ++i) { - assert(args[i]); - arg_types[i] = LLVMTypeOf(args[i]); - } + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, num_args, 0); - function = lp_declare_intrinsic(module, name, ret_type, arg_types, num_args); + function = LLVMGetNamedFunction(module, name); + + if(!function) { + function = lp_declare_intrinsic_with_type(module, name, function_type); /* * If llvm removes an intrinsic we use, we'll hit this abort (rather @@ -265,7 +273,7 @@ lp_build_intrinsic(LLVMBuilderRef builder, } } - call = LLVMBuildCall(builder, function, args, num_args, ""); + call = LLVMBuildCall2(builder, function_type, function, args, num_args, ""); if (set_callsite_attrs) lp_add_func_attributes(call, attr_mask); return call; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_intr.h b/src/gallium/auxiliary/gallivm/lp_bld_intr.h index ed90979f16fbb..98dfb0d0cb31d 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_intr.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_intr.h @@ -78,6 +78,11 @@ lp_declare_intrinsic(LLVMModuleRef module, LLVMTypeRef *arg_types, unsigned num_args); +LLVMValueRef +lp_declare_intrinsic_with_type(LLVMModuleRef module, + const char *name, + LLVMTypeRef function_type); + void lp_add_function_attr(LLVMValueRef function_or_call, int attr_idx, enum lp_func_attr attr); -- GitLab From 61da78c31109a44b503c9350794d471a3acc7c7f Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 15:59:55 +0300 Subject: [PATCH 13/22] gallivm: use LLVM opaque pointers in lp_bld_format_s3tc.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_format_s3tc.c | 39 +++++++------------ 1 file changed, 15 insertions(+), 24 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c index 497d403fad372..8f972b840fa66 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c @@ -1097,13 +1097,12 @@ lp_build_gather_s3tc_simple_scalar(struct gallivm_state *gallivm, LLVMValueRef elem, shuf; LLVMTypeRef type32 = LLVMIntTypeInContext(gallivm->context, 32); LLVMTypeRef src_type = LLVMIntTypeInContext(gallivm->context, block_bits); - LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0); LLVMTypeRef type32_4 = LLVMVectorType(type32, 4); assert(block_bits == 64 || block_bits == 128); - ptr = LLVMBuildBitCast(builder, ptr, src_ptr_type, ""); - elem = LLVMBuildLoad(builder, ptr, ""); + ptr = LLVMBuildBitCast(builder, ptr, LLVMPointerType(src_type, 0), ""); + elem = LLVMBuildLoad2(builder, src_type, ptr, ""); if (block_bits == 128) { /* just return block as is */ @@ -1139,15 +1138,13 @@ s3tc_store_cached_block(struct gallivm_state *gallivm, LLVMBuildStore(builder, tag_value, ptr); indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_DATA); - hash_index = LLVMBuildMul(builder, hash_index, - lp_build_const_int32(gallivm, 16), ""); + hash_index = LLVMBuildMul(builder, hash_index, lp_build_const_int32(gallivm, 16), ""); for (count = 0; count < 4; count++) { indices[2] = hash_index; ptr = LLVMBuildGEP(builder, cache, indices, ARRAY_SIZE(indices), ""); ptr = LLVMBuildBitCast(builder, ptr, type_ptr4x32, ""); LLVMBuildStore(builder, col[count], ptr); - hash_index = LLVMBuildAdd(builder, hash_index, - lp_build_const_int32(gallivm, 4), ""); + hash_index = LLVMBuildAdd(builder, hash_index, lp_build_const_int32(gallivm, 4), ""); } } @@ -1177,8 +1174,9 @@ s3tc_lookup_tag_data(struct gallivm_state *gallivm, indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); indices[2] = index; + LLVMTypeRef tag_type = LLVMInt64TypeInContext(gallivm->context); member_ptr = LLVMBuildGEP(builder, ptr, indices, ARRAY_SIZE(indices), ""); - return LLVMBuildLoad(builder, member_ptr, "tag_data"); + return LLVMBuildLoad2(builder, tag_type, member_ptr, "tag_data"); } #if LP_BUILD_FORMAT_CACHE_DEBUG @@ -1996,24 +1994,17 @@ update_cached_block(struct gallivm_state *gallivm, format_desc->short_name); function = LLVMGetNamedFunction(module, name); - if (!function) { - LLVMTypeRef ret_type; - LLVMTypeRef arg_types[3]; - LLVMTypeRef function_type; - unsigned arg; + LLVMTypeRef ret_type = LLVMVoidTypeInContext(gallivm->context); + LLVMTypeRef arg_types[3]; + arg_types[0] = pi8t; + arg_types[1] = LLVMInt32TypeInContext(gallivm->context); + arg_types[2] = LLVMTypeOf(cache); // XXX: put right type here + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, ARRAY_SIZE(arg_types), 0); - /* - * Generate the function prototype. - */ - - ret_type = LLVMVoidTypeInContext(gallivm->context); - arg_types[0] = pi8t; - arg_types[1] = LLVMInt32TypeInContext(gallivm->context); - arg_types[2] = LLVMTypeOf(cache); // XXX: put right type here - function_type = LLVMFunctionType(ret_type, arg_types, ARRAY_SIZE(arg_types), 0); + if (!function) { function = LLVMAddFunction(module, name, function_type); - for (arg = 0; arg < ARRAY_SIZE(arg_types); ++arg) + for (unsigned arg = 0; arg < ARRAY_SIZE(arg_types); ++arg) if (LLVMGetTypeKind(arg_types[arg]) == LLVMPointerTypeKind) lp_add_function_attr(function, arg + 1, LP_FUNC_ATTR_NOALIAS); @@ -2026,7 +2017,7 @@ update_cached_block(struct gallivm_state *gallivm, args[1] = hash_index; args[2] = cache; - LLVMBuildCall(builder, function, args, ARRAY_SIZE(args), ""); + LLVMBuildCall2(builder, function_type, function, args, ARRAY_SIZE(args), ""); bb = LLVMGetInsertBlock(builder); inst = LLVMGetLastInstruction(bb); LLVMSetInstructionCallConv(inst, LLVMFastCallConv); -- GitLab From 36c45736ce03c7e66c8fe5422d0df49b5954a213 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:01:52 +0300 Subject: [PATCH 14/22] gallivm: use LLVM opaque pointers in lp_bld_gather.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_gather.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_gather.c b/src/gallium/auxiliary/gallivm/lp_bld_gather.c index 42cc17371a0db..2f2506803cf9a 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_gather.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_gather.c @@ -55,7 +55,8 @@ lp_build_gather_elem_ptr(struct gallivm_state *gallivm, LLVMValueRef offset; LLVMValueRef ptr; - assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0)); + ASSERTED LLVMTypeRef element_type = LLVMInt8TypeInContext(gallivm->context); + assert(LLVMTypeOf(base_ptr) == LLVMPointerType(element_type, 0)); if (length == 1) { assert(i == 0); @@ -65,7 +66,7 @@ lp_build_gather_elem_ptr(struct gallivm_state *gallivm, offset = LLVMBuildExtractElement(gallivm->builder, offsets, index, ""); } - ptr = LLVMBuildGEP(gallivm->builder, base_ptr, &offset, 1, ""); + ptr = LLVMBuildGEP2(gallivm->builder, element_type, base_ptr, &offset, 1, ""); return ptr; } @@ -88,7 +89,6 @@ lp_build_gather_elem(struct gallivm_state *gallivm, boolean vector_justify) { LLVMTypeRef src_type = LLVMIntTypeInContext(gallivm->context, src_width); - LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0); LLVMTypeRef dst_elem_type = LLVMIntTypeInContext(gallivm->context, dst_width); LLVMValueRef ptr; LLVMValueRef res; @@ -96,8 +96,8 @@ lp_build_gather_elem(struct gallivm_state *gallivm, assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0)); ptr = lp_build_gather_elem_ptr(gallivm, length, base_ptr, offsets, i); - ptr = LLVMBuildBitCast(gallivm->builder, ptr, src_ptr_type, ""); - res = LLVMBuildLoad(gallivm->builder, ptr, ""); + ptr = LLVMBuildBitCast(gallivm->builder, ptr, LLVMPointerType(src_type, 0), ""); + res = LLVMBuildLoad2(gallivm->builder, src_type, ptr, ""); /* XXX * On some archs we probably really want to avoid having to deal @@ -173,12 +173,11 @@ lp_build_gather_elem_vec(struct gallivm_state *gallivm, boolean vector_justify) { LLVMValueRef ptr, res; - LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0); assert(LLVMTypeOf(base_ptr) == LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0)); ptr = lp_build_gather_elem_ptr(gallivm, length, base_ptr, offsets, i); - ptr = LLVMBuildBitCast(gallivm->builder, ptr, src_ptr_type, ""); - res = LLVMBuildLoad(gallivm->builder, ptr, ""); + ptr = LLVMBuildBitCast(gallivm->builder, ptr, LLVMPointerType(src_type, 0), ""); + res = LLVMBuildLoad2(gallivm->builder, src_type, ptr, ""); /* XXX * On some archs we probably really want to avoid having to deal @@ -324,7 +323,7 @@ lp_build_gather_avx2(struct gallivm_state *gallivm, assert(LLVMTypeOf(offsets) == i32_vec_type); offsets = LLVMBuildSDiv(builder, offsets, scale, ""); - src_ptr = LLVMBuildGEP(builder, base_ptr, &offsets, 1, "vector-gep"); + src_ptr = LLVMBuildGEP2(builder, src_type, base_ptr, &offsets, 1, "vector-gep"); char intrinsic[64]; snprintf(intrinsic, sizeof intrinsic, "llvm.masked.gather.v%u%s%u", -- GitLab From 2a59fdb96d5a7bfe8c10b6ce7eec621480abd092 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:03:36 +0300 Subject: [PATCH 15/22] gallivm: use LLVM opaque pointers in lp_bld_nir_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_nir_soa.c | 89 ++++++++++--------- 1 file changed, 45 insertions(+), 44 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index 5a8fd02561bfb..e31faf577077b 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -282,8 +282,8 @@ build_gather(struct lp_build_nir_context *bld_base, index = LLVMBuildExtractElement(builder, indexes, si, ""); } - scalar_ptr = LLVMBuildGEP(builder, base_ptr, - &index, 1, "gather_ptr"); + + scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "gather_ptr"); scalar = LLVMBuildLoad(builder, scalar_ptr, ""); res = LLVMBuildInsertElement(builder, res, scalar, di, ""); @@ -324,8 +324,8 @@ emit_mask_scatter(struct lp_build_nir_soa_context *bld, for (i = 0; i < bld->bld_base.base.type.length; i++) { LLVMValueRef ii = lp_build_const_int32(gallivm, i); LLVMValueRef index = LLVMBuildExtractElement(builder, indexes, ii, ""); - LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "scatter_ptr"); LLVMValueRef val = LLVMBuildExtractElement(builder, values, ii, "scatter_val"); + LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "scatter_ptr"); LLVMValueRef scalar_pred = pred ? LLVMBuildExtractElement(builder, pred, ii, "scatter_pred") : NULL; @@ -335,7 +335,7 @@ emit_mask_scatter(struct lp_build_nir_soa_context *bld, if (scalar_pred) { LLVMValueRef real_val, dst_val; - dst_val = LLVMBuildLoad(builder, scalar_ptr, ""); + dst_val = LLVMBuildLoad2(builder, LLVMTypeOf(val), scalar_ptr, ""); scalar_pred = LLVMBuildTrunc(builder, scalar_pred, LLVMInt1TypeInContext(gallivm->context), ""); real_val = LLVMBuildSelect(builder, scalar_pred, val, dst_val, ""); LLVMBuildStore(builder, real_val, scalar_ptr); @@ -862,13 +862,13 @@ static void emit_load_global(struct lp_build_nir_context *bld_base, LLVMValueRef value_ptr = lp_build_pointer_get(builder, addr_ptr, lp_build_const_int32(gallivm, c)); LLVMValueRef temp_res; - temp_res = LLVMBuildLoad(builder, result, ""); + temp_res = LLVMBuildLoad2(builder, res_bld->vec_type, result, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, value_ptr, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result); lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - outval[c] = LLVMBuildLoad(builder, result, ""); + outval[c] = LLVMBuildLoad2(builder, res_bld->vec_type, result, ""); } } @@ -1007,11 +1007,11 @@ static void emit_atomic_global(struct lp_build_nir_context *bld_base, LLVMAtomicOrderingSequentiallyConsistent, false); } - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, LLVMTypeOf(val), atom_res, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, atom_res); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, LLVMTypeOf(val), atom_res, ""); bool is_float = LLVMTypeOf(val) == bld_base->base.vec_type; LLVMValueRef zero_val; if (is_float) { @@ -1031,7 +1031,7 @@ static void emit_atomic_global(struct lp_build_nir_context *bld_base, lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - *result = LLVMBuildLoad(builder, atom_res, ""); + *result = LLVMBuildLoad2(builder, LLVMTypeOf(val), atom_res, ""); } static void emit_load_ubo(struct lp_build_nir_context *bld_base, @@ -1135,7 +1135,7 @@ mem_access_base_pointer(struct lp_build_nir_context *bld_base, *bounds = NULL; } - /* Cast it to the pointer type of the access this instruciton is doing. */ + /* Cast it to the pointer type of the access this instruction is doing. */ if (bit_size == 32) return ptr; else @@ -1187,7 +1187,7 @@ static void emit_load_mem(struct lp_build_nir_context *bld_base, LLVMBuildStore(builder, lp_build_pointer_get(builder, mem_ptr, chan_offset), res_store); lp_build_endif(&ifthen); - scalar = LLVMBuildLoad(builder, res_store, ""); + scalar = LLVMBuildLoad2(builder, LLVMTypeOf(zero), res_store, ""); } else { scalar = lp_build_pointer_get(builder, mem_ptr, chan_offset); } @@ -1233,11 +1233,11 @@ static void emit_load_mem(struct lp_build_nir_context *bld_base, lp_build_if(&ifthen, gallivm, fetch_cond); LLVMValueRef scalar = lp_build_pointer_get(builder, mem_ptr, loop_index); - temp_res = LLVMBuildLoad(builder, result[c], ""); + temp_res = LLVMBuildLoad2(builder, load_bld->vec_type, result[c], ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result[c]); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, result[c], ""); + temp_res = LLVMBuildLoad2(builder, load_bld->vec_type, result[c], ""); LLVMValueRef zero = lp_build_zero_bits(gallivm, bit_size); temp_res = LLVMBuildInsertElement(builder, temp_res, zero, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result[c]); @@ -1248,7 +1248,7 @@ static void emit_load_mem(struct lp_build_nir_context *bld_base, lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); for (unsigned c = 0; c < nc; c++) - outval[c] = LLVMBuildLoad(gallivm->builder, result[c], ""); + outval[c] = LLVMBuildLoad2(gallivm->builder, load_bld->vec_type, result[c], ""); } @@ -1356,7 +1356,7 @@ static void emit_atomic_mem(struct lp_build_nir_context *bld_base, loop_state.counter, ""); value_ptr = LLVMBuildBitCast(gallivm->builder, value_ptr, atomic_bld->elem_type, ""); - LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, mem_ptr, &loop_offset, 1, ""); + LLVMValueRef scalar_ptr = LLVMBuildGEP2(builder, atomic_bld->elem_type, mem_ptr, &loop_offset, 1, ""); struct lp_build_if_state ifthen; LLVMValueRef inner_cond, temp_res; @@ -1423,11 +1423,11 @@ static void emit_atomic_mem(struct lp_build_nir_context *bld_base, LLVMAtomicOrderingSequentiallyConsistent, false); } - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, atomic_bld->vec_type, atom_res, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, atom_res); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, atomic_bld->vec_type, atom_res, ""); LLVMValueRef zero = lp_build_zero_bits(gallivm, bit_size); temp_res = LLVMBuildInsertElement(builder, temp_res, zero, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, atom_res); @@ -1436,7 +1436,7 @@ static void emit_atomic_mem(struct lp_build_nir_context *bld_base, lp_build_endif(&exec_ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - *result = LLVMBuildLoad(builder, atom_res, ""); + *result = LLVMBuildLoad2(builder, atomic_bld->vec_type, atom_res, ""); } static void emit_barrier(struct lp_build_nir_context *bld_base) @@ -1614,7 +1614,7 @@ static void emit_tex(struct lp_build_nir_context *bld_base, lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); - LLVMValueRef idx_val = LLVMBuildLoad(builder, res_store, ""); + LLVMValueRef idx_val = LLVMBuildLoad2(builder, bld_base->uint_bld.elem_type, res_store, ""); params->texture_index_offset = idx_val; } @@ -1856,7 +1856,7 @@ increment_vec_ptr_by_mask(struct lp_build_nir_context * bld_base, LLVMValueRef mask) { LLVMBuilderRef builder = bld_base->base.gallivm->builder; - LLVMValueRef current_vec = LLVMBuildLoad(builder, ptr, ""); + LLVMValueRef current_vec = LLVMBuildLoad2(builder, LLVMTypeOf(mask), ptr, ""); current_vec = LLVMBuildSub(builder, current_vec, mask, ""); @@ -1869,7 +1869,7 @@ clear_uint_vec_ptr_from_mask(struct lp_build_nir_context * bld_base, LLVMValueRef mask) { LLVMBuilderRef builder = bld_base->base.gallivm->builder; - LLVMValueRef current_vec = LLVMBuildLoad(builder, ptr, ""); + LLVMValueRef current_vec = LLVMBuildLoad2(builder, bld_base->uint_bld.vec_type, ptr, ""); current_vec = lp_build_select(&bld_base->uint_bld, mask, @@ -1902,7 +1902,7 @@ static void emit_vertex(struct lp_build_nir_context *bld_base, uint32_t stream_i return; assert(bld->gs_iface->emit_vertex); LLVMValueRef total_emitted_vertices_vec = - LLVMBuildLoad(builder, bld->total_emitted_vertices_vec_ptr[stream_id], ""); + LLVMBuildLoad2(builder, bld->bld_base.uint_bld.vec_type, bld->total_emitted_vertices_vec_ptr[stream_id], ""); LLVMValueRef mask = mask_vec(bld_base); mask = clamp_mask_to_max_output_vertices(bld, mask, total_emitted_vertices_vec); @@ -1929,11 +1929,11 @@ end_primitive_masked(struct lp_build_nir_context * bld_base, return; struct lp_build_context *uint_bld = &bld_base->uint_bld; LLVMValueRef emitted_vertices_vec = - LLVMBuildLoad(builder, bld->emitted_vertices_vec_ptr[stream_id], ""); + LLVMBuildLoad2(builder, bld->bld_base.uint_bld.vec_type, bld->emitted_vertices_vec_ptr[stream_id], ""); LLVMValueRef emitted_prims_vec = - LLVMBuildLoad(builder, bld->emitted_prims_vec_ptr[stream_id], ""); + LLVMBuildLoad2(builder, bld->bld_base.uint_bld.vec_type, bld->emitted_prims_vec_ptr[stream_id], ""); LLVMValueRef total_emitted_vertices_vec = - LLVMBuildLoad(builder, bld->total_emitted_vertices_vec_ptr[stream_id], ""); + LLVMBuildLoad2(builder, bld->bld_base.uint_bld.vec_type, bld->total_emitted_vertices_vec_ptr[stream_id], ""); LLVMValueRef emitted_mask = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL, @@ -1977,8 +1977,7 @@ emit_prologue(struct lp_build_nir_soa_context *bld) LLVMValueRef lindex = lp_build_const_int32(gallivm, index * 4 + chan); LLVMValueRef input_ptr = - LLVMBuildGEP(gallivm->builder, bld->inputs_array, - &lindex, 1, ""); + LLVMBuildGEP2(gallivm->builder, vec_type, bld->inputs_array, &lindex, 1, ""); LLVMValueRef value = bld->inputs[index][chan]; if (value) LLVMBuildStore(gallivm->builder, value, input_ptr); @@ -2015,7 +2014,7 @@ static void emit_vote(struct lp_build_nir_context *bld_base, LLVMValueRef src, lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); - init_val = LLVMBuildLoad(builder, eq_store, ""); + init_val = LLVMBuildLoad2(builder, get_int_bld(bld_base, true, bit_size)->elem_type, eq_store, ""); } else { LLVMBuildStore(builder, lp_build_const_int32(gallivm, instr->intrinsic == nir_intrinsic_vote_any ? 0 : -1), res_store); } @@ -2029,7 +2028,7 @@ static void emit_vote(struct lp_build_nir_context *bld_base, LLVMValueRef src, if_cond = LLVMBuildExtractElement(gallivm->builder, outer_cond, loop_state.counter, ""); lp_build_if(&ifthen, gallivm, if_cond); - res = LLVMBuildLoad(builder, res_store, ""); + res = LLVMBuildLoad2(builder, bld_base->uint_bld.elem_type, res_store, ""); if (instr->intrinsic == nir_intrinsic_vote_feq) { struct lp_build_context *flt_bld = get_flt_bld(bld_base, bit_size); @@ -2050,7 +2049,8 @@ static void emit_vote(struct lp_build_nir_context *bld_base, LLVMValueRef src, lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); - result[0] = lp_build_broadcast_scalar(&bld_base->uint_bld, LLVMBuildLoad(builder, res_store, "")); + result[0] = lp_build_broadcast_scalar(&bld_base->uint_bld, + LLVMBuildLoad2(builder, bld_base->uint_bld.elem_type, res_store, "")); } static void emit_ballot(struct lp_build_nir_context *bld_base, LLVMValueRef src, nir_intrinsic_instr *instr, LLVMValueRef result[4]) @@ -2065,7 +2065,7 @@ static void emit_ballot(struct lp_build_nir_context *bld_base, LLVMValueRef src, lp_build_loop_begin(&loop_state, gallivm, lp_build_const_int32(gallivm, 0)); LLVMValueRef value_ptr = LLVMBuildExtractElement(gallivm->builder, src, loop_state.counter, ""); - res = LLVMBuildLoad(builder, res_store, ""); + res = LLVMBuildLoad2(builder, bld_base->int_bld.elem_type, res_store, ""); res = LLVMBuildOr(builder, res, LLVMBuildAnd(builder, value_ptr, LLVMBuildShl(builder, lp_build_const_int32(gallivm, 1), loop_state.counter, ""), ""), ""); @@ -2073,7 +2073,8 @@ static void emit_ballot(struct lp_build_nir_context *bld_base, LLVMValueRef src, lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); - result[0] = lp_build_broadcast_scalar(&bld_base->uint_bld, LLVMBuildLoad(builder, res_store, "")); + result[0] = lp_build_broadcast_scalar(&bld_base->uint_bld, + LLVMBuildLoad2(builder, bld_base->int_bld.elem_type, res_store, "")); } static void emit_elect(struct lp_build_nir_context *bld_base, LLVMValueRef result[4]) @@ -2094,7 +2095,7 @@ static void emit_elect(struct lp_build_nir_context *bld_base, LLVMValueRef resul lp_build_const_int32(gallivm, -1), ""); LLVMValueRef cond2 = LLVMBuildICmp(gallivm->builder, LLVMIntEQ, - LLVMBuildLoad(builder, found_store, ""), + LLVMBuildLoad2(builder, bld_base->int_bld.elem_type, found_store, ""), lp_build_const_int32(gallivm, 0), ""); cond = LLVMBuildAnd(builder, cond, cond2, ""); @@ -2108,7 +2109,7 @@ static void emit_elect(struct lp_build_nir_context *bld_base, LLVMValueRef resul result[0] = LLVMBuildInsertElement(builder, bld_base->uint_bld.zero, lp_build_const_int32(gallivm, -1), - LLVMBuildLoad(builder, idx_store, ""), + LLVMBuildLoad2(builder, bld_base->int_bld.elem_type, idx_store, ""), ""); } @@ -2316,9 +2317,9 @@ static void emit_reduce(struct lp_build_nir_context *bld_base, LLVMValueRef src, LLVMValueRef value = LLVMBuildExtractElement(gallivm->builder, src, loop_state.counter, ""); LLVMValueRef res = NULL; - LLVMValueRef scan_val = LLVMBuildLoad(gallivm->builder, scan_store, ""); + LLVMValueRef scan_val = LLVMBuildLoad2(gallivm->builder, int_bld->elem_type, scan_store, ""); if (instr->intrinsic != nir_intrinsic_reduce) - res = LLVMBuildLoad(gallivm->builder, res_store, ""); + res = LLVMBuildLoad2(gallivm->builder, int_bld->vec_type, res_store, ""); if (instr->intrinsic == nir_intrinsic_exclusive_scan) res = LLVMBuildInsertElement(builder, res, scan_val, loop_state.counter, ""); @@ -2374,9 +2375,9 @@ static void emit_reduce(struct lp_build_nir_context *bld_base, LLVMValueRef src, lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); if (instr->intrinsic == nir_intrinsic_reduce) - result[0] = lp_build_broadcast_scalar(int_bld, LLVMBuildLoad(builder, scan_store, "")); + result[0] = lp_build_broadcast_scalar(int_bld, LLVMBuildLoad2(builder, int_bld->elem_type, scan_store, "")); else - result[0] = LLVMBuildLoad(builder, res_store, ""); + result[0] = LLVMBuildLoad2(builder, int_bld->vec_type, res_store, ""); } static void emit_read_invocation(struct lp_build_nir_context *bld_base, @@ -2409,7 +2410,7 @@ static void emit_read_invocation(struct lp_build_nir_context *bld_base, lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, -1), lp_build_const_int32(gallivm, -1), LLVMIntEQ); - idx = LLVMBuildLoad(builder, res_store, ""); + idx = LLVMBuildLoad2(builder, bld_base->int_bld.elem_type, res_store, ""); LLVMValueRef value = LLVMBuildExtractElement(gallivm->builder, src, idx, ""); @@ -2492,18 +2493,18 @@ emit_load_scratch(struct lp_build_nir_context *bld_base, LLVMValueRef ptr2 = LLVMBuildBitCast(builder, bld->scratch_ptr, LLVMPointerType(load_bld->elem_type, 0), ""); scalar = lp_build_pointer_get(builder, ptr2, loop_index); - temp_res = LLVMBuildLoad(builder, result, ""); + temp_res = LLVMBuildLoad2(builder, load_bld->vec_type, result, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, result, ""); + temp_res = LLVMBuildLoad2(builder, load_bld->vec_type, result, ""); LLVMValueRef zero = lp_build_zero_bits(gallivm, bit_size); temp_res = LLVMBuildInsertElement(builder, temp_res, zero, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result); lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - outval[c] = LLVMBuildLoad(gallivm->builder, result, ""); + outval[c] = LLVMBuildLoad2(gallivm->builder, load_bld->vec_type, result, ""); } } @@ -2737,10 +2738,10 @@ void lp_build_nir_soa(struct gallivm_state *gallivm, end_primitive_masked(&bld.bld_base, lp_build_mask_value(bld.mask), i); total_emitted_vertices_vec = - LLVMBuildLoad(builder, bld.total_emitted_vertices_vec_ptr[i], ""); + LLVMBuildLoad2(builder, bld.bld_base.uint_bld.vec_type, bld.total_emitted_vertices_vec_ptr[i], ""); emitted_prims_vec = - LLVMBuildLoad(builder, bld.emitted_prims_vec_ptr[i], ""); + LLVMBuildLoad2(builder, bld.bld_base.uint_bld.vec_type, bld.emitted_prims_vec_ptr[i], ""); bld.gs_iface->gs_epilogue(bld.gs_iface, total_emitted_vertices_vec, emitted_prims_vec, i); -- GitLab From 12cac07fe6e02d4557f0b4843e7eb526dc2f2292 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:04:44 +0300 Subject: [PATCH 16/22] gallivm: use LLVM opaque pointers in lp_bld_sample.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_sample.c | 49 ++++++++----------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index f04b692204fc7..97f9766798856 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -1163,6 +1163,16 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld, lp_build_name(*lod_fpart_inout, "texture%u_mipweight", texture_unit); } +/** + * A helper function that factorizes this common pattern. + */ +static LLVMValueRef +load_mip(struct gallivm_state *gallivm, LLVMValueRef offsets, LLVMValueRef index1) { + LLVMValueRef zero = lp_build_const_int32(gallivm, 0); + LLVMValueRef indexes[2] = {zero, index1}; + LLVMValueRef ptr = LLVMBuildGEP(gallivm->builder, offsets, indexes, ARRAY_SIZE(indexes), ""); + return LLVMBuildLoad(gallivm->builder, ptr, ""); +} /** * Return pointer to a single mipmap level. @@ -1172,14 +1182,9 @@ LLVMValueRef lp_build_get_mipmap_level(struct lp_build_sample_context *bld, LLVMValueRef level) { + LLVMValueRef mip_offset = load_mip(bld->gallivm, bld->mip_offsets, level); LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef indexes[2], data_ptr, mip_offset; - - indexes[0] = lp_build_const_int32(bld->gallivm, 0); - indexes[1] = level; - mip_offset = LLVMBuildGEP(builder, bld->mip_offsets, indexes, 2, ""); - mip_offset = LLVMBuildLoad(builder, mip_offset, ""); - data_ptr = LLVMBuildGEP(builder, bld->base_ptr, &mip_offset, 1, ""); + LLVMValueRef data_ptr = LLVMBuildGEP(builder, bld->base_ptr, &mip_offset, 1, ""); return data_ptr; } @@ -1192,13 +1197,10 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, LLVMValueRef level) { LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef indexes[2], offsets, offset1; + LLVMValueRef offsets, offset1; - indexes[0] = lp_build_const_int32(bld->gallivm, 0); if (bld->num_mips == 1) { - indexes[1] = level; - offset1 = LLVMBuildGEP(builder, bld->mip_offsets, indexes, 2, ""); - offset1 = LLVMBuildLoad(builder, offset1, ""); + offset1 = load_mip(bld->gallivm, bld->mip_offsets, level); offsets = lp_build_broadcast_scalar(&bld->int_coord_bld, offset1); } else if (bld->num_mips == bld->coord_bld.type.length / 4) { @@ -1207,10 +1209,8 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, offsets = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); + offset1 = load_mip(bld->gallivm, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); - indexes[1] = LLVMBuildExtractElement(builder, level, indexi, ""); - offset1 = LLVMBuildGEP(builder, bld->mip_offsets, indexes, 2, ""); - offset1 = LLVMBuildLoad(builder, offset1, ""); offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexo, ""); } offsets = lp_build_swizzle_scalar_aos(&bld->int_coord_bld, offsets, 0, 4); @@ -1223,9 +1223,7 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, offsets = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - indexes[1] = LLVMBuildExtractElement(builder, level, indexi, ""); - offset1 = LLVMBuildGEP(builder, bld->mip_offsets, indexes, 2, ""); - offset1 = LLVMBuildLoad(builder, offset1, ""); + offset1 = load_mip(bld->gallivm, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexi, ""); } } @@ -1310,12 +1308,9 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, LLVMValueRef stride_array, LLVMValueRef level) { LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef indexes[2], stride, stride1; - indexes[0] = lp_build_const_int32(bld->gallivm, 0); + LLVMValueRef stride, stride1; if (bld->num_mips == 1) { - indexes[1] = level; - stride1 = LLVMBuildGEP(builder, stride_array, indexes, 2, ""); - stride1 = LLVMBuildLoad(builder, stride1, ""); + stride1 = load_mip(bld->gallivm, stride_array, level); stride = lp_build_broadcast_scalar(&bld->int_coord_bld, stride1); } else if (bld->num_mips == bld->coord_bld.type.length / 4) { @@ -1325,10 +1320,8 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, stride = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); + stride1 = load_mip(bld->gallivm, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); - indexes[1] = LLVMBuildExtractElement(builder, level, indexi, ""); - stride1 = LLVMBuildGEP(builder, stride_array, indexes, 2, ""); - stride1 = LLVMBuildLoad(builder, stride1, ""); stride = LLVMBuildInsertElement(builder, stride, stride1, indexo, ""); } stride = lp_build_swizzle_scalar_aos(&bld->int_coord_bld, stride, 0, 4); @@ -1342,9 +1335,7 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, stride = bld->int_coord_bld.undef; for (i = 0; i < bld->coord_bld.type.length; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - indexes[1] = LLVMBuildExtractElement(builder, level, indexi, ""); - stride1 = LLVMBuildGEP(builder, stride_array, indexes, 2, ""); - stride1 = LLVMBuildLoad(builder, stride1, ""); + stride1 = load_mip(bld->gallivm, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); stride = LLVMBuildInsertElement(builder, stride, stride1, indexi, ""); } } -- GitLab From 1f636e7fb20292a1d377ea89404b8c10f5cf061e Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:06:06 +0300 Subject: [PATCH 17/22] gallivm: use LLVM opaque pointers in lp_bld_sample_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_sample_soa.c | 171 +++++++++--------- 1 file changed, 86 insertions(+), 85 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c index 8417cdd79fc9d..09f6080fca223 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c @@ -1078,6 +1078,8 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, flt_size, &flt_width_vec, &flt_height_vec, &flt_depth_vec); + LLVMTypeRef int1t = LLVMInt1TypeInContext(bld->gallivm->context); + /* * Compute integer texcoords. */ @@ -1130,7 +1132,6 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, } else { struct lp_build_if_state edge_if; - LLVMTypeRef int1t; LLVMValueRef new_faces[4], new_xcoords[4][2], new_ycoords[4][2]; LLVMValueRef coord0, coord1, have_edge, have_corner; LLVMValueRef fall_off_ym_notxm, fall_off_ym_notxp, fall_off_x, fall_off_y; @@ -1183,7 +1184,6 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, have_edge = lp_build_any_true_range(ivec_bld, ivec_bld->type.length, have_edge); /* needed for accurate corner filtering branch later, rely on 0 init */ - int1t = LLVMInt1TypeInContext(bld->gallivm->context); have_corners = lp_build_alloca(bld->gallivm, int1t, "have_corner"); for (texel_index = 0; texel_index < 4; texel_index++) { @@ -1302,18 +1302,19 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, lp_build_endif(&edge_if); - x00 = LLVMBuildLoad(builder, xs[0], ""); - x01 = LLVMBuildLoad(builder, xs[1], ""); - x10 = LLVMBuildLoad(builder, xs[2], ""); - x11 = LLVMBuildLoad(builder, xs[3], ""); - y00 = LLVMBuildLoad(builder, ys[0], ""); - y01 = LLVMBuildLoad(builder, ys[1], ""); - y10 = LLVMBuildLoad(builder, ys[2], ""); - y11 = LLVMBuildLoad(builder, ys[3], ""); - z00 = LLVMBuildLoad(builder, zs[0], ""); - z01 = LLVMBuildLoad(builder, zs[1], ""); - z10 = LLVMBuildLoad(builder, zs[2], ""); - z11 = LLVMBuildLoad(builder, zs[3], ""); + LLVMTypeRef type = ivec_bld->vec_type; + x00 = LLVMBuildLoad2(builder, type, xs[0], ""); + x01 = LLVMBuildLoad2(builder, type, xs[1], ""); + x10 = LLVMBuildLoad2(builder, type, xs[2], ""); + x11 = LLVMBuildLoad2(builder, type, xs[3], ""); + y00 = LLVMBuildLoad2(builder, type, ys[0], ""); + y01 = LLVMBuildLoad2(builder, type, ys[1], ""); + y10 = LLVMBuildLoad2(builder, type, ys[2], ""); + y11 = LLVMBuildLoad2(builder, type, ys[3], ""); + z00 = LLVMBuildLoad2(builder, type, zs[0], ""); + z01 = LLVMBuildLoad2(builder, type, zs[1], ""); + z10 = LLVMBuildLoad2(builder, type, zs[2], ""); + z11 = LLVMBuildLoad2(builder, type, zs[3], ""); } if (linear_mask) { @@ -1411,7 +1412,7 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, colorss[2] = lp_build_alloca(bld->gallivm, coord_bld->vec_type, "cs2"); colorss[3] = lp_build_alloca(bld->gallivm, coord_bld->vec_type, "cs3"); - have_corner = LLVMBuildLoad(builder, have_corners, ""); + have_corner = LLVMBuildLoad2(builder, int1t, have_corners, ""); lp_build_if(&corner_if, bld->gallivm, have_corner); @@ -1668,10 +1669,10 @@ lp_build_sample_image_linear(struct lp_build_sample_context *bld, lp_build_endif(&corner_if); - colors0[0] = LLVMBuildLoad(builder, colorss[0], ""); - colors0[1] = LLVMBuildLoad(builder, colorss[1], ""); - colors0[2] = LLVMBuildLoad(builder, colorss[2], ""); - colors0[3] = LLVMBuildLoad(builder, colorss[3], ""); + colors0[0] = LLVMBuildLoad2(builder, coord_bld->vec_type, colorss[0], ""); + colors0[1] = LLVMBuildLoad2(builder, coord_bld->vec_type, colorss[1], ""); + colors0[2] = LLVMBuildLoad2(builder, coord_bld->vec_type, colorss[2], ""); + colors0[3] = LLVMBuildLoad2(builder, coord_bld->vec_type, colorss[3], ""); } if (dims == 3) { @@ -2306,7 +2307,7 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, LLVMBuildBr(builder, v_loop_block); LLVMPositionBuilderAtEnd(builder, v_loop_block); - LLVMValueRef v_val = LLVMBuildLoad(builder, v_limiter, ""); + LLVMValueRef v_val = LLVMBuildLoad2(builder, bld->int_coord_bld.vec_type, v_limiter, ""); LLVMValueRef v_mask = LLVMBuildICmp(builder, LLVMIntSLE, v_val, @@ -2338,7 +2339,7 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, LLVMBuildBr(builder, u_loop_block); LLVMPositionBuilderAtEnd(builder, u_loop_block); - LLVMValueRef u_val = LLVMBuildLoad(builder, u_limiter, ""); + LLVMValueRef u_val = LLVMBuildLoad2(builder, bld->int_coord_bld.vec_type, u_limiter, ""); LLVMValueRef u_mask = LLVMBuildICmp(builder, LLVMIntSLE, u_val, @@ -2347,7 +2348,7 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, /* loop over U values */ { /* q = (int)q */ - q = lp_build_itrunc(coord_bld, LLVMBuildLoad(builder, q_store, "")); + q = lp_build_itrunc(coord_bld, LLVMBuildLoad2(builder, bld->coord_bld.vec_type, q_store, "")); /* * avoid OOB access to filter table, generate a mask for q > 1024, @@ -2403,7 +2404,7 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, temp_colors); for (chan = 0; chan < 4; chan++) { - LLVMValueRef tcolor = LLVMBuildLoad(builder, colors0[chan], ""); + LLVMValueRef tcolor = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, colors0[chan], ""); tcolor = lp_build_add(&bld->texel_bld, tcolor, lp_build_mul(&bld->texel_bld, temp_colors[chan], weights)); LLVMBuildStore(builder, tcolor, colors0[chan]); @@ -2411,22 +2412,22 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, /* multiple colors by weight and add in. */ /* den += weight; */ - LLVMValueRef den = LLVMBuildLoad(builder, den_store, ""); + LLVMValueRef den = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, den_store, ""); den = lp_build_add(&bld->texel_bld, den, weights); LLVMBuildStore(builder, den, den_store); lp_build_endif(&noloadw0); /* q += dq; */ /* dq += ddq; */ - q = LLVMBuildLoad(builder, q_store, ""); - dq = LLVMBuildLoad(builder, dq_store, ""); + q = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, q_store, ""); + dq = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, dq_store, ""); q = lp_build_add(coord_bld, q, dq); dq = lp_build_add(coord_bld, dq, ddq); LLVMBuildStore(builder, q, q_store); LLVMBuildStore(builder, dq, dq_store); } /* u += 1 */ - u_val = LLVMBuildLoad(builder, u_limiter, ""); + u_val = LLVMBuildLoad2(builder, bld->int_coord_bld.vec_type, u_limiter, ""); u_val = lp_build_add(&bld->int_coord_bld, u_val, bld->int_coord_bld.one); LLVMBuildStore(builder, u_val, u_limiter); @@ -2447,7 +2448,7 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, } /* v += 1 */ - v_val = LLVMBuildLoad(builder, v_limiter, ""); + v_val = LLVMBuildLoad2(builder, bld->int_coord_bld.vec_type, v_limiter, ""); v_val = lp_build_add(&bld->int_coord_bld, v_val, bld->int_coord_bld.one); LLVMBuildStore(builder, v_val, v_limiter); @@ -2465,10 +2466,10 @@ lp_build_sample_aniso(struct lp_build_sample_context *bld, LLVMPositionBuilderAtEnd(builder, v_end_loop); - LLVMValueRef den = LLVMBuildLoad(builder, den_store, ""); + LLVMValueRef den = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, den_store, ""); for (chan = 0; chan < 4; chan++) - colors0[chan] = lp_build_div(&bld->texel_bld, LLVMBuildLoad(builder, colors0[chan], ""), den); + colors0[chan] = lp_build_div(&bld->texel_bld, LLVMBuildLoad2(builder, bld->texel_bld.vec_type, colors0[chan], ""), den); LLVMValueRef den0 = lp_build_cmp(&bld->coord_bld, PIPE_FUNC_EQUAL, den, bld->coord_bld.zero); LLVMValueRef den0_any = lp_build_any_true_range(&bld->coord_bld, bld->coord_bld.type.length, den0); @@ -2710,7 +2711,7 @@ lp_build_clamp_border_color(struct lp_build_sample_context *bld, lp_build_const_int32(gallivm, 0)); border_color_ptr = LLVMBuildBitCast(builder, border_color_ptr, LLVMPointerType(vec4_bld.vec_type, 0), ""); - border_color = LLVMBuildLoad(builder, border_color_ptr, ""); + border_color = LLVMBuildLoad2(builder, vec4_bld.vec_type, border_color_ptr, ""); /* we don't have aligned type in the dynamic state unfortunately */ LLVMSetAlignment(border_color, 4); @@ -3055,7 +3056,7 @@ lp_build_sample_general(struct lp_build_sample_context *bld, } for (chan = 0; chan < 4; ++chan) { - colors_out[chan] = LLVMBuildLoad(builder, texels[chan], ""); + colors_out[chan] = LLVMBuildLoad2(builder, bld->texel_bld.vec_type, texels[chan], ""); lp_build_name(colors_out[chan], "sampler%u_texel_%c", sampler_unit, "xyzw"[chan]); } } @@ -4116,60 +4117,60 @@ lp_build_sample_soa_func(struct gallivm_state *gallivm, function = LLVMGetNamedFunction(module, func_name); - if(!function) { - LLVMTypeRef arg_types[LP_MAX_TEX_FUNC_ARGS]; - LLVMTypeRef ret_type; - LLVMTypeRef function_type; - LLVMTypeRef val_type[4]; - unsigned num_param = 0; + LLVMTypeRef arg_types[LP_MAX_TEX_FUNC_ARGS]; + LLVMTypeRef ret_type; + LLVMTypeRef val_type[4]; + unsigned num_param = 0; - /* - * Generate the function prototype. - */ + /* + * Generate the function prototype. + */ - arg_types[num_param++] = LLVMTypeOf(params->context_ptr); - if (params->aniso_filter_table) - arg_types[num_param++] = LLVMTypeOf(params->aniso_filter_table); - if (need_cache) { - arg_types[num_param++] = LLVMTypeOf(params->thread_data_ptr); - } - for (i = 0; i < num_coords; i++) { - arg_types[num_param++] = LLVMTypeOf(coords[0]); - assert(LLVMTypeOf(coords[0]) == LLVMTypeOf(coords[i])); - } - if (layer) { - arg_types[num_param++] = LLVMTypeOf(coords[layer]); - assert(LLVMTypeOf(coords[0]) == LLVMTypeOf(coords[layer])); - } - if (sample_key & LP_SAMPLER_SHADOW) { - arg_types[num_param++] = LLVMTypeOf(coords[0]); - } - if (sample_key & LP_SAMPLER_FETCH_MS) { - arg_types[num_param++] = LLVMTypeOf(params->ms_index); - } - if (sample_key & LP_SAMPLER_OFFSETS) { - for (i = 0; i < num_offsets; i++) { - arg_types[num_param++] = LLVMTypeOf(offsets[0]); - assert(LLVMTypeOf(offsets[0]) == LLVMTypeOf(offsets[i])); - } - } - if (lod_control == LP_SAMPLER_LOD_BIAS || - lod_control == LP_SAMPLER_LOD_EXPLICIT) { - arg_types[num_param++] = LLVMTypeOf(params->lod); + arg_types[num_param++] = LLVMTypeOf(params->context_ptr); + if (params->aniso_filter_table) + arg_types[num_param++] = LLVMTypeOf(params->aniso_filter_table); + if (need_cache) { + arg_types[num_param++] = LLVMTypeOf(params->thread_data_ptr); + } + for (i = 0; i < num_coords; i++) { + arg_types[num_param++] = LLVMTypeOf(coords[0]); + assert(LLVMTypeOf(coords[0]) == LLVMTypeOf(coords[i])); + } + if (layer) { + arg_types[num_param++] = LLVMTypeOf(coords[layer]); + assert(LLVMTypeOf(coords[0]) == LLVMTypeOf(coords[layer])); + } + if (sample_key & LP_SAMPLER_SHADOW) { + arg_types[num_param++] = LLVMTypeOf(coords[0]); + } + if (sample_key & LP_SAMPLER_FETCH_MS) { + arg_types[num_param++] = LLVMTypeOf(params->ms_index); + } + if (sample_key & LP_SAMPLER_OFFSETS) { + for (i = 0; i < num_offsets; i++) { + arg_types[num_param++] = LLVMTypeOf(offsets[0]); + assert(LLVMTypeOf(offsets[0]) == LLVMTypeOf(offsets[i])); } - else if (lod_control == LP_SAMPLER_LOD_DERIVATIVES) { - for (i = 0; i < num_derivs; i++) { - arg_types[num_param++] = LLVMTypeOf(derivs->ddx[i]); - arg_types[num_param++] = LLVMTypeOf(derivs->ddy[i]); - assert(LLVMTypeOf(derivs->ddx[0]) == LLVMTypeOf(derivs->ddx[i])); - assert(LLVMTypeOf(derivs->ddy[0]) == LLVMTypeOf(derivs->ddy[i])); - } + } + if (lod_control == LP_SAMPLER_LOD_BIAS || + lod_control == LP_SAMPLER_LOD_EXPLICIT) { + arg_types[num_param++] = LLVMTypeOf(params->lod); + } + else if (lod_control == LP_SAMPLER_LOD_DERIVATIVES) { + for (i = 0; i < num_derivs; i++) { + arg_types[num_param++] = LLVMTypeOf(derivs->ddx[i]); + arg_types[num_param++] = LLVMTypeOf(derivs->ddy[i]); + assert(LLVMTypeOf(derivs->ddx[0]) == LLVMTypeOf(derivs->ddx[i])); + assert(LLVMTypeOf(derivs->ddy[0]) == LLVMTypeOf(derivs->ddy[i])); } + } - val_type[0] = val_type[1] = val_type[2] = val_type[3] = + val_type[0] = val_type[1] = val_type[2] = val_type[3] = lp_build_vec_type(gallivm, params->type); - ret_type = LLVMStructTypeInContext(gallivm->context, val_type, 4, 0); - function_type = LLVMFunctionType(ret_type, arg_types, num_param, 0); + ret_type = LLVMStructTypeInContext(gallivm->context, val_type, 4, 0); + LLVMTypeRef function_type = LLVMFunctionType(ret_type, arg_types, num_param, 0); + + if(!function) { function = LLVMAddFunction(module, func_name, function_type); for (i = 0; i < num_param; ++i) { @@ -4232,7 +4233,7 @@ lp_build_sample_soa_func(struct gallivm_state *gallivm, assert(num_args <= LP_MAX_TEX_FUNC_ARGS); - *tex_ret = LLVMBuildCall(builder, function, args, num_args, ""); + *tex_ret = LLVMBuildCall2(builder, function_type, function, args, num_args, ""); bb = LLVMGetInsertBlock(builder); inst = LLVMGetLastInstruction(bb); LLVMSetInstructionCallConv(inst, LLVMFastCallConv); @@ -4529,8 +4530,8 @@ lp_build_do_atomic_soa(struct gallivm_state *gallivm, return; } - LLVMValueRef atom_res = lp_build_alloca(gallivm, - LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), type.length), ""); + LLVMTypeRef atom_res_elem_type = LLVMVectorType(LLVMInt32TypeInContext(gallivm->context), type.length); + LLVMValueRef atom_res = lp_build_alloca(gallivm, atom_res_elem_type, ""); offset = LLVMBuildGEP(gallivm->builder, base_ptr, &offset, 1, ""); struct lp_build_loop_state loop_state; @@ -4567,14 +4568,14 @@ lp_build_do_atomic_soa(struct gallivm_state *gallivm, false); } - LLVMValueRef temp_res = LLVMBuildLoad(gallivm->builder, atom_res, ""); + LLVMValueRef temp_res = LLVMBuildLoad2(gallivm->builder, atom_res_elem_type, atom_res, ""); temp_res = LLVMBuildInsertElement(gallivm->builder, temp_res, data, loop_state.counter, ""); LLVMBuildStore(gallivm->builder, temp_res, atom_res); lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, type.length), NULL, LLVMIntUGE); - atomic_result[0] = LLVMBuildLoad(gallivm->builder, atom_res, ""); + atomic_result[0] = LLVMBuildLoad2(gallivm->builder, atom_res_elem_type, atom_res, ""); } static void -- GitLab From c8520c2a8fed749e6c280895748effb589bff79d Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:08:16 +0300 Subject: [PATCH 18/22] gallivm: use LLVM opaque pointers in lp_bld_struct.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 067740b5c8853..bd969d4681ae6 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -134,15 +134,7 @@ lp_build_pointer_get(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef index) { - LLVMValueRef element_ptr; - LLVMValueRef res; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - element_ptr = LLVMBuildGEP(builder, ptr, &index, 1, ""); - res = LLVMBuildLoad(builder, element_ptr, ""); -#ifdef DEBUG - lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); -#endif - return res; + return lp_build_pointer_get_unaligned(builder, ptr, index, 0); } @@ -157,7 +149,8 @@ lp_build_pointer_get_unaligned(LLVMBuilderRef builder, assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); element_ptr = LLVMBuildGEP(builder, ptr, &index, 1, ""); res = LLVMBuildLoad(builder, element_ptr, ""); - LLVMSetAlignment(res, alignment); + if (alignment) + LLVMSetAlignment(res, alignment); #ifdef DEBUG lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); #endif @@ -172,7 +165,7 @@ lp_build_pointer_set(LLVMBuilderRef builder, LLVMValueRef value) { LLVMValueRef element_ptr; - element_ptr = LLVMBuildGEP(builder, ptr, &index, 1, ""); + element_ptr = LLVMBuildGEP2(builder, LLVMTypeOf(value), ptr, &index, 1, ""); LLVMBuildStore(builder, value, element_ptr); } @@ -186,7 +179,7 @@ lp_build_pointer_set_unaligned(LLVMBuilderRef builder, { LLVMValueRef element_ptr; LLVMValueRef instr; - element_ptr = LLVMBuildGEP(builder, ptr, &index, 1, ""); + element_ptr = LLVMBuildGEP2(builder, LLVMTypeOf(value), ptr, &index, 1, ""); instr = LLVMBuildStore(builder, value, element_ptr); LLVMSetAlignment(instr, alignment); } -- GitLab From 32a55651cf4ecb830801acafe6410df3f66afca9 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:09:40 +0300 Subject: [PATCH 19/22] gallivm: use LLVM opaque pointers in lp_bld_tgsi_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_tgsi_soa.c | 82 ++++++++++--------- 1 file changed, 42 insertions(+), 40 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c index afaf35e5b11b7..262fa533b3a29 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c @@ -597,9 +597,10 @@ build_gather(struct lp_build_tgsi_context *bld_base, index = LLVMBuildExtractElement(builder, indexes, si, ""); } - scalar_ptr = LLVMBuildGEP(builder, base_ptr, + LLVMTypeRef scalar_type = LLVMGetElementType(LLVMTypeOf(res)); + scalar_ptr = LLVMBuildGEP2(builder, scalar_type, base_ptr, &index, 1, "gather_ptr"); - scalar = LLVMBuildLoad(builder, scalar_ptr, ""); + scalar = LLVMBuildLoad2(builder, scalar_type, scalar_ptr, ""); res = LLVMBuildInsertElement(builder, res, scalar, di, ""); } @@ -640,8 +641,8 @@ emit_mask_scatter(struct lp_build_tgsi_soa_context *bld, for (i = 0; i < bld->bld_base.base.type.length; i++) { LLVMValueRef ii = lp_build_const_int32(gallivm, i); LLVMValueRef index = LLVMBuildExtractElement(builder, indexes, ii, ""); - LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "scatter_ptr"); LLVMValueRef val = LLVMBuildExtractElement(builder, values, ii, "scatter_val"); + LLVMValueRef scalar_ptr = LLVMBuildGEP2(builder, LLVMTypeOf(val), base_ptr, &index, 1, "scatter_ptr"); LLVMValueRef scalar_pred = pred ? LLVMBuildExtractElement(builder, pred, ii, "scatter_pred") : NULL; @@ -651,7 +652,7 @@ emit_mask_scatter(struct lp_build_tgsi_soa_context *bld, if (scalar_pred) { LLVMValueRef real_val, dst_val; - dst_val = LLVMBuildLoad(builder, scalar_ptr, ""); + dst_val = LLVMBuildLoad2(builder, LLVMTypeOf(val), scalar_ptr, ""); real_val = lp_build_select(&bld->elem_bld, scalar_pred, val, dst_val); LLVMBuildStore(builder, real_val, scalar_ptr); } @@ -690,7 +691,7 @@ get_indirect_index(struct lp_build_tgsi_soa_context *bld, assert(swizzle < 4); switch (indirect_reg->File) { case TGSI_FILE_ADDRESS: - rel = LLVMBuildLoad(builder, + rel = LLVMBuildLoad2(builder, bld->bld_base.base.int_elem_type, bld->addr[indirect_reg->Index][swizzle], "load addr reg"); /* ADDR LLVM values already have LLVM integer type. */ @@ -890,23 +891,23 @@ emit_fetch_constant( res = LLVMBuildInsertElement(builder, res, scalar, shuffles[0], ""); res = LLVMBuildInsertElement(builder, res, scalar2, shuffles[1], ""); } else { + LLVMTypeRef scalar_type = NULL; if (stype == TGSI_TYPE_DOUBLE) { - LLVMTypeRef dptr_type = LLVMPointerType(LLVMDoubleTypeInContext(gallivm->context), 0); - scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, dptr_type, ""); + scalar_type = LLVMPointerType(LLVMDoubleTypeInContext(gallivm->context), 0); + scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, scalar_type, ""); bld_broad = &bld_base->dbl_bld; } else if (stype == TGSI_TYPE_UNSIGNED64) { - LLVMTypeRef u64ptr_type = LLVMPointerType(LLVMInt64TypeInContext(gallivm->context), 0); - scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, u64ptr_type, ""); + scalar_type = LLVMPointerType(LLVMInt64TypeInContext(gallivm->context), 0); + scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, scalar_type, ""); bld_broad = &bld_base->uint64_bld; } else if (stype == TGSI_TYPE_SIGNED64) { - LLVMTypeRef i64ptr_type = LLVMPointerType(LLVMInt64TypeInContext(gallivm->context), 0); - scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, i64ptr_type, ""); + scalar_type = LLVMPointerType(LLVMInt64TypeInContext(gallivm->context), 0); + scalar_ptr = LLVMBuildBitCast(builder, scalar_ptr, scalar_type, ""); bld_broad = &bld_base->int64_bld; } - scalar = LLVMBuildLoad(builder, scalar_ptr, ""); + scalar = LLVMBuildLoad2(builder, scalar_type, scalar_ptr, ""); res = lp_build_broadcast_scalar(bld_broad, scalar); } - } if (stype == TGSI_TYPE_SIGNED || stype == TGSI_TYPE_UNSIGNED || stype == TGSI_TYPE_DOUBLE || stype == TGSI_TYPE_SIGNED64 || stype == TGSI_TYPE_UNSIGNED64) { @@ -1003,7 +1004,7 @@ emit_fetch_immediate( gep[1] = lp_build_const_int32(gallivm, reg->Register.Index * 4 + swizzle); LLVMValueRef imms_ptr = LLVMBuildGEP(builder, bld->imms_array, gep, 2, ""); - res = LLVMBuildLoad(builder, imms_ptr, ""); + res = LLVMBuildLoad2(builder, bld_base->base.vec_type, imms_ptr, ""); if (tgsi_type_is_64bit(stype)) { LLVMValueRef imms_ptr2; @@ -1012,7 +1013,7 @@ emit_fetch_immediate( reg->Register.Index * 4 + (swizzle_in >> 16)); imms_ptr2 = LLVMBuildGEP(builder, bld->imms_array, gep, 2, ""); - res2 = LLVMBuildLoad(builder, imms_ptr2, ""); + res2 = LLVMBuildLoad2(builder, bld_base->base.vec_type, imms_ptr2, ""); res = emit_fetch_64bit(bld_base, stype, res, res2); } } @@ -1076,10 +1077,10 @@ emit_fetch_input( if (bld->indirect_files & (1 << TGSI_FILE_INPUT)) { LLVMValueRef lindex = lp_build_const_int32(gallivm, reg->Register.Index * 4 + swizzle); - LLVMValueRef input_ptr = LLVMBuildGEP(builder, + LLVMValueRef input_ptr = LLVMBuildGEP2(builder, bld_base->base.vec_type, bld->inputs_array, &lindex, 1, ""); - res = LLVMBuildLoad(builder, input_ptr, ""); + res = LLVMBuildLoad2(builder, bld_base->base.vec_type, input_ptr, ""); if (tgsi_type_is_64bit(stype)) { LLVMValueRef lindex1; LLVMValueRef input_ptr2; @@ -1087,9 +1088,9 @@ emit_fetch_input( lindex1 = lp_build_const_int32(gallivm, reg->Register.Index * 4 + (swizzle_in >> 16)); - input_ptr2 = LLVMBuildGEP(builder, + input_ptr2 = LLVMBuildGEP2(builder, bld_base->base.vec_type, bld->inputs_array, &lindex1, 1, ""); - res2 = LLVMBuildLoad(builder, input_ptr2, ""); + res2 = LLVMBuildLoad2(builder, bld_base->base.vec_type, input_ptr2, ""); res = emit_fetch_64bit(bld_base, stype, res, res2); } } @@ -1444,13 +1445,13 @@ emit_fetch_temporary( else { LLVMValueRef temp_ptr; temp_ptr = lp_get_temp_ptr_soa(bld, reg->Register.Index, swizzle); - res = LLVMBuildLoad(builder, temp_ptr, ""); + res = LLVMBuildLoad2(builder, bld->bld_base.base.vec_type, temp_ptr, ""); if (tgsi_type_is_64bit(stype)) { LLVMValueRef temp_ptr2, res2; temp_ptr2 = lp_get_temp_ptr_soa(bld, reg->Register.Index, swizzle_in >> 16); - res2 = LLVMBuildLoad(builder, temp_ptr2, ""); + res2 = LLVMBuildLoad2(builder, bld->bld_base.base.vec_type, temp_ptr2, ""); res = emit_fetch_64bit(bld_base, stype, res, res2); } } @@ -3539,17 +3540,17 @@ load_emit( lp_build_if(&ifthen, gallivm, cond); scalar = lp_build_pointer_get(builder, scalar_ptr, loop_index); - temp_res = LLVMBuildLoad(builder, result, ""); + temp_res = LLVMBuildLoad2(builder, uint_bld->vec_type, result, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, result, ""); + temp_res = LLVMBuildLoad2(builder, uint_bld->vec_type, result, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, lp_build_const_int32(gallivm, 0), loop_state.counter, ""); LLVMBuildStore(builder, temp_res, result); lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - emit_data->output[chan_index] = LLVMBuildLoad(gallivm->builder, result, ""); + emit_data->output[chan_index] = LLVMBuildLoad2(gallivm->builder, uint_bld->vec_type, result, ""); } } } @@ -3875,18 +3876,18 @@ atomic_emit( LLVMAtomicOrderingSequentiallyConsistent, false); } - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, uint_bld->vec_type, atom_res, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, scalar, loop_state.counter, ""); LLVMBuildStore(builder, temp_res, atom_res); lp_build_else(&ifthen); - temp_res = LLVMBuildLoad(builder, atom_res, ""); + temp_res = LLVMBuildLoad2(builder, uint_bld->vec_type, atom_res, ""); temp_res = LLVMBuildInsertElement(builder, temp_res, lp_build_const_int32(gallivm, 0), loop_state.counter, ""); LLVMBuildStore(builder, temp_res, atom_res); lp_build_endif(&ifthen); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, uint_bld->type.length), NULL, LLVMIntUGE); - emit_data->output[emit_data->chan] = LLVMBuildLoad(gallivm->builder, atom_res, ""); + emit_data->output[emit_data->chan] = LLVMBuildLoad2(gallivm->builder, uint_bld->vec_type, atom_res, ""); } } @@ -3921,7 +3922,7 @@ increment_vec_ptr_by_mask(struct lp_build_tgsi_context * bld_base, LLVMValueRef mask) { LLVMBuilderRef builder = bld_base->base.gallivm->builder; - LLVMValueRef current_vec = LLVMBuildLoad(builder, ptr, ""); + LLVMValueRef current_vec = LLVMBuildLoad2(builder, LLVMTypeOf(mask), ptr, ""); current_vec = LLVMBuildSub(builder, current_vec, mask, ""); @@ -3934,7 +3935,7 @@ clear_uint_vec_ptr_from_mask(struct lp_build_tgsi_context * bld_base, LLVMValueRef mask) { LLVMBuilderRef builder = bld_base->base.gallivm->builder; - LLVMValueRef current_vec = LLVMBuildLoad(builder, ptr, ""); + LLVMValueRef current_vec = LLVMBuildLoad2(builder, LLVMTypeOf(mask), ptr, ""); current_vec = lp_build_select(&bld_base->uint_bld, mask, @@ -3973,7 +3974,7 @@ emit_vertex( emit_data->inst->Src[0].Register.SwizzleX); LLVMValueRef mask = mask_vec(bld_base); LLVMValueRef total_emitted_vertices_vec = - LLVMBuildLoad(builder, bld->total_emitted_vertices_vec_ptr, ""); + LLVMBuildLoad2(builder, LLVMTypeOf(mask), bld->total_emitted_vertices_vec_ptr, ""); mask = clamp_mask_to_max_output_vertices(bld, mask, total_emitted_vertices_vec); @@ -4009,11 +4010,11 @@ end_primitive_masked(struct lp_build_tgsi_context * bld_base, if (bld->gs_iface->end_primitive) { struct lp_build_context *uint_bld = &bld_base->uint_bld; LLVMValueRef emitted_vertices_vec = - LLVMBuildLoad(builder, bld->emitted_vertices_vec_ptr, ""); + LLVMBuildLoad2(builder, uint_bld->vec_type, bld->emitted_vertices_vec_ptr, ""); LLVMValueRef emitted_prims_vec = - LLVMBuildLoad(builder, bld->emitted_prims_vec_ptr, ""); + LLVMBuildLoad2(builder, uint_bld->vec_type, bld->emitted_prims_vec_ptr, ""); LLVMValueRef total_emitted_vertices_vec = - LLVMBuildLoad(builder, bld->total_emitted_vertices_vec_ptr, ""); + LLVMBuildLoad2(builder, uint_bld->vec_type, bld->total_emitted_vertices_vec_ptr, ""); LLVMValueRef emitted_mask = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL, emitted_vertices_vec, uint_bld->zero); @@ -4048,7 +4049,7 @@ end_primitive_masked(struct lp_build_tgsi_context * bld_base, #if DUMP_GS_EMITS lp_build_print_value(bld->bld_base.base.gallivm, " +++ end prim emitted verts2 = ", - LLVMBuildLoad(builder, + LLVMBuildLoad2(builder, uint_bld->vec_type, bld->emitted_vertices_vec_ptr, "")); #endif } @@ -4312,14 +4313,15 @@ static void emit_prologue(struct lp_build_tgsi_context * bld_base) for (index = 0; index < bld_base->info->num_inputs; ++index) { for (chan = 0; chan < TGSI_NUM_CHANNELS; ++chan) { - LLVMValueRef lindex = - lp_build_const_int32(gallivm, index * 4 + chan); - LLVMValueRef input_ptr = - LLVMBuildGEP(gallivm->builder, bld->inputs_array, - &lindex, 1, ""); LLVMValueRef value = bld->inputs[index][chan]; - if (value) + if (value) { + LLVMValueRef lindex = + lp_build_const_int32(gallivm, index * 4 + chan); + LLVMValueRef input_ptr = + LLVMBuildGEP2(gallivm->builder, LLVMTypeOf(value), bld->inputs_array, + &lindex, 1, ""); LLVMBuildStore(gallivm->builder, value, input_ptr); + } } } } -- GitLab From 051f588bfef33169db2162ecf4a0e7d5e063100f Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:10:19 +0300 Subject: [PATCH 20/22] gallivm: use LLVM opaque pointers in lp_bld_tgsi_aos.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c index 85b2e8a207ea6..d04b84700c78e 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c @@ -206,7 +206,8 @@ emit_fetch_temporary( struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base); LLVMBuilderRef builder = bld_base->base.gallivm->builder; LLVMValueRef temp_ptr = bld->temps[reg->Register.Index]; - LLVMValueRef res = LLVMBuildLoad(builder, temp_ptr, ""); + LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type); + LLVMValueRef res = LLVMBuildLoad2(builder, vec_type, temp_ptr, ""); assert(!reg->Register.Indirect); if (!res) return bld->bld_base.base.undef; @@ -286,8 +287,8 @@ lp_emit_store_aos( if (mask) { LLVMValueRef orig_value; - - orig_value = LLVMBuildLoad(builder, ptr, ""); + LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type); + orig_value = LLVMBuildLoad2(builder, vec_type, ptr, ""); value = lp_build_select(&bld->bld_base.base, mask, value, orig_value); } -- GitLab From ccbee20f6b4d84240865caa6c4eabcbc6091f0f6 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 2 May 2022 16:11:07 +0300 Subject: [PATCH 21/22] gallivm: LLVM opaque pointers small changes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c | 2 +- src/gallium/auxiliary/gallivm/lp_bld_ir_common.c | 6 +++--- src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c b/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c index 7d106195d0a56..bc0bd4f4831ae 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c @@ -80,7 +80,7 @@ lp_build_fetch_rgba_aos_array(struct gallivm_state *gallivm, */ ptr = LLVMBuildGEP(builder, base_ptr, &offset, 1, ""); ptr = LLVMBuildPointerCast(builder, ptr, LLVMPointerType(src_vec_type, 0), ""); - res = LLVMBuildLoad(builder, ptr, ""); + res = LLVMBuildLoad2(builder, src_vec_type, ptr, ""); LLVMSetAlignment(res, src_type.width / 8); /* Truncate doubles to float */ diff --git a/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c b/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c index cecc8abc31b88..d127ea0c7ff84 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c @@ -215,7 +215,7 @@ void lp_exec_mask_store(struct lp_exec_mask *mask, if (exec_mask) { LLVMValueRef res, dst; - dst = LLVMBuildLoad(builder, dst_ptr, ""); + dst = LLVMBuildLoad2(builder, LLVMTypeOf(val), dst_ptr, ""); if (bld_store->type.width < 32) exec_mask = LLVMBuildTrunc(builder, exec_mask, bld_store->vec_type, ""); res = lp_build_select(bld_store, exec_mask, val, dst); @@ -230,7 +230,7 @@ void lp_exec_bgnloop_post_phi(struct lp_exec_mask *mask) struct function_ctx *ctx = func_ctx(mask); if (ctx->loop_stack_size != ctx->bgnloop_stack_size) { - mask->break_mask = LLVMBuildLoad(builder, ctx->break_var, ""); + mask->break_mask = LLVMBuildLoad2(builder, mask->int_vec_type, ctx->break_var, ""); lp_exec_mask_update(mask); ctx->bgnloop_stack_size = ctx->loop_stack_size; } @@ -303,7 +303,7 @@ void lp_exec_endloop(struct gallivm_state *gallivm, LLVMBuildStore(builder, mask->break_mask, ctx->break_var); /* Decrement the loop limiter */ - limiter = LLVMBuildLoad(builder, ctx->loop_limiter, ""); + limiter = LLVMBuildLoad2(builder, int_type, ctx->loop_limiter, ""); limiter = LLVMBuildSub( builder, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c index 0564b156d97cb..b0a9f48e8e016 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_aos.c @@ -1191,7 +1191,7 @@ lp_build_sample_aos(struct lp_build_sample_context *bld, lp_build_endif(&if_ctx); } - packed = LLVMBuildLoad(builder, packed_var, ""); + packed = LLVMBuildLoad2(builder, u8n_bld.vec_type, packed_var, ""); /* * Convert to SoA and swizzle. -- GitLab From ae6d32c938fc79ff5019806a2592097ca97bd945 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Wed, 20 Apr 2022 14:30:30 +0300 Subject: [PATCH 22/22] gallium: refactor a channel loop in draw_llvm.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acked-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/draw/draw_llvm.c | 36 ++++++++++---------------- 1 file changed, 13 insertions(+), 23 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index 1f68170d99e03..ee4ff8178a8a5 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -1651,29 +1651,19 @@ generate_clipmask(struct draw_llvm *llvm, indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, plane_idx); - indices[2] = lp_build_const_int32(gallivm, 0); - plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_x"); - planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - sum = LLVMBuildFMul(builder, planes, cv_x, ""); - - indices[2] = lp_build_const_int32(gallivm, 1); - plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_y"); - planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - sum = lp_build_fmuladd(builder, planes, cv_y, sum); - - indices[2] = lp_build_const_int32(gallivm, 2); - plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_z"); - planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - sum = lp_build_fmuladd(builder, planes, cv_z, sum); - - indices[2] = lp_build_const_int32(gallivm, 3); - plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); - plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, "plane_w"); - planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - sum = lp_build_fmuladd(builder, planes, cv_w, sum); + for (int i = 0; i < 4; ++i) { + indices[2] = lp_build_const_int32(gallivm, i); + plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); + plane1 = LLVMBuildLoad2(builder, vs_elem_type, plane_ptr, + (const char *[]){"plane_x", "plane_y", "plane_z", "plane_w"}[i]); + planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); + if (i == 0) { + sum = LLVMBuildFMul(builder, planes, cv_x, ""); + } else { + sum = lp_build_fmuladd(builder, planes, + (LLVMValueRef[]){cv_x, cv_y, cv_z, cv_w}[i], sum); + } + } test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_GREATER, zero, sum); temp = lp_build_const_int_vec(gallivm, i32_type, 1LL << plane_idx); -- GitLab From b549394992553330f191b589b32a30a1f6fb792f Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Thu, 30 Jun 2022 09:14:02 +0300 Subject: [PATCH 1/4] gallivm: fix a few llvm non-opaque pointers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As LLVM 15 transitions to opaque pointers, we need to update the deprecated methods dealing with non-opaque pointers. Reviewed-by: Brian Paul Acked-by: Marek Olšák Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_coro.c | 2 +- src/gallium/auxiliary/gallivm/lp_bld_format.c | 10 ++++++---- src/gallium/auxiliary/gallivm/lp_bld_format.h | 2 ++ .../auxiliary/gallivm/lp_bld_format_aos_array.c | 3 ++- src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c | 12 +++++++----- 5 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_coro.c b/src/gallium/auxiliary/gallivm/lp_bld_coro.c index a423f60d939a6..0214dcf674203 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_coro.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_coro.c @@ -206,7 +206,7 @@ LLVMValueRef lp_build_coro_alloc_mem_array(struct gallivm_state *gallivm, LLVMValueRef coro_num_hdls) { LLVMTypeRef mem_ptr_type = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0); - LLVMValueRef alloced_ptr = LLVMBuildLoad(gallivm->builder, coro_hdl_ptr, ""); + LLVMValueRef alloced_ptr = LLVMBuildLoad2(gallivm->builder, mem_ptr_type, coro_hdl_ptr, ""); LLVMValueRef not_alloced = LLVMBuildICmp(gallivm->builder, LLVMIntEQ, alloced_ptr, LLVMConstNull(mem_ptr_type), ""); LLVMValueRef coro_size = lp_build_coro_size(gallivm); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format.c b/src/gallium/auxiliary/gallivm/lp_bld_format.c index a82fd8feee815..d26485eb4973a 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format.c @@ -28,7 +28,10 @@ #include "lp_bld_format.h" - +LLVMTypeRef lp_build_format_cache_member_data_type(struct gallivm_state *gallivm) +{ + return LLVMArrayType(LLVMInt32TypeInContext(gallivm->context), LP_BUILD_FORMAT_CACHE_SIZE * 16); +} LLVMTypeRef lp_build_format_cache_type(struct gallivm_state *gallivm) @@ -36,9 +39,8 @@ lp_build_format_cache_type(struct gallivm_state *gallivm) LLVMTypeRef elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_COUNT]; LLVMTypeRef s; - elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_DATA] = - LLVMArrayType(LLVMInt32TypeInContext(gallivm->context), - LP_BUILD_FORMAT_CACHE_SIZE * 16); + elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_DATA] = lp_build_format_cache_member_data_type(gallivm); + elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_TAGS] = LLVMArrayType(LLVMInt64TypeInContext(gallivm->context), LP_BUILD_FORMAT_CACHE_SIZE); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format.h b/src/gallium/auxiliary/gallivm/lp_bld_format.h index 425b2f572f515..0ed1dca38864c 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_format.h @@ -82,6 +82,8 @@ enum { LLVMTypeRef lp_build_format_cache_type(struct gallivm_state *gallivm); +LLVMTypeRef +lp_build_format_cache_member_data_type(struct gallivm_state *gallivm); /* * AoS diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c b/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c index bc0bd4f4831ae..55b5bec53e591 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_aos_array.c @@ -78,7 +78,8 @@ lp_build_fetch_rgba_aos_array(struct gallivm_state *gallivm, * (If all callers can guarantee element type alignment, we should * relax alignment restrictions elsewhere.) */ - ptr = LLVMBuildGEP(builder, base_ptr, &offset, 1, ""); + LLVMTypeRef byte_type = LLVMInt8TypeInContext(gallivm->context); + ptr = LLVMBuildGEP2(builder, byte_type, base_ptr, &offset, 1, ""); ptr = LLVMBuildPointerCast(builder, ptr, LLVMPointerType(src_vec_type, 0), ""); res = LLVMBuildLoad2(builder, src_vec_type, ptr, ""); LLVMSetAlignment(res, src_type.width / 8); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c index 8f972b840fa66..5d91c779e88d2 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c @@ -1134,14 +1134,15 @@ s3tc_store_cached_block(struct gallivm_state *gallivm, indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); indices[2] = hash_index; - ptr = LLVMBuildGEP(builder, cache, indices, ARRAY_SIZE(indices), ""); + LLVMTypeRef cache_type = lp_build_format_cache_type(gallivm); + ptr = LLVMBuildGEP2(builder, cache_type, cache, indices, ARRAY_SIZE(indices), ""); LLVMBuildStore(builder, tag_value, ptr); indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_DATA); hash_index = LLVMBuildMul(builder, hash_index, lp_build_const_int32(gallivm, 16), ""); for (count = 0; count < 4; count++) { indices[2] = hash_index; - ptr = LLVMBuildGEP(builder, cache, indices, ARRAY_SIZE(indices), ""); + ptr = LLVMBuildGEP2(builder, cache_type, cache, indices, ARRAY_SIZE(indices), ""); ptr = LLVMBuildBitCast(builder, ptr, type_ptr4x32, ""); LLVMBuildStore(builder, col[count], ptr); hash_index = LLVMBuildAdd(builder, hash_index, lp_build_const_int32(gallivm, 4), ""); @@ -1150,7 +1151,7 @@ s3tc_store_cached_block(struct gallivm_state *gallivm, static LLVMValueRef s3tc_lookup_cached_pixel(struct gallivm_state *gallivm, - LLVMValueRef ptr, + LLVMValueRef cache, LLVMValueRef index) { LLVMBuilderRef builder = gallivm->builder; @@ -1159,8 +1160,9 @@ s3tc_lookup_cached_pixel(struct gallivm_state *gallivm, indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_DATA); indices[2] = index; - member_ptr = LLVMBuildGEP(builder, ptr, indices, ARRAY_SIZE(indices), ""); - return LLVMBuildLoad(builder, member_ptr, "cache_data"); + member_ptr = LLVMBuildGEP2(builder, lp_build_format_cache_type(gallivm), cache, indices, ARRAY_SIZE(indices), ""); + + return LLVMBuildLoad2(builder, lp_build_format_cache_member_data_type(gallivm), member_ptr, "cache_data"); } static LLVMValueRef -- GitLab From 8c4aef2abb9170c1f5590a7921383345b4626b1d Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Fri, 1 Jul 2022 12:52:25 +0300 Subject: [PATCH 2/4] gallivm: refactor a bit the cache access in view of LLVM opaque pointers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit LLVM 15 requires transition to opaque pointers; factorize a bit the cache memthods to help this transition. Reviewed-by: Brian Paul Acked-by: Marek Olšák Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_format.c | 30 +++++++++++---- src/gallium/auxiliary/gallivm/lp_bld_format.h | 7 +++- .../auxiliary/gallivm/lp_bld_format_s3tc.c | 38 ++++++++++--------- 3 files changed, 49 insertions(+), 26 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format.c b/src/gallium/auxiliary/gallivm/lp_bld_format.c index d26485eb4973a..796277feee702 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format.c @@ -28,9 +28,24 @@ #include "lp_bld_format.h" -LLVMTypeRef lp_build_format_cache_member_data_type(struct gallivm_state *gallivm) -{ - return LLVMArrayType(LLVMInt32TypeInContext(gallivm->context), LP_BUILD_FORMAT_CACHE_SIZE * 16); +LLVMTypeRef lp_build_format_cache_elem_type(struct gallivm_state *gallivm, enum cache_member member) { + assert(member == LP_BUILD_FORMAT_CACHE_MEMBER_DATA || member == LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); + switch (member) { + case LP_BUILD_FORMAT_CACHE_MEMBER_DATA: + return LLVMInt32TypeInContext(gallivm->context); + case LP_BUILD_FORMAT_CACHE_MEMBER_TAGS: + return LLVMInt64TypeInContext(gallivm->context); + default: + unreachable("lp_build_format_cache_elem_type unhandled member type"); + } +} + +LLVMTypeRef lp_build_format_cache_member_type(struct gallivm_state *gallivm, enum cache_member member) { + assert(member == LP_BUILD_FORMAT_CACHE_MEMBER_DATA || member == LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); + unsigned elem_count = + member == LP_BUILD_FORMAT_CACHE_MEMBER_DATA ? LP_BUILD_FORMAT_CACHE_SIZE * 16 : + member == LP_BUILD_FORMAT_CACHE_MEMBER_TAGS ? LP_BUILD_FORMAT_CACHE_SIZE : 0; + return LLVMArrayType(lp_build_format_cache_elem_type(gallivm, member), elem_count); } LLVMTypeRef @@ -39,11 +54,12 @@ lp_build_format_cache_type(struct gallivm_state *gallivm) LLVMTypeRef elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_COUNT]; LLVMTypeRef s; - elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_DATA] = lp_build_format_cache_member_data_type(gallivm); + int members[] = {LP_BUILD_FORMAT_CACHE_MEMBER_DATA, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS}; + for (int i = 0; i < ARRAY_SIZE(members); ++i) { + int member = members[i]; + elem_types[member] = lp_build_format_cache_member_type(gallivm, member); + } - elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_TAGS] = - LLVMArrayType(LLVMInt64TypeInContext(gallivm->context), - LP_BUILD_FORMAT_CACHE_SIZE); #if LP_BUILD_FORMAT_CACHE_DEBUG elem_types[LP_BUILD_FORMAT_CACHE_MEMBER_ACCESS_TOTAL] = LLVMInt64TypeInContext(gallivm->context); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format.h b/src/gallium/auxiliary/gallivm/lp_bld_format.h index 0ed1dca38864c..74a625dce7292 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_format.h @@ -68,7 +68,7 @@ struct lp_build_format_cache }; -enum { +enum cache_member { LP_BUILD_FORMAT_CACHE_MEMBER_DATA = 0, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS, #if LP_BUILD_FORMAT_CACHE_DEBUG @@ -83,7 +83,10 @@ LLVMTypeRef lp_build_format_cache_type(struct gallivm_state *gallivm); LLVMTypeRef -lp_build_format_cache_member_data_type(struct gallivm_state *gallivm); +lp_build_format_cache_member_type(struct gallivm_state *gallivm, enum cache_member member); + +LLVMTypeRef +lp_build_format_cache_elem_type(struct gallivm_state *gallivm, enum cache_member member); /* * AoS diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c index 5d91c779e88d2..fe44841528cb0 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c @@ -1150,35 +1150,39 @@ s3tc_store_cached_block(struct gallivm_state *gallivm, } static LLVMValueRef -s3tc_lookup_cached_pixel(struct gallivm_state *gallivm, - LLVMValueRef cache, - LLVMValueRef index) -{ +lookup_cache_member(struct gallivm_state *gallivm, LLVMValueRef cache, enum cache_member member, LLVMValueRef index) { + assert(member == LP_BUILD_FORMAT_CACHE_MEMBER_DATA || member == LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); LLVMBuilderRef builder = gallivm->builder; LLVMValueRef member_ptr, indices[3]; indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_DATA); + indices[1] = lp_build_const_int32(gallivm, member); indices[2] = index; - member_ptr = LLVMBuildGEP2(builder, lp_build_format_cache_type(gallivm), cache, indices, ARRAY_SIZE(indices), ""); - return LLVMBuildLoad2(builder, lp_build_format_cache_member_data_type(gallivm), member_ptr, "cache_data"); + const char *name = + member == LP_BUILD_FORMAT_CACHE_MEMBER_DATA ? "cache_data" : + member == LP_BUILD_FORMAT_CACHE_MEMBER_TAGS ? "tag_data" : ""; + + member_ptr = LLVMBuildGEP2(builder, lp_build_format_cache_type(gallivm), + cache, indices, ARRAY_SIZE(indices), "cache_gep"); + + return LLVMBuildLoad2(builder, lp_build_format_cache_elem_type(gallivm, member), member_ptr, name); +} + +static LLVMValueRef +s3tc_lookup_cached_pixel(struct gallivm_state *gallivm, + LLVMValueRef cache, + LLVMValueRef index) +{ + return lookup_cache_member(gallivm, cache, LP_BUILD_FORMAT_CACHE_MEMBER_DATA, index); } static LLVMValueRef s3tc_lookup_tag_data(struct gallivm_state *gallivm, - LLVMValueRef ptr, + LLVMValueRef cache, LLVMValueRef index) { - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef member_ptr, indices[3]; - - indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = lp_build_const_int32(gallivm, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS); - indices[2] = index; - LLVMTypeRef tag_type = LLVMInt64TypeInContext(gallivm->context); - member_ptr = LLVMBuildGEP(builder, ptr, indices, ARRAY_SIZE(indices), ""); - return LLVMBuildLoad2(builder, tag_type, member_ptr, "tag_data"); + return lookup_cache_member(gallivm, cache, LP_BUILD_FORMAT_CACHE_MEMBER_TAGS, index); } #if LP_BUILD_FORMAT_CACHE_DEBUG -- GitLab From f0fda08739e46dfcb552d4510c387130ee14874d Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 12 Jul 2022 23:21:49 +0300 Subject: [PATCH 3/4] gallivm: add lp_build_struct_get() variants that take the LLVM type MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is needed for LLVM-15 opaque pointers. The new variants taking the type are named with the suffix "2", using the same naming pattern LLVM (e.g. LLVMBuildGEP2 vs. LLVMBuildGEP). Reviewed-by: Brian Paul Acked-by: Marek Olšák Part-of: --- src/gallium/auxiliary/draw/draw_llvm.c | 165 +++++++++--------- src/gallium/auxiliary/draw/draw_llvm.h | 145 +++++++-------- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 49 +++++- src/gallium/auxiliary/gallivm/lp_bld_struct.h | 22 +++ 4 files changed, 225 insertions(+), 156 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index 4f952e0e17c48..4ec2883c2dd0a 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -307,37 +307,28 @@ create_jit_image_type(struct gallivm_state *gallivm, const char *struct_name) * Create LLVM type for struct draw_jit_context */ static LLVMTypeRef -create_jit_context_type(struct gallivm_state *gallivm, - LLVMTypeRef texture_type, LLVMTypeRef sampler_type, - LLVMTypeRef image_type, - const char *struct_name) +create_jit_context_type(struct gallivm_state *gallivm, const char *struct_name) { + LLVMTypeRef texture_type = create_jit_texture_type(gallivm, "texture"); + LLVMTypeRef sampler_type = create_jit_sampler_type(gallivm, "sampler"); + LLVMTypeRef image_type = create_jit_image_type(gallivm, "image"); + LLVMTargetDataRef target = gallivm->target; LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); LLVMTypeRef int_type = LLVMInt32TypeInContext(gallivm->context); LLVMTypeRef elem_types[DRAW_JIT_CTX_NUM_FIELDS]; - LLVMTypeRef context_type; - elem_types[0] = LLVMArrayType(LLVMPointerType(float_type, 0), /* vs_constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[1] = LLVMArrayType(int_type, /* num_vs_constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[2] = LLVMPointerType(LLVMArrayType(LLVMArrayType(float_type, 4), - DRAW_TOTAL_CLIP_PLANES), 0); - elem_types[3] = LLVMPointerType(float_type, 0); /* viewports */ - elem_types[4] = LLVMArrayType(texture_type, - PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */ - elem_types[5] = LLVMArrayType(sampler_type, - PIPE_MAX_SAMPLERS); /* samplers */ - elem_types[6] = LLVMArrayType(image_type, - PIPE_MAX_SHADER_IMAGES); /* images */ - elem_types[7] = LLVMArrayType(LLVMPointerType(int_type, 0), /* vs_ssbo */ - LP_MAX_TGSI_SHADER_BUFFERS); - elem_types[8] = LLVMArrayType(int_type, /* num_vs_ssbos */ - LP_MAX_TGSI_SHADER_BUFFERS); - elem_types[9] = LLVMPointerType(float_type, 0); /* aniso table */ - context_type = LLVMStructTypeInContext(gallivm->context, elem_types, - ARRAY_SIZE(elem_types), 0); + elem_types[DRAW_JIT_CTX_CONSTANTS] = LLVMArrayType(LLVMPointerType(float_type, 0), LP_MAX_TGSI_CONST_BUFFERS); + elem_types[DRAW_JIT_CTX_NUM_CONSTANTS] = LLVMArrayType(int_type, LP_MAX_TGSI_CONST_BUFFERS); + elem_types[DRAW_JIT_CTX_PLANES] = LLVMPointerType(LLVMArrayType(LLVMArrayType(float_type, 4), DRAW_TOTAL_CLIP_PLANES), 0); + elem_types[DRAW_JIT_CTX_VIEWPORT] = LLVMPointerType(float_type, 0); + elem_types[DRAW_JIT_CTX_TEXTURES] = LLVMArrayType(texture_type, PIPE_MAX_SHADER_SAMPLER_VIEWS); + elem_types[DRAW_JIT_CTX_SAMPLERS] = LLVMArrayType(sampler_type, PIPE_MAX_SAMPLERS); + elem_types[DRAW_JIT_CTX_IMAGES] = LLVMArrayType(image_type, PIPE_MAX_SHADER_IMAGES); + elem_types[DRAW_JIT_CTX_SSBOS] = LLVMArrayType(LLVMPointerType(int_type, 0), LP_MAX_TGSI_SHADER_BUFFERS); + elem_types[DRAW_JIT_CTX_NUM_SSBOS] = LLVMArrayType(int_type, LP_MAX_TGSI_SHADER_BUFFERS); + elem_types[DRAW_JIT_CTX_ANISO_FILTER_TABLE] = LLVMPointerType(float_type, 0); + LLVMTypeRef context_type = LLVMStructTypeInContext(gallivm->context, elem_types, ARRAY_SIZE(elem_types), 0); (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants, @@ -720,16 +711,9 @@ static void create_jit_types(struct draw_llvm_variant *variant) { struct gallivm_state *gallivm = variant->gallivm; - LLVMTypeRef texture_type, sampler_type, context_type, image_type; - texture_type = create_jit_texture_type(gallivm, "texture"); - sampler_type = create_jit_sampler_type(gallivm, "sampler"); - image_type = create_jit_image_type(gallivm, "image"); - - context_type = create_jit_context_type(gallivm, texture_type, sampler_type, - image_type, - "draw_jit_context"); - variant->context_ptr_type = LLVMPointerType(context_type, 0); + variant->context_type = create_jit_context_type(gallivm, "draw_jit_context"); + variant->context_ptr_type = LLVMPointerType(variant->context_type, 0); variant->buffer_type = create_jit_dvbuffer_type(gallivm, "draw_vertex_buffer"); variant->buffer_ptr_type = LLVMPointerType(variant->buffer_type, 0); @@ -983,13 +967,13 @@ generate_vs(struct draw_llvm_variant *variant, struct draw_llvm *llvm = variant->llvm; const struct tgsi_token *tokens = llvm->draw->vs.vertex_shader->state.tokens; LLVMValueRef consts_ptr = - draw_jit_context_vs_constants(variant->gallivm, context_ptr); + draw_jit_context_vs_constants(variant, context_ptr); LLVMValueRef num_consts_ptr = - draw_jit_context_num_vs_constants(variant->gallivm, context_ptr); + draw_jit_context_num_vs_constants(variant, context_ptr); LLVMValueRef ssbos_ptr = - draw_jit_context_vs_ssbos(variant->gallivm, context_ptr); + draw_jit_context_vs_ssbos(variant, context_ptr); LLVMValueRef num_ssbos_ptr = - draw_jit_context_num_vs_ssbos(variant->gallivm, context_ptr); + draw_jit_context_num_vs_ssbos(variant, context_ptr); struct lp_build_tgsi_params params; memset(¶ms, 0, sizeof(params)); @@ -1006,7 +990,7 @@ generate_vs(struct draw_llvm_variant *variant, params.ssbo_ptr = ssbos_ptr; params.ssbo_sizes_ptr = num_ssbos_ptr; params.image = draw_image; - params.aniso_filter_table = draw_jit_context_aniso_filter_table(variant->gallivm, context_ptr); + params.aniso_filter_table = draw_jit_context_aniso_filter_table(variant, context_ptr); if (llvm->draw->vs.vertex_shader->state.ir.nir && llvm->draw->vs.vertex_shader->state.type == PIPE_SHADER_IR_NIR) @@ -1161,13 +1145,14 @@ fetch_vector(struct gallivm_state *gallivm, static void store_aos(struct gallivm_state *gallivm, + LLVMTypeRef io_type, LLVMValueRef io_ptr, LLVMValueRef index, LLVMValueRef value) { LLVMTypeRef data_ptr_type = LLVMPointerType(lp_build_vec_type(gallivm, lp_float32_vec4_type()), 0); LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef data_ptr = draw_jit_header_data(gallivm, io_ptr); + LLVMValueRef data_ptr = draw_jit_header_data(gallivm, io_type, io_ptr); LLVMValueRef indices[3]; indices[0] = lp_build_const_int32(gallivm, 0); @@ -1240,6 +1225,7 @@ adjust_mask(struct gallivm_state *gallivm, static void store_aos_array(struct gallivm_state *gallivm, struct lp_type soa_type, + LLVMTypeRef io_type, LLVMValueRef io_ptr, LLVMValueRef *indices, LLVMValueRef* aos, @@ -1265,7 +1251,7 @@ store_aos_array(struct gallivm_state *gallivm, } else { inds[i] = linear_inds[i]; } - io_ptrs[i] = LLVMBuildGEP(builder, io_ptr, &inds[i], 1, ""); + io_ptrs[i] = LLVMBuildGEP2(builder, io_type, io_ptr, &inds[i], 1, ""); } if (attrib == 0) { @@ -1289,7 +1275,7 @@ store_aos_array(struct gallivm_state *gallivm, /* OR with the clipmask */ cliptmp = LLVMBuildOr(builder, val, clipmask, ""); for (i = 0; i < vector_length; i++) { - LLVMValueRef id_ptr = draw_jit_header_id(gallivm, io_ptrs[i]); + LLVMValueRef id_ptr = draw_jit_header_id(gallivm, io_type, io_ptrs[i]); val = LLVMBuildExtractElement(builder, cliptmp, linear_inds[i], ""); val = adjust_mask(gallivm, val); #if DEBUG_STORE @@ -1302,13 +1288,14 @@ store_aos_array(struct gallivm_state *gallivm, /* store for each of the n vertices */ for (i = 0; i < vector_length; i++) { - store_aos(gallivm, io_ptrs[i], attr_index, aos[i]); + store_aos(gallivm, io_type, io_ptrs[i], attr_index, aos[i]); } } static void convert_to_aos(struct gallivm_state *gallivm, + LLVMTypeRef io_type, LLVMValueRef io, LLVMValueRef *indices, LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS], @@ -1367,7 +1354,9 @@ convert_to_aos(struct gallivm_state *gallivm, store_aos_array(gallivm, soa_type, - io, indices, + io_type, + io, + indices, aos, attrib, num_outputs, @@ -1386,6 +1375,7 @@ convert_to_aos(struct gallivm_state *gallivm, static void store_clip(struct gallivm_state *gallivm, const struct lp_type vs_type, + LLVMTypeRef io_type, LLVMValueRef io_ptr, LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS], int idx) @@ -1403,7 +1393,7 @@ store_clip(struct gallivm_state *gallivm, for (i = 0; i < vs_type.length; i++) { inds[i] = lp_build_const_int32(gallivm, i); - io_ptrs[i] = LLVMBuildGEP(builder, io_ptr, &inds[i], 1, ""); + io_ptrs[i] = LLVMBuildGEP2(builder, io_type, io_ptr, &inds[i], 1, ""); } soa[0] = LLVMBuildLoad(builder, outputs[idx][0], ""); /*x0 x1 .. xn*/ @@ -1412,7 +1402,7 @@ store_clip(struct gallivm_state *gallivm, soa[3] = LLVMBuildLoad(builder, outputs[idx][3], ""); /*w0 w1 .. wn*/ for (i = 0; i < vs_type.length; i++) { - clip_ptrs[i] = draw_jit_header_clip_pos(gallivm, io_ptrs[i]); + clip_ptrs[i] = draw_jit_header_clip_pos(gallivm, io_type, io_ptrs[i]); } lp_build_transpose_aos(gallivm, vs_type, soa, soa); @@ -1451,7 +1441,7 @@ generate_viewport(struct draw_llvm_variant *variant, LLVMTypeRef vs_type_llvm = lp_build_vec_type(gallivm, vs_type); LLVMValueRef out3 = LLVMBuildLoad2(builder, vs_type_llvm, outputs[pos][3], ""); /*w0 w1 .. wn*/ LLVMValueRef const1 = lp_build_const_vec(gallivm, f32_type, 1.0); /*1.0 1.0 1.0 1.0*/ - LLVMValueRef vp_ptr = draw_jit_context_viewports(gallivm, context_ptr); + LLVMValueRef vp_ptr = draw_jit_context_viewports(variant, context_ptr); /* We treat pipe_viewport_state as a float array */ const int scale_index_offset = offsetof(struct pipe_viewport_state, scale) / sizeof(float); @@ -1504,6 +1494,7 @@ generate_clipmask(struct draw_llvm *llvm, struct lp_type vs_type, LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS], struct draw_llvm_variant_key *key, + LLVMTypeRef context_type, LLVMValueRef context_ptr, boolean *have_clipdist) { @@ -1623,7 +1614,7 @@ generate_clipmask(struct draw_llvm *llvm, } if (clip_user) { - LLVMValueRef planes_ptr = draw_jit_context_planes(gallivm, context_ptr); + LLVMValueRef planes_ptr = draw_jit_context_planes(gallivm, context_type, context_ptr); LLVMValueRef indices[3]; LLVMValueRef is_nan_or_inf; @@ -1834,7 +1825,8 @@ draw_gs_llvm_emit_vertex(const struct lp_build_gs_iface *gs_base, do_clamp_vertex_color(gallivm, gs_type, gs_info, outputs); } - convert_to_aos(gallivm, io, indices, + convert_to_aos(gallivm, variant->vertex_header_type, + io, indices, outputs, clipmask, gs_info->num_outputs, gs_type, FALSE); @@ -1854,7 +1846,7 @@ draw_gs_llvm_end_primitive(const struct lp_build_gs_iface *gs_base, struct gallivm_state *gallivm = variant->gallivm; LLVMBuilderRef builder = gallivm->builder; LLVMValueRef prim_lengts_ptr = - draw_gs_jit_prim_lengths(variant->gallivm, variant->context_ptr); + draw_gs_jit_prim_lengths(variant, variant->context_ptr); unsigned i; LLVMValueRef cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE, mask_vec, lp_build_const_int_vec(gallivm, bld->type, 0), ""); @@ -1889,9 +1881,9 @@ draw_gs_llvm_epilogue(const struct lp_build_gs_iface *gs_base, struct gallivm_state *gallivm = variant->gallivm; LLVMBuilderRef builder = gallivm->builder; LLVMValueRef emitted_verts_ptr = - draw_gs_jit_emitted_vertices(gallivm, variant->context_ptr); + draw_gs_jit_emitted_vertices(variant, variant->context_ptr); LLVMValueRef emitted_prims_ptr = - draw_gs_jit_emitted_prims(gallivm, variant->context_ptr); + draw_gs_jit_emitted_prims(variant, variant->context_ptr); LLVMValueRef stream_val = lp_build_const_int32(gallivm, stream); emitted_verts_ptr = LLVMBuildGEP(builder, emitted_verts_ptr, &stream_val, 1, ""); @@ -2097,12 +2089,12 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) if (velem->src_format != PIPE_FORMAT_NONE) { vbuffer_ptr = LLVMBuildGEP2(builder, variant->buffer_type, vbuffers_ptr, &vb_index, 1, ""); vb_info = LLVMBuildGEP2(builder, variant->vb_type, vb_ptr, &vb_index, 1, ""); - vb_stride[j] = draw_jit_vbuffer_stride(gallivm, vb_info); + vb_stride[j] = draw_jit_vbuffer_stride(gallivm, variant->vb_type, vb_info); vb_stride[j] = LLVMBuildZExt(gallivm->builder, vb_stride[j], LLVMInt32TypeInContext(context), ""); - vb_buffer_offset = draw_jit_vbuffer_offset(gallivm, vb_info); - map_ptr[j] = draw_jit_dvbuffer_map(gallivm, vbuffer_ptr); - buffer_size = draw_jit_dvbuffer_size(gallivm, vbuffer_ptr); + vb_buffer_offset = draw_jit_vbuffer_offset(gallivm, variant->vb_type, vb_info); + map_ptr[j] = draw_jit_dvbuffer_map(gallivm, variant->buffer_type, vbuffer_ptr); + buffer_size = draw_jit_dvbuffer_size(gallivm, variant->buffer_type, vbuffer_ptr); ofbit = NULL; /* @@ -2317,7 +2309,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) lp_build_mask_end(&mask); if (pos != -1 && cv != -1) { /* store original positions in clip before further manipulation */ - store_clip(gallivm, vs_type, io, outputs, pos); + store_clip(gallivm, vs_type, variant->vertex_header_type, io, outputs, pos); /* do cliptest */ if (enable_cliptest) { @@ -2328,6 +2320,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) vs_type, outputs, key, + variant->context_type, context_ptr, &have_clipdist); temp = LLVMBuildOr(builder, clipmask, temp, ""); /* store temporary clipping boolean value */ @@ -2350,7 +2343,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) * original positions in clip * and transformed positions in data */ - convert_to_aos(gallivm, io, NULL, outputs, clipmask, + convert_to_aos(gallivm, variant->vertex_header_type, io, NULL, outputs, clipmask, vs_info->num_outputs, vs_type, enable_cliptest && key->need_edgeflags); } @@ -2695,18 +2688,18 @@ static void create_gs_jit_types(struct draw_gs_llvm_variant *var) { struct gallivm_state *gallivm = var->gallivm; - LLVMTypeRef texture_type, sampler_type, image_type, context_type; + LLVMTypeRef texture_type, sampler_type, image_type; texture_type = create_jit_texture_type(gallivm, "texture"); sampler_type = create_jit_sampler_type(gallivm, "sampler"); image_type = create_jit_image_type(gallivm, "image"); - context_type = create_gs_jit_context_type(gallivm, + var->context_type = create_gs_jit_context_type(gallivm, var->shader->base.vector_length, texture_type, sampler_type, image_type, "draw_gs_jit_context"); - var->context_ptr_type = LLVMPointerType(context_type, 0); + var->context_ptr_type = LLVMPointerType(var->context_type, 0); var->input_array_type = create_gs_jit_input_type(gallivm); } @@ -2850,13 +2843,13 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, gs_type.width = 32; /* 32-bit float */ gs_type.length = vector_length; - consts_ptr = draw_gs_jit_context_constants(variant->gallivm, context_ptr); + consts_ptr = draw_gs_jit_context_constants(variant, context_ptr); num_consts_ptr = - draw_gs_jit_context_num_constants(variant->gallivm, context_ptr); + draw_gs_jit_context_num_constants(variant, context_ptr); - ssbos_ptr = draw_gs_jit_context_ssbos(variant->gallivm, context_ptr); + ssbos_ptr = draw_gs_jit_context_ssbos(variant, context_ptr); num_ssbos_ptr = - draw_gs_jit_context_num_ssbos(variant->gallivm, context_ptr); + draw_gs_jit_context_num_ssbos(variant, context_ptr); /* code generated texture sampling */ sampler = draw_llvm_sampler_soa_create(variant->key.samplers, @@ -2895,7 +2888,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, params.ssbo_sizes_ptr = num_ssbos_ptr; params.image = image; params.gs_vertex_streams = variant->shader->base.num_vertex_streams; - params.aniso_filter_table = draw_gs_jit_context_aniso_filter_table(gallivm, context_ptr); + params.aniso_filter_table = draw_gs_jit_context_aniso_filter_table(variant, context_ptr); if (llvm->draw->gs.geometry_shader->state.type == PIPE_SHADER_IR_TGSI) lp_build_tgsi_soa(variant->gallivm, @@ -2926,7 +2919,6 @@ draw_gs_llvm_create_variant(struct draw_llvm *llvm, struct draw_gs_llvm_variant *variant; struct llvm_geometry_shader *shader = llvm_geometry_shader(llvm->draw->gs.geometry_shader); - LLVMTypeRef vertex_header; char module_name[64]; unsigned char ir_sha1_cache_key[20]; struct lp_cached_code cached = { 0 }; @@ -2963,9 +2955,8 @@ draw_gs_llvm_create_variant(struct draw_llvm *llvm, create_gs_jit_types(variant); - vertex_header = create_jit_vertex_header(variant->gallivm, num_outputs); - - variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0); + variant->vertex_header_type = create_jit_vertex_header(variant->gallivm, num_outputs); + variant->vertex_header_ptr_type = LLVMPointerType(variant->vertex_header_type, 0); draw_gs_llvm_generate(llvm, variant); @@ -3083,20 +3074,20 @@ static void create_tcs_jit_types(struct draw_tcs_llvm_variant *var) { struct gallivm_state *gallivm = var->gallivm; - LLVMTypeRef texture_type, sampler_type, image_type, context_type; + LLVMTypeRef texture_type, sampler_type, image_type; texture_type = create_jit_texture_type(gallivm, "texture"); sampler_type = create_jit_sampler_type(gallivm, "sampler"); image_type = create_jit_image_type(gallivm, "image"); - context_type = create_tcs_jit_context_type(gallivm, + var->context_type = create_tcs_jit_context_type(gallivm, 0, texture_type, sampler_type, image_type, "draw_tcs_jit_context"); var->input_array_type = create_tcs_jit_input_type(gallivm); var->output_array_type = create_tcs_jit_output_type(gallivm); - var->context_ptr_type = LLVMPointerType(context_type, 0); + var->context_ptr_type = LLVMPointerType(var->context_type, 0); } static LLVMTypeRef @@ -3496,13 +3487,13 @@ draw_tcs_llvm_generate(struct draw_llvm *llvm, patch_vertices_in = LLVMGetParam(variant_coro, 4); view_index = LLVMGetParam(variant_coro, 5); - consts_ptr = draw_tcs_jit_context_constants(variant->gallivm, context_ptr); + consts_ptr = draw_tcs_jit_context_constants(variant, context_ptr); num_consts_ptr = - draw_tcs_jit_context_num_constants(variant->gallivm, context_ptr); + draw_tcs_jit_context_num_constants(variant, context_ptr); - ssbos_ptr = draw_tcs_jit_context_ssbos(variant->gallivm, context_ptr); + ssbos_ptr = draw_tcs_jit_context_ssbos(variant, context_ptr); num_ssbos_ptr = - draw_tcs_jit_context_num_ssbos(variant->gallivm, context_ptr); + draw_tcs_jit_context_num_ssbos(variant, context_ptr); sampler = draw_llvm_sampler_soa_create(variant->key.samplers, MAX2(variant->key.nr_samplers, variant->key.nr_sampler_views)); @@ -3559,7 +3550,7 @@ draw_tcs_llvm_generate(struct draw_llvm *llvm, params.image = image; params.coro = &coro_info; params.tcs_iface = &tcs_iface.base; - params.aniso_filter_table = draw_tcs_jit_context_aniso_filter_table(gallivm, context_ptr); + params.aniso_filter_table = draw_tcs_jit_context_aniso_filter_table(variant, context_ptr); lp_build_nir_soa(variant->gallivm, llvm->draw->tcs.tess_ctrl_shader->state.ir.nir, @@ -3745,18 +3736,18 @@ static void create_tes_jit_types(struct draw_tes_llvm_variant *var) { struct gallivm_state *gallivm = var->gallivm; - LLVMTypeRef texture_type, sampler_type, image_type, context_type; + LLVMTypeRef texture_type, sampler_type, image_type; texture_type = create_jit_texture_type(gallivm, "texture"); sampler_type = create_jit_sampler_type(gallivm, "sampler"); image_type = create_jit_image_type(gallivm, "image"); - context_type = create_tes_jit_context_type(gallivm, + var->context_type = create_tes_jit_context_type(gallivm, 0, texture_type, sampler_type, image_type, "draw_tes_jit_context"); - var->context_ptr_type = LLVMPointerType(context_type, 0); + var->context_ptr_type = LLVMPointerType(var->context_type, 0); var->input_array_deref_type = create_tes_jit_input_deref_type(gallivm); var->input_array_type = LLVMPointerType(var->input_array_deref_type, 0); /* num vertices per prim */ @@ -4013,13 +4004,13 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, tes_type.length = vector_length; lp_build_context_init(&bldvec, variant->gallivm, lp_int_type(tes_type)); - consts_ptr = draw_tes_jit_context_constants(variant->gallivm, context_ptr); + consts_ptr = draw_tes_jit_context_constants(variant, context_ptr); num_consts_ptr = - draw_tes_jit_context_num_constants(variant->gallivm, context_ptr); + draw_tes_jit_context_num_constants(variant, context_ptr); - ssbos_ptr = draw_tes_jit_context_ssbos(variant->gallivm, context_ptr); + ssbos_ptr = draw_tes_jit_context_ssbos(variant, context_ptr); num_ssbos_ptr = - draw_tes_jit_context_num_ssbos(variant->gallivm, context_ptr); + draw_tes_jit_context_num_ssbos(variant, context_ptr); sampler = draw_llvm_sampler_soa_create(variant->key.samplers, MAX2(variant->key.nr_samplers, variant->key.nr_sampler_views)); @@ -4088,7 +4079,7 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, params.ssbo_sizes_ptr = num_ssbos_ptr; params.image = image; params.tes_iface = &tes_iface.base; - params.aniso_filter_table = draw_tes_jit_context_aniso_filter_table(variant->gallivm, context_ptr); + params.aniso_filter_table = draw_tes_jit_context_aniso_filter_table(variant, context_ptr); lp_build_nir_soa(variant->gallivm, llvm->draw->tes.tess_eval_shader->state.ir.nir, @@ -4106,7 +4097,7 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, LLVMValueRef clipmask = lp_build_const_int_vec(gallivm, lp_int_type(tes_type), 0); - convert_to_aos(gallivm, io, NULL, outputs, clipmask, + convert_to_aos(gallivm, variant->vertex_header_type, io, NULL, outputs, clipmask, draw_total_tes_outputs(llvm->draw), tes_type, FALSE); } lp_build_loop_end_cond(&lp_loop, num_tess_coord, step, LLVMIntUGE); diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h index 50525cbd25b05..3e1946a3144f3 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.h +++ b/src/gallium/auxiliary/draw/draw_llvm.h @@ -188,17 +188,17 @@ enum { DRAW_JIT_CTX_NUM_FIELDS }; -#define draw_jit_context_vs_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_CONSTANTS, "vs_constants") +#define draw_jit_context_vs_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_CONSTANTS, "vs_constants") -#define draw_jit_context_num_vs_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_NUM_CONSTANTS, "num_vs_constants") +#define draw_jit_context_num_vs_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_NUM_CONSTANTS, "num_vs_constants") -#define draw_jit_context_planes(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_JIT_CTX_PLANES, "planes") +#define draw_jit_context_planes(_gallivm, _type, _ptr) \ + lp_build_struct_get2(_gallivm, _type, _ptr, DRAW_JIT_CTX_PLANES, "planes") -#define draw_jit_context_viewports(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_JIT_CTX_VIEWPORT, "viewports") +#define draw_jit_context_viewports(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_VIEWPORT, "viewports") #define draw_jit_context_textures(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_TEXTURES, "textures") @@ -209,31 +209,31 @@ enum { #define draw_jit_context_images(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_IMAGES, "images") -#define draw_jit_context_vs_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_SSBOS, "vs_ssbos") +#define draw_jit_context_vs_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_SSBOS, "vs_ssbos") -#define draw_jit_context_num_vs_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_NUM_SSBOS, "num_vs_ssbos") +#define draw_jit_context_num_vs_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_NUM_SSBOS, "num_vs_ssbos") -#define draw_jit_context_aniso_filter_table(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") +#define draw_jit_context_aniso_filter_table(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") -#define draw_jit_header_id(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_VERTEX_ID, "id") +#define draw_jit_header_id(_gallivm, _type, _ptr) \ + lp_build_struct_get_ptr2(_gallivm, _type, _ptr, DRAW_JIT_VERTEX_VERTEX_ID, "id") -#define draw_jit_header_clip_pos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_CLIP_POS, "clip_pos") +#define draw_jit_header_clip_pos(_gallivm, _type, _ptr) \ + lp_build_struct_get_ptr2(_gallivm, _type, _ptr, DRAW_JIT_VERTEX_CLIP_POS, "clip_pos") -#define draw_jit_header_data(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_VERTEX_DATA, "data") +#define draw_jit_header_data(_gallivm, _type, _ptr) \ + lp_build_struct_get_ptr2(_gallivm, _type, _ptr, DRAW_JIT_VERTEX_DATA, "data") -#define draw_jit_vbuffer_stride(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, 0, "stride") +#define draw_jit_vbuffer_stride(_gallivm, _type, _ptr) \ + lp_build_struct_get2(_gallivm, _type, _ptr, 0, "stride") -#define draw_jit_vbuffer_offset(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, 2, "buffer_offset") +#define draw_jit_vbuffer_offset(_gallivm, _type, _ptr) \ + lp_build_struct_get2(_gallivm, _type, _ptr, 2, "buffer_offset") enum { DRAW_JIT_DVBUFFER_MAP = 0, @@ -241,11 +241,11 @@ enum { DRAW_JIT_DVBUFFER_NUM_FIELDS /* number of fields above */ }; -#define draw_jit_dvbuffer_map(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_JIT_DVBUFFER_MAP, "map") +#define draw_jit_dvbuffer_map(_gallivm, _type, _ptr) \ + lp_build_struct_get2(_gallivm, _type, _ptr, DRAW_JIT_DVBUFFER_MAP, "map") -#define draw_jit_dvbuffer_size(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_JIT_DVBUFFER_SIZE, "size") +#define draw_jit_dvbuffer_size(_gallivm, _type, _ptr) \ + lp_build_struct_get2(_gallivm, _type, _ptr, DRAW_JIT_DVBUFFER_SIZE, "size") /** @@ -302,11 +302,11 @@ enum { DRAW_GS_JIT_CTX_NUM_FIELDS = 13 }; -#define draw_gs_jit_context_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_CONSTANTS, "constants") +#define draw_gs_jit_context_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_CONSTANTS, "constants") -#define draw_gs_jit_context_num_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_NUM_CONSTANTS, "num_constants") +#define draw_gs_jit_context_num_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_NUM_CONSTANTS, "num_constants") #define draw_gs_jit_context_planes(_gallivm, _ptr) \ lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_PLANES, "planes") @@ -323,23 +323,23 @@ enum { #define draw_gs_jit_context_images(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_IMAGES, "images") -#define draw_gs_jit_prim_lengths(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_PRIM_LENGTHS, "prim_lengths") +#define draw_gs_jit_prim_lengths(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_PRIM_LENGTHS, "prim_lengths") -#define draw_gs_jit_emitted_vertices(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_EMITTED_VERTICES, "emitted_vertices") +#define draw_gs_jit_emitted_vertices(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_EMITTED_VERTICES, "emitted_vertices") -#define draw_gs_jit_emitted_prims(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_EMITTED_PRIMS, "emitted_prims") +#define draw_gs_jit_emitted_prims(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_EMITTED_PRIMS, "emitted_prims") -#define draw_gs_jit_context_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_SSBOS, "ssbos") +#define draw_gs_jit_context_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_SSBOS, "ssbos") -#define draw_gs_jit_context_num_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_NUM_SSBOS, "num_ssbos") +#define draw_gs_jit_context_num_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_NUM_SSBOS, "num_ssbos") -#define draw_gs_jit_context_aniso_filter_table(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") +#define draw_gs_jit_context_aniso_filter_table(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") struct draw_tcs_jit_context { const float *constants[LP_MAX_TGSI_CONST_BUFFERS]; @@ -371,11 +371,11 @@ enum { DRAW_TCS_JIT_CTX_NUM_FIELDS = 10, }; -#define draw_tcs_jit_context_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_CONSTANTS, "constants") +#define draw_tcs_jit_context_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_CONSTANTS, "constants") -#define draw_tcs_jit_context_num_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_CONSTANTS, "num_constants") +#define draw_tcs_jit_context_num_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_NUM_CONSTANTS, "num_constants") #define draw_tcs_jit_context_textures(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_TEXTURES, "textures") @@ -386,14 +386,14 @@ enum { #define draw_tcs_jit_context_images(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_IMAGES, "images") -#define draw_tcs_jit_context_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SSBOS, "ssbos") +#define draw_tcs_jit_context_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_SSBOS, "ssbos") -#define draw_tcs_jit_context_num_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_SSBOS, "num_ssbos") +#define draw_tcs_jit_context_num_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_NUM_SSBOS, "num_ssbos") -#define draw_tcs_jit_context_aniso_filter_table(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_TCS_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") +#define draw_tcs_jit_context_aniso_filter_table(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") struct draw_tes_jit_context { const float *constants[LP_MAX_TGSI_CONST_BUFFERS]; @@ -425,11 +425,11 @@ enum { DRAW_TES_JIT_CTX_NUM_FIELDS = 10, }; -#define draw_tes_jit_context_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_CONSTANTS, "constants") +#define draw_tes_jit_context_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_CONSTANTS, "constants") -#define draw_tes_jit_context_num_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_CONSTANTS, "num_constants") +#define draw_tes_jit_context_num_constants(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_NUM_CONSTANTS, "num_constants") #define draw_tes_jit_context_textures(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_TEXTURES, "textures") @@ -440,14 +440,14 @@ enum { #define draw_tes_jit_context_images(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_IMAGES, "images") -#define draw_tes_jit_context_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SSBOS, "ssbos") +#define draw_tes_jit_context_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_SSBOS, "ssbos") -#define draw_tes_jit_context_num_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_SSBOS, "num_ssbos") +#define draw_tes_jit_context_num_ssbos(_variant, _ptr) \ + lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_NUM_SSBOS, "num_ssbos") -#define draw_tes_jit_context_aniso_filter_table(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_TES_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") +#define draw_tes_jit_context_aniso_filter_table(_variant, _ptr) \ + lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_ANISO_FILTER_TABLE, "aniso_filter_table") typedef boolean (*draw_jit_vert_func)(struct draw_jit_context *context, @@ -688,14 +688,17 @@ struct draw_llvm_variant struct gallivm_state *gallivm; /* LLVM JIT builder types */ + LLVMTypeRef context_type; LLVMTypeRef context_ptr_type; - LLVMTypeRef buffer_ptr_type; - LLVMTypeRef vb_ptr_type; - LLVMTypeRef vertex_header_ptr_type; LLVMTypeRef buffer_type; + LLVMTypeRef buffer_ptr_type; + LLVMTypeRef vb_type; + LLVMTypeRef vb_ptr_type; + LLVMTypeRef vertex_header_type; + LLVMTypeRef vertex_header_ptr_type; LLVMValueRef function; draw_jit_vert_func jit_func; @@ -716,8 +719,12 @@ struct draw_gs_llvm_variant struct gallivm_state *gallivm; /* LLVM JIT builder types */ + LLVMTypeRef context_type; LLVMTypeRef context_ptr_type; + + LLVMTypeRef vertex_header_type; LLVMTypeRef vertex_header_ptr_type; + LLVMTypeRef input_array_type; LLVMValueRef context_ptr; @@ -741,12 +748,13 @@ struct draw_tcs_llvm_variant struct gallivm_state *gallivm; /* LLVM JIT builder types */ + LLVMTypeRef context_type; LLVMTypeRef context_ptr_type; LLVMTypeRef input_array_type; LLVMTypeRef output_array_type; LLVMValueRef context_ptr; - LLVMValueRef io_ptr; + /* LLVMValueRef io_ptr; */ LLVMValueRef num_prims; LLVMValueRef function; draw_tcs_jit_func jit_func; @@ -766,6 +774,7 @@ struct draw_tes_llvm_variant struct gallivm_state *gallivm; /* LLVM JIT builder types */ + LLVMTypeRef context_type; LLVMTypeRef context_ptr_type; LLVMTypeRef vertex_header_ptr_type; LLVMTypeRef input_array_type; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index bd969d4681ae6..1007090410412 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -51,7 +51,12 @@ lp_build_struct_get_ptr(struct gallivm_state *gallivm, LLVMValueRef indices[2]; LLVMValueRef member_ptr; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); + + /* Starting with LLVM 15, we're not supposed to look at pointer element type anymore. */ +#if LLVM_VERSION_MAJOR < 15 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); +#endif + indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, member); member_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, ARRAY_SIZE(indices), ""); @@ -59,7 +64,6 @@ lp_build_struct_get_ptr(struct gallivm_state *gallivm, return member_ptr; } - LLVMValueRef lp_build_struct_get(struct gallivm_state *gallivm, LLVMValueRef ptr, @@ -69,13 +73,56 @@ lp_build_struct_get(struct gallivm_state *gallivm, LLVMValueRef member_ptr; LLVMValueRef res; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); +#if LLVM_VERSION_MAJOR < 15 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); +#endif member_ptr = lp_build_struct_get_ptr(gallivm, ptr, member, name); res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); return res; } +LLVMValueRef +lp_build_struct_get_ptr2(struct gallivm_state *gallivm, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + unsigned member, + const char *name) +{ + LLVMValueRef indices[2]; + LLVMValueRef member_ptr; + assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); + + /* Starting with LLVM 15, we're not supposed to look at pointer element type anymore. */ +#if LLVM_VERSION_MAJOR < 15 + assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); +#endif + + indices[0] = lp_build_const_int32(gallivm, 0); + indices[1] = lp_build_const_int32(gallivm, member); + member_ptr = LLVMBuildGEP2(gallivm->builder, ptr_type, ptr, indices, ARRAY_SIZE(indices), ""); + lp_build_name(member_ptr, "%s.%s_ptr", LLVMGetValueName(ptr), name); + return member_ptr; +} + +LLVMValueRef +lp_build_struct_get2(struct gallivm_state *gallivm, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + unsigned member, + const char *name) +{ + LLVMValueRef member_ptr; + LLVMValueRef res; + assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); +#if LLVM_VERSION_MAJOR < 15 + assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); +#endif + member_ptr = lp_build_struct_get_ptr2(gallivm, ptr_type, ptr, member, name); + res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); + lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); + return res; +} LLVMValueRef lp_build_array_get_ptr(struct gallivm_state *gallivm, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.h b/src/gallium/auxiliary/gallivm/lp_bld_struct.h index 6b7b4f2a6bf7d..a87519883b4df 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.h @@ -71,6 +71,28 @@ lp_build_struct_get(struct gallivm_state *gallivm, unsigned member, const char *name); +/** + * Get value pointer to a structure member. + * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. + */ +LLVMValueRef +lp_build_struct_get_ptr2(struct gallivm_state *gallivm, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + unsigned member, + const char *name); + +/** + * Get the value of a structure member. + * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. + */ +LLVMValueRef +lp_build_struct_get2(struct gallivm_state *gallivm, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + unsigned member, + const char *name); + /** * Get value pointer to an array element. */ -- GitLab From da9feae7355c15d489b916340ea2b62f9f8c0a7c Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Sat, 23 Jul 2022 08:45:55 +0300 Subject: [PATCH 4/4] gallivm: push LLVM version guard into assert The asserts that check the pointer element type can't be used on LLVM >= 15. Instead of using precompiler #if, use boolean shortcut in assert. Reviewed-by: Brian Paul Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 20 ++++--------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 1007090410412..be579c4ee25d7 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -51,11 +51,7 @@ lp_build_struct_get_ptr(struct gallivm_state *gallivm, LLVMValueRef indices[2]; LLVMValueRef member_ptr; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - - /* Starting with LLVM 15, we're not supposed to look at pointer element type anymore. */ -#if LLVM_VERSION_MAJOR < 15 - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); -#endif + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, member); @@ -73,9 +69,7 @@ lp_build_struct_get(struct gallivm_state *gallivm, LLVMValueRef member_ptr; LLVMValueRef res; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); -#if LLVM_VERSION_MAJOR < 15 - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); -#endif + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); member_ptr = lp_build_struct_get_ptr(gallivm, ptr, member, name); res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); @@ -92,11 +86,7 @@ lp_build_struct_get_ptr2(struct gallivm_state *gallivm, LLVMValueRef indices[2]; LLVMValueRef member_ptr; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - - /* Starting with LLVM 15, we're not supposed to look at pointer element type anymore. */ -#if LLVM_VERSION_MAJOR < 15 - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); -#endif + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = lp_build_const_int32(gallivm, member); @@ -115,9 +105,7 @@ lp_build_struct_get2(struct gallivm_state *gallivm, LLVMValueRef member_ptr; LLVMValueRef res; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); -#if LLVM_VERSION_MAJOR < 15 - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); -#endif + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); member_ptr = lp_build_struct_get_ptr2(gallivm, ptr_type, ptr, member, name); res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); -- GitLab From adf28955162007af80989b65df641b3c7ae6f78c Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Fri, 19 Aug 2022 11:56:35 +0300 Subject: [PATCH 1/9] gallivm: LLVM-15 opaque pointers: disable LLVMGetElementType(ptr_type) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit with opaque pointers, we can't query the element type of a pointer type Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_ir_common.c | 5 +++-- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 6 +++--- src/gallium/auxiliary/gallivm/lp_bld_swizzle.c | 2 +- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c b/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c index d127ea0c7ff84..042cd5c814f27 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_ir_common.c @@ -209,8 +209,9 @@ void lp_exec_mask_store(struct lp_exec_mask *mask, assert(lp_check_value(bld_store->type, val)); assert(LLVMGetTypeKind(LLVMTypeOf(dst_ptr)) == LLVMPointerTypeKind); - assert(LLVMGetElementType(LLVMTypeOf(dst_ptr)) == LLVMTypeOf(val) || - LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(dst_ptr))) == LLVMArrayTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 + || (LLVMGetElementType(LLVMTypeOf(dst_ptr)) == LLVMTypeOf(val) + || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(dst_ptr))) == LLVMArrayTypeKind)); if (exec_mask) { LLVMValueRef res, dst; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index be579c4ee25d7..9e3e24cd9e1e7 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -120,7 +120,7 @@ lp_build_array_get_ptr(struct gallivm_state *gallivm, LLVMValueRef indices[2]; LLVMValueRef element_ptr; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); indices[0] = lp_build_const_int32(gallivm, 0); indices[1] = index; element_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, ARRAY_SIZE(indices), ""); @@ -140,7 +140,7 @@ lp_build_array_get(struct gallivm_state *gallivm, LLVMValueRef element_ptr; LLVMValueRef res; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); element_ptr = lp_build_array_get_ptr(gallivm, ptr, index); res = LLVMBuildLoad(gallivm->builder, element_ptr, ""); #ifdef DEBUG @@ -158,7 +158,7 @@ lp_build_array_set(struct gallivm_state *gallivm, { LLVMValueRef element_ptr; assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); element_ptr = lp_build_array_get_ptr(gallivm, ptr, index); LLVMBuildStore(gallivm->builder, value, element_ptr); } diff --git a/src/gallium/auxiliary/gallivm/lp_bld_swizzle.c b/src/gallium/auxiliary/gallivm/lp_bld_swizzle.c index b23c4cbbf02be..904eaa034d6cb 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_swizzle.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_swizzle.c @@ -63,7 +63,7 @@ lp_build_broadcast(struct gallivm_state *gallivm, LLVMTypeRef i32_type = LLVMInt32TypeInContext(gallivm->context); LLVMTypeRef i32_vec_type = LLVMVectorType(i32_type, length); - assert(LLVMGetElementType(vec_type) == LLVMTypeOf(scalar)); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetElementType(vec_type) == LLVMTypeOf(scalar)); res = LLVMBuildInsertElement(builder, undef, scalar, LLVMConstNull(i32_type), ""); res = LLVMBuildShuffleVector(builder, res, undef, LLVMConstNull(i32_vec_type), ""); -- GitLab From 3668ebf8bd42bd9c9c9a7b8b5d4537198e5a2b4c Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 16 Aug 2022 09:44:53 +0300 Subject: [PATCH 2/9] gallivm: drop unused "emit_load" in lp_llvm_buffer_member() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_jit_types.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c index 6e6c63db9f39b..c4bfa2be899ce 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c @@ -60,8 +60,7 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, LLVMValueRef buffers_offset, unsigned buffers_limit, unsigned member_index, - const char *member_name, - boolean emit_load) + const char *member_name) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef indices[3]; @@ -74,7 +73,7 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, LLVMValueRef ptr = LLVMBuildGEP(builder, buffers_ptr, indices, ARRAY_SIZE(indices), ""); - LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; + LLVMValueRef res = LLVMBuildLoad(builder, ptr, ""); lp_build_name(res, "buffer.%s", member_name); @@ -90,7 +89,7 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, * sampler code generator a reusable module without dependencies to * llvmpipe internals. */ -#define LP_LLVM_BUFFER_MEMBER(_name, _index, _emit_load) \ +#define LP_LLVM_BUFFER_MEMBER(_name, _index) \ LLVMValueRef \ lp_llvm_buffer_##_name(struct gallivm_state *gallivm, \ LLVMValueRef buffers_ptr, \ @@ -98,8 +97,8 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, { \ return lp_llvm_buffer_member(gallivm, buffers_ptr, \ buffers_offset, buffers_limit, \ - _index, #_name, _emit_load ); \ + _index, #_name); \ } -LP_LLVM_BUFFER_MEMBER(base, LP_JIT_BUFFER_BASE, TRUE) -LP_LLVM_BUFFER_MEMBER(num_elements, LP_JIT_BUFFER_NUM_ELEMENTS, TRUE) +LP_LLVM_BUFFER_MEMBER(base, LP_JIT_BUFFER_BASE) +LP_LLVM_BUFFER_MEMBER(num_elements, LP_JIT_BUFFER_NUM_ELEMENTS) -- GitLab From 49c6e2fd70aa2db61e784e41f263c19625ca67ba Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 16 Aug 2022 11:11:24 +0300 Subject: [PATCH 3/9] gallium: drop unused macros in draw_llvm.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The reason is that these macros use lp_build_struct_get(), which is being replaced by lp_build_structure_get2() which takes the explicit pointer type. Rather than attempt to update these unused macros, simply drop them. Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/draw/draw_llvm.h | 42 -------------------------- 1 file changed, 42 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h index 37052db3175ba..941591ac7fb7a 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.h +++ b/src/gallium/auxiliary/draw/draw_llvm.h @@ -194,15 +194,6 @@ enum { #define draw_jit_context_viewports(_variant, _ptr) \ lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_VIEWPORT, "viewports") -#define draw_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_TEXTURES, "textures") - -#define draw_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_SAMPLERS, "samplers") - -#define draw_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_JIT_CTX_IMAGES, "images") - #define draw_jit_context_ssbos(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_JIT_CTX_SSBOS, "ssbos") @@ -292,21 +283,6 @@ enum { #define draw_gs_jit_context_constants(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_CONSTANTS, "constants") -#define draw_gs_jit_context_planes(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_PLANES, "planes") - -#define draw_gs_jit_context_viewports(_gallivm, _ptr) \ - lp_build_struct_get(_gallivm, _ptr, DRAW_GS_JIT_CTX_VIEWPORT, "viewports") - -#define draw_gs_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_TEXTURES, "textures") - -#define draw_gs_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_SAMPLERS, "samplers") - -#define draw_gs_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_IMAGES, "images") - #define draw_gs_jit_prim_lengths(_variant, _ptr) \ lp_build_struct_get2(_variant->gallivm, _variant->context_type, _ptr, DRAW_GS_JIT_CTX_PRIM_LENGTHS, "prim_lengths") @@ -353,15 +329,6 @@ enum { #define draw_tcs_jit_context_constants(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_CONSTANTS, "constants") -#define draw_tcs_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_TEXTURES, "textures") - -#define draw_tcs_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SAMPLERS, "samplers") - -#define draw_tcs_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_IMAGES, "images") - #define draw_tcs_jit_context_ssbos(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TCS_JIT_CTX_SSBOS, "ssbos") @@ -399,15 +366,6 @@ enum { #define draw_tes_jit_context_constants(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_CONSTANTS, "constants") -#define draw_tes_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_TEXTURES, "textures") - -#define draw_tes_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SAMPLERS, "samplers") - -#define draw_tes_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_IMAGES, "images") - #define draw_tes_jit_context_ssbos(_variant, _ptr) \ lp_build_struct_get_ptr2(_variant->gallivm, _variant->context_type, _ptr, DRAW_TES_JIT_CTX_SSBOS, "ssbos") -- GitLab From 8289ac87a404ff95759ec2a12012c1eae20419e6 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 26 Jul 2022 15:43:30 +0300 Subject: [PATCH 4/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_nir_aos.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c index c449b5de46c77..226bb5e75cf0f 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_aos.c @@ -172,7 +172,7 @@ emit_load_reg(struct lp_build_nir_context *bld_base, LLVMValueRef reg_storage) { struct gallivm_state *gallivm = bld_base->base.gallivm; - return LLVMBuildLoad(gallivm->builder, reg_storage, ""); + return LLVMBuildLoad2(gallivm->builder, reg_bld->vec_type, reg_storage, ""); } @@ -195,7 +195,7 @@ emit_store_reg(struct lp_build_nir_context *bld_base, return; } - LLVMValueRef cur = LLVMBuildLoad(gallivm->builder, reg_storage, ""); + LLVMValueRef cur = LLVMBuildLoad2(gallivm->builder, reg_bld->vec_type, reg_storage, ""); LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context); LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH]; for (unsigned j = 0; j < 16; j++) { @@ -238,10 +238,9 @@ emit_load_ubo(struct lp_build_nir_context *bld_base, LLVMValueRef this_offset = lp_build_const_int32(gallivm, offset_val + chan); - LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, bld->consts_ptr, - &this_offset, 1, ""); - - LLVMValueRef scalar = LLVMBuildLoad(builder, scalar_ptr, ""); + LLVMTypeRef scalar_type = LLVMInt8TypeInContext(gallivm->context); + LLVMValueRef scalar_ptr = LLVMBuildGEP2(builder, scalar_type, bld->consts_ptr, &this_offset, 1, ""); + LLVMValueRef scalar = LLVMBuildLoad2(builder, scalar_type, scalar_ptr, ""); lp_build_name(scalar, "const[%u].%c", offset_val, "xyzw"[chan]); -- GitLab From f30251ef9bf20274d49848d614c8bf407bec353b Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 26 Jul 2022 16:02:52 +0300 Subject: [PATCH 5/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_nir_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_nir_soa.c | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index 94dcace50e33f..90836928adee1 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -223,6 +223,7 @@ get_soa_array_offsets(struct lp_build_context *uint_bld, static LLVMValueRef build_gather(struct lp_build_nir_context *bld_base, struct lp_build_context *bld, + LLVMTypeRef base_type, LLVMValueRef base_ptr, LLVMValueRef indexes, LLVMValueRef overflow_mask, @@ -284,8 +285,8 @@ build_gather(struct lp_build_nir_context *bld_base, indexes, si, ""); } - scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "gather_ptr"); - scalar = LLVMBuildLoad(builder, scalar_ptr, ""); + scalar_ptr = LLVMBuildGEP2(builder, base_type, base_ptr, &index, 1, "gather_ptr"); + scalar = LLVMBuildLoad2(builder, base_type, scalar_ptr, ""); res = LLVMBuildInsertElement(builder, res, scalar, di, ""); } @@ -326,7 +327,7 @@ emit_mask_scatter(struct lp_build_nir_soa_context *bld, LLVMValueRef ii = lp_build_const_int32(gallivm, i); LLVMValueRef index = LLVMBuildExtractElement(builder, indexes, ii, ""); LLVMValueRef val = LLVMBuildExtractElement(builder, values, ii, "scatter_val"); - LLVMValueRef scalar_ptr = LLVMBuildGEP(builder, base_ptr, &index, 1, "scatter_ptr"); + LLVMValueRef scalar_ptr = LLVMBuildGEP2(builder, LLVMTypeOf(val), base_ptr, &index, 1, "scatter_ptr"); LLVMValueRef scalar_pred = pred ? LLVMBuildExtractElement(builder, pred, ii, "scatter_pred") : NULL; @@ -468,17 +469,15 @@ static void emit_load_var(struct lp_build_nir_context *bld_base, attrib_index_val, 4, idx, TRUE); LLVMValueRef index_vec2 = NULL; - LLVMTypeRef fptr_type; - LLVMValueRef inputs_array; - fptr_type = LLVMPointerType(LLVMFloatTypeInContext(gallivm->context), 0); - inputs_array = LLVMBuildBitCast(gallivm->builder, bld->inputs_array, fptr_type, ""); + LLVMTypeRef scalar_type = LLVMFloatTypeInContext(gallivm->context); + LLVMValueRef inputs_array = LLVMBuildBitCast(gallivm->builder, bld->inputs_array, LLVMPointerType(scalar_type, 0), ""); if (bit_size == 64) index_vec2 = get_soa_array_offsets(&bld_base->uint_bld, indir_index, 4, idx + 1, TRUE); /* Gather values from the input register array */ - result[i] = build_gather(bld_base, &bld_base->base, inputs_array, index_vec, NULL, index_vec2); + result[i] = build_gather(bld_base, &bld_base->base, scalar_type, inputs_array, index_vec, NULL, index_vec2); } else { if (bld->indirects & nir_var_shader_in) { LLVMValueRef lindex = lp_build_const_int32(gallivm, @@ -706,13 +705,13 @@ static LLVMValueRef emit_load_reg(struct lp_build_nir_context *bld_base, reg_storage = LLVMBuildBitCast(builder, reg_storage, LLVMPointerType(reg_bld->elem_type, 0), ""); for (unsigned i = 0; i < nc; i++) { LLVMValueRef indirect_offset = get_soa_array_offsets(uint_bld, indirect_val, nc, i, TRUE); - vals[i] = build_gather(bld_base, reg_bld, reg_storage, indirect_offset, NULL, NULL); + vals[i] = build_gather(bld_base, reg_bld, reg_bld->elem_type, reg_storage, indirect_offset, NULL, NULL); } } else { for (unsigned i = 0; i < nc; i++) { LLVMValueRef this_storage = nc == 1 ? reg_storage : lp_build_array_get_ptr(gallivm, reg_storage, lp_build_const_int32(gallivm, i)); - vals[i] = LLVMBuildLoad(builder, this_storage, ""); + vals[i] = LLVMBuildLoad2(builder, reg_bld->vec_type, this_storage, ""); } } return nc == 1 ? vals[0] : lp_nir_array_build_gather_values(builder, vals, nc); @@ -1103,7 +1102,7 @@ static void emit_load_ubo(struct lp_build_nir_context *bld_base, LLVMBuildStore(builder, lp_build_pointer_get(builder, consts_ptr, chan_offset), res_store); lp_build_endif(&ifthen); - scalar = LLVMBuildLoad(builder, res_store, ""); + scalar = LLVMBuildLoad2(builder, LLVMTypeOf(zero), res_store, ""); result[c] = lp_build_broadcast_scalar(load_bld, scalar); } @@ -1122,7 +1121,7 @@ static void emit_load_ubo(struct lp_build_nir_context *bld_base, LLVMValueRef this_offset = lp_build_add(uint_bld, offset, lp_build_const_int_vec(gallivm, uint_bld->type, c)); overflow_mask = lp_build_compare(gallivm, uint_bld->type, PIPE_FUNC_GEQUAL, this_offset, num_consts); - result[c] = build_gather(bld_base, bld_broad, consts_ptr, this_offset, overflow_mask, NULL); + result[c] = build_gather(bld_base, bld_broad, bld_broad->elem_type, consts_ptr, this_offset, overflow_mask, NULL); } } } @@ -2232,14 +2231,14 @@ static void emit_shuffle(struct lp_build_nir_context *bld_base, LLVMValueRef src */ src_value = LLVMBuildFreeze(builder, src_value, ""); - LLVMValueRef res = LLVMBuildLoad(builder, res_store, ""); + LLVMValueRef res = LLVMBuildLoad2(builder, int_bld->vec_type, res_store, ""); res = LLVMBuildInsertElement(builder, res, src_value, loop_state.counter, ""); LLVMBuildStore(builder, res, res_store); lp_build_loop_end_cond(&loop_state, lp_build_const_int32(gallivm, bld_base->uint_bld.type.length), NULL, LLVMIntUGE); - result[0] = LLVMBuildLoad(builder, res_store, ""); + result[0] = LLVMBuildLoad2(builder, int_bld->vec_type, res_store, ""); } } #endif @@ -2653,7 +2652,8 @@ emit_clock(struct lp_build_nir_context *bld_base, lp_init_clock_hook(gallivm); - LLVMValueRef result = LLVMBuildCall(builder, gallivm->get_time_hook, NULL, 0, ""); + LLVMTypeRef get_time_type = LLVMFunctionType(LLVMInt64TypeInContext(gallivm->context), NULL, 0, 1); + LLVMValueRef result = LLVMBuildCall2(builder, get_time_type, gallivm->get_time_hook, NULL, 0, ""); LLVMValueRef hi = LLVMBuildShl(builder, result, lp_build_const_int64(gallivm, 32), ""); hi = LLVMBuildTrunc(builder, hi, uint_bld->elem_type, ""); -- GitLab From 1b8c4931df9d0ec55fc80dc280f27c40c9a2b781 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 16 Aug 2022 22:55:47 +0300 Subject: [PATCH 6/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_jit_types.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- .../auxiliary/gallivm/lp_bld_jit_types.c | 41 ++++++++----------- 1 file changed, 17 insertions(+), 24 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c index c4bfa2be899ce..7af92824a5a43 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c @@ -70,35 +70,28 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, indices[1] = LLVMBuildSelect(gallivm->builder, cond, buffers_offset, lp_build_const_int32(gallivm, 0), ""); indices[2] = lp_build_const_int32(gallivm, member_index); - LLVMValueRef ptr = - LLVMBuildGEP(builder, buffers_ptr, indices, ARRAY_SIZE(indices), ""); + LLVMTypeRef buffer_type = lp_build_create_jit_buffer_type(gallivm); + LLVMTypeRef buffers_type = LLVMArrayType(buffer_type, LP_MAX_TGSI_CONST_BUFFERS); + LLVMValueRef ptr = LLVMBuildGEP2(builder, buffers_type, buffers_ptr, indices, ARRAY_SIZE(indices), ""); - LLVMValueRef res = LLVMBuildLoad(builder, ptr, ""); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(buffer_type, member_index); + LLVMValueRef res = LLVMBuildLoad2(builder, res_type, ptr, ""); lp_build_name(res, "buffer.%s", member_name); return res; } -/** - * Helper macro to instantiate the functions that generate the code to - * fetch the members of lp_jit_buffer to fulfill the sampler code - * generator requests. - * - * This complexity is the price we have to pay to keep the image - * sampler code generator a reusable module without dependencies to - * llvmpipe internals. - */ -#define LP_LLVM_BUFFER_MEMBER(_name, _index) \ - LLVMValueRef \ - lp_llvm_buffer_##_name(struct gallivm_state *gallivm, \ - LLVMValueRef buffers_ptr, \ - LLVMValueRef buffers_offset, unsigned buffers_limit) \ - { \ - return lp_llvm_buffer_member(gallivm, buffers_ptr, \ - buffers_offset, buffers_limit, \ - _index, #_name); \ - } +LLVMValueRef +lp_llvm_buffer_base(struct gallivm_state *gallivm, + LLVMValueRef buffers_ptr, LLVMValueRef buffers_offset, unsigned buffers_limit) +{ + return lp_llvm_buffer_member(gallivm, buffers_ptr, buffers_offset, buffers_limit, LP_JIT_BUFFER_BASE, "base"); +} -LP_LLVM_BUFFER_MEMBER(base, LP_JIT_BUFFER_BASE) -LP_LLVM_BUFFER_MEMBER(num_elements, LP_JIT_BUFFER_NUM_ELEMENTS) +LLVMValueRef +lp_llvm_buffer_num_elements(struct gallivm_state *gallivm, + LLVMValueRef buffers_ptr, LLVMValueRef buffers_offset, unsigned buffers_limit) +{ + return lp_llvm_buffer_member(gallivm, buffers_ptr, buffers_offset, buffers_limit, LP_JIT_BUFFER_NUM_ELEMENTS, "num_elements"); +} -- GitLab From 02b9a8ba12e62cfa40b62af5a338bb9e670de12b Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Sat, 20 Aug 2022 13:50:04 +0300 Subject: [PATCH 7/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_format_s3tc.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c | 9 ++++----- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 2 ++ src/gallium/auxiliary/gallivm/lp_bld_struct.h | 2 ++ 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c index fe44841528cb0..4ea40d14f8cac 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_s3tc.c @@ -1197,12 +1197,11 @@ s3tc_update_cache_access(struct gallivm_state *gallivm, assert(index == LP_BUILD_FORMAT_CACHE_MEMBER_ACCESS_TOTAL || index == LP_BUILD_FORMAT_CACHE_MEMBER_ACCESS_MISS); - - member_ptr = lp_build_struct_get_ptr(gallivm, ptr, index, ""); - cache_access = LLVMBuildLoad(builder, member_ptr, "cache_access"); + LLVMTypeRef cache_type = lp_build_format_cache_type(gallivm); + member_ptr = lp_build_struct_get_ptr2(gallivm, cache_type, ptr, index, ""); + cache_access = LLVMBuildLoad2(builder, LLVMInt64TypeInContext(gallivm->context), member_ptr, "cache_access"); cache_access = LLVMBuildAdd(builder, cache_access, - LLVMConstInt(LLVMInt64TypeInContext(gallivm->context), - count, 0), ""); + LLVMConstInt(LLVMInt64TypeInContext(gallivm->context), count, 0), ""); LLVMBuildStore(builder, cache_access, member_ptr); } #endif diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 9e3e24cd9e1e7..4259ecfa0d453 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -42,6 +42,7 @@ #include "lp_bld_struct.h" +/* Deprecated (used only by llvmpipe); use lp_build_struct_get_ptr2() instead. */ LLVMValueRef lp_build_struct_get_ptr(struct gallivm_state *gallivm, LLVMValueRef ptr, @@ -60,6 +61,7 @@ lp_build_struct_get_ptr(struct gallivm_state *gallivm, return member_ptr; } +/* Deprecated (used only by llvmpipe); use lp_build_struct_get2() instead. */ LLVMValueRef lp_build_struct_get(struct gallivm_state *gallivm, LLVMValueRef ptr, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.h b/src/gallium/auxiliary/gallivm/lp_bld_struct.h index a87519883b4df..4b1cc79b2aa48 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.h @@ -55,6 +55,7 @@ /** * Get value pointer to a structure member. + * Deprecated (used only by llvmpipe); use lp_build_struct_get_ptr2() instead. */ LLVMValueRef lp_build_struct_get_ptr(struct gallivm_state *gallivm, @@ -64,6 +65,7 @@ lp_build_struct_get_ptr(struct gallivm_state *gallivm, /** * Get the value of a structure member. + * Deprecated (used only by llvmpipe); use lp_build_struct_get2() instead. */ LLVMValueRef lp_build_struct_get(struct gallivm_state *gallivm, -- GitLab From 4ff7e64e81c0b4acb39c841b6d8da7ebc8bdd6dd Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Mon, 22 Aug 2022 16:34:30 +0300 Subject: [PATCH 8/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_struct.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 4259ecfa0d453..fa25b4ac3124a 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -109,7 +109,8 @@ lp_build_struct_get2(struct gallivm_state *gallivm, assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); member_ptr = lp_build_struct_get_ptr2(gallivm, ptr_type, ptr, member, name); - res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); + LLVMTypeRef member_type = LLVMStructGetTypeAtIndex(ptr_type, member); + res = LLVMBuildLoad2(gallivm->builder, member_type, member_ptr, ""); lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); return res; } -- GitLab From 136a26f271b5b846f3808f917267b79d0460e71a Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Wed, 24 Aug 2022 14:22:07 +0300 Subject: [PATCH 9/9] gallivm: fixes for LLVM-15 opaque pointers in lp_bld_format_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_format_soa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c index 6cda6036b37c8..784b8dc66946f 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c @@ -1099,7 +1099,7 @@ lp_build_store_rgba_soa(struct gallivm_state *gallivm, struct lp_build_loop_state loop_state; LLVMValueRef store_offset = LLVMBuildAdd(gallivm->builder, offset, lp_build_const_int_vec(gallivm, type, i * 4), ""); - store_offset = LLVMBuildGEP(gallivm->builder, base_ptr, &store_offset, 1, ""); + store_offset = LLVMBuildGEP2(gallivm->builder, LLVMInt8TypeInContext(gallivm->context), base_ptr, &store_offset, 1, ""); lp_build_loop_begin(&loop_state, gallivm, lp_build_const_int32(gallivm, 0)); -- GitLab From 1d741f4c62af71af860eaab35e16633b5d6428ed Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Wed, 31 Aug 2022 15:38:52 +0300 Subject: [PATCH 1/3] gallivm: LLVM opaque pointer fixes in lp_bld_sample.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit load_mip() Reviewed-by: Marek Olšák Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_sample.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index 5ab732ab765d1..181a6f4e08ff1 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -1175,7 +1175,7 @@ load_mip(struct gallivm_state *gallivm, LLVMValueRef offsets, LLVMValueRef index LLVMValueRef zero = lp_build_const_int32(gallivm, 0); LLVMValueRef indexes[2] = {zero, index1}; LLVMValueRef ptr = LLVMBuildGEP(gallivm->builder, offsets, indexes, ARRAY_SIZE(indexes), ""); - return LLVMBuildLoad(gallivm->builder, ptr, ""); + return LLVMBuildLoad2(gallivm->builder, LLVMInt32TypeInContext(gallivm->context), ptr, ""); } /** -- GitLab From cdd7e8f5cecf137a33430f41f48ae671a52561b6 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 6 Sep 2022 18:57:42 +0300 Subject: [PATCH 2/3] gallivm: LLVM opaque pointers: add lp_build_array_get[_ptr]2 in lp_bld_struct.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit i.e. variants taking an explicit LLVM type Reviewed-by: Marek Olšák Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 39 +++++++++++++++++++ src/gallium/auxiliary/gallivm/lp_bld_struct.h | 12 ++++++ 2 files changed, 51 insertions(+) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index fa25b4ac3124a..408ac17e246ea 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -115,6 +115,45 @@ lp_build_struct_get2(struct gallivm_state *gallivm, return res; } +LLVMValueRef +lp_build_array_get_ptr2(struct gallivm_state *gallivm, + LLVMTypeRef array_type, + LLVMValueRef ptr, + LLVMValueRef index) +{ + LLVMValueRef indices[2]; + LLVMValueRef element_ptr; + assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); + indices[0] = lp_build_const_int32(gallivm, 0); + indices[1] = index; + element_ptr = LLVMBuildGEP2(gallivm->builder, array_type, ptr, indices, ARRAY_SIZE(indices), ""); +#ifdef DEBUG + lp_build_name(element_ptr, "&%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); +#endif + return element_ptr; +} + + +LLVMValueRef +lp_build_array_get2(struct gallivm_state *gallivm, + LLVMTypeRef array_type, + LLVMValueRef ptr, + LLVMValueRef index) +{ + LLVMValueRef element_ptr; + LLVMValueRef res; + assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); + assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); + element_ptr = lp_build_array_get_ptr2(gallivm, array_type, ptr, index); + LLVMTypeRef element_type = LLVMGetElementType(array_type); + res = LLVMBuildLoad2(gallivm->builder, element_type, element_ptr, ""); +#ifdef DEBUG + lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); +#endif + return res; +} + LLVMValueRef lp_build_array_get_ptr(struct gallivm_state *gallivm, LLVMValueRef ptr, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.h b/src/gallium/auxiliary/gallivm/lp_bld_struct.h index 4b1cc79b2aa48..d90bdf48d321b 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.h @@ -95,6 +95,18 @@ lp_build_struct_get2(struct gallivm_state *gallivm, unsigned member, const char *name); +LLVMValueRef +lp_build_array_get_ptr2(struct gallivm_state *gallivm, + LLVMTypeRef array_type, + LLVMValueRef ptr, + LLVMValueRef index); + +LLVMValueRef +lp_build_array_get2(struct gallivm_state *gallivm, + LLVMTypeRef array_type, + LLVMValueRef ptr, + LLVMValueRef index); + /** * Get value pointer to an array element. */ -- GitLab From 15e78caf8d38e97183aba6bce65b1bef34869537 Mon Sep 17 00:00:00 2001 From: Mihai Preda Date: Tue, 6 Sep 2022 19:00:30 +0300 Subject: [PATCH 3/3] gallivm: LLVM opaque pointers: use lp_build_array_get_ptr2() in lp_bld_nir_soa.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-by: Marek Olšák Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index 6128f90ee16f4..5e1a987049db7 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -708,9 +708,12 @@ static LLVMValueRef emit_load_reg(struct lp_build_nir_context *bld_base, vals[i] = build_gather(bld_base, reg_bld, reg_bld->elem_type, reg_storage, indirect_offset, NULL, NULL); } } else { + LLVMTypeRef array_type = LLVMArrayType(reg_bld->vec_type, nc); for (unsigned i = 0; i < nc; i++) { - LLVMValueRef this_storage = nc == 1 ? reg_storage : lp_build_array_get_ptr(gallivm, reg_storage, - lp_build_const_int32(gallivm, i)); + LLVMValueRef index = lp_build_const_int32(gallivm, i); + LLVMValueRef this_storage = + nc == 1 ? reg_storage + : lp_build_array_get_ptr2(gallivm, array_type, reg_storage, index); vals[i] = LLVMBuildLoad2(builder, reg_bld->vec_type, this_storage, ""); } } @@ -748,9 +751,12 @@ static void emit_store_reg(struct lp_build_nir_context *bld_base, return; } + LLVMTypeRef array_type = LLVMArrayType(reg_bld->vec_type, nc); for (unsigned i = 0; i < nc; i++) { - LLVMValueRef this_storage = nc == 1 ? reg_storage : lp_build_array_get_ptr(gallivm, reg_storage, - lp_build_const_int32(gallivm, i)); + LLVMValueRef index = lp_build_const_int32(gallivm, i); + LLVMValueRef this_storage = + nc == 1 ? reg_storage + : lp_build_array_get_ptr2(gallivm, array_type, reg_storage, index); dst[i] = LLVMBuildBitCast(builder, dst[i], reg_bld->vec_type, ""); lp_exec_mask_store(&bld->exec_mask, reg_bld, dst[i], this_storage); } -- GitLab From 25ead8ec5c84028d4c58eff0b203b49f0425d812 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 12:16:48 +1000 Subject: [PATCH] gallivm: fix buffer_type for LLVM 15 Fixes deqp-vk: /home/airlied/devel/llvm-project/llvm/include/llvm/IR/Instructions.h:961: static llvm::GetElementPtrInst* llvm::GetElementPtrInst::Create(llvm::Type*, llvm::Value*, llvm::ArrayRef, const llvm::Twine&, llvm::Instruction*): Assertion `cast(Ptr->getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType)' failed. Fixes: 1b8c4931df9d ("gallivm: fixes for LLVM-15 opaque pointers in lp_bld_jit_types.c") Acked-by: Mike Blumenkrantz Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_jit_types.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c index 7af92824a5a43..2a4ecf72e711b 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_jit_types.c @@ -71,7 +71,7 @@ lp_llvm_buffer_member(struct gallivm_state *gallivm, indices[2] = lp_build_const_int32(gallivm, member_index); LLVMTypeRef buffer_type = lp_build_create_jit_buffer_type(gallivm); - LLVMTypeRef buffers_type = LLVMArrayType(buffer_type, LP_MAX_TGSI_CONST_BUFFERS); + LLVMTypeRef buffers_type = LLVMArrayType(buffer_type, buffers_limit); LLVMValueRef ptr = LLVMBuildGEP2(builder, buffers_type, buffers_ptr, indices, ARRAY_SIZE(indices), ""); LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(buffer_type, member_index); -- GitLab From d132625eed474d149ed6372dd5448492675b738e Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Tue, 27 Sep 2022 05:15:26 +1000 Subject: [PATCH 1/3] lavapipe: add fmin/fmax to image lowering. Fixes: 31695f81c925 ("lavapipe: export VK_KHR_shader_atomic_float") Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c index ff7a38bd5e208..16a1567a6ae1b 100644 --- a/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c +++ b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c @@ -50,6 +50,8 @@ lower_vulkan_resource_index(const nir_instr *instr, const void *data_cb) case nir_intrinsic_image_deref_atomic_exchange: case nir_intrinsic_image_deref_atomic_comp_swap: case nir_intrinsic_image_deref_atomic_fadd: + case nir_intrinsic_image_deref_atomic_fmin: + case nir_intrinsic_image_deref_atomic_fmax: case nir_intrinsic_image_deref_size: case nir_intrinsic_image_deref_samples: return true; @@ -339,6 +341,8 @@ static nir_ssa_def *lower_vri_instr(struct nir_builder *b, case nir_intrinsic_image_deref_atomic_exchange: case nir_intrinsic_image_deref_atomic_comp_swap: case nir_intrinsic_image_deref_atomic_fadd: + case nir_intrinsic_image_deref_atomic_fmin: + case nir_intrinsic_image_deref_atomic_fmax: case nir_intrinsic_image_deref_size: case nir_intrinsic_image_deref_samples: lower_image_intrinsic(b, intrin, data_cb); -- GitLab From c642fa122ccd90b11ad54dd50e398373069ae8c7 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Tue, 27 Sep 2022 05:17:39 +1000 Subject: [PATCH 2/3] gallivm/nir: fix fmin/fmax translation Fixes: 203920d4c693 ("gallivm: add atomic 32-bit float support") Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_nir.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir.c b/src/gallium/auxiliary/gallivm/lp_bld_nir.c index 8d71fb304a4a8..4afeebfd06ad1 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir.c @@ -1738,10 +1738,10 @@ visit_atomic_image(struct lp_build_nir_context *bld_base, break; #if LLVM_VERSION >= 15 case nir_intrinsic_image_atomic_fmin: - params.op = LLVMAtomicRMWBinOpMin; + params.op = LLVMAtomicRMWBinOpFMin; break; case nir_intrinsic_image_atomic_fmax: - params.op = LLVMAtomicRMWBinOpMax; + params.op = LLVMAtomicRMWBinOpFMax; break; #endif default: -- GitLab From f2922126156b9bc9fd10bfd3690e7ed3db08184f Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Tue, 27 Sep 2022 15:26:42 +1000 Subject: [PATCH 3/3] gallivm/nir: bitcast when non-float ptr type. This matters more when opaque pointers are used. Fixes: 203920d4c693 ("gallivm: add atomic 32-bit float support") Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index 5e1a987049db7..b5e401f6132a1 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -1224,7 +1224,7 @@ mem_access_base_pointer(struct lp_build_nir_context *bld_base, } /* Cast it to the pointer type of the access this instruction is doing. */ - if (bit_size == 32) + if (bit_size == 32 && !mem_bld->type.floating) return ptr; else return LLVMBuildBitCast(gallivm->builder, ptr, LLVMPointerType(mem_bld->elem_type, 0), ""); -- GitLab From b36160689f430e0845940fb0c3dac9ba22c6608b Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 13:47:15 +1000 Subject: [PATCH 01/10] gallivm/struct: add opaque ptr friendly pointer accessors. These just add explicit types. Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 29 +++++++++++++++++++ src/gallium/auxiliary/gallivm/lp_bld_struct.h | 24 +++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 408ac17e246ea..73c32cebadfb6 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -234,6 +234,35 @@ lp_build_pointer_get_unaligned(LLVMBuilderRef builder, return res; } +LLVMValueRef +lp_build_pointer_get_unaligned2(LLVMBuilderRef builder, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + LLVMValueRef index, + unsigned alignment) +{ + LLVMValueRef element_ptr; + LLVMValueRef res; + assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); + element_ptr = LLVMBuildGEP2(builder, ptr_type, ptr, &index, 1, ""); + res = LLVMBuildLoad2(builder, ptr_type, element_ptr, ""); + if (alignment) + LLVMSetAlignment(res, alignment); +#ifdef DEBUG + lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); +#endif + return res; +} + + +LLVMValueRef +lp_build_pointer_get2(LLVMBuilderRef builder, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + LLVMValueRef index) +{ + return lp_build_pointer_get_unaligned2(builder, ptr_type, ptr, index, 0); +} void lp_build_pointer_set(LLVMBuilderRef builder, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.h b/src/gallium/auxiliary/gallivm/lp_bld_struct.h index d90bdf48d321b..52d6020563bfb 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.h @@ -152,6 +152,30 @@ lp_build_pointer_get_unaligned(LLVMBuilderRef builder, LLVMValueRef index, unsigned alignment); +/** + * Get the value of an array element. + * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. + */ +LLVMValueRef +lp_build_pointer_get2(LLVMBuilderRef builder, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + LLVMValueRef index); + +/** + * Get the value of an array element, with explicit alignment, and explicit type, + * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. + * + * If the element size is different from the alignment this will + * cause llvm to emit an unaligned load + */ +LLVMValueRef +lp_build_pointer_get_unaligned2(LLVMBuilderRef builder, + LLVMTypeRef ptr_type, + LLVMValueRef ptr, + LLVMValueRef index, + unsigned alignment); + /** * Set the value of an array element. */ -- GitLab From 637652a97fab5c20959505f17972f6a0a549ef9f Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 13:55:57 +1000 Subject: [PATCH 02/10] llvmpipe/fs: add mask_type for mask_store accesses. This adds and passes around the type for mask stores. Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 32 ++++++++++++---------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 53d933cfb0219..42b07bba4f8bc 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -633,6 +633,7 @@ generate_fs_loop(struct gallivm_state *gallivm, struct lp_build_interp_soa_context *interp, const struct lp_build_sampler_soa *sampler, const struct lp_build_image_soa *image, + LLVMTypeRef mask_type, LLVMValueRef mask_store, LLVMValueRef (*out_color)[4], LLVMValueRef depth_base_ptr, @@ -789,7 +790,7 @@ generate_fs_loop(struct gallivm_state *gallivm, for (unsigned s = 0; s < key->coverage_samples; s++) { LLVMValueRef s_mask_idx = LLVMBuildMul(builder, num_loop, lp_build_const_int32(gallivm, s), ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_state.counter, ""); - LLVMValueRef s_mask = lp_build_pointer_get(builder, mask_store, s_mask_idx); + LLVMValueRef s_mask = lp_build_pointer_get2(builder, mask_type, mask_store, s_mask_idx); if (s == 0) mask_val = s_mask; else @@ -800,9 +801,9 @@ generate_fs_loop(struct gallivm_state *gallivm, } } else { sample_mask_in = lp_build_const_int_vec(gallivm, type, 1); - mask_ptr = LLVMBuildGEP(builder, mask_store, + mask_ptr = LLVMBuildGEP2(builder, mask_type, mask_store, &loop_state.counter, 1, "mask_ptr"); - mask_val = LLVMBuildLoad(builder, mask_ptr, ""); + mask_val = LLVMBuildLoad2(builder, mask_type, mask_ptr, ""); LLVMValueRef mask_in = LLVMBuildAnd(builder, mask_val, lp_build_const_int_vec(gallivm, type, 1), ""); sample_mask_in = LLVMBuildOr(builder, sample_mask_in, mask_in, ""); @@ -860,9 +861,9 @@ generate_fs_loop(struct gallivm_state *gallivm, LLVMValueRef s_mask_idx = LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_state.counter, ""); - s_mask_ptr = LLVMBuildGEP(builder, mask_store, &s_mask_idx, 1, ""); + s_mask_ptr = LLVMBuildGEP2(builder, mask_type, mask_store, &s_mask_idx, 1, ""); - s_mask = LLVMBuildLoad(builder, s_mask_ptr, ""); + s_mask = LLVMBuildLoad2(builder, mask_type, s_mask_ptr, ""); s_mask = LLVMBuildAnd(builder, s_mask, mask_val, ""); } @@ -990,8 +991,8 @@ generate_fs_loop(struct gallivm_state *gallivm, LLVMValueRef s_mask_idx = LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_state.counter, ""); - s_mask_ptr = LLVMBuildGEP(builder, mask_store, &s_mask_idx, 1, ""); - s_mask = LLVMBuildLoad(builder, s_mask_ptr, ""); + s_mask_ptr = LLVMBuildGEP2(builder, mask_type, mask_store, &s_mask_idx, 1, ""); + s_mask = LLVMBuildLoad2(builder, mask_type, s_mask_ptr, ""); lp_build_mask_force(&mask, s_mask); lp_build_interp_soa_update_pos_dyn(interp, gallivm, loop_state.counter, sample_loop_state.counter); system_values.sample_id = sample_loop_state.counter; @@ -1216,10 +1217,10 @@ generate_fs_loop(struct gallivm_state *gallivm, /* load the per-sample coverage mask */ LLVMValueRef s_mask_idx = LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_state.counter, ""); - s_mask_ptr = LLVMBuildGEP(builder, mask_store, &s_mask_idx, 1, ""); + s_mask_ptr = LLVMBuildGEP2(builder, mask_type, mask_store, &s_mask_idx, 1, ""); /* combine the execution mask post fragment shader with the coverage mask. */ - s_mask = LLVMBuildLoad(builder, s_mask_ptr, ""); + s_mask = LLVMBuildLoad2(builder, mask_type, s_mask_ptr, ""); if (key->min_samples == 1) s_mask = LLVMBuildAnd(builder, s_mask, lp_build_mask_value(&mask), ""); @@ -3339,8 +3340,8 @@ generate_fragment(struct llvmpipe_context *lp, LLVMValueRef sindexi = lp_build_const_int32(gallivm, i + (s * num_fs)); LLVMValueRef sample_mask_ptr = - LLVMBuildGEP(builder, mask_store, &sindexi, 1, - "sample_mask_ptr"); + LLVMBuildGEP2(builder, mask_type, mask_store, &sindexi, 1, + "sample_mask_ptr"); LLVMValueRef s_mask = generate_quad_mask(gallivm, fs_type, i * fs_type.length / 4, s, mask_input); @@ -3359,8 +3360,8 @@ generate_fragment(struct llvmpipe_context *lp, } else { LLVMValueRef mask; LLVMValueRef indexi = lp_build_const_int32(gallivm, i); - LLVMValueRef mask_ptr = LLVMBuildGEP(builder, mask_store, - &indexi, 1, "mask_ptr"); + LLVMValueRef mask_ptr = LLVMBuildGEP2(builder, mask_type, mask_store, + &indexi, 1, "mask_ptr"); if (partial_mask) { mask = generate_quad_mask(gallivm, fs_type, @@ -3383,6 +3384,7 @@ generate_fragment(struct llvmpipe_context *lp, &interp, sampler, image, + mask_type, mask_store, /* output */ color_store, depth_ptr, @@ -3400,9 +3402,9 @@ generate_fragment(struct llvmpipe_context *lp, for (unsigned s = 0; s < key->coverage_samples; s++) { int idx = (i + (s * num_fs)); LLVMValueRef sindexi = lp_build_const_int32(gallivm, idx); - ptr = LLVMBuildGEP(builder, mask_store, &sindexi, 1, ""); + ptr = LLVMBuildGEP2(builder, mask_type, mask_store, &sindexi, 1, ""); - fs_mask[idx] = LLVMBuildLoad(builder, ptr, "smask"); + fs_mask[idx] = LLVMBuildLoad2(builder, mask_type, ptr, "smask"); } for (unsigned s = 0; s < key->min_samples; s++) { -- GitLab From 694104b7761b4fece5b0861fc443a6dc553de5b2 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 17:36:58 +1000 Subject: [PATCH 03/10] llvmpipe/fs: pass explicit mask_type into interp code. This is so it is known for explicit pointer support Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_bld_interp.c | 14 +++++++++----- src/gallium/drivers/llvmpipe/lp_bld_interp.h | 2 ++ src/gallium/drivers/llvmpipe/lp_state_fs.c | 7 +++++-- 3 files changed, 16 insertions(+), 7 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.c b/src/gallium/drivers/llvmpipe/lp_bld_interp.c index 61d0bfa492fa5..f03da17c4d481 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.c +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.c @@ -157,6 +157,7 @@ static void calc_centroid_offsets(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef loop_iter, + LLVMTypeRef mask_type, LLVMValueRef mask_store, LLVMValueRef pix_center_offset, LLVMValueRef *centroid_x, LLVMValueRef *centroid_y) @@ -171,7 +172,7 @@ calc_centroid_offsets(struct lp_build_interp_soa_context *bld, LLVMValueRef s_mask_idx = LLVMBuildMul(builder, bld->num_loop, lp_build_const_int32(gallivm, s), ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_iter, ""); - sample_cov = lp_build_pointer_get(builder, mask_store, s_mask_idx); + sample_cov = lp_build_pointer_get2(builder, mask_type, mask_store, s_mask_idx); if (s == bld->coverage_samples - 1) s_mask_and = sample_cov; else @@ -284,6 +285,7 @@ static void attribs_update_simple(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef loop_iter, + LLVMTypeRef mask_type, LLVMValueRef mask_store, LLVMValueRef sample_id, int start, @@ -376,7 +378,7 @@ attribs_update_simple(struct lp_build_interp_soa_context *bld, xoffset = lp_build_broadcast_scalar(coeff_bld, x_val_idx); yoffset = lp_build_broadcast_scalar(coeff_bld, y_val_idx); } else if (loc == TGSI_INTERPOLATE_LOC_CENTROID) { - calc_centroid_offsets(bld, gallivm, loop_iter, mask_store, + calc_centroid_offsets(bld, gallivm, loop_iter, mask_type, mask_store, pix_center_offset, &xoffset, &yoffset); } chan_pixoffx = lp_build_add(coeff_bld, chan_pixoffx, xoffset); @@ -508,6 +510,7 @@ LLVMValueRef lp_build_interp_soa(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef loop_iter, + LLVMTypeRef mask_type, LLVMValueRef mask_store, unsigned attrib, unsigned chan, enum tgsi_interpolate_loc loc, @@ -579,7 +582,7 @@ lp_build_interp_soa(struct lp_build_interp_soa_context *bld, /* for centroid find covered samples for this quad. */ /* if all samples are covered use pixel centers */ if (bld->coverage_samples > 1) { - calc_centroid_offsets(bld, gallivm, loop_iter, mask_store, + calc_centroid_offsets(bld, gallivm, loop_iter, mask_type, mask_store, pix_center_offset, ¢roid_x_offset, ¢roid_y_offset); @@ -793,10 +796,11 @@ void lp_build_interp_soa_update_inputs_dyn(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef quad_start_index, + LLVMTypeRef mask_type, LLVMValueRef mask_store, LLVMValueRef sample_id) { - attribs_update_simple(bld, gallivm, quad_start_index, mask_store, sample_id, 1, bld->num_attribs); + attribs_update_simple(bld, gallivm, quad_start_index, mask_type, mask_store, sample_id, 1, bld->num_attribs); } void @@ -805,6 +809,6 @@ lp_build_interp_soa_update_pos_dyn(struct lp_build_interp_soa_context *bld, LLVMValueRef quad_start_index, LLVMValueRef sample_id) { - attribs_update_simple(bld, gallivm, quad_start_index, NULL, sample_id, 0, 1); + attribs_update_simple(bld, gallivm, quad_start_index, NULL, NULL, sample_id, 0, 1); } diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.h b/src/gallium/drivers/llvmpipe/lp_bld_interp.h index f9c9211cbb8d5..acd5546118471 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.h +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.h @@ -138,6 +138,7 @@ void lp_build_interp_soa_update_inputs_dyn(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef quad_start_index, + LLVMTypeRef mask_type, LLVMValueRef mask_store, LLVMValueRef sample_id); @@ -151,6 +152,7 @@ LLVMValueRef lp_build_interp_soa(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, LLVMValueRef loop_iter, + LLVMTypeRef mask_type, LLVMValueRef mask_store, unsigned attrib, unsigned chan, unsigned loc, diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 42b07bba4f8bc..1aef483fd6446 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -434,6 +434,7 @@ struct lp_build_fs_llvm_iface { struct lp_build_fs_iface base; struct lp_build_interp_soa_context *interp; struct lp_build_for_loop_state *loop_state; + LLVMTypeRef mask_type; LLVMValueRef mask_store; LLVMValueRef sample_id; LLVMValueRef color_ptr_ptr; @@ -463,7 +464,7 @@ fs_interp(const struct lp_build_fs_iface *iface, loc = TGSI_INTERPOLATE_LOC_SAMPLE; return lp_build_interp_soa(interp, bld->gallivm, fs_iface->loop_state->counter, - fs_iface->mask_store, + fs_iface->mask_type, fs_iface->mask_store, attrib, chan, loc, attrib_indir, offsets); } @@ -1005,7 +1006,8 @@ generate_fs_loop(struct gallivm_state *gallivm, } system_values.sample_pos = sample_pos_array; - lp_build_interp_soa_update_inputs_dyn(interp, gallivm, loop_state.counter, mask_store, sample_loop_state.counter); + lp_build_interp_soa_update_inputs_dyn(interp, gallivm, loop_state.counter, + mask_type, mask_store, sample_loop_state.counter); struct lp_build_fs_llvm_iface fs_iface = { .base.interp_fn = fs_interp, @@ -1013,6 +1015,7 @@ generate_fs_loop(struct gallivm_state *gallivm, .interp = interp, .loop_state = &loop_state, .sample_id = system_values.sample_id, + .mask_type = mask_type, .mask_store = mask_store, .color_ptr_ptr = color_ptr_ptr, .color_stride_ptr = color_stride_ptr, -- GitLab From ff02d042aabd9567e35cf289830bbfd552eaff05 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:15:28 +1000 Subject: [PATCH 04/10] llvmpipe/fs: port depth code to opaque pointer api Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_bld_depth.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_bld_depth.c b/src/gallium/drivers/llvmpipe/lp_bld_depth.c index 91bb347e307c3..10bb2d9939266 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_depth.c +++ b/src/gallium/drivers/llvmpipe/lp_bld_depth.c @@ -587,8 +587,9 @@ lp_build_depth_stencil_load_swizzled(struct gallivm_state *gallivm, /* Load current z/stencil values from z/stencil buffer */ LLVMTypeRef load_ptr_type = LLVMPointerType(zs_dst_type, 0); + LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); LLVMValueRef zs_dst_ptr = - LLVMBuildGEP(builder, depth_ptr, &depth_offset1, 1, ""); + LLVMBuildGEP2(builder, int8_type, depth_ptr, &depth_offset1, 1, ""); zs_dst_ptr = LLVMBuildBitCast(builder, zs_dst_ptr, load_ptr_type, ""); LLVMValueRef zs_dst1 = LLVMBuildLoad2(builder, zs_dst_type, zs_dst_ptr, ""); LLVMValueRef zs_dst2; @@ -596,7 +597,7 @@ lp_build_depth_stencil_load_swizzled(struct gallivm_state *gallivm, zs_dst2 = lp_build_undef(gallivm, zs_load_type); } else { - zs_dst_ptr = LLVMBuildGEP(builder, depth_ptr, &depth_offset2, 1, ""); + zs_dst_ptr = LLVMBuildGEP2(builder, int8_type, depth_ptr, &depth_offset2, 1, ""); zs_dst_ptr = LLVMBuildBitCast(builder, zs_dst_ptr, load_ptr_type, ""); zs_dst2 = LLVMBuildLoad2(builder, zs_dst_type, zs_dst_ptr, ""); } @@ -733,9 +734,10 @@ lp_build_depth_stencil_write_swizzled(struct gallivm_state *gallivm, depth_offset2 = LLVMBuildAdd(builder, depth_offset1, depth_stride, ""); - zs_dst_ptr1 = LLVMBuildGEP(builder, depth_ptr, &depth_offset1, 1, ""); + LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); + zs_dst_ptr1 = LLVMBuildGEP2(builder, int8_type, depth_ptr, &depth_offset1, 1, ""); zs_dst_ptr1 = LLVMBuildBitCast(builder, zs_dst_ptr1, load_ptr_type, ""); - zs_dst_ptr2 = LLVMBuildGEP(builder, depth_ptr, &depth_offset2, 1, ""); + zs_dst_ptr2 = LLVMBuildGEP2(builder, int8_type, depth_ptr, &depth_offset2, 1, ""); zs_dst_ptr2 = LLVMBuildBitCast(builder, zs_dst_ptr2, load_ptr_type, ""); if (format_desc->block.bits > 32) { -- GitLab From e28db68e53c3e265df5dd66c5b6bfe7cfb762f2a Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:17:35 +1000 Subject: [PATCH 05/10] llvmpipe/fs: add sample position type to the interp interface Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_bld_interp.c | 20 ++++++++++++++------ src/gallium/drivers/llvmpipe/lp_bld_interp.h | 2 ++ src/gallium/drivers/llvmpipe/lp_state_fs.c | 4 +++- 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.c b/src/gallium/drivers/llvmpipe/lp_bld_interp.c index f03da17c4d481..f5c4a2105b4d4 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.c +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.c @@ -181,8 +181,10 @@ calc_centroid_offsets(struct lp_build_interp_soa_context *bld, LLVMValueRef x_val_idx = lp_build_const_int32(gallivm, s * 2); LLVMValueRef y_val_idx = lp_build_const_int32(gallivm, s * 2 + 1); - x_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, x_val_idx); - y_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, y_val_idx); + x_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, x_val_idx); + y_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, y_val_idx); x_val_idx = lp_build_broadcast_scalar(coeff_bld, x_val_idx); y_val_idx = lp_build_broadcast_scalar(coeff_bld, y_val_idx); centroid_x_offset = lp_build_select(coeff_bld, sample_cov, x_val_idx, centroid_x_offset); @@ -338,7 +340,8 @@ attribs_update_simple(struct lp_build_interp_soa_context *bld, dadx = coeff_bld->one; if (sample_id) { LLVMValueRef x_val_idx = LLVMBuildMul(gallivm->builder, sample_id, lp_build_const_int32(gallivm, 2), ""); - x_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, x_val_idx); + x_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, x_val_idx); a = lp_build_broadcast_scalar(coeff_bld, x_val_idx); } else { a = lp_build_const_vec(gallivm, coeff_bld->type, bld->pos_offset); @@ -349,7 +352,8 @@ attribs_update_simple(struct lp_build_interp_soa_context *bld, if (sample_id) { LLVMValueRef y_val_idx = LLVMBuildMul(gallivm->builder, sample_id, lp_build_const_int32(gallivm, 2), ""); y_val_idx = LLVMBuildAdd(gallivm->builder, y_val_idx, lp_build_const_int32(gallivm, 1), ""); - y_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, y_val_idx); + y_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, y_val_idx); a = lp_build_broadcast_scalar(coeff_bld, y_val_idx); } else { a = lp_build_const_vec(gallivm, coeff_bld->type, bld->pos_offset); @@ -373,8 +377,10 @@ attribs_update_simple(struct lp_build_interp_soa_context *bld, LLVMValueRef x_val_idx = LLVMBuildMul(gallivm->builder, sample_id, lp_build_const_int32(gallivm, 2), ""); LLVMValueRef y_val_idx = LLVMBuildAdd(gallivm->builder, x_val_idx, lp_build_const_int32(gallivm, 1), ""); - x_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, x_val_idx); - y_val_idx = lp_build_array_get(gallivm, bld->sample_pos_array, y_val_idx); + x_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, x_val_idx); + y_val_idx = lp_build_array_get2(gallivm, bld->sample_pos_array_type, + bld->sample_pos_array, y_val_idx); xoffset = lp_build_broadcast_scalar(coeff_bld, x_val_idx); yoffset = lp_build_broadcast_scalar(coeff_bld, y_val_idx); } else if (loc == TGSI_INTERPOLATE_LOC_CENTROID) { @@ -678,6 +684,7 @@ lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld, const struct lp_shader_input *inputs, boolean pixel_center_integer, unsigned coverage_samples, + LLVMTypeRef sample_pos_array_type, LLVMValueRef sample_pos_array, LLVMValueRef num_loop, LLVMBuilderRef builder, @@ -750,6 +757,7 @@ lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld, } bld->coverage_samples = coverage_samples; bld->num_loop = num_loop; + bld->sample_pos_array_type = sample_pos_array_type; bld->sample_pos_array = sample_pos_array; pos_init(bld, x0, y0); diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.h b/src/gallium/drivers/llvmpipe/lp_bld_interp.h index acd5546118471..445c8655d4d59 100644 --- a/src/gallium/drivers/llvmpipe/lp_bld_interp.h +++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.h @@ -90,6 +90,7 @@ struct lp_build_interp_soa_context double pos_offset; unsigned coverage_samples; LLVMValueRef num_loop; + LLVMTypeRef sample_pos_array_type; LLVMValueRef sample_pos_array; LLVMValueRef x; @@ -124,6 +125,7 @@ lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld, const struct lp_shader_input *inputs, boolean pixel_center_integer, unsigned coverage_samples, + LLVMTypeRef sample_pos_array_type, LLVMValueRef sample_pos_array, LLVMValueRef num_loop, LLVMBuilderRef builder, diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 1aef483fd6446..7e554662bdd8b 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -3319,7 +3319,9 @@ generate_fragment(struct llvmpipe_context *lp, shader->info.base.num_inputs, inputs, pixel_center_integer, - key->coverage_samples, glob_sample_pos, + key->coverage_samples, + LLVMTypeOf(sample_pos_array), + glob_sample_pos, num_loop, builder, fs_type, a0_ptr, dadx_ptr, dady_ptr, -- GitLab From 38907a40ab0848c9fe8d1b7ad6d0f4047fcf6f5b Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:19:44 +1000 Subject: [PATCH 06/10] llvmpipe/fs: pass mask type to alpha to coverage handler Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 7e554662bdd8b..9dabfcb4a80f3 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -408,6 +408,7 @@ lp_build_sample_alpha_to_coverage(struct gallivm_state *gallivm, unsigned coverage_samples, LLVMValueRef num_loop, LLVMValueRef loop_counter, + LLVMTypeRef coverage_mask_type, LLVMValueRef coverage_mask_store, LLVMValueRef alpha) { @@ -422,8 +423,9 @@ lp_build_sample_alpha_to_coverage(struct gallivm_state *gallivm, LLVMValueRef s_mask_idx = LLVMBuildMul(builder, lp_build_const_int32(gallivm, s), num_loop, ""); s_mask_idx = LLVMBuildAdd(builder, s_mask_idx, loop_counter, ""); - LLVMValueRef s_mask_ptr = LLVMBuildGEP(builder, coverage_mask_store, &s_mask_idx, 1, ""); - LLVMValueRef s_mask = LLVMBuildLoad(builder, s_mask_ptr, ""); + LLVMValueRef s_mask_ptr = LLVMBuildGEP2(builder, coverage_mask_type, + coverage_mask_store, &s_mask_idx, 1, ""); + LLVMValueRef s_mask = LLVMBuildLoad2(builder, coverage_mask_type, s_mask_ptr, ""); s_mask = LLVMBuildAnd(builder, s_mask, test, ""); LLVMBuildStore(builder, s_mask, s_mask_ptr); } @@ -1089,7 +1091,7 @@ generate_fs_loop(struct gallivm_state *gallivm, } else { lp_build_sample_alpha_to_coverage(gallivm, type, key->coverage_samples, num_loop, loop_state.counter, - mask_store, alpha); + mask_type, mask_store, alpha); } } } -- GitLab From 3137f4fad15058cc7d16b2438f44b5e581853be8 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:20:25 +1000 Subject: [PATCH 07/10] llvmpipe/fs: use explicit api in viewport code. Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 9dabfcb4a80f3..9cbdc9cff037d 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -332,12 +332,13 @@ lp_llvm_viewport(LLVMTypeRef context_type, LLVMValueRef res; struct lp_type viewport_type = lp_type_float_vec(32, 32 * LP_JIT_VIEWPORT_NUM_FIELDS); + LLVMTypeRef vtype = lp_build_vec_type(gallivm, viewport_type); ptr = lp_jit_context_viewports(gallivm, context_type, context_ptr); ptr = LLVMBuildPointerCast(builder, ptr, - LLVMPointerType(lp_build_vec_type(gallivm, viewport_type), 0), ""); + LLVMPointerType(vtype, 0), ""); - res = lp_build_pointer_get(builder, ptr, viewport_index); + res = lp_build_pointer_get2(builder, vtype, ptr, viewport_index); return res; } -- GitLab From b9a0ec0c67741cb4b1d2c0d44f747aabe28018e3 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:24:44 +1000 Subject: [PATCH 08/10] llvmpipe/fs: handle explicit types around blending and c/zs bufs calcs Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 132 +++++++++++++-------- 1 file changed, 80 insertions(+), 52 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 9cbdc9cff037d..900d2c1e63c3b 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -117,6 +117,7 @@ static unsigned fs_no = 0; static void load_unswizzled_block(struct gallivm_state *gallivm, + LLVMTypeRef base_type, LLVMValueRef base_ptr, LLVMValueRef stride, unsigned block_width, @@ -507,6 +508,9 @@ fs_fb_fetch(const struct lp_build_fs_iface *iface, struct lp_build_fs_llvm_iface *fs_iface = (struct lp_build_fs_llvm_iface *)iface; struct gallivm_state *gallivm = bld->gallivm; LLVMBuilderRef builder = gallivm->builder; + LLVMTypeRef int32_type = LLVMInt32TypeInContext(gallivm->context); + LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); + LLVMTypeRef int8p_type = LLVMPointerType(int8_type, 0); const struct lp_fragment_shader_variant_key *key = fs_iface->key; LLVMValueRef buf_ptr; @@ -524,8 +528,12 @@ fs_fb_fetch(const struct lp_build_fs_iface *iface, const int cbuf = location - FRAG_RESULT_DATA0; LLVMValueRef index = lp_build_const_int32(gallivm, cbuf); - buf_ptr = LLVMBuildLoad(builder, LLVMBuildGEP(builder, fs_iface->color_ptr_ptr, &index, 1, ""), ""); - stride = LLVMBuildLoad(builder, LLVMBuildGEP(builder, fs_iface->color_stride_ptr, &index, 1, ""), ""); + buf_ptr = LLVMBuildLoad2(builder, int8p_type, + LLVMBuildGEP2(builder, int8p_type, + fs_iface->color_ptr_ptr, &index, 1, ""), ""); + stride = LLVMBuildLoad2(builder, int32_type, + LLVMBuildGEP2(builder, int32_type, + fs_iface->color_stride_ptr, &index, 1, ""), ""); buf_format = key->cbuf_format[cbuf]; } @@ -546,13 +554,16 @@ fs_fb_fetch(const struct lp_build_fs_iface *iface, sample_stride = fs_iface->zs_sample_stride; } else { LLVMValueRef index = lp_build_const_int32(gallivm, location - FRAG_RESULT_DATA0); - sample_stride = LLVMBuildLoad(builder, - LLVMBuildGEP(builder, fs_iface->color_sample_stride_ptr, - &index, 1, ""), ""); + sample_stride = LLVMBuildLoad2(builder, int32_type, + LLVMBuildGEP2(builder, + int32_type, + fs_iface->color_sample_stride_ptr, + &index, 1, ""), ""); } LLVMValueRef sample_offset = LLVMBuildMul(builder, sample_stride, fs_iface->sample_id, ""); - buf_ptr = LLVMBuildGEP(builder, buf_ptr, &sample_offset, 1, ""); + buf_ptr = LLVMBuildGEP2(builder, int8_type, + buf_ptr, &sample_offset, 1, ""); } /* fragment shader executes on 4x4 blocks. depending on vector width it can @@ -883,7 +894,8 @@ generate_fs_loop(struct gallivm_state *gallivm, LLVMValueRef sample_offset = LLVMBuildMul(builder, sample_loop_state.counter, depth_sample_stride, ""); - depth_ptr = LLVMBuildGEP(builder, depth_ptr, &sample_offset, 1, ""); + depth_ptr = LLVMBuildGEP2(builder, LLVMInt8TypeInContext(gallivm->context), + depth_ptr, &sample_offset, 1, ""); } if (depth_mode & EARLY_DEPTH_TEST) { @@ -1248,7 +1260,8 @@ generate_fs_loop(struct gallivm_state *gallivm, depth_ptr = depth_base_ptr; if (key->multisample) { LLVMValueRef sample_offset = LLVMBuildMul(builder, sample_loop_state.counter, depth_sample_stride, ""); - depth_ptr = LLVMBuildGEP(builder, depth_ptr, &sample_offset, 1, ""); + depth_ptr = LLVMBuildGEP2(builder, LLVMInt8TypeInContext(gallivm->context), + depth_ptr, &sample_offset, 1, ""); } /* Late Z test */ @@ -1258,8 +1271,8 @@ generate_fs_loop(struct gallivm_state *gallivm, if (key->min_samples > 1) idx = LLVMBuildAdd(builder, idx, LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""), ""); - LLVMValueRef ptr = LLVMBuildGEP(builder, z_out, &idx, 1, ""); - z = LLVMBuildLoad(builder, ptr, "output.z"); + LLVMValueRef ptr = LLVMBuildGEP2(builder, vec_type, z_out, &idx, 1, ""); + z = LLVMBuildLoad2(builder, vec_type, ptr, "output.z"); } else { if (key->multisample) { lp_build_interp_soa_update_pos_dyn(interp, gallivm, loop_state.counter, key->multisample ? sample_loop_state.counter : NULL); @@ -1280,8 +1293,8 @@ generate_fs_loop(struct gallivm_state *gallivm, if (key->min_samples > 1) idx = LLVMBuildAdd(builder, idx, LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""), ""); - LLVMValueRef ptr = LLVMBuildGEP(builder, s_out, &idx, 1, ""); - stencil_refs[0] = LLVMBuildLoad(builder, ptr, "output.s"); + LLVMValueRef ptr = LLVMBuildGEP2(builder, vec_type, s_out, &idx, 1, ""); + stencil_refs[0] = LLVMBuildLoad2(builder, vec_type, ptr, "output.s"); /* there's only one value, and spec says to discard additional bits */ LLVMValueRef s_max_mask = lp_build_const_int_vec(gallivm, int_type, 255); stencil_refs[0] = LLVMBuildBitCast(builder, stencil_refs[0], int_vec_type, ""); @@ -1322,10 +1335,10 @@ generate_fs_loop(struct gallivm_state *gallivm, * write that out. */ if (key->multisample) { - z_value = LLVMBuildBitCast(builder, lp_build_pointer_get(builder, z_sample_value_store, sample_loop_state.counter), z_type, "");; - s_value = lp_build_pointer_get(builder, s_sample_value_store, sample_loop_state.counter); - z_fb = LLVMBuildBitCast(builder, lp_build_pointer_get(builder, z_fb_store, sample_loop_state.counter), z_fb_type, ""); - s_fb = lp_build_pointer_get(builder, s_fb_store, sample_loop_state.counter); + z_value = LLVMBuildBitCast(builder, lp_build_pointer_get2(builder, int_vec_type, z_sample_value_store, sample_loop_state.counter), z_type, ""); + s_value = lp_build_pointer_get2(builder, int_vec_type, s_sample_value_store, sample_loop_state.counter); + z_fb = LLVMBuildBitCast(builder, lp_build_pointer_get2(builder, int_vec_type, z_fb_store, sample_loop_state.counter), z_fb_type, ""); + s_fb = lp_build_pointer_get2(builder, int_vec_type, s_fb_store, sample_loop_state.counter); } lp_build_depth_stencil_write_swizzled(gallivm, type, zs_format_desc, key->resource_1d, @@ -1604,6 +1617,7 @@ fs_twiddle_transpose(struct gallivm_state *gallivm, */ static void load_unswizzled_block(struct gallivm_state *gallivm, + LLVMTypeRef base_type, LLVMValueRef base_ptr, LLVMValueRef stride, unsigned block_width, @@ -1632,11 +1646,13 @@ load_unswizzled_block(struct gallivm_state *gallivm, gep[0] = lp_build_const_int32(gallivm, 0); gep[1] = LLVMBuildAdd(builder, bx, by, ""); - dst_ptr = LLVMBuildGEP(builder, base_ptr, gep, 2, ""); + dst_ptr = LLVMBuildGEP2(builder, base_type, base_ptr, gep, 2, ""); dst_ptr = LLVMBuildBitCast(builder, dst_ptr, LLVMPointerType(lp_build_vec_type(gallivm, dst_type), 0), ""); - dst[i] = LLVMBuildLoad(builder, dst_ptr, ""); + dst[i] = LLVMBuildLoad2(builder, + lp_build_vec_type(gallivm, dst_type), + dst_ptr, ""); LLVMSetAlignment(dst[i], dst_alignment); } @@ -1648,6 +1664,7 @@ load_unswizzled_block(struct gallivm_state *gallivm, */ static void store_unswizzled_block(struct gallivm_state *gallivm, + LLVMTypeRef base_type, LLVMValueRef base_ptr, LLVMValueRef stride, unsigned block_width, @@ -1676,7 +1693,7 @@ store_unswizzled_block(struct gallivm_state *gallivm, gep[0] = lp_build_const_int32(gallivm, 0); gep[1] = LLVMBuildAdd(builder, bx, by, ""); - src_ptr = LLVMBuildGEP(builder, base_ptr, gep, 2, ""); + src_ptr = LLVMBuildGEP2(builder, base_type, base_ptr, gep, 2, ""); src_ptr = LLVMBuildBitCast(builder, src_ptr, LLVMPointerType(lp_build_vec_type(gallivm, src_type), 0), ""); @@ -2377,6 +2394,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, LLVMValueRef fs_out_color[PIPE_MAX_COLOR_BUFS][TGSI_NUM_CHANNELS][4], LLVMTypeRef context_type, LLVMValueRef context_ptr, + LLVMTypeRef color_type, LLVMValueRef color_ptr, LLVMValueRef stride, unsigned partial_mask, @@ -2431,6 +2449,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, unsigned num_fullblock_fs = is_1d ? 2 * num_fs : num_fs; LLVMValueRef fpstate = 0; + LLVMTypeRef fs_vec_type = lp_build_vec_type(gallivm, fs_type); + /* Get type from output format */ lp_blend_type_from_format_desc(out_format_desc, &row_type); lp_mem_type_from_format_desc(out_format_desc, &dst_type); @@ -2550,7 +2570,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, /* Always load alpha for use in blending */ LLVMValueRef alpha; if (i < num_fs) { - alpha = LLVMBuildLoad(builder, fs_out_color[rt][alpha_channel][i], ""); + alpha = LLVMBuildLoad2(builder, fs_vec_type, + fs_out_color[rt][alpha_channel][i], ""); } else { alpha = undef_src_val; } @@ -2559,8 +2580,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, for (unsigned j = 0; j < dst_channels; ++j) { assert(swizzle[j] < 4); if (i < num_fs) { - fs_src[i][j] = LLVMBuildLoad(builder, - fs_out_color[rt][swizzle[j]][i], ""); + fs_src[i][j] = LLVMBuildLoad2(builder, fs_vec_type, + fs_out_color[rt][swizzle[j]][i], ""); } else { fs_src[i][j] = undef_src_val; } @@ -2599,7 +2620,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, for (unsigned i = 0; i < num_fullblock_fs; ++i) { LLVMValueRef alpha; if (i < num_fs) { - alpha = LLVMBuildLoad(builder, fs_out_color[1][alpha_channel][i], ""); + alpha = LLVMBuildLoad2(builder, fs_vec_type, + fs_out_color[1][alpha_channel][i], ""); } else { alpha = undef_src_val; } @@ -2607,7 +2629,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, for (unsigned j = 0; j < dst_channels; ++j) { assert(swizzle[j] < 4); if (i < num_fs) { - fs_src1[i][j] = LLVMBuildLoad(builder, fs_out_color[1][swizzle[j]][i], ""); + fs_src1[i][j] = LLVMBuildLoad2(builder, fs_vec_type, + fs_out_color[1][swizzle[j]][i], ""); } else { fs_src1[i][j] = undef_src_val; } @@ -2632,14 +2655,15 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, */ fs_type.floating = 0; fs_type.sign = dst_type.sign; + fs_vec_type = lp_build_vec_type(gallivm, fs_type); for (unsigned i = 0; i < num_fullblock_fs; ++i) { for (unsigned j = 0; j < dst_channels; ++j) { fs_src[i][j] = LLVMBuildBitCast(builder, fs_src[i][j], - lp_build_vec_type(gallivm, fs_type), ""); + fs_vec_type, ""); } if (dst_channels == 3 && !has_alpha) { fs_src[i][3] = LLVMBuildBitCast(builder, fs_src[i][3], - lp_build_vec_type(gallivm, fs_type), ""); + fs_vec_type, ""); } } } @@ -2690,6 +2714,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, unsigned ds = src_count / (num_fullblock_fs * src_channels); row_type.length /= ds; fs_type.length = row_type.length; + fs_vec_type = lp_build_vec_type(gallivm, fs_type); } blend_type = row_type; @@ -2740,9 +2765,9 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, */ blend_color = lp_jit_context_f_blend_color(gallivm, context_type, context_ptr); blend_color = LLVMBuildPointerCast(builder, blend_color, - LLVMPointerType(lp_build_vec_type(gallivm, fs_type), 0), + LLVMPointerType(fs_vec_type, 0), ""); - blend_color = LLVMBuildLoad(builder, LLVMBuildGEP(builder, blend_color, + blend_color = LLVMBuildLoad2(builder, fs_vec_type, LLVMBuildGEP2(builder, fs_vec_type, blend_color, &i32_zero, 1, ""), ""); /* Convert */ @@ -2932,13 +2957,13 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, } if (is_1d) { - load_unswizzled_block(gallivm, color_ptr, stride, block_width, 1, + load_unswizzled_block(gallivm, color_type, color_ptr, stride, block_width, 1, dst, ls_type, dst_count / 4, dst_alignment); for (unsigned i = dst_count / 4; i < dst_count; i++) { dst[i] = lp_build_undef(gallivm, ls_type); } } else { - load_unswizzled_block(gallivm, color_ptr, stride, block_width, + load_unswizzled_block(gallivm, color_type, color_ptr, stride, block_width, block_height, dst, ls_type, dst_count, dst_alignment); } @@ -3047,10 +3072,10 @@ generate_unswizzled_blend(struct gallivm_state *gallivm, * Store blend result to memory */ if (is_1d) { - store_unswizzled_block(gallivm, color_ptr, stride, block_width, 1, + store_unswizzled_block(gallivm, color_type, color_ptr, stride, block_width, 1, dst, dst_type, dst_count / 4, dst_alignment); } else { - store_unswizzled_block(gallivm, color_ptr, stride, block_width, + store_unswizzled_block(gallivm, color_type, color_ptr, stride, block_width, block_height, dst, dst_type, dst_count, dst_alignment); } @@ -3089,6 +3114,7 @@ generate_fragment(struct llvmpipe_context *lp, LLVMTypeRef func_type; LLVMTypeRef int32_type = LLVMInt32TypeInContext(gallivm->context); LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); + LLVMTypeRef int8p_type = LLVMPointerType(int8_type, 0); LLVMValueRef context_ptr; LLVMValueRef x; LLVMValueRef y; @@ -3405,6 +3431,7 @@ generate_fragment(struct llvmpipe_context *lp, variant->jit_thread_data_type, thread_data_ptr); + LLVMTypeRef fs_vec_type = lp_build_vec_type(gallivm, fs_type); for (unsigned i = 0; i < num_fs; i++) { LLVMValueRef ptr; for (unsigned s = 0; s < key->coverage_samples; s++) { @@ -3421,9 +3448,9 @@ generate_fragment(struct llvmpipe_context *lp, LLVMValueRef sindexi = lp_build_const_int32(gallivm, idx); for (unsigned cbuf = 0; cbuf < key->nr_cbufs; cbuf++) { for (unsigned chan = 0; chan < TGSI_NUM_CHANNELS; ++chan) { - ptr = LLVMBuildGEP(builder, - color_store[cbuf * !cbuf0_write_all][chan], - &sindexi, 1, ""); + ptr = LLVMBuildGEP2(builder, fs_vec_type, + color_store[cbuf * !cbuf0_write_all][chan], + &sindexi, 1, ""); fs_out_color[s][cbuf][chan][i] = ptr; } } @@ -3432,9 +3459,9 @@ generate_fragment(struct llvmpipe_context *lp, * output 1 */ for (unsigned chan = 0; chan < TGSI_NUM_CHANNELS; ++chan) { - ptr = LLVMBuildGEP(builder, - color_store[1][chan], - &sindexi, 1, ""); + ptr = LLVMBuildGEP2(builder, fs_vec_type, + color_store[1][chan], + &sindexi, 1, ""); fs_out_color[s][1][chan][i] = ptr; } } @@ -3458,32 +3485,33 @@ generate_fragment(struct llvmpipe_context *lp, || key->alpha.enabled) && !shader->info.base.uses_kill); - color_ptr = LLVMBuildLoad(builder, - LLVMBuildGEP(builder, color_ptr_ptr, - &index, 1, ""), - ""); + color_ptr = LLVMBuildLoad2(builder, int8p_type, + LLVMBuildGEP2(builder, int8p_type, color_ptr_ptr, + &index, 1, ""), + ""); - stride = LLVMBuildLoad(builder, - LLVMBuildGEP(builder, stride_ptr, + stride = LLVMBuildLoad2(builder, int32_type, + LLVMBuildGEP2(builder, int32_type, stride_ptr, &index, 1, ""), - ""); + ""); if (key->cbuf_nr_samples[cbuf] > 1) - sample_stride = LLVMBuildLoad(builder, - LLVMBuildGEP(builder, - color_sample_stride_ptr, - &index, 1, ""), ""); + sample_stride = LLVMBuildLoad2(builder, int32_type, + LLVMBuildGEP2(builder, + int32_type, + color_sample_stride_ptr, + &index, 1, ""), ""); for (unsigned s = 0; s < key->cbuf_nr_samples[cbuf]; s++) { unsigned mask_idx = num_fs * (key->multisample ? s : 0); unsigned out_idx = key->min_samples == 1 ? 0 : s; - LLVMValueRef out_ptr = color_ptr;; + LLVMValueRef out_ptr = color_ptr; if (sample_stride) { LLVMValueRef sample_offset = LLVMBuildMul(builder, sample_stride, lp_build_const_int32(gallivm, s), ""); - out_ptr = LLVMBuildGEP(builder, out_ptr, &sample_offset, 1, ""); + out_ptr = LLVMBuildGEP2(builder, int8_type, out_ptr, &sample_offset, 1, ""); } out_ptr = LLVMBuildBitCast(builder, out_ptr, LLVMPointerType(blend_vec_type, 0), ""); @@ -3495,7 +3523,7 @@ generate_fragment(struct llvmpipe_context *lp, num_fs, fs_type, &fs_mask[mask_idx], fs_out_color[out_idx], variant->jit_context_type, - context_ptr, out_ptr, stride, + context_ptr, blend_vec_type, out_ptr, stride, partial_mask, do_branch); } } -- GitLab From 5b83357ac5aea1b1735030cd1ece13d1a7e2f402 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:25:42 +1000 Subject: [PATCH 09/10] llvmpipe/fs: cleanup some remaining mask handling and reuse types Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 33 +++++++++++----------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 900d2c1e63c3b..d906d83840eff 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -831,8 +831,8 @@ generate_fs_loop(struct gallivm_state *gallivm, lp_build_mask_check(&mask); /* Create storage for recombining sample masks after early Z pass. */ - LLVMValueRef s_mask_or = lp_build_alloca(gallivm, lp_build_int_vec_type(gallivm, type), "cov_mask_early_depth"); - LLVMBuildStore(builder, LLVMConstNull(lp_build_int_vec_type(gallivm, type)), s_mask_or); + LLVMValueRef s_mask_or = lp_build_alloca(gallivm, int_vec_type, "cov_mask_early_depth"); + LLVMBuildStore(builder, LLVMConstNull(int_vec_type), s_mask_or); /* Create storage for post depth sample mask */ LLVMValueRef post_depth_sample_mask_in = NULL; @@ -953,13 +953,13 @@ generate_fs_loop(struct gallivm_state *gallivm, * Recombine the resulting coverage masks post early Z into the fragment * shader execution mask. */ - LLVMValueRef tmp_s_mask_or = LLVMBuildLoad(builder, s_mask_or, ""); + LLVMValueRef tmp_s_mask_or = LLVMBuildLoad2(builder, int_vec_type, s_mask_or, ""); tmp_s_mask_or = LLVMBuildOr(builder, tmp_s_mask_or, s_mask, ""); LLVMBuildStore(builder, tmp_s_mask_or, s_mask_or); if (post_depth_coverage) { LLVMValueRef mask_bit_idx = LLVMBuildShl(builder, lp_build_const_int32(gallivm, 1), sample_loop_state.counter, ""); - LLVMValueRef post_depth_mask_in = LLVMBuildLoad(builder, post_depth_sample_mask_in, ""); + LLVMValueRef post_depth_mask_in = LLVMBuildLoad2(builder, int_vec_type, post_depth_sample_mask_in, ""); mask_bit_idx = LLVMBuildAnd(builder, s_mask, lp_build_broadcast(gallivm, int_vec_type, mask_bit_idx), ""); post_depth_mask_in = LLVMBuildOr(builder, post_depth_mask_in, mask_bit_idx, ""); LLVMBuildStore(builder, post_depth_mask_in, post_depth_sample_mask_in); @@ -970,7 +970,7 @@ generate_fs_loop(struct gallivm_state *gallivm, lp_build_for_loop_end(&sample_loop_state); /* recombined all the coverage masks in the shader exec mask. */ - tmp_s_mask_or = LLVMBuildLoad(builder, s_mask_or, ""); + tmp_s_mask_or = LLVMBuildLoad2(builder, int_vec_type, s_mask_or, ""); lp_build_mask_update(&mask, tmp_s_mask_or); if (key->min_samples == 1) { @@ -994,7 +994,7 @@ generate_fs_loop(struct gallivm_state *gallivm, } if (post_depth_coverage) { - system_values.sample_mask_in = LLVMBuildLoad(builder, post_depth_sample_mask_in, ""); + system_values.sample_mask_in = LLVMBuildLoad2(builder, int_vec_type, post_depth_sample_mask_in, ""); } else { system_values.sample_mask_in = sample_mask_in; } @@ -1140,7 +1140,7 @@ generate_fs_loop(struct gallivm_state *gallivm, if (key->min_samples > 1) { /* only the bit corresponding to this sample is to be used. */ - LLVMValueRef tmp_mask = LLVMBuildLoad(builder, out_sample_mask_storage, "tmp_mask"); + LLVMValueRef tmp_mask = LLVMBuildLoad2(builder, int_vec_type, out_sample_mask_storage, "tmp_mask"); LLVMValueRef out_smask_idx = LLVMBuildShl(builder, lp_build_const_int32(gallivm, 1), sample_loop_state.counter, ""); LLVMValueRef smask_bit = LLVMBuildAnd(builder, output_smask, lp_build_broadcast(gallivm, int_vec_type, out_smask_idx), ""); output_smask = LLVMBuildOr(builder, tmp_mask, smask_bit, ""); @@ -1248,7 +1248,7 @@ generate_fs_loop(struct gallivm_state *gallivm, (!(depth_mode & EARLY_DEPTH_TEST) || (depth_mode & (EARLY_DEPTH_TEST_INFERRED)))) { LLVMValueRef out_smask_idx = LLVMBuildShl(builder, lp_build_const_int32(gallivm, 1), sample_loop_state.counter, ""); out_smask_idx = lp_build_broadcast(gallivm, int_vec_type, out_smask_idx); - LLVMValueRef output_smask = LLVMBuildLoad(builder, out_sample_mask_storage, ""); + LLVMValueRef output_smask = LLVMBuildLoad2(builder, int_vec_type, out_sample_mask_storage, ""); LLVMValueRef smask_bit = LLVMBuildAnd(builder, output_smask, out_smask_idx, ""); LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntNE, smask_bit, lp_build_const_int_vec(gallivm, int_type, 0), ""); smask_bit = LLVMBuildSExt(builder, cmp, int_vec_type, ""); @@ -1363,7 +1363,7 @@ generate_fs_loop(struct gallivm_state *gallivm, /* if the shader writes sample mask use that */ LLVMValueRef out_smask_idx = LLVMBuildShl(builder, lp_build_const_int32(gallivm, 1), sample_loop_state.counter, ""); out_smask_idx = lp_build_broadcast(gallivm, int_vec_type, out_smask_idx); - LLVMValueRef output_smask = LLVMBuildLoad(builder, out_sample_mask_storage, ""); + LLVMValueRef output_smask = LLVMBuildLoad2(builder, int_vec_type, out_sample_mask_storage, ""); LLVMValueRef smask_bit = LLVMBuildAnd(builder, output_smask, out_smask_idx, ""); LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntNE, smask_bit, lp_build_const_int_vec(gallivm, int_type, 0), ""); smask_bit = LLVMBuildSExt(builder, cmp, int_vec_type, ""); @@ -3113,6 +3113,7 @@ generate_fragment(struct llvmpipe_context *lp, LLVMTypeRef arg_types[15]; LLVMTypeRef func_type; LLVMTypeRef int32_type = LLVMInt32TypeInContext(gallivm->context); + LLVMTypeRef int32p_type = LLVMPointerType(int32_type, 0); LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); LLVMTypeRef int8p_type = LLVMPointerType(int8_type, 0); LLVMValueRef context_ptr; @@ -3198,13 +3199,13 @@ generate_fragment(struct llvmpipe_context *lp, arg_types[4] = LLVMPointerType(fs_elem_type, 0); /* a0 */ arg_types[5] = LLVMPointerType(fs_elem_type, 0); /* dadx */ arg_types[6] = LLVMPointerType(fs_elem_type, 0); /* dady */ - arg_types[7] = LLVMPointerType(LLVMPointerType(int8_type, 0), 0); /* color */ - arg_types[8] = LLVMPointerType(int8_type, 0); /* depth */ + arg_types[7] = LLVMPointerType(int8p_type, 0); /* color */ + arg_types[8] = int8p_type; /* depth */ arg_types[9] = LLVMInt64TypeInContext(gallivm->context); /* mask_input */ arg_types[10] = variant->jit_thread_data_ptr_type; /* per thread data */ - arg_types[11] = LLVMPointerType(int32_type, 0); /* stride */ + arg_types[11] = int32p_type; /* stride */ arg_types[12] = int32_type; /* depth_stride */ - arg_types[13] = LLVMPointerType(int32_type, 0); /* color sample strides */ + arg_types[13] = int32p_type; /* color sample strides */ arg_types[14] = int32_type; /* depth sample stride */ func_type = LLVMFunctionType(LLVMVoidTypeInContext(gallivm->context), @@ -3359,9 +3360,9 @@ generate_fragment(struct llvmpipe_context *lp, for (unsigned i = 0; i < num_fs; i++) { if (key->multisample) { LLVMValueRef smask_val = - LLVMBuildLoad(builder, - lp_jit_context_sample_mask(gallivm, variant->jit_context_type, context_ptr), - ""); + LLVMBuildLoad2(builder, int32_type, + lp_jit_context_sample_mask(gallivm, variant->jit_context_type, context_ptr), + ""); /* * For multisampling, extract the per-sample mask from the -- GitLab From 111bf8bfee280683a4c2d14ec08f65675204138c Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Thu, 29 Sep 2022 08:26:01 +1000 Subject: [PATCH 10/10] llvmpipe/fs: convert outputs handling to explicit api Reviewed-by: Brian Paul Reviewed-by: Mihai Preda Part-of: --- src/gallium/drivers/llvmpipe/lp_state_fs.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index d906d83840eff..b65a3a897eb9c 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -1074,7 +1074,7 @@ generate_fs_loop(struct gallivm_state *gallivm, if (color0 != -1 && outputs[color0][3]) { const struct util_format_description *cbuf_format_desc; - LLVMValueRef alpha = LLVMBuildLoad(builder, outputs[color0][3], "alpha"); + LLVMValueRef alpha = LLVMBuildLoad2(builder, vec_type, outputs[color0][3], "alpha"); LLVMValueRef alpha_ref_value; alpha_ref_value = lp_jit_context_alpha_ref_value(gallivm, context_type, context_ptr); @@ -1095,7 +1095,7 @@ generate_fs_loop(struct gallivm_state *gallivm, 0); if (color0 != -1 && outputs[color0][3]) { - LLVMValueRef alpha = LLVMBuildLoad(builder, outputs[color0][3], "alpha"); + LLVMValueRef alpha = LLVMBuildLoad2(builder, vec_type, outputs[color0][3], "alpha"); if (!key->multisample) { lp_build_alpha_to_coverage(gallivm, type, @@ -1130,7 +1130,7 @@ generate_fs_loop(struct gallivm_state *gallivm, lp_build_context_init(&smask_bld, gallivm, int_type); assert(smaski >= 0); - output_smask = LLVMBuildLoad(builder, outputs[smaski][0], "smask"); + output_smask = LLVMBuildLoad2(builder, vec_type, outputs[smaski][0], "smask"); output_smask = LLVMBuildBitCast(builder, output_smask, smask_bld.vec_type, ""); if (!key->multisample && key->no_ms_sample_mask_out) { output_smask = lp_build_and(&smask_bld, output_smask, smask_bld.one); @@ -1153,12 +1153,12 @@ generate_fs_loop(struct gallivm_state *gallivm, int pos0 = find_output_by_semantic(&shader->info.base, TGSI_SEMANTIC_POSITION, 0); - LLVMValueRef out = LLVMBuildLoad(builder, outputs[pos0][2], ""); + LLVMValueRef out = LLVMBuildLoad2(builder, vec_type, outputs[pos0][2], ""); LLVMValueRef idx = loop_state.counter; if (key->min_samples > 1) idx = LLVMBuildAdd(builder, idx, LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""), ""); - LLVMValueRef ptr = LLVMBuildGEP(builder, z_out, &idx, 1, ""); + LLVMValueRef ptr = LLVMBuildGEP2(builder, vec_type, z_out, &idx, 1, ""); LLVMBuildStore(builder, out, ptr); } @@ -1166,12 +1166,13 @@ generate_fs_loop(struct gallivm_state *gallivm, int sten_out = find_output_by_semantic(&shader->info.base, TGSI_SEMANTIC_STENCIL, 0); - LLVMValueRef out = LLVMBuildLoad(builder, outputs[sten_out][1], "output.s"); + LLVMValueRef out = LLVMBuildLoad2(builder, vec_type, + outputs[sten_out][1], "output.s"); LLVMValueRef idx = loop_state.counter; if (key->min_samples > 1) idx = LLVMBuildAdd(builder, idx, LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""), ""); - LLVMValueRef ptr = LLVMBuildGEP(builder, s_out, &idx, 1, ""); + LLVMValueRef ptr = LLVMBuildGEP2(builder, vec_type, s_out, &idx, 1, ""); LLVMBuildStore(builder, out, ptr); } @@ -1205,14 +1206,14 @@ generate_fs_loop(struct gallivm_state *gallivm, /* XXX: just initialize outputs to point at colors[] and * skip this. */ - LLVMValueRef out = LLVMBuildLoad(builder, outputs[attrib][chan], ""); + LLVMValueRef out = LLVMBuildLoad2(builder, vec_type, outputs[attrib][chan], ""); LLVMValueRef color_ptr; LLVMValueRef color_idx = loop_state.counter; if (key->min_samples > 1) color_idx = LLVMBuildAdd(builder, color_idx, LLVMBuildMul(builder, sample_loop_state.counter, num_loop, ""), ""); - color_ptr = LLVMBuildGEP(builder, out_color[cbuf][chan], - &color_idx, 1, ""); + color_ptr = LLVMBuildGEP2(builder, vec_type, out_color[cbuf][chan], + &color_idx, 1, ""); lp_build_name(out, "color%u.%c", attrib, "rgba"[chan]); LLVMBuildStore(builder, out, color_ptr); } -- GitLab From 3d242c044758292712e1876ba3afdd3e8f06d5df Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Tue, 4 Oct 2022 09:41:00 +1000 Subject: [PATCH 1/6] llvmpipe/tests: port to new pointer interfaces. Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/drivers/llvmpipe/lp_test_arit.c | 6 +++--- src/gallium/drivers/llvmpipe/lp_test_blend.c | 8 ++++---- src/gallium/drivers/llvmpipe/lp_test_conv.c | 12 +++++++----- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/gallium/drivers/llvmpipe/lp_test_arit.c b/src/gallium/drivers/llvmpipe/lp_test_arit.c index 55ced4c67ccd4..4118928d52ed0 100644 --- a/src/gallium/drivers/llvmpipe/lp_test_arit.c +++ b/src/gallium/drivers/llvmpipe/lp_test_arit.c @@ -362,11 +362,11 @@ build_unary_test_func(struct gallivm_state *gallivm, LLVMSetFunctionCallConv(func, LLVMCCallConv); LLVMPositionBuilderAtEnd(builder, block); - - arg1 = LLVMBuildLoad(builder, arg1, ""); + + arg1 = LLVMBuildLoad2(builder, vf32t, arg1, ""); ret = test->builder(&bld, arg1); - + LLVMBuildStore(builder, ret, arg0); LLVMBuildRetVoid(builder); diff --git a/src/gallium/drivers/llvmpipe/lp_test_blend.c b/src/gallium/drivers/llvmpipe/lp_test_blend.c index 7805ec58d98a3..2d44e8eafe70c 100644 --- a/src/gallium/drivers/llvmpipe/lp_test_blend.c +++ b/src/gallium/drivers/llvmpipe/lp_test_blend.c @@ -172,10 +172,10 @@ add_blend_test(struct gallivm_state *gallivm, builder = gallivm->builder; LLVMPositionBuilderAtEnd(builder, block); - src = LLVMBuildLoad(builder, src_ptr, "src"); - src1 = LLVMBuildLoad(builder, src1_ptr, "src1"); - dst = LLVMBuildLoad(builder, dst_ptr, "dst"); - con = LLVMBuildLoad(builder, const_ptr, "const"); + src = LLVMBuildLoad2(builder, vec_type, src_ptr, "src"); + src1 = LLVMBuildLoad2(builder, vec_type, src1_ptr, "src1"); + dst = LLVMBuildLoad2(builder, vec_type, dst_ptr, "dst"); + con = LLVMBuildLoad2(builder, vec_type, const_ptr, "const"); res = lp_build_blend_aos(gallivm, blend, format, type, rt, src, NULL, src1, NULL, dst, NULL, con, NULL, swizzle, 4); diff --git a/src/gallium/drivers/llvmpipe/lp_test_conv.c b/src/gallium/drivers/llvmpipe/lp_test_conv.c index 9ae148866af38..05aaa1b4fcdab 100644 --- a/src/gallium/drivers/llvmpipe/lp_test_conv.c +++ b/src/gallium/drivers/llvmpipe/lp_test_conv.c @@ -112,9 +112,11 @@ add_conv_test(struct gallivm_state *gallivm, LLVMValueRef src[LP_MAX_VECTOR_LENGTH]; LLVMValueRef dst[LP_MAX_VECTOR_LENGTH]; unsigned i; + LLVMTypeRef src_vec_type = lp_build_vec_type(gallivm, src_type); + LLVMTypeRef dst_vec_type = lp_build_vec_type(gallivm, dst_type); - args[0] = LLVMPointerType(lp_build_vec_type(gallivm, src_type), 0); - args[1] = LLVMPointerType(lp_build_vec_type(gallivm, dst_type), 0); + args[0] = LLVMPointerType(src_vec_type, 0); + args[1] = LLVMPointerType(dst_vec_type, 0); func = LLVMAddFunction(module, "test", LLVMFunctionType(LLVMVoidTypeInContext(context), @@ -128,15 +130,15 @@ add_conv_test(struct gallivm_state *gallivm, for(i = 0; i < num_srcs; ++i) { LLVMValueRef index = LLVMConstInt(LLVMInt32TypeInContext(context), i, 0); - LLVMValueRef ptr = LLVMBuildGEP(builder, src_ptr, &index, 1, ""); - src[i] = LLVMBuildLoad(builder, ptr, ""); + LLVMValueRef ptr = LLVMBuildGEP2(builder, src_vec_type, src_ptr, &index, 1, ""); + src[i] = LLVMBuildLoad2(builder, src_vec_type, ptr, ""); } lp_build_conv(gallivm, src_type, dst_type, src, num_srcs, dst, num_dsts); for(i = 0; i < num_dsts; ++i) { LLVMValueRef index = LLVMConstInt(LLVMInt32TypeInContext(context), i, 0); - LLVMValueRef ptr = LLVMBuildGEP(builder, dst_ptr, &index, 1, ""); + LLVMValueRef ptr = LLVMBuildGEP2(builder, dst_vec_type, dst_ptr, &index, 1, ""); LLVMBuildStore(builder, dst[i], ptr); } -- GitLab From 9fe8e5ccf7a18c02634be4e80bb15e854e95e78a Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 14:11:30 +1000 Subject: [PATCH 2/6] gallivm/llvmpipe: add opaque pointers support to sampler This adds explicit context types wiring through the sampler code Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/draw/draw_llvm.c | 4 ++ src/gallium/auxiliary/draw/draw_llvm_sample.c | 18 +++-- src/gallium/auxiliary/gallivm/lp_bld_nir.h | 2 + .../auxiliary/gallivm/lp_bld_nir_soa.c | 8 +++ src/gallium/auxiliary/gallivm/lp_bld_sample.c | 20 +++--- src/gallium/auxiliary/gallivm/lp_bld_sample.h | 23 +++++++ .../auxiliary/gallivm/lp_bld_sample_soa.c | 69 ++++++++++++++----- src/gallium/auxiliary/gallivm/lp_bld_tgsi.h | 4 ++ .../auxiliary/gallivm/lp_bld_tgsi_soa.c | 16 +++++ src/gallium/drivers/llvmpipe/lp_state_cs.c | 1 + src/gallium/drivers/llvmpipe/lp_state_fs.c | 2 + src/gallium/drivers/llvmpipe/lp_tex_sample.c | 21 ++++-- 12 files changed, 148 insertions(+), 40 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index 3bdc8775bd7e5..16c93ec85f24e 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -965,6 +965,7 @@ generate_vs(struct draw_llvm_variant *variant, params.consts_ptr = consts_ptr; params.system_values = system_values; params.inputs = inputs; + params.context_type = variant->context_type; params.context_ptr = context_ptr; params.sampler = draw_sampler; params.info = &llvm->draw->vs.vertex_shader->info; @@ -2872,6 +2873,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, params.mask = &mask; params.consts_ptr = consts_ptr; params.system_values = &system_values; + params.context_type = variant->context_type; params.context_ptr = context_ptr; params.sampler = sampler; params.info = &llvm->draw->gs.geometry_shader->info; @@ -3533,6 +3535,7 @@ draw_tcs_llvm_generate(struct draw_llvm *llvm, params.mask = &mask; params.consts_ptr = consts_ptr; params.system_values = &system_values; + params.context_type = variant->context_type; params.context_ptr = context_ptr; params.sampler = sampler; params.info = &llvm->draw->tcs.tess_ctrl_shader->info; @@ -4062,6 +4065,7 @@ draw_tes_llvm_generate(struct draw_llvm *llvm, params.mask = &mask; params.consts_ptr = consts_ptr; params.system_values = &system_values; + params.context_type = variant->context_type; params.context_ptr = context_ptr; params.sampler = sampler; params.info = &llvm->draw->tes.tess_eval_shader->info; diff --git a/src/gallium/auxiliary/draw/draw_llvm_sample.c b/src/gallium/auxiliary/draw/draw_llvm_sample.c index 6032f5b2a002f..5a48fb17caf2b 100644 --- a/src/gallium/auxiliary/draw/draw_llvm_sample.c +++ b/src/gallium/auxiliary/draw/draw_llvm_sample.c @@ -100,6 +100,7 @@ struct draw_llvm_image_soa */ static LLVMValueRef draw_llvm_texture_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset, @@ -128,7 +129,7 @@ draw_llvm_texture_member(struct gallivm_state *gallivm, /* context[0].textures[unit].member */ indices[3] = lp_build_const_int32(gallivm, member_index); - ptr = LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); if (emit_load) res = LLVMBuildLoad(builder, ptr, ""); @@ -151,6 +152,7 @@ draw_llvm_texture_member(struct gallivm_state *gallivm, */ static LLVMValueRef draw_llvm_sampler_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit, unsigned member_index, @@ -173,7 +175,7 @@ draw_llvm_sampler_member(struct gallivm_state *gallivm, /* context[0].samplers[unit].member */ indices[3] = lp_build_const_int32(gallivm, member_index); - ptr = LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); if (emit_load) res = LLVMBuildLoad(builder, ptr, ""); @@ -195,6 +197,7 @@ draw_llvm_sampler_member(struct gallivm_state *gallivm, */ static LLVMValueRef draw_llvm_image_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned image_unit, LLVMValueRef image_unit_offset, @@ -223,7 +226,7 @@ draw_llvm_image_member(struct gallivm_state *gallivm, /* context[0].textures[unit].member */ indices[3] = lp_build_const_int32(gallivm, member_index); - ptr = LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); if (emit_load) res = LLVMBuildLoad(builder, ptr, ""); @@ -247,11 +250,12 @@ draw_llvm_image_member(struct gallivm_state *gallivm, #define DRAW_LLVM_TEXTURE_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ draw_llvm_texture_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned texture_unit, \ LLVMValueRef texture_unit_offset) \ { \ - return draw_llvm_texture_member(gallivm, context_ptr, \ + return draw_llvm_texture_member(gallivm, context_type, context_ptr, \ texture_unit, texture_unit_offset, \ _index, #_name, _emit_load ); \ } @@ -272,10 +276,11 @@ DRAW_LLVM_TEXTURE_MEMBER(sample_stride, DRAW_JIT_TEXTURE_SAMPLE_STRIDE, TRUE) #define DRAW_LLVM_SAMPLER_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ draw_llvm_sampler_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned sampler_unit) \ { \ - return draw_llvm_sampler_member(gallivm, context_ptr, \ + return draw_llvm_sampler_member(gallivm, context_type, context_ptr, \ sampler_unit, _index, #_name, _emit_load ); \ } @@ -289,10 +294,11 @@ DRAW_LLVM_SAMPLER_MEMBER(max_aniso, DRAW_JIT_SAMPLER_MAX_ANISO, TRUE) #define DRAW_LLVM_IMAGE_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ draw_llvm_image_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned image_unit, LLVMValueRef image_unit_offset) \ { \ - return draw_llvm_image_member(gallivm, context_ptr, \ + return draw_llvm_image_member(gallivm, context_type, context_ptr, \ image_unit, image_unit_offset, \ _index, #_name, _emit_load ); \ } diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir.h b/src/gallium/auxiliary/gallivm/lp_bld_nir.h index 922208d8603d5..727837e9a5390 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir.h @@ -246,7 +246,9 @@ struct lp_build_nir_soa_context LLVMValueRef consts_sizes[LP_MAX_TGSI_CONST_BUFFERS]; const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS]; LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS]; + LLVMTypeRef context_type; LLVMValueRef context_ptr; + LLVMTypeRef thread_data_type; LLVMValueRef thread_data_ptr; LLVMValueRef ssbo_ptr; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c index dafbffb344833..443bf4fea8afd 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_nir_soa.c @@ -1613,7 +1613,9 @@ static void emit_image_op(struct lp_build_nir_context *bld_base, struct gallivm_state *gallivm = bld_base->base.gallivm; params->type = bld_base->base.type; + params->context_type = bld->context_type; params->context_ptr = bld->context_ptr; + params->thread_data_type = bld->thread_data_type; params->thread_data_ptr = bld->thread_data_ptr; params->exec_mask = mask_vec(bld_base); @@ -1634,6 +1636,7 @@ static void emit_image_size(struct lp_build_nir_context *bld_base, struct gallivm_state *gallivm = bld_base->base.gallivm; params->int_type = bld_base->int_bld.type; + params->context_type = bld->context_type; params->context_ptr = bld->context_ptr; if (params->texture_unit_offset) @@ -1691,7 +1694,9 @@ static void emit_tex(struct lp_build_nir_context *bld_base, LLVMBuilderRef builder = bld_base->base.gallivm->builder; params->type = bld_base->base.type; + params->context_type = bld->context_type; params->context_ptr = bld->context_ptr; + params->thread_data_type = bld->thread_data_type; params->thread_data_ptr = bld->thread_data_ptr; if (params->texture_index_offset && bld_base->shader->info.stage != MESA_SHADER_FRAGMENT) { @@ -1774,6 +1779,7 @@ static void emit_tex_size(struct lp_build_nir_context *bld_base, struct lp_build_nir_soa_context *bld = (struct lp_build_nir_soa_context *)bld_base; params->int_type = bld_base->int_bld.type; + params->context_type = bld->context_type; params->context_ptr = bld->context_ptr; if (params->texture_unit_offset) @@ -2847,7 +2853,9 @@ void lp_build_nir_soa(struct gallivm_state *gallivm, bld.sampler = params->sampler; // bld.bld_base.info = params->info; + bld.context_type = params->context_type; bld.context_ptr = params->context_ptr; + bld.thread_data_type = params->thread_data_type; bld.thread_data_ptr = params->thread_data_ptr; bld.bld_base.aniso_filter_table = params->aniso_filter_table; bld.image = params->image; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index bb7b422346575..cdbf737031a8c 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -266,7 +266,7 @@ lp_build_pmin(struct lp_build_sample_context *bld, boolean pmin_per_quad = pmin_bld->type.length != length; unsigned i; - first_level = bld->dynamic_state->first_level(bld->gallivm, + first_level = bld->dynamic_state->first_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); first_level_vec = lp_build_broadcast_scalar(int_size_bld, first_level); int_size = lp_build_minify(int_size_bld, bld->int_size, first_level_vec, TRUE); @@ -376,7 +376,7 @@ lp_build_rho(struct lp_build_sample_context *bld, * the messy cube maps for now) when requested. */ - first_level = bld->dynamic_state->first_level(bld->gallivm, + first_level = bld->dynamic_state->first_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); first_level_vec = lp_build_broadcast_scalar(int_size_bld, first_level); int_size = lp_build_minify(int_size_bld, bld->int_size, first_level_vec, TRUE); @@ -854,7 +854,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, * This is hit during mipmap generation. */ LLVMValueRef min_lod = - dynamic_state->min_lod(bld->gallivm, + dynamic_state->min_lod(bld->gallivm, bld->context_type, bld->context_ptr, sampler_unit); lod = lp_build_broadcast_scalar(lodf_bld, min_lod); @@ -952,7 +952,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, /* add sampler lod bias */ if (bld->static_sampler_state->lod_bias_non_zero) { LLVMValueRef sampler_lod_bias = - dynamic_state->lod_bias(bld->gallivm, + dynamic_state->lod_bias(bld->gallivm, bld->context_type, bld->context_ptr, sampler_unit); sampler_lod_bias = lp_build_broadcast_scalar(lodf_bld, sampler_lod_bias); @@ -966,7 +966,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, /* clamp lod */ if (bld->static_sampler_state->apply_max_lod) { LLVMValueRef max_lod = - dynamic_state->max_lod(bld->gallivm, + dynamic_state->max_lod(bld->gallivm, bld->context_type, bld->context_ptr, sampler_unit); max_lod = lp_build_broadcast_scalar(lodf_bld, max_lod); @@ -974,7 +974,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, } if (bld->static_sampler_state->apply_min_lod) { LLVMValueRef min_lod = - dynamic_state->min_lod(bld->gallivm, + dynamic_state->min_lod(bld->gallivm, bld->context_type, bld->context_ptr, sampler_unit); min_lod = lp_build_broadcast_scalar(lodf_bld, min_lod); @@ -1032,9 +1032,9 @@ lp_build_nearest_mip_level(struct lp_build_sample_context *bld, struct lp_sampler_dynamic_state *dynamic_state = bld->dynamic_state; LLVMValueRef first_level, last_level, level; - first_level = dynamic_state->first_level(bld->gallivm, + first_level = dynamic_state->first_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); - last_level = dynamic_state->last_level(bld->gallivm, + last_level = dynamic_state->last_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); first_level = lp_build_broadcast_scalar(leveli_bld, first_level); last_level = lp_build_broadcast_scalar(leveli_bld, last_level); @@ -1094,9 +1094,9 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld, assert(bld->num_lods == bld->num_mips); - first_level = dynamic_state->first_level(bld->gallivm, + first_level = dynamic_state->first_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); - last_level = dynamic_state->last_level(bld->gallivm, + last_level = dynamic_state->last_level(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); first_level = lp_build_broadcast_scalar(leveli_bld, first_level); last_level = lp_build_broadcast_scalar(leveli_bld, last_level); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.h b/src/gallium/auxiliary/gallivm/lp_bld_sample.h index 91d946545c81c..ecebc8fc631fe 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.h @@ -109,7 +109,9 @@ struct lp_sampler_params unsigned sampler_index; LLVMValueRef texture_index_offset; unsigned sample_key; + LLVMTypeRef context_type; LLVMValueRef context_ptr; + LLVMTypeRef thread_data_type; LLVMValueRef thread_data_ptr; const LLVMValueRef *coords; const LLVMValueRef *offsets; @@ -127,6 +129,7 @@ struct lp_sampler_size_query_params unsigned texture_unit; LLVMValueRef texture_unit_offset; unsigned target; + LLVMTypeRef context_type; LLVMValueRef context_ptr; boolean is_sviewinfo; bool samples_only; @@ -149,7 +152,9 @@ struct lp_img_params unsigned target; LLVMAtomicRMWBinOp op; LLVMValueRef exec_mask; + LLVMTypeRef context_type; LLVMValueRef context_ptr; + LLVMTypeRef thread_data_type; LLVMValueRef thread_data_ptr; const LLVMValueRef *coords; LLVMValueRef ms_index; @@ -230,66 +235,77 @@ struct lp_sampler_dynamic_state /** Obtain the base texture width (or number of elements) (returns int32) */ LLVMValueRef (*width)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain the base texture height (returns int32) */ LLVMValueRef (*height)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain the base texture depth (or array size) (returns int32) */ LLVMValueRef (*depth)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain the first mipmap level (base level) (returns int32) */ LLVMValueRef (*first_level)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain the number of mipmap levels minus one (returns int32) */ LLVMValueRef (*last_level)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain stride in bytes between image rows/blocks (returns int32) */ LLVMValueRef (*row_stride)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain stride in bytes between image slices (returns int32) */ LLVMValueRef (*img_stride)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain pointer to base of texture */ LLVMValueRef (*base_ptr)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain pointer to array of mipmap offsets */ LLVMValueRef (*mip_offsets)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain number of samples (returns int32) */ LLVMValueRef (*num_samples)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); /** Obtain multisample stride (returns int32) */ LLVMValueRef (*sample_stride)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset); @@ -298,30 +314,35 @@ struct lp_sampler_dynamic_state /** Obtain texture min lod (returns float) */ LLVMValueRef (*min_lod)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit); /** Obtain texture max lod (returns float) */ LLVMValueRef (*max_lod)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit); /** Obtain texture lod bias (returns float) */ LLVMValueRef (*lod_bias)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit); /** Obtain texture border color (returns ptr to float[4]) */ LLVMValueRef (*border_color)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit); /** Obtain maximum anisotropy */ LLVMValueRef (*max_aniso)(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit); @@ -332,6 +353,7 @@ struct lp_sampler_dynamic_state */ LLVMValueRef (*cache_ptr)(struct gallivm_state *gallivm, + LLVMTypeRef thread_data_type, LLVMValueRef thread_data_ptr, unsigned unit); }; @@ -440,6 +462,7 @@ struct lp_build_sample_context LLVMValueRef border_color_clamped; + LLVMTypeRef context_type; LLVMValueRef context_ptr; LLVMValueRef aniso_filter_table; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c index bf0453b3de284..c24833dafe123 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c @@ -2046,7 +2046,7 @@ lp_build_layer_coord(struct lp_build_sample_context *bld, LLVMValueRef num_layers; struct lp_build_context *int_coord_bld = &bld->int_coord_bld; - num_layers = bld->dynamic_state->depth(bld->gallivm, + num_layers = bld->dynamic_state->depth(bld->gallivm, bld->context_type, bld->context_ptr, texture_unit, NULL); if (out_of_bounds) { @@ -2611,6 +2611,7 @@ lp_build_sample_common(struct lp_build_sample_context *bld, if (aniso) max_aniso = bld->dynamic_state->max_aniso(bld->gallivm, + bld->context_type, bld->context_ptr, sampler_index); @@ -2625,9 +2626,11 @@ lp_build_sample_common(struct lp_build_sample_context *bld, if (is_lodq) { LLVMValueRef last_level; last_level = bld->dynamic_state->last_level(bld->gallivm, + bld->context_type, bld->context_ptr, texture_index, NULL); first_level = bld->dynamic_state->first_level(bld->gallivm, + bld->context_type, bld->context_ptr, texture_index, NULL); last_level = lp_build_sub(&bld->int_bld, last_level, first_level); @@ -2674,7 +2677,9 @@ lp_build_sample_common(struct lp_build_sample_context *bld, unreachable("Bad mip_filter value in lp_build_sample_soa()"); case PIPE_TEX_MIPFILTER_NONE: /* always use mip level 0 */ - first_level = bld->dynamic_state->first_level(bld->gallivm, bld->context_ptr, + first_level = bld->dynamic_state->first_level(bld->gallivm, + bld->context_type, + bld->context_ptr, texture_index, NULL); first_level = lp_build_broadcast_scalar(&bld->leveli_bld, first_level); *ilevel0 = first_level; @@ -2702,6 +2707,7 @@ lp_build_clamp_border_color(struct lp_build_sample_context *bld, LLVMBuilderRef builder = gallivm->builder; LLVMValueRef border_color_ptr = bld->dynamic_state->border_color(gallivm, + bld->context_type, bld->context_ptr, sampler_unit); LLVMValueRef border_color; const struct util_format_description *format_desc = bld->format_desc; @@ -3128,6 +3134,7 @@ lp_build_fetch_texel(struct lp_build_sample_context *bld, assert(bld->num_mips == 1); if (bld->static_texture_state->target != PIPE_BUFFER) { ilevel = bld->dynamic_state->first_level(bld->gallivm, + bld->context_type, bld->context_ptr, texture_unit, NULL); } else { @@ -3197,6 +3204,7 @@ lp_build_fetch_texel(struct lp_build_sample_context *bld, if (bld->fetch_ms) { LLVMValueRef num_samples; num_samples = bld->dynamic_state->num_samples(bld->gallivm, + bld->context_type, bld->context_ptr, texture_unit, NULL); out1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, ms_index, int_coord_bld->zero); out_of_bounds = lp_build_or(int_coord_bld, out_of_bounds, out1); @@ -3295,7 +3303,9 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, unsigned sample_key, unsigned texture_index, unsigned sampler_index, + LLVMTypeRef context_type, LLVMValueRef context_ptr, + LLVMTypeRef thread_data_type, LLVMValueRef thread_data_ptr, const LLVMValueRef *coords, const LLVMValueRef *offsets, @@ -3376,6 +3386,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, /* Setup our build context */ memset(&bld, 0, sizeof bld); bld.gallivm = gallivm; + bld.context_type = context_type; bld.context_ptr = context_ptr; bld.aniso_filter_table = aniso_filter_table; bld.static_sampler_state = &derived_sampler_state; @@ -3559,22 +3570,23 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, lp_build_context_init(&bld.lodi_bld, gallivm, bld.lodi_type); /* Get the dynamic state */ - LLVMValueRef tex_width = dynamic_state->width(gallivm, + LLVMValueRef tex_width = dynamic_state->width(gallivm, context_type, context_ptr, texture_index, NULL); - bld.row_stride_array = dynamic_state->row_stride(gallivm, + bld.row_stride_array = dynamic_state->row_stride(gallivm, context_type, context_ptr, texture_index, NULL); - bld.img_stride_array = dynamic_state->img_stride(gallivm, + bld.img_stride_array = dynamic_state->img_stride(gallivm, context_type, context_ptr, texture_index, NULL); - bld.base_ptr = dynamic_state->base_ptr(gallivm, + bld.base_ptr = dynamic_state->base_ptr(gallivm, context_type, context_ptr, texture_index, NULL); - bld.mip_offsets = dynamic_state->mip_offsets(gallivm, + bld.mip_offsets = dynamic_state->mip_offsets(gallivm, context_type, context_ptr, texture_index, NULL); if (fetch_ms) { bld.sample_stride = lp_build_broadcast_scalar(&bld.int_coord_bld, dynamic_state->sample_stride(gallivm, + context_type, context_ptr, texture_index, NULL)); @@ -3583,7 +3595,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, /* Note that mip_offsets is an array[level] of offsets to texture images */ if (dynamic_state->cache_ptr && thread_data_ptr) { - bld.cache = dynamic_state->cache_ptr(gallivm, + bld.cache = dynamic_state->cache_ptr(gallivm, thread_data_type, thread_data_ptr, texture_index); } @@ -3620,7 +3632,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, LLVMConstInt(i32t, 0, 0), ""); if (dims >= 2) { LLVMValueRef tex_height = - dynamic_state->height(gallivm, + dynamic_state->height(gallivm, context_type, context_ptr, texture_index, NULL); bld.int_size = LLVMBuildInsertElement(builder, bld.int_size, tex_height, @@ -3636,7 +3648,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, LLVMConstInt(i32t, 1, 0), ""); if (dims >= 3) { LLVMValueRef tex_depth = - dynamic_state->depth(gallivm, context_ptr, + dynamic_state->depth(gallivm, context_type, context_ptr, texture_index, NULL); bld.int_size = LLVMBuildInsertElement(builder, bld.int_size, tex_depth, @@ -3800,6 +3812,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, bld4.no_rho_approx = bld.no_rho_approx; bld4.no_brilinear = bld.no_brilinear; bld4.gallivm = bld.gallivm; + bld4.context_type = bld.context_type; bld4.context_ptr = bld.context_ptr; bld4.aniso_filter_table = aniso_filter_table; bld4.static_texture_state = bld.static_texture_state; @@ -4001,6 +4014,8 @@ lp_build_sample_gen_func(struct gallivm_state *gallivm, const struct lp_static_sampler_state *static_sampler_state, struct lp_sampler_dynamic_state *dynamic_state, struct lp_type type, + LLVMTypeRef context_type, + LLVMTypeRef thread_data_type, unsigned texture_index, unsigned sampler_index, LLVMValueRef function, @@ -4106,7 +4121,9 @@ lp_build_sample_gen_func(struct gallivm_state *gallivm, sample_key, texture_index, sampler_index, + context_type, context_ptr, + thread_data_type, thread_data_ptr, coords, offsets, @@ -4254,6 +4271,8 @@ lp_build_sample_soa_func(struct gallivm_state *gallivm, static_sampler_state, dynamic_state, params->type, + params->context_type, + params->thread_data_type, texture_index, sampler_index, function, @@ -4376,7 +4395,9 @@ lp_build_sample_soa(const struct lp_static_texture_state *static_texture_state, params->sample_key, params->texture_index, params->sampler_index, + params->context_type, params->context_ptr, + params->thread_data_type, params->thread_data_ptr, params->coords, params->offsets, @@ -4397,6 +4418,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, { LLVMValueRef first_level = NULL; const unsigned num_lods = 1; + LLVMTypeRef context_type = params->context_type; LLVMValueRef context_ptr = params->context_ptr; const unsigned texture_unit = params->texture_unit; const enum pipe_texture_target target = params->target; @@ -4459,6 +4481,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, params->int_type), dynamic_state->num_samples(gallivm, + context_type, context_ptr, texture_unit, texture_unit_offset)); @@ -4471,7 +4494,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, /* FIXME: this needs to honor per-element lod */ lod = LLVMBuildExtractElement(gallivm->builder, params->explicit_lod, lp_build_const_int32(gallivm, 0), ""); - first_level = dynamic_state->first_level(gallivm, + first_level = dynamic_state->first_level(gallivm, context_type, context_ptr, texture_unit, texture_unit_offset); level = LLVMBuildAdd(gallivm->builder, lod, first_level, "level"); @@ -4497,6 +4520,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, res_bh = bh = 1; size = LLVMBuildInsertElement(gallivm->builder, size, dynamic_state->width(gallivm, + context_type, context_ptr, texture_unit, texture_unit_offset), @@ -4512,7 +4536,9 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, lp_build_const_int32(gallivm, 0), ""); if (dims >= 2) { size = LLVMBuildInsertElement(gallivm->builder, size, - dynamic_state->height(gallivm, context_ptr, + dynamic_state->height(gallivm, + context_type, + context_ptr, texture_unit, texture_unit_offset), lp_build_const_int32(gallivm, 1), ""); @@ -4530,6 +4556,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, if (dims >= 3) { size = LLVMBuildInsertElement(gallivm->builder, size, dynamic_state->depth(gallivm, + context_type, context_ptr, texture_unit, texture_unit_offset), @@ -4550,7 +4577,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, tex_blocksize_log2, view_blocksize); if (has_array) { - LLVMValueRef layers = dynamic_state->depth(gallivm, + LLVMValueRef layers = dynamic_state->depth(gallivm, context_type, context_ptr, texture_unit, texture_unit_offset); if (target == PIPE_TEXTURE_CUBE_ARRAY) { @@ -4577,7 +4604,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, /* everything is scalar for now */ lp_build_context_init(&leveli_bld, gallivm, lp_type_int_vec(32, 32)); - last_level = dynamic_state->last_level(gallivm, + last_level = dynamic_state->last_level(gallivm, context_type, context_ptr, texture_unit, texture_unit_offset); @@ -4624,7 +4651,7 @@ lp_build_size_query_soa(struct gallivm_state *gallivm, else { LLVMValueRef last_level; - last_level = dynamic_state->last_level(gallivm, + last_level = dynamic_state->last_level(gallivm, context_type, context_ptr, texture_unit, texture_unit_offset); num_levels = lp_build_sub(&bld_int_scalar, last_level, first_level); @@ -4784,31 +4811,39 @@ lp_build_img_op_soa(const struct lp_static_texture_state *static_texture_state, } LLVMValueRef row_stride = dynamic_state->row_stride(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); LLVMValueRef img_stride = dynamic_state->img_stride(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); LLVMValueRef base_ptr = dynamic_state->base_ptr(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); LLVMValueRef width = dynamic_state->width(gallivm, - params->context_ptr, + params->context_type, + params->context_ptr, params->image_index, NULL); LLVMValueRef height = dynamic_state->height(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); LLVMValueRef depth = dynamic_state->depth(gallivm, - params->context_ptr, + params->context_type, + params->context_ptr, params->image_index, NULL); LLVMValueRef num_samples = NULL, sample_stride = NULL; LLVMValueRef ms_index = params->ms_index; if (ms_index) { num_samples = dynamic_state->num_samples(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); sample_stride = dynamic_state->sample_stride(gallivm, + params->context_type, params->context_ptr, params->image_index, NULL); } diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h b/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h index 31067e0165491..d335a92388fe4 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h @@ -267,7 +267,9 @@ struct lp_build_tgsi_params { LLVMValueRef const_sizes_ptr; const struct lp_bld_tgsi_system_values *system_values; const LLVMValueRef (*inputs)[4]; + LLVMTypeRef context_type; LLVMValueRef context_ptr; + LLVMTypeRef thread_data_type; LLVMValueRef thread_data_ptr; const struct lp_build_sampler_soa *sampler; const struct tgsi_shader_info *info; @@ -521,7 +523,9 @@ struct lp_build_tgsi_soa_context LLVMValueRef consts_sizes[LP_MAX_TGSI_CONST_BUFFERS]; const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS]; LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS]; + LLVMTypeRef context_type; LLVMValueRef context_ptr; + LLVMTypeRef thread_data_type; LLVMValueRef thread_data_ptr; LLVMValueRef ssbo_ptr; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c index f33de194484a0..d98d20e11e5d3 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c @@ -2273,7 +2273,9 @@ emit_tex( struct lp_build_tgsi_soa_context *bld, params.sample_key = sample_key; params.texture_index = unit; params.sampler_index = unit; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.coords = coords; params.offsets = offsets; @@ -2442,7 +2444,9 @@ emit_sample(struct lp_build_tgsi_soa_context *bld, params.sample_key = sample_key; params.texture_index = texture_unit; params.sampler_index = sampler_unit; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.coords = coords; params.offsets = offsets; @@ -2580,7 +2584,9 @@ emit_fetch_texels( struct lp_build_tgsi_soa_context *bld, * can exceed this. */ params.sampler_index = 0; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.coords = coords; params.offsets = offsets; @@ -2665,6 +2671,7 @@ emit_size_query( struct lp_build_tgsi_soa_context *bld, params.texture_unit = unit; params.texture_unit_offset = NULL; params.target = pipe_target; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; params.is_sviewinfo = TRUE; params.lod_property = lod_property; @@ -3453,7 +3460,9 @@ img_load_emit( memset(¶ms, 0, sizeof(params)); params.type = bld->bld_base.base.type; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.coords = coords; params.outdata = emit_data->output; @@ -3601,7 +3610,9 @@ img_store_emit( memset(¶ms, 0, sizeof(params)); params.type = bld->bld_base.base.type; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.coords = coords; params.outdata = NULL; @@ -3710,6 +3721,7 @@ resq_emit( params.int_type = bld->bld_base.int_bld.type; params.texture_unit = buf; params.target = tgsi_to_pipe_tex_target(target); + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; params.sizes_out = emit_data->output; @@ -3751,7 +3763,9 @@ img_atomic_emit( memset(¶ms, 0, sizeof(params)); params.type = bld->bld_base.base.type; + params.context_type = bld->context_type; params.context_ptr = bld->context_ptr; + params.thread_data_type = bld->thread_data_type; params.thread_data_ptr = bld->thread_data_ptr; params.exec_mask = mask_vec(bld_base); params.image_index = emit_data->inst->Src[0].Register.Index; @@ -4483,7 +4497,9 @@ lp_build_tgsi_soa(struct gallivm_state *gallivm, bld.sampler = params->sampler; bld.bld_base.info = params->info; bld.indirect_files = params->info->indirect_files; + bld.context_type = params->context_type; bld.context_ptr = params->context_ptr; + bld.thread_data_type = params->thread_data_type; bld.thread_data_ptr = params->thread_data_ptr; bld.image = params->image; bld.shared_ptr = params->shared_ptr; diff --git a/src/gallium/drivers/llvmpipe/lp_state_cs.c b/src/gallium/drivers/llvmpipe/lp_state_cs.c index 86f7b65585ae5..22ac92e1fb7da 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_cs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_cs.c @@ -447,6 +447,7 @@ generate_compute(struct llvmpipe_context *lp, params.mask = &mask; params.consts_ptr = consts_ptr; params.system_values = &system_values; + params.context_type = variant->jit_cs_context_type; params.context_ptr = context_ptr; params.sampler = sampler; params.info = &shader->info.base; diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index d1dbd9d787dc1..e10e10836faa3 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -1052,7 +1052,9 @@ generate_fs_loop(struct gallivm_state *gallivm, params.consts_ptr = consts_ptr; params.system_values = &system_values; params.inputs = interp->inputs; + params.context_type = context_type; params.context_ptr = context_ptr; + params.thread_data_type = thread_data_type; params.thread_data_ptr = thread_data_ptr; params.sampler = sampler; params.info = &shader->info.base; diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample.c b/src/gallium/drivers/llvmpipe/lp_tex_sample.c index 0812bc72cd098..8700eda253332 100644 --- a/src/gallium/drivers/llvmpipe/lp_tex_sample.c +++ b/src/gallium/drivers/llvmpipe/lp_tex_sample.c @@ -110,6 +110,7 @@ struct lp_llvm_image_soa */ static LLVMValueRef lp_llvm_texture_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned texture_unit, LLVMValueRef texture_unit_offset, @@ -144,7 +145,7 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, indices[3] = lp_build_const_int32(gallivm, member_index); LLVMValueRef ptr = - LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; @@ -166,11 +167,12 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, #define LP_LLVM_TEXTURE_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ lp_llvm_texture_##_name(struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned texture_unit, \ LLVMValueRef texture_unit_offset) \ { \ - return lp_llvm_texture_member(gallivm, context_ptr, \ + return lp_llvm_texture_member(gallivm, context_type, context_ptr, \ texture_unit, texture_unit_offset, \ _index, #_name, _emit_load ); \ } @@ -199,6 +201,7 @@ LP_LLVM_TEXTURE_MEMBER(sample_stride, LP_JIT_TEXTURE_SAMPLE_STRIDE, TRUE) */ static LLVMValueRef lp_llvm_sampler_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned sampler_unit, unsigned member_index, @@ -220,7 +223,7 @@ lp_llvm_sampler_member(struct gallivm_state *gallivm, indices[3] = lp_build_const_int32(gallivm, member_index); LLVMValueRef ptr = - LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; @@ -233,10 +236,11 @@ lp_llvm_sampler_member(struct gallivm_state *gallivm, #define LP_LLVM_SAMPLER_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ lp_llvm_sampler_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned sampler_unit) \ { \ - return lp_llvm_sampler_member(gallivm, context_ptr, \ + return lp_llvm_sampler_member(gallivm, context_type, context_ptr, \ sampler_unit, _index, #_name, _emit_load ); \ } @@ -258,6 +262,7 @@ LP_LLVM_SAMPLER_MEMBER(max_aniso, LP_JIT_SAMPLER_MAX_ANISO, TRUE) */ static LLVMValueRef lp_llvm_image_member(struct gallivm_state *gallivm, + LLVMTypeRef context_type, LLVMValueRef context_ptr, unsigned image_unit, LLVMValueRef image_unit_offset, @@ -285,7 +290,7 @@ lp_llvm_image_member(struct gallivm_state *gallivm, indices[3] = lp_build_const_int32(gallivm, member_index); LLVMValueRef ptr = - LLVMBuildGEP(builder, context_ptr, indices, ARRAY_SIZE(indices), ""); + LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; @@ -307,10 +312,11 @@ lp_llvm_image_member(struct gallivm_state *gallivm, #define LP_LLVM_IMAGE_MEMBER(_name, _index, _emit_load) \ static LLVMValueRef \ lp_llvm_image_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ LLVMValueRef context_ptr, \ unsigned image_unit, LLVMValueRef image_unit_offset) \ { \ - return lp_llvm_image_member(gallivm, context_ptr, \ + return lp_llvm_image_member(gallivm, context_type, context_ptr, \ image_unit, image_unit_offset, \ _index, #_name, _emit_load ); \ } @@ -329,13 +335,14 @@ LP_LLVM_IMAGE_MEMBER(sample_stride, LP_JIT_IMAGE_SAMPLE_STRIDE, TRUE) #if LP_USE_TEXTURE_CACHE static LLVMValueRef lp_llvm_texture_cache_ptr(struct gallivm_state *gallivm, + LLVMTypeRef thread_data_type, LLVMValueRef thread_data_ptr, unsigned unit) { /* We use the same cache for all units */ (void)unit; - return lp_jit_thread_data_cache(gallivm, LLVMGetElementType(LLVMTypeOf(thread_data_ptr)), thread_data_ptr); + return lp_jit_thread_data_cache(gallivm, thread_data_type, thread_data_ptr); } #endif -- GitLab From 02c675b1960a11f02b91018c519d9da6b371615b Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 14:41:20 +1000 Subject: [PATCH 3/6] draw/llvmpipe: move texture/sampler/image member load to opaque. This removes the non-opaque paths from the draw/lp sampling code. Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/draw/draw_llvm_sample.c | 24 ++++++++++++------- src/gallium/drivers/llvmpipe/lp_tex_sample.c | 24 ++++++++++++++++--- 2 files changed, 36 insertions(+), 12 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm_sample.c b/src/gallium/auxiliary/draw/draw_llvm_sample.c index 5a48fb17caf2b..cde003afcebe6 100644 --- a/src/gallium/auxiliary/draw/draw_llvm_sample.c +++ b/src/gallium/auxiliary/draw/draw_llvm_sample.c @@ -131,9 +131,11 @@ draw_llvm_texture_member(struct gallivm_state *gallivm, ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - if (emit_load) - res = LLVMBuildLoad(builder, ptr, ""); - else + if (emit_load) { + LLVMTypeRef tex_type = LLVMStructGetTypeAtIndex(context_type, DRAW_JIT_CTX_TEXTURES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(tex_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else res = ptr; lp_build_name(res, "context.texture%u.%s", texture_unit, member_name); @@ -177,9 +179,11 @@ draw_llvm_sampler_member(struct gallivm_state *gallivm, ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - if (emit_load) - res = LLVMBuildLoad(builder, ptr, ""); - else + if (emit_load) { + LLVMTypeRef samp_type = LLVMStructGetTypeAtIndex(context_type, DRAW_JIT_CTX_SAMPLERS); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(samp_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else res = ptr; lp_build_name(res, "context.sampler%u.%s", sampler_unit, member_name); @@ -228,9 +232,11 @@ draw_llvm_image_member(struct gallivm_state *gallivm, ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - if (emit_load) - res = LLVMBuildLoad(builder, ptr, ""); - else + if (emit_load) { + LLVMTypeRef img_type = LLVMStructGetTypeAtIndex(context_type, DRAW_JIT_CTX_IMAGES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(img_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else res = ptr; lp_build_name(res, "context.image%u.%s", image_unit, member_name); diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample.c b/src/gallium/drivers/llvmpipe/lp_tex_sample.c index 8700eda253332..e62ec9f6d8915 100644 --- a/src/gallium/drivers/llvmpipe/lp_tex_sample.c +++ b/src/gallium/drivers/llvmpipe/lp_tex_sample.c @@ -147,7 +147,13 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, LLVMValueRef ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; + LLVMValueRef res; + if (emit_load) { + LLVMTypeRef tex_type = LLVMStructGetTypeAtIndex(context_type, LP_JIT_CTX_TEXTURES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(tex_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else + res = ptr; lp_build_name(res, "context.texture%u.%s", texture_unit, member_name); @@ -225,7 +231,13 @@ lp_llvm_sampler_member(struct gallivm_state *gallivm, LLVMValueRef ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; + LLVMValueRef res; + if (emit_load) { + LLVMTypeRef samp_type = LLVMStructGetTypeAtIndex(context_type, LP_JIT_CTX_SAMPLERS); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(samp_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else + res = ptr; lp_build_name(res, "context.sampler%u.%s", sampler_unit, member_name); @@ -292,7 +304,13 @@ lp_llvm_image_member(struct gallivm_state *gallivm, LLVMValueRef ptr = LLVMBuildGEP2(builder, context_type, context_ptr, indices, ARRAY_SIZE(indices), ""); - LLVMValueRef res = emit_load ? LLVMBuildLoad(builder, ptr, "") : ptr; + LLVMValueRef res; + if (emit_load) { + LLVMTypeRef img_type = LLVMStructGetTypeAtIndex(context_type, LP_JIT_CTX_IMAGES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(img_type), member_index); + res = LLVMBuildLoad2(builder, res_type, ptr, ""); + } else + res = ptr; lp_build_name(res, "context.image%u.%s", image_unit, member_name); -- GitLab From 1a9889ae12757e9bdc019cbd109783a3e93121b7 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 14:59:54 +1000 Subject: [PATCH 4/6] draw/llvmpipe: add way to return pointer types to generic code. Some of the generic code tries to load from things it has no types for, mip offsets, row and image strides. Fix the interfaces to allow returning types for these. Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/draw/draw_llvm_sample.c | 49 ++++++++++++++++--- src/gallium/auxiliary/gallivm/lp_bld_sample.h | 12 +++-- .../auxiliary/gallivm/lp_bld_sample_soa.c | 16 ++++-- src/gallium/drivers/llvmpipe/lp_tex_sample.c | 49 ++++++++++++++++--- 4 files changed, 104 insertions(+), 22 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_llvm_sample.c b/src/gallium/auxiliary/draw/draw_llvm_sample.c index cde003afcebe6..19e9937d57ac6 100644 --- a/src/gallium/auxiliary/draw/draw_llvm_sample.c +++ b/src/gallium/auxiliary/draw/draw_llvm_sample.c @@ -106,7 +106,8 @@ draw_llvm_texture_member(struct gallivm_state *gallivm, LLVMValueRef texture_unit_offset, unsigned member_index, const char *member_name, - boolean emit_load) + boolean emit_load, + LLVMTypeRef *out_type) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef indices[4]; @@ -138,6 +139,12 @@ draw_llvm_texture_member(struct gallivm_state *gallivm, } else res = ptr; + if (out_type) { + LLVMTypeRef tex_type = LLVMStructGetTypeAtIndex(context_type, DRAW_JIT_CTX_TEXTURES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(tex_type), member_index); + *out_type = res_type; + } + lp_build_name(res, "context.texture%u.%s", texture_unit, member_name); return res; @@ -263,7 +270,21 @@ draw_llvm_image_member(struct gallivm_state *gallivm, { \ return draw_llvm_texture_member(gallivm, context_type, context_ptr, \ texture_unit, texture_unit_offset, \ - _index, #_name, _emit_load ); \ + _index, #_name, _emit_load, NULL ); \ + } + +#define DRAW_LLVM_TEXTURE_MEMBER_OUTTYPE(_name, _index, _emit_load) \ + static LLVMValueRef \ + draw_llvm_texture_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ + LLVMValueRef context_ptr, \ + unsigned texture_unit, \ + LLVMValueRef texture_unit_offset, \ + LLVMTypeRef *out_type) \ + { \ + return draw_llvm_texture_member(gallivm, context_type, context_ptr, \ + texture_unit, texture_unit_offset, \ + _index, #_name, _emit_load, out_type); \ } @@ -273,9 +294,9 @@ DRAW_LLVM_TEXTURE_MEMBER(depth, DRAW_JIT_TEXTURE_DEPTH, TRUE) DRAW_LLVM_TEXTURE_MEMBER(first_level,DRAW_JIT_TEXTURE_FIRST_LEVEL, TRUE) DRAW_LLVM_TEXTURE_MEMBER(last_level, DRAW_JIT_TEXTURE_LAST_LEVEL, TRUE) DRAW_LLVM_TEXTURE_MEMBER(base_ptr, DRAW_JIT_TEXTURE_BASE, TRUE) -DRAW_LLVM_TEXTURE_MEMBER(row_stride, DRAW_JIT_TEXTURE_ROW_STRIDE, FALSE) -DRAW_LLVM_TEXTURE_MEMBER(img_stride, DRAW_JIT_TEXTURE_IMG_STRIDE, FALSE) -DRAW_LLVM_TEXTURE_MEMBER(mip_offsets, DRAW_JIT_TEXTURE_MIP_OFFSETS, FALSE) +DRAW_LLVM_TEXTURE_MEMBER_OUTTYPE(row_stride, DRAW_JIT_TEXTURE_ROW_STRIDE, FALSE) +DRAW_LLVM_TEXTURE_MEMBER_OUTTYPE(img_stride, DRAW_JIT_TEXTURE_IMG_STRIDE, FALSE) +DRAW_LLVM_TEXTURE_MEMBER_OUTTYPE(mip_offsets, DRAW_JIT_TEXTURE_MIP_OFFSETS, FALSE) DRAW_LLVM_TEXTURE_MEMBER(num_samples, DRAW_JIT_TEXTURE_NUM_SAMPLES, TRUE) DRAW_LLVM_TEXTURE_MEMBER(sample_stride, DRAW_JIT_TEXTURE_SAMPLE_STRIDE, TRUE) @@ -309,13 +330,27 @@ DRAW_LLVM_SAMPLER_MEMBER(max_aniso, DRAW_JIT_SAMPLER_MAX_ANISO, TRUE) _index, #_name, _emit_load ); \ } +#define DRAW_LLVM_IMAGE_MEMBER_OUTTYPE(_name, _index, _emit_load) \ + static LLVMValueRef \ + draw_llvm_image_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ + LLVMValueRef context_ptr, \ + unsigned image_unit, LLVMValueRef image_unit_offset, \ + LLVMTypeRef *out_type) \ + { \ + assert(!out_type); \ + return draw_llvm_image_member(gallivm, context_type, context_ptr, \ + image_unit, image_unit_offset, \ + _index, #_name, _emit_load); \ + } + DRAW_LLVM_IMAGE_MEMBER(width, DRAW_JIT_IMAGE_WIDTH, TRUE) DRAW_LLVM_IMAGE_MEMBER(height, DRAW_JIT_IMAGE_HEIGHT, TRUE) DRAW_LLVM_IMAGE_MEMBER(depth, DRAW_JIT_IMAGE_DEPTH, TRUE) DRAW_LLVM_IMAGE_MEMBER(base_ptr, DRAW_JIT_IMAGE_BASE, TRUE) -DRAW_LLVM_IMAGE_MEMBER(row_stride, DRAW_JIT_IMAGE_ROW_STRIDE, TRUE) -DRAW_LLVM_IMAGE_MEMBER(img_stride, DRAW_JIT_IMAGE_IMG_STRIDE, TRUE) +DRAW_LLVM_IMAGE_MEMBER_OUTTYPE(row_stride, DRAW_JIT_IMAGE_ROW_STRIDE, TRUE) +DRAW_LLVM_IMAGE_MEMBER_OUTTYPE(img_stride, DRAW_JIT_IMAGE_IMG_STRIDE, TRUE) DRAW_LLVM_IMAGE_MEMBER(num_samples, DRAW_JIT_IMAGE_NUM_SAMPLES, TRUE) DRAW_LLVM_IMAGE_MEMBER(sample_stride, DRAW_JIT_IMAGE_SAMPLE_STRIDE, TRUE) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.h b/src/gallium/auxiliary/gallivm/lp_bld_sample.h index ecebc8fc631fe..caf0ab0907d80 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.h @@ -272,14 +272,16 @@ struct lp_sampler_dynamic_state (*row_stride)(struct gallivm_state *gallivm, LLVMTypeRef context_type, LLVMValueRef context_ptr, - unsigned texture_unit, LLVMValueRef texture_unit_offset); + unsigned texture_unit, LLVMValueRef texture_unit_offset, + LLVMTypeRef *out_type); /** Obtain stride in bytes between image slices (returns int32) */ LLVMValueRef (*img_stride)(struct gallivm_state *gallivm, LLVMTypeRef context_type, LLVMValueRef context_ptr, - unsigned texture_unit, LLVMValueRef texture_unit_offset); + unsigned texture_unit, LLVMValueRef texture_unit_offset,\ + LLVMTypeRef *out_type); /** Obtain pointer to base of texture */ LLVMValueRef @@ -293,7 +295,8 @@ struct lp_sampler_dynamic_state (*mip_offsets)(struct gallivm_state *gallivm, LLVMTypeRef context_type, LLVMValueRef context_ptr, - unsigned texture_unit, LLVMValueRef texture_unit_offset); + unsigned texture_unit, LLVMValueRef texture_unit_offset, + LLVMTypeRef *out_type); /** Obtain number of samples (returns int32) */ LLVMValueRef @@ -447,9 +450,12 @@ struct lp_build_sample_context struct lp_build_context lodi_bld; /* Common dynamic state values */ + LLVMTypeRef row_stride_type; LLVMValueRef row_stride_array; + LLVMTypeRef img_stride_type; LLVMValueRef img_stride_array; LLVMValueRef base_ptr; + LLVMTypeRef mip_offsets_type; LLVMValueRef mip_offsets; LLVMValueRef cache; LLVMValueRef sample_stride; diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c index c24833dafe123..2e90d09ae617f 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c @@ -3574,13 +3574,16 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, context_ptr, texture_index, NULL); bld.row_stride_array = dynamic_state->row_stride(gallivm, context_type, - context_ptr, texture_index, NULL); + context_ptr, texture_index, NULL, + &bld.row_stride_type); bld.img_stride_array = dynamic_state->img_stride(gallivm, context_type, - context_ptr, texture_index, NULL); + context_ptr, texture_index, NULL, + &bld.img_stride_type); bld.base_ptr = dynamic_state->base_ptr(gallivm, context_type, context_ptr, texture_index, NULL); bld.mip_offsets = dynamic_state->mip_offsets(gallivm, context_type, - context_ptr, texture_index, NULL); + context_ptr, texture_index, NULL, + &bld.mip_offsets_type); if (fetch_ms) { bld.sample_stride = @@ -3820,9 +3823,12 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, bld4.dynamic_state = bld.dynamic_state; bld4.format_desc = bld.format_desc; bld4.dims = bld.dims; + bld4.row_stride_type = bld.row_stride_type; bld4.row_stride_array = bld.row_stride_array; + bld4.img_stride_type = bld.img_stride_type; bld4.img_stride_array = bld.img_stride_array; bld4.base_ptr = bld.base_ptr; + bld4.mip_offsets_type = bld.mip_offsets_type; bld4.mip_offsets = bld.mip_offsets; bld4.int_size = bld.int_size; bld4.int_tex_blocksize = bld.int_tex_blocksize; @@ -4813,11 +4819,11 @@ lp_build_img_op_soa(const struct lp_static_texture_state *static_texture_state, LLVMValueRef row_stride = dynamic_state->row_stride(gallivm, params->context_type, params->context_ptr, - params->image_index, NULL); + params->image_index, NULL, NULL); LLVMValueRef img_stride = dynamic_state->img_stride(gallivm, params->context_type, params->context_ptr, - params->image_index, NULL); + params->image_index, NULL, NULL); LLVMValueRef base_ptr = dynamic_state->base_ptr(gallivm, params->context_type, params->context_ptr, diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample.c b/src/gallium/drivers/llvmpipe/lp_tex_sample.c index e62ec9f6d8915..ddaea90aecda2 100644 --- a/src/gallium/drivers/llvmpipe/lp_tex_sample.c +++ b/src/gallium/drivers/llvmpipe/lp_tex_sample.c @@ -116,7 +116,8 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, LLVMValueRef texture_unit_offset, unsigned member_index, const char *member_name, - boolean emit_load) + boolean emit_load, + LLVMTypeRef *out_type) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef indices[4]; @@ -155,6 +156,12 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, } else res = ptr; + if (out_type) { + LLVMTypeRef tex_type = LLVMStructGetTypeAtIndex(context_type, LP_JIT_CTX_TEXTURES); + LLVMTypeRef res_type = LLVMStructGetTypeAtIndex(LLVMGetElementType(tex_type), member_index); + *out_type = res_type; + } + lp_build_name(res, "context.texture%u.%s", texture_unit, member_name); return res; @@ -180,7 +187,21 @@ lp_llvm_texture_member(struct gallivm_state *gallivm, { \ return lp_llvm_texture_member(gallivm, context_type, context_ptr, \ texture_unit, texture_unit_offset, \ - _index, #_name, _emit_load ); \ + _index, #_name, _emit_load, NULL ); \ + } + +#define LP_LLVM_TEXTURE_MEMBER_OUTTYPE(_name, _index, _emit_load) \ + static LLVMValueRef \ + lp_llvm_texture_##_name(struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ + LLVMValueRef context_ptr, \ + unsigned texture_unit, \ + LLVMValueRef texture_unit_offset, \ + LLVMTypeRef *out_type) \ + { \ + return lp_llvm_texture_member(gallivm, context_type, context_ptr, \ + texture_unit, texture_unit_offset, \ + _index, #_name, _emit_load, out_type ); \ } @@ -190,9 +211,9 @@ LP_LLVM_TEXTURE_MEMBER(depth, LP_JIT_TEXTURE_DEPTH, TRUE) LP_LLVM_TEXTURE_MEMBER(first_level, LP_JIT_TEXTURE_FIRST_LEVEL, TRUE) LP_LLVM_TEXTURE_MEMBER(last_level, LP_JIT_TEXTURE_LAST_LEVEL, TRUE) LP_LLVM_TEXTURE_MEMBER(base_ptr, LP_JIT_TEXTURE_BASE, TRUE) -LP_LLVM_TEXTURE_MEMBER(row_stride, LP_JIT_TEXTURE_ROW_STRIDE, FALSE) -LP_LLVM_TEXTURE_MEMBER(img_stride, LP_JIT_TEXTURE_IMG_STRIDE, FALSE) -LP_LLVM_TEXTURE_MEMBER(mip_offsets, LP_JIT_TEXTURE_MIP_OFFSETS, FALSE) +LP_LLVM_TEXTURE_MEMBER_OUTTYPE(row_stride, LP_JIT_TEXTURE_ROW_STRIDE, FALSE) +LP_LLVM_TEXTURE_MEMBER_OUTTYPE(img_stride, LP_JIT_TEXTURE_IMG_STRIDE, FALSE) +LP_LLVM_TEXTURE_MEMBER_OUTTYPE(mip_offsets, LP_JIT_TEXTURE_MIP_OFFSETS, FALSE) LP_LLVM_TEXTURE_MEMBER(num_samples, LP_JIT_TEXTURE_NUM_SAMPLES, TRUE) LP_LLVM_TEXTURE_MEMBER(sample_stride, LP_JIT_TEXTURE_SAMPLE_STRIDE, TRUE) @@ -339,13 +360,27 @@ lp_llvm_image_member(struct gallivm_state *gallivm, _index, #_name, _emit_load ); \ } +#define LP_LLVM_IMAGE_MEMBER_OUTTYPE(_name, _index, _emit_load) \ + static LLVMValueRef \ + lp_llvm_image_##_name( struct gallivm_state *gallivm, \ + LLVMTypeRef context_type, \ + LLVMValueRef context_ptr, \ + unsigned image_unit, LLVMValueRef image_unit_offset, \ + LLVMTypeRef *out_type) \ + { \ + assert(!out_type); \ + return lp_llvm_image_member(gallivm, context_type, context_ptr, \ + image_unit, image_unit_offset, \ + _index, #_name, _emit_load ); \ + } + LP_LLVM_IMAGE_MEMBER(width, LP_JIT_IMAGE_WIDTH, TRUE) LP_LLVM_IMAGE_MEMBER(height, LP_JIT_IMAGE_HEIGHT, TRUE) LP_LLVM_IMAGE_MEMBER(depth, LP_JIT_IMAGE_DEPTH, TRUE) LP_LLVM_IMAGE_MEMBER(base_ptr, LP_JIT_IMAGE_BASE, TRUE) -LP_LLVM_IMAGE_MEMBER(row_stride, LP_JIT_IMAGE_ROW_STRIDE, TRUE) -LP_LLVM_IMAGE_MEMBER(img_stride, LP_JIT_IMAGE_IMG_STRIDE, TRUE) +LP_LLVM_IMAGE_MEMBER_OUTTYPE(row_stride, LP_JIT_IMAGE_ROW_STRIDE, TRUE) +LP_LLVM_IMAGE_MEMBER_OUTTYPE(img_stride, LP_JIT_IMAGE_IMG_STRIDE, TRUE) LP_LLVM_IMAGE_MEMBER(num_samples, LP_JIT_IMAGE_NUM_SAMPLES, TRUE) LP_LLVM_IMAGE_MEMBER(sample_stride, LP_JIT_IMAGE_SAMPLE_STRIDE, TRUE) -- GitLab From 0c865245900615e57f103b5e3f8759a68e978f85 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 26 Sep 2022 15:02:38 +1000 Subject: [PATCH 5/6] gallivm/sample: use retrieved types to do opaque pointer loads. This uses the types to do the loads using opaque ptr interfaces. Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_sample.c | 26 ++++++++++++------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index cdbf737031a8c..9e608303451d6 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -1147,10 +1147,11 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld, * A helper function that factorizes this common pattern. */ static LLVMValueRef -load_mip(struct gallivm_state *gallivm, LLVMValueRef offsets, LLVMValueRef index1) { +load_mip(struct gallivm_state *gallivm, + LLVMTypeRef ptr_type, LLVMValueRef offsets, LLVMValueRef index1) { LLVMValueRef zero = lp_build_const_int32(gallivm, 0); LLVMValueRef indexes[2] = {zero, index1}; - LLVMValueRef ptr = LLVMBuildGEP(gallivm->builder, offsets, indexes, ARRAY_SIZE(indexes), ""); + LLVMValueRef ptr = LLVMBuildGEP2(gallivm->builder, ptr_type, offsets, indexes, ARRAY_SIZE(indexes), ""); return LLVMBuildLoad2(gallivm->builder, LLVMInt32TypeInContext(gallivm->context), ptr, ""); } @@ -1162,9 +1163,11 @@ LLVMValueRef lp_build_get_mipmap_level(struct lp_build_sample_context *bld, LLVMValueRef level) { - LLVMValueRef mip_offset = load_mip(bld->gallivm, bld->mip_offsets, level); + LLVMValueRef mip_offset = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, level); LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef data_ptr = LLVMBuildGEP(builder, bld->base_ptr, &mip_offset, 1, ""); + LLVMValueRef data_ptr = LLVMBuildGEP2(builder, + LLVMInt8TypeInContext(bld->gallivm->context), + bld->base_ptr, &mip_offset, 1, ""); return data_ptr; } @@ -1180,7 +1183,7 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, LLVMValueRef offsets, offset1; if (bld->num_mips == 1) { - offset1 = load_mip(bld->gallivm, bld->mip_offsets, level); + offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, level); offsets = lp_build_broadcast_scalar(&bld->int_coord_bld, offset1); } else if (bld->num_mips == bld->coord_bld.type.length / 4) { @@ -1189,7 +1192,7 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, offsets = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - offset1 = load_mip(bld->gallivm, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); + offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexo, ""); } @@ -1203,7 +1206,7 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, offsets = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - offset1 = load_mip(bld->gallivm, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); + offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexi, ""); } } @@ -1333,12 +1336,13 @@ lp_build_scale_view_dim(struct gallivm_state *gallivm, LLVMValueRef size, */ static LLVMValueRef lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, + LLVMTypeRef stride_type, LLVMValueRef stride_array, LLVMValueRef level) { LLVMBuilderRef builder = bld->gallivm->builder; LLVMValueRef stride, stride1; if (bld->num_mips == 1) { - stride1 = load_mip(bld->gallivm, stride_array, level); + stride1 = load_mip(bld->gallivm, stride_type, stride_array, level); stride = lp_build_broadcast_scalar(&bld->int_coord_bld, stride1); } else if (bld->num_mips == bld->coord_bld.type.length / 4) { @@ -1348,7 +1352,7 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, stride = bld->int_coord_bld.undef; for (i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - stride1 = load_mip(bld->gallivm, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); + stride1 = load_mip(bld->gallivm, stride_type, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); stride = LLVMBuildInsertElement(builder, stride, stride1, indexo, ""); } @@ -1363,7 +1367,7 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, stride = bld->int_coord_bld.undef; for (i = 0; i < bld->coord_bld.type.length; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - stride1 = load_mip(bld->gallivm, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); + stride1 = load_mip(bld->gallivm, stride_type, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); stride = LLVMBuildInsertElement(builder, stride, stride1, indexi, ""); } } @@ -1515,11 +1519,13 @@ lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld, if (dims >= 2) { *row_stride_vec = lp_build_get_level_stride_vec(bld, + bld->row_stride_type, bld->row_stride_array, ilevel); } if (dims == 3 || has_layer_coord(bld->static_texture_state->target)) { *img_stride_vec = lp_build_get_level_stride_vec(bld, + bld->img_stride_type, bld->img_stride_array, ilevel); } -- GitLab From 6f27bf250461e02ad7df17ad41cbfa71a4cae487 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Tue, 27 Sep 2022 15:28:18 +1000 Subject: [PATCH 6/6] gallivm: remove legacy pointer_get apis These are no longer used. Reviewed-by: Mihai Preda Reviewed-by: Roland Scheidegger Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_struct.c | 117 ------------------ src/gallium/auxiliary/gallivm/lp_bld_struct.h | 65 ---------- 2 files changed, 182 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.c b/src/gallium/auxiliary/gallivm/lp_bld_struct.c index 73c32cebadfb6..0595c3d3df220 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.c @@ -41,43 +41,6 @@ #include "lp_bld_debug.h" #include "lp_bld_struct.h" - -/* Deprecated (used only by llvmpipe); use lp_build_struct_get_ptr2() instead. */ -LLVMValueRef -lp_build_struct_get_ptr(struct gallivm_state *gallivm, - LLVMValueRef ptr, - unsigned member, - const char *name) -{ - LLVMValueRef indices[2]; - LLVMValueRef member_ptr; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); - - indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = lp_build_const_int32(gallivm, member); - member_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, ARRAY_SIZE(indices), ""); - lp_build_name(member_ptr, "%s.%s_ptr", LLVMGetValueName(ptr), name); - return member_ptr; -} - -/* Deprecated (used only by llvmpipe); use lp_build_struct_get2() instead. */ -LLVMValueRef -lp_build_struct_get(struct gallivm_state *gallivm, - LLVMValueRef ptr, - unsigned member, - const char *name) -{ - LLVMValueRef member_ptr; - LLVMValueRef res; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMStructTypeKind); - member_ptr = lp_build_struct_get_ptr(gallivm, ptr, member, name); - res = LLVMBuildLoad(gallivm->builder, member_ptr, ""); - lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name); - return res; -} - LLVMValueRef lp_build_struct_get_ptr2(struct gallivm_state *gallivm, LLVMTypeRef ptr_type, @@ -154,86 +117,6 @@ lp_build_array_get2(struct gallivm_state *gallivm, return res; } -LLVMValueRef -lp_build_array_get_ptr(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index) -{ - LLVMValueRef indices[2]; - LLVMValueRef element_ptr; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); - indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = index; - element_ptr = LLVMBuildGEP(gallivm->builder, ptr, indices, ARRAY_SIZE(indices), ""); -#ifdef DEBUG - lp_build_name(element_ptr, "&%s[%s]", - LLVMGetValueName(ptr), LLVMGetValueName(index)); -#endif - return element_ptr; -} - - -LLVMValueRef -lp_build_array_get(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index) -{ - LLVMValueRef element_ptr; - LLVMValueRef res; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); - element_ptr = lp_build_array_get_ptr(gallivm, ptr, index); - res = LLVMBuildLoad(gallivm->builder, element_ptr, ""); -#ifdef DEBUG - lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); -#endif - return res; -} - - -void -lp_build_array_set(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index, - LLVMValueRef value) -{ - LLVMValueRef element_ptr; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - assert(LLVM_VERSION_MAJOR >= 15 || LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(ptr))) == LLVMArrayTypeKind); - element_ptr = lp_build_array_get_ptr(gallivm, ptr, index); - LLVMBuildStore(gallivm->builder, value, element_ptr); -} - - -LLVMValueRef -lp_build_pointer_get(LLVMBuilderRef builder, - LLVMValueRef ptr, - LLVMValueRef index) -{ - return lp_build_pointer_get_unaligned(builder, ptr, index, 0); -} - - -LLVMValueRef -lp_build_pointer_get_unaligned(LLVMBuilderRef builder, - LLVMValueRef ptr, - LLVMValueRef index, - unsigned alignment) -{ - LLVMValueRef element_ptr; - LLVMValueRef res; - assert(LLVMGetTypeKind(LLVMTypeOf(ptr)) == LLVMPointerTypeKind); - element_ptr = LLVMBuildGEP(builder, ptr, &index, 1, ""); - res = LLVMBuildLoad(builder, element_ptr, ""); - if (alignment) - LLVMSetAlignment(res, alignment); -#ifdef DEBUG - lp_build_name(res, "%s[%s]", LLVMGetValueName(ptr), LLVMGetValueName(index)); -#endif - return res; -} - LLVMValueRef lp_build_pointer_get_unaligned2(LLVMBuilderRef builder, LLVMTypeRef ptr_type, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_struct.h b/src/gallium/auxiliary/gallivm/lp_bld_struct.h index 52d6020563bfb..11f256964f540 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_struct.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_struct.h @@ -53,26 +53,6 @@ offsetof(_ctype, _cmember)) -/** - * Get value pointer to a structure member. - * Deprecated (used only by llvmpipe); use lp_build_struct_get_ptr2() instead. - */ -LLVMValueRef -lp_build_struct_get_ptr(struct gallivm_state *gallivm, - LLVMValueRef ptr, - unsigned member, - const char *name); - -/** - * Get the value of a structure member. - * Deprecated (used only by llvmpipe); use lp_build_struct_get2() instead. - */ -LLVMValueRef -lp_build_struct_get(struct gallivm_state *gallivm, - LLVMValueRef ptr, - unsigned member, - const char *name); - /** * Get value pointer to a structure member. * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. @@ -107,51 +87,6 @@ lp_build_array_get2(struct gallivm_state *gallivm, LLVMValueRef ptr, LLVMValueRef index); -/** - * Get value pointer to an array element. - */ -LLVMValueRef -lp_build_array_get_ptr(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index); - -/** - * Get the value of an array element. - */ -LLVMValueRef -lp_build_array_get(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index); - -/** - * Set the value of an array element. - */ -void -lp_build_array_set(struct gallivm_state *gallivm, - LLVMValueRef ptr, - LLVMValueRef index, - LLVMValueRef value); - -/** - * Get the value of an array element. - */ -LLVMValueRef -lp_build_pointer_get(LLVMBuilderRef builder, - LLVMValueRef ptr, - LLVMValueRef index); - -/** - * Get the value of an array element, with explicit alignment. - * - * If the element size is different from the alignment this will - * cause llvm to emit an unaligned load - */ -LLVMValueRef -lp_build_pointer_get_unaligned(LLVMBuilderRef builder, - LLVMValueRef ptr, - LLVMValueRef index, - unsigned alignment); - /** * Get the value of an array element. * This takes the explicit LLVM type of ptr, as required by LLVM-15 opaque-pointers. -- GitLab