radeonsi/nir: always lower ballot masks as 64-bit, codegen handles it

[mesa.git] / src / gallium / drivers / radeonsi / si_shader.c

diff --git a/src/gallium/drivers/radeonsi/si_shader.c b/src/gallium/drivers/radeonsi/si_shader.c
index 69466361d41629c5aacd0fabad675c2e41f332d4..64d7ec08348f9f7454b12e2ece0351ff13c628c2 100644 (file)
--- a/src/gallium/drivers/radeonsi/si_shader.c
+++ b/src/gallium/drivers/radeonsi/si_shader.c
@@ -50,7 +50,8 @@ static const char scratch_rsrc_dword1_symbol[] =
 static void si_init_shader_ctx(struct si_shader_context *ctx,
                               struct si_screen *sscreen,
                               struct ac_llvm_compiler *compiler,
-                              unsigned wave_size);
+                              unsigned wave_size,
+                              bool nir);
 
 static void si_llvm_emit_barrier(const struct lp_build_tgsi_action *action,
                                 struct lp_build_tgsi_context *bld_base,
@@ -1977,12 +1978,44 @@ static LLVMValueRef load_tess_level(struct si_shader_context *ctx,
 
 }
 
+static LLVMValueRef load_tess_level_default(struct si_shader_context *ctx,
+                                           unsigned semantic_name)
+{
+       LLVMValueRef buf, slot, val[4];
+       int i, offset;
+
+       slot = LLVMConstInt(ctx->i32, SI_HS_CONST_DEFAULT_TESS_LEVELS, 0);
+       buf = LLVMGetParam(ctx->main_fn, ctx->param_rw_buffers);
+       buf = ac_build_load_to_sgpr(&ctx->ac, buf, slot);
+       offset = semantic_name == TGSI_SEMANTIC_TESS_DEFAULT_INNER_LEVEL ? 4 : 0;
+
+       for (i = 0; i < 4; i++)
+               val[i] = buffer_load_const(ctx, buf,
+                                          LLVMConstInt(ctx->i32, (offset + i) * 4, 0));
+       return ac_build_gather_values(&ctx->ac, val, 4);
+}
+
 static LLVMValueRef si_load_tess_level(struct ac_shader_abi *abi,
-                                      unsigned varying_id)
+                                      unsigned varying_id,
+                                      bool load_default_state)
 {
        struct si_shader_context *ctx = si_shader_context_from_abi(abi);
        unsigned semantic_name;
 
+       if (load_default_state) {
+               switch (varying_id) {
+               case VARYING_SLOT_TESS_LEVEL_INNER:
+                       semantic_name = TGSI_SEMANTIC_TESS_DEFAULT_INNER_LEVEL;
+                       break;
+               case VARYING_SLOT_TESS_LEVEL_OUTER:
+                       semantic_name = TGSI_SEMANTIC_TESS_DEFAULT_OUTER_LEVEL;
+                       break;
+               default:
+                       unreachable("unknown tess level");
+               }
+               return load_tess_level_default(ctx, semantic_name);
+       }
+
        switch (varying_id) {
        case VARYING_SLOT_TESS_LEVEL_INNER:
                semantic_name = TGSI_SEMANTIC_TESSINNER;
@@ -2118,21 +2151,8 @@ void si_load_system_value(struct si_shader_context *ctx,
 
        case TGSI_SEMANTIC_TESS_DEFAULT_OUTER_LEVEL:
        case TGSI_SEMANTIC_TESS_DEFAULT_INNER_LEVEL:
-       {
-               LLVMValueRef buf, slot, val[4];
-               int i, offset;
-
-               slot = LLVMConstInt(ctx->i32, SI_HS_CONST_DEFAULT_TESS_LEVELS, 0);
-               buf = LLVMGetParam(ctx->main_fn, ctx->param_rw_buffers);
-               buf = ac_build_load_to_sgpr(&ctx->ac, buf, slot);
-               offset = decl->Semantic.Name == TGSI_SEMANTIC_TESS_DEFAULT_INNER_LEVEL ? 4 : 0;
-
-               for (i = 0; i < 4; i++)
-                       val[i] = buffer_load_const(ctx, buf,
-                                                  LLVMConstInt(ctx->i32, (offset + i) * 4, 0));
-               value = ac_build_gather_values(&ctx->ac, val, 4);
+               value = load_tess_level_default(ctx, decl->Semantic.Name);
                break;
-       }
 
        case TGSI_SEMANTIC_PRIMID:
                value = si_get_primitive_id(ctx, 0);
@@ -4440,22 +4460,6 @@ void si_create_function(struct si_shader_context *ctx,
        LLVMAddTargetDependentFunctionAttr(ctx->main_fn,
                                           "no-signed-zeros-fp-math",
                                           "true");
-
-       if (ctx->screen->debug_flags & DBG(UNSAFE_MATH)) {
-               /* These were copied from some LLVM test. */
-               LLVMAddTargetDependentFunctionAttr(ctx->main_fn,
-                                                  "less-precise-fpmad",
-                                                  "true");
-               LLVMAddTargetDependentFunctionAttr(ctx->main_fn,
-                                                  "no-infs-fp-math",
-                                                  "true");
-               LLVMAddTargetDependentFunctionAttr(ctx->main_fn,
-                                                  "no-nans-fp-math",
-                                                  "true");
-               LLVMAddTargetDependentFunctionAttr(ctx->main_fn,
-                                                  "unsafe-fp-math",
-                                                  "true");
-       }
 }
 
 static void declare_streamout_params(struct si_shader_context *ctx,
@@ -5722,7 +5726,8 @@ si_generate_gs_copy_shader(struct si_screen *sscreen,
        shader->is_gs_copy_shader = true;
 
        si_init_shader_ctx(&ctx, sscreen, compiler,
-                          si_get_wave_size(sscreen, PIPE_SHADER_VERTEX, false, false));
+                          si_get_wave_size(sscreen, PIPE_SHADER_VERTEX, false, false),
+                          false);
        ctx.shader = shader;
        ctx.type = PIPE_SHADER_VERTEX;
 
@@ -5986,11 +5991,13 @@ static void si_dump_shader_key(const struct si_shader *shader, FILE *f)
 static void si_init_shader_ctx(struct si_shader_context *ctx,
                               struct si_screen *sscreen,
                               struct ac_llvm_compiler *compiler,
-                              unsigned wave_size)
+                              unsigned wave_size,
+                              bool nir)
 {
        struct lp_build_tgsi_context *bld_base;
 
-       si_llvm_context_init(ctx, sscreen, compiler, wave_size);
+       si_llvm_context_init(ctx, sscreen, compiler, wave_size,
+                            nir ? 64 : wave_size);
 
        bld_base = &ctx->bld_base;
        bld_base->emit_fetch_funcs[TGSI_FILE_CONSTANT] = fetch_constant;
@@ -6086,6 +6093,7 @@ static bool si_compile_tgsi_main(struct si_shader_context *ctx)
        case PIPE_SHADER_TESS_CTRL:
                bld_base->emit_fetch_funcs[TGSI_FILE_INPUT] = fetch_input_tcs;
                ctx->abi.load_tess_varyings = si_nir_load_tcs_varyings;
+               ctx->abi.load_tess_level = si_load_tess_level;
                bld_base->emit_fetch_funcs[TGSI_FILE_OUTPUT] = fetch_output_tcs;
                bld_base->emit_store = store_output_tcs;
                ctx->abi.store_tcs_outputs = si_nir_store_output_tcs;
@@ -6935,8 +6943,9 @@ int si_compile_tgsi_shader(struct si_screen *sscreen,
                si_dump_streamout(&sel->so);
        }
 
-       si_init_shader_ctx(&ctx, sscreen, compiler, si_get_shader_wave_size(shader));
-       si_llvm_context_set_tgsi(&ctx, shader);
+       si_init_shader_ctx(&ctx, sscreen, compiler, si_get_shader_wave_size(shader),
+                          sel->nir != NULL);
+       si_llvm_context_set_ir(&ctx, shader);
 
        memset(shader->info.vs_output_param_offset, AC_EXP_PARAM_UNDEFINED,
               sizeof(shader->info.vs_output_param_offset));
@@ -6993,7 +7002,7 @@ int si_compile_tgsi_shader(struct si_screen *sscreen,
                        shader_ls.key.mono = shader->key.mono;
                        shader_ls.key.opt = shader->key.opt;
                        shader_ls.is_monolithic = true;
-                       si_llvm_context_set_tgsi(&ctx, &shader_ls);
+                       si_llvm_context_set_ir(&ctx, &shader_ls);
 
                        if (!si_compile_tgsi_main(&ctx)) {
                                si_llvm_dispose(&ctx);
@@ -7060,7 +7069,7 @@ int si_compile_tgsi_shader(struct si_screen *sscreen,
                        shader_es.key.mono = shader->key.mono;
                        shader_es.key.opt = shader->key.opt;
                        shader_es.is_monolithic = true;
-                       si_llvm_context_set_tgsi(&ctx, &shader_es);
+                       si_llvm_context_set_ir(&ctx, &shader_es);
 
                        if (!si_compile_tgsi_main(&ctx)) {
                                si_llvm_dispose(&ctx);
@@ -7315,7 +7324,8 @@ si_get_shader_part(struct si_screen *sscreen,
        struct si_shader_context ctx;
        si_init_shader_ctx(&ctx, sscreen, compiler,
                           si_get_wave_size(sscreen, type, shader.key.as_ngg,
-                                           shader.key.as_es));
+                                           shader.key.as_es),
+                          false);
        ctx.shader = &shader;
        ctx.type = type;