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/u_simple_list.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_FADD] = { "fadd", 1, 2 },
  39         [QOP_FSUB] = { "fsub", 1, 2 },
  40         [QOP_FMUL] = { "fmul", 1, 2 },
  41         [QOP_FMIN] = { "fmin", 1, 2 },
  42         [QOP_FMAX] = { "fmax", 1, 2 },
  43         [QOP_FMINABS] = { "fminabs", 1, 2 },
  44         [QOP_FMAXABS] = { "fmaxabs", 1, 2 },
  45
  46         [QOP_SEQ] = { "seq", 1, 2 },
  47         [QOP_SNE] = { "sne", 1, 2 },
  48         [QOP_SGE] = { "sge", 1, 2 },
  49         [QOP_SLT] = { "slt", 1, 2 },
  50         [QOP_CMP] = { "cmp", 1, 3 },
  51
  52         [QOP_FTOI] = { "ftoi", 1, 1 },
  53         [QOP_ITOF] = { "itof", 1, 1 },
  54         [QOP_RCP] = { "rcp", 1, 1 },
  55         [QOP_RSQ] = { "rsq", 1, 1 },
  56         [QOP_EXP2] = { "exp2", 1, 2 },
  57         [QOP_LOG2] = { "log2", 1, 2 },
  58         [QOP_PACK_COLORS] = { "pack_colors", 1, 4 },
  59         [QOP_PACK_SCALED] = { "pack_scaled", 1, 2 },
  60         [QOP_VPM_WRITE] = { "vpm_write", 0, 1, true },
  61         [QOP_VPM_READ] = { "vpm_read", 0, 1, true },
  62         [QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
  63         [QOP_TLB_PASSTHROUGH_Z_WRITE] = { "tlb_passthrough_z", 0, 0, true },
  64         [QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
  65         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 0, 0, true },
  66         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  67
  68         [QOP_FRAG_X] = { "frag_x", 1, 0 },
  69         [QOP_FRAG_Y] = { "frag_y", 1, 0 },
  70         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  71         [QOP_FRAG_RCP_W] = { "frag_rcp_w", 1, 0 },
  72
  73         [QOP_TEX_S] = { "tex_s", 0, 2 },
  74         [QOP_TEX_T] = { "tex_t", 0, 2 },
  75         [QOP_TEX_R] = { "tex_r", 0, 2 },
  76         [QOP_TEX_B] = { "tex_b", 0, 2 },
  77         [QOP_TEX_RESULT] = { "tex_result", 0, 0 },
  78         [QOP_R4_UNPACK_A] = { "r4_unpack_a", 1, 0 },
  79         [QOP_R4_UNPACK_B] = { "r4_unpack_b", 1, 0 },
  80         [QOP_R4_UNPACK_C] = { "r4_unpack_c", 1, 0 },
  81         [QOP_R4_UNPACK_D] = { "r4_unpack_d", 1, 0 },
  82 };
  83
  84 static const char *
  85 qir_get_op_name(enum qop qop)
  86 {
  87         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
  88                 return qir_op_info[qop].name;
  89         else
  90                 return "???";
  91 }
  92
  93 int
  94 qir_get_op_nsrc(enum qop qop)
  95 {
  96         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
  97                 return qir_op_info[qop].nsrc;
  98         else
  99                 abort();
 100 }
 101
 102 bool
 103 qir_has_side_effects(struct qinst *inst)
 104 {
 105         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 106                 if (inst->src[i].file == QFILE_VARY ||
 107                     inst->src[i].file == QFILE_UNIF)
 108                         return true;
 109         }
 110
 111         return qir_op_info[inst->op].has_side_effects;
 112 }
 113
 114 static void
 115 qir_print_reg(struct qreg reg)
 116 {
 117         const char *files[] = {
 118                 [QFILE_TEMP] = "t",
 119                 [QFILE_VARY] = "v",
 120                 [QFILE_UNIF] = "u",
 121         };
 122
 123         if (reg.file == QFILE_NULL)
 124                 fprintf(stderr, "null");
 125         else
 126                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 127 }
 128
 129 void
 130 qir_dump_inst(struct qinst *inst)
 131 {
 132         fprintf(stderr, "%s ", qir_get_op_name(inst->op));
 133
 134         qir_print_reg(inst->dst);
 135         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 136                 fprintf(stderr, ", ");
 137                 qir_print_reg(inst->src[i]);
 138         }
 139 }
 140
 141 void
 142 qir_dump(struct qcompile *c)
 143 {
 144         struct simple_node *node;
 145
 146         foreach(node, &c->instructions) {
 147                 struct qinst *inst = (struct qinst *)node;
 148                 qir_dump_inst(inst);
 149                 fprintf(stderr, "\n");
 150         }
 151 }
 152
 153 struct qreg
 154 qir_get_temp(struct qcompile *c)
 155 {
 156         struct qreg reg;
 157
 158         reg.file = QFILE_TEMP;
 159         reg.index = c->num_temps++;
 160
 161         return reg;
 162 }
 163
 164 struct qinst *
 165 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 166 {
 167         struct qinst *inst = CALLOC_STRUCT(qinst);
 168
 169         inst->op = op;
 170         inst->dst = dst;
 171         inst->src = calloc(2, sizeof(inst->src[0]));
 172         inst->src[0] = src0;
 173         inst->src[1] = src1;
 174
 175         return inst;
 176 }
 177
 178 struct qinst *
 179 qir_inst4(enum qop op, struct qreg dst,
 180           struct qreg a,
 181           struct qreg b,
 182           struct qreg c,
 183           struct qreg d)
 184 {
 185         struct qinst *inst = CALLOC_STRUCT(qinst);
 186
 187         inst->op = op;
 188         inst->dst = dst;
 189         inst->src = calloc(4, sizeof(*inst->src));
 190         inst->src[0] = a;
 191         inst->src[1] = b;
 192         inst->src[2] = c;
 193         inst->src[3] = d;
 194
 195         return inst;
 196 }
 197
 198 void
 199 qir_emit(struct qcompile *c, struct qinst *inst)
 200 {
 201         insert_at_tail(&c->instructions, &inst->link);
 202 }
 203
 204 bool
 205 qir_reg_equals(struct qreg a, struct qreg b)
 206 {
 207         return a.file == b.file && a.index == b.index;
 208 }
 209
 210 struct qcompile *
 211 qir_compile_init(void)
 212 {
 213         struct qcompile *c = CALLOC_STRUCT(qcompile);
 214
 215         make_empty_list(&c->instructions);
 216
 217         return c;
 218 }
 219
 220 void
 221 qir_compile_destroy(struct qcompile *c)
 222 {
 223         free(c);
 224 }
 225
 226 const char *
 227 qir_get_stage_name(enum qstage stage)
 228 {
 229         static const char *names[] = {
 230                 [QSTAGE_FRAG] = "FS",
 231                 [QSTAGE_VERT] = "VS",
 232                 [QSTAGE_COORD] = "CS",
 233         };
 234
 235         return names[stage];
 236 }
 237
 238 #define OPTPASS(func)                                                   \
 239         do {                                                            \
 240                 bool stage_progress = func(c);                          \
 241                 if (stage_progress) {                                   \
 242                         progress = true;                                \
 243                         if (print_opt_debug) {                          \
 244                                 fprintf(stderr,                         \
 245                                         "QIR opt pass %2d: %s progress\n", \
 246                                         pass, #func);                   \
 247                         }                                               \
 248                 }                                                       \
 249         } while (0)
 250
 251 void
 252 qir_optimize(struct qcompile *c)
 253 {
 254         bool print_opt_debug = false;
 255         int pass = 1;
 256
 257         while (true) {
 258                 bool progress = false;
 259
 260                 OPTPASS(qir_opt_algebraic);
 261                 OPTPASS(qir_opt_copy_propagation);
 262                 OPTPASS(qir_opt_dead_code);
 263
 264                 if (!progress)
 265                         break;
 266
 267                 pass++;
 268         }
 269 }