class nir_visitor : public ir_visitor
{
public:
- nir_visitor(nir_shader *shader, bool supports_ints);
+ nir_visitor(nir_shader *shader, gl_shader_stage stage);
~nir_visitor();
virtual void visit(ir_variable *);
bool supports_ints;
nir_shader *shader;
+ gl_shader_stage stage;
nir_function_impl *impl;
exec_list *cf_node_list;
nir_instr *result; /* result of the expression tree last visited */
+ nir_deref_var *evaluate_deref(nir_instr *mem_ctx, ir_instruction *ir);
+
/* the head of the dereference chain we're creating */
nir_deref_var *deref_head;
/* the tail of the dereference chain we're creating */
}; /* end of anonymous namespace */
nir_shader *
-glsl_to_nir(exec_list *ir, _mesa_glsl_parse_state *state,
- bool native_integers)
+glsl_to_nir(struct gl_shader *sh, const nir_shader_compiler_options *options)
{
- nir_shader *shader = nir_shader_create(NULL);
-
- if (state) {
- shader->num_user_structures = state->num_user_structures;
- shader->user_structures = ralloc_array(shader, glsl_type *,
- shader->num_user_structures);
- memcpy(shader->user_structures, state->user_structures,
- shader->num_user_structures * sizeof(glsl_type *));
- } else {
- shader->num_user_structures = 0;
- shader->user_structures = NULL;
- }
+ nir_shader *shader = nir_shader_create(NULL, options);
- nir_visitor v1(shader, native_integers);
+ nir_visitor v1(shader, sh->Stage);
nir_function_visitor v2(&v1);
- v2.run(ir);
- visit_exec_list(ir, &v1);
+ v2.run(sh->ir);
+ visit_exec_list(sh->ir, &v1);
return shader;
}
-nir_visitor::nir_visitor(nir_shader *shader, bool supports_ints)
+nir_visitor::nir_visitor(nir_shader *shader, gl_shader_stage stage)
{
- this->supports_ints = supports_ints;
+ this->supports_ints = shader->options->native_integers;
this->shader = shader;
+ this->stage = stage;
this->is_global = true;
this->var_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
_mesa_key_pointer_equal);
_mesa_hash_table_destroy(this->overload_table, NULL);
}
+nir_deref_var *
+nir_visitor::evaluate_deref(nir_instr *mem_ctx, ir_instruction *ir)
+{
+ ir->accept(this);
+ ralloc_steal(mem_ctx, this->deref_head);
+ return this->deref_head;
+}
+
static nir_constant *
constant_copy(ir_constant *ir, void *mem_ctx)
{
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
return ret;
var->data.centroid = ir->data.centroid;
var->data.sample = ir->data.sample;
var->data.invariant = ir->data.invariant;
+ var->data.location = ir->data.location;
switch(ir->data.mode) {
case ir_var_auto:
break;
case ir_var_shader_in:
- var->data.mode = nir_var_shader_in;
+ if (stage == MESA_SHADER_FRAGMENT &&
+ ir->data.location == VARYING_SLOT_FACE) {
+ /* For whatever reason, GLSL IR makes gl_FrontFacing an input */
+ var->data.location = SYSTEM_VALUE_FRONT_FACE;
+ var->data.mode = nir_var_system_value;
+ } else {
+ var->data.mode = nir_var_shader_in;
+ }
break;
case ir_var_shader_out:
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
var->data.interpolation = ir->data.interpolation;
var->data.depth_layout = nir_depth_layout_unchanged;
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
- var->data.location = ir->data.location;
var->data.index = ir->data.index;
var->data.binding = ir->data.binding;
/* XXX Get rid of buffer_index */
var->state_slots = NULL;
}
- var->constant_value = constant_copy(ir->constant_value, var);
var->constant_initializer = constant_copy(ir->constant_initializer, var);
var->interface_type = ir->get_interface_type();
break;
case nir_var_shader_in:
- _mesa_hash_table_insert(shader->inputs, var->name, var);
+ exec_list_push_tail(&shader->inputs, &var->node);
break;
case nir_var_shader_out:
- _mesa_hash_table_insert(shader->outputs, var->name, var);
+ exec_list_push_tail(&shader->outputs, &var->node);
break;
case nir_var_uniform:
- _mesa_hash_table_insert(shader->uniforms, var->name, var);
+ exec_list_push_tail(&shader->uniforms, &var->node);
break;
case nir_var_system_value:
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
_mesa_hash_table_insert(var_table, ir, var);
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
overload->params[i].type = param->type;
* discards will be immediately followed by a return.
*/
- nir_intrinsic_instr *discard =
- nir_intrinsic_instr_create(this->shader, nir_intrinsic_discard);
+ nir_intrinsic_instr *discard;
+ if (ir->condition) {
+ discard = nir_intrinsic_instr_create(this->shader,
+ nir_intrinsic_discard_if);
+ discard->src[0] = evaluate_rvalue(ir->condition);
+ } else {
+ discard = nir_intrinsic_instr_create(this->shader, nir_intrinsic_discard);
+ }
nir_instr_insert_after_cf_list(this->cf_node_list, &discard->instr);
}
type = nir_jump_continue;
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
nir_jump_instr *instr = nir_jump_instr_create(this->shader, type);
nir_visitor::visit(ir_return *ir)
{
if (ir->value != NULL) {
- ir->value->accept(this);
nir_intrinsic_instr *copy =
nir_intrinsic_instr_create(this->shader, nir_intrinsic_copy_var);
- copy->variables[0] = nir_deref_var_create(this->shader,
- this->impl->return_var);
- copy->variables[1] = this->deref_head;
+ copy->variables[0] = nir_deref_var_create(copy, this->impl->return_var);
+ copy->variables[1] = evaluate_deref(©->instr, ir->value);
}
nir_jump_instr *instr = nir_jump_instr_create(this->shader, nir_jump_return);
} else if (strcmp(ir->callee_name(), "__intrinsic_atomic_predecrement") == 0) {
op = nir_intrinsic_atomic_counter_dec_var;
} else {
- assert(0);
+ unreachable("not reached");
}
nir_intrinsic_instr *instr = nir_intrinsic_instr_create(shader, op);
ir_dereference *param =
(ir_dereference *) ir->actual_parameters.get_head();
- param->accept(this);
- instr->variables[0] = this->deref_head;
- instr->dest.is_ssa = true;
- nir_ssa_def_init(&instr->instr, &instr->dest.ssa, 1, NULL);
+ instr->variables[0] = evaluate_deref(&instr->instr, param);
+ nir_ssa_dest_init(&instr->instr, &instr->dest, 1, NULL);
nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
nir_intrinsic_instr_create(shader, nir_intrinsic_store_var);
store_instr->num_components = 1;
- ir->return_deref->accept(this);
- store_instr->variables[0] = this->deref_head;
+ store_instr->variables[0] = evaluate_deref(&store_instr->instr, ir->return_deref);
store_instr->src[0].is_ssa = true;
store_instr->src[0].ssa = &instr->dest.ssa;
unsigned i = 0;
foreach_in_list(ir_dereference, param, &ir->actual_parameters) {
- param->accept(this);
- instr->params[i] = this->deref_head;
+ instr->params[i] = evaluate_deref(&instr->instr, param);
i++;
}
- ir->return_deref->accept(this);
- instr->return_deref = this->deref_head;
+ instr->return_deref = evaluate_deref(&instr->instr, ir->return_deref);
nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
}
nir_intrinsic_instr *copy =
nir_intrinsic_instr_create(this->shader, nir_intrinsic_copy_var);
- ir->lhs->accept(this);
- copy->variables[0] = this->deref_head;
-
- ir->rhs->accept(this);
- copy->variables[1] = this->deref_head;
-
+ copy->variables[0] = evaluate_deref(©->instr, ir->lhs);
+ copy->variables[1] = evaluate_deref(©->instr, ir->rhs);
if (ir->condition) {
nir_if *if_stmt = nir_if_create(this->shader);
nir_intrinsic_instr *load =
nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_var);
load->num_components = ir->lhs->type->vector_elements;
- load->dest.is_ssa = true;
- nir_ssa_def_init(&load->instr, &load->dest.ssa,
- num_components, NULL);
+ nir_ssa_dest_init(&load->instr, &load->dest, num_components, NULL);
load->variables[0] = lhs_deref;
+ ralloc_steal(load, load->variables[0]);
nir_instr_insert_after_cf_list(this->cf_node_list, &load->instr);
nir_op vec_op;
default: unreachable("Invalid number of components"); break;
}
nir_alu_instr *vec = nir_alu_instr_create(this->shader, vec_op);
- vec->dest.dest.is_ssa = true;
- nir_ssa_def_init(&vec->instr, &vec->dest.dest.ssa,
- num_components, NULL);
+ nir_ssa_dest_init(&vec->instr, &vec->dest.dest, num_components, NULL);
vec->dest.write_mask = (1 << num_components) - 1;
unsigned component = 0;
nir_intrinsic_instr *store =
nir_intrinsic_instr_create(this->shader, nir_intrinsic_store_var);
store->num_components = ir->lhs->type->vector_elements;
- nir_deref *store_deref = nir_copy_deref(this->shader, &lhs_deref->deref);
+ nir_deref *store_deref = nir_copy_deref(store, &lhs_deref->deref);
store->variables[0] = nir_deref_as_var(store_deref);
store->src[0] = src;
nir_alu_instr *alu_instr;
nir_intrinsic_instr *intrinsic_instr;
nir_tex_instr *tex_instr;
- nir_load_const_instr *load_const_instr;
switch (instr->type) {
case nir_instr_type_alu:
tex_instr = nir_instr_as_tex(instr);
return &tex_instr->dest;
- case nir_instr_type_load_const:
- load_const_instr = nir_instr_as_load_const(instr);
- return &load_const_instr->dest;
-
default:
- assert(0);
- break;
+ unreachable("not reached");
}
return NULL;
{
nir_dest *dest = get_instr_dest(instr);
- dest->is_ssa = true;
- nir_ssa_def_init(instr, &dest->ssa, num_components, NULL);
+ nir_ssa_dest_init(instr, dest, num_components, NULL);
nir_instr_insert_after_cf_list(this->cf_node_list, instr);
this->result = instr;
nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_var);
load_instr->num_components = ir->type->vector_elements;
load_instr->variables[0] = this->deref_head;
+ ralloc_steal(load_instr, load_instr->variables[0]);
add_instr(&load_instr->instr, ir->type->vector_elements);
}
*/
if (ir->type->base_type == GLSL_TYPE_BOOL) {
- nir_load_const_instr *const_zero = nir_load_const_instr_create(shader);
- const_zero->num_components = 1;
+ nir_load_const_instr *const_zero = nir_load_const_instr_create(shader, 1);
const_zero->value.u[0] = 0;
- const_zero->dest.is_ssa = true;
- nir_ssa_def_init(&const_zero->instr, &const_zero->dest.ssa, 1, NULL);
nir_instr_insert_after_cf_list(this->cf_node_list, &const_zero->instr);
nir_alu_instr *compare = nir_alu_instr_create(shader, nir_op_ine);
compare->src[0].src.is_ssa = true;
compare->src[0].src.ssa = &load->dest.ssa;
compare->src[1].src.is_ssa = true;
- compare->src[1].src.ssa = &const_zero->dest.ssa;
+ compare->src[1].src.ssa = &const_zero->def;
for (unsigned i = 0; i < ir->type->vector_elements; i++)
compare->src[1].swizzle[i] = 0;
compare->dest.write_mask = (1 << ir->type->vector_elements) - 1;
nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(shader, op);
intrin->num_components = deref->type->vector_elements;
intrin->variables[0] = this->deref_head;
+ ralloc_steal(intrin, intrin->variables[0]);
if (intrin->intrinsic == nir_intrinsic_interp_var_at_offset ||
intrin->intrinsic == nir_intrinsic_interp_var_at_sample)
case ir_unop_rcp: emit(nir_op_frcp, dest_size, srcs); break;
case ir_unop_rsq: emit(nir_op_frsq, dest_size, srcs); break;
case ir_unop_sqrt: emit(nir_op_fsqrt, dest_size, srcs); break;
- case ir_unop_exp: emit(nir_op_fexp, dest_size, srcs); break;
+ case ir_unop_exp: unreachable("ir_unop_exp should have been lowered");
case ir_unop_log: emit(nir_op_flog, dest_size, srcs); break;
case ir_unop_exp2: emit(nir_op_fexp2, dest_size, srcs); break;
case ir_unop_log2: emit(nir_op_flog2, dest_size, srcs); break;
dest_size, srcs);
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
break;
case ir_unop_trunc: emit(nir_op_ftrunc, dest_size, srcs); break;
case ir_unop_round_even: emit(nir_op_fround_even, dest_size, srcs); break;
case ir_unop_sin: emit(nir_op_fsin, dest_size, srcs); break;
case ir_unop_cos: emit(nir_op_fcos, dest_size, srcs); break;
- case ir_unop_sin_reduced:
- emit(nir_op_fsin_reduced, dest_size, srcs);
- break;
- case ir_unop_cos_reduced:
- emit(nir_op_fcos_reduced, dest_size, srcs);
- break;
case ir_unop_dFdx: emit(nir_op_fddx, dest_size, srcs); break;
case ir_unop_dFdy: emit(nir_op_fddy, dest_size, srcs); break;
case ir_unop_dFdx_fine: emit(nir_op_fddx_fine, dest_size, srcs); break;
case 2: emit(nir_op_fnoise1_2, dest_size, srcs); break;
case 3: emit(nir_op_fnoise1_3, dest_size, srcs); break;
case 4: emit(nir_op_fnoise1_4, dest_size, srcs); break;
- default: assert(0); break;
+ default: unreachable("not reached");
}
break;
case 2:
case 2: emit(nir_op_fnoise2_2, dest_size, srcs); break;
case 3: emit(nir_op_fnoise2_3, dest_size, srcs); break;
case 4: emit(nir_op_fnoise2_4, dest_size, srcs); break;
- default: assert(0); break;
+ default: unreachable("not reached");
}
break;
case 3:
case 2: emit(nir_op_fnoise3_2, dest_size, srcs); break;
case 3: emit(nir_op_fnoise3_3, dest_size, srcs); break;
case 4: emit(nir_op_fnoise3_4, dest_size, srcs); break;
- default: assert(0); break;
+ default: unreachable("not reached");
}
break;
case 4:
case 2: emit(nir_op_fnoise4_2, dest_size, srcs); break;
case 3: emit(nir_op_fnoise4_3, dest_size, srcs); break;
case 4: emit(nir_op_fnoise4_4, dest_size, srcs); break;
- default: assert(0); break;
+ default: unreachable("not reached");
}
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
break;
case ir_binop_add:
case ir_binop_bit_and:
case ir_binop_bit_or:
case ir_binop_bit_xor:
+ case ir_binop_logic_and:
+ case ir_binop_logic_or:
+ case ir_binop_logic_xor:
case ir_binop_lshift:
case ir_binop_rshift:
switch (ir->operation) {
case ir_binop_bit_xor:
op = nir_op_ixor;
break;
+ case ir_binop_logic_and:
+ if (supports_ints)
+ op = nir_op_iand;
+ else
+ op = nir_op_fand;
+ break;
+ case ir_binop_logic_or:
+ if (supports_ints)
+ op = nir_op_ior;
+ else
+ op = nir_op_for;
+ break;
+ case ir_binop_logic_xor:
+ if (supports_ints)
+ op = nir_op_ixor;
+ else
+ op = nir_op_fxor;
+ break;
case ir_binop_lshift:
op = nir_op_ishl;
break;
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
instr = emit(op, dest_size, srcs);
case 3: emit(nir_op_ball_fequal3, dest_size, srcs); break;
case 4: emit(nir_op_ball_fequal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
} else {
switch (ir->operands[0]->type->vector_elements) {
case 3: emit(nir_op_ball_iequal3, dest_size, srcs); break;
case 4: emit(nir_op_ball_iequal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
}
} else {
case 3: emit(nir_op_fall_equal3, dest_size, srcs); break;
case 4: emit(nir_op_fall_equal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
}
break;
case 3: emit(nir_op_bany_fnequal3, dest_size, srcs); break;
case 4: emit(nir_op_bany_fnequal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
} else {
switch (ir->operands[0]->type->vector_elements) {
case 3: emit(nir_op_bany_inequal3, dest_size, srcs); break;
case 4: emit(nir_op_bany_inequal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
}
} else {
case 3: emit(nir_op_fany_nequal3, dest_size, srcs); break;
case 4: emit(nir_op_fany_nequal4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
}
break;
- case ir_binop_logic_and:
- if (supports_ints)
- emit(nir_op_iand, dest_size, srcs);
- else
- emit(nir_op_fand, dest_size, srcs);
- break;
- case ir_binop_logic_or:
- if (supports_ints)
- emit(nir_op_ior, dest_size, srcs);
- else
- emit(nir_op_for, dest_size, srcs);
- break;
- case ir_binop_logic_xor:
- if (supports_ints)
- emit(nir_op_ixor, dest_size, srcs);
- else
- emit(nir_op_fxor, dest_size, srcs);
- break;
case ir_binop_dot:
switch (ir->operands[0]->type->vector_elements) {
case 2: emit(nir_op_fdot2, dest_size, srcs); break;
case 3: emit(nir_op_fdot3, dest_size, srcs); break;
case 4: emit(nir_op_fdot4, dest_size, srcs); break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
break;
case 2: emit(nir_op_vec2, dest_size, srcs); break;
case 3: emit(nir_op_vec3, dest_size, srcs); break;
case 4: emit(nir_op_vec4, dest_size, srcs); break;
- default: assert(0); break;
+ default: unreachable("not reached");
}
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
}
break;
default:
- assert(0);
- break;
+ unreachable("not reached");
}
if (ir->projector != NULL)
instr->dest_type = nir_type_unsigned;
break;
default:
- assert(0);
+ unreachable("not reached");
}
- ir->sampler->accept(this);
- instr->sampler = this->deref_head;
+ instr->sampler = evaluate_deref(&instr->instr, ir->sampler);
unsigned src_number = 0;
if (ir->coordinate != NULL) {
instr->coord_components = ir->coordinate->type->vector_elements;
- instr->src[src_number] = evaluate_rvalue(ir->coordinate);
- instr->src_type[src_number] = nir_tex_src_coord;
+ instr->src[src_number].src = evaluate_rvalue(ir->coordinate);
+ instr->src[src_number].src_type = nir_tex_src_coord;
src_number++;
}
if (ir->projector != NULL) {
- instr->src[src_number] = evaluate_rvalue(ir->projector);
- instr->src_type[src_number] = nir_tex_src_projector;
+ instr->src[src_number].src = evaluate_rvalue(ir->projector);
+ instr->src[src_number].src_type = nir_tex_src_projector;
src_number++;
}
if (ir->shadow_comparitor != NULL) {
- instr->src[src_number] = evaluate_rvalue(ir->shadow_comparitor);
- instr->src_type[src_number] = nir_tex_src_comparitor;
+ instr->src[src_number].src = evaluate_rvalue(ir->shadow_comparitor);
+ instr->src[src_number].src_type = nir_tex_src_comparitor;
src_number++;
}
for (unsigned i = 0; i < const_offset->type->vector_elements; i++)
instr->const_offset[i] = const_offset->value.i[i];
} else {
- instr->src[src_number] = evaluate_rvalue(ir->offset);
- instr->src_type[src_number] = nir_tex_src_offset;
+ instr->src[src_number].src = evaluate_rvalue(ir->offset);
+ instr->src[src_number].src_type = nir_tex_src_offset;
src_number++;
}
}
switch (ir->op) {
case ir_txb:
- instr->src[src_number] = evaluate_rvalue(ir->lod_info.bias);
- instr->src_type[src_number] = nir_tex_src_bias;
+ instr->src[src_number].src = evaluate_rvalue(ir->lod_info.bias);
+ instr->src[src_number].src_type = nir_tex_src_bias;
src_number++;
break;
case ir_txf:
case ir_txs:
if (ir->lod_info.lod != NULL) {
- instr->src[src_number] = evaluate_rvalue(ir->lod_info.lod);
- instr->src_type[src_number] = nir_tex_src_lod;
+ instr->src[src_number].src = evaluate_rvalue(ir->lod_info.lod);
+ instr->src[src_number].src_type = nir_tex_src_lod;
src_number++;
}
break;
case ir_txd:
- instr->src[src_number] = evaluate_rvalue(ir->lod_info.grad.dPdx);
- instr->src_type[src_number] = nir_tex_src_ddx;
+ instr->src[src_number].src = evaluate_rvalue(ir->lod_info.grad.dPdx);
+ instr->src[src_number].src_type = nir_tex_src_ddx;
src_number++;
- instr->src[src_number] = evaluate_rvalue(ir->lod_info.grad.dPdy);
- instr->src_type[src_number] = nir_tex_src_ddy;
+ instr->src[src_number].src = evaluate_rvalue(ir->lod_info.grad.dPdy);
+ instr->src[src_number].src_type = nir_tex_src_ddy;
src_number++;
break;
case ir_txf_ms:
- instr->src[src_number] = evaluate_rvalue(ir->lod_info.sample_index);
- instr->src_type[src_number] = nir_tex_src_ms_index;
+ instr->src[src_number].src = evaluate_rvalue(ir->lod_info.sample_index);
+ instr->src[src_number].src_type = nir_tex_src_ms_index;
src_number++;
break;
{
/*
* We don't know if this variable is an an array or struct that gets
- * dereferenced, so do the safe thing an make it a variable and return a
- * dereference.
+ * dereferenced, so do the safe thing an make it a variable with a
+ * constant initializer and return a dereference.
*/
nir_variable *var = ralloc(this->shader, nir_variable);
var->type = ir->type;
var->data.mode = nir_var_local;
var->data.read_only = true;
- var->constant_value = constant_copy(ir, var);
var->constant_initializer = constant_copy(ir, var);
exec_list_push_tail(&this->impl->locals, &var->node);
int field_index = this->deref_tail->type->field_index(ir->field);
assert(field_index >= 0);
- nir_deref_struct *deref = nir_deref_struct_create(this->shader, field_index);
+ nir_deref_struct *deref = nir_deref_struct_create(this->deref_tail, field_index);
deref->deref.type = ir->type;
this->deref_tail->child = &deref->deref;
this->deref_tail = &deref->deref;
ir->array->accept(this);
this->deref_tail->child = &deref->deref;
+ ralloc_steal(this->deref_tail, deref);
this->deref_tail = &deref->deref;
}
projects / mesa.git / blobdiff