src/broadcom/compiler/vir_dump.c

   1 /*
   2  * Copyright © 2016-2017 Broadcom
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "v3d_compiler.h"
  25
  26 static void
  27 vir_print_reg(struct v3d_compile *c, struct qreg reg)
  28 {
  29         static const char *files[] = {
  30                 [QFILE_TEMP] = "t",
  31                 [QFILE_VARY] = "v",
  32                 [QFILE_UNIF] = "u",
  33                 [QFILE_TLB] = "tlb",
  34                 [QFILE_TLBU] = "tlbu",
  35         };
  36         static const char *quniform_names[] = {
  37                 [QUNIFORM_VIEWPORT_X_SCALE] = "vp_x_scale",
  38                 [QUNIFORM_VIEWPORT_Y_SCALE] = "vp_y_scale",
  39                 [QUNIFORM_VIEWPORT_Z_OFFSET] = "vp_z_offset",
  40                 [QUNIFORM_VIEWPORT_Z_SCALE] = "vp_z_scale",
  41         };
  42
  43         switch (reg.file) {
  44
  45         case QFILE_NULL:
  46                 fprintf(stderr, "null");
  47                 break;
  48
  49         case QFILE_LOAD_IMM:
  50                 fprintf(stderr, "0x%08x (%f)", reg.index, uif(reg.index));
  51                 break;
  52
  53         case QFILE_REG:
  54                 fprintf(stderr, "rf%d", reg.index);
  55                 break;
  56
  57         case QFILE_MAGIC:
  58                 fprintf(stderr, "%s", v3d_qpu_magic_waddr_name(reg.index));
  59                 break;
  60
  61         case QFILE_SMALL_IMM:
  62                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
  63                         fprintf(stderr, "%d", reg.index);
  64                 else
  65                         fprintf(stderr, "%f", uif(reg.index));
  66                 break;
  67
  68         case QFILE_VPM:
  69                 fprintf(stderr, "vpm%d.%d",
  70                         reg.index / 4, reg.index % 4);
  71                 break;
  72
  73         case QFILE_TLB:
  74                 fprintf(stderr, "%s", files[reg.file]);
  75                 break;
  76
  77         case QFILE_UNIF: {
  78                 enum quniform_contents contents = c->uniform_contents[reg.index];
  79
  80                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
  81
  82                 switch (contents) {
  83                 case QUNIFORM_CONSTANT:
  84                         fprintf(stderr, " (0x%08x / %f)",
  85                                 c->uniform_data[reg.index],
  86                                 uif(c->uniform_data[reg.index]));
  87                         break;
  88
  89                 case QUNIFORM_UNIFORM:
  90                         fprintf(stderr, " (push[%d])",
  91                                 c->uniform_data[reg.index]);
  92                         break;
  93
  94                 case QUNIFORM_TEXTURE_CONFIG_P1:
  95                         fprintf(stderr, " (tex[%d].p1)",
  96                                 c->uniform_data[reg.index]);
  97                         break;
  98
  99                 case QUNIFORM_TEXTURE_WIDTH:
 100                         fprintf(stderr, " (tex[%d].width)",
 101                                 c->uniform_data[reg.index]);
 102                         break;
 103                 case QUNIFORM_TEXTURE_HEIGHT:
 104                         fprintf(stderr, " (tex[%d].height)",
 105                                 c->uniform_data[reg.index]);
 106                         break;
 107                 case QUNIFORM_TEXTURE_DEPTH:
 108                         fprintf(stderr, " (tex[%d].depth)",
 109                                 c->uniform_data[reg.index]);
 110                         break;
 111                 case QUNIFORM_TEXTURE_ARRAY_SIZE:
 112                         fprintf(stderr, " (tex[%d].array_size)",
 113                                 c->uniform_data[reg.index]);
 114                         break;
 115                 case QUNIFORM_TEXTURE_LEVELS:
 116                         fprintf(stderr, " (tex[%d].levels)",
 117                                 c->uniform_data[reg.index]);
 118                         break;
 119
 120                 case QUNIFORM_UBO_ADDR:
 121                         fprintf(stderr, " (ubo[%d])",
 122                                 c->uniform_data[reg.index]);
 123                         break;
 124
 125                 default:
 126                         if (quniform_contents_is_texture_p0(contents)) {
 127                                 fprintf(stderr, " (tex[%d].p0: 0x%08x)",
 128                                         contents - QUNIFORM_TEXTURE_CONFIG_P0_0,
 129                                         c->uniform_data[reg.index]);
 130                         } else if (contents < ARRAY_SIZE(quniform_names)) {
 131                                 fprintf(stderr, " (%s)",
 132                                         quniform_names[contents]);
 133                         } else {
 134                                 fprintf(stderr, " (%d / 0x%08x)", contents,
 135                                         c->uniform_data[reg.index]);
 136                         }
 137                 }
 138
 139                 break;
 140         }
 141
 142         default:
 143                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 144                 break;
 145         }
 146 }
 147
 148 static void
 149 vir_dump_sig(struct v3d_compile *c, struct qinst *inst)
 150 {
 151         struct v3d_qpu_sig *sig = &inst->qpu.sig;
 152
 153         if (sig->thrsw)
 154                 fprintf(stderr, "; thrsw");
 155         if (sig->ldvary)
 156                 fprintf(stderr, "; ldvary");
 157         if (sig->ldvpm)
 158                 fprintf(stderr, "; ldvpm");
 159         if (sig->ldtmu)
 160                 fprintf(stderr, "; ldtmu");
 161         if (sig->ldunif)
 162                 fprintf(stderr, "; ldunif");
 163         if (sig->wrtmuc)
 164                 fprintf(stderr, "; wrtmuc");
 165 }
 166
 167 static void
 168 vir_dump_alu(struct v3d_compile *c, struct qinst *inst)
 169 {
 170         struct v3d_qpu_instr *instr = &inst->qpu;
 171         int nsrc = vir_get_non_sideband_nsrc(inst);
 172         int sideband_nsrc = vir_get_nsrc(inst);
 173         enum v3d_qpu_input_unpack unpack[2];
 174
 175         if (inst->qpu.alu.add.op != V3D_QPU_A_NOP) {
 176                 fprintf(stderr, "%s", v3d_qpu_add_op_name(instr->alu.add.op));
 177                 fprintf(stderr, "%s", v3d_qpu_cond_name(instr->flags.ac));
 178                 fprintf(stderr, "%s", v3d_qpu_pf_name(instr->flags.apf));
 179                 fprintf(stderr, "%s", v3d_qpu_uf_name(instr->flags.auf));
 180                 fprintf(stderr, " ");
 181
 182                 vir_print_reg(c, inst->dst);
 183                 fprintf(stderr, "%s", v3d_qpu_pack_name(instr->alu.add.output_pack));
 184
 185                 unpack[0] = instr->alu.add.a_unpack;
 186                 unpack[1] = instr->alu.add.b_unpack;
 187         } else {
 188                 fprintf(stderr, "%s", v3d_qpu_mul_op_name(instr->alu.mul.op));
 189                 fprintf(stderr, "%s", v3d_qpu_cond_name(instr->flags.mc));
 190                 fprintf(stderr, "%s", v3d_qpu_pf_name(instr->flags.mpf));
 191                 fprintf(stderr, "%s", v3d_qpu_uf_name(instr->flags.muf));
 192                 fprintf(stderr, " ");
 193
 194                 vir_print_reg(c, inst->dst);
 195                 fprintf(stderr, "%s", v3d_qpu_pack_name(instr->alu.mul.output_pack));
 196
 197                 unpack[0] = instr->alu.mul.a_unpack;
 198                 unpack[1] = instr->alu.mul.b_unpack;
 199         }
 200
 201         for (int i = 0; i < sideband_nsrc; i++) {
 202                 fprintf(stderr, ", ");
 203                 vir_print_reg(c, inst->src[i]);
 204                 if (i < nsrc)
 205                         fprintf(stderr, "%s", v3d_qpu_unpack_name(unpack[i]));
 206         }
 207
 208         vir_dump_sig(c, inst);
 209 }
 210
 211 void
 212 vir_dump_inst(struct v3d_compile *c, struct qinst *inst)
 213 {
 214         struct v3d_qpu_instr *instr = &inst->qpu;
 215
 216         switch (inst->qpu.type) {
 217         case V3D_QPU_INSTR_TYPE_ALU:
 218                 vir_dump_alu(c, inst);
 219                 break;
 220         case V3D_QPU_INSTR_TYPE_BRANCH:
 221                 fprintf(stderr, "b");
 222                 if (instr->branch.ub)
 223                         fprintf(stderr, "u");
 224
 225                 fprintf(stderr, "%s",
 226                         v3d_qpu_branch_cond_name(instr->branch.cond));
 227                 fprintf(stderr, "%s", v3d_qpu_msfign_name(instr->branch.msfign));
 228
 229                 switch (instr->branch.bdi) {
 230                 case V3D_QPU_BRANCH_DEST_ABS:
 231                         fprintf(stderr, "  zero_addr+0x%08x", instr->branch.offset);
 232                         break;
 233
 234                 case V3D_QPU_BRANCH_DEST_REL:
 235                         fprintf(stderr, "  %d", instr->branch.offset);
 236                         break;
 237
 238                 case V3D_QPU_BRANCH_DEST_LINK_REG:
 239                         fprintf(stderr, "  lri");
 240                         break;
 241
 242                 case V3D_QPU_BRANCH_DEST_REGFILE:
 243                         fprintf(stderr, "  rf%d", instr->branch.raddr_a);
 244                         break;
 245                 }
 246
 247                 if (instr->branch.ub) {
 248                         switch (instr->branch.bdu) {
 249                         case V3D_QPU_BRANCH_DEST_ABS:
 250                                 fprintf(stderr, ", a:unif");
 251                                 break;
 252
 253                         case V3D_QPU_BRANCH_DEST_REL:
 254                                 fprintf(stderr, ", r:unif");
 255                                 break;
 256
 257                         case V3D_QPU_BRANCH_DEST_LINK_REG:
 258                                 fprintf(stderr, ", lri");
 259                                 break;
 260
 261                         case V3D_QPU_BRANCH_DEST_REGFILE:
 262                                 fprintf(stderr, ", rf%d", instr->branch.raddr_a);
 263                                 break;
 264                         }
 265                 }
 266
 267                 if (vir_has_implicit_uniform(inst)) {
 268                         fprintf(stderr, " ");
 269                         vir_print_reg(c, inst->src[vir_get_implicit_uniform_src(inst)]);
 270                 }
 271
 272                 break;
 273         }
 274 }
 275
 276 void
 277 vir_dump(struct v3d_compile *c)
 278 {
 279         int ip = 0;
 280
 281         vir_for_each_block(block, c) {
 282                 fprintf(stderr, "BLOCK %d:\n", block->index);
 283                 vir_for_each_inst(inst, block) {
 284                         if (c->temp_start) {
 285                                 bool first = true;
 286
 287                                 for (int i = 0; i < c->num_temps; i++) {
 288                                         if (c->temp_start[i] != ip)
 289                                                 continue;
 290
 291                                         if (first) {
 292                                                 first = false;
 293                                         } else {
 294                                                 fprintf(stderr, ", ");
 295                                         }
 296                                         fprintf(stderr, "S%4d", i);
 297                                 }
 298
 299                                 if (first)
 300                                         fprintf(stderr, "      ");
 301                                 else
 302                                         fprintf(stderr, " ");
 303                         }
 304
 305                         if (c->temp_end) {
 306                                 bool first = true;
 307
 308                                 for (int i = 0; i < c->num_temps; i++) {
 309                                         if (c->temp_end[i] != ip)
 310                                                 continue;
 311
 312                                         if (first) {
 313                                                 first = false;
 314                                         } else {
 315                                                 fprintf(stderr, ", ");
 316                                         }
 317                                         fprintf(stderr, "E%4d", i);
 318                                 }
 319
 320                                 if (first)
 321                                         fprintf(stderr, "      ");
 322                                 else
 323                                         fprintf(stderr, " ");
 324                         }
 325
 326                         vir_dump_inst(c, inst);
 327                         fprintf(stderr, "\n");
 328                         ip++;
 329                 }
 330                 if (block->successors[1]) {
 331                         fprintf(stderr, "-> BLOCK %d, %d\n",
 332                                 block->successors[0]->index,
 333                                 block->successors[1]->index);
 334                 } else if (block->successors[0]) {
 335                         fprintf(stderr, "-> BLOCK %d\n",
 336                                 block->successors[0]->index);
 337                 }
 338         }
 339 }