KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nir: use intrinsic builders 

Signed-off-by: Christian Gmeiner <christian.gmeiner@gmail.com>
Reviewed-by: Eric Anholt <eric@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8295>
This commit is contained in:
Christian Gmeiner 2021-01-01 20:37:53 +01:00 committed by Marge Bot
parent 02553d96c8
commit c0fe111d64
11 changed files with 68 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/compiler/nir/nir_lower_alpha_test.c
View File

@ -109,12 +109,7 @@ nir_lower_alpha_test(nir_shader *shader, enum compare_func func,
nir_ssa_def *condition =
nir_compare_func(&b, func, alpha, alpha_ref);
nir_intrinsic_instr *discard =
nir_intrinsic_instr_create(b.shader,
nir_intrinsic_discard_if);
discard->num_components = 1;
discard->src[0] = nir_src_for_ssa(nir_inot(&b, condition));
nir_builder_instr_insert(&b, &discard->instr);
nir_discard_if(&b, nir_inot(&b, condition));
shader->info.fs.uses_discard = true;
}
}

45
src/compiler/nir/nir_lower_clip.c
View File

@ -94,49 +94,35 @@ create_clipdist_vars(nir_shader *shader, nir_variable **io_vars,
static void
store_clipdist_output(nir_builder *b, nir_variable *out, nir_ssa_def **val)
{
nir_intrinsic_instr *store;
store = nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_output);
store->num_components = 4;
nir_intrinsic_set_base(store, out->data.driver_location);
nir_intrinsic_set_write_mask(store, 0xf);
nir_io_semantics semantics = {
.location = out->data.location,
.num_slots = 1,
};
nir_intrinsic_set_io_semantics(store, semantics);
store->src[0].ssa = nir_vec4(b, val[0], val[1], val[2], val[3]);
store->src[0].is_ssa = true;
store->src[1] = nir_src_for_ssa(nir_imm_int(b, 0));
nir_builder_instr_insert(b, &store->instr);
nir_store_output(b, nir_vec4(b, val[0], val[1], val[2], val[3]), nir_imm_int(b, 0),
.base = out->data.driver_location,
.write_mask = 0xf,
.io_semantics = semantics);
}
static void
load_clipdist_input(nir_builder *b, nir_variable *in, int location_offset,
nir_ssa_def **val)
{
nir_intrinsic_instr *load;
load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_input);
load->num_components = 4;
nir_intrinsic_set_base(load, in->data.driver_location + location_offset);
nir_io_semantics semantics = {
.location = in->data.location,
.num_slots = 1,
};
nir_intrinsic_set_io_semantics(load, semantics);
load->src[0] = nir_src_for_ssa(nir_imm_int(b, 0));
nir_ssa_dest_init(&load->instr, &load->dest, 4, 32, NULL);
nir_builder_instr_insert(b, &load->instr);
nir_ssa_def *load =
nir_load_input(b, 4, 32, nir_imm_int(b, 0),
.base = in->data.driver_location + location_offset,
.io_semantics = semantics);
val[0] = nir_channel(b, &load->dest.ssa, 0);
val[1] = nir_channel(b, &load->dest.ssa, 1);
val[2] = nir_channel(b, &load->dest.ssa, 2);
val[3] = nir_channel(b, &load->dest.ssa, 3);
val[0] = nir_channel(b, load, 0);
val[1] = nir_channel(b, load, 1);
val[2] = nir_channel(b, load, 2);
val[3] = nir_channel(b, load, 3);
}
static nir_ssa_def *
@ -449,15 +435,10 @@ lower_clip_fs(nir_function_impl *impl, unsigned ucp_enables,
for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) {
if (ucp_enables & (1 << plane)) {
nir_intrinsic_instr *discard;
nir_ssa_def *cond;
cond = nir_flt(&b, clipdist[plane], nir_imm_float(&b, 0.0));
discard = nir_intrinsic_instr_create(b.shader,
nir_intrinsic_discard_if);
discard->src[0] = nir_src_for_ssa(cond);
nir_builder_instr_insert(&b, &discard->instr);
nir_discard_if(&b, cond);
b.shader->info.fs.uses_discard = true;
}

18
src/compiler/nir/nir_lower_interpolation.c
View File

@ -102,20 +102,12 @@ nir_lower_interpolation_block(nir_block *block, nir_builder *b,
nir_ssa_def *comps[NIR_MAX_VEC_COMPONENTS];
for (int i = 0; i < intr->num_components; i++) {
nir_intrinsic_instr *load_iid =
nir_intrinsic_instr_create(b->shader,
nir_intrinsic_load_fs_input_interp_deltas);
load_iid->src[0] = nir_src_for_ssa(intr->src[1].ssa);
nir_ssa_dest_init(&load_iid->instr, &load_iid->dest,
3, 32, NULL);
nir_intrinsic_set_base(load_iid, nir_intrinsic_base(intr));
nir_intrinsic_set_component(load_iid,
nir_intrinsic_component(intr) + i);
nir_intrinsic_set_io_semantics(load_iid,
nir_intrinsic_io_semantics(intr));
nir_builder_instr_insert(b, &load_iid->instr);
nir_ssa_def *iid =
nir_load_fs_input_interp_deltas(b, 32, intr->src[1].ssa,
.base = nir_intrinsic_base(intr),
.component = (nir_intrinsic_component(intr) + i),
.io_semantics = nir_intrinsic_io_semantics(intr));
nir_ssa_def *iid = &load_iid->dest.ssa;
nir_ssa_def *bary = intr->src[0].ssa;
nir_ssa_def *val;

27
src/compiler/nir/nir_lower_io.c
View File

@ -558,32 +558,25 @@ lower_interpolate_at(nir_intrinsic_instr *intrin, struct lower_io_state *state,
nir_builder_instr_insert(b, &bary_setup->instr);
nir_intrinsic_instr *load =
nir_intrinsic_instr_create(state->builder.shader,
nir_intrinsic_load_interpolated_input);
load->num_components = intrin->num_components;
nir_intrinsic_set_base(load, var->data.driver_location);
nir_intrinsic_set_component(load, component);
nir_io_semantics semantics = {0};
semantics.location = var->data.location;
semantics.num_slots = get_number_of_slots(state, var);
semantics.medium_precision =
var->data.precision == GLSL_PRECISION_MEDIUM ||
var->data.precision == GLSL_PRECISION_LOW;
nir_intrinsic_set_io_semantics(load, semantics);
load->src[0] = nir_src_for_ssa(&bary_setup->dest.ssa);
load->src[1] = nir_src_for_ssa(offset);
assert(intrin->dest.is_ssa);
nir_ssa_dest_init(&load->instr, &load->dest,
intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size, NULL);
nir_builder_instr_insert(b, &load->instr);
nir_ssa_def *load =
nir_load_interpolated_input(&state->builder,
intrin->dest.ssa.num_components,
intrin->dest.ssa.bit_size,
&bary_setup->dest.ssa,
offset,
.base = var->data.driver_location,
.component = component,
.io_semantics = semantics);
return &load->dest.ssa;
return load;
}
static bool

40
src/compiler/nir/nir_lower_passthrough_edgeflags.c
View File

@ -44,40 +44,28 @@ lower_impl(nir_function_impl *impl)
util_bitcount64(shader->info.outputs_written));
/* Load an edge flag. */
nir_intrinsic_instr *load =
nir_intrinsic_instr_create(shader, nir_intrinsic_load_input);
load->num_components = 1;
load->src[0] = nir_src_for_ssa(nir_imm_int(&b, 0));
nir_ssa_dest_init(&load->instr, &load->dest,
load->num_components, 32, NULL);
nir_intrinsic_set_base(load, shader->num_inputs++);
nir_intrinsic_set_component(load, 0);
nir_intrinsic_set_dest_type(load, nir_type_float32);
nir_io_semantics load_sem = {0};
load_sem.location = VERT_ATTRIB_EDGEFLAG;
load_sem.num_slots = 1;
nir_intrinsic_set_io_semantics(load, load_sem);
nir_builder_instr_insert(&b, &load->instr);
nir_ssa_def *load =
nir_load_input(&b, 1, 32, nir_imm_int(&b, 0),
.base = shader->num_inputs++,
.component = 0,
.dest_type = nir_type_float32,
.io_semantics = load_sem);
/* Store an edge flag. */
nir_intrinsic_instr *store =
nir_intrinsic_instr_create(shader, nir_intrinsic_store_output);
store->num_components = 1;
store->src[0] = nir_src_for_ssa(&load->dest.ssa);
store->src[1] = nir_src_for_ssa(nir_imm_int(&b, 0));
nir_intrinsic_set_base(store, shader->num_outputs++);
nir_intrinsic_set_component(store, 0);
nir_intrinsic_set_src_type(store, nir_type_float32);
nir_intrinsic_set_write_mask(store, 0x1);
nir_io_semantics semantics = {0};
semantics.location = VARYING_SLOT_EDGE;
semantics.num_slots = 1;
nir_intrinsic_set_io_semantics(store, semantics);
nir_builder_instr_insert(&b, &store->instr);
nir_store_output(&b, load, nir_imm_int(&b, 0),
.base = shader->num_outputs++,
.component = 0,
.io_semantics = semantics,
.src_type = nir_type_float32,
.write_mask = 0x1);
nir_metadata_preserve(impl, nir_metadata_block_index |
nir_metadata_dominance);

12
src/compiler/nir/nir_lower_two_sided_color.c
View File

@ -86,16 +86,8 @@ create_face_input(nir_shader *shader)
static nir_ssa_def *
load_input(nir_builder *b, nir_variable *in)
{
nir_intrinsic_instr *load;
load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_input);
load->num_components = 4;
nir_intrinsic_set_base(load, in->data.driver_location);
load->src[0] = nir_src_for_ssa(nir_imm_int(b, 0));
nir_ssa_dest_init(&load->instr, &load->dest, 4, 32, NULL);
nir_builder_instr_insert(b, &load->instr);
return &load->dest.ssa;
return nir_load_input(b, 4, 32, nir_imm_int(b, 0),
.base = in->data.driver_location);
}
static int

12
src/compiler/nir/nir_opt_intrinsics.c
View File

@ -74,17 +74,9 @@ try_opt_bcsel_of_shuffle(nir_builder *b, nir_alu_instr *alu)
return NULL;
nir_ssa_def *index = nir_bcsel(b, alu->src[0].src.ssa, index1, index2);
nir_intrinsic_instr *shuffle =
nir_intrinsic_instr_create(b->shader, nir_intrinsic_shuffle);
shuffle->src[0] = nir_src_for_ssa(index);
shuffle->src[1] = nir_src_for_ssa(data1);
shuffle->num_components = alu->dest.dest.ssa.num_components;
nir_ssa_dest_init(&shuffle->instr, &shuffle->dest,
alu->dest.dest.ssa.num_components,
alu->dest.dest.ssa.bit_size, NULL);
nir_builder_instr_insert(b, &shuffle->instr);
nir_ssa_def *shuffle = nir_shuffle(b, index, data1);
return &shuffle->dest.ssa;
return shuffle;
}
static bool

