src/freedreno/ir3/ir3_print.c

   1 /*
   2  * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
   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 FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Rob Clark <robclark@freedesktop.org>
  25  */
  26
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29
  30 #include "ir3.h"
  31
  32 #define PTRID(x) ((unsigned long)(x))
  33
  34 /* ansi escape sequences: */
  35 #define RESET   "\x1b[0m"
  36 #define RED             "\x1b[0;31m"
  37 #define GREEN   "\x1b[0;32m"
  38 #define BLUE    "\x1b[0;34m"
  39 #define MAGENTA "\x1b[0;35m"
  40
  41 /* syntax coloring, mostly to make it easier to see different sorts of
  42  * srcs (immediate, constant, ssa, array, ...)
  43  */
  44 #define SYN_REG(x)              RED x RESET
  45 #define SYN_IMMED(x)    GREEN x RESET
  46 #define SYN_CONST(x)    GREEN x RESET
  47 #define SYN_SSA(x)              BLUE x RESET
  48 #define SYN_ARRAY(x)    MAGENTA x RESET
  49
  50 static const char *
  51 type_name(type_t type)
  52 {
  53         static const char *type_names[] = {
  54                         [TYPE_F16] = "f16",
  55                         [TYPE_F32] = "f32",
  56                         [TYPE_U16] = "u16",
  57                         [TYPE_U32] = "u32",
  58                         [TYPE_S16] = "s16",
  59                         [TYPE_S32] = "s32",
  60                         [TYPE_U8]  = "u8",
  61                         [TYPE_S8]  = "s8",
  62         };
  63         return type_names[type];
  64 }
  65
  66 static void print_instr_name(struct ir3_instruction *instr, bool flags)
  67 {
  68         if (!instr)
  69                 return;
  70 #ifdef DEBUG
  71         printf("%04u:", instr->serialno);
  72 #endif
  73         printf("%04u:", instr->name);
  74         printf("%04u:", instr->ip);
  75         if (instr->flags & IR3_INSTR_UNUSED) {
  76                 printf("XXX: ");
  77         } else {
  78                 printf("%03u: ", instr->use_count);
  79         }
  80
  81         if (flags) {
  82                 printf("\t");
  83                 if (instr->flags & IR3_INSTR_SY)
  84                         printf("(sy)");
  85                 if (instr->flags & IR3_INSTR_SS)
  86                         printf("(ss)");
  87                 if (instr->flags & IR3_INSTR_JP)
  88                         printf("(jp)");
  89                 if (instr->repeat)
  90                         printf("(rpt%d)", instr->repeat);
  91                 if (instr->nop)
  92                         printf("(nop%d)", instr->nop);
  93                 if (instr->flags & IR3_INSTR_UL)
  94                         printf("(ul)");
  95         } else {
  96                 printf(" ");
  97         }
  98
  99         if (is_meta(instr)) {
 100                 switch (instr->opc) {
 101                 case OPC_META_INPUT:  printf("_meta:in");   break;
 102                 case OPC_META_SPLIT:        printf("_meta:split");        break;
 103                 case OPC_META_COLLECT:      printf("_meta:collect");      break;
 104                 case OPC_META_TEX_PREFETCH: printf("_meta:tex_prefetch"); break;
 105
 106                 /* shouldn't hit here.. just for debugging: */
 107                 default: printf("_meta:%d", instr->opc);    break;
 108                 }
 109         } else if (instr->opc == OPC_MOV) {
 110                 if (instr->cat1.src_type == instr->cat1.dst_type)
 111                         printf("mov");
 112                 else
 113                         printf("cov");
 114                 printf(".%s%s", type_name(instr->cat1.src_type),
 115                                 type_name(instr->cat1.dst_type));
 116         } else {
 117                 printf("%s", ir3_instr_name(instr));
 118                 if (instr->flags & IR3_INSTR_3D)
 119                         printf(".3d");
 120                 if (instr->flags & IR3_INSTR_A)
 121                         printf(".a");
 122                 if (instr->flags & IR3_INSTR_O)
 123                         printf(".o");
 124                 if (instr->flags & IR3_INSTR_P)
 125                         printf(".p");
 126                 if (instr->flags & IR3_INSTR_S)
 127                         printf(".s");
 128                 if (instr->flags & IR3_INSTR_A1EN)
 129                         printf(".a1en");
 130                 if (instr->opc == OPC_LDC)
 131                         printf(".offset%d", instr->cat6.d);
 132                 if (instr->flags & IR3_INSTR_B) {
 133                         printf(".base%d",
 134                                    is_tex(instr) ? instr->cat5.tex_base : instr->cat6.base);
 135                 }
 136                 if (instr->flags & IR3_INSTR_S2EN)
 137                         printf(".s2en");
 138
 139                 static const char *cond[0x7] = {
 140                                 "lt",
 141                                 "le",
 142                                 "gt",
 143                                 "ge",
 144                                 "eq",
 145                                 "ne",
 146                 };
 147
 148                 switch (instr->opc) {
 149                 case OPC_CMPS_F:
 150                 case OPC_CMPS_U:
 151                 case OPC_CMPS_S:
 152                 case OPC_CMPV_F:
 153                 case OPC_CMPV_U:
 154                 case OPC_CMPV_S:
 155                         printf(".%s", cond[instr->cat2.condition & 0x7]);
 156                         break;
 157                 default:
 158                         break;
 159                 }
 160         }
 161 }
 162
 163 static void print_reg_name(struct ir3_register *reg)
 164 {
 165         if ((reg->flags & (IR3_REG_FABS | IR3_REG_SABS)) &&
 166                         (reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT)))
 167                 printf("(absneg)");
 168         else if (reg->flags & (IR3_REG_FNEG | IR3_REG_SNEG | IR3_REG_BNOT))
 169                 printf("(neg)");
 170         else if (reg->flags & (IR3_REG_FABS | IR3_REG_SABS))
 171                 printf("(abs)");
 172
 173         if (reg->flags & IR3_REG_R)
 174                 printf("(r)");
 175
 176         if (reg->flags & IR3_REG_HIGH)
 177                 printf("H");
 178         if (reg->flags & IR3_REG_HALF)
 179                 printf("h");
 180
 181         if (reg->flags & IR3_REG_IMMED) {
 182                 printf(SYN_IMMED("imm[%f,%d,0x%x]"), reg->fim_val, reg->iim_val, reg->iim_val);
 183         } else if (reg->flags & IR3_REG_ARRAY) {
 184                 printf(SYN_ARRAY("arr[id=%u, offset=%d, size=%u"), reg->array.id,
 185                                 reg->array.offset, reg->size);
 186                 /* for ARRAY we could have null src, for example first write
 187                  * instruction..
 188                  */
 189                 if (reg->instr) {
 190                         printf(SYN_ARRAY(", "));
 191                         printf(SYN_SSA("_["));
 192                         print_instr_name(reg->instr, false);
 193                         printf(SYN_SSA("]"));
 194                 }
 195                 printf(SYN_ARRAY("]"));
 196         } else if (reg->flags & IR3_REG_SSA) {
 197                 printf(SYN_SSA("_["));
 198                 print_instr_name(reg->instr, false);
 199                 printf(SYN_SSA("]"));
 200         } else if (reg->flags & IR3_REG_RELATIV) {
 201                 if (reg->flags & IR3_REG_CONST)
 202                         printf(SYN_CONST("c<a0.x + %d>"), reg->array.offset);
 203                 else
 204                         printf(SYN_REG("r<a0.x + %d>")" (%u)", reg->array.offset, reg->size);
 205         } else {
 206                 if (reg->flags & IR3_REG_CONST)
 207                         printf(SYN_CONST("c%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
 208                 else
 209                         printf(SYN_REG("r%u.%c"), reg_num(reg), "xyzw"[reg_comp(reg)]);
 210         }
 211
 212         if (reg->wrmask > 0x1)
 213                 printf(" (wrmask=0x%x)", reg->wrmask);
 214 }
 215
 216 static void
 217 tab(int lvl)
 218 {
 219         for (int i = 0; i < lvl; i++)
 220                 printf("\t");
 221 }
 222
 223 static void
 224 print_instr(struct ir3_instruction *instr, int lvl)
 225 {
 226         unsigned i;
 227
 228         tab(lvl);
 229
 230         print_instr_name(instr, true);
 231
 232         if (is_tex(instr)) {
 233                 printf(" (%s)(", type_name(instr->cat5.type));
 234                 for (i = 0; i < 4; i++)
 235                         if (instr->regs[0]->wrmask & (1 << i))
 236                                 printf("%c", "xyzw"[i]);
 237                 printf(")");
 238         } else if (instr->regs_count > 0) {
 239                 printf(" ");
 240         }
 241
 242         for (i = 0; i < instr->regs_count; i++) {
 243                 struct ir3_register *reg = instr->regs[i];
 244
 245                 printf(i ? ", " : "");
 246                 print_reg_name(reg);
 247         }
 248
 249         if (is_tex(instr) && !(instr->flags & IR3_INSTR_S2EN)) {
 250                 if (!!(instr->flags & IR3_INSTR_B)) {
 251                         if (!!(instr->flags & IR3_INSTR_A1EN)) {
 252                                 printf(", s#%d", instr->cat5.samp);
 253                         } else {
 254                                 printf(", s#%d, t#%d", instr->cat5.samp & 0xf,
 255                                            instr->cat5.samp >> 4);
 256                         }
 257                 } else {
 258                         printf(", s#%d, t#%d", instr->cat5.samp, instr->cat5.tex);
 259                 }
 260         }
 261
 262         if (instr->address) {
 263                 printf(", address=_");
 264                 printf("[");
 265                 print_instr_name(instr->address, false);
 266                 printf("]");
 267         }
 268
 269         if (instr->cp.left) {
 270                 printf(", left=_");
 271                 printf("[");
 272                 print_instr_name(instr->cp.left, false);
 273                 printf("]");
 274         }
 275
 276         if (instr->cp.right) {
 277                 printf(", right=_");
 278                 printf("[");
 279                 print_instr_name(instr->cp.right, false);
 280                 printf("]");
 281         }
 282
 283         if (instr->opc == OPC_META_SPLIT) {
 284                 printf(", off=%d", instr->split.off);
 285         } else if (instr->opc == OPC_META_TEX_PREFETCH) {
 286                 printf(", tex=%d, samp=%d, input_offset=%d", instr->prefetch.tex,
 287                                 instr->prefetch.samp, instr->prefetch.input_offset);
 288         }
 289
 290         if (is_flow(instr) && instr->cat0.target) {
 291                 /* the predicate register src is implied: */
 292                 if (instr->opc == OPC_B) {
 293                         printf("r %sp0.x", instr->cat0.inv ? "!" : "");
 294                 }
 295                 printf(", target=block%u", block_id(instr->cat0.target));
 296         }
 297
 298         if (instr->deps_count) {
 299                 printf(", false-deps:");
 300                 for (unsigned i = 0; i < instr->deps_count; i++) {
 301                         if (i > 0)
 302                                 printf(", ");
 303                         printf("_[");
 304                         print_instr_name(instr->deps[i], false);
 305                         printf("]");
 306                 }
 307         }
 308
 309         printf("\n");
 310 }
 311
 312 void ir3_print_instr(struct ir3_instruction *instr)
 313 {
 314         print_instr(instr, 0);
 315 }
 316
 317 static void
 318 print_block(struct ir3_block *block, int lvl)
 319 {
 320         tab(lvl); printf("block%u {\n", block_id(block));
 321
 322         /* computerator (ir3 assembler) doesn't really use blocks for flow
 323          * control, so block->predecessors will be null.
 324          */
 325         if (block->predecessors && block->predecessors->entries > 0) {
 326                 unsigned i = 0;
 327                 tab(lvl+1);
 328                 printf("pred: ");
 329                 set_foreach (block->predecessors, entry) {
 330                         struct ir3_block *pred = (struct ir3_block *)entry->key;
 331                         if (i++)
 332                                 printf(", ");
 333                         printf("block%u", block_id(pred));
 334                 }
 335                 printf("\n");
 336         }
 337
 338         foreach_instr (instr, &block->instr_list) {
 339                 print_instr(instr, lvl+1);
 340         }
 341
 342         tab(lvl+1); printf("/* keeps:\n");
 343         for (unsigned i = 0; i < block->keeps_count; i++) {
 344                 print_instr(block->keeps[i], lvl+2);
 345         }
 346         tab(lvl+1); printf(" */\n");
 347
 348         if (block->successors[1]) {
 349                 /* leading into if/else: */
 350                 tab(lvl+1);
 351                 printf("/* succs: if _[");
 352                 print_instr_name(block->condition, false);
 353                 printf("] block%u; else block%u; */\n",
 354                                 block_id(block->successors[0]),
 355                                 block_id(block->successors[1]));
 356         } else if (block->successors[0]) {
 357                 tab(lvl+1);
 358                 printf("/* succs: block%u; */\n",
 359                                 block_id(block->successors[0]));
 360         }
 361         tab(lvl); printf("}\n");
 362 }
 363
 364 void
 365 ir3_print(struct ir3 *ir)
 366 {
 367         foreach_block (block, &ir->block_list)
 368                 print_block(block, 0);
 369
 370         foreach_output_n (out, i, ir) {
 371                 printf("out%d: ", i);
 372                 print_instr(out, 0);
 373         }
 374 }