pan/mdg: eliminate references to ins->alu.op

[mesa.git] / src / panfrost / midgard / midgard_print.c

diff --git a/src/panfrost/midgard/midgard_print.c b/src/panfrost/midgard/midgard_print.c
index e23e7d59817d675288c68bec1c89bfe90cf2e690..44e21966091d217eeee54de9925afde5926552bd 100644 (file)
--- a/src/panfrost/midgard/midgard_print.c
+++ b/src/panfrost/midgard/midgard_print.c
@@ -71,12 +71,17 @@ mir_print_mask(unsigned mask)
 }
 
 static void
-mir_print_swizzle(unsigned *swizzle)
+mir_print_swizzle(unsigned *swizzle, nir_alu_type T)
 {
+        unsigned comps = mir_components_for_type(T);
+
         printf(".");
 
-        for (unsigned i = 0; i < 16; ++i)
-                putchar(components[swizzle[i]]);
+        for (unsigned i = 0; i < comps; ++i) {
+                unsigned C = swizzle[i];
+                assert(C < comps);
+                putchar(components[C]);
+        }
 }
 
 static const char *
@@ -216,7 +221,13 @@ mir_print_constant_component(FILE *fp, const midgard_constants *consts, unsigned
                 break;
 
         case midgard_reg_mode_8:
-                unreachable("XXX TODO: sort out how 8-bit constant encoding works");
+                fprintf(fp, "0x%X", consts->u8[c]);
+
+                if (mod)
+                        fprintf(fp, " /* %u */", mod);
+
+                assert(!half); /* No 4-bit */
+
                 break;
         }
 }
@@ -224,7 +235,6 @@ mir_print_constant_component(FILE *fp, const midgard_constants *consts, unsigned
 static void
 mir_print_embedded_constant(midgard_instruction *ins, unsigned src_idx)
 {
-        unsigned type_size = mir_bytes_for_mode(ins->alu.reg_mode);
         midgard_vector_alu_src src;
 
         assert(src_idx <= 1);
@@ -234,9 +244,9 @@ mir_print_embedded_constant(midgard_instruction *ins, unsigned src_idx)
                 src = vector_alu_from_unsigned(ins->alu.src2);
 
         unsigned *swizzle = ins->swizzle[src_idx];
-        unsigned comp_mask = effective_writemask(&ins->alu, ins->mask);
+        unsigned comp_mask = effective_writemask(ins->op, ins->mask);
         unsigned num_comp = util_bitcount(comp_mask);
-        unsigned max_comp = 16 / type_size;
+        unsigned max_comp = mir_components_for_type(ins->dest_type);
         bool first = true;
 
         printf("#");
@@ -255,13 +265,20 @@ mir_print_embedded_constant(midgard_instruction *ins, unsigned src_idx)
 
                 mir_print_constant_component(stdout, &ins->constants,
                                              swizzle[comp], ins->alu.reg_mode,
-                                             src.half, src.mod, ins->alu.op);
+                                             src.half, src.mod, ins->op);
         }
 
         if (num_comp > 1)
                 printf(")");
 }
 