25
src/compiler/nir/nir_opt_large_constants.c
View File

@ -80,26 +80,23 @@ build_constant_load(nir_builder *b, nir_deref_instr *deref,
UNUSED unsigned deref_size, deref_align;
size_align(deref->type, &deref_size, &deref_align);
nir_intrinsic_instr *load =
nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_constant);
load->num_components = num_components;
nir_intrinsic_set_base(load, var->data.location);
nir_intrinsic_set_range(load, var_size);
nir_intrinsic_set_align(load, deref_align, 0);
load->src[0] = nir_src_for_ssa(nir_build_deref_offset(b, deref, size_align));
nir_ssa_dest_init(&load->instr, &load->dest,
num_components, bit_size, NULL);
nir_builder_instr_insert(b, &load->instr);
nir_ssa_def *src = nir_build_deref_offset(b, deref, size_align);
nir_ssa_def *load =
nir_load_constant(b, num_components, bit_size, src,
.base = var->data.location,
.range = var_size,
.align_mul = deref_align,
.align_offset = 0);
if (load->dest.ssa.bit_size < 8) {
if (load->bit_size < 8) {
/* Booleans are special-cased to be 32-bit */
assert(glsl_type_is_boolean(deref->type));
assert(deref_size == num_components * 4);
load->dest.ssa.bit_size = 32;
return nir_b2b1(b, &load->dest.ssa);
load->bit_size = 32;
return nir_b2b1(b, load);
} else {
assert(deref_size == num_components * bit_size / 8);
return &load->dest.ssa;
return load;
}
}

