X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fradeonsi%2Fsi_shader.c;h=2b9fe4bf7a141bfa55b84fe1c107d8b059f80073;hb=a9773311f6a1b7f49dbd207c12e8081a5823c5a9;hp=10f40a925e499353b7792a863bb941c2057b3760;hpb=57f18623fb94891c04f3a395cfd977ea3747ee61;p=mesa.git

diff --git a/src/gallium/drivers/radeonsi/si_shader.c b/src/gallium/drivers/radeonsi/si_shader.c
index 10f40a925e4..2b9fe4bf7a1 100644
--- a/src/gallium/drivers/radeonsi/si_shader.c
+++ b/src/gallium/drivers/radeonsi/si_shader.c
@@ -307,64 +307,6 @@ get_tcs_out_current_patch_data_offset(struct si_shader_context *ctx)
 			    "");
 }
 
-static LLVMValueRef build_gep0(struct si_shader_context *ctx,
-			       LLVMValueRef base_ptr, LLVMValueRef index)
-{
-	LLVMValueRef indices[2] = {
-		LLVMConstInt(ctx->i32, 0, 0),
-		index,
-	};
-	return LLVMBuildGEP(ctx->gallivm.builder, base_ptr,
-			    indices, 2, "");
-}
-
-static void build_indexed_store(struct si_shader_context *ctx,
-				LLVMValueRef base_ptr, LLVMValueRef index,
-				LLVMValueRef value)
-{
-	struct lp_build_tgsi_context *bld_base = &ctx->bld_base;
-	struct gallivm_state *gallivm = bld_base->base.gallivm;
-
-	LLVMBuildStore(gallivm->builder, value,
-		       build_gep0(ctx, base_ptr, index));
-}
-
-/**
- * Build an LLVM bytecode indexed load using LLVMBuildGEP + LLVMBuildLoad.
- * It's equivalent to doing a load from &base_ptr[index].
- *
- * \param base_ptr  Where the array starts.
- * \param index     The element index into the array.
- * \param uniform   Whether the base_ptr and index can be assumed to be
- *                  dynamically uniform
- */
-static LLVMValueRef build_indexed_load(struct si_shader_context *ctx,
-				       LLVMValueRef base_ptr, LLVMValueRef index,
-				       bool uniform)
-{
-	struct lp_build_tgsi_context *bld_base = &ctx->bld_base;
-	struct gallivm_state *gallivm = bld_base->base.gallivm;
-	LLVMValueRef pointer;
-
-	pointer = build_gep0(ctx, base_ptr, index);
-	if (uniform)
-		LLVMSetMetadata(pointer, ctx->uniform_md_kind, ctx->empty_md);
-	return LLVMBuildLoad(gallivm->builder, pointer, "");
-}
-
-/**
- * Do a load from &base_ptr[index], but also add a flag that it's loading
- * a constant from a dynamically uniform index.
- */
-static LLVMValueRef build_indexed_load_const(
-	struct si_shader_context *ctx,
-	LLVMValueRef base_ptr, LLVMValueRef index)
-{
-	LLVMValueRef result = build_indexed_load(ctx, base_ptr, index, true);
-	LLVMSetMetadata(result, ctx->invariant_load_md_kind, ctx->empty_md);
-	return result;
-}
-
 static LLVMValueRef get_instance_index_for_fetch(
 	struct si_shader_context *radeon_bld,
 	unsigned param_start_instance, unsigned divisor)
