const struct etna_specs *specs;
struct etna_shader_variant *variant;
- /* register assigned to each output, indexed by driver_location */
- unsigned output_reg[ETNA_NUM_INPUTS];
-
/* block # to instr index */
unsigned *block_ptr;
int inst_ptr; /* current instruction pointer */
struct etna_inst code[ETNA_MAX_INSTRUCTIONS * ETNA_INST_SIZE];
+ /* constants */
+ uint64_t consts[ETNA_MAX_IMM];
+
/* There was an error during compilation */
bool error;
};
-#define compile_error(ctx, args...) ({ \
- printf(args); \
- ctx->error = true; \
- assert(0); \
-})
-
/* io related lowering
* run after lower_int_to_float because it adds i2f/f2i ops
*/
static void
etna_lower_io(nir_shader *shader, struct etna_shader_variant *v)
{
- bool rb_swap = shader->info.stage == MESA_SHADER_FRAGMENT && v->key.frag_rb_swap;
-
- unsigned color_location = 0;
- nir_foreach_variable(var, &shader->outputs) {
- switch (var->data.location) {
- case FRAG_RESULT_COLOR:
- case FRAG_RESULT_DATA0:
- color_location = var->data.driver_location;
- break;
- }
- }
-
nir_foreach_function(function, shader) {
nir_builder b;
nir_builder_init(&b, function->impl);
nir_src_for_ssa(ssa),
ssa->parent_instr);
} break;
- case nir_intrinsic_store_output: {
- if (!rb_swap || nir_intrinsic_base(intr) != color_location)
+ case nir_intrinsic_store_deref: {
+ if (shader->info.stage != MESA_SHADER_FRAGMENT || !v->key.frag_rb_swap)
break;
+
+ nir_deref_instr *deref = nir_src_as_deref(intr->src[0]);
+ assert(deref->deref_type == nir_deref_type_var);
+
+ if (deref->var->data.location != FRAG_RESULT_COLOR &&
+ deref->var->data.location != FRAG_RESULT_DATA0)
+ break;
+
b.cursor = nir_before_instr(instr);
- nir_ssa_def *ssa = nir_mov(&b, intr->src[0].ssa);
+ nir_ssa_def *ssa = nir_mov(&b, intr->src[1].ssa);
nir_alu_instr *alu = nir_instr_as_alu(ssa->parent_instr);
alu->src[0].swizzle[0] = 2;
alu->src[0].swizzle[2] = 0;
- nir_instr_rewrite_src(instr, &intr->src[0], nir_src_for_ssa(ssa));
+ nir_instr_rewrite_src(instr, &intr->src[1], nir_src_for_ssa(ssa));
} break;
case nir_intrinsic_load_uniform: {
/* multiply by 16 and convert to int */
lod_bias = &tex->src[i].src;
lod_bias_idx = i;
break;
+ case nir_tex_src_comparator:
+ break;
default:
assert(0);
break;
static void
etna_emit_tex(struct etna_compile *c, nir_texop op, unsigned texid, unsigned dst_swiz,
struct etna_inst_dst dst, struct etna_inst_src coord,
- struct etna_inst_src lod_bias)
+ struct etna_inst_src lod_bias, struct etna_inst_src compare)
{
struct etna_inst inst = {
.dst = dst,
if (lod_bias.use)
inst.src[1] = lod_bias;
+ if (compare.use)
+ inst.src[2] = compare;
+
switch (op) {
case nir_texop_tex: inst.opcode = INST_OPCODE_TEXLD; break;
case nir_texop_txb: inst.opcode = INST_OPCODE_TEXLDB; break;
}
static void
-etna_emit_output(struct etna_compile *c, unsigned index, struct etna_inst_src src)
+etna_emit_output(struct etna_compile *c, nir_variable *var, struct etna_inst_src src)
{
- c->output_reg[index] = src.reg;
+ struct etna_shader_io_file *sf = &c->variant->outfile;
+
+ if (is_fs(c)) {
+ switch (var->data.location) {
+ case FRAG_RESULT_COLOR:
+ case FRAG_RESULT_DATA0: /* DATA0 is used by gallium shaders for color */
+ c->variant->ps_color_out_reg = src.reg;
+ break;
+ case FRAG_RESULT_DEPTH:
+ c->variant->ps_depth_out_reg = src.reg;
+ break;
+ default:
+ unreachable("Unsupported fs output");
+ }
+ return;
+ }
+
+ switch (var->data.location) {
+ case VARYING_SLOT_POS:
+ c->variant->vs_pos_out_reg = src.reg;
+ break;
+ case VARYING_SLOT_PSIZ:
+ c->variant->vs_pointsize_out_reg = src.reg;
+ break;
+ default:
+ sf->reg[sf->num_reg].reg = src.reg;
+ sf->reg[sf->num_reg].slot = var->data.location;
+ sf->reg[sf->num_reg].num_components = glsl_get_components(var->type);
+ sf->num_reg++;
+ break;
+ }
}
static void
assert(sf->num_reg == count);
}
- NIR_PASS_V(s, nir_lower_io, nir_var_all, etna_glsl_type_size,
+ NIR_PASS_V(s, nir_lower_io, ~nir_var_shader_out, etna_glsl_type_size,
(nir_lower_io_options)0);
OPT_V(s, nir_lower_regs_to_ssa);
OPT_V(s, nir_opt_algebraic);
OPT_V(s, nir_lower_bool_to_float);
} else {
- OPT_V(s, nir_lower_idiv);
+ OPT_V(s, nir_lower_idiv, nir_lower_idiv_fast);
OPT_V(s, nir_lower_bool_to_int32);
}
if (DBG_ENABLED(ETNA_DBG_DUMP_SHADERS))
nir_print_shader(s, stdout);
- uint64_t consts[ETNA_MAX_IMM] = {};
-
unsigned block_ptr[nir_shader_get_entrypoint(s)->num_blocks];
c->block_ptr = block_ptr;
- struct emit_options options = {
- .max_temps = ETNA_MAX_TEMPS,
- .max_consts = ETNA_MAX_IMM / 4,
- .id_reg = sf->num_reg,
- .single_const_src = c->specs->halti < 5,
- .etna_new_transcendentals = c->specs->has_new_transcendentals,
- .no_integers = c->specs->halti < 2,
- .user = c,
- .consts = consts,
- };
unsigned num_consts;
- ASSERTED bool ok = emit_shader(c->nir, &options, &v->num_temps, &num_consts);
+ ASSERTED bool ok = emit_shader(c, &v->num_temps, &num_consts);
assert(ok);
/* empty shader, emit NOP */
emit_inst(c, &(struct etna_inst) { .opcode = INST_OPCODE_NOP });
/* assemble instructions, fixing up labels */
- uint32_t *code = MALLOC(c->inst_ptr * 16 + 1024);
+ uint32_t *code = MALLOC(c->inst_ptr * 16);
for (unsigned i = 0; i < c->inst_ptr; i++) {
struct etna_inst *inst = &c->code[i];
if (inst->opcode == INST_OPCODE_BRANCH)
v->code = code;
v->needs_icache = c->inst_ptr > specs->max_instructions;
- copy_uniform_state_to_shader(v, consts, num_consts);
+ copy_uniform_state_to_shader(v, c->consts, num_consts);
if (s->info.stage == MESA_SHADER_FRAGMENT) {
v->input_count_unk8 = 31; /* XXX what is this */
-
- nir_foreach_variable(var, &s->outputs) {
- unsigned reg = c->output_reg[var->data.driver_location];
- switch (var->data.location) {
- case FRAG_RESULT_COLOR:
- case FRAG_RESULT_DATA0: /* DATA0 is used by gallium shaders for color */
- v->ps_color_out_reg = reg;
- break;
- case FRAG_RESULT_DEPTH:
- v->ps_depth_out_reg = reg;
- break;
- default:
- compile_error(c, "Unsupported fs output %s\n", gl_frag_result_name(var->data.location));
- }
- }
assert(v->ps_depth_out_reg <= 0);
- v->outfile.num_reg = 0;
ralloc_free(c->nir);
FREE(c);
return true;
v->input_count_unk8 = DIV_ROUND_UP(v->infile.num_reg + 4, 16); /* XXX what is this */
- sf = &v->outfile;
- sf->num_reg = 0;
- nir_foreach_variable(var, &s->outputs) {
- unsigned native = c->output_reg[var->data.driver_location];
-
- if (var->data.location == VARYING_SLOT_POS) {
- v->vs_pos_out_reg = native;
- continue;
- }
-
- if (var->data.location == VARYING_SLOT_PSIZ) {
- v->vs_pointsize_out_reg = native;
- continue;
- }
-
- sf->reg[sf->num_reg].reg = native;
- sf->reg[sf->num_reg].slot = var->data.location;
- sf->reg[sf->num_reg].num_components = glsl_get_components(var->type);
- sf->num_reg++;
- }
-
/* fill in "mystery meat" load balancing value. This value determines how
* work is scheduled between VS and PS
* in the unified shader architecture. More precisely, it is determined from
projects / mesa.git / blobdiff