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, 2 },
  70         [QOP_LOG2] = { "log2", 1, 2 },
  71         [QOP_TLB_STENCIL_SETUP] = { "tlb_stencil_setup", 0, 1, true },
  72         [QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
  73         [QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
  74         [QOP_TLB_COLOR_WRITE_MS] = { "tlb_color_ms", 0, 1, true },
  75         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0 },
  76         [QOP_MS_MASK] = { "ms_mask", 0, 1, true },
  77         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  78
  79         [QOP_FRAG_X] = { "frag_x", 1, 0 },
  80         [QOP_FRAG_Y] = { "frag_y", 1, 0 },
  81         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  82         [QOP_FRAG_W] = { "frag_w", 1, 0 },
  83         [QOP_FRAG_REV_FLAG] = { "frag_rev_flag", 1, 0 },
  84
  85         [QOP_TEX_S] = { "tex_s", 0, 2 },
  86         [QOP_TEX_T] = { "tex_t", 0, 2 },
  87         [QOP_TEX_R] = { "tex_r", 0, 2 },
  88         [QOP_TEX_B] = { "tex_b", 0, 2 },
  89         [QOP_TEX_DIRECT] = { "tex_direct", 0, 2 },
  90         [QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
  91 };
  92
  93 static const char *
  94 qir_get_op_name(enum qop qop)
  95 {
  96         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
  97                 return qir_op_info[qop].name;
  98         else
  99                 return "???";
 100 }
 101
 102 int
 103 qir_get_op_nsrc(enum qop qop)
 104 {
 105         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 106                 return qir_op_info[qop].nsrc;
 107         else
 108                 abort();
 109 }
 110
 111 /**
 112  * Returns whether the instruction has any side effects that must be
 113  * preserved.
 114  */
 115 bool
 116 qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
 117 {
 118         return qir_op_info[inst->op].has_side_effects;
 119 }
 120
 121 bool
 122 qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
 123 {
 124         /* We can dead-code eliminate varyings, because we only tell the VS
 125          * about the live ones at the end.  But we have to preserve the
 126          * point/line coordinates reads, because they're generated by
 127          * fixed-function hardware.
 128          */
 129         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 130                 if (inst->src[i].file == QFILE_VARY &&
 131                     c->input_slots[inst->src[i].index].slot == 0xff) {
 132                         return true;
 133                 }
 134
 135                 if (inst->src[i].file == QFILE_VPM)
 136                         return true;
 137         }
 138
 139         if (inst->dst.file == QFILE_VPM)
 140                 return true;
 141
 142         return false;
 143 }
 144
 145 bool
 146 qir_is_mul(struct qinst *inst)
 147 {
 148         switch (inst->op) {
 149         case QOP_MMOV:
 150         case QOP_FMUL:
 151         case QOP_MUL24:
 152         case QOP_V8MULD:
 153         case QOP_V8MIN:
 154         case QOP_V8MAX:
 155         case QOP_V8ADDS:
 156         case QOP_V8SUBS:
 157                 return true;
 158         default:
 159                 return false;
 160         }
 161 }
 162
 163 bool
 164 qir_is_float_input(struct qinst *inst)
 165 {
 166         switch (inst->op) {
 167         case QOP_FMOV:
 168         case QOP_FMUL:
 169         case QOP_FADD:
 170         case QOP_FSUB:
 171         case QOP_FMIN:
 172         case QOP_FMAX:
 173         case QOP_FMINABS:
 174         case QOP_FMAXABS:
 175         case QOP_FTOI:
 176                 return true;
 177         default:
 178                 return false;
 179         }
 180 }
 181
 182 bool
 183 qir_is_raw_mov(struct qinst *inst)
 184 {
 185         return ((inst->op == QOP_MOV ||
 186                  inst->op == QOP_FMOV ||
 187                  inst->op == QOP_MMOV) &&
 188                 inst->cond == QPU_COND_ALWAYS &&
 189                 !inst->dst.pack &&
 190                 !inst->src[0].pack);
 191 }
 192
 193 bool
 194 qir_is_tex(struct qinst *inst)
 195 {
 196         return inst->op >= QOP_TEX_S && inst->op <= QOP_TEX_DIRECT;
 197 }
 198
 199 bool
 200 qir_depends_on_flags(struct qinst *inst)
 201 {
 202         return (inst->cond != QPU_COND_ALWAYS &&
 203                 inst->cond != QPU_COND_NEVER);
 204 }
 205
 206 bool
 207 qir_writes_r4(struct qinst *inst)
 208 {
 209         switch (inst->op) {
 210         case QOP_TEX_RESULT:
 211         case QOP_TLB_COLOR_READ:
 212         case QOP_RCP:
 213         case QOP_RSQ:
 214         case QOP_EXP2:
 215         case QOP_LOG2:
 216                 return true;
 217         default:
 218                 return false;
 219         }
 220 }
 221
 222 static void
 223 qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
 224 {
 225         static const char *files[] = {
 226                 [QFILE_TEMP] = "t",
 227                 [QFILE_VARY] = "v",
 228                 [QFILE_UNIF] = "u",
 229         };
 230
 231         if (reg.file == QFILE_NULL) {
 232                 fprintf(stderr, "null");
 233         } else if (reg.file == QFILE_SMALL_IMM) {
 234                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
 235                         fprintf(stderr, "%d", reg.index);
 236                 else
 237                         fprintf(stderr, "%f", uif(reg.index));
 238         } else if (reg.file == QFILE_VPM) {
 239                 if (write) {
 240                         fprintf(stderr, "vpm");
 241                 } else {
 242                         fprintf(stderr, "vpm%d.%d",
 243                                 reg.index / 4, reg.index % 4);
 244                 }
 245         } else {
 246                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 247         }
 248
 249         if (reg.file == QFILE_UNIF &&
 250             c->uniform_contents[reg.index] == QUNIFORM_CONSTANT) {
 251                 fprintf(stderr, " (0x%08x / %f)",
 252                         c->uniform_data[reg.index],
 253                         uif(c->uniform_data[reg.index]));
 254         }
 255 }
 256
 257 void
 258 qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
 259 {
 260         static const char *conditions[] = {
 261                 [QPU_COND_ALWAYS] = "",
 262                 [QPU_COND_NEVER] = ".never",
 263                 [QPU_COND_ZS] = ".zs",
 264                 [QPU_COND_ZC] = ".zc",
 265                 [QPU_COND_NS] = ".ns",
 266                 [QPU_COND_NC] = ".nc",
 267                 [QPU_COND_CS] = ".cs",
 268                 [QPU_COND_CC] = ".cc",
 269         };
 270         fprintf(stderr, "%s%s%s ",
 271                 qir_get_op_name(inst->op),
 272                 conditions[inst->cond],
 273                 inst->sf ? ".sf" : "");
 274
 275         qir_print_reg(c, inst->dst, true);
 276         if (inst->dst.pack) {
 277                 if (inst->dst.pack) {
 278                         if (qir_is_mul(inst))
 279                                 vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
 280                         else
 281                                 vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
 282                 }
 283         }
 284         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 285                 fprintf(stderr, ", ");
 286                 qir_print_reg(c, inst->src[i], false);
 287                 vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
 288         }
 289 }
 290
 291 void
 292 qir_dump(struct vc4_compile *c)
 293 {
 294         list_for_each_entry(struct qinst, inst, &c->instructions, link) {
 295                 qir_dump_inst(c, inst);
 296                 fprintf(stderr, "\n");
 297         }
 298 }
 299
 300 struct qreg
 301 qir_get_temp(struct vc4_compile *c)
 302 {
 303         struct qreg reg;
 304
 305         reg.file = QFILE_TEMP;
 306         reg.index = c->num_temps++;
 307         reg.pack = 0;
 308
 309         if (c->num_temps > c->defs_array_size) {
 310                 uint32_t old_size = c->defs_array_size;
 311                 c->defs_array_size = MAX2(old_size * 2, 16);
 312                 c->defs = reralloc(c, c->defs, struct qinst *,
 313                                    c->defs_array_size);
 314                 memset(&c->defs[old_size], 0,
 315                        sizeof(c->defs[0]) * (c->defs_array_size - old_size));
 316         }
 317
 318         return reg;
 319 }
 320
 321 struct qinst *
 322 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 323 {
 324         struct qinst *inst = CALLOC_STRUCT(qinst);
 325
 326         inst->op = op;
 327         inst->dst = dst;
 328         inst->src = calloc(2, sizeof(inst->src[0]));
 329         inst->src[0] = src0;
 330         inst->src[1] = src1;
 331         inst->cond = QPU_COND_ALWAYS;
 332
 333         return inst;
 334 }
 335
 336 struct qinst *
 337 qir_inst4(enum qop op, struct qreg dst,
 338           struct qreg a,
 339           struct qreg b,
 340           struct qreg c,
 341           struct qreg d)
 342 {
 343         struct qinst *inst = CALLOC_STRUCT(qinst);
 344
 345         inst->op = op;
 346         inst->dst = dst;
 347         inst->src = calloc(4, sizeof(*inst->src));
 348         inst->src[0] = a;
 349         inst->src[1] = b;
 350         inst->src[2] = c;
 351         inst->src[3] = d;
 352
 353         return inst;
 354 }
 355
 356 void
 357 qir_emit(struct vc4_compile *c, struct qinst *inst)
 358 {
 359         if (inst->dst.file == QFILE_TEMP)
 360                 c->defs[inst->dst.index] = inst;
 361
 362         qir_emit_nodef(c, inst);
 363 }
 364
 365 bool
 366 qir_reg_equals(struct qreg a, struct qreg b)
 367 {
 368         return a.file == b.file && a.index == b.index;
 369 }
 370
 371 struct vc4_compile *
 372 qir_compile_init(void)
 373 {
 374         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 375
 376         list_inithead(&c->instructions);
 377
 378         c->output_position_index = -1;
 379         c->output_color_index = -1;
 380         c->output_point_size_index = -1;
 381         c->output_sample_mask_index = -1;
 382
 383         c->def_ht = _mesa_hash_table_create(c, _mesa_hash_pointer,
 384                                             _mesa_key_pointer_equal);
 385
 386         return c;
 387 }
 388
 389 void
 390 qir_remove_instruction(struct vc4_compile *c, struct qinst *qinst)
 391 {
 392         if (qinst->dst.file == QFILE_TEMP)
 393                 c->defs[qinst->dst.index] = NULL;
 394
 395         list_del(&qinst->link);
 396         free(qinst->src);
 397         free(qinst);
 398 }
 399
 400 struct qreg
 401 qir_follow_movs(struct vc4_compile *c, struct qreg reg)
 402 {
 403         int pack = reg.pack;
 404
 405         while (reg.file == QFILE_TEMP &&
 406                c->defs[reg.index] &&
 407                (c->defs[reg.index]->op == QOP_MOV ||
 408                 c->defs[reg.index]->op == QOP_FMOV ||
 409                 c->defs[reg.index]->op == QOP_MMOV)&&
 410                !c->defs[reg.index]->dst.pack &&
 411                !c->defs[reg.index]->src[0].pack) {
 412                 reg = c->defs[reg.index]->src[0];
 413         }
 414
 415         reg.pack = pack;
 416         return reg;
 417 }
 418
 419 void
 420 qir_compile_destroy(struct vc4_compile *c)
 421 {
 422         while (!list_empty(&c->instructions)) {
 423                 struct qinst *qinst =
 424                         (struct qinst *)c->instructions.next;
 425                 qir_remove_instruction(c, qinst);
 426         }
 427
 428         ralloc_free(c);
 429 }
 430
 431 const char *
 432 qir_get_stage_name(enum qstage stage)
 433 {
 434         static const char *names[] = {
 435                 [QSTAGE_FRAG] = "FS",
 436                 [QSTAGE_VERT] = "VS",
 437                 [QSTAGE_COORD] = "CS",
 438         };
 439
 440         return names[stage];
 441 }
 442
 443 struct qreg
 444 qir_uniform(struct vc4_compile *c,
 445             enum quniform_contents contents,
 446             uint32_t data)
 447 {
 448         for (int i = 0; i < c->num_uniforms; i++) {
 449                 if (c->uniform_contents[i] == contents &&
 450                     c->uniform_data[i] == data) {
 451                         return (struct qreg) { QFILE_UNIF, i };
 452                 }
 453         }
 454
 455         uint32_t uniform = c->num_uniforms++;
 456         struct qreg u = { QFILE_UNIF, uniform };
 457
 458         if (uniform >= c->uniform_array_size) {
 459                 c->uniform_array_size = MAX2(MAX2(16, uniform + 1),
 460                                              c->uniform_array_size * 2);
 461
 462                 c->uniform_data = reralloc(c, c->uniform_data,
 463                                            uint32_t,
 464                                            c->uniform_array_size);
 465                 c->uniform_contents = reralloc(c, c->uniform_contents,
 466                                                enum quniform_contents,
 467                                                c->uniform_array_size);
 468         }
 469
 470         c->uniform_contents[uniform] = contents;
 471         c->uniform_data[uniform] = data;
 472
 473         return u;
 474 }
 475
 476 void
 477 qir_SF(struct vc4_compile *c, struct qreg src)
 478 {
 479         struct qinst *last_inst = NULL;
 480         if (!list_empty(&c->instructions))
 481                 last_inst = (struct qinst *)c->instructions.prev;
 482
 483         /* We don't have any way to guess which kind of MOV is implied. */
 484         assert(!src.pack);
 485
 486         if (src.file != QFILE_TEMP ||
 487             !c->defs[src.index] ||
 488             last_inst != c->defs[src.index]) {
 489                 struct qreg null = { QFILE_NULL, 0 };
 490                 last_inst = qir_MOV_dest(c, null, src);
 491                 last_inst = (struct qinst *)c->instructions.prev;
 492         }
 493         last_inst->sf = true;
 494 }
 495
 496 #define OPTPASS(func)                                                   \
 497         do {                                                            \
 498                 bool stage_progress = func(c);                          \
 499                 if (stage_progress) {                                   \
 500                         progress = true;                                \
 501                         if (print_opt_debug) {                          \
 502                                 fprintf(stderr,                         \
 503                                         "QIR opt pass %2d: %s progress\n", \
 504                                         pass, #func);                   \
 505                         }                                               \
 506                 }                                                       \
 507         } while (0)
 508
 509 void
 510 qir_optimize(struct vc4_compile *c)
 511 {
 512         bool print_opt_debug = false;
 513         int pass = 1;
 514
 515         while (true) {
 516                 bool progress = false;
 517
 518                 OPTPASS(qir_opt_algebraic);
 519                 OPTPASS(qir_opt_cse);
 520                 OPTPASS(qir_opt_constant_folding);
 521                 OPTPASS(qir_opt_copy_propagation);
 522                 OPTPASS(qir_opt_dead_code);
 523                 OPTPASS(qir_opt_small_immediates);
 524                 OPTPASS(qir_opt_vpm);
 525
 526                 if (!progress)
 527                         break;
 528
 529                 pass++;
 530         }
 531 }