@@ -410,7 +352,7 @@ static void declare_input_vs(
 
 	t_offset = lp_build_const_int32(gallivm, input_index);
 
-	t_list = build_indexed_load_const(ctx, t_list_ptr, t_offset);
+	t_list = ac_build_indexed_load_const(&ctx->ac, t_list_ptr, t_offset);
 
 	/* Build the attribute offset */
 	attribute_offset = lp_build_const_int32(gallivm, 0);
@@ -1017,12 +959,12 @@ static LLVMValueRef lds_load(struct lp_build_tgsi_context *bld_base,
 	dw_addr = lp_build_add(&bld_base->uint_bld, dw_addr,
 			    lp_build_const_int32(gallivm, swizzle));
 
-	value = build_indexed_load(ctx, ctx->lds, dw_addr, false);
+	value = ac_build_indexed_load(&ctx->ac, ctx->lds, dw_addr, false);
 	if (tgsi_type_is_64bit(type)) {
 		LLVMValueRef value2;
 		dw_addr = lp_build_add(&bld_base->uint_bld, dw_addr,
 				       lp_build_const_int32(gallivm, 1));
-		value2 = build_indexed_load(ctx, ctx->lds, dw_addr, false);
+		value2 = ac_build_indexed_load(&ctx->ac, ctx->lds, dw_addr, false);
 		return si_llvm_emit_fetch_64bit(bld_base, type, value, value2);
 	}
 
@@ -1048,8 +990,8 @@ static void lds_store(struct lp_build_tgsi_context *bld_base,
 			    lp_build_const_int32(gallivm, swizzle));
 
 	value = LLVMBuildBitCast(gallivm->builder, value, ctx->i32, "");
-	build_indexed_store(ctx, ctx->lds,
-			    dw_addr, value);
+	ac_build_indexed_store(&ctx->ac, ctx->lds,
+			       dw_addr, value);
 }
 
 static LLVMValueRef fetch_input_tcs(
@@ -1098,7 +1040,7 @@ static LLVMValueRef fetch_input_tes(
 
 	rw_buffers = LLVMGetParam(ctx->main_fn,
 				  SI_PARAM_RW_BUFFERS);
-	buffer = build_indexed_load_const(ctx, rw_buffers,
+	buffer = ac_build_indexed_load_const(&ctx->ac, rw_buffers,
 			lp_build_const_int32(gallivm, SI_HS_RING_TESS_OFFCHIP));
 
 	base = LLVMGetParam(ctx->main_fn, ctx->param_oc_lds);
@@ -1140,7 +1082,7 @@ static void store_output_tcs(struct lp_build_tgsi_context *bld_base,
 
 	rw_buffers = LLVMGetParam(ctx->main_fn,
 				  SI_PARAM_RW_BUFFERS);
-	buffer = build_indexed_load_const(ctx, rw_buffers,
+	buffer = ac_build_indexed_load_const(&ctx->ac, rw_buffers,
 			lp_build_const_int32(gallivm, SI_HS_RING_TESS_OFFCHIP));
 
 	base = LLVMGetParam(ctx->main_fn, ctx->param_oc_lds);
@@ -1281,80 +1223,6 @@ static int lookup_interp_param_index(unsigned interpolate, unsigned location)
 	}
 }
 
-static LLVMValueRef build_fs_interp(
-	struct lp_build_tgsi_context *bld_base,
-	LLVMValueRef llvm_chan,
-	LLVMValueRef attr_number,
-	LLVMValueRef params,
-	LLVMValueRef i,
-	LLVMValueRef j) {
-
-	struct si_shader_context *ctx = si_shader_context(bld_base);
-	struct gallivm_state *gallivm = bld_base->base.gallivm;
-	LLVMValueRef args[5];
-	LLVMValueRef p1;
-	if (HAVE_LLVM < 0x0400) {
-		LLVMValueRef ij[2];
-		ij[0] = LLVMBuildBitCast(gallivm->builder, i, ctx->i32, "");
-		ij[1] = LLVMBuildBitCast(gallivm->builder, j, ctx->i32, "");
-
-		args[0] = llvm_chan;
-		args[1] = attr_number;
-		args[2] = params;
-		args[3] = lp_build_gather_values(gallivm, ij, 2);
-		return lp_build_intrinsic(gallivm->builder, "llvm.SI.fs.interp",
-					  ctx->f32, args, 4,
-					  LP_FUNC_ATTR_READNONE);
-	}
-
-	args[0] = i;
-	args[1] = llvm_chan;
-	args[2] = attr_number;
-	args[3] = params;
-
-	p1 = lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.interp.p1",
-				ctx->f32, args, 4, LP_FUNC_ATTR_READNONE);
-
-	args[0] = p1;
-	args[1] = j;
-	args[2] = llvm_chan;
-	args[3] = attr_number;
-	args[4] = params;
-
-	return lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.interp.p2",
-				  ctx->f32, args, 5, LP_FUNC_ATTR_READNONE);
-}
-
-static LLVMValueRef build_fs_interp_mov(
-	struct lp_build_tgsi_context *bld_base,
-	LLVMValueRef parameter,
-	LLVMValueRef llvm_chan,
-	LLVMValueRef attr_number,
-	LLVMValueRef params) {
-
-	struct si_shader_context *ctx = si_shader_context(bld_base);
-	struct gallivm_state *gallivm = bld_base->base.gallivm;
-	LLVMValueRef args[4];
-	if (HAVE_LLVM < 0x0400) {
-		args[0] = llvm_chan;
-		args[1] = attr_number;
-		args[2] = params;
-
-		return lp_build_intrinsic(gallivm->builder,
-					  "llvm.SI.fs.constant",
-					  ctx->f32, args, 3,
-					  LP_FUNC_ATTR_READNONE);
-	}
-
-	args[0] = parameter;
-	args[1] = llvm_chan;
-	args[2] = attr_number;
-	args[3] = params;
-
-	return lp_build_intrinsic(gallivm->builder, "llvm.amdgcn.interp.mov",
-				  ctx->f32, args, 4, LP_FUNC_ATTR_READNONE);
-}
-
 /**
  * Interpolate a fragment shader input.
  *
@@ -1438,17 +1306,17 @@ static void interp_fs_input(struct si_shader_context *ctx,
 			LLVMValueRef front, back;
 
 			if (interp) {
-				front = build_fs_interp(bld_base, llvm_chan,
+				front = ac_build_fs_interp(&ctx->ac, llvm_chan,
 							attr_number, prim_mask,
 							i, j);
-				back = build_fs_interp(bld_base, llvm_chan,
+				back = ac_build_fs_interp(&ctx->ac, llvm_chan,
 							back_attr_number, prim_mask,
 							i, j);
 			} else {
-				front = build_fs_interp_mov(bld_base,
+				front = ac_build_fs_interp_mov(&ctx->ac,
 					lp_build_const_int32(gallivm, 2), /* P0 */
 					llvm_chan, attr_number, prim_mask);
-				back = build_fs_interp_mov(bld_base,
+				back = ac_build_fs_interp_mov(&ctx->ac,
 					lp_build_const_int32(gallivm, 2), /* P0 */
 					llvm_chan, back_attr_number, prim_mask);
 			}
@@ -1461,12 +1329,12 @@ static void interp_fs_input(struct si_shader_context *ctx,
 		}
 	} else if (semantic_name == TGSI_SEMANTIC_FOG) {
 		if (interp) {
-			result[0] = build_fs_interp(bld_base, uint->zero,
-						attr_number, prim_mask, i, j);
+			result[0] = ac_build_fs_interp(&ctx->ac, uint->zero,
+						       attr_number, prim_mask, i, j);
 		} else {
-			result[0] = build_fs_interp_mov(bld_base, uint->zero,
-				lp_build_const_int32(gallivm, 2), /* P0 */
-				attr_number, prim_mask);
+			result[0] = ac_build_fs_interp_mov(&ctx->ac, uint->zero,
+							   lp_build_const_int32(gallivm, 2), /* P0 */
+							   attr_number, prim_mask);
 		}
 		result[1] =
 		result[2] = lp_build_const_float(gallivm, 0.0f);
@@ -1476,10 +1344,10 @@ static void interp_fs_input(struct si_shader_context *ctx,
 			LLVMValueRef llvm_chan = lp_build_const_int32(gallivm, chan);
 
 			if (interp) {
-				result[chan] = build_fs_interp(bld_base,
+				result[chan] = ac_build_fs_interp(&ctx->ac,
 					llvm_chan, attr_number, prim_mask, i, j);
 			} else {
-				result[chan] = build_fs_interp_mov(bld_base,
+				result[chan] = ac_build_fs_interp_mov(&ctx->ac,
 					lp_build_const_int32(gallivm, 2), /* P0 */
 					llvm_chan, attr_number, prim_mask);
 			}
@@ -1610,7 +1478,7 @@ static LLVMValueRef load_sample_position(struct si_shader_context *radeon_bld, L
 	LLVMBuilderRef builder = gallivm->builder;
 	LLVMValueRef desc = LLVMGetParam(ctx->main_fn, SI_PARAM_RW_BUFFERS);
 	LLVMValueRef buf_index = lp_build_const_int32(gallivm, SI_PS_CONST_SAMPLE_POSITIONS);
-	LLVMValueRef resource = build_indexed_load_const(ctx, desc, buf_index);
+	LLVMValueRef resource = ac_build_indexed_load_const(&ctx->ac, desc, buf_index);
 
 	/* offset = sample_id * 8  (8 = 2 floats containing samplepos.xy) */
 	LLVMValueRef offset0 = lp_build_mul_imm(uint_bld, sample_id, 8);
@@ -1761,7 +1629,7 @@ static void declare_system_value(
 
 		rw_buffers = LLVMGetParam(ctx->main_fn,
 					SI_PARAM_RW_BUFFERS);
-		buffer = build_indexed_load_const(ctx, rw_buffers,
+		buffer = ac_build_indexed_load_const(&ctx->ac, rw_buffers,
 		        lp_build_const_int32(gallivm, SI_HS_RING_TESS_OFFCHIP));
 
 		base = LLVMGetParam(ctx->main_fn, ctx->param_oc_lds);
@@ -1782,7 +1650,7 @@ static void declare_system_value(
 
 		slot = lp_build_const_int32(gallivm, SI_HS_CONST_DEFAULT_TESS_LEVELS);
 		buf = LLVMGetParam(ctx->main_fn, SI_PARAM_RW_BUFFERS);
-		buf = build_indexed_load_const(ctx, buf, slot);
+		buf = ac_build_indexed_load_const(&ctx->ac, buf, slot);
 		offset = decl->Semantic.Name == TGSI_SEMANTIC_DEFAULT_TESSINNER_SI ? 4 : 0;
 
 		for (i = 0; i < 4; i++)
@@ -1882,7 +1750,7 @@ static LLVMValueRef load_const_buffer_desc(struct si_shader_context *ctx, int i)
 	LLVMValueRef list_ptr = LLVMGetParam(ctx->main_fn,
 					     SI_PARAM_CONST_BUFFERS);
 
-	return build_indexed_load_const(ctx, list_ptr,
+	return ac_build_indexed_load_const(&ctx->ac, list_ptr,
 					LLVMConstInt(ctx->i32, i, 0));
 }
 
@@ -1918,7 +1786,7 @@ static LLVMValueRef fetch_constant(
 		index = get_bounded_indirect_index(ctx, &reg->DimIndirect,
 						   reg->Dimension.Index,
 						   SI_NUM_CONST_BUFFERS);
-		bufp = build_indexed_load_const(ctx, ptr, index);
+		bufp = ac_build_indexed_load_const(&ctx->ac, ptr, index);
 	} else
 		bufp = load_const_buffer_desc(ctx, buf);
 
@@ -2221,7 +2089,7 @@ static void si_llvm_emit_clipvertex(struct lp_build_tgsi_context *bld_base,
 	LLVMValueRef ptr = LLVMGetParam(ctx->main_fn, SI_PARAM_RW_BUFFERS);
 	LLVMValueRef constbuf_index = lp_build_const_int32(base->gallivm,
 							   SI_VS_CONST_CLIP_PLANES);
-	LLVMValueRef const_resource = build_indexed_load_const(ctx, ptr, constbuf_index);
+	LLVMValueRef const_resource = ac_build_indexed_load_const(&ctx->ac, ptr, constbuf_index);
 
 	for (reg_index = 0; reg_index < 2; reg_index ++) {
 		LLVMValueRef *args = pos[2 + reg_index];
@@ -2384,7 +2252,7 @@ static void si_llvm_emit_streamout(struct si_shader_context *ctx,
 			LLVMValueRef offset = lp_build_const_int32(gallivm,
 								   SI_VS_STREAMOUT_BUF0 + i);
 
-			so_buffers[i] = build_indexed_load_const(ctx, buf_ptr, offset);
+			so_buffers[i] = ac_build_indexed_load_const(&ctx->ac, buf_ptr, offset);
 
 			LLVMValueRef so_offset = LLVMGetParam(ctx->main_fn,
 							      ctx->param_streamout_offset[i]);
@@ -2627,7 +2495,7 @@ static void si_copy_tcs_inputs(struct lp_build_tgsi_context *bld_base)
 	invocation_id = unpack_param(ctx, SI_PARAM_REL_IDS, 8, 5);
 
 	rw_buffers = LLVMGetParam(ctx->main_fn, SI_PARAM_RW_BUFFERS);
-	buffer = build_indexed_load_const(ctx, rw_buffers,
+	buffer = ac_build_indexed_load_const(&ctx->ac, rw_buffers,
 	                lp_build_const_int32(gallivm, SI_HS_RING_TESS_OFFCHIP));
 
 	buffer_offset = LLVMGetParam(ctx->main_fn, ctx->param_oc_lds);
@@ -2743,7 +2611,7 @@ static void si_write_tess_factors(struct lp_build_tgsi_context *bld_base,
 	/* Get the buffer. */
 	rw_buffers = LLVMGetParam(ctx->main_fn,
 				  SI_PARAM_RW_BUFFERS);
-	buffer = build_indexed_load_const(ctx, rw_buffers,
+	buffer = ac_build_indexed_load_const(&ctx->ac, rw_buffers,
 			lp_build_const_int32(gallivm, SI_HS_RING_TESS_FACTOR));
 
 	/* Get the offset. */
@@ -3414,7 +3282,7 @@ shader_buffer_fetch_rsrc(struct si_shader_context *ctx,
 						   reg->Register.Index,
 						   SI_NUM_SHADER_BUFFERS);
 
-	return build_indexed_load_const(ctx, rsrc_ptr, index);
+	return ac_build_indexed_load_const(&ctx->ac, rsrc_ptr, index);
 }
 
 static bool tgsi_is_array_sampler(unsigned target)
@@ -3522,11 +3390,11 @@ image_fetch_rsrc(
 				     LLVMConstInt(ctx->i32, 2, 0), "");
 		index = LLVMBuildAdd(builder, index,
 				     LLVMConstInt(ctx->i32, 1, 0), "");
-		*rsrc = build_indexed_load_const(ctx, rsrc_ptr, index);
+		*rsrc = ac_build_indexed_load_const(&ctx->ac, rsrc_ptr, index);
 		return;
 	}
 
-	tmp = build_indexed_load_const(ctx, rsrc_ptr, index);
+	tmp = ac_build_indexed_load_const(&ctx->ac, rsrc_ptr, index);
 	if (dcc_off)
 		tmp = force_dcc_off(ctx, tmp);
 	*rsrc = tmp;
@@ -4366,7 +4234,7 @@ static LLVMValueRef load_sampler_desc_custom(struct si_shader_context *ctx,
 		break;
 	}
 
-	return build_indexed_load_const(ctx, list, index);
+	return ac_build_indexed_load_const(&ctx->ac, list, index);
 }
 
 static LLVMValueRef load_sampler_desc(struct si_shader_context *ctx,
@@ -5118,9 +4986,9 @@ static void si_llvm_emit_ddxy(
 	} else {
 		LLVMValueRef store_ptr, load_ptr0, load_ptr1;
 
-		store_ptr = build_gep0(ctx, ctx->lds, thread_id);
-		load_ptr0 = build_gep0(ctx, ctx->lds, tl_tid);
-		load_ptr1 = build_gep0(ctx, ctx->lds, trbl_tid);
+		store_ptr = ac_build_gep0(&ctx->ac, ctx->lds, thread_id);
+		load_ptr0 = ac_build_gep0(&ctx->ac, ctx->lds, tl_tid);
+		load_ptr1 = ac_build_gep0(&ctx->ac, ctx->lds, trbl_tid);
 
 		LLVMBuildStore(gallivm->builder, val, store_ptr);
 		tl = LLVMBuildLoad(gallivm->builder, load_ptr0, "");
@@ -5291,11 +5159,11 @@ static void build_interp_intrinsic(const struct lp_build_tgsi_action *action,
 				gallivm->builder, interp_param, uint->zero, "");
 			LLVMValueRef j = LLVMBuildExtractElement(
 				gallivm->builder, interp_param, uint->one, "");
-			emit_data->output[chan] = build_fs_interp(bld_base,
+			emit_data->output[chan] = ac_build_fs_interp(&ctx->ac,
 				llvm_chan, attr_number, params,
 				i, j);
 		} else {
-			emit_data->output[chan] = build_fs_interp_mov(bld_base,
+			emit_data->output[chan] = ac_build_fs_interp_mov(&ctx->ac,
 				lp_build_const_int32(gallivm, 2), /* P0 */
 				llvm_chan, attr_number, params);
 		}
@@ -5518,14 +5386,8 @@ static void create_meta_data(struct si_shader_context *ctx)
 {
 	struct gallivm_state *gallivm = ctx->bld_base.base.gallivm;
 
-	ctx->invariant_load_md_kind = LLVMGetMDKindIDInContext(gallivm->context,
-							       "invariant.load", 14);
 	ctx->range_md_kind = LLVMGetMDKindIDInContext(gallivm->context,
 						     "range", 5);
-	ctx->uniform_md_kind = LLVMGetMDKindIDInContext(gallivm->context,
-							"amdgpu.uniform", 14);
-
-	ctx->empty_md = LLVMMDNodeInContext(gallivm->context, NULL, 0);
 }
 
 static void declare_streamout_params(struct si_shader_context *ctx,
@@ -5540,7 +5402,7 @@ static void declare_streamout_params(struct si_shader_context *ctx,
 		if (ctx->type != PIPE_SHADER_TESS_EVAL)
 			params[ctx->param_streamout_config = (*num_params)++] = i32;
 		else
-			ctx->param_streamout_config = ctx->param_tess_offchip;
+			ctx->param_streamout_config = *num_params - 1;
 
 		params[ctx->param_streamout_write_index = (*num_params)++] = i32;
 	}
@@ -5704,10 +5566,10 @@ static void create_function(struct si_shader_context *ctx)
 
 		if (shader->key.as_es) {
 			params[ctx->param_oc_lds = num_params++] = ctx->i32;
-			params[ctx->param_tess_offchip = num_params++] = ctx->i32;
+			params[num_params++] = ctx->i32;
 			params[ctx->param_es2gs_offset = num_params++] = ctx->i32;
 		} else {
-			params[ctx->param_tess_offchip = num_params++] = ctx->i32;
+			params[num_params++] = ctx->i32;
 			declare_streamout_params(ctx, &shader->selector->so,
 						 params, ctx->i32, &num_params);
 			params[ctx->param_oc_lds = num_params++] = ctx->i32;
@@ -5863,8 +5725,7 @@ static void create_function(struct si_shader_context *ctx)
 						    LOCAL_ADDR_SPACE);
 
 	if ((ctx->type == PIPE_SHADER_VERTEX && shader->key.as_ls) ||
-	    ctx->type == PIPE_SHADER_TESS_CTRL ||
-	    ctx->type == PIPE_SHADER_TESS_EVAL)
+	    ctx->type == PIPE_SHADER_TESS_CTRL)
 		declare_tess_lds(ctx);
 }
 
@@ -5891,21 +5752,21 @@ static void preload_ring_buffers(struct si_shader_context *ctx)
 		LLVMValueRef offset = lp_build_const_int32(gallivm, ring);
 
 		ctx->esgs_ring =
-			build_indexed_load_const(ctx, buf_ptr, offset);
+			ac_build_indexed_load_const(&ctx->ac, buf_ptr, offset);
 	}
 
 	if (ctx->shader->is_gs_copy_shader) {
 		LLVMValueRef offset = lp_build_const_int32(gallivm, SI_RING_GSVS);
 
 		ctx->gsvs_ring[0] =
-			build_indexed_load_const(ctx, buf_ptr, offset);
+			ac_build_indexed_load_const(&ctx->ac, buf_ptr, offset);
 	} else if (ctx->type == PIPE_SHADER_GEOMETRY) {
 		const struct si_shader_selector *sel = ctx->shader->selector;
 		struct lp_build_context *uint = &ctx->bld_base.uint_bld;
 		LLVMValueRef offset = lp_build_const_int32(gallivm, SI_RING_GSVS);
 		LLVMValueRef base_ring;
 
-		base_ring = build_indexed_load_const(ctx, buf_ptr, offset);
+		base_ring = ac_build_indexed_load_const(&ctx->ac, buf_ptr, offset);
 
 		/* The conceptual layout of the GSVS ring is
 		 *   v0c0 .. vLv0 v0c1 .. vLc1 ..
@@ -5991,7 +5852,7 @@ static void si_llvm_emit_polygon_stipple(struct si_shader_context *ctx,
 
 	/* Load the buffer descriptor. */
 	slot = lp_build_const_int32(gallivm, SI_PS_CONST_POLY_STIPPLE);
-	desc = build_indexed_load_const(ctx, param_rw_buffers, slot);
+	desc = ac_build_indexed_load_const(&ctx->ac, param_rw_buffers, slot);
 
 	/* The stipple pattern is 32x32, each row has 32 bits. */
 	offset = LLVMBuildMul(builder, address[1],
@@ -6401,7 +6262,7 @@ int si_compile_llvm(struct si_screen *sscreen,
 
 		if (!(sscreen->b.debug_flags & (DBG_NO_IR | DBG_PREOPT_IR))) {
 			fprintf(stderr, "%s LLVM IR:\n\n", name);
-			LLVMDumpModule(mod);
+			ac_dump_module(mod);
 			fprintf(stderr, "\n");
 		}
 	}
@@ -6600,7 +6461,7 @@ si_generate_gs_copy_shader(struct si_screen *sscreen,
 	/* Dump LLVM IR before any optimization passes */
 	if (sscreen->b.debug_flags & DBG_PREOPT_IR &&
 	    r600_can_dump_shader(&sscreen->b, PIPE_SHADER_GEOMETRY))
-		LLVMDumpModule(bld_base->base.gallivm->module);
+		ac_dump_module(bld_base->base.gallivm->module);
 
 	si_llvm_finalize_module(&ctx,
 		r600_extra_shader_checks(&sscreen->b, PIPE_SHADER_GEOMETRY));
@@ -7604,7 +7465,7 @@ int si_compile_tgsi_shader(struct si_screen *sscreen,
 	/* Dump LLVM IR before any optimization passes */
 	if (sscreen->b.debug_flags & DBG_PREOPT_IR &&
 	    r600_can_dump_shader(&sscreen->b, ctx.type))
-		LLVMDumpModule(mod);
+		ac_dump_module(mod);
 
 	si_llvm_finalize_module(&ctx,
 				    r600_extra_shader_checks(&sscreen->b, ctx.type));