This creates a common function that can be shared by the tgsi
and nir backends.

v2: use LLVMBuildBitCast() directly
---
 src/gallium/drivers/radeonsi/si_shader.c          | 61 ++++++++++++++---------
 src/gallium/drivers/radeonsi/si_shader_internal.h |  6 +++
 2 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/src/gallium/drivers/radeonsi/si_shader.c 
b/src/gallium/drivers/radeonsi/si_shader.c
index ce90c7beb5..c2338089b3 100644
--- a/src/gallium/drivers/radeonsi/si_shader.c
+++ b/src/gallium/drivers/radeonsi/si_shader.c
@@ -1297,47 +1297,42 @@ static void store_output_tcs(struct 
lp_build_tgsi_context *bld_base,
        }
 
        if (reg->Register.WriteMask == 0xF && !is_tess_factor) {
                LLVMValueRef value = lp_build_gather_values(&ctx->gallivm,
                                                            values, 4);
                ac_build_buffer_store_dword(&ctx->ac, buffer, value, 4, 
buf_addr,
                                            base, 0, 1, 0, true, false);
        }
 }
 
-static LLVMValueRef fetch_input_gs(
-       struct lp_build_tgsi_context *bld_base,
-       const struct tgsi_full_src_register *reg,
-       enum tgsi_opcode_type type,
-       unsigned swizzle)
+LLVMValueRef si_llvm_load_input_gs(struct ac_shader_abi *abi,
+                                  unsigned input_index,
+                                  unsigned vtx_offset_param,
+                                  LLVMTypeRef type,
+                                  unsigned swizzle)
 {
-       struct si_shader_context *ctx = si_shader_context(bld_base);
+       struct si_shader_context *ctx = si_shader_context_from_abi(abi);
+       struct lp_build_tgsi_context *bld_base = &ctx->bld_base;
        struct si_shader *shader = ctx->shader;
        struct lp_build_context *uint = &ctx->bld_base.uint_bld;
        LLVMValueRef vtx_offset, soffset;
        struct tgsi_shader_info *info = &shader->selector->info;
-       unsigned semantic_name = info->input_semantic_name[reg->Register.Index];
-       unsigned semantic_index = 
info->input_semantic_index[reg->Register.Index];
+       unsigned semantic_name = info->input_semantic_name[input_index];
+       unsigned semantic_index = info->input_semantic_index[input_index];
        unsigned param;
        LLVMValueRef value;
 
-       if (swizzle != ~0 && semantic_name == TGSI_SEMANTIC_PRIMID)
-               return get_primitive_id(ctx, swizzle);
-
-       if (!reg->Register.Dimension)
-               return NULL;
-
        param = si_shader_io_get_unique_index(semantic_name, semantic_index);
 
        /* GFX9 has the ESGS ring in LDS. */
        if (ctx->screen->b.chip_class >= GFX9) {
-               unsigned index = reg->Dimension.Index;
+               unsigned index = vtx_offset_param;
 
                switch (index / 2) {
                case 0:
                        vtx_offset = unpack_param(ctx, 
ctx->param_gs_vtx01_offset,
                                                  index % 2 ? 16 : 0, 16);
                        break;
                case 1:
                        vtx_offset = unpack_param(ctx, 
ctx->param_gs_vtx23_offset,
                                                  index % 2 ? 16 : 0, 16);
                        break;
@@ -1345,56 +1340,76 @@ static LLVMValueRef fetch_input_gs(
                        vtx_offset = unpack_param(ctx, 
ctx->param_gs_vtx45_offset,
                                                  index % 2 ? 16 : 0, 16);
                        break;
                default:
                        assert(0);
                        return NULL;
                }
 
                vtx_offset = LLVMBuildAdd(ctx->ac.builder, vtx_offset,
                                          LLVMConstInt(ctx->i32, param * 4, 0), 
"");
-               return lds_load(bld_base, tgsi2llvmtype(bld_base, type),
-                               swizzle, vtx_offset);
+               return lds_load(bld_base, type, swizzle, vtx_offset);
        }
 
        /* GFX6: input load from the ESGS ring in memory. */
        if (swizzle == ~0) {
                LLVMValueRef values[TGSI_NUM_CHANNELS];
                unsigned chan;
                for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
-                       values[chan] = fetch_input_gs(bld_base, reg, type, 
chan);
+                       values[chan] = si_llvm_load_input_gs(abi, input_index, 
vtx_offset_param,
+                                                            type, chan);
                }
                return lp_build_gather_values(&ctx->gallivm, values,
                                              TGSI_NUM_CHANNELS);
        }
 
        /* Get the vertex offset parameter on GFX6. */
-       unsigned vtx_offset_param = reg->Dimension.Index;
        LLVMValueRef gs_vtx_offset = ctx->gs_vtx_offset[vtx_offset_param];
 
        vtx_offset = lp_build_mul_imm(uint, gs_vtx_offset, 4);
 
        soffset = LLVMConstInt(ctx->i32, (param * 4 + swizzle) * 256, 0);
 
        value = ac_build_buffer_load(&ctx->ac, ctx->esgs_ring, 1, ctx->i32_0,
                                     vtx_offset, soffset, 0, 1, 0, true, false);
-       if (tgsi_type_is_64bit(type)) {
+       if (llvm_type_is_64bit(ctx, type)) {
                LLVMValueRef value2;
                soffset = LLVMConstInt(ctx->i32, (param * 4 + swizzle + 1) * 
256, 0);
 
                value2 = ac_build_buffer_load(&ctx->ac, ctx->esgs_ring, 1,
                                              ctx->i32_0, vtx_offset, soffset,
                                              0, 1, 0, true, false);
-               return si_llvm_emit_fetch_64bit(bld_base, 
tgsi2llvmtype(bld_base, type),
-                                               value, value2);
+               return si_llvm_emit_fetch_64bit(bld_base, type, value, value2);
        }
-       return bitcast(bld_base, type, value);
+       return LLVMBuildBitCast(ctx->ac.builder, value, type, "");
+}
+
+static LLVMValueRef fetch_input_gs(
+       struct lp_build_tgsi_context *bld_base,
+       const struct tgsi_full_src_register *reg,
+       enum tgsi_opcode_type type,
+       unsigned swizzle)
+{
+       struct si_shader_context *ctx = si_shader_context(bld_base);
+       struct tgsi_shader_info *info = &ctx->shader->selector->info;
+
+       unsigned semantic_name = info->input_semantic_name[reg->Register.Index];
+       if (swizzle != ~0 && semantic_name == TGSI_SEMANTIC_PRIMID)
+               return get_primitive_id(ctx, swizzle);
+
+       if (!reg->Register.Dimension)
+               return NULL;
+
+       return si_llvm_load_input_gs(&ctx->abi, reg->Register.Index,
+                                    reg->Dimension.Index,
+                                    tgsi2llvmtype(bld_base, type),
+                                    swizzle);
 }
 
 static int lookup_interp_param_index(unsigned interpolate, unsigned location)
 {
        switch (interpolate) {
        case TGSI_INTERPOLATE_CONSTANT:
                return 0;
 
        case TGSI_INTERPOLATE_LINEAR:
                if (location == TGSI_INTERPOLATE_LOC_SAMPLE)
diff --git a/src/gallium/drivers/radeonsi/si_shader_internal.h 
b/src/gallium/drivers/radeonsi/si_shader_internal.h
index 5219aa0f1d..03cf8fa6d9 100644
--- a/src/gallium/drivers/radeonsi/si_shader_internal.h
+++ b/src/gallium/drivers/radeonsi/si_shader_internal.h
@@ -272,20 +272,26 @@ void si_llvm_optimize_module(struct si_shader_context 
*ctx);
 LLVMValueRef si_llvm_emit_fetch_64bit(struct lp_build_tgsi_context *bld_base,
                                      LLVMTypeRef type,
                                      LLVMValueRef ptr,
                                      LLVMValueRef ptr2);
 
 LLVMValueRef si_llvm_emit_fetch(struct lp_build_tgsi_context *bld_base,
                                const struct tgsi_full_src_register *reg,
                                enum tgsi_opcode_type type,
                                unsigned swizzle);
 
+LLVMValueRef si_llvm_load_input_gs(struct ac_shader_abi *abi,
+                                  unsigned input_index,
+                                  unsigned vtx_offset_param,
+                                  LLVMTypeRef type,
+                                  unsigned swizzle);
+
 void si_llvm_emit_store(struct lp_build_tgsi_context *bld_base,
                        const struct tgsi_full_instruction *inst,
                        const struct tgsi_opcode_info *info,
                        unsigned index,
                        LLVMValueRef dst[4]);
 
 /* Combine these with & instead of |. */
 #define NOOP_WAITCNT 0xf7f
 #define LGKM_CNT 0x07f
 #define VM_CNT 0xf70
-- 
2.14.3

_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev

Reply via email to