nir_deref_instr *evaluate_deref(ir_instruction *ir);
+ nir_constant *constant_copy(ir_constant *ir, void *mem_ctx);
+
/* most recent deref instruction created */
nir_deref_instr *deref;
- nir_variable *var; /* variable created by ir_variable visitor */
-
/* whether the IR we're operating on is per-function or global */
bool is_global;
+ ir_function_signature *sig;
+
/* map of ir_variable -> nir_variable */
struct hash_table *var_table;
shader->info.has_transform_feedback_varyings |=
shader_prog->last_vert_prog->sh.LinkedTransformFeedback->NumVarying > 0;
+ if (shader->info.stage == MESA_SHADER_FRAGMENT) {
+ shader->info.fs.pixel_center_integer = sh->Program->info.fs.pixel_center_integer;
+ shader->info.fs.origin_upper_left = sh->Program->info.fs.origin_upper_left;
+ }
+
return shader;
}
this->supports_ints = shader->options->native_integers;
this->shader = shader;
this->is_global = true;
- this->var_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
- this->overload_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
- _mesa_key_pointer_equal);
+ this->var_table = _mesa_pointer_hash_table_create(NULL);
+ this->overload_table = _mesa_pointer_hash_table_create(NULL);
this->result = NULL;
this->impl = NULL;
- this->var = NULL;
+ this->deref = NULL;
memset(&this->b, 0, sizeof(this->b));
}
return this->deref;
}
-static nir_constant *
-constant_copy(ir_constant *ir, void *mem_ctx)
+nir_constant *
+nir_visitor::constant_copy(ir_constant *ir, void *mem_ctx)
{
if (ir == NULL)
return NULL;
assert(cols == 1);
for (unsigned r = 0; r < rows; r++)
- ret->values[0].u32[r] = ir->value.u[r];
+ if (supports_ints)
+ ret->values[0].u32[r] = ir->value.u[r];
+ else
+ ret->values[0].f32[r] = ir->value.u[r];
break;
assert(cols == 1);
for (unsigned r = 0; r < rows; r++)
- ret->values[0].i32[r] = ir->value.i[r];
+ if (supports_ints)
+ ret->values[0].i32[r] = ir->value.i[r];
+ else
+ ret->values[0].f32[r] = ir->value.i[r];
break;
assert(cols == 1);
for (unsigned r = 0; r < rows; r++)
- ret->values[0].u32[r] = ir->value.b[r] ? NIR_TRUE : NIR_FALSE;
+ ret->values[0].b[r] = ir->value.b[r];
break;
if (ir->data.mode == ir_var_shader_shared)
return;
+ /* FINISHME: inout parameters */
+ assert(ir->data.mode != ir_var_function_inout);
+
+ if (ir->data.mode == ir_var_function_out)
+ return;
+
nir_variable *var = rzalloc(shader, nir_variable);
var->type = ir->type;
var->name = ralloc_strdup(var, ir->name);
case ir_var_auto:
case ir_var_temporary:
if (is_global)
- var->data.mode = nir_var_global;
+ var->data.mode = nir_var_shader_temp;
else
- var->data.mode = nir_var_local;
+ var->data.mode = nir_var_function_temp;
break;
case ir_var_function_in:
- case ir_var_function_out:
- case ir_var_function_inout:
case ir_var_const_in:
- var->data.mode = nir_var_local;
+ var->data.mode = nir_var_function_temp;
break;
case ir_var_shader_in:
ir->data.location == VARYING_SLOT_TESS_LEVEL_OUTER)) {
var->data.compact = ir->type->without_array()->is_scalar();
}
+
+ if (shader->info.stage > MESA_SHADER_VERTEX &&
+ ir->data.location >= VARYING_SLOT_CLIP_DIST0 &&
+ ir->data.location <= VARYING_SLOT_CULL_DIST1) {
+ var->data.compact = ir->type->without_array()->is_scalar();
+ }
}
break;
ir->data.location == VARYING_SLOT_TESS_LEVEL_OUTER)) {
var->data.compact = ir->type->without_array()->is_scalar();
}
+
+ if (shader->info.stage <= MESA_SHADER_GEOMETRY &&
+ ir->data.location >= VARYING_SLOT_CLIP_DIST0 &&
+ ir->data.location <= VARYING_SLOT_CULL_DIST1) {
+ var->data.compact = ir->type->without_array()->is_scalar();
+ }
break;
case ir_var_uniform:
- var->data.mode = nir_var_uniform;
+ if (ir->get_interface_type())
+ var->data.mode = nir_var_mem_ubo;
+ else
+ var->data.mode = nir_var_uniform;
break;
case ir_var_shader_storage:
- var->data.mode = nir_var_shader_storage;
+ var->data.mode = nir_var_mem_ssbo;
break;
case ir_var_system_value:
}
var->data.interpolation = ir->data.interpolation;
- var->data.origin_upper_left = ir->data.origin_upper_left;
- var->data.pixel_center_integer = ir->data.pixel_center_integer;
var->data.location_frac = ir->data.location_frac;
- if (var->data.pixel_center_integer) {
- assert(shader->info.stage == MESA_SHADER_FRAGMENT);
- shader->info.fs.pixel_center_integer = true;
- }
-
switch (ir->data.depth_layout) {
case ir_depth_layout_none:
var->data.depth_layout = nir_depth_layout_none;
var->interface_type = ir->get_interface_type();
- if (var->data.mode == nir_var_local)
+ if (var->data.mode == nir_var_function_temp)
nir_function_impl_add_variable(impl, var);
else
nir_shader_add_variable(shader, var);
_mesa_hash_table_insert(var_table, ir, var);
- this->var = var;
}
ir_visitor_status
return;
nir_function *func = nir_function_create(shader, ir->function_name());
+ if (strcmp(ir->function_name(), "main") == 0)
+ func->is_entrypoint = true;
+
+ func->num_params = ir->parameters.length() +
+ (ir->return_type != glsl_type::void_type);
+ func->params = ralloc_array(shader, nir_parameter, func->num_params);
+
+ unsigned np = 0;
+
+ if (ir->return_type != glsl_type::void_type) {
+ /* The return value is a variable deref (basically an out parameter) */
+ func->params[np].num_components = 1;
+ func->params[np].bit_size = 32;
+ np++;
+ }
+
+ foreach_in_list(ir_variable, param, &ir->parameters) {
+ /* FINISHME: pass arrays, structs, etc by reference? */
+ assert(param->type->is_vector() || param->type->is_scalar());
- assert(ir->parameters.is_empty());
- assert(ir->return_type == glsl_type::void_type);
+ if (param->data.mode == ir_var_function_in) {
+ func->params[np].num_components = param->type->vector_elements;
+ func->params[np].bit_size = glsl_get_bit_size(param->type);
+ } else {
+ func->params[np].num_components = 1;
+ func->params[np].bit_size = 32;
+ }
+ np++;
+ }
+ assert(np == func->num_params);
_mesa_hash_table_insert(this->overload_table, ir, func);
}
if (ir->is_intrinsic())
return;
+ this->sig = ir;
+
struct hash_entry *entry =
_mesa_hash_table_search(this->overload_table, ir);
nir_function_impl *impl = nir_function_impl_create(func);
this->impl = impl;
- assert(strcmp(func->name, "main") == 0);
- assert(ir->parameters.is_empty());
-
this->is_global = false;
nir_builder_init(&b, impl);
b.cursor = nir_after_cf_list(&impl->body);
+
+ unsigned i = (ir->return_type != glsl_type::void_type) ? 1 : 0;
+
+ foreach_in_list(ir_variable, param, &ir->parameters) {
+ nir_variable *var =
+ nir_local_variable_create(impl, param->type, param->name);
+
+ if (param->data.mode == ir_var_function_in) {
+ nir_store_var(&b, var, nir_load_param(&b, i), ~0);
+ }
+
+ _mesa_hash_table_insert(var_table, param, var);
+ i++;
+ }
+
visit_exec_list(&ir->body, this);
this->is_global = true;
void
nir_visitor::visit(ir_return *ir)
{
- assert(ir->value == NULL);
+ if (ir->value != NULL) {
+ nir_deref_instr *ret_deref =
+ nir_build_deref_cast(&b, nir_load_param(&b, 0),
+ nir_var_function_temp, ir->value->type, 0);
+
+ nir_ssa_def *val = evaluate_rvalue(ir->value);
+ nir_store_deref(&b, ret_deref, val, ~0);
+ }
+
nir_jump_instr *instr = nir_jump_instr_create(this->shader, nir_jump_return);
nir_builder_instr_insert(&b, &instr->instr);
}
case ir_intrinsic_end_invocation_interlock:
op = nir_intrinsic_end_invocation_interlock;
break;
- case ir_intrinsic_begin_fragment_shader_ordering:
- op = nir_intrinsic_begin_fragment_shader_ordering;
- break;
case ir_intrinsic_group_memory_barrier:
op = nir_intrinsic_group_memory_barrier;
break;
case nir_intrinsic_end_invocation_interlock:
nir_builder_instr_insert(&b, &instr->instr);
break;
- case nir_intrinsic_begin_fragment_shader_ordering:
- nir_builder_instr_insert(&b, &instr->instr);
- break;
case nir_intrinsic_store_ssbo: {
exec_node *param = ir->actual_parameters.get_head();
ir_rvalue *block = ((ir_instruction *)param)->as_rvalue();
assert(write_mask);
nir_ssa_def *nir_val = evaluate_rvalue(val);
- assert(!val->type->is_boolean() || nir_val->bit_size == 32);
+ if (val->type->is_boolean())
+ nir_val = nir_b2i32(&b, nir_val);
instr->src[0] = nir_src_for_ssa(nir_val);
instr->src[1] = nir_src_for_ssa(evaluate_rvalue(block));
type->vector_elements, bit_size, NULL);
nir_builder_instr_insert(&b, &instr->instr);
+
+ /* The value in shared memory is a 32-bit value */
+ if (type->is_boolean())
+ ret = nir_i2b(&b, &instr->dest.ssa);
break;
}
case nir_intrinsic_store_shared: {
nir_intrinsic_set_write_mask(instr, write_mask->value.u[0]);
nir_ssa_def *nir_val = evaluate_rvalue(val);
- assert(!val->type->is_boolean() || nir_val->bit_size == 32);
+ /* The value in shared memory is a 32-bit value */
+ if (val->type->is_boolean())
+ nir_val = nir_b2i32(&b, nir_val);
instr->src[0] = nir_src_for_ssa(nir_val);
instr->num_components = val->type->vector_elements;
case nir_intrinsic_vote_any:
case nir_intrinsic_vote_all:
case nir_intrinsic_vote_ieq: {
- nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL);
+ nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 1, NULL);
instr->num_components = 1;
ir_rvalue *value = (ir_rvalue *) ir->actual_parameters.get_head();
return;
}
- unreachable("glsl_to_nir only handles function calls to intrinsics");
+ struct hash_entry *entry =
+ _mesa_hash_table_search(this->overload_table, ir->callee);
+ assert(entry);
+ nir_function *callee = (nir_function *) entry->data;
+
+ nir_call_instr *call = nir_call_instr_create(this->shader, callee);
+
+ unsigned i = 0;
+ nir_deref_instr *ret_deref = NULL;
+ if (ir->return_deref) {
+ nir_variable *ret_tmp =
+ nir_local_variable_create(this->impl, ir->return_deref->type,
+ "return_tmp");
+ ret_deref = nir_build_deref_var(&b, ret_tmp);
+ call->params[i++] = nir_src_for_ssa(&ret_deref->dest.ssa);
+ }
+
+ foreach_two_lists(formal_node, &ir->callee->parameters,
+ actual_node, &ir->actual_parameters) {
+ ir_rvalue *param_rvalue = (ir_rvalue *) actual_node;
+ ir_variable *sig_param = (ir_variable *) formal_node;
+
+ if (sig_param->data.mode == ir_var_function_out) {
+ nir_deref_instr *out_deref = evaluate_deref(param_rvalue);
+ call->params[i] = nir_src_for_ssa(&out_deref->dest.ssa);
+ } else if (sig_param->data.mode == ir_var_function_in) {
+ nir_ssa_def *val = evaluate_rvalue(param_rvalue);
+ nir_src src = nir_src_for_ssa(val);
+
+ nir_src_copy(&call->params[i], &src, call);
+ } else if (sig_param->data.mode == ir_var_function_inout) {
+ unreachable("unimplemented: inout parameters");
+ }
+
+ i++;
+ }
+
+ nir_builder_instr_insert(&b, &call->instr);
+
+ if (ir->return_deref)
+ nir_store_deref(&b, evaluate_deref(ir->return_deref), nir_load_deref(&b, ret_deref), ~0);
}
void
for (unsigned i = 0; i < 4; i++) {
swiz[i] = ir->write_mask & (1 << i) ? component++ : 0;
}
- src = nir_swizzle(&b, src, swiz, num_components, !supports_ints);
+ src = nir_swizzle(&b, src, swiz, num_components, false);
}
if (ir->condition) {
type == GLSL_TYPE_INT16;
}
+static bool
+type_is_int(glsl_base_type type)
+{
+ return type == GLSL_TYPE_UINT || type == GLSL_TYPE_INT ||
+ type == GLSL_TYPE_UINT8 || type == GLSL_TYPE_INT8 ||
+ type == GLSL_TYPE_UINT16 || type == GLSL_TYPE_INT16 ||
+ type == GLSL_TYPE_UINT64 || type == GLSL_TYPE_INT64;
+}
+
void
nir_visitor::visit(ir_expression *ir)
{
* sense, we'll just turn it into a load which will probably
* eventually end up as an SSA definition.
*/
- assert(this->deref->mode == nir_var_global);
+ assert(this->deref->mode == nir_var_shader_temp);
op = nir_intrinsic_load_deref;
}
glsl_base_type types[4];
for (unsigned i = 0; i < ir->num_operands; i++)
- if (supports_ints)
+ if (supports_ints || !type_is_int(ir->operands[i]->type->base_type))
types[i] = ir->operands[i]->type->base_type;
else
types[i] = GLSL_TYPE_FLOAT;
glsl_base_type out_type;
- if (supports_ints)
+ if (supports_ints || !type_is_int(ir->type->base_type))
out_type = ir->type->base_type;
else
out_type = GLSL_TYPE_FLOAT;
switch (ir->operation) {
case ir_unop_bit_not: result = nir_inot(&b, srcs[0]); break;
case ir_unop_logic_not:
- result = supports_ints ? nir_inot(&b, srcs[0]) : nir_fnot(&b, srcs[0]);
+ result = nir_inot(&b, srcs[0]);
break;
case ir_unop_neg:
result = type_is_float(types[0]) ? nir_fneg(&b, srcs[0])
result = supports_ints ? nir_u2f32(&b, srcs[0]) : nir_fmov(&b, srcs[0]);
break;
case ir_unop_b2f:
- result = supports_ints ? nir_b2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]);
+ result = nir_b2f32(&b, srcs[0]);
break;
case ir_unop_f2i:
+ result = supports_ints ? nir_f2i32(&b, srcs[0]) : nir_ftrunc(&b, srcs[0]);
+ break;
case ir_unop_f2u:
+ result = supports_ints ? nir_f2u32(&b, srcs[0]) : nir_ftrunc(&b, srcs[0]);
+ break;
case ir_unop_f2b:
case ir_unop_i2b:
case ir_unop_b2i:
: nir_isub(&b, srcs[0], srcs[1]);
break;
case ir_binop_mul:
- result = type_is_float(out_type) ? nir_fmul(&b, srcs[0], srcs[1])
- : nir_imul(&b, srcs[0], srcs[1]);
+ if (type_is_float(out_type))
+ result = nir_fmul(&b, srcs[0], srcs[1]);
+ else if (out_type == GLSL_TYPE_INT64 &&
+ (ir->operands[0]->type->base_type == GLSL_TYPE_INT ||
+ ir->operands[1]->type->base_type == GLSL_TYPE_INT))
+ result = nir_imul_2x32_64(&b, srcs[0], srcs[1]);
+ else if (out_type == GLSL_TYPE_UINT64 &&
+ (ir->operands[0]->type->base_type == GLSL_TYPE_UINT ||
+ ir->operands[1]->type->base_type == GLSL_TYPE_UINT))
+ result = nir_umul_2x32_64(&b, srcs[0], srcs[1]);
+ else
+ result = nir_imul(&b, srcs[0], srcs[1]);
break;
case ir_binop_div:
if (type_is_float(out_type))
case ir_binop_bit_or: result = nir_ior(&b, srcs[0], srcs[1]); break;
case ir_binop_bit_xor: result = nir_ixor(&b, srcs[0], srcs[1]); break;
case ir_binop_logic_and:
- result = supports_ints ? nir_iand(&b, srcs[0], srcs[1])
- : nir_fand(&b, srcs[0], srcs[1]);
+ result = nir_iand(&b, srcs[0], srcs[1]);
break;
case ir_binop_logic_or:
- result = supports_ints ? nir_ior(&b, srcs[0], srcs[1])
- : nir_for(&b, srcs[0], srcs[1]);
+ result = nir_ior(&b, srcs[0], srcs[1]);
break;
case ir_binop_logic_xor:
- result = supports_ints ? nir_ixor(&b, srcs[0], srcs[1])
- : nir_fxor(&b, srcs[0], srcs[1]);
+ result = nir_ixor(&b, srcs[0], srcs[1]);
break;
case ir_binop_lshift: result = nir_ishl(&b, srcs[0], srcs[1]); break;
case ir_binop_rshift:
case ir_binop_carry: result = nir_uadd_carry(&b, srcs[0], srcs[1]); break;
case ir_binop_borrow: result = nir_usub_borrow(&b, srcs[0], srcs[1]); break;
case ir_binop_less:
- if (supports_ints) {
- if (type_is_float(types[0]))
- result = nir_flt(&b, srcs[0], srcs[1]);
- else if (type_is_signed(types[0]))
- result = nir_ilt(&b, srcs[0], srcs[1]);
- else
- result = nir_ult(&b, srcs[0], srcs[1]);
- } else {
- result = nir_slt(&b, srcs[0], srcs[1]);
- }
+ if (type_is_float(types[0]))
+ result = nir_flt(&b, srcs[0], srcs[1]);
+ else if (type_is_signed(types[0]))
+ result = nir_ilt(&b, srcs[0], srcs[1]);
+ else
+ result = nir_ult(&b, srcs[0], srcs[1]);
break;
case ir_binop_gequal:
- if (supports_ints) {
- if (type_is_float(types[0]))
- result = nir_fge(&b, srcs[0], srcs[1]);
- else if (type_is_signed(types[0]))
- result = nir_ige(&b, srcs[0], srcs[1]);
- else
- result = nir_uge(&b, srcs[0], srcs[1]);
- } else {
- result = nir_sge(&b, srcs[0], srcs[1]);
- }
+ if (type_is_float(types[0]))
+ result = nir_fge(&b, srcs[0], srcs[1]);
+ else if (type_is_signed(types[0]))
+ result = nir_ige(&b, srcs[0], srcs[1]);
+ else
+ result = nir_uge(&b, srcs[0], srcs[1]);
break;
case ir_binop_equal:
- if (supports_ints) {
- if (type_is_float(types[0]))
- result = nir_feq(&b, srcs[0], srcs[1]);
- else
- result = nir_ieq(&b, srcs[0], srcs[1]);
- } else {
- result = nir_seq(&b, srcs[0], srcs[1]);
- }
+ if (type_is_float(types[0]))
+ result = nir_feq(&b, srcs[0], srcs[1]);
+ else
+ result = nir_ieq(&b, srcs[0], srcs[1]);
break;
case ir_binop_nequal:
- if (supports_ints) {
- if (type_is_float(types[0]))
- result = nir_fne(&b, srcs[0], srcs[1]);
- else
- result = nir_ine(&b, srcs[0], srcs[1]);
- } else {
- result = nir_sne(&b, srcs[0], srcs[1]);
- }
+ if (type_is_float(types[0]))
+ result = nir_fne(&b, srcs[0], srcs[1]);
+ else
+ result = nir_ine(&b, srcs[0], srcs[1]);
break;
case ir_binop_all_equal:
- if (supports_ints) {
- if (type_is_float(types[0])) {
- switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_feq(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_ball_fequal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_ball_fequal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_ball_fequal4(&b, srcs[0], srcs[1]); break;
- default:
- unreachable("not reached");
- }
- } else {
- switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_ieq(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_ball_iequal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_ball_iequal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_ball_iequal4(&b, srcs[0], srcs[1]); break;
- default:
- unreachable("not reached");
- }
+ if (type_is_float(types[0])) {
+ switch (ir->operands[0]->type->vector_elements) {
+ case 1: result = nir_feq(&b, srcs[0], srcs[1]); break;
+ case 2: result = nir_ball_fequal2(&b, srcs[0], srcs[1]); break;
+ case 3: result = nir_ball_fequal3(&b, srcs[0], srcs[1]); break;
+ case 4: result = nir_ball_fequal4(&b, srcs[0], srcs[1]); break;
+ default:
+ unreachable("not reached");
}
} else {
switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_seq(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_fall_equal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_fall_equal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_fall_equal4(&b, srcs[0], srcs[1]); break;
+ case 1: result = nir_ieq(&b, srcs[0], srcs[1]); break;
+ case 2: result = nir_ball_iequal2(&b, srcs[0], srcs[1]); break;
+ case 3: result = nir_ball_iequal3(&b, srcs[0], srcs[1]); break;
+ case 4: result = nir_ball_iequal4(&b, srcs[0], srcs[1]); break;
default:
unreachable("not reached");
}
}
break;
case ir_binop_any_nequal:
- if (supports_ints) {
- if (type_is_float(types[0])) {
- switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_fne(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_bany_fnequal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_bany_fnequal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_bany_fnequal4(&b, srcs[0], srcs[1]); break;
- default:
- unreachable("not reached");
- }
- } else {
- switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_ine(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_bany_inequal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_bany_inequal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_bany_inequal4(&b, srcs[0], srcs[1]); break;
- default:
- unreachable("not reached");
- }
+ if (type_is_float(types[0])) {
+ switch (ir->operands[0]->type->vector_elements) {
+ case 1: result = nir_fne(&b, srcs[0], srcs[1]); break;
+ case 2: result = nir_bany_fnequal2(&b, srcs[0], srcs[1]); break;
+ case 3: result = nir_bany_fnequal3(&b, srcs[0], srcs[1]); break;
+ case 4: result = nir_bany_fnequal4(&b, srcs[0], srcs[1]); break;
+ default:
+ unreachable("not reached");
}
} else {
switch (ir->operands[0]->type->vector_elements) {
- case 1: result = nir_sne(&b, srcs[0], srcs[1]); break;
- case 2: result = nir_fany_nequal2(&b, srcs[0], srcs[1]); break;
- case 3: result = nir_fany_nequal3(&b, srcs[0], srcs[1]); break;
- case 4: result = nir_fany_nequal4(&b, srcs[0], srcs[1]); break;
+ case 1: result = nir_ine(&b, srcs[0], srcs[1]); break;
+ case 2: result = nir_bany_inequal2(&b, srcs[0], srcs[1]); break;
+ case 3: result = nir_bany_inequal3(&b, srcs[0], srcs[1]); break;
+ case 4: result = nir_bany_inequal4(&b, srcs[0], srcs[1]); break;
default:
unreachable("not reached");
}
result = nir_flrp(&b, srcs[0], srcs[1], srcs[2]);
break;
case ir_triop_csel:
- if (supports_ints)
- result = nir_bcsel(&b, srcs[0], srcs[1], srcs[2]);
- else
- result = nir_fcsel(&b, srcs[0], srcs[1], srcs[2]);
+ result = nir_bcsel(&b, srcs[0], srcs[1], srcs[2]);
break;
case ir_triop_bitfield_extract:
result = (out_type == GLSL_TYPE_INT) ?
{
unsigned swizzle[4] = { ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w };
result = nir_swizzle(&b, evaluate_rvalue(ir->val), swizzle,
- ir->type->vector_elements, !supports_ints);
+ ir->type->vector_elements, false);
}
void
void
nir_visitor::visit(ir_dereference_variable *ir)
{
+ if (ir->variable_referenced()->data.mode == ir_var_function_out) {
+ unsigned i = (sig->return_type != glsl_type::void_type) ? 1 : 0;
+
+ foreach_in_list(ir_variable, param, &sig->parameters) {
+ if (param == ir->variable_referenced()) {
+ break;
+ }
+ i++;
+ }
+
+ this->deref = nir_build_deref_cast(&b, nir_load_param(&b, i),
+ nir_var_function_temp, ir->type, 0);
+ return;
+ }
+
+ assert(ir->variable_referenced()->data.mode != ir_var_function_inout);
+
struct hash_entry *entry =
_mesa_hash_table_search(this->var_table, ir->var);
assert(entry);
projects / mesa.git / blobdiff