user/mesa: Disable SSE on pmmx

3 files changed, 8866 insertions, 1 deletions

diff --git a/user/mesa/APKBUILD b/user/mesa/APKBUILD
index d5f828129..bd6c40a70 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="-Dsse=disabled"
 	;;
 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
+