src/gallium/drivers/vc4/vc4_qir.c

   1 /*
   2  * Copyright © 2014 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 "util/u_memory.h"
  25 #include "util/simple_list.h"
  26 #include "util/ralloc.h"
  27
  28 #include "vc4_qir.h"
  29 #include "vc4_qpu.h"
  30
  31 struct qir_op_info {
  32         const char *name;
  33         uint8_t ndst, nsrc;
  34         bool has_side_effects;
  35         bool multi_instruction;
  36 };
  37
  38 static const struct qir_op_info qir_op_info[] = {
  39         [QOP_MOV] = { "mov", 1, 1 },
  40         [QOP_FADD] = { "fadd", 1, 2 },
  41         [QOP_FSUB] = { "fsub", 1, 2 },
  42         [QOP_FMUL] = { "fmul", 1, 2 },
  43         [QOP_MUL24] = { "mul24", 1, 2 },
  44         [QOP_FMIN] = { "fmin", 1, 2 },
  45         [QOP_FMAX] = { "fmax", 1, 2 },
  46         [QOP_FMINABS] = { "fminabs", 1, 2 },
  47         [QOP_FMAXABS] = { "fmaxabs", 1, 2 },
  48         [QOP_FTOI] = { "ftoi", 1, 1 },
  49         [QOP_ITOF] = { "itof", 1, 1 },
  50         [QOP_ADD] = { "add", 1, 2 },
  51         [QOP_SUB] = { "sub", 1, 2 },
  52         [QOP_SHR] = { "shr", 1, 2 },
  53         [QOP_ASR] = { "asr", 1, 2 },
  54         [QOP_SHL] = { "shl", 1, 2 },
  55         [QOP_MIN] = { "min", 1, 2 },
  56         [QOP_MAX] = { "max", 1, 2 },
  57         [QOP_AND] = { "and", 1, 2 },
  58         [QOP_OR] = { "or", 1, 2 },
  59         [QOP_XOR] = { "xor", 1, 2 },
  60         [QOP_NOT] = { "not", 1, 1 },
  61
  62         [QOP_SF] = { "sf", 0, 1 },
  63         [QOP_SEL_X_0_NS] = { "fsel_x_0_ns", 1, 1, false, true },
  64         [QOP_SEL_X_0_NC] = { "fsel_x_0_nc", 1, 1, false, true },
  65         [QOP_SEL_X_0_ZS] = { "fsel_x_0_zs", 1, 1, false, true },
  66         [QOP_SEL_X_0_ZC] = { "fsel_x_0_zc", 1, 1, false, true },
  67         [QOP_SEL_X_Y_NS] = { "fsel_x_y_ns", 1, 2, false, true },
  68         [QOP_SEL_X_Y_NC] = { "fsel_x_y_nc", 1, 2, false, true },
  69         [QOP_SEL_X_Y_ZS] = { "fsel_x_y_zs", 1, 2, false, true },
  70         [QOP_SEL_X_Y_ZC] = { "fsel_x_y_zc", 1, 2, false, true },
  71
  72         [QOP_RCP] = { "rcp", 1, 1, false, true },
  73         [QOP_RSQ] = { "rsq", 1, 1, false, true },
  74         [QOP_EXP2] = { "exp2", 1, 2, false, true },
  75         [QOP_LOG2] = { "log2", 1, 2, false, true },
  76         [QOP_PACK_8888_F] = { "pack_8888_f", 1, 1, false, true },
  77         [QOP_PACK_8A_F] = { "pack_8a_f", 1, 2, false, true },
  78         [QOP_PACK_8B_F] = { "pack_8b_f", 1, 2, false, true },
  79         [QOP_PACK_8C_F] = { "pack_8c_f", 1, 2, false, true },
  80         [QOP_PACK_8D_F] = { "pack_8d_f", 1, 2, false, true },
  81         [QOP_PACK_SCALED] = { "pack_scaled", 1, 2, false, true },
  82         [QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
  83         [QOP_TLB_STENCIL_SETUP] = { "tlb_stencil_setup", 0, 1, true },
  84         [QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
  85         [QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
  86         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0 },
  87         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  88
  89         [QOP_FRAG_X] = { "frag_x", 1, 0 },
  90         [QOP_FRAG_Y] = { "frag_y", 1, 0 },
  91         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  92         [QOP_FRAG_W] = { "frag_w", 1, 0 },
  93         [QOP_FRAG_REV_FLAG] = { "frag_rev_flag", 1, 0 },
  94
  95         [QOP_TEX_S] = { "tex_s", 0, 2 },
  96         [QOP_TEX_T] = { "tex_t", 0, 2 },
  97         [QOP_TEX_R] = { "tex_r", 0, 2 },
  98         [QOP_TEX_B] = { "tex_b", 0, 2 },
  99         [QOP_TEX_DIRECT] = { "tex_direct", 0, 2 },
 100         [QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
 101         [QOP_R4_UNPACK_A] = { "r4_unpack_a", 1, 1 },
 102         [QOP_R4_UNPACK_B] = { "r4_unpack_b", 1, 1 },
 103         [QOP_R4_UNPACK_C] = { "r4_unpack_c", 1, 1 },
 104         [QOP_R4_UNPACK_D] = { "r4_unpack_d", 1, 1 },
 105         [QOP_UNPACK_8A_F] = { "unpack_8a_f", 1, 1 },
 106         [QOP_UNPACK_8B_F] = { "unpack_8b_f", 1, 1 },
 107         [QOP_UNPACK_8C_F] = { "unpack_8c_f", 1, 1 },
 108         [QOP_UNPACK_8D_F] = { "unpack_8d_f", 1, 1 },
 109         [QOP_UNPACK_16A_F] = { "unpack_16a_f", 1, 1 },
 110         [QOP_UNPACK_16B_F] = { "unpack_16b_f", 1, 1 },
 111         [QOP_UNPACK_8A_I] = { "unpack_8a_i", 1, 1 },
 112         [QOP_UNPACK_8B_I] = { "unpack_8b_i", 1, 1 },
 113         [QOP_UNPACK_8C_I] = { "unpack_8c_i", 1, 1 },
 114         [QOP_UNPACK_8D_I] = { "unpack_8d_i", 1, 1 },
 115         [QOP_UNPACK_16A_I] = { "unpack_16a_i", 1, 1 },
 116         [QOP_UNPACK_16B_I] = { "unpack_16b_i", 1, 1 },
 117 };
 118
 119 static const char *
 120 qir_get_op_name(enum qop qop)
 121 {
 122         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 123                 return qir_op_info[qop].name;
 124         else
 125                 return "???";
 126 }
 127
 128 int
 129 qir_get_op_nsrc(enum qop qop)
 130 {
 131         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 132                 return qir_op_info[qop].nsrc;
 133         else
 134                 abort();
 135 }
 136
 137 /**
 138  * Returns whether the instruction has any side effects that must be
 139  * preserved.
 140  */
 141 bool
 142 qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
 143 {
 144         return qir_op_info[inst->op].has_side_effects;
 145 }
 146
 147 bool
 148 qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
 149 {
 150         /* We can dead-code eliminate varyings, because we only tell the VS
 151          * about the live ones at the end.  But we have to preserve the
 152          * point/line coordinates reads, because they're generated by
 153          * fixed-function hardware.
 154          */
 155         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 156                 if (inst->src[i].file == QFILE_VARY &&
 157                     c->input_semantics[inst->src[i].index].semantic == 0xff) {
 158                         return true;
 159                 }
 160
 161                 if (inst->src[i].file == QFILE_VPM)
 162                         return true;
 163         }
 164
 165         if (inst->dst.file == QFILE_VPM)
 166                 return true;
 167
 168         return false;
 169 }
 170
 171 bool
 172 qir_is_multi_instruction(struct qinst *inst)
 173 {
 174         return qir_op_info[inst->op].multi_instruction;
 175 }
 176
 177 bool
 178 qir_depends_on_flags(struct qinst *inst)
 179 {
 180         switch (inst->op) {
 181         case QOP_SEL_X_0_NS:
 182         case QOP_SEL_X_0_NC:
 183         case QOP_SEL_X_0_ZS:
 184         case QOP_SEL_X_0_ZC:
 185         case QOP_SEL_X_Y_NS:
 186         case QOP_SEL_X_Y_NC:
 187         case QOP_SEL_X_Y_ZS:
 188         case QOP_SEL_X_Y_ZC:
 189                 return true;
 190         default:
 191                 return false;
 192         }
 193 }
 194
 195 bool
 196 qir_src_needs_a_file(struct qinst *inst)
 197 {
 198         switch (inst->op) {
 199         case QOP_UNPACK_8A_F:
 200         case QOP_UNPACK_8B_F:
 201         case QOP_UNPACK_8C_F:
 202         case QOP_UNPACK_8D_F:
 203         case QOP_UNPACK_16A_F:
 204         case QOP_UNPACK_16B_F:
 205         case QOP_UNPACK_8A_I:
 206         case QOP_UNPACK_8B_I:
 207         case QOP_UNPACK_8C_I:
 208         case QOP_UNPACK_8D_I:
 209         case QOP_UNPACK_16A_I:
 210         case QOP_UNPACK_16B_I:
 211                 return true;
 212         default:
 213                 return false;
 214         }
 215 }
 216
 217 bool
 218 qir_writes_r4(struct qinst *inst)
 219 {
 220         switch (inst->op) {
 221         case QOP_TEX_RESULT:
 222         case QOP_TLB_COLOR_READ:
 223         case QOP_RCP:
 224         case QOP_RSQ:
 225         case QOP_EXP2:
 226         case QOP_LOG2:
 227                 return true;
 228         default:
 229                 return false;
 230         }
 231 }
 232
 233 bool
 234 qir_reads_r4(struct qinst *inst)
 235 {
 236         switch (inst->op) {
 237         case QOP_R4_UNPACK_A:
 238         case QOP_R4_UNPACK_B:
 239         case QOP_R4_UNPACK_C:
 240         case QOP_R4_UNPACK_D:
 241                 return true;
 242         default:
 243                 return false;
 244         }
 245 }
 246
 247 static void
 248 qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
 249 {
 250         static const char *files[] = {
 251                 [QFILE_TEMP] = "t",
 252                 [QFILE_VARY] = "v",
 253                 [QFILE_UNIF] = "u",
 254         };
 255
 256         if (reg.file == QFILE_NULL) {
 257                 fprintf(stderr, "null");
 258         } else if (reg.file == QFILE_SMALL_IMM) {
 259                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
 260                         fprintf(stderr, "%d", reg.index);
 261                 else
 262                         fprintf(stderr, "%f", uif(reg.index));
 263         } else if (reg.file == QFILE_VPM) {
 264                 if (write) {
 265                         fprintf(stderr, "vpm");
 266                 } else {
 267                         fprintf(stderr, "vpm%d.%d",
 268                                 reg.index / 4, reg.index % 4);
 269                 }
 270         } else {
 271                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 272         }
 273
 274         if (reg.file == QFILE_UNIF &&
 275             c->uniform_contents[reg.index] == QUNIFORM_CONSTANT) {
 276                 fprintf(stderr, " (0x%08x / %f)",
 277                         c->uniform_data[reg.index],
 278                         uif(c->uniform_data[reg.index]));
 279         }
 280 }
 281
 282 void
 283 qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
 284 {
 285         fprintf(stderr, "%s ", qir_get_op_name(inst->op));
 286
 287         qir_print_reg(c, inst->dst, true);
 288         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 289                 fprintf(stderr, ", ");
 290                 qir_print_reg(c, inst->src[i], false);
 291         }
 292 }
 293
 294 void
 295 qir_dump(struct vc4_compile *c)
 296 {
 297         struct simple_node *node;
 298
 299         foreach(node, &c->instructions) {
 300                 struct qinst *inst = (struct qinst *)node;
 301                 qir_dump_inst(c, inst);
 302                 fprintf(stderr, "\n");
 303         }
 304 }
 305
 306 struct qreg
 307 qir_get_temp(struct vc4_compile *c)
 308 {
 309         struct qreg reg;
 310
 311         reg.file = QFILE_TEMP;
 312         reg.index = c->num_temps++;
 313
 314         return reg;
 315 }
 316
 317 struct qinst *
 318 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 319 {
 320         struct qinst *inst = CALLOC_STRUCT(qinst);
 321
 322         inst->op = op;
 323         inst->dst = dst;
 324         inst->src = calloc(2, sizeof(inst->src[0]));
 325         inst->src[0] = src0;
 326         inst->src[1] = src1;
 327
 328         return inst;
 329 }
 330
 331 struct qinst *
 332 qir_inst4(enum qop op, struct qreg dst,
 333           struct qreg a,
 334           struct qreg b,
 335           struct qreg c,
 336           struct qreg d)
 337 {
 338         struct qinst *inst = CALLOC_STRUCT(qinst);
 339
 340         inst->op = op;
 341         inst->dst = dst;
 342         inst->src = calloc(4, sizeof(*inst->src));
 343         inst->src[0] = a;
 344         inst->src[1] = b;
 345         inst->src[2] = c;
 346         inst->src[3] = d;
 347
 348         return inst;
 349 }
 350
 351 void
 352 qir_emit(struct vc4_compile *c, struct qinst *inst)
 353 {
 354         insert_at_tail(&c->instructions, &inst->link);
 355 }
 356
 357 bool
 358 qir_reg_equals(struct qreg a, struct qreg b)
 359 {
 360         return a.file == b.file && a.index == b.index;
 361 }
 362
 363 struct vc4_compile *
 364 qir_compile_init(void)
 365 {
 366         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 367
 368         make_empty_list(&c->instructions);
 369
 370         c->output_position_index = -1;
 371         c->output_clipvertex_index = -1;
 372         c->output_color_index = -1;
 373         c->output_point_size_index = -1;
 374
 375         return c;
 376 }
 377
 378 void
 379 qir_remove_instruction(struct qinst *qinst)
 380 {
 381         remove_from_list(&qinst->link);
 382         free(qinst->src);
 383         free(qinst);
 384 }
 385
 386 struct qreg
 387 qir_follow_movs(struct qinst **defs, struct qreg reg)
 388 {
 389         while (reg.file == QFILE_TEMP && defs[reg.index]->op == QOP_MOV)
 390                 reg = defs[reg.index]->src[0];
 391
 392         return reg;
 393 }
 394
 395 void
 396 qir_compile_destroy(struct vc4_compile *c)
 397 {
 398         while (!is_empty_list(&c->instructions)) {
 399                 struct qinst *qinst =
 400                         (struct qinst *)first_elem(&c->instructions);
 401                 qir_remove_instruction(qinst);
 402         }
 403
 404         ralloc_free(c);
 405 }
 406
 407 const char *
 408 qir_get_stage_name(enum qstage stage)
 409 {
 410         static const char *names[] = {
 411                 [QSTAGE_FRAG] = "FS",
 412                 [QSTAGE_VERT] = "VS",
 413                 [QSTAGE_COORD] = "CS",
 414         };
 415
 416         return names[stage];
 417 }
 418
 419 #define OPTPASS(func)                                                   \
 420         do {                                                            \
 421                 bool stage_progress = func(c);                          \
 422                 if (stage_progress) {                                   \
 423                         progress = true;                                \
 424                         if (print_opt_debug) {                          \
 425                                 fprintf(stderr,                         \
 426                                         "QIR opt pass %2d: %s progress\n", \
 427                                         pass, #func);                   \
 428                         }                                               \
 429                 }                                                       \
 430         } while (0)
 431
 432 void
 433 qir_optimize(struct vc4_compile *c)
 434 {
 435         bool print_opt_debug = false;
 436         int pass = 1;
 437
 438         while (true) {
 439                 bool progress = false;
 440
 441                 OPTPASS(qir_opt_algebraic);
 442                 OPTPASS(qir_opt_cse);
 443                 OPTPASS(qir_opt_copy_propagation);
 444                 OPTPASS(qir_opt_dead_code);
 445                 OPTPASS(qir_opt_small_immediates);
 446                 OPTPASS(qir_opt_vpm_writes);
 447
 448                 if (!progress)
 449                         break;
 450
 451                 pass++;
 452         }
 453 }