*/
#include "util/u_memory.h"
-#include "util/u_simple_list.h"
#include "util/ralloc.h"
#include "vc4_qir.h"
const char *name;
uint8_t ndst, nsrc;
bool has_side_effects;
+ bool multi_instruction;
};
static const struct qir_op_info qir_op_info[] = {
[QOP_MOV] = { "mov", 1, 1 },
+ [QOP_FMOV] = { "fmov", 1, 1 },
+ [QOP_MMOV] = { "mmov", 1, 1 },
[QOP_FADD] = { "fadd", 1, 2 },
[QOP_FSUB] = { "fsub", 1, 2 },
[QOP_FMUL] = { "fmul", 1, 2 },
[QOP_MUL24] = { "mul24", 1, 2 },
+ [QOP_V8MULD] = {"v8muld", 1, 2 },
+ [QOP_V8MIN] = {"v8min", 1, 2 },
+ [QOP_V8MAX] = {"v8max", 1, 2 },
+ [QOP_V8ADDS] = {"v8adds", 1, 2 },
+ [QOP_V8SUBS] = {"v8subs", 1, 2 },
[QOP_FMIN] = { "fmin", 1, 2 },
[QOP_FMAX] = { "fmax", 1, 2 },
[QOP_FMINABS] = { "fminabs", 1, 2 },
[QOP_XOR] = { "xor", 1, 2 },
[QOP_NOT] = { "not", 1, 1 },
- [QOP_SF] = { "sf", 0, 1 },
- [QOP_SEL_X_0_NS] = { "fsel_x_0_ns", 1, 1 },
- [QOP_SEL_X_0_NC] = { "fsel_x_0_nc", 1, 1 },
- [QOP_SEL_X_0_ZS] = { "fsel_x_0_zs", 1, 1 },
- [QOP_SEL_X_0_ZC] = { "fsel_x_0_zc", 1, 1 },
- [QOP_SEL_X_Y_NS] = { "fsel_x_y_ns", 1, 2 },
- [QOP_SEL_X_Y_NC] = { "fsel_x_y_nc", 1, 2 },
- [QOP_SEL_X_Y_ZS] = { "fsel_x_y_zs", 1, 2 },
- [QOP_SEL_X_Y_ZC] = { "fsel_x_y_zc", 1, 2 },
-
- [QOP_RCP] = { "rcp", 1, 1 },
- [QOP_RSQ] = { "rsq", 1, 1 },
- [QOP_EXP2] = { "exp2", 1, 2 },
- [QOP_LOG2] = { "log2", 1, 2 },
- [QOP_PACK_COLORS] = { "pack_colors", 1, 4 },
- [QOP_PACK_SCALED] = { "pack_scaled", 1, 2 },
- [QOP_VPM_WRITE] = { "vpm_write", 0, 1, true },
- [QOP_VPM_READ] = { "vpm_read", 0, 1, true },
+ [QOP_RCP] = { "rcp", 1, 1, false, true },
+ [QOP_RSQ] = { "rsq", 1, 1, false, true },
+ [QOP_EXP2] = { "exp2", 1, 2, false, true },
+ [QOP_LOG2] = { "log2", 1, 2, false, true },
[QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
[QOP_TLB_STENCIL_SETUP] = { "tlb_stencil_setup", 0, 1, true },
[QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
[QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
+ [QOP_TLB_COLOR_WRITE_MS] = { "tlb_color_ms", 0, 1, true },
[QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0 },
+ [QOP_MS_MASK] = { "ms_mask", 0, 1, true },
[QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
[QOP_FRAG_X] = { "frag_x", 1, 0 },
[QOP_TEX_B] = { "tex_b", 0, 2 },
[QOP_TEX_DIRECT] = { "tex_direct", 0, 2 },
[QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
- [QOP_R4_UNPACK_A] = { "r4_unpack_a", 1, 1 },
- [QOP_R4_UNPACK_B] = { "r4_unpack_b", 1, 1 },
- [QOP_R4_UNPACK_C] = { "r4_unpack_c", 1, 1 },
- [QOP_R4_UNPACK_D] = { "r4_unpack_d", 1, 1 },
- [QOP_UNPACK_8A_F] = { "unpack_8a_f", 1, 1 },
- [QOP_UNPACK_8B_F] = { "unpack_8b_f", 1, 1 },
- [QOP_UNPACK_8C_F] = { "unpack_8c_f", 1, 1 },
- [QOP_UNPACK_8D_F] = { "unpack_8d_f", 1, 1 },
- [QOP_UNPACK_16A_F] = { "unpack_16a_f", 1, 1 },
- [QOP_UNPACK_16B_F] = { "unpack_16b_f", 1, 1 },
- [QOP_UNPACK_8A_I] = { "unpack_8a_i", 1, 1 },
- [QOP_UNPACK_8B_I] = { "unpack_8b_i", 1, 1 },
- [QOP_UNPACK_8C_I] = { "unpack_8c_i", 1, 1 },
- [QOP_UNPACK_8D_I] = { "unpack_8d_i", 1, 1 },
- [QOP_UNPACK_16A_I] = { "unpack_16a_i", 1, 1 },
- [QOP_UNPACK_16B_I] = { "unpack_16b_i", 1, 1 },
};
static const char *
*/
bool
qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
+{
+ return qir_op_info[inst->op].has_side_effects;
+}
+
+bool
+qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
{
/* We can dead-code eliminate varyings, because we only tell the VS
* about the live ones at the end. But we have to preserve the
*/
for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
if (inst->src[i].file == QFILE_VARY &&
- c->input_semantics[inst->src[i].index].semantic == 0xff) {
+ c->input_slots[inst->src[i].index].slot == 0xff) {
return true;
}
+
+ if (inst->src[i].file == QFILE_VPM)
+ return true;
}
- return qir_op_info[inst->op].has_side_effects;
+ if (inst->dst.file == QFILE_VPM)
+ return true;
+
+ return false;
}
bool
-qir_depends_on_flags(struct qinst *inst)
+qir_is_multi_instruction(struct qinst *inst)
+{
+ return qir_op_info[inst->op].multi_instruction;
+}
+
+bool
+qir_is_mul(struct qinst *inst)
{
switch (inst->op) {
- case QOP_SEL_X_0_NS:
- case QOP_SEL_X_0_NC:
- case QOP_SEL_X_0_ZS:
- case QOP_SEL_X_0_ZC:
- case QOP_SEL_X_Y_NS:
- case QOP_SEL_X_Y_NC:
- case QOP_SEL_X_Y_ZS:
- case QOP_SEL_X_Y_ZC:
+ case QOP_MMOV:
+ case QOP_FMUL:
+ case QOP_MUL24:
+ case QOP_V8MULD:
+ case QOP_V8MIN:
+ case QOP_V8MAX:
+ case QOP_V8ADDS:
+ case QOP_V8SUBS:
return true;
default:
return false;
}
bool
-qir_writes_r4(struct qinst *inst)
+qir_is_float_input(struct qinst *inst)
{
switch (inst->op) {
- case QOP_TEX_RESULT:
- case QOP_TLB_COLOR_READ:
- case QOP_RCP:
- case QOP_RSQ:
- case QOP_EXP2:
- case QOP_LOG2:
+ case QOP_FMOV:
+ case QOP_FMUL:
+ case QOP_FADD:
+ case QOP_FSUB:
+ case QOP_FMIN:
+ case QOP_FMAX:
+ case QOP_FMINABS:
+ case QOP_FMAXABS:
+ case QOP_FTOI:
return true;
default:
return false;
}
bool
-qir_reads_r4(struct qinst *inst)
+qir_is_raw_mov(struct qinst *inst)
+{
+ return ((inst->op == QOP_MOV ||
+ inst->op == QOP_FMOV ||
+ inst->op == QOP_MMOV) &&
+ inst->cond == QPU_COND_ALWAYS &&
+ !inst->dst.pack &&
+ !inst->src[0].pack);
+}
+
+bool
+qir_is_tex(struct qinst *inst)
+{
+ return inst->op >= QOP_TEX_S && inst->op <= QOP_TEX_DIRECT;
+}
+
+bool
+qir_depends_on_flags(struct qinst *inst)
+{
+ return (inst->cond != QPU_COND_ALWAYS &&
+ inst->cond != QPU_COND_NEVER);
+}
+
+bool
+qir_writes_r4(struct qinst *inst)
{
switch (inst->op) {
- case QOP_R4_UNPACK_A:
- case QOP_R4_UNPACK_B:
- case QOP_R4_UNPACK_C:
- case QOP_R4_UNPACK_D:
+ case QOP_TEX_RESULT:
+ case QOP_TLB_COLOR_READ:
+ case QOP_RCP:
+ case QOP_RSQ:
+ case QOP_EXP2:
+ case QOP_LOG2:
return true;
default:
return false;
}
static void
-qir_print_reg(struct vc4_compile *c, struct qreg reg)
+qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
{
static const char *files[] = {
[QFILE_TEMP] = "t",
fprintf(stderr, "%d", reg.index);
else
fprintf(stderr, "%f", uif(reg.index));
+ } else if (reg.file == QFILE_VPM) {
+ if (write) {
+ fprintf(stderr, "vpm");
+ } else {
+ fprintf(stderr, "vpm%d.%d",
+ reg.index / 4, reg.index % 4);
+ }
} else {
fprintf(stderr, "%s%d", files[reg.file], reg.index);
}
void
qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
{
- fprintf(stderr, "%s ", qir_get_op_name(inst->op));
-
- qir_print_reg(c, inst->dst);
+ static const char *conditions[] = {
+ [QPU_COND_ALWAYS] = "",
+ [QPU_COND_NEVER] = ".never",
+ [QPU_COND_ZS] = ".zs",
+ [QPU_COND_ZC] = ".zc",
+ [QPU_COND_NS] = ".ns",
+ [QPU_COND_NC] = ".nc",
+ [QPU_COND_CS] = ".cs",
+ [QPU_COND_CC] = ".cc",
+ };
+ fprintf(stderr, "%s%s%s ",
+ qir_get_op_name(inst->op),
+ conditions[inst->cond],
+ inst->sf ? ".sf" : "");
+
+ qir_print_reg(c, inst->dst, true);
+ if (inst->dst.pack) {
+ if (inst->dst.pack) {
+ if (qir_is_mul(inst))
+ vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
+ else
+ vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
+ }
+ }
for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
fprintf(stderr, ", ");
- qir_print_reg(c, inst->src[i]);
+ qir_print_reg(c, inst->src[i], false);
+ vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
}
}
void
qir_dump(struct vc4_compile *c)
{
- struct simple_node *node;
-
- foreach(node, &c->instructions) {
- struct qinst *inst = (struct qinst *)node;
+ list_for_each_entry(struct qinst, inst, &c->instructions, link) {
qir_dump_inst(c, inst);
fprintf(stderr, "\n");
}
reg.file = QFILE_TEMP;
reg.index = c->num_temps++;
+ reg.pack = 0;
+
+ 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));
+ }
return reg;
}
inst->src = calloc(2, sizeof(inst->src[0]));
inst->src[0] = src0;
inst->src[1] = src1;
+ inst->cond = QPU_COND_ALWAYS;
return inst;
}
void
qir_emit(struct vc4_compile *c, struct qinst *inst)
{
- insert_at_tail(&c->instructions, &inst->link);
+ if (inst->dst.file == QFILE_TEMP)
+ c->defs[inst->dst.index] = inst;
+
+ qir_emit_nodef(c, inst);
}
bool
{
struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
- make_empty_list(&c->instructions);
+ list_inithead(&c->instructions);
c->output_position_index = -1;
- c->output_clipvertex_index = -1;
c->output_color_index = -1;
c->output_point_size_index = -1;
+ c->output_sample_mask_index = -1;
+
+ c->def_ht = _mesa_hash_table_create(c, _mesa_hash_pointer,
+ _mesa_key_pointer_equal);
return c;
}
void
-qir_remove_instruction(struct qinst *qinst)
+qir_remove_instruction(struct vc4_compile *c, struct qinst *qinst)
{
- remove_from_list(&qinst->link);
+ if (qinst->dst.file == QFILE_TEMP)
+ c->defs[qinst->dst.index] = NULL;
+
+ list_del(&qinst->link);
free(qinst->src);
free(qinst);
}
struct qreg
-qir_follow_movs(struct qinst **defs, struct qreg reg)
+qir_follow_movs(struct vc4_compile *c, struct qreg reg)
{
- while (reg.file == QFILE_TEMP && defs[reg.index]->op == QOP_MOV)
- reg = defs[reg.index]->src[0];
+ int pack = reg.pack;
+
+ while (reg.file == QFILE_TEMP &&
+ c->defs[reg.index] &&
+ (c->defs[reg.index]->op == QOP_MOV ||
+ c->defs[reg.index]->op == QOP_FMOV ||
+ c->defs[reg.index]->op == QOP_MMOV)&&
+ !c->defs[reg.index]->dst.pack &&
+ !c->defs[reg.index]->src[0].pack) {
+ reg = c->defs[reg.index]->src[0];
+ }
+ reg.pack = pack;
return reg;
}
void
qir_compile_destroy(struct vc4_compile *c)
{
- while (!is_empty_list(&c->instructions)) {
+ while (!list_empty(&c->instructions)) {
struct qinst *qinst =
- (struct qinst *)first_elem(&c->instructions);
- qir_remove_instruction(qinst);
+ (struct qinst *)c->instructions.next;
+ qir_remove_instruction(c, qinst);
}
ralloc_free(c);
return names[stage];
}
+struct qreg
+qir_uniform(struct vc4_compile *c,
+ enum quniform_contents contents,
+ uint32_t data)
+{
+ for (int i = 0; i < c->num_uniforms; i++) {
+ if (c->uniform_contents[i] == contents &&
+ c->uniform_data[i] == data) {
+ return (struct qreg) { QFILE_UNIF, i };
+ }
+ }
+
+ uint32_t uniform = c->num_uniforms++;
+ struct qreg u = { QFILE_UNIF, uniform };
+
+ if (uniform >= c->uniform_array_size) {
+ c->uniform_array_size = MAX2(MAX2(16, uniform + 1),
+ c->uniform_array_size * 2);
+
+ c->uniform_data = reralloc(c, c->uniform_data,
+ uint32_t,
+ c->uniform_array_size);
+ c->uniform_contents = reralloc(c, c->uniform_contents,
+ enum quniform_contents,
+ c->uniform_array_size);
+ }
+
+ c->uniform_contents[uniform] = contents;
+ c->uniform_data[uniform] = data;
+
+ return u;
+}
+
+void
+qir_SF(struct vc4_compile *c, struct qreg src)
+{
+ struct qinst *last_inst = NULL;
+ if (!list_empty(&c->instructions))
+ last_inst = (struct qinst *)c->instructions.prev;
+
+ if (src.file != QFILE_TEMP ||
+ !c->defs[src.index] ||
+ last_inst != c->defs[src.index] ||
+ qir_is_multi_instruction(last_inst)) {
+ src = qir_MOV(c, src);
+ last_inst = (struct qinst *)c->instructions.prev;
+ }
+ last_inst->sf = true;
+}
+
#define OPTPASS(func) \
do { \
bool stage_progress = func(c); \
OPTPASS(qir_opt_algebraic);
OPTPASS(qir_opt_cse);
+ OPTPASS(qir_opt_constant_folding);
OPTPASS(qir_opt_copy_propagation);
OPTPASS(qir_opt_dead_code);
OPTPASS(qir_opt_small_immediates);
+ OPTPASS(qir_opt_vpm_writes);
if (!progress)
break;
projects / mesa.git / blobdiff