24
src/compiler/nir/tests/load_store_vectorizer_tests.cpp
View File

@ -309,12 +309,8 @@ nir_load_store_vectorize_test::create_store(
void nir_load_store_vectorize_test::create_shared_load(
nir_deref_instr *deref, uint32_t id, unsigned bit_size, unsigned components)
{
nir_intrinsic_instr *load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_deref);
nir_ssa_dest_init(&load->instr, &load->dest, components, bit_size, NULL);
load->num_components = components;
load->src[0] = nir_src_for_ssa(&deref->dest.ssa);
nir_builder_instr_insert(b, &load->instr);
nir_alu_instr *mov = nir_instr_as_alu(nir_mov(b, &load->dest.ssa)->parent_instr);
nir_ssa_def *load = nir_load_deref(b, deref);
nir_alu_instr *mov = nir_instr_as_alu(nir_mov(b, load)->parent_instr);
movs[id] = mov;
loads[id] = &mov->src[0];
}
@ -328,13 +324,7 @@ void nir_load_store_vectorize_test::create_shared_store(
values[i] = nir_const_value_for_raw_uint((id << 4) | i, bit_size);
nir_ssa_def *value = nir_build_imm(b, components, bit_size, values);
nir_intrinsic_instr *store = nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_deref);
nir_ssa_dest_init(&store->instr, &store->dest, components, bit_size, NULL);
store->num_components = components;
store->src[0] = nir_src_for_ssa(&deref->dest.ssa);
store->src[1] = nir_src_for_ssa(value);
nir_intrinsic_set_write_mask(store, wrmask & ((1 << components) - 1));
nir_builder_instr_insert(b, &store->instr);
nir_store_deref(b, deref, value, wrmask & ((1 << components) - 1));
}
bool nir_load_store_vectorize_test::test_alu(nir_instr *instr, nir_op op)
@ -868,7 +858,7 @@ TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_memory_barrier_shared)
TEST_F(nir_load_store_vectorize_test, ssbo_store_adjacent_discard)
{
create_store(nir_var_mem_ssbo, 0, 0, 0x1);
nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_discard)->instr);
nir_discard(b);
create_store(nir_var_mem_ssbo, 0, 4, 0x2);
nir_validate_shader(b->shader, NULL);
@ -882,7 +872,7 @@ TEST_F(nir_load_store_vectorize_test, ssbo_store_adjacent_discard)
TEST_F(nir_load_store_vectorize_test, ssbo_store_adjacent_demote)
{
create_store(nir_var_mem_ssbo, 0, 0, 0x1);
nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_demote)->instr);
nir_demote(b);
create_store(nir_var_mem_ssbo, 0, 4, 0x2);
nir_validate_shader(b->shader, NULL);
@ -896,7 +886,7 @@ TEST_F(nir_load_store_vectorize_test, ssbo_store_adjacent_demote)
TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_discard)
{
create_load(nir_var_mem_ssbo, 0, 0, 0x1);
nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_discard)->instr);
nir_discard(b);
create_load(nir_var_mem_ssbo, 0, 4, 0x2);
nir_validate_shader(b->shader, NULL);
@ -910,7 +900,7 @@ TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_discard)
TEST_F(nir_load_store_vectorize_test, ssbo_load_adjacent_demote)
{
create_load(nir_var_mem_ssbo, 0, 0, 0x1);
nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_demote)->instr);
nir_demote(b);
create_load(nir_var_mem_ssbo, 0, 4, 0x2);
nir_validate_shader(b->shader, NULL);

