[2/2] ac: use 1D GEPs for descriptors and constants

Submitted by Marek Olšák on May 10, 2019, 5:20 a.m.

Details

Message ID 20190510052043.30686-2-maraeo@gmail.com
State New
Headers show
Series "Series without cover letter" ( rev: 1 ) in Mesa

Not browsing as part of any series.

Commit Message

Marek Olšák May 10, 2019, 5:20 a.m.
From: Marek Olšák <marek.olsak@amd.com>

just a cleanup
---
 src/amd/common/ac_llvm_build.c    | 15 ++++++---------
 src/amd/common/ac_nir_to_llvm.c   |  2 +-
 src/amd/vulkan/radv_nir_to_llvm.c |  8 +++++---
 3 files changed, 12 insertions(+), 13 deletions(-)

Patch hide | download patch | download mbox

diff --git a/src/amd/common/ac_llvm_build.c b/src/amd/common/ac_llvm_build.c
index 22b771db774..f8f2df52bfd 100644
--- a/src/amd/common/ac_llvm_build.c
+++ b/src/amd/common/ac_llvm_build.c
@@ -1009,21 +1009,21 @@  ac_build_gep0(struct ac_llvm_context *ctx,
 		ctx->i32_0,
 		index,
 	};
 	return LLVMBuildGEP(ctx->builder, base_ptr, indices, 2, "");
 }
 
 LLVMValueRef ac_build_pointer_add(struct ac_llvm_context *ctx, LLVMValueRef ptr,
 				  LLVMValueRef index)
 {
 	return LLVMBuildPointerCast(ctx->builder,
-				    ac_build_gep0(ctx, ptr, index),
+				    LLVMBuildGEP(ctx->builder, ptr, &index, 1, ""),
 				    LLVMTypeOf(ptr), "");
 }
 
 void
 ac_build_indexed_store(struct ac_llvm_context *ctx,
 		       LLVMValueRef base_ptr, LLVMValueRef index,
 		       LLVMValueRef value)
 {
 	LLVMBuildStore(ctx->builder, value,
 		       ac_build_gep0(ctx, base_ptr, index));
@@ -1056,27 +1056,26 @@  ac_build_indexed_store(struct ac_llvm_context *ctx,
  *
  *      ptr2 = LLVMBuildInBoundsGEP(ptr1, 32 / elemsize);
  *      sampler = load(ptr2); // becomes "s_load ptr1, 32" thanks to InBounds
  */
 static LLVMValueRef
 ac_build_load_custom(struct ac_llvm_context *ctx, LLVMValueRef base_ptr,
 		     LLVMValueRef index, bool uniform, bool invariant,
 		     bool no_unsigned_wraparound)
 {
 	LLVMValueRef pointer, result;
-	LLVMValueRef indices[2] = {ctx->i32_0, index};
 
 	if (no_unsigned_wraparound &&
 	    LLVMGetPointerAddressSpace(LLVMTypeOf(base_ptr)) == AC_ADDR_SPACE_CONST_32BIT)
-		pointer = LLVMBuildInBoundsGEP(ctx->builder, base_ptr, indices, 2, "");
+		pointer = LLVMBuildInBoundsGEP(ctx->builder, base_ptr, &index, 1, "");
 	else
-		pointer = LLVMBuildGEP(ctx->builder, base_ptr, indices, 2, "");
+		pointer = LLVMBuildGEP(ctx->builder, base_ptr, &index, 1, "");
 
 	if (uniform)
 		LLVMSetMetadata(pointer, ctx->uniform_md_kind, ctx->empty_md);
 	result = LLVMBuildLoad(ctx->builder, pointer, "");
 	if (invariant)
 		LLVMSetMetadata(result, ctx->invariant_load_md_kind, ctx->empty_md);
 	return result;
 }
 
 LLVMValueRef ac_build_load(struct ac_llvm_context *ctx, LLVMValueRef base_ptr,
@@ -2994,21 +2993,21 @@  void ac_declare_lds_as_pointer(struct ac_llvm_context *ctx)
 {
 	unsigned lds_size = ctx->chip_class >= CIK ? 65536 : 32768;
 	ctx->lds = LLVMBuildIntToPtr(ctx->builder, ctx->i32_0,
 				     LLVMPointerType(LLVMArrayType(ctx->i32, lds_size / 4), AC_ADDR_SPACE_LDS),
 				     "lds");
 }
 
 LLVMValueRef ac_lds_load(struct ac_llvm_context *ctx,
 			 LLVMValueRef dw_addr)
 {
-	return ac_build_load(ctx, ctx->lds, dw_addr);
+	return LLVMBuildLoad(ctx->builder, ac_build_gep0(ctx, ctx->lds, dw_addr), "");
 }
 
 void ac_lds_store(struct ac_llvm_context *ctx,
 		  LLVMValueRef dw_addr,
 		  LLVMValueRef value)
 {
 	value = ac_to_integer(ctx, value);
 	ac_build_indexed_store(ctx, ctx->lds,
 			       dw_addr, value);
 }
@@ -3075,28 +3074,26 @@  LLVMValueRef ac_find_lsb(struct ac_llvm_context *ctx,
 	/* TODO: We need an intrinsic to skip this conditional. */
 	/* Check for zero: */
 	return LLVMBuildSelect(ctx->builder, LLVMBuildICmp(ctx->builder,
 							   LLVMIntEQ, src0,
 							   zero, ""),
 			       LLVMConstInt(ctx->i32, -1, 0), lsb, "");
 }
 
 LLVMTypeRef ac_array_in_const_addr_space(LLVMTypeRef elem_type)
 {
-	return LLVMPointerType(LLVMArrayType(elem_type, 0),
-			       AC_ADDR_SPACE_CONST);
+	return LLVMPointerType(elem_type, AC_ADDR_SPACE_CONST);
 }
 
 LLVMTypeRef ac_array_in_const32_addr_space(LLVMTypeRef elem_type)
 {
-	return LLVMPointerType(LLVMArrayType(elem_type, 0),
-			       AC_ADDR_SPACE_CONST_32BIT);
+	return LLVMPointerType(elem_type, AC_ADDR_SPACE_CONST_32BIT);
 }
 
 static struct ac_llvm_flow *
 get_current_flow(struct ac_llvm_context *ctx)
 {
 	if (ctx->flow_depth > 0)
 		return &ctx->flow[ctx->flow_depth - 1];
 	return NULL;
 }
 
diff --git a/src/amd/common/ac_nir_to_llvm.c b/src/amd/common/ac_nir_to_llvm.c
index 151e0d0f961..682645e9b1f 100644
--- a/src/amd/common/ac_nir_to_llvm.c
+++ b/src/amd/common/ac_nir_to_llvm.c
@@ -1432,21 +1432,21 @@  static LLVMValueRef visit_load_push_constant(struct ac_nir_context *ctx,
 
 		offset -= ctx->abi->base_inline_push_consts;
 
 		if (offset + count <= ctx->abi->num_inline_push_consts) {
 			return ac_build_gather_values(&ctx->ac,
 						      ctx->abi->inline_push_consts + offset,
 						      count);
 		}
 	}
 
-	ptr = ac_build_gep0(&ctx->ac, ctx->abi->push_constants, addr);
+	ptr = LLVMBuildGEP(ctx->ac.builder, ctx->abi->push_constants, &addr, 1, "");
 
 	if (instr->dest.ssa.bit_size == 8) {
 		unsigned load_dwords = instr->dest.ssa.num_components > 1 ? 2 : 1;
 		LLVMTypeRef vec_type = LLVMVectorType(LLVMInt8TypeInContext(ctx->ac.context), 4 * load_dwords);
 		ptr = ac_cast_ptr(&ctx->ac, ptr, vec_type);
 		LLVMValueRef res = LLVMBuildLoad(ctx->ac.builder, ptr, "");
 
 		LLVMValueRef params[3];
 		if (load_dwords > 1) {
 			LLVMValueRef res_vec = LLVMBuildBitCast(ctx->ac.builder, res, LLVMVectorType(ctx->ac.i32, 2), "");
diff --git a/src/amd/vulkan/radv_nir_to_llvm.c b/src/amd/vulkan/radv_nir_to_llvm.c
index d83f0bd547f..61eca7ca280 100644
--- a/src/amd/vulkan/radv_nir_to_llvm.c
+++ b/src/amd/vulkan/radv_nir_to_llvm.c
@@ -1304,21 +1304,21 @@  radv_load_resource(struct ac_shader_abi *abi, LLVMValueRef index,
 		stride = LLVMConstInt(ctx->ac.i32, 16, false);
 	} else
 		stride = LLVMConstInt(ctx->ac.i32, layout->binding[binding].size, false);
 
 	offset = LLVMConstInt(ctx->ac.i32, base_offset, false);
 
 	if (layout->binding[binding].type != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
 		offset = ac_build_imad(&ctx->ac, index, stride, offset);
 	}
 
-	desc_ptr = ac_build_gep0(&ctx->ac, desc_ptr, offset);
+	desc_ptr = LLVMBuildGEP(ctx->ac.builder, desc_ptr, &offset, 1, "");
 	desc_ptr = ac_cast_ptr(&ctx->ac, desc_ptr, ctx->ac.v4i32);
 	LLVMSetMetadata(desc_ptr, ctx->ac.uniform_md_kind, ctx->ac.empty_md);
 
 	if (layout->binding[binding].type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
 		uint32_t desc_type = S_008F0C_DST_SEL_X(V_008F0C_SQ_SEL_X) |
 			S_008F0C_DST_SEL_Y(V_008F0C_SQ_SEL_Y) |
 			S_008F0C_DST_SEL_Z(V_008F0C_SQ_SEL_Z) |
 			S_008F0C_DST_SEL_W(V_008F0C_SQ_SEL_W) |
 			S_008F0C_NUM_FORMAT(V_008F0C_BUF_NUM_FORMAT_FLOAT) |
 			S_008F0C_DATA_FORMAT(V_008F0C_BUF_DATA_FORMAT_32);
@@ -1748,21 +1748,22 @@  radv_get_sample_pos_offset(uint32_t num_samples)
 	}
 	return sample_pos_offset;
 }
 
 static LLVMValueRef load_sample_position(struct ac_shader_abi *abi,
 					 LLVMValueRef sample_id)
 {
 	struct radv_shader_context *ctx = radv_shader_context_from_abi(abi);
 
 	LLVMValueRef result;
-	LLVMValueRef ptr = ac_build_gep0(&ctx->ac, ctx->ring_offsets, LLVMConstInt(ctx->ac.i32, RING_PS_SAMPLE_POSITIONS, false));
+	LLVMValueRef index = LLVMConstInt(ctx->ac.i32, RING_PS_SAMPLE_POSITIONS, false);
+	LLVMValueRef ptr = LLVMBuildGEP(ctx->ac.builder, ctx->ring_offsets, &index, 1, "");
 
 	ptr = LLVMBuildBitCast(ctx->ac.builder, ptr,
 			       ac_array_in_const_addr_space(ctx->ac.v2f32), "");
 
 	uint32_t sample_pos_offset =
 		radv_get_sample_pos_offset(ctx->options->key.fs.num_samples);
 
 	sample_id =
 		LLVMBuildAdd(ctx->ac.builder, sample_id,
 			     LLVMConstInt(ctx->ac.i32, sample_pos_offset, false), "");
@@ -2017,21 +2018,22 @@  static LLVMValueRef radv_get_sampler_desc(struct ac_shader_abi *abi,
 		return ac_build_gather_values(&ctx->ac, constants, 4);
 	}
 
 	assert(stride % type_size == 0);
 
 	if (!index)
 		index = ctx->ac.i32_0;
 
 	index = LLVMBuildMul(builder, index, LLVMConstInt(ctx->ac.i32, stride / type_size, 0), "");
 
-	list = ac_build_gep0(&ctx->ac, list, LLVMConstInt(ctx->ac.i32, offset, 0));
+	LLVMValueRef val_offset = LLVMConstInt(ctx->ac.i32, offset, 0);
+	list = LLVMBuildGEP(builder, list, &val_offset, 1, "");
 	list = LLVMBuildPointerCast(builder, list,
 				    ac_array_in_const32_addr_space(type), "");
 
 	return ac_build_load_to_sgpr(&ctx->ac, list, index);
 }
 
 /* For 2_10_10_10 formats the alpha is handled as unsigned by pre-vega HW.
  * so we may need to fix it up. */
 static LLVMValueRef
 adjust_vertex_fetch_alpha(struct radv_shader_context *ctx,