+#define PRINT_SRC(ins, c) \
+        do { mir_print_index(ins->src[c]); \
+             if (ins->src[c] != ~0 && ins->src_types[c] != nir_type_invalid) { \
+                     pan_print_alu_type(ins->src_types[c], stdout); \
+                     mir_print_swizzle(ins->swizzle[c], ins->src_types[c]); \
+             } } while (0)
+
 void
 mir_print_instruction(midgard_instruction *ins)
 {
@@ -290,9 +307,20 @@ mir_print_instruction(midgard_instruction *ins)
                 else
                         printf("true");
 
+                if (ins->writeout) {
+                        printf(" (c: ");
+                        PRINT_SRC(ins, 0);
+                        printf(", z: ");
+                        PRINT_SRC(ins, 2);
+                        printf(", s: ");
+                        PRINT_SRC(ins, 3);
+                        printf(")");
+                }
+
                 if (ins->branch.target_type != TARGET_DISCARD)
                         printf(" %s -> block(%d)\n",
-                               branch_target_names[ins->branch.target_type],
+                               ins->branch.target_type < 4 ?
+                                       branch_target_names[ins->branch.target_type] : "??",
                                ins->branch.target_block);
 
                 return;
@@ -300,7 +328,7 @@ mir_print_instruction(midgard_instruction *ins)
 
         switch (ins->type) {
         case TAG_ALU_4: {
-                midgard_alu_op op = ins->alu.op;
+                midgard_alu_op op = ins->op;
                 const char *name = alu_opcode_props[op].name;
 
                 if (ins->unit)
@@ -321,6 +349,13 @@ mir_print_instruction(midgard_instruction *ins)
 
         case TAG_TEXTURE_4: {
                 printf("texture");
+
+                if (ins->helper_terminate)
+                        printf(".terminate");
+
+                if (ins->helper_execute)
+                        printf(".execute");
+
                 break;
         }
 
@@ -328,14 +363,16 @@ mir_print_instruction(midgard_instruction *ins)
                 assert(0);
         }
 
-        if (ins->invert || (ins->compact_branch && ins->branch.invert_conditional))
+        if (ins->compact_branch && ins->branch.invert_conditional)
                 printf(".not");
 
         printf(" ");
         mir_print_index(ins->dest);
 
-        if (ins->mask != 0xF)
+        if (ins->dest != ~0) {
+                pan_print_alu_type(ins->dest_type, stdout);
                 mir_print_mask(ins->mask);
+        }
 
         printf(", ");
 
@@ -343,28 +380,22 @@ mir_print_instruction(midgard_instruction *ins)
 
         if (ins->src[0] == r_constant)
                 mir_print_embedded_constant(ins, 0);
-        else {
-                mir_print_index(ins->src[0]);
-                mir_print_swizzle(ins->swizzle[0]);
-        }
+        else
+                PRINT_SRC(ins, 0);
+
         printf(", ");
 
         if (ins->has_inline_constant)
                 printf("#%d", ins->inline_constant);
         else if (ins->src[1] == r_constant)
                 mir_print_embedded_constant(ins, 1);
-        else {
-                mir_print_index(ins->src[1]);
-                mir_print_swizzle(ins->swizzle[1]);
-        }
-
-        printf(", ");
-        mir_print_index(ins->src[2]);
-        mir_print_swizzle(ins->swizzle[2]);
+        else
+                PRINT_SRC(ins, 1);
 
-        printf(", ");
-        mir_print_index(ins->src[3]);
-        mir_print_swizzle(ins->swizzle[3]);
+        for (unsigned c = 2; c <= 3; ++c) {
+                printf(", ");
+                PRINT_SRC(ins, c);
+        }
 
         if (ins->no_spill)
                 printf(" /* no spill */");
@@ -377,9 +408,9 @@ mir_print_instruction(midgard_instruction *ins)
 void
 mir_print_block(midgard_block *block)
 {
-        printf("block%u: {\n", block->source_id);
+        printf("block%u: {\n", block->base.name);
 
-        if (block->is_scheduled) {
+        if (block->scheduled) {
                 mir_foreach_bundle_in_block(block, bundle) {
                         for (unsigned i = 0; i < bundle->instruction_count; ++i)
                                 mir_print_instruction(bundle->instructions[i]);
@@ -394,17 +425,15 @@ mir_print_block(midgard_block *block)
 
         printf("}");
 
-        if (block->nr_successors) {
+        if (block->base.successors[0]) {
                 printf(" -> ");
-                for (unsigned i = 0; i < block->nr_successors; ++i) {
-                        printf("block%u%s", block->successors[i]->source_id,
-                                        (i + 1) != block->nr_successors ? ", " : "");
-                }
+                pan_foreach_successor((&block->base), succ)
+                        printf(" block%u ", succ->name);
         }
 
         printf(" from { ");
         mir_foreach_predecessor(block, pred)
-                printf("block%u ", pred->source_id);
+                printf("block%u ", pred->base.name);
         printf("}");
 
         printf("\n\n");
@@ -414,6 +443,6 @@ void
 mir_print_shader(compiler_context *ctx)
 {
         mir_foreach_block(ctx, block) {
-                mir_print_block(block);
+                mir_print_block((midgard_block *) block);
         }
 }