summaryrefslogtreecommitdiff
path: root/user
diff options
context:
space:
mode:
authorA. Wilcox <AWilcox@Wilcox-Tech.com>2024-07-09 01:43:21 -0500
committerA. Wilcox <AWilcox@Wilcox-Tech.com>2024-08-07 10:08:22 -0500
commit9d42e3f8027576d895eadbeb6d22147917529eb0 (patch)
tree59e15443fc8e685bf52709dc425a3eb487ea1a81 /user
parent6b8db867300862d6f96df1c7d8f02bea1ef79cc4 (diff)
downloadpackages-9d42e3f8027576d895eadbeb6d22147917529eb0.tar.gz
packages-9d42e3f8027576d895eadbeb6d22147917529eb0.tar.bz2
packages-9d42e3f8027576d895eadbeb6d22147917529eb0.tar.xz
packages-9d42e3f8027576d895eadbeb6d22147917529eb0.zip
user/mesa: Disable SSE2 on pmmx
Closes: #1207
Diffstat (limited to 'user')
-rw-r--r--user/mesa/APKBUILD3
-rw-r--r--user/mesa/llvm-opaque.patch8467
-rw-r--r--user/mesa/llvm18.patch397
3 files changed, 8866 insertions, 1 deletions
diff --git a/user/mesa/APKBUILD b/user/mesa/APKBUILD
index d5f828129..c7030182e 100644
--- a/user/mesa/APKBUILD
+++ b/user/mesa/APKBUILD
@@ -2,7 +2,7 @@
pkgname=mesa
pkgver=21.3.9
_llvmver=14
-pkgrel=0
+pkgrel=1
pkgdesc="Mesa DRI OpenGL library"
url="https://www.mesa3d.org"
arch="all"
@@ -38,6 +38,7 @@ x86* | pmmx)
_dri_drivers="${_dri_drivers},i965"
_gallium_drivers="${_gallium_drivers},i915,svga,iris"
_vulkan_drivers="${_vulkan_drivers},intel"
+ _arch_conf="-Dsse2=false"
;;
aarch64 | arm*)
_gallium_drivers="${_gallium_drivers},vc4,freedreno,tegra,kmsro,v3d,lima,panfrost,etnaviv"
diff --git a/user/mesa/llvm-opaque.patch b/user/mesa/llvm-opaque.patch
new file mode 100644
index 000000000..80bd18967
--- /dev/null
+++ b/user/mesa/llvm-opaque.patch
@@ -0,0 +1,8467 @@
+From af20d46a39e4431b85d593f56912a185a157554e Mon Sep 17 00:00:00 2001
+From: Mihai Preda <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15893>
+---
+ 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 <mhpreda@gmail.com>
+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 <brianp@vmware.com>
+Acked-by: Marek Olšák <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17650>
+---
+ 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 <mhpreda@gmail.com>
+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 <brianp@vmware.com>
+Acked-by: Marek Olšák <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17650>
+---
+ 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 <mhpreda@gmail.com>
+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 <brianp@vmware.com>
+Acked-by: Marek Olšák <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17650>
+---
+ 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(&params, 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 <mhpreda@gmail.com>
+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 <brianp@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17650>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ .../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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18334>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18721>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18721>
+---
+ 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 <mhpreda@gmail.com>
+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 <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18721>
+---
+ 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 <airlied@redhat.com>
+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<llvm::Value*>, const llvm::Twine&, llvm::Instruction*): Assertion `cast<PointerType>(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 <michael.blumenkrantz@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18816>
+---
+ 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 <airlied@redhat.com>
+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 <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18835>
+---
+ 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 <airlied@redhat.com>
+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 <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18835>
+---
+ 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 <airlied@redhat.com>
+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 <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18835>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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, &centroid_x_offset,
+ &centroid_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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+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 <brianp@vmware.com>
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18876>
+---
+ 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 <airlied@redhat.com>
+Date: Tue, 4 Oct 2022 09:41:00 +1000
+Subject: [PATCH 1/6] llvmpipe/tests: port to new pointer interfaces.
+
+Reviewed-by: Mihai Preda <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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 <airlied@redhat.com>
+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 <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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(&params, 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(&params, 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(&params, 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 <airlied@redhat.com>
+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 <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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 <airlied@redhat.com>
+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 <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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 <airlied@redhat.com>
+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 <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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 <airlied@redhat.com>
+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 <mhpreda@gmail.com>
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18947>
+---
+ 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
+
diff --git a/user/mesa/llvm18.patch b/user/mesa/llvm18.patch
new file mode 100644
index 000000000..660bacb91
--- /dev/null
+++ b/user/mesa/llvm18.patch
@@ -0,0 +1,397 @@
+From f79617fe804ea6524651ff1bc3a91098d3199179 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marek=20Ol=C5=A1=C3=A1k?= <marek.olsak@amd.com>
+Date: Mon, 25 Sep 2023 15:57:33 -0400
+Subject: [PATCH] amd/llvm: fix build with LLVM 18
+
+Reviewed-by: Dave Airlie <airlied@redhat.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/25388>
+---
+ src/gallium/auxiliary/gallivm/lp_bld_misc.cpp | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
+index 5e7a30a6cc2e3..e213f7e4be180 100644
+--- a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
++++ b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
+@@ -366,7 +366,11 @@ lp_build_create_jit_compiler_for_module(LLVMExecutionEngineRef *OutJIT,
+ builder.setEngineKind(EngineKind::JIT)
+ .setErrorStr(&Error)
+ .setTargetOptions(options)
++#if LLVM_VERSION_MAJOR >= 18
++ .setOptLevel((CodeGenOptLevel)OptLevel);
++#else
+ .setOptLevel((CodeGenOpt::Level)OptLevel);
++#endif
+
+ #if DETECT_OS_WINDOWS
+ /*
+--
+GitLab
+
+
+
+
+
+
+<!DOCTYPE html>
+<html class="gl-light ui-neutral with-header with-top-bar " lang="en">
+<head prefix="og: http://ogp.me/ns#">
+<meta charset="utf-8">
+<meta content="IE=edge" http-equiv="X-UA-Compatible">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>gallivm: handle llvm 16 atexit ordering problems. (b3cfec2f) · Commits · Mesa / mesa · GitLab</title>
+<script>
+//<![CDATA[
+window.gon={};gon.math_rendering_limits_enabled=true;gon.features={"ciGraphqlPipelineMiniGraph":false};
+//]]>
+</script>
+
+
+
+
+
+
+<link rel="stylesheet" href="/assets/application-bc8000290bc8c8c0ebadb5c9d96dac50df8244426ef375a23cfae334e9b100c2.css" media="all" />
+<link rel="stylesheet" href="/assets/page_bundles/pipelines-147f0c35e12b857600d63ad57bd1505da553bee448fee17c49459845401fed79.css" media="all" /><link rel="stylesheet" href="/assets/page_bundles/commit_description-5653213c51a6c90453a926cfc5e5e71ad9b41881a20a408bef8a303cf175435c.css" media="all" /><link rel="stylesheet" href="/assets/page_bundles/work_items-4dbc32cca030ff7727ba26485149518edc039e72f1577ef00291805720518949.css" media="all" />
+<link rel="stylesheet" href="/assets/application_utilities-d9a7b82eeacf5bfb8ceea81780b391ff56bc5b4332509ae17839f3590bce0ae9.css" media="all" />
+<link rel="stylesheet" href="/assets/tailwind-c4fd78b89a0e3b72cbd08ce282e35067bb563355705f68ef5cb893962ccc7c32.css" media="all" />
+
+
+<link rel="stylesheet" href="/assets/fonts-fae5d3f79948bd85f18b6513a025f863b19636e85b09a1492907eb4b1bb0557b.css" media="all" />
+<link rel="stylesheet" href="/assets/highlight/themes/white-2ffecda73965655b02849f077e67509c64f03bf7959a10ee45a0147e79ab96fd.css" media="all" />
+
+
+<link rel="preload" href="/assets/application_utilities-d9a7b82eeacf5bfb8ceea81780b391ff56bc5b4332509ae17839f3590bce0ae9.css" as="style" type="text/css">
+<link rel="preload" href="/assets/application-bc8000290bc8c8c0ebadb5c9d96dac50df8244426ef375a23cfae334e9b100c2.css" as="style" type="text/css">
+<link rel="preload" href="/assets/highlight/themes/white-2ffecda73965655b02849f077e67509c64f03bf7959a10ee45a0147e79ab96fd.css" as="style" type="text/css">
+
+
+
+
+
+<script src="/assets/webpack/runtime.c3b445fb.bundle.js" defer="defer"></script>
+<script src="/assets/webpack/main.aa8f43d1.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/graphql.e1f11a07.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.dashboard.issues-pages.dashboard.milestones.show-pages.-a65b27a2.97e0c257.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.dashboard.issues-pages.groups.boards-pages.groups.issue-8f3ec9c9.450d024d.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.dashboard.issues-pages.groups.boards-pages.groups.issue-181be4cb.80f39b87.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.groups.new-pages.import.gitlab_projects.new-pages.import.manifest.new-pages.projects.n-44c6c18e.227a132b.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.search.show-super_sidebar.4ea731a1.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/super_sidebar.ed4df32c.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.admin.topics.edit-pages.admin.topics.new-pages.dashboar-7469413d.4f86d3e8.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.admin.topics.edit-pages.admin.topics.new-pages.groups.i-56cf042c.01ecb85c.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/8.788661b8.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.admin.topics.edit-pages.admin.topics.new-pages.groups.i-79e94350.81fd5681.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/10.abcd7097.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.abuse_reports.show-pages.admin.topics.edit-pages.admin.topics.new-pages.groups.i-aa2a43bd.1d1306c9.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.admin.topics.edit-pages.admin.topics.new-pages.groups.milestones.edit-pages.groups.mil-d4098e09.740ed42b.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/26.3e8521dc.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.groups.milestones.edit-pages.groups.milestones.new-pages.groups.milestones.show-pages.-3a9ea570.d48dcdaa.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.projects.commit.pipelines-pages.projects.commit.rapid_diffs-pages.projects.commit.show.c0025a99.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.projects.commit.show-pages.projects.snippets.show-pages.snippets.show.cf9cdece.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/commons-pages.projects.commit.show-pages.projects.compare.show-pages.projects.wikis.diff.14466c81.chunk.js" defer="defer"></script>
+<script src="/assets/webpack/pages.projects.commit.show.67c9270a.chunk.js" defer="defer"></script>
+<meta content="object" property="og:type">
+<meta content="GitLab" property="og:site_name">
+<meta content="gallivm: handle llvm 16 atexit ordering problems. (b3cfec2f) · Commits · Mesa / mesa · GitLab" property="og:title">
+<meta content="This is ported from amd ac_llvm_helper.cpp, thanks to Marek for the pointer. This is needed to avoid crashes due to atexit ordering between some piglit tests and mesa internals. Cc:..." property="og:description">
+<meta content="https://gitlab.freedesktop.org/uploads/-/system/project/avatar/176/gears.png" property="og:image">
+<meta content="64" property="og:image:width">
+<meta content="64" property="og:image:height">
+<meta content="https://gitlab.freedesktop.org/mesa/mesa/-/commit/b3cfec2fd824a52023c92fd5928f4f5c1cb449a0" property="og:url">
+<meta content="summary" property="twitter:card">
+<meta content="gallivm: handle llvm 16 atexit ordering problems. (b3cfec2f) · Commits · Mesa / mesa · GitLab" property="twitter:title">
+<meta content="This is ported from amd ac_llvm_helper.cpp, thanks to Marek for the pointer. This is needed to avoid crashes due to atexit ordering between some piglit tests and mesa internals. Cc:..." property="twitter:description">
+<meta content="https://gitlab.freedesktop.org/uploads/-/system/project/avatar/176/gears.png" property="twitter:image">
+
+<meta name="csrf-param" content="authenticity_token" />
+<meta name="csrf-token" content="AioFgsl_omxJZyl5Q2D4GnKiXe47UFUKYPQW0znQbNIsHTFW0Bd4XCkZo8p5Pmlez7T9muUsVHMfGUAj9SBU6g" />
+<meta name="csp-nonce" />
+<meta name="action-cable-url" content="/-/cable" />
+<link href="/-/manifest.json" rel="manifest">
+<link rel="icon" type="image/png" href="/uploads/-/system/appearance/favicon/1/fdo-favicon.ico" id="favicon" data-original-href="/uploads/-/system/appearance/favicon/1/fdo-favicon.ico" />
+<link rel="apple-touch-icon" type="image/x-icon" href="/assets/apple-touch-icon-b049d4bc0dd9626f31db825d61880737befc7835982586d015bded10b4435460.png" />
+<link href="/search/opensearch.xml" rel="search" title="Search GitLab" type="application/opensearchdescription+xml">
+
+
+
+
+<meta content="This is ported from amd ac_llvm_helper.cpp, thanks to Marek for the pointer. This is needed to avoid crashes due to atexit ordering between some piglit tests and mesa internals. Cc:..." name="description">
+<meta content="#ececef" name="theme-color">
+</head>
+
+<body class="tab-width-8 gl-browser-generic gl-platform-other " data-find-file="/mesa/mesa/-/find_file/b3cfec2fd824a52023c92fd5928f4f5c1cb449a0" data-group="mesa" data-group-full-path="mesa" data-namespace-id="1155" data-page="projects:commit:show" data-page-type-id="b3cfec2fd824a52023c92fd5928f4f5c1cb449a0" data-project="mesa" data-project-full-path="mesa/mesa" data-project-id="176">
+<script>
+//<![CDATA[
+gl = window.gl || {};
+gl.GfmAutoComplete = gl.GfmAutoComplete || {};
+gl.GfmAutoComplete.dataSources = {"members":"/mesa/mesa/-/autocomplete_sources/members?type=Commit\u0026type_id=b3cfec2fd824a52023c92fd5928f4f5c1cb449a0","issues":"/mesa/mesa/-/autocomplete_sources/issues","mergeRequests":"/mesa/mesa/-/autocomplete_sources/merge_requests","labels":"/mesa/mesa/-/autocomplete_sources/labels?type=Commit\u0026type_id=b3cfec2fd824a52023c92fd5928f4f5c1cb449a0","milestones":"/mesa/mesa/-/autocomplete_sources/milestones","commands":"/mesa/mesa/-/autocomplete_sources/commands?type=Commit\u0026type_id=b3cfec2fd824a52023c92fd5928f4f5c1cb449a0","snippets":"/mesa/mesa/-/autocomplete_sources/snippets","contacts":"/mesa/mesa/-/autocomplete_sources/contacts?type=Commit\u0026type_id=b3cfec2fd824a52023c92fd5928f4f5c1cb449a0","wikis":null};
+
+
+//]]>
+</script>
+<script>
+//<![CDATA[
+gl = window.gl || {};
+gl.client = {"isGeneric":true,"isOther":true};
+
+
+//]]>
+</script>
+
+
+<header class="header-logged-out" data-testid="navbar">
+<a class="gl-sr-only gl-accessibility" href="#content-body">Skip to content</a>
+<div class="container-fluid">
+<nav aria-label="Explore GitLab" class="header-logged-out-nav gl-display-flex gl-gap-3 gl-justify-content-space-between">
+<div class="gl-display-flex gl-align-items-center gl-gap-1">
+<span class="gl-sr-only">GitLab</span>
+<a title="Homepage" id="logo" class="header-logged-out-logo has-tooltip" aria-label="Homepage" href="/"><img class="brand-header-logo lazy" alt="" data-src="/uploads/-/system/appearance/header_logo/1/fdo-logo-header.png" src="data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==" />
+</a></div>
+<ul class="gl-list-none gl-p-0 gl-m-0 gl-display-flex gl-gap-3 gl-align-items-center gl-flex-grow-1">
+<li class="header-logged-out-nav-item">
+<a class="" href="/explore">Explore</a>
+</li>
+</ul>
+<ul class="gl-list-none gl-p-0 gl-m-0 gl-display-flex gl-gap-3 gl-align-items-center gl-justify-content-end">
+<li class="header-logged-out-nav-item">
+<a href="/users/sign_in?redirect_to_referer=yes">Sign in</a>
+</li>
+<li class="header-logged-out-nav-item">
+<a class="gl-button btn btn-md btn-confirm " href="/users/sign_up"><span class="gl-button-text">
+Register
+
+</span>
+
+</a></li>
+</ul>
+</nav>
+</div>
+</header>
+
+<div class="layout-page page-with-super-sidebar">
+<aside class="js-super-sidebar super-sidebar super-sidebar-loading" data-command-palette="{&quot;project_files_url&quot;:&quot;/mesa/mesa/-/files/b3cfec2fd824a52023c92fd5928f4f5c1cb449a0?format=json&quot;,&quot;project_blob_url&quot;:&quot;/mesa/mesa/-/blob/b3cfec2fd824a52023c92fd5928f4f5c1cb449a0&quot;}" data-force-desktop-expanded-sidebar="" data-root-path="/" data-sidebar="{&quot;is_logged_in&quot;:false,&quot;context_switcher_links&quot;:[{&quot;title&quot;:&quot;Explore&quot;,&quot;link&quot;:&quot;/explore&quot;,&quot;icon&quot;:&quot;compass&quot;}],&quot;current_menu_items&quot;:[{&quot;id&quot;:&quot;project_overview&quot;,&quot;title&quot;:&quot;mesa&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:&quot;/uploads/-/system/project/avatar/176/gears.png&quot;,&quot;entity_id&quot;:176,&quot;link&quot;:&quot;/mesa/mesa&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:&quot;shortcuts-project&quot;,&quot;is_active&quot;:false},{&quot;id&quot;:&quot;manage_menu&quot;,&quot;title&quot;:&quot;Manage&quot;,&quot;icon&quot;:&quot;users&quot;,&quot;avatar&quot;:null,&quot;avatar_shape&quot;:&quot;rect&quot;,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/activity&quot;,&quot;is_active&quot;:false,&quot;pill_count&quot;:null,&quot;items&quot;:[{&quot;id&quot;:&quot;activity&quot;,&quot;title&quot;:&quot;Activity&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/activity&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:&quot;shortcuts-project-activity&quot;,&quot;is_active&quot;:false},{&quot;id&quot;:&quot;members&quot;,&quot;title&quot;:&quot;Members&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/project_members&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:null,&quot;is_active&quot;:false},{&quot;id&quot;:&quot;labels&quot;,&quot;title&quot;:&quot;Labels&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/labels&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:null,&quot;is_active&quot;:false}],&quot;separated&quot;:false},{&quot;id&quot;:&quot;plan_menu&quot;,&quot;title&quot;:&quot;Plan&quot;,&quot;icon&quot;:&quot;planning&quot;,&quot;avatar&quot;:null,&quot;avatar_shape&quot;:&quot;rect&quot;,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/issues&quot;,&quot;is_active&quot;:false,&quot;pill_count&quot;:null,&quot;items&quot;:[{&quot;id&quot;:&quot;project_issue_list&quot;,&quot;title&quot;:&quot;Issues&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/issues&quot;,&quot;pill_count&quot;:&quot;3.7k&quot;,&quot;link_classes&quot;:&quot;shortcuts-issues has-sub-items&quot;,&quot;is_active&quot;:false},{&quot;id&quot;:&quot;boards&quot;,&quot;title&quot;:&quot;Issue boards&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/boards&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:&quot;shortcuts-issue-boards&quot;,&quot;is_active&quot;:false},{&quot;id&quot;:&quot;milestones&quot;,&quot;title&quot;:&quot;Milestones&quot;,&quot;icon&quot;:null,&quot;avatar&quot;:null,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/milestones&quot;,&quot;pill_count&quot;:null,&quot;link_classes&quot;:null,&quot;is_active&quot;:false}],&quot;separated&quot;:false},{&quot;id&quot;:&quot;code_menu&quot;,&quot;title&quot;:&quot;Code&quot;,&quot;icon&quot;:&quot;code&quot;,&quot;avatar&quot;:null,&quot;avatar_shape&quot;:&quot;rect&quot;,&quot;entity_id&quot;:null,&quot;link&quot;:&quot;/mesa/mesa/-/merge_requests&quot;,&quot;is_active&quot;:true,&quot;pill_count&quot;:null,&quot;items&quot;:[{&quot;id&quot;:&quot;project_merge_request_list&quot;,&quot;title&quot;:&quot;Merge requests&quot;,&quot;icon&quot;:nFrom b3cfec2fd824a52023c92fd5928f4f5c1cb449a0 Mon Sep 17 00:00:00 2001
+From: Dave Airlie <airlied@redhat.com>
+Date: Thu, 4 Jan 2024 06:17:50 +1000
+Subject: [PATCH] gallivm: handle llvm 16 atexit ordering problems.
+
+This is ported from amd ac_llvm_helper.cpp, thanks to Marek for the pointer.
+
+This is needed to avoid crashes due to atexit ordering between some piglit
+tests and mesa internals.
+
+Cc: mesa-stable
+Reviewed-by: Konstantin Seurer <konstantin.seurer@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26883>
+---
+ src/gallium/auxiliary/gallivm/lp_bld_misc.cpp | 34 +++++++++++++++++++
+ 1 file changed, 34 insertions(+)
+
+diff --git a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
+index e213f7e4be180..a5e84d708f2c6 100644
+--- a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
++++ b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp
+@@ -62,6 +62,7 @@
+ #include <llvm/Support/PrettyStackTrace.h>
+ #include <llvm/ExecutionEngine/ObjectCache.h>
+ #include <llvm/Support/TargetSelect.h>
++#include <llvm/CodeGen/SelectionDAGNodes.h>
+ #if LLVM_VERSION_MAJOR >= 15
+ #include <llvm/Support/MemoryBuffer.h>
+ #endif
+@@ -100,6 +101,8 @@
+ #include "lp_bld_misc.h"
+ #include "lp_bld_debug.h"
+
++static void lp_run_atexit_for_destructors(void);
++
+ namespace {
+
+ class LLVMEnsureMultithreaded {
+@@ -147,6 +150,7 @@ static void init_native_targets()
+ }
+ }
+ #endif
++ lp_run_atexit_for_destructors();
+ }
+
+ extern "C" void
+@@ -623,3 +627,33 @@ lp_set_module_stack_alignment_override(LLVMModuleRef MRef, unsigned align)
+ M->setOverrideStackAlignment(align);
+ #endif
+ }
++
++using namespace llvm;
++
++class GallivmRunAtExitForStaticDestructors : public SDNode
++{
++public:
++ /* getSDVTList (protected) calls getValueTypeList (private), which contains static variables. */
++ GallivmRunAtExitForStaticDestructors(): SDNode(0, 0, DebugLoc(), getSDVTList(MVT::Other))
++ {
++ }
++};
++
++static void
++lp_run_atexit_for_destructors(void)
++{
++ /* LLVM >= 16 registers static variable destructors on the first compile, which gcc
++ * implements by calling atexit there. Before that, u_queue registers its atexit
++ * handler to kill all threads. Since exit() runs atexit handlers in the reverse order,
++ * the LLVM destructors are called first while shader compiler threads may still be
++ * running, which crashes in LLVM in SelectionDAG.cpp.
++ *
++ * The solution is to run the code that declares the LLVM static variables first,
++ * so that atexit for LLVM is registered first and u_queue is registered after that,
++ * which ensures that all u_queue threads are terminated before LLVM destructors are
++ * called.
++ *
++ * This just executes the code that declares static variables.
++ */
++ GallivmRunAtExitForStaticDestructors();
++}
+--
+GitLab
+
+From 550cc685a76b609a3c3f358d554de6e9911510ec Mon Sep 17 00:00:00 2001
+From: Dave Airlie <airlied@redhat.com>
+Date: Thu, 18 Jan 2024 18:05:47 +1000
+Subject: [PATCH] gallivm: fix coroutines with llvm 18
+
+llvm 18 added an extra parameters to coro end which should just
+take a null token always for us.
+
+Reviewed-by: Konstantin Seurer <konstantin.seurer@gmail.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/27133>
+---
+ src/gallium/auxiliary/gallivm/lp_bld_coro.c | 9 +++++++--
+ 1 file changed, 7 insertions(+), 2 deletions(-)
+
+diff --git a/src/gallium/auxiliary/gallivm/lp_bld_coro.c b/src/gallium/auxiliary/gallivm/lp_bld_coro.c
+index 0214dcf674203..75aaa7d2b84c9 100644
+--- a/src/gallium/auxiliary/gallivm/lp_bld_coro.c
++++ b/src/gallium/auxiliary/gallivm/lp_bld_coro.c
+@@ -89,13 +89,18 @@ LLVMValueRef lp_build_coro_free(struct gallivm_state *gallivm,
+
+ void lp_build_coro_end(struct gallivm_state *gallivm, LLVMValueRef coro_hdl)
+ {
+- LLVMValueRef coro_end_args[2];
++ LLVMValueRef coro_end_args[3];
++ int num_args = 2;
+ coro_end_args[0] = coro_hdl;
+ coro_end_args[1] = LLVMConstInt(LLVMInt1TypeInContext(gallivm->context), 0, 0);
++#if LLVM_VERSION_MAJOR >= 18
++ coro_end_args[2] = LLVMConstNull(LLVMTokenTypeInContext(gallivm->context));
++ num_args++;
++#endif
+ lp_build_intrinsic(gallivm->builder,
+ "llvm.coro.end",
+ LLVMInt1TypeInContext(gallivm->context),
+- coro_end_args, 2, 0);
++ coro_end_args, num_args, 0);
+ }
+
+ void lp_build_coro_resume(struct gallivm_state *gallivm, LLVMValueRef coro_hdl)
+--
+GitLab
+
+From 99f0449987bec1f82cd42a06f40bb4a863a37792 Mon Sep 17 00:00:00 2001
+From: Nikita Popov <npopov@redhat.com>
+Date: Mon, 11 Mar 2024 14:45:41 +0100
+Subject: [PATCH] Pass no-verify-fixpoint option to instcombine in LLVM 18
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+When LLVM 18 is used, pass the no-verify-fixpoint option when
+running the instcombine pass. Otherwise LLVM may abort with an
+error.
+
+The background here is that this option is enabled by default for
+testing purposes, because instcombine is normally only explicitly
+invoked like this inside tests. If it is used in an actual
+production pipeline, the no-verify-fixpoint option needs to be
+enabled.
+
+This should fix the issue reported at
+https://bugzilla.redhat.com/show_bug.cgi?id=2268800.
+
+Reviewed-by: Konstantin Seurer <konstantin.seurer@gmail.com>
+Reviewed-by: Marek Olšák <marek.olsak@amd.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/28101>
+---
+ src/gallium/auxiliary/gallivm/lp_bld_init.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/src/gallium/auxiliary/gallivm/lp_bld_init.c b/src/gallium/auxiliary/gallivm/lp_bld_init.c
+index cd2108f3a088d..1345d85b22439 100644
+--- a/src/gallium/auxiliary/gallivm/lp_bld_init.c
++++ b/src/gallium/auxiliary/gallivm/lp_bld_init.c
+@@ -609,7 +609,11 @@ gallivm_compile_module(struct gallivm_state *gallivm)
+ LLVMRunPasses(gallivm->module, passes, LLVMGetExecutionEngineTargetMachine(gallivm->engine), opts);
+
+ if (!(gallivm_perf & GALLIVM_PERF_NO_OPT))
++#if LLVM_VERSION_MAJOR >= 18
++ strcpy(passes, "sroa,early-cse,simplifycfg,reassociate,mem2reg,instsimplify,instcombine<no-verify-fixpoint>");
++#else
+ strcpy(passes, "sroa,early-cse,simplifycfg,reassociate,mem2reg,instsimplify,instcombine");
++#endif
+ else
+ strcpy(passes, "mem2reg");
+
+--
+GitLab
+
+From a2ae6518c2d70dca9e3e9e93dc8e38a18f73c14e Mon Sep 17 00:00:00 2001
+From: Konstantin Seurer <konstantin.seurer@gmail.com>
+Date: Fri, 28 Apr 2023 23:15:48 +0200
+Subject: [PATCH] gallivm: Fix gather/scatter types for newer llvm
+
+The types changed with opaque pointer support.
+
+Fixes a bunch of lavapipe regressions.
+Cc: mesa-stable
+
+Reviewed-by: Roland Scheidegger <sroland@vmware.com>
+Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23293>
+---
+ src/gallium/auxiliary/gallivm/lp_bld_gather.c | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+diff --git a/src/gallium/auxiliary/gallivm/lp_bld_gather.c b/src/gallium/auxiliary/gallivm/lp_bld_gather.c
+index b93251b444495..f55f2f3145e28 100644
+--- a/src/gallium/auxiliary/gallivm/lp_bld_gather.c
++++ b/src/gallium/auxiliary/gallivm/lp_bld_gather.c
+@@ -611,8 +611,14 @@ lp_build_masked_gather(struct gallivm_state *gallivm,
+ LLVMValueRef args[4];
+ char intrin_name[64];
+
++#if LLVM_VERSION_MAJOR >= 16
++ snprintf(intrin_name, 64, "llvm.masked.gather.v%ui%u.v%up0",
++ length, bit_size, length);
++#else
+ snprintf(intrin_name, 64, "llvm.masked.gather.v%ui%u.v%up0i%u",
+ length, bit_size, length, bit_size);
++#endif
++
+ args[0] = offset_ptr;
+ args[1] = lp_build_const_int32(gallivm, bit_size / 8);
+ args[2] = LLVMBuildICmp(builder, LLVMIntNE, exec_mask,
+@@ -635,8 +641,14 @@ lp_build_masked_scatter(struct gallivm_state *gallivm,
+ LLVMValueRef args[4];
+ char intrin_name[64];
+
++#if LLVM_VERSION_MAJOR >= 16
++ snprintf(intrin_name, 64, "llvm.masked.scatter.v%ui%u.v%up0",
++ length, bit_size, length);
++#else
+ snprintf(intrin_name, 64, "llvm.masked.scatter.v%ui%u.v%up0i%u",
+ length, bit_size, length, bit_size);
++#endif
++
+ args[0] = value_vec;
+ args[1] = offset_ptr;
+ args[2] = lp_build_const_int32(gallivm, bit_size / 8);
+--
+GitLab
+
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-11 03:46:18 +0000