gen8_instruction *
gen8_generator::next_inst(unsigned opcode)
{
gen8_instruction *inst;
if (nr_inst + 1 > unsigned(store_size)) {
store_size <<= 1;
store = reralloc(mem_ctx, store, gen8_instruction, store_size);
assert(store);
}
next_inst_offset += 16;
inst = &store[nr_inst++];
memset(inst, 0, sizeof(gen8_instruction));
gen8_set_opcode(inst, opcode);
gen8_set_exec_size(inst, default_state.exec_size);
gen8_set_access_mode(inst, default_state.access_mode);
gen8_set_mask_control(inst, default_state.mask_control);
gen8_set_qtr_control(inst, default_state.qtr_control);
gen8_set_cond_modifier(inst, default_state.conditional_mod);
gen8_set_pred_control(inst, default_state.predicate);
gen8_set_pred_inv(inst, default_state.predicate_inverse);
gen8_set_saturate(inst, default_state.saturate);
gen8_set_flag_subreg_nr(inst, default_state.flag_subreg_nr);
return inst;
}
/* Initialize the liveness data to zero and add the given block to the
* worklist.
*/
static bool
init_liveness_block(nir_block *block,
struct live_ssa_defs_state *state)
{
block->live_in = reralloc(block, block->live_in, BITSET_WORD,
state->bitset_words);
memset(block->live_in, 0, state->bitset_words * sizeof(BITSET_WORD));
block->live_out = reralloc(block, block->live_out, BITSET_WORD,
state->bitset_words);
memset(block->live_out, 0, state->bitset_words * sizeof(BITSET_WORD));
nir_block_worklist_push_head(&state->worklist, block);
return true;
}
void
qpu_serialize_one_inst(struct vc4_compile *c, uint64_t inst)
{
if (c->qpu_inst_count >= c->qpu_inst_size) {
c->qpu_inst_size = MAX2(16, c->qpu_inst_size * 2);
c->qpu_insts = reralloc(c, c->qpu_insts,
uint64_t, c->qpu_inst_size);
}
c->qpu_insts[c->qpu_inst_count++] = inst;
}
void
cl_ensure_space(struct vc4_cl *cl, uint32_t space)
{
if ((cl->next - cl->base) + space <= cl->size)
return;
uint32_t size = MAX2(cl->size + space, cl->size * 2);
uint32_t offset = cl->next -cl->base;
cl->base = reralloc(ralloc_parent(cl->base), cl->base, uint8_t, size);
cl->size = size;
cl->next = cl->base + offset;
}
struct qreg
vir_get_temp(struct v3d_compile *c)
{
struct qreg reg;
reg.file = QFILE_TEMP;
reg.index = c->num_temps++;
if (c->num_temps > c->defs_array_size) {
uint32_t old_size = c->defs_array_size;
c->defs_array_size = MAX2(old_size * 2, 16);
c->defs = reralloc(c, c->defs, struct qinst *,
c->defs_array_size);
memset(&c->defs[old_size], 0,
sizeof(c->defs[0]) * (c->defs_array_size - old_size));
c->spillable = reralloc(c, c->spillable,
BITSET_WORD,
BITSET_WORDS(c->defs_array_size));
for (int i = old_size; i < c->defs_array_size; i++)
BITSET_SET(c->spillable, i);
}
static void
lower_sampler(nir_tex_instr *instr, struct gl_shader_program *shader_program,
const struct gl_program *prog, void *mem_ctx)
{
if (instr->sampler == NULL)
return;
/* Get the name and the offset */
instr->sampler_index = 0;
bool has_indirect = false;
char *name = ralloc_strdup(mem_ctx, instr->sampler->var->name);
for (nir_deref *deref = &instr->sampler->deref;
deref->child; deref = deref->child) {
switch (deref->child->deref_type) {
case nir_deref_type_array: {
nir_deref_array *deref_array = nir_deref_as_array(deref->child);
/* XXX: We're assuming here that the indirect is the last array
* thing we have. This should be ok for now as we don't support
* arrays_of_arrays yet.
*/
assert(!has_indirect);
instr->sampler_index *= glsl_get_length(deref->type);
switch (deref_array->deref_array_type) {
case nir_deref_array_type_direct:
instr->sampler_index += deref_array->base_offset;
if (deref_array->deref.child)
ralloc_asprintf_append(&name, "[%u]", deref_array->base_offset);
break;
case nir_deref_array_type_indirect: {
assert(!has_indirect);
instr->src = reralloc(mem_ctx, instr->src, nir_tex_src,
instr->num_srcs + 1);
memset(&instr->src[instr->num_srcs], 0, sizeof *instr->src);
instr->src[instr->num_srcs].src_type = nir_tex_src_sampler_offset;
instr->num_srcs++;
nir_instr_rewrite_src(&instr->instr,
&instr->src[instr->num_srcs - 1].src,
deref_array->indirect);
instr->sampler_array_size = glsl_get_length(deref->type);
nir_src empty;
memset(&empty, 0, sizeof empty);
nir_instr_rewrite_src(&instr->instr, &deref_array->indirect, empty);
if (deref_array->deref.child)
ralloc_strcat(&name, "[0]");
break;
}
case nir_deref_array_type_wildcard:
unreachable("Cannot copy samplers");
default:
unreachable("Invalid deref array type");
}
break;
}
case nir_deref_type_struct: {
nir_deref_struct *deref_struct = nir_deref_as_struct(deref->child);
const char *field = glsl_get_struct_elem_name(deref->type,
deref_struct->index);
ralloc_asprintf_append(&name, ".%s", field);
break;
}
default:
unreachable("Invalid deref type");
break;
}
}
instr->sampler_index += get_sampler_index(shader_program, name, prog);
instr->sampler = NULL;
}