2
src/compiler/nir/tests/vars_tests.cpp
View File

@ -1586,7 +1586,7 @@ TEST_F(nir_dead_write_vars_test, DISABLED_unrelated_barrier_in_two_blocks)
/* Emit vertex will ensure writes to output variables are considered used,
* but should not affect other types of variables. */
nir_builder_instr_insert(b, &nir_intrinsic_instr_create(b->shader, nir_intrinsic_emit_vertex)->instr);
nir_emit_vertex(b);
nir_store_var(b, out, nir_load_var(b, v[2]), 1);
nir_store_var(b, v[0], nir_load_var(b, v[2]), 1);

8
src/gallium/auxiliary/nir/nir_draw_helpers.c
View File

@ -90,9 +90,7 @@ nir_lower_pstipple_block(nir_block *block,
nir_builder_instr_insert(b, &tex->instr);
nir_ssa_def *condition = nir_f2b32(b, nir_channel(b, &tex->dest.ssa, 3));
nir_intrinsic_instr *discard = nir_intrinsic_instr_create(b->shader, nir_intrinsic_discard_if);
discard->src[0] = nir_src_for_ssa(condition);
nir_builder_instr_insert(b, &discard->instr);
nir_discard_if(b, condition);
b->shader->info.fs.uses_discard = true;
}
@ -300,9 +298,7 @@ nir_lower_aapoint_impl(nir_function_impl *impl,
nir_ssa_def *chan_val_one = nir_channel(b, aainput, 3);
nir_ssa_def *comp = nir_flt32(b, chan_val_one, dist);
nir_intrinsic_instr *discard = nir_intrinsic_instr_create(b->shader, nir_intrinsic_discard_if);
discard->src[0] = nir_src_for_ssa(comp);
nir_builder_instr_insert(b, &discard->instr);
nir_discard_if(b, comp);
b->shader->info.fs.uses_discard = true;
/* compute coverage factor = (1-d)/(1-k) */