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         bool multi_instruction;
  35 };
  36
  37 static const struct qir_op_info qir_op_info[] = {
  38         [QOP_MOV] = { "mov", 1, 1 },
  39         [QOP_FADD] = { "fadd", 1, 2 },
  40         [QOP_FSUB] = { "fsub", 1, 2 },
  41         [QOP_FMUL] = { "fmul", 1, 2 },
  42         [QOP_MUL24] = { "mul24", 1, 2 },
  43         [QOP_V8MULD] = {"v8muld", 1, 2 },
  44         [QOP_V8MIN] = {"v8min", 1, 2 },
  45         [QOP_V8MAX] = {"v8max", 1, 2 },
  46         [QOP_V8ADDS] = {"v8adds", 1, 2 },
  47         [QOP_V8SUBS] = {"v8subs", 1, 2 },
  48         [QOP_FMIN] = { "fmin", 1, 2 },
  49         [QOP_FMAX] = { "fmax", 1, 2 },
  50         [QOP_FMINABS] = { "fminabs", 1, 2 },
  51         [QOP_FMAXABS] = { "fmaxabs", 1, 2 },
  52         [QOP_FTOI] = { "ftoi", 1, 1 },
  53         [QOP_ITOF] = { "itof", 1, 1 },
  54         [QOP_ADD] = { "add", 1, 2 },
  55         [QOP_SUB] = { "sub", 1, 2 },
  56         [QOP_SHR] = { "shr", 1, 2 },
  57         [QOP_ASR] = { "asr", 1, 2 },
  58         [QOP_SHL] = { "shl", 1, 2 },
  59         [QOP_MIN] = { "min", 1, 2 },
  60         [QOP_MAX] = { "max", 1, 2 },
  61         [QOP_AND] = { "and", 1, 2 },
  62         [QOP_OR] = { "or", 1, 2 },
  63         [QOP_XOR] = { "xor", 1, 2 },
  64         [QOP_NOT] = { "not", 1, 1 },
  65
  66         [QOP_SEL_X_0_NS] = { "fsel_x_0_ns", 1, 1, false, true },
  67         [QOP_SEL_X_0_NC] = { "fsel_x_0_nc", 1, 1, false, true },
  68         [QOP_SEL_X_0_ZS] = { "fsel_x_0_zs", 1, 1, false, true },
  69         [QOP_SEL_X_0_ZC] = { "fsel_x_0_zc", 1, 1, false, true },
  70         [QOP_SEL_X_Y_NS] = { "fsel_x_y_ns", 1, 2, false, true },
  71         [QOP_SEL_X_Y_NC] = { "fsel_x_y_nc", 1, 2, false, true },
  72         [QOP_SEL_X_Y_ZS] = { "fsel_x_y_zs", 1, 2, false, true },
  73         [QOP_SEL_X_Y_ZC] = { "fsel_x_y_zc", 1, 2, false, true },
  74
  75         [QOP_RCP] = { "rcp", 1, 1, false, true },
  76         [QOP_RSQ] = { "rsq", 1, 1, false, true },
  77         [QOP_EXP2] = { "exp2", 1, 2, false, true },
  78         [QOP_LOG2] = { "log2", 1, 2, false, true },
  79         [QOP_PACK_8888_F] = { "pack_8888_f", 1, 1 },
  80         [QOP_PACK_8A_F] = { "pack_8a_f", 1, 1 },
  81         [QOP_PACK_8B_F] = { "pack_8b_f", 1, 1 },
  82         [QOP_PACK_8C_F] = { "pack_8c_f", 1, 1 },
  83         [QOP_PACK_8D_F] = { "pack_8d_f", 1, 1 },
  84         [QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
  85         [QOP_TLB_STENCIL_SETUP] = { "tlb_stencil_setup", 0, 1, true },
  86         [QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
  87         [QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
  88         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0 },
  89         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  90
  91         [QOP_FRAG_X] = { "frag_x", 1, 0 },
  92         [QOP_FRAG_Y] = { "frag_y", 1, 0 },
  93         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  94         [QOP_FRAG_W] = { "frag_w", 1, 0 },
  95         [QOP_FRAG_REV_FLAG] = { "frag_rev_flag", 1, 0 },
  96
  97         [QOP_TEX_S] = { "tex_s", 0, 2 },
  98         [QOP_TEX_T] = { "tex_t", 0, 2 },
  99         [QOP_TEX_R] = { "tex_r", 0, 2 },
 100         [QOP_TEX_B] = { "tex_b", 0, 2 },
 101         [QOP_TEX_DIRECT] = { "tex_direct", 0, 2 },
 102         [QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
 103         [QOP_UNPACK_8A_F] = { "unpack_8a_f", 1, 1 },
 104         [QOP_UNPACK_8B_F] = { "unpack_8b_f", 1, 1 },
 105         [QOP_UNPACK_8C_F] = { "unpack_8c_f", 1, 1 },
 106         [QOP_UNPACK_8D_F] = { "unpack_8d_f", 1, 1 },
 107         [QOP_UNPACK_16A_F] = { "unpack_16a_f", 1, 1 },
 108         [QOP_UNPACK_16B_F] = { "unpack_16b_f", 1, 1 },
 109         [QOP_UNPACK_8A_I] = { "unpack_8a_i", 1, 1 },
 110         [QOP_UNPACK_8B_I] = { "unpack_8b_i", 1, 1 },
 111         [QOP_UNPACK_8C_I] = { "unpack_8c_i", 1, 1 },
 112         [QOP_UNPACK_8D_I] = { "unpack_8d_i", 1, 1 },
 113         [QOP_UNPACK_16A_I] = { "unpack_16a_i", 1, 1 },
 114         [QOP_UNPACK_16B_I] = { "unpack_16b_i", 1, 1 },
 115 };
 116
 117 static const char *
 118 qir_get_op_name(enum qop qop)
 119 {
 120         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 121                 return qir_op_info[qop].name;
 122         else
 123                 return "???";
 124 }
 125
 126 int
 127 qir_get_op_nsrc(enum qop qop)
 128 {
 129         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 130                 return qir_op_info[qop].nsrc;
 131         else
 132                 abort();
 133 }
 134
 135 /**
 136  * Returns whether the instruction has any side effects that must be
 137  * preserved.
 138  */
 139 bool
 140 qir_has_side_effects(struct vc4_compile *c, struct qinst *inst)
 141 {
 142         return qir_op_info[inst->op].has_side_effects;
 143 }
 144
 145 bool
 146 qir_has_side_effect_reads(struct vc4_compile *c, struct qinst *inst)
 147 {
 148         /* We can dead-code eliminate varyings, because we only tell the VS
 149          * about the live ones at the end.  But we have to preserve the
 150          * point/line coordinates reads, because they're generated by
 151          * fixed-function hardware.
 152          */
 153         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 154                 if (inst->src[i].file == QFILE_VARY &&
 155                     c->input_slots[inst->src[i].index].slot == 0xff) {
 156                         return true;
 157                 }
 158
 159                 if (inst->src[i].file == QFILE_VPM)
 160                         return true;
 161         }
 162
 163         if (inst->dst.file == QFILE_VPM)
 164                 return true;
 165
 166         return false;
 167 }
 168
 169 bool
 170 qir_is_multi_instruction(struct qinst *inst)
 171 {
 172         return qir_op_info[inst->op].multi_instruction;
 173 }
 174
 175 bool
 176 qir_is_mul(struct qinst *inst)
 177 {
 178         switch (inst->op) {
 179         case QOP_FMUL:
 180         case QOP_MUL24:
 181         case QOP_V8MULD:
 182         case QOP_V8MIN:
 183         case QOP_V8MAX:
 184         case QOP_V8ADDS:
 185         case QOP_V8SUBS:
 186                 return true;
 187         default:
 188                 return false;
 189         }
 190 }
 191
 192 bool
 193 qir_is_float_input(struct qinst *inst)
 194 {
 195         switch (inst->op) {
 196         case QOP_FMUL:
 197         case QOP_FADD:
 198         case QOP_FSUB:
 199         case QOP_FMIN:
 200         case QOP_FMAX:
 201         case QOP_FMINABS:
 202         case QOP_FMAXABS:
 203         case QOP_FTOI:
 204         case QOP_UNPACK_8A_F:
 205         case QOP_UNPACK_8B_F:
 206         case QOP_UNPACK_8C_F:
 207         case QOP_UNPACK_8D_F:
 208         case QOP_UNPACK_16A_F:
 209         case QOP_UNPACK_16B_F:
 210                 return true;
 211         default:
 212                 return false;
 213         }
 214 }
 215
 216 bool
 217 qir_is_raw_mov(struct qinst *inst)
 218 {
 219         return (inst->op == QOP_MOV &&
 220                 !inst->dst.pack &&
 221                 !inst->src[0].pack);
 222 }
 223
 224 bool
 225 qir_is_tex(struct qinst *inst)
 226 {
 227         return inst->op >= QOP_TEX_S && inst->op <= QOP_TEX_DIRECT;
 228 }
 229
 230 bool
 231 qir_depends_on_flags(struct qinst *inst)
 232 {
 233         switch (inst->op) {
 234         case QOP_SEL_X_0_NS:
 235         case QOP_SEL_X_0_NC:
 236         case QOP_SEL_X_0_ZS:
 237         case QOP_SEL_X_0_ZC:
 238         case QOP_SEL_X_Y_NS:
 239         case QOP_SEL_X_Y_NC:
 240         case QOP_SEL_X_Y_ZS:
 241         case QOP_SEL_X_Y_ZC:
 242                 return true;
 243         default:
 244                 return false;
 245         }
 246 }
 247
 248 bool
 249 qir_src_needs_a_file(struct qinst *inst)
 250 {
 251         switch (inst->op) {
 252         case QOP_UNPACK_8A_F:
 253         case QOP_UNPACK_8B_F:
 254         case QOP_UNPACK_8C_F:
 255         case QOP_UNPACK_8D_F:
 256         case QOP_UNPACK_16A_F:
 257         case QOP_UNPACK_16B_F:
 258         case QOP_UNPACK_8A_I:
 259         case QOP_UNPACK_8B_I:
 260         case QOP_UNPACK_8C_I:
 261         case QOP_UNPACK_8D_I:
 262         case QOP_UNPACK_16A_I:
 263         case QOP_UNPACK_16B_I:
 264                 return true;
 265         default:
 266                 return false;
 267         }
 268 }
 269
 270 bool
 271 qir_writes_r4(struct qinst *inst)
 272 {
 273         switch (inst->op) {
 274         case QOP_TEX_RESULT:
 275         case QOP_TLB_COLOR_READ:
 276         case QOP_RCP:
 277         case QOP_RSQ:
 278         case QOP_EXP2:
 279         case QOP_LOG2:
 280                 return true;
 281         default:
 282                 return false;
 283         }
 284 }
 285
 286 static void
 287 qir_print_reg(struct vc4_compile *c, struct qreg reg, bool write)
 288 {
 289         static const char *files[] = {
 290                 [QFILE_TEMP] = "t",
 291                 [QFILE_VARY] = "v",
 292                 [QFILE_UNIF] = "u",
 293         };
 294
 295         if (reg.file == QFILE_NULL) {
 296                 fprintf(stderr, "null");
 297         } else if (reg.file == QFILE_SMALL_IMM) {
 298                 if ((int)reg.index >= -16 && (int)reg.index <= 15)
 299                         fprintf(stderr, "%d", reg.index);
 300                 else
 301                         fprintf(stderr, "%f", uif(reg.index));
 302         } else if (reg.file == QFILE_VPM) {
 303                 if (write) {
 304                         fprintf(stderr, "vpm");
 305                 } else {
 306                         fprintf(stderr, "vpm%d.%d",
 307                                 reg.index / 4, reg.index % 4);
 308                 }
 309         } else {
 310                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 311         }
 312
 313         if (reg.file == QFILE_UNIF &&
 314             c->uniform_contents[reg.index] == QUNIFORM_CONSTANT) {
 315                 fprintf(stderr, " (0x%08x / %f)",
 316                         c->uniform_data[reg.index],
 317                         uif(c->uniform_data[reg.index]));
 318         }
 319 }
 320
 321 void
 322 qir_dump_inst(struct vc4_compile *c, struct qinst *inst)
 323 {
 324         fprintf(stderr, "%s%s ",
 325                 qir_get_op_name(inst->op),
 326                 inst->sf ? ".sf" : "");
 327
 328         qir_print_reg(c, inst->dst, true);
 329         if (inst->dst.pack) {
 330                 if (inst->dst.pack) {
 331                         if (qir_is_mul(inst))
 332                                 vc4_qpu_disasm_pack_mul(stderr, inst->dst.pack);
 333                         else
 334                                 vc4_qpu_disasm_pack_a(stderr, inst->dst.pack);
 335                 }
 336         }
 337         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 338                 fprintf(stderr, ", ");
 339                 qir_print_reg(c, inst->src[i], false);
 340                 vc4_qpu_disasm_unpack(stderr, inst->src[i].pack);
 341         }
 342 }
 343
 344 void
 345 qir_dump(struct vc4_compile *c)
 346 {
 347         list_for_each_entry(struct qinst, inst, &c->instructions, link) {
 348                 qir_dump_inst(c, inst);
 349                 fprintf(stderr, "\n");
 350         }
 351 }
 352
 353 struct qreg
 354 qir_get_temp(struct vc4_compile *c)
 355 {
 356         struct qreg reg;
 357
 358         reg.file = QFILE_TEMP;
 359         reg.index = c->num_temps++;
 360         reg.pack = 0;
 361
 362         if (c->num_temps > c->defs_array_size) {
 363                 uint32_t old_size = c->defs_array_size;
 364                 c->defs_array_size = MAX2(old_size * 2, 16);
 365                 c->defs = reralloc(c, c->defs, struct qinst *,
 366                                    c->defs_array_size);
 367                 memset(&c->defs[old_size], 0,
 368                        sizeof(c->defs[0]) * (c->defs_array_size - old_size));
 369         }
 370
 371         return reg;
 372 }
 373
 374 struct qinst *
 375 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 376 {
 377         struct qinst *inst = CALLOC_STRUCT(qinst);
 378
 379         inst->op = op;
 380         inst->dst = dst;
 381         inst->src = calloc(2, sizeof(inst->src[0]));
 382         inst->src[0] = src0;
 383         inst->src[1] = src1;
 384
 385         return inst;
 386 }
 387
 388 struct qinst *
 389 qir_inst4(enum qop op, struct qreg dst,
 390           struct qreg a,
 391           struct qreg b,
 392           struct qreg c,
 393           struct qreg d)
 394 {
 395         struct qinst *inst = CALLOC_STRUCT(qinst);
 396
 397         inst->op = op;
 398         inst->dst = dst;
 399         inst->src = calloc(4, sizeof(*inst->src));
 400         inst->src[0] = a;
 401         inst->src[1] = b;
 402         inst->src[2] = c;
 403         inst->src[3] = d;
 404
 405         return inst;
 406 }
 407
 408 void
 409 qir_emit(struct vc4_compile *c, struct qinst *inst)
 410 {
 411         if (inst->dst.file == QFILE_TEMP)
 412                 c->defs[inst->dst.index] = inst;
 413
 414         qir_emit_nodef(c, inst);
 415 }
 416
 417 bool
 418 qir_reg_equals(struct qreg a, struct qreg b)
 419 {
 420         return a.file == b.file && a.index == b.index;
 421 }
 422
 423 struct vc4_compile *
 424 qir_compile_init(void)
 425 {
 426         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 427
 428         list_inithead(&c->instructions);
 429
 430         c->output_position_index = -1;
 431         c->output_color_index = -1;
 432         c->output_point_size_index = -1;
 433
 434         c->def_ht = _mesa_hash_table_create(c, _mesa_hash_pointer,
 435                                             _mesa_key_pointer_equal);
 436
 437         return c;
 438 }
 439
 440 void
 441 qir_remove_instruction(struct vc4_compile *c, struct qinst *qinst)
 442 {
 443         if (qinst->dst.file == QFILE_TEMP)
 444                 c->defs[qinst->dst.index] = NULL;
 445
 446         list_del(&qinst->link);
 447         free(qinst->src);
 448         free(qinst);
 449 }
 450
 451 struct qreg
 452 qir_follow_movs(struct vc4_compile *c, struct qreg reg)
 453 {
 454         while (reg.file == QFILE_TEMP &&
 455                c->defs[reg.index] &&
 456                c->defs[reg.index]->op == QOP_MOV &&
 457                !c->defs[reg.index]->dst.pack) {
 458                 reg = c->defs[reg.index]->src[0];
 459         }
 460
 461         return reg;
 462 }
 463
 464 void
 465 qir_compile_destroy(struct vc4_compile *c)
 466 {
 467         while (!list_empty(&c->instructions)) {
 468                 struct qinst *qinst =
 469                         (struct qinst *)c->instructions.next;
 470                 qir_remove_instruction(c, qinst);
 471         }
 472
 473         ralloc_free(c);
 474 }
 475
 476 const char *
 477 qir_get_stage_name(enum qstage stage)
 478 {
 479         static const char *names[] = {
 480                 [QSTAGE_FRAG] = "FS",
 481                 [QSTAGE_VERT] = "VS",
 482                 [QSTAGE_COORD] = "CS",
 483         };
 484
 485         return names[stage];
 486 }
 487
 488 struct qreg
 489 qir_uniform(struct vc4_compile *c,
 490             enum quniform_contents contents,
 491             uint32_t data)
 492 {
 493         for (int i = 0; i < c->num_uniforms; i++) {
 494                 if (c->uniform_contents[i] == contents &&
 495                     c->uniform_data[i] == data) {
 496                         return (struct qreg) { QFILE_UNIF, i };
 497                 }
 498         }
 499
 500         uint32_t uniform = c->num_uniforms++;
 501         struct qreg u = { QFILE_UNIF, uniform };
 502
 503         if (uniform >= c->uniform_array_size) {
 504                 c->uniform_array_size = MAX2(MAX2(16, uniform + 1),
 505                                              c->uniform_array_size * 2);
 506
 507                 c->uniform_data = reralloc(c, c->uniform_data,
 508                                            uint32_t,
 509                                            c->uniform_array_size);
 510                 c->uniform_contents = reralloc(c, c->uniform_contents,
 511                                                enum quniform_contents,
 512                                                c->uniform_array_size);
 513         }
 514
 515         c->uniform_contents[uniform] = contents;
 516         c->uniform_data[uniform] = data;
 517
 518         return u;
 519 }
 520
 521 void
 522 qir_SF(struct vc4_compile *c, struct qreg src)
 523 {
 524         struct qinst *last_inst = NULL;
 525         if (!list_empty(&c->instructions))
 526                 last_inst = (struct qinst *)c->instructions.prev;
 527
 528         if (!last_inst ||
 529             last_inst->dst.file != src.file ||
 530             last_inst->dst.index != src.index ||
 531             qir_is_multi_instruction(last_inst)) {
 532                 src = qir_MOV(c, src);
 533                 last_inst = (struct qinst *)c->instructions.prev;
 534         }
 535         last_inst->sf = true;
 536 }
 537
 538 #define OPTPASS(func)                                                   \
 539         do {                                                            \
 540                 bool stage_progress = func(c);                          \
 541                 if (stage_progress) {                                   \
 542                         progress = true;                                \
 543                         if (print_opt_debug) {                          \
 544                                 fprintf(stderr,                         \
 545                                         "QIR opt pass %2d: %s progress\n", \
 546                                         pass, #func);                   \
 547                         }                                               \
 548                 }                                                       \
 549         } while (0)
 550
 551 void
 552 qir_optimize(struct vc4_compile *c)
 553 {
 554         bool print_opt_debug = false;
 555         int pass = 1;
 556
 557         while (true) {
 558                 bool progress = false;
 559
 560                 OPTPASS(qir_opt_algebraic);
 561                 OPTPASS(qir_opt_cse);
 562                 OPTPASS(qir_opt_constant_folding);
 563                 OPTPASS(qir_opt_copy_propagation);
 564                 OPTPASS(qir_opt_dead_code);
 565                 OPTPASS(qir_opt_small_immediates);
 566                 OPTPASS(qir_opt_vpm_writes);
 567
 568                 if (!progress)
 569                         break;
 570
 571                 pass++;
 572         }
 573 }