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         [QOP_BRANCH] = { "branch", 0, 0, true },
  88         [QOP_UNIFORMS_RESET] = { "uniforms_reset", 0, 2, true },
  89 };
  90
  91 static const char *
  92 qir_get_op_name(enum qop qop)
  93 {
  94         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
  95                 return qir_op_info[qop].name;
  96         else
  97                 return "???";
  98 }
  99
 100 int
 101 qir_get_op_nsrc(enum qop qop)
 102 {
 103         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 104                 return qir_op_info[qop].nsrc;
 105         else
 106                 abort();
 107 }
 108
 109 /**
 110  * Returns whether the instruction has any side effects that must be
 111  * preserved.
 112  */
 113 bool
 114 qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
 115 {
 116         switch (inst->dst.file) {
 117         case QFILE_TLB_Z_WRITE:
 118         case QFILE_TLB_COLOR_WRITE:
 119         case QFILE_TLB_COLOR_WRITE_MS:
 120         case QFILE_TLB_STENCIL_SETUP:
 121                 return true;
 122         default:
 123                 break;
 124         }
 125
 126         return qir_op_info[inst->op].has_side_effects;
 127 }
 128
 129 bool
 130 qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
 131 {
 132         /* We can dead-code eliminate varyings, because we only tell the VS
 133          * about the live ones at the end.  But we have to preserve the
 134          * point/line coordinates reads, because they're generated by
 135          * fixed-function hardware.
 136          */
 137         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 138                 if (inst->src[i].file == QFILE_VARY &&
 139                     c->input_slots[inst->src[i].index].slot == 0xff) {
 140                         return true;
 141                 }
 142
 143                 if (inst->src[i].file == QFILE_VPM)
 144                         return true;
 145         }
 146
 147         if (inst->dst.file == QFILE_VPM)
 148                 return true;
 149
 150         return false;
 151 }
 152
 153 bool
 154 qir_is_mul(struct qinst *inst)
 155 {
 156         switch (inst->op) {
 157         case QOP_MMOV:
 158         case QOP_FMUL:
 159         case QOP_MUL24:
 160         case QOP_V8MULD:
 161         case QOP_V8MIN:
 162         case QOP_V8MAX:
 163         case QOP_V8ADDS:
 164         case QOP_V8SUBS:
 165                 return true;
 166         default:
 167                 return false;
 168         }
 169 }
 170
 171 bool
 172 qir_is_float_input(struct qinst *inst)
 173 {
 174         switch (inst->op) {
 175         case QOP_FMOV:
 176         case QOP_FMUL:
 177         case QOP_FADD:
 178         case QOP_FSUB:
 179         case QOP_FMIN:
 180         case QOP_FMAX:
 181         case QOP_FMINABS:
 182         case QOP_FMAXABS:
 183         case QOP_FTOI:
 184                 return true;
 185         default:
 186                 return false;
 187         }
 188 }
 189
 190 bool
 191 qir_is_raw_mov(struct qinst *inst)
 192 {
 193         return ((inst->op == QOP_MOV ||
 194                  inst->op == QOP_FMOV ||
 195                  inst->op == QOP_MMOV) &&
 196                 inst->cond == QPU_COND_ALWAYS &&
 197                 !inst->dst.pack &&
 198                 !inst->src[0].pack);
 199 }
 200
 201 bool
 202 qir_is_tex(struct qinst *inst)
 203 {
 204         return inst->op >= QOP_TEX_S && inst->op <= QOP_TEX_DIRECT;
 205 }
 206
 207 bool
 208 qir_depends_on_flags(struct qinst *inst)
 209 {
 210         if (inst->op == QOP_BRANCH) {
 211                 return inst->cond != QPU_COND_BRANCH_ALWAYS;
 212         } else {
 213                 return (inst->cond != QPU_COND_ALWAYS &&
 214                         inst->cond != QPU_COND_NEVER);
 215         }
 216 }
 217
 218 bool
 219 qir_writes_r4(struct qinst *inst)
 220 {
 221         switch (inst->op) {
 222         case QOP_TEX_RESULT:
 223         case QOP_TLB_COLOR_READ:
 224         case QOP_RCP:
 225         case QOP_RSQ:
 226         case QOP_EXP2:
 227         case QOP_LOG2:
 228                 return true;
 229         default:
 230                 return false;
 231         }
 232 }
 233
 234 uint8_t
 235 qir_channels_written(struct qinst *inst)
 236 {
 237         if (qir_is_mul(inst)) {
 238                 switch (inst->dst.pack) {
 239                 case QPU_PACK_MUL_NOP:
 240                 case QPU_PACK_MUL_8888:
 241                         return 0xf;
 242                 case QPU_PACK_MUL_8A:
 243                         return 0x1;
 244                 case QPU_PACK_MUL_8B:
 245                         return 0x2;
 246                 case QPU_PACK_MUL_8C:
 247                         return 0x4;
 248                 case QPU_PACK_MUL_8D:
 249                         return 0x8;
 250                 }
 251         } else {
 252                 switch (inst->dst.pack) {
 253                 case QPU_PACK_A_NOP:
 254                 case QPU_PACK_A_8888:
 255                 case QPU_PACK_A_8888_SAT:
 256                 case QPU_PACK_A_32_SAT:
 257                         return 0xf;
 258                 case QPU_PACK_A_8A:
 259                 case QPU_PACK_A_8A_SAT:
 260                         return 0x1;
 261                 case QPU_PACK_A_8B:
 262                 case QPU_PACK_A_8B_SAT:
 263                         return 0x2;
 264                 case QPU_PACK_A_8C:
 265                 case QPU_PACK_A_8C_SAT:
 266                         return 0x4;
 267                 case QPU_PACK_A_8D:
 268                 case QPU_PACK_A_8D_SAT:
 269                         return 0x8;
 270                 case QPU_PACK_A_16A:
 271                 case QPU_PACK_A_16A_SAT:
 272                         return 0x3;
 273                 case QPU_PACK_A_16B:
 274                 case QPU_PACK_A_16B_SAT:
 275                         return 0xc;
 276                 }
 277         }
 278         unreachable("Bad pack field");
 279 }
 280
 281 static void
 282 qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
 283 {
 284         static const char *files[] = {
 285                 [QFILE_TEMP] = "t",
 286                 [QFILE_VARY] = "v",
 287                 [QFILE_UNIF] = "u",
 288                 [QFILE_TLB_COLOR_WRITE] = "tlb_c",
 289                 [QFILE_TLB_COLOR_WRITE_MS] = "tlb_c_ms",
 290                 [QFILE_TLB_Z_WRITE] = "tlb_z",
 291                 [QFILE_TLB_STENCIL_SETUP] = "tlb_stencil",
 292                 [QFILE_FRAG_X] = "frag_x",
 293                 [QFILE_FRAG_Y] = "frag_y",
 294                 [QFILE_FRAG_REV_FLAG] = "frag_rev_flag",
 295         };
 296
 297         switch (reg.file) {
 298
 299         case QFILE_NULL:
 300                 fprintf(stderr, "null");
 301                 break;
 302
 303         case QFILE_LOAD_IMM:
 304                 fprintf(stderr, "0x%08x (%f)", reg.index, uif(reg.index));
 305                 break;
 306
 307         case QFILE_SMALL_IMM:
 308                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
 309                         fprintf(stderr, "%d", reg.index);
 310                 else
 311                         fprintf(stderr, "%f", uif(reg.index));
 312                 break;
 313
 314         case QFILE_VPM:
 315                 if (write) {
 316                         fprintf(stderr, "vpm");
 317                 } else {
 318                         fprintf(stderr, "vpm%d.%d",
 319                                 reg.index / 4, reg.index % 4);
 320                 }
 321                 break;
 322
 323         case QFILE_TLB_COLOR_WRITE:
 324         case QFILE_TLB_COLOR_WRITE_MS:
 325         case QFILE_TLB_Z_WRITE:
 326         case QFILE_TLB_STENCIL_SETUP:
 327                 fprintf(stderr, "%s", files[reg.file]);
 328                 break;
 329
 330         default:
 331                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 332                 break;
 333         }
 334
 335         if (reg.file == QFILE_UNIF &&
 336             c->uniform_contents[reg.index] == QUNIFORM_CONSTANT) {
 337                 fprintf(stderr, " (0x%08x / %f)",
 338                         c->uniform_data[reg.index],
 339                         uif(c->uniform_data[reg.index]));
 340         }
 341 }
 342
 343 void
 344 qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
 345 {
 346         fprintf(stderr, "%s", qir_get_op_name(inst->op));
 347         if (inst->op == QOP_BRANCH)
 348                 vc4_qpu_disasm_cond_branch(stderr, inst->cond);
 349         else
 350                 vc4_qpu_disasm_cond(stderr, inst->cond);
 351         if (inst->sf)
 352                 fprintf(stderr, ".sf");
 353         fprintf(stderr, " ");
 354
 355         if (inst->op != QOP_BRANCH) {
 356                 qir_print_reg(c, inst->dst, true);
 357                 if (inst->dst.pack) {
 358                         if (inst->dst.pack) {
 359                                 if (qir_is_mul(inst))
 360                                         vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
 361                                 else
 362                                         vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
 363                         }
 364                 }
 365         }
 366
 367         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 368                 fprintf(stderr, ", ");
 369                 qir_print_reg(c, inst->src[i], false);
 370                 vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
 371         }
 372 }
 373
 374 void
 375 qir_dump(struct vc4_compile *c)
 376 {
 377         int ip = 0;
 378
 379         qir_for_each_block(block, c) {
 380                 fprintf(stderr, "BLOCK %d:\n", block->index);
 381                 qir_for_each_inst(inst, block) {
 382                         if (c->temp_start) {
 383                                 bool first = true;
 384
 385                                 for (int i = 0; i < c->num_temps; i++) {
 386                                         if (c->temp_start[i] != ip)
 387                                                 continue;
 388
 389                                         if (first) {
 390                                                 first = false;
 391                                         } else {
 392                                                 fprintf(stderr, ", ");
 393                                         }
 394                                         fprintf(stderr, "S%4d", i);
 395                                 }
 396
 397                                 if (first)
 398                                         fprintf(stderr, "      ");
 399                                 else
 400                                         fprintf(stderr, " ");
 401                         }
 402
 403                         if (c->temp_end) {
 404                                 bool first = true;
 405
 406                                 for (int i = 0; i < c->num_temps; i++) {
 407                                         if (c->temp_end[i] != ip)
 408                                                 continue;
 409
 410                                         if (first) {
 411                                                 first = false;
 412                                         } else {
 413                                                 fprintf(stderr, ", ");
 414                                         }
 415                                         fprintf(stderr, "E%4d", i);
 416                                 }
 417
 418                                 if (first)
 419                                         fprintf(stderr, "      ");
 420                                 else
 421                                         fprintf(stderr, " ");
 422                         }
 423
 424                         qir_dump_inst(c, inst);
 425                         fprintf(stderr, "\n");
 426                         ip++;
 427                 }
 428                 if (block->successors[1]) {
 429                         fprintf(stderr, "-> BLOCK %d, %d\n",
 430                                 block->successors[0]->index,
 431                                 block->successors[1]->index);
 432                 } else if (block->successors[0]) {
 433                         fprintf(stderr, "-> BLOCK %d\n",
 434                                 block->successors[0]->index);
 435                 }
 436         }
 437 }
 438
 439 struct qreg
 440 qir_get_temp(struct vc4_compile *c)
 441 {
 442         struct qreg reg;
 443
 444         reg.file = QFILE_TEMP;
 445         reg.index = c->num_temps++;
 446         reg.pack = 0;
 447
 448         if (c->num_temps > c->defs_array_size) {
 449                 uint32_t old_size = c->defs_array_size;
 450                 c->defs_array_size = MAX2(old_size * 2, 16);
 451                 c->defs = reralloc(c, c->defs, struct qinst *,
 452                                    c->defs_array_size);
 453                 memset(&c->defs[old_size], 0,
 454                        sizeof(c->defs[0]) * (c->defs_array_size - old_size));
 455         }
 456
 457         return reg;
 458 }
 459
 460 struct qinst *
 461 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 462 {
 463         struct qinst *inst = CALLOC_STRUCT(qinst);
 464
 465         inst->op = op;
 466         inst->dst = dst;
 467         inst->src = calloc(2, sizeof(inst->src[0]));
 468         inst->src[0] = src0;
 469         inst->src[1] = src1;
 470         inst->cond = QPU_COND_ALWAYS;
 471
 472         return inst;
 473 }
 474
 475 struct qinst *
 476 qir_inst4(enum qop op, struct qreg dst,
 477           struct qreg a,
 478           struct qreg b,
 479           struct qreg c,
 480           struct qreg d)
 481 {
 482         struct qinst *inst = CALLOC_STRUCT(qinst);
 483
 484         inst->op = op;
 485         inst->dst = dst;
 486         inst->src = calloc(4, sizeof(*inst->src));
 487         inst->src[0] = a;
 488         inst->src[1] = b;
 489         inst->src[2] = c;
 490         inst->src[3] = d;
 491
 492         return inst;
 493 }
 494
 495 static void
 496 qir_emit(struct vc4_compile *c, struct qinst *inst)
 497 {
 498         list_addtail(&inst->link, &c->cur_block->instructions);
 499 }
 500
 501 /* Updates inst to write to a new temporary, emits it, and notes the def. */
 502 struct qreg
 503 qir_emit_def(struct vc4_compile *c, struct qinst *inst)
 504 {
 505         assert(inst->dst.file == QFILE_NULL);
 506
 507         inst->dst = qir_get_temp(c);
 508
 509         if (inst->dst.file == QFILE_TEMP)
 510                 c->defs[inst->dst.index] = inst;
 511
 512         qir_emit(c, inst);
 513
 514         return inst->dst;
 515 }
 516
 517 struct qinst *
 518 qir_emit_nondef(struct vc4_compile *c, struct qinst *inst)
 519 {
 520         if (inst->dst.file == QFILE_TEMP)
 521                 c->defs[inst->dst.index] = NULL;
 522
 523         qir_emit(c, inst);
 524
 525         return inst;
 526 }
 527
 528 bool
 529 qir_reg_equals(struct qreg a, struct qreg b)
 530 {
 531         return a.file == b.file && a.index == b.index && a.pack == b.pack;
 532 }
 533
 534 struct qblock *
 535 qir_new_block(struct vc4_compile *c)
 536 {
 537         struct qblock *block = rzalloc(c, struct qblock);
 538
 539         list_inithead(&block->instructions);
 540         list_inithead(&block->qpu_inst_list);
 541
 542         block->predecessors = _mesa_set_create(block,
 543                                                _mesa_hash_pointer,
 544                                                _mesa_key_pointer_equal);
 545
 546         block->index = c->next_block_index++;
 547
 548         return block;
 549 }
 550
 551 void
 552 qir_set_emit_block(struct vc4_compile *c, struct qblock *block)
 553 {
 554         c->cur_block = block;
 555         list_addtail(&block->link, &c->blocks);
 556 }
 557
 558 struct qblock *
 559 qir_entry_block(struct vc4_compile *c)
 560 {
 561         return list_first_entry(&c->blocks, struct qblock, link);
 562 }
 563
 564 struct qblock *
 565 qir_exit_block(struct vc4_compile *c)
 566 {
 567         return list_last_entry(&c->blocks, struct qblock, link);
 568 }
 569
 570 void
 571 qir_link_blocks(struct qblock *predecessor, struct qblock *successor)
 572 {
 573         _mesa_set_add(successor->predecessors, predecessor);
 574         if (predecessor->successors[0]) {
 575                 assert(!predecessor->successors[1]);
 576                 predecessor->successors[1] = successor;
 577         } else {
 578                 predecessor->successors[0] = successor;
 579         }
 580 }
 581
 582 struct vc4_compile *
 583 qir_compile_init(void)
 584 {
 585         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 586
 587         list_inithead(&c->blocks);
 588         qir_set_emit_block(c, qir_new_block(c));
 589
 590         c->output_position_index = -1;
 591         c->output_color_index = -1;
 592         c->output_point_size_index = -1;
 593         c->output_sample_mask_index = -1;
 594
 595         c->def_ht = _mesa_hash_table_create(c, _mesa_hash_pointer,
 596                                             _mesa_key_pointer_equal);
 597
 598         return c;
 599 }
 600
 601 void
 602 qir_remove_instruction(struct vc4_compile *c, struct qinst *qinst)
 603 {
 604         if (qinst->dst.file == QFILE_TEMP)
 605                 c->defs[qinst->dst.index] = NULL;
 606
 607         list_del(&qinst->link);
 608         free(qinst->src);
 609         free(qinst);
 610 }
 611
 612 struct qreg
 613 qir_follow_movs(struct vc4_compile *c, struct qreg reg)
 614 {
 615         int pack = reg.pack;
 616
 617         while (reg.file == QFILE_TEMP &&
 618                c->defs[reg.index] &&
 619                (c->defs[reg.index]->op == QOP_MOV ||
 620                 c->defs[reg.index]->op == QOP_FMOV ||
 621                 c->defs[reg.index]->op == QOP_MMOV)&&
 622                !c->defs[reg.index]->dst.pack &&
 623                !c->defs[reg.index]->src[0].pack) {
 624                 reg = c->defs[reg.index]->src[0];
 625         }
 626
 627         reg.pack = pack;
 628         return reg;
 629 }
 630
 631 void
 632 qir_compile_destroy(struct vc4_compile *c)
 633 {
 634         qir_for_each_block(block, c) {
 635                 while (!list_empty(&block->instructions)) {
 636                         struct qinst *qinst =
 637                                 list_first_entry(&block->instructions,
 638                                                  struct qinst, link);
 639                         qir_remove_instruction(c, qinst);
 640                 }
 641         }
 642
 643         ralloc_free(c);
 644 }
 645
 646 const char *
 647 qir_get_stage_name(enum qstage stage)
 648 {
 649         static const char *names[] = {
 650                 [QSTAGE_FRAG] = "FS",
 651                 [QSTAGE_VERT] = "VS",
 652                 [QSTAGE_COORD] = "CS",
 653         };
 654
 655         return names[stage];
 656 }
 657
 658 struct qreg
 659 qir_uniform(struct vc4_compile *c,
 660             enum quniform_contents contents,
 661             uint32_t data)
 662 {
 663         for (int i = 0; i < c->num_uniforms; i++) {
 664                 if (c->uniform_contents[i] == contents &&
 665                     c->uniform_data[i] == data) {
 666                         return qir_reg(QFILE_UNIF, i);
 667                 }
 668         }
 669
 670         uint32_t uniform = c->num_uniforms++;
 671
 672         if (uniform >= c->uniform_array_size) {
 673                 c->uniform_array_size = MAX2(MAX2(16, uniform + 1),
 674                                              c->uniform_array_size * 2);
 675
 676                 c->uniform_data = reralloc(c, c->uniform_data,
 677                                            uint32_t,
 678                                            c->uniform_array_size);
 679                 c->uniform_contents = reralloc(c, c->uniform_contents,
 680                                                enum quniform_contents,
 681                                                c->uniform_array_size);
 682         }
 683
 684         c->uniform_contents[uniform] = contents;
 685         c->uniform_data[uniform] = data;
 686
 687         return qir_reg(QFILE_UNIF, uniform);
 688 }
 689
 690 void
 691 qir_SF(struct vc4_compile *c, struct qreg src)
 692 {
 693         struct qinst *last_inst = NULL;
 694
 695         if (!list_empty(&c->cur_block->instructions))
 696                 last_inst = (struct qinst *)c->cur_block->instructions.prev;
 697
 698         /* We don't have any way to guess which kind of MOV is implied. */
 699         assert(!src.pack);
 700
 701         if (src.file != QFILE_TEMP ||
 702             !c->defs[src.index] ||
 703             last_inst != c->defs[src.index]) {
 704                 last_inst = qir_MOV_dest(c, qir_reg(QFILE_NULL, 0), src);
 705                 last_inst = (struct qinst *)c->cur_block->instructions.prev;
 706         }
 707         last_inst->sf = true;
 708 }
 709
 710 #define OPTPASS(func)                                                   \
 711         do {                                                            \
 712                 bool stage_progress = func(c);                          \
 713                 if (stage_progress) {                                   \
 714                         progress = true;                                \
 715                         if (print_opt_debug) {                          \
 716                                 fprintf(stderr,                         \
 717                                         "QIR opt pass %2d: %s progress\n", \
 718                                         pass, #func);                   \
 719                         }                                               \
 720                         qir_validate(c);                                \
 721                 }                                                       \
 722         } while (0)
 723
 724 void
 725 qir_optimize(struct vc4_compile *c)
 726 {
 727         bool print_opt_debug = false;
 728         int pass = 1;
 729
 730         while (true) {
 731                 bool progress = false;
 732
 733                 OPTPASS(qir_opt_algebraic);
 734                 OPTPASS(qir_opt_constant_folding);
 735                 OPTPASS(qir_opt_copy_propagation);
 736                 OPTPASS(qir_opt_peephole_sf);
 737                 OPTPASS(qir_opt_dead_code);
 738                 OPTPASS(qir_opt_small_immediates);
 739                 OPTPASS(qir_opt_vpm);
 740
 741                 if (!progress)
 742                         break;
 743
 744                 pass++;
 745         }
 746 }