* SOFTWARE.
*/
+/* #define NV50PC_DEBUG */
+
#include "nv50_pc.h"
#include "nv50_program.h"
case NV_OP_XOR:
case NV_OP_SHL:
case NV_OP_SHR:
- return (s == 1) && (nvi->def[0]->reg.file == NV_FILE_GPR);
+ return (s == 1) && (nvi->src[0]->value->reg.file == NV_FILE_GPR) &&
+ (nvi->def[0]->reg.file == NV_FILE_GPR);
case NV_OP_MOV:
assert(s == 0);
return (nvi->def[0]->reg.file == NV_FILE_GPR);
boolean
nv50_nvi_can_load(struct nv_instruction *nvi, int s, struct nv_value *value)
{
+ int i;
+
+ for (i = 0; i < 3 && nvi->src[i]; ++i)
+ if (nvi->src[i]->value->reg.file == NV_FILE_IMM)
+ return FALSE;
+
switch (nvi->opcode) {
case NV_OP_ABS:
case NV_OP_ADD:
}
}
+/* Return whether this instruction can be executed conditionally. */
+boolean
+nv50_nvi_can_predicate(struct nv_instruction *nvi)
+{
+ int i;
+
+ if (nvi->flags_src)
+ return FALSE;
+ for (i = 0; i < 4 && nvi->src[i]; ++i)
+ if (nvi->src[i]->value->reg.file == NV_FILE_IMM)
+ return FALSE;
+ return TRUE;
+}
+
ubyte
nv50_supported_src_mods(uint opcode, int s)
{
return n;
}
+struct nv_value *
+nvcg_find_constant(struct nv_ref *ref)
+{
+ struct nv_value *src;
+
+ if (!ref)
+ return NULL;
+
+ src = ref->value;
+ while (src->insn && src->insn->opcode == NV_OP_MOV) {
+ assert(!src->insn->src[0]->mod);
+ src = src->insn->src[0]->value;
+ }
+ if ((src->reg.file == NV_FILE_IMM) ||
+ (src->insn && src->insn->opcode == NV_OP_LDA &&
+ src->insn->src[0]->value->reg.file >= NV_FILE_MEM_C(0) &&
+ src->insn->src[0]->value->reg.file <= NV_FILE_MEM_C(15)))
+ return src;
+ return NULL;
+}
+
+struct nv_value *
+nvcg_find_immediate(struct nv_ref *ref)
+{
+ struct nv_value *src = nvcg_find_constant(ref);
+
+ return (src && src->reg.file == NV_FILE_IMM) ? src : NULL;
+}
+
static void
nv_pc_free_refs(struct nv_pc *pc)
{
FREE(pc->refs[i]);
}
+static const char *
+edge_name(ubyte type)
+{
+ switch (type) {
+ case CFG_EDGE_FORWARD: return "forward";
+ case CFG_EDGE_BACK: return "back";
+ case CFG_EDGE_LOOP_ENTER: return "loop";
+ case CFG_EDGE_LOOP_LEAVE: return "break";
+ case CFG_EDGE_FAKE: return "fake";
+ default:
+ return "?";
+ }
+}
+
void
-nv_print_program(struct nv_basic_block *b)
+nv_pc_pass_in_order(struct nv_basic_block *root, nv_pc_pass_func f, void *priv)
{
- struct nv_instruction *i = b->phi;
+ struct nv_basic_block *bb[64], *bbb[16], *b;
+ int j, p, pp;
+
+ bb[0] = root;
+ p = 1;
+ pp = 0;
+
+ while (p > 0) {
+ b = bb[--p];
+ b->priv = 0;
+
+ for (j = 1; j >= 0; --j) {
+ if (!b->out[j])
+ continue;
+
+ switch (b->out_kind[j]) {
+ case CFG_EDGE_BACK:
+ continue;
+ case CFG_EDGE_FORWARD:
+ case CFG_EDGE_FAKE:
+ if (++b->out[j]->priv == b->out[j]->num_in)
+ bb[p++] = b->out[j];
+ break;
+ case CFG_EDGE_LOOP_ENTER:
+ bb[p++] = b->out[j];
+ break;
+ case CFG_EDGE_LOOP_LEAVE:
+ bbb[pp++] = b->out[j];
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ }
+
+ f(priv, b);
+
+ if (!p) {
+ p = pp;
+ for (; pp > 0; --pp)
+ bb[pp - 1] = bbb[pp - 1];
+ }
+ }
+}
- b->priv = 0;
+static void
+nv_do_print_program(void *priv, struct nv_basic_block *b)
+{
+ struct nv_instruction *i = b->phi;
debug_printf("=== BB %i ", b->id);
if (b->out[0])
- debug_printf("(--0> %i) ", b->out[0]->id);
+ debug_printf("[%s -> %i] ", edge_name(b->out_kind[0]), b->out[0]->id);
if (b->out[1])
- debug_printf("(--1> %i) ", b->out[1]->id);
+ debug_printf("[%s -> %i] ", edge_name(b->out_kind[1]), b->out[1]->id);
debug_printf("===\n");
+ i = b->phi;
if (!i)
i = b->entry;
for (; i; i = i->next)
nv_print_instruction(i);
+}
- if (!b->out[0]) {
- debug_printf("END\n\n");
- return;
- }
- if (!b->out[1] && ++(b->out[0]->priv) != b->out[0]->num_in)
- return;
-
- if (b->out[0] != b)
- nv_print_program(b->out[0]);
+void
+nv_print_program(struct nv_basic_block *root)
+{
+ nv_pc_pass_in_order(root, nv_do_print_program, root);
- if (b->out[1] && b->out[1] != b)
- nv_print_program(b->out[1]);
+ debug_printf("END\n\n");
}
static INLINE void
uint32_t *code = pc->emit;
int n;
- debug_printf("emitting program: size = %u\n", pc->bin_size);
+ NV50_DBGMSG("emitting program: size = %u\n", pc->bin_size);
for (n = 0; n < pc->num_blocks; ++n) {
struct nv_instruction *i;
assert(pc->emit == &code[pc->bin_size / 4]);
/* XXX: we can do better than this ... */
- if ((pc->emit[-2] & 2) || (pc->emit[-1] & 3) == 3) {
+ if (!(pc->emit[-2] & 1) || (pc->emit[-2] & 2) || (pc->emit[-1] & 3)) {
pc->emit[0] = 0xf0000001;
pc->emit[1] = 0xe0000000;
pc->bin_size += 8;
pc->emit = code;
code[pc->bin_size / 4 - 1] |= 1;
+#ifdef NV50PC_DEBUG
nvcg_show_bincode(pc);
+#endif
return 0;
}
ret = nv50_tgsi_to_nc(pc, ti);
if (ret)
goto out;
+#ifdef NV50PC_DEBUG
+ nv_print_program(pc->root);
+#endif
/* optimization */
ret = nv_pc_exec_pass0(pc);
if (ret)
goto out;
+#ifdef NV50PC_DEBUG
+ nv_print_program(pc->root);
+#endif
/* register allocation */
ret = nv_pc_exec_pass1(pc);
if (ret)
goto out;
+#ifdef NV50PC_DEBUG
+ nv_print_program(pc->root);
+#endif
/* prepare for emission */
ret = nv_pc_exec_pass2(pc);
ti->p->fixups = pc->fixups;
ti->p->num_fixups = pc->num_fixups;
- debug_printf("SHADER TRANSLATION - %s\n", ret ? "failure" : "success");
+ NV50_DBGMSG("SHADER TRANSLATION - %s\n", ret ? "failure" : "success");
out:
nv_pc_free_refs(pc);
if (nvi == b->phi) {
if (nvi->opcode != NV_OP_PHI)
- debug_printf("NOTE: b->phi points to non-PHI instruction\n");
+ NV50_DBGMSG("NOTE: b->phi points to non-PHI instruction\n");
assert(!nvi->prev);
if (!nvi->next || nvi->next->opcode != NV_OP_PHI)
i1->next->prev = i1;
}
-void nvbb_attach_block(struct nv_basic_block *parent, struct nv_basic_block *b)
+void
+nvbb_attach_block(struct nv_basic_block *parent,
+ struct nv_basic_block *b, ubyte edge_kind)
{
+ assert(b->num_in < 8);
+
if (parent->out[0]) {
assert(!parent->out[1]);
parent->out[1] = b;
- } else
+ parent->out_kind[1] = edge_kind;
+ } else {
parent->out[0] = b;
+ parent->out_kind[0] = edge_kind;
+ }
- b->in[b->num_in++] = parent;
+ b->in[b->num_in] = parent;
+ b->in_kind[b->num_in++] = edge_kind;
}
-int
+/* NOTE: all BRKs are treated as conditional, so there are 2 outgoing BBs */
+
+boolean
nvbb_dominated_by(struct nv_basic_block *b, struct nv_basic_block *d)
{
- int j, n;
+ int j;
if (b == d)
- return 1;
+ return TRUE;
- n = 0;
for (j = 0; j < b->num_in; ++j)
- n += nvbb_dominated_by(b->in[j], d);
+ if ((b->in_kind[j] != CFG_EDGE_BACK) && !nvbb_dominated_by(b->in[j], d))
+ return FALSE;
- return (n && (n == b->num_in)) ? 1 : 0;
+ return j ? TRUE : FALSE;
}
/* check if bf (future) can be reached from bp (past) */
if (bp == bt)
return FALSE;
- if (bp->out[0] && bp->out[0] != bp &&
+ if (bp->out[0] && !IS_WALL_EDGE(bp->out_kind[0]) &&
nvbb_reachable_by(bf, bp->out[0], bt))
return TRUE;
- if (bp->out[1] && bp->out[1] != bp &&
+ if (bp->out[1] && !IS_WALL_EDGE(bp->out_kind[1]) &&
nvbb_reachable_by(bf, bp->out[1], bt))
return TRUE;
return FALSE;
}
+static struct nv_basic_block *
+nvbb_find_dom_frontier(struct nv_basic_block *b, struct nv_basic_block *df)
+{
+ struct nv_basic_block *out;
+ int i;
+
+ if (!nvbb_dominated_by(df, b)) {
+ for (i = 0; i < df->num_in; ++i) {
+ if (df->in_kind[i] == CFG_EDGE_BACK)
+ continue;
+ if (nvbb_dominated_by(df->in[i], b))
+ return df;
+ }
+ }
+ for (i = 0; i < 2 && df->out[i]; ++i) {
+ if (df->out_kind[i] == CFG_EDGE_BACK)
+ continue;
+ if ((out = nvbb_find_dom_frontier(b, df->out[i])))
+ return out;
+ }
+ return NULL;
+}
+
struct nv_basic_block *
nvbb_dom_frontier(struct nv_basic_block *b)
{
- struct nv_basic_block *df = b->out[0];
-
- assert(df);
- while (nvbb_dominated_by(df, b) ||
- (!nvbb_dominated_by(df->in[0], b) &&
- (!df->in[1] || !nvbb_dominated_by(df->in[1], b)))) {
- df = df->out[0];
- assert(df);
- }
- assert(df);
- return df;
+ struct nv_basic_block *df;
+ int i;
+
+ for (i = 0; i < 2 && b->out[i]; ++i)
+ if ((df = nvbb_find_dom_frontier(b, b->out[i])))
+ return df;
+ return NULL;
}
projects / mesa.git / blobdiff