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/ralloc.h"
  26
  27 #include "vc4_qir.h"
  28 #include "vc4_qpu.h"
  29
  30 struct qir_op_info {
  31         const char *name;
  32         uint8_t ndst, nsrc;
  33         bool has_side_effects;
  34 };
  35
  36 static const struct qir_op_info qir_op_info[] = {
  37         [QOP_MOV] = { "mov", 1, 1 },
  38         [QOP_FMOV] = { "fmov", 1, 1 },
  39         [QOP_MMOV] = { "mmov", 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_V8MULD] = {"v8muld", 1, 2 },
  45         [QOP_V8MIN] = {"v8min", 1, 2 },
  46         [QOP_V8MAX] = {"v8max", 1, 2 },
  47         [QOP_V8ADDS] = {"v8adds", 1, 2 },
  48         [QOP_V8SUBS] = {"v8subs", 1, 2 },
  49         [QOP_FMIN] = { "fmin", 1, 2 },
  50         [QOP_FMAX] = { "fmax", 1, 2 },
  51         [QOP_FMINABS] = { "fminabs", 1, 2 },
  52         [QOP_FMAXABS] = { "fmaxabs", 1, 2 },
  53         [QOP_FTOI] = { "ftoi", 1, 1 },
  54         [QOP_ITOF] = { "itof", 1, 1 },
  55         [QOP_ADD] = { "add", 1, 2 },
  56         [QOP_SUB] = { "sub", 1, 2 },
  57         [QOP_SHR] = { "shr", 1, 2 },
  58         [QOP_ASR] = { "asr", 1, 2 },
  59         [QOP_SHL] = { "shl", 1, 2 },
  60         [QOP_MIN] = { "min", 1, 2 },
  61         [QOP_MAX] = { "max", 1, 2 },
  62         [QOP_AND] = { "and", 1, 2 },
  63         [QOP_OR] = { "or", 1, 2 },
  64         [QOP_XOR] = { "xor", 1, 2 },
  65         [QOP_NOT] = { "not", 1, 1 },
  66
  67         [QOP_RCP] = { "rcp", 1, 1 },
  68         [QOP_RSQ] = { "rsq", 1, 1 },
  69         [QOP_EXP2] = { "exp2", 1, 1 },
  70         [QOP_LOG2] = { "log2", 1, 1 },
  71         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0 },
  72         [QOP_MS_MASK] = { "ms_mask", 0, 1, true },
  73         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  74
  75         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  76         [QOP_FRAG_W] = { "frag_w", 1, 0 },
  77
  78         [QOP_TEX_S] = { "tex_s", 0, 2, true },
  79         [QOP_TEX_T] = { "tex_t", 0, 2, true },
  80         [QOP_TEX_R] = { "tex_r", 0, 2, true },
  81         [QOP_TEX_B] = { "tex_b", 0, 2, true },
  82         [QOP_TEX_DIRECT] = { "tex_direct", 0, 2, true },
  83         [QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
  84
  85         [QOP_LOAD_IMM] = { "load_imm", 0, 1 },
  86 };
  87
  88 static const char *
  89 qir_get_op_name(enum qop qop)
  90 {
  91         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
  92                 return qir_op_info[qop].name;
  93         else
  94                 return "???";
  95 }
  96
  97 int
  98 qir_get_op_nsrc(enum qop qop)
  99 {
 100         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 101                 return qir_op_info[qop].nsrc;
 102         else
 103                 abort();
 104 }
 105
 106 /**
 107  * Returns whether the instruction has any side effects that must be
 108  * preserved.
 109  */
 110 bool
 111 qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
 112 {
 113         switch (inst->dst.file) {
 114         case QFILE_TLB_Z_WRITE:
 115         case QFILE_TLB_COLOR_WRITE:
 116         case QFILE_TLB_COLOR_WRITE_MS:
 117         case QFILE_TLB_STENCIL_SETUP:
 118                 return true;
 119         default:
 120                 break;
 121         }
 122
 123         return qir_op_info[inst->op].has_side_effects;
 124 }
 125
 126 bool
 127 qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
 128 {
 129         /* We can dead-code eliminate varyings, because we only tell the VS
 130          * about the live ones at the end.  But we have to preserve the
 131          * point/line coordinates reads, because they're generated by
 132          * fixed-function hardware.
 133          */
 134         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 135                 if (inst->src[i].file == QFILE_VARY &&
 136                     c->input_slots[inst->src[i].index].slot == 0xff) {
 137                         return true;
 138                 }
 139
 140                 if (inst->src[i].file == QFILE_VPM)
 141                         return true;
 142         }
 143
 144         if (inst->dst.file == QFILE_VPM)
 145                 return true;
 146
 147         return false;
 148 }
 149
 150 bool
 151 qir_is_mul(struct qinst *inst)
 152 {
 153         switch (inst->op) {
 154         case QOP_MMOV:
 155         case QOP_FMUL:
 156         case QOP_MUL24:
 157         case QOP_V8MULD:
 158         case QOP_V8MIN:
 159         case QOP_V8MAX:
 160         case QOP_V8ADDS:
 161         case QOP_V8SUBS:
 162                 return true;
 163         default:
 164                 return false;
 165         }
 166 }
 167
 168 bool
 169 qir_is_float_input(struct qinst *inst)
 170 {
 171         switch (inst->op) {
 172         case QOP_FMOV:
 173         case QOP_FMUL:
 174         case QOP_FADD:
 175         case QOP_FSUB:
 176         case QOP_FMIN:
 177         case QOP_FMAX:
 178         case QOP_FMINABS:
 179         case QOP_FMAXABS:
 180         case QOP_FTOI:
 181                 return true;
 182         default:
 183                 return false;
 184         }
 185 }
 186
 187 bool
 188 qir_is_raw_mov(struct qinst *inst)
 189 {
 190         return ((inst->op == QOP_MOV ||
 191                  inst->op == QOP_FMOV ||
 192                  inst->op == QOP_MMOV) &&
 193                 inst->cond == QPU_COND_ALWAYS &&
 194                 !inst->dst.pack &&
 195                 !inst->src[0].pack);
 196 }
 197
 198 bool
 199 qir_is_tex(struct qinst *inst)
 200 {
 201         return inst->op >= QOP_TEX_S && inst->op <= QOP_TEX_DIRECT;
 202 }
 203
 204 bool
 205 qir_depends_on_flags(struct qinst *inst)
 206 {
 207         return (inst->cond != QPU_COND_ALWAYS &&
 208                 inst->cond != QPU_COND_NEVER);
 209 }
 210
 211 bool
 212 qir_writes_r4(struct qinst *inst)
 213 {
 214         switch (inst->op) {
 215         case QOP_TEX_RESULT:
 216         case QOP_TLB_COLOR_READ:
 217         case QOP_RCP:
 218         case QOP_RSQ:
 219         case QOP_EXP2:
 220         case QOP_LOG2:
 221                 return true;
 222         default:
 223                 return false;
 224         }
 225 }
 226
 227 static void
 228 qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
 229 {
 230         static const char *files[] = {
 231                 [QFILE_TEMP] = "t",
 232                 [QFILE_VARY] = "v",
 233                 [QFILE_UNIF] = "u",
 234                 [QFILE_TLB_COLOR_WRITE] = "tlb_c",
 235                 [QFILE_TLB_COLOR_WRITE_MS] = "tlb_c_ms",
 236                 [QFILE_TLB_Z_WRITE] = "tlb_z",
 237                 [QFILE_TLB_STENCIL_SETUP] = "tlb_stencil",
 238                 [QFILE_FRAG_X] = "frag_x",
 239                 [QFILE_FRAG_Y] = "frag_y",
 240                 [QFILE_FRAG_REV_FLAG] = "frag_rev_flag",
 241         };
 242
 243         switch (reg.file) {
 244
 245         case QFILE_NULL:
 246                 fprintf(stderr, "null");
 247                 break;
 248
 249         case QFILE_LOAD_IMM:
 250                 fprintf(stderr, "0x%08x (%f)", reg.index, uif(reg.index));
 251                 break;
 252
 253         case QFILE_SMALL_IMM:
 254                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
 255                         fprintf(stderr, "%d", reg.index);
 256                 else
 257                         fprintf(stderr, "%f", uif(reg.index));
 258                 break;
 259
 260         case QFILE_VPM:
 261                 if (write) {
 262                         fprintf(stderr, "vpm");
 263                 } else {
 264                         fprintf(stderr, "vpm%d.%d",
 265                                 reg.index / 4, reg.index % 4);
 266                 }
 267                 break;
 268
 269         case QFILE_TLB_COLOR_WRITE:
 270         case QFILE_TLB_COLOR_WRITE_MS:
 271         case QFILE_TLB_Z_WRITE:
 272         case QFILE_TLB_STENCIL_SETUP:
 273                 fprintf(stderr, "%s", files[reg.file]);
 274                 break;
 275
 276         default:
 277                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 278                 break;
 279         }
 280
 281         if (reg.file == QFILE_UNIF &&
 282             c->uniform_contents[reg.index] == QUNIFORM_CONSTANT) {
 283                 fprintf(stderr, " (0x%08x / %f)",
 284                         c->uniform_data[reg.index],
 285                         uif(c->uniform_data[reg.index]));
 286         }
 287 }
 288
 289 void
 290 qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
 291 {
 292         fprintf(stderr, "%s", qir_get_op_name(inst->op));
 293         vc4_qpu_disasm_cond(stderr, inst->cond);
 294         if (inst->sf)
 295                 fprintf(stderr, ".sf");
 296         fprintf(stderr, " ");
 297
 298         qir_print_reg(c, inst->dst, true);
 299         if (inst->dst.pack) {
 300                 if (inst->dst.pack) {
 301                         if (qir_is_mul(inst))
 302                                 vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
 303                         else
 304                                 vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
 305                 }
 306         }
 307         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 308                 fprintf(stderr, ", ");
 309                 qir_print_reg(c, inst->src[i], false);
 310                 vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
 311         }
 312 }
 313
 314 void
 315 qir_dump(struct vc4_compile *c)
 316 {
 317         qir_for_each_block(block, c) {
 318                 fprintf(stderr, "BLOCK %d:\n", block->index);
 319                 qir_for_each_inst(inst, block) {
 320                         qir_dump_inst(c, inst);
 321                         fprintf(stderr, "\n");
 322                 }
 323         }
 324 }
 325
 326 struct qreg
 327 qir_get_temp(struct vc4_compile *c)
 328 {
 329         struct qreg reg;
 330
 331         reg.file = QFILE_TEMP;
 332         reg.index = c->num_temps++;
 333         reg.pack = 0;
 334
 335         if (c->num_temps > c->defs_array_size) {
 336                 uint32_t old_size = c->defs_array_size;
 337                 c->defs_array_size = MAX2(old_size * 2, 16);
 338                 c->defs = reralloc(c, c->defs, struct qinst *,
 339                                    c->defs_array_size);
 340                 memset(&c->defs[old_size], 0,
 341                        sizeof(c->defs[0]) * (c->defs_array_size - old_size));
 342         }
 343
 344         return reg;
 345 }
 346
 347 struct qinst *
 348 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 349 {
 350         struct qinst *inst = CALLOC_STRUCT(qinst);
 351
 352         inst->op = op;
 353         inst->dst = dst;
 354         inst->src = calloc(2, sizeof(inst->src[0]));
 355         inst->src[0] = src0;
 356         inst->src[1] = src1;
 357         inst->cond = QPU_COND_ALWAYS;
 358
 359         return inst;
 360 }
 361
 362 struct qinst *
 363 qir_inst4(enum qop op, struct qreg dst,
 364           struct qreg a,
 365           struct qreg b,
 366           struct qreg c,
 367           struct qreg d)
 368 {
 369         struct qinst *inst = CALLOC_STRUCT(qinst);
 370
 371         inst->op = op;
 372         inst->dst = dst;
 373         inst->src = calloc(4, sizeof(*inst->src));
 374         inst->src[0] = a;
 375         inst->src[1] = b;
 376         inst->src[2] = c;
 377         inst->src[3] = d;
 378
 379         return inst;
 380 }
 381
 382 static void
 383 qir_emit(struct vc4_compile *c, struct qinst *inst)
 384 {
 385         list_addtail(&inst->link, &c->cur_block->instructions);
 386 }
 387
 388 /* Updates inst to write to a new temporary, emits it, and notes the def. */
 389 struct qreg
 390 qir_emit_def(struct vc4_compile *c, struct qinst *inst)
 391 {
 392         assert(inst->dst.file == QFILE_NULL);
 393
 394         inst->dst = qir_get_temp(c);
 395
 396         if (inst->dst.file == QFILE_TEMP)
 397                 c->defs[inst->dst.index] = inst;
 398
 399         qir_emit(c, inst);
 400
 401         return inst->dst;
 402 }
 403
 404 struct qinst *
 405 qir_emit_nondef(struct vc4_compile *c, struct qinst *inst)
 406 {
 407         if (inst->dst.file == QFILE_TEMP)
 408                 c->defs[inst->dst.index] = NULL;
 409
 410         qir_emit(c, inst);
 411
 412         return inst;
 413 }
 414
 415 bool
 416 qir_reg_equals(struct qreg a, struct qreg b)
 417 {
 418         return a.file == b.file && a.index == b.index && a.pack == b.pack;
 419 }
 420
 421 struct qblock *
 422 qir_new_block(struct vc4_compile *c)
 423 {
 424         struct qblock *block = rzalloc(c, struct qblock);
 425
 426         list_inithead(&block->instructions);
 427
 428         block->predecessors = _mesa_set_create(block,
 429                                                _mesa_hash_pointer,
 430                                                _mesa_key_pointer_equal);
 431
 432         block->index = c->next_block_index++;
 433
 434         return block;
 435 }
 436
 437 void
 438 qir_set_emit_block(struct vc4_compile *c, struct qblock *block)
 439 {
 440         c->cur_block = block;
 441         list_addtail(&block->link, &c->blocks);
 442 }
 443
 444 struct qblock *
 445 qir_entry_block(struct vc4_compile *c)
 446 {
 447         return list_first_entry(&c->blocks, struct qblock, link);
 448 }
 449
 450 struct qblock *
 451 qir_exit_block(struct vc4_compile *c)
 452 {
 453         return list_last_entry(&c->blocks, struct qblock, link);
 454 }
 455
 456 void
 457 qir_link_blocks(struct qblock *predecessor, struct qblock *successor)
 458 {
 459         _mesa_set_add(successor->predecessors, predecessor);
 460         if (predecessor->successors[0]) {
 461                 assert(!predecessor->successors[1]);
 462                 predecessor->successors[1] = successor;
 463         } else {
 464                 predecessor->successors[0] = successor;
 465         }
 466 }
 467
 468 struct vc4_compile *
 469 qir_compile_init(void)
 470 {
 471         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 472
 473         list_inithead(&c->blocks);
 474         qir_set_emit_block(c, qir_new_block(c));
 475
 476         c->output_position_index = -1;
 477         c->output_color_index = -1;
 478         c->output_point_size_index = -1;
 479         c->output_sample_mask_index = -1;
 480
 481         c->def_ht = _mesa_hash_table_create(c, _mesa_hash_pointer,
 482                                             _mesa_key_pointer_equal);
 483
 484         return c;
 485 }
 486
 487 void
 488 qir_remove_instruction(struct vc4_compile *c, struct qinst *qinst)
 489 {
 490         if (qinst->dst.file == QFILE_TEMP)
 491                 c->defs[qinst->dst.index] = NULL;
 492
 493         list_del(&qinst->link);
 494         free(qinst->src);
 495         free(qinst);
 496 }
 497
 498 struct qreg
 499 qir_follow_movs(struct vc4_compile *c, struct qreg reg)
 500 {
 501         int pack = reg.pack;
 502
 503         while (reg.file == QFILE_TEMP &&
 504                c->defs[reg.index] &&
 505                (c->defs[reg.index]->op == QOP_MOV ||
 506                 c->defs[reg.index]->op == QOP_FMOV ||
 507                 c->defs[reg.index]->op == QOP_MMOV)&&
 508                !c->defs[reg.index]->dst.pack &&
 509                !c->defs[reg.index]->src[0].pack) {
 510                 reg = c->defs[reg.index]->src[0];
 511         }
 512
 513         reg.pack = pack;
 514         return reg;
 515 }
 516
 517 void
 518 qir_compile_destroy(struct vc4_compile *c)
 519 {
 520         qir_for_each_block(block, c) {
 521                 while (!list_empty(&block->instructions)) {
 522                         struct qinst *qinst =
 523                                 list_first_entry(&block->instructions,
 524                                                  struct qinst, link);
 525                         qir_remove_instruction(c, qinst);
 526                 }
 527         }
 528
 529         ralloc_free(c);
 530 }
 531
 532 const char *
 533 qir_get_stage_name(enum qstage stage)
 534 {
 535         static const char *names[] = {
 536                 [QSTAGE_FRAG] = "FS",
 537                 [QSTAGE_VERT] = "VS",
 538                 [QSTAGE_COORD] = "CS",
 539         };
 540
 541         return names[stage];
 542 }
 543
 544 struct qreg
 545 qir_uniform(struct vc4_compile *c,
 546             enum quniform_contents contents,
 547             uint32_t data)
 548 {
 549         for (int i = 0; i < c->num_uniforms; i++) {
 550                 if (c->uniform_contents[i] == contents &&
 551                     c->uniform_data[i] == data) {
 552                         return qir_reg(QFILE_UNIF, i);
 553                 }
 554         }
 555
 556         uint32_t uniform = c->num_uniforms++;
 557
 558         if (uniform >= c->uniform_array_size) {
 559                 c->uniform_array_size = MAX2(MAX2(16, uniform + 1),
 560                                              c->uniform_array_size * 2);
 561
 562                 c->uniform_data = reralloc(c, c->uniform_data,
 563                                            uint32_t,
 564                                            c->uniform_array_size);
 565                 c->uniform_contents = reralloc(c, c->uniform_contents,
 566                                                enum quniform_contents,
 567                                                c->uniform_array_size);
 568         }
 569
 570         c->uniform_contents[uniform] = contents;
 571         c->uniform_data[uniform] = data;
 572
 573         return qir_reg(QFILE_UNIF, uniform);
 574 }
 575
 576 void
 577 qir_SF(struct vc4_compile *c, struct qreg src)
 578 {
 579         struct qinst *last_inst = NULL;
 580
 581         if (!list_empty(&c->cur_block->instructions))
 582                 last_inst = (struct qinst *)c->cur_block->instructions.prev;
 583
 584         /* We don't have any way to guess which kind of MOV is implied. */
 585         assert(!src.pack);
 586
 587         if (src.file != QFILE_TEMP ||
 588             !c->defs[src.index] ||
 589             last_inst != c->defs[src.index]) {
 590                 last_inst = qir_MOV_dest(c, qir_reg(QFILE_NULL, 0), src);
 591                 last_inst = (struct qinst *)c->cur_block->instructions.prev;
 592         }
 593         last_inst->sf = true;
 594 }
 595
 596 #define OPTPASS(func)                                                   \
 597         do {                                                            \
 598                 bool stage_progress = func(c);                          \
 599                 if (stage_progress) {                                   \
 600                         progress = true;                                \
 601                         if (print_opt_debug) {                          \
 602                                 fprintf(stderr,                         \
 603                                         "QIR opt pass %2d: %s progress\n", \
 604                                         pass, #func);                   \
 605                         }                                               \
 606                         qir_validate(c);                                \
 607                 }                                                       \
 608         } while (0)
 609
 610 void
 611 qir_optimize(struct vc4_compile *c)
 612 {
 613         bool print_opt_debug = false;
 614         int pass = 1;
 615
 616         while (true) {
 617                 bool progress = false;
 618
 619                 OPTPASS(qir_opt_algebraic);
 620                 OPTPASS(qir_opt_constant_folding);
 621                 OPTPASS(qir_opt_copy_propagation);
 622                 OPTPASS(qir_opt_peephole_sf);
 623                 OPTPASS(qir_opt_dead_code);
 624                 OPTPASS(qir_opt_small_immediates);
 625                 OPTPASS(qir_opt_vpm);
 626
 627                 if (!progress)
 628                         break;
 629
 630                 pass++;
 631         }
 632 }