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 #include "util/ralloc.h"
  27
  28 #include "vc4_qir.h"
  29 #include "vc4_qpu.h"
  30
  31 struct qir_op_info {
  32         const char *name;
  33         uint8_t ndst, nsrc;
  34         bool has_side_effects;
  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_FMIN] = { "fmin", 1, 2 },
  44         [QOP_FMAX] = { "fmax", 1, 2 },
  45         [QOP_FMINABS] = { "fminabs", 1, 2 },
  46         [QOP_FMAXABS] = { "fmaxabs", 1, 2 },
  47         [QOP_FTOI] = { "ftoi", 1, 1 },
  48         [QOP_ITOF] = { "itof", 1, 1 },
  49         [QOP_ADD] = { "add", 1, 2 },
  50         [QOP_SUB] = { "sub", 1, 2 },
  51         [QOP_SHR] = { "shr", 1, 2 },
  52         [QOP_ASR] = { "asr", 1, 2 },
  53         [QOP_SHL] = { "shl", 1, 2 },
  54         [QOP_MIN] = { "min", 1, 2 },
  55         [QOP_MAX] = { "max", 1, 2 },
  56         [QOP_AND] = { "and", 1, 2 },
  57         [QOP_OR] = { "or", 1, 2 },
  58         [QOP_XOR] = { "xor", 1, 2 },
  59         [QOP_NOT] = { "not", 1, 1 },
  60
  61         [QOP_SF] = { "sf", 0, 1 },
  62         [QOP_SEL_X_0_NS] = { "fsel_x_0_ns", 1, 1 },
  63         [QOP_SEL_X_0_NC] = { "fsel_x_0_nc", 1, 1 },
  64         [QOP_SEL_X_0_ZS] = { "fsel_x_0_zs", 1, 1 },
  65         [QOP_SEL_X_0_ZC] = { "fsel_x_0_zc", 1, 1 },
  66         [QOP_SEL_X_Y_NS] = { "fsel_x_y_ns", 1, 2 },
  67         [QOP_SEL_X_Y_NC] = { "fsel_x_y_nc", 1, 2 },
  68         [QOP_SEL_X_Y_ZS] = { "fsel_x_y_zs", 1, 2 },
  69         [QOP_SEL_X_Y_ZC] = { "fsel_x_y_zc", 1, 2 },
  70
  71         [QOP_RCP] = { "rcp", 1, 1 },
  72         [QOP_RSQ] = { "rsq", 1, 1 },
  73         [QOP_EXP2] = { "exp2", 1, 2 },
  74         [QOP_LOG2] = { "log2", 1, 2 },
  75         [QOP_PACK_COLORS] = { "pack_colors", 1, 4 },
  76         [QOP_PACK_SCALED] = { "pack_scaled", 1, 2 },
  77         [QOP_VPM_WRITE] = { "vpm_write", 0, 1, true },
  78         [QOP_VPM_READ] = { "vpm_read", 0, 1, true },
  79         [QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
  80         [QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
  81         [QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
  82         [QOP_TLB_COLOR_READ] = { "tlb_color_read", 1, 0, true },
  83         [QOP_VARY_ADD_C] = { "vary_add_c", 1, 1 },
  84
  85         [QOP_FRAG_X] = { "frag_x", 1, 0 },
  86         [QOP_FRAG_Y] = { "frag_y", 1, 0 },
  87         [QOP_FRAG_Z] = { "frag_z", 1, 0 },
  88         [QOP_FRAG_RCP_W] = { "frag_rcp_w", 1, 0 },
  89
  90         [QOP_TEX_S] = { "tex_s", 0, 2 },
  91         [QOP_TEX_T] = { "tex_t", 0, 2 },
  92         [QOP_TEX_R] = { "tex_r", 0, 2 },
  93         [QOP_TEX_B] = { "tex_b", 0, 2 },
  94         [QOP_TEX_RESULT] = { "tex_result", 1, 0, true },
  95         [QOP_R4_UNPACK_A] = { "r4_unpack_a", 1, 1 },
  96         [QOP_R4_UNPACK_B] = { "r4_unpack_b", 1, 1 },
  97         [QOP_R4_UNPACK_C] = { "r4_unpack_c", 1, 1 },
  98         [QOP_R4_UNPACK_D] = { "r4_unpack_d", 1, 1 },
  99 };
 100
 101 static const char *
 102 qir_get_op_name(enum qop qop)
 103 {
 104         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 105                 return qir_op_info[qop].name;
 106         else
 107                 return "???";
 108 }
 109
 110 int
 111 qir_get_op_nsrc(enum qop qop)
 112 {
 113         if (qop < ARRAY_SIZE(qir_op_info) && qir_op_info[qop].name)
 114                 return qir_op_info[qop].nsrc;
 115         else
 116                 abort();
 117 }
 118
 119 bool
 120 qir_has_side_effects(struct qinst *inst)
 121 {
 122         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 123                 if (inst->src[i].file == QFILE_VARY)
 124                         return true;
 125         }
 126
 127         return qir_op_info[inst->op].has_side_effects;
 128 }
 129
 130 bool
 131 qir_depends_on_flags(struct qinst *inst)
 132 {
 133         switch (inst->op) {
 134         case QOP_SEL_X_0_NS:
 135         case QOP_SEL_X_0_NC:
 136         case QOP_SEL_X_0_ZS:
 137         case QOP_SEL_X_0_ZC:
 138         case QOP_SEL_X_Y_NS:
 139         case QOP_SEL_X_Y_NC:
 140         case QOP_SEL_X_Y_ZS:
 141         case QOP_SEL_X_Y_ZC:
 142                 return true;
 143         default:
 144                 return false;
 145         }
 146 }
 147
 148 bool
 149 qir_writes_r4(struct qinst *inst)
 150 {
 151         switch (inst->op) {
 152         case QOP_TEX_RESULT:
 153         case QOP_TLB_COLOR_READ:
 154         case QOP_RCP:
 155         case QOP_RSQ:
 156         case QOP_EXP2:
 157         case QOP_LOG2:
 158                 return true;
 159         default:
 160                 return false;
 161         }
 162 }
 163
 164 bool
 165 qir_reads_r4(struct qinst *inst)
 166 {
 167         switch (inst->op) {
 168         case QOP_R4_UNPACK_A:
 169         case QOP_R4_UNPACK_B:
 170         case QOP_R4_UNPACK_C:
 171         case QOP_R4_UNPACK_D:
 172                 return true;
 173         default:
 174                 return false;
 175         }
 176 }
 177
 178 static void
 179 qir_print_reg(struct qreg reg)
 180 {
 181         const char *files[] = {
 182                 [QFILE_TEMP] = "t",
 183                 [QFILE_VARY] = "v",
 184                 [QFILE_UNIF] = "u",
 185         };
 186
 187         if (reg.file == QFILE_NULL)
 188                 fprintf(stderr, "null");
 189         else
 190                 fprintf(stderr, "%s%d", files[reg.file], reg.index);
 191 }
 192
 193 void
 194 qir_dump_inst(struct qinst *inst)
 195 {
 196         fprintf(stderr, "%s ", qir_get_op_name(inst->op));
 197
 198         qir_print_reg(inst->dst);
 199         for (int i = 0; i < qir_get_op_nsrc(inst->op); i++) {
 200                 fprintf(stderr, ", ");
 201                 qir_print_reg(inst->src[i]);
 202         }
 203 }
 204
 205 void
 206 qir_dump(struct vc4_compile *c)
 207 {
 208         struct simple_node *node;
 209
 210         foreach(node, &c->instructions) {
 211                 struct qinst *inst = (struct qinst *)node;
 212                 qir_dump_inst(inst);
 213                 fprintf(stderr, "\n");
 214         }
 215 }
 216
 217 struct qreg
 218 qir_get_temp(struct vc4_compile *c)
 219 {
 220         struct qreg reg;
 221
 222         reg.file = QFILE_TEMP;
 223         reg.index = c->num_temps++;
 224
 225         return reg;
 226 }
 227
 228 struct qinst *
 229 qir_inst(enum qop op, struct qreg dst, struct qreg src0, struct qreg src1)
 230 {
 231         struct qinst *inst = CALLOC_STRUCT(qinst);
 232
 233         inst->op = op;
 234         inst->dst = dst;
 235         inst->src = calloc(2, sizeof(inst->src[0]));
 236         inst->src[0] = src0;
 237         inst->src[1] = src1;
 238
 239         return inst;
 240 }
 241
 242 struct qinst *
 243 qir_inst4(enum qop op, struct qreg dst,
 244           struct qreg a,
 245           struct qreg b,
 246           struct qreg c,
 247           struct qreg d)
 248 {
 249         struct qinst *inst = CALLOC_STRUCT(qinst);
 250
 251         inst->op = op;
 252         inst->dst = dst;
 253         inst->src = calloc(4, sizeof(*inst->src));
 254         inst->src[0] = a;
 255         inst->src[1] = b;
 256         inst->src[2] = c;
 257         inst->src[3] = d;
 258
 259         return inst;
 260 }
 261
 262 void
 263 qir_emit(struct vc4_compile *c, struct qinst *inst)
 264 {
 265         insert_at_tail(&c->instructions, &inst->link);
 266 }
 267
 268 bool
 269 qir_reg_equals(struct qreg a, struct qreg b)
 270 {
 271         return a.file == b.file && a.index == b.index;
 272 }
 273
 274 struct vc4_compile *
 275 qir_compile_init(void)
 276 {
 277         struct vc4_compile *c = rzalloc(NULL, struct vc4_compile);
 278
 279         make_empty_list(&c->instructions);
 280
 281         c->output_position_index = -1;
 282         c->output_color_index = -1;
 283
 284         return c;
 285 }
 286
 287 void
 288 qir_remove_instruction(struct qinst *qinst)
 289 {
 290         remove_from_list(&qinst->link);
 291         free(qinst->src);
 292         free(qinst);
 293 }
 294
 295 void
 296 qir_compile_destroy(struct vc4_compile *c)
 297 {
 298         while (!is_empty_list(&c->instructions)) {
 299                 struct qinst *qinst =
 300                         (struct qinst *)first_elem(&c->instructions);
 301                 qir_remove_instruction(qinst);
 302         }
 303
 304         ralloc_free(c);
 305 }
 306
 307 const char *
 308 qir_get_stage_name(enum qstage stage)
 309 {
 310         static const char *names[] = {
 311                 [QSTAGE_FRAG] = "FS",
 312                 [QSTAGE_VERT] = "VS",
 313                 [QSTAGE_COORD] = "CS",
 314         };
 315
 316         return names[stage];
 317 }
 318
 319 #define OPTPASS(func)                                                   \
 320         do {                                                            \
 321                 bool stage_progress = func(c);                          \
 322                 if (stage_progress) {                                   \
 323                         progress = true;                                \
 324                         if (print_opt_debug) {                          \
 325                                 fprintf(stderr,                         \
 326                                         "QIR opt pass %2d: %s progress\n", \
 327                                         pass, #func);                   \
 328                         }                                               \
 329                 }                                                       \
 330         } while (0)
 331
 332 void
 333 qir_optimize(struct vc4_compile *c)
 334 {
 335         bool print_opt_debug = false;
 336         int pass = 1;
 337
 338         while (true) {
 339                 bool progress = false;
 340
 341                 OPTPASS(qir_opt_algebraic);
 342                 OPTPASS(qir_opt_cse);
 343                 OPTPASS(qir_opt_copy_propagation);
 344                 OPTPASS(qir_opt_dead_code);
 345
 346                 if (!progress)
 347                         break;
 348
 349                 pass++;
 350         }
 351 }