fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-25 08:40:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

glsl_to_nir: remove dead code

Browse source 
This code was made unused by the changes described in be2990d8fb.

NIR based Gallium drivers switched to the NIR based lowering in
efa4fc0ebd.

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Tested-by: Marge Bot <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4415>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4415>
This commit is contained in:
Timothy Arceri 2020-04-02 11:33:48 +11:00 • committed by Marge Bot
parent 191ced539a
commit d259768e62
1 changed files with 11 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

153
src/compiler/glsl/glsl_to_nir.cpp
View file

@ -1052,54 +1052,21 @@ nir_visitor::visit(ir_call *ir)
op = nir_intrinsic_image_deref_samples;
break;
case ir_intrinsic_ssbo_store:
op = nir_intrinsic_store_ssbo;
break;
case ir_intrinsic_ssbo_load:
op = nir_intrinsic_load_ssbo;
break;
case ir_intrinsic_ssbo_atomic_add:
op = ir->return_deref->type->is_integer_32_64()
? nir_intrinsic_ssbo_atomic_add : nir_intrinsic_ssbo_atomic_fadd;
break;
case ir_intrinsic_ssbo_atomic_and:
op = nir_intrinsic_ssbo_atomic_and;
break;
case ir_intrinsic_ssbo_atomic_or:
op = nir_intrinsic_ssbo_atomic_or;
break;
case ir_intrinsic_ssbo_atomic_xor:
op = nir_intrinsic_ssbo_atomic_xor;
break;
case ir_intrinsic_ssbo_atomic_min:
assert(ir->return_deref);
if (ir->return_deref->type == glsl_type::int_type)
op = nir_intrinsic_ssbo_atomic_imin;
else if (ir->return_deref->type == glsl_type::uint_type)
op = nir_intrinsic_ssbo_atomic_umin;
else if (ir->return_deref->type == glsl_type::float_type)
op = nir_intrinsic_ssbo_atomic_fmin;
else
unreachable("Invalid type");
break;
case ir_intrinsic_ssbo_atomic_max:
assert(ir->return_deref);
if (ir->return_deref->type == glsl_type::int_type)
op = nir_intrinsic_ssbo_atomic_imax;
else if (ir->return_deref->type == glsl_type::uint_type)
op = nir_intrinsic_ssbo_atomic_umax;
else if (ir->return_deref->type == glsl_type::float_type)
op = nir_intrinsic_ssbo_atomic_fmax;
else
unreachable("Invalid type");
break;
case ir_intrinsic_ssbo_atomic_exchange:
op = nir_intrinsic_ssbo_atomic_exchange;
break;
case ir_intrinsic_ssbo_atomic_comp_swap:
op = ir->return_deref->type->is_integer_32_64()
? nir_intrinsic_ssbo_atomic_comp_swap
: nir_intrinsic_ssbo_atomic_fcomp_swap;
break;
/* SSBO store/loads should only have been lowered in GLSL IR for
* non-nir drivers, NIR drivers make use of gl_nir_lower_buffers()
* instead.
*/
unreachable("Invalid operation nir doesn't want lowered ssbo "
"store/loads");
case ir_intrinsic_shader_clock:
op = nir_intrinsic_shader_clock;
break;
@ -1448,87 +1415,6 @@ nir_visitor::visit(ir_call *ir)
nir_builder_instr_insert(&b, &instr->instr);
break;
}
case nir_intrinsic_load_ssbo: {
exec_node *param = ir->actual_parameters.get_head();
ir_rvalue *block = ((ir_instruction *)param)->as_rvalue();
param = param->get_next();
ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue();
instr->src[0] = nir_src_for_ssa(evaluate_rvalue(block));
instr->src[1] = nir_src_for_ssa(evaluate_rvalue(offset));
const glsl_type *type = ir->return_deref->var->type;
instr->num_components = type->vector_elements;
intrinsic_set_std430_align(instr, type);
/* Setup destination register */
unsigned bit_size = type->is_boolean() ? 32 : glsl_get_bit_size(type);
nir_ssa_dest_init(&instr->instr, &instr->dest,
type->vector_elements, bit_size, NULL);
/* Insert the created nir instruction now since in the case of boolean
* result we will need to emit another instruction after it
*/
nir_builder_instr_insert(&b, &instr->instr);
/*
* In SSBO/UBO's, a true boolean value is any non-zero value, but we
* consider a true boolean to be ~0. Fix this up with a != 0
* comparison.
*/
if (type->is_boolean())
ret = nir_i2b(&b, &instr->dest.ssa);
break;
}
case nir_intrinsic_ssbo_atomic_add:
case nir_intrinsic_ssbo_atomic_imin:
case nir_intrinsic_ssbo_atomic_umin:
case nir_intrinsic_ssbo_atomic_imax:
case nir_intrinsic_ssbo_atomic_umax:
case nir_intrinsic_ssbo_atomic_and:
case nir_intrinsic_ssbo_atomic_or:
case nir_intrinsic_ssbo_atomic_xor:
case nir_intrinsic_ssbo_atomic_exchange:
case nir_intrinsic_ssbo_atomic_comp_swap:
case nir_intrinsic_ssbo_atomic_fadd:
case nir_intrinsic_ssbo_atomic_fmin:
case nir_intrinsic_ssbo_atomic_fmax:
case nir_intrinsic_ssbo_atomic_fcomp_swap: {
int param_count = ir->actual_parameters.length();
assert(param_count == 3 || param_count == 4);
/* Block index */
exec_node *param = ir->actual_parameters.get_head();
ir_instruction *inst = (ir_instruction *) param;
instr->src[0] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
/* Offset */
param = param->get_next();
inst = (ir_instruction *) param;
instr->src[1] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
/* data1 parameter (this is always present) */
param = param->get_next();
inst = (ir_instruction *) param;
instr->src[2] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
/* data2 parameter (only with atomic_comp_swap) */
if (param_count == 4) {
assert(op == nir_intrinsic_ssbo_atomic_comp_swap ||
op == nir_intrinsic_ssbo_atomic_fcomp_swap);
param = param->get_next();
inst = (ir_instruction *) param;
instr->src[3] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
}
/* Atomic result */
assert(ir->return_deref);
nir_ssa_dest_init(&instr->instr, &instr->dest,
ir->return_deref->type->vector_elements, 32, NULL);
nir_builder_instr_insert(&b, &instr->instr);
break;
}
case nir_intrinsic_load_shared: {
exec_node *param = ir->actual_parameters.get_head();
ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue();
@ -1881,28 +1767,6 @@ nir_visitor::visit(ir_expression *ir)
{
/* Some special cases */
switch (ir->operation) {
case ir_binop_ubo_load: {
nir_intrinsic_instr *load =
nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_ubo);
unsigned bit_size = ir->type->is_boolean() ? 32 :
glsl_get_bit_size(ir->type);
load->num_components = ir->type->vector_elements;
load->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[0]));
load->src[1] = nir_src_for_ssa(evaluate_rvalue(ir->operands[1]));
intrinsic_set_std430_align(load, ir->type);
add_instr(&load->instr, ir->type->vector_elements, bit_size);
/*
* In UBO's, a true boolean value is any non-zero value, but we consider
* a true boolean to be ~0. Fix this up with a != 0 comparison.
*/
if (ir->type->is_boolean())
this->result = nir_i2b(&b, &load->dest.ssa);
return;
}
case ir_unop_interpolate_at_centroid:
case ir_binop_interpolate_at_offset:
case ir_binop_interpolate_at_sample: {
@ -1981,6 +1845,11 @@ nir_visitor::visit(ir_expression *ir)
return;
}
case ir_binop_ubo_load:
/* UBO loads should only have been lowered in GLSL IR for non-nir drivers,
* NIR drivers make use of gl_nir_lower_buffers() instead.
*/
unreachable("Invalid operation nir doesn't want lowered ubo loads");
default:
break;
}