src/gallium/drivers/freedreno/ir3/ir3_shader.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include "pipe/p_state.h"
  30 #include "util/u_string.h"
  31 #include "util/u_memory.h"
  32 #include "util/u_inlines.h"
  33 #include "util/u_format.h"
  34 #include "tgsi/tgsi_dump.h"
  35 #include "tgsi/tgsi_parse.h"
  36
  37 #include "freedreno_context.h"
  38 #include "freedreno_lowering.h"
  39 #include "freedreno_util.h"
  40
  41 #include "ir3_shader.h"
  42 #include "ir3_compiler.h"
  43
  44
  45 static void
  46 delete_variant(struct ir3_shader_variant *v)
  47 {
  48         if (v->ir)
  49                 ir3_destroy(v->ir);
  50         fd_bo_del(v->bo);
  51         free(v);
  52 }
  53
  54 static void
  55 assemble_variant(struct ir3_shader_variant *v)
  56 {
  57         struct fd_context *ctx = fd_context(v->shader->pctx);
  58         uint32_t sz, *bin;
  59
  60         bin = ir3_assemble(v->ir, &v->info);
  61         sz = v->info.sizedwords * 4;
  62
  63         v->bo = fd_bo_new(ctx->dev, sz,
  64                         DRM_FREEDRENO_GEM_CACHE_WCOMBINE |
  65                         DRM_FREEDRENO_GEM_TYPE_KMEM);
  66
  67         memcpy(fd_bo_map(v->bo), bin, sz);
  68
  69         free(bin);
  70
  71         v->instrlen = v->info.sizedwords / 8;
  72
  73         /* NOTE: if relative addressing is used, we set constlen in
  74          * the compiler (to worst-case value) since we don't know in
  75          * the assembler what the max addr reg value can be:
  76          */
  77         v->constlen = MAX2(v->constlen, v->info.max_const + 1);
  78
  79         /* no need to keep the ir around beyond this point: */
  80         ir3_destroy(v->ir);
  81         v->ir = NULL;
  82 }
  83
  84 /* for vertex shader, the inputs are loaded into registers before the shader
  85  * is executed, so max_regs from the shader instructions might not properly
  86  * reflect the # of registers actually used:
  87  */
  88 static void
  89 fixup_vp_regfootprint(struct ir3_shader_variant *v)
  90 {
  91         unsigned i;
  92         for (i = 0; i < v->inputs_count; i++) {
  93                 if (v->inputs[i].compmask) {
  94                         uint32_t regid = (v->inputs[i].regid + 3) >> 2;
  95                         v->info.max_reg = MAX2(v->info.max_reg, regid);
  96                 }
  97         }
  98         for (i = 0; i < v->outputs_count; i++) {
  99                 uint32_t regid = (v->outputs[i].regid + 3) >> 2;
 100                 v->info.max_reg = MAX2(v->info.max_reg, regid);
 101         }
 102 }
 103
 104 /* reset before attempting to compile again.. */
 105 static void reset_variant(struct ir3_shader_variant *v, const char *msg)
 106 {
 107         debug_error(msg);
 108         v->inputs_count = 0;
 109         v->outputs_count = 0;
 110         v->total_in = 0;
 111         v->has_samp = false;
 112         v->immediates_count = 0;
 113 }
 114
 115 static struct ir3_shader_variant *
 116 create_variant(struct ir3_shader *shader, struct ir3_shader_key key)
 117 {
 118         struct ir3_shader_variant *v = CALLOC_STRUCT(ir3_shader_variant);
 119         const struct tgsi_token *tokens = shader->tokens;
 120         int ret;
 121
 122         if (!v)
 123                 return NULL;
 124
 125         v->shader = shader;
 126         v->key = key;
 127         v->type = shader->type;
 128
 129         if (fd_mesa_debug & FD_DBG_DISASM) {
 130                 DBG("dump tgsi: type=%d, k={bp=%u,cts=%u,hp=%u}", shader->type,
 131                         key.binning_pass, key.color_two_side, key.half_precision);
 132                 tgsi_dump(tokens, 0);
 133         }
 134
 135         if (!(fd_mesa_debug & FD_DBG_NOOPT)) {
 136                 ret = ir3_compile_shader(v, tokens, key, true);
 137                 if (ret) {
 138                         reset_variant(v, "new compiler failed, trying without copy propagation!");
 139                         ret = ir3_compile_shader(v, tokens, key, false);
 140                         if (ret)
 141                                 reset_variant(v, "new compiler failed, trying fallback!");
 142                 }
 143         } else {
 144                 ret = -1;  /* force fallback to old compiler */
 145         }
 146
 147         if (ret)
 148                 ret = ir3_compile_shader_old(v, tokens, key);
 149
 150         if (ret) {
 151                 debug_error("compile failed!");
 152                 goto fail;
 153         }
 154
 155         assemble_variant(v);
 156         if (!v->bo) {
 157                 debug_error("assemble failed!");
 158                 goto fail;
 159         }
 160
 161         if (shader->type == SHADER_VERTEX)
 162                 fixup_vp_regfootprint(v);
 163
 164         if (fd_mesa_debug & FD_DBG_DISASM) {
 165                 DBG("disassemble: type=%d, k={bp=%u,cts=%u,hp=%u}", v->type,
 166                         key.binning_pass, key.color_two_side, key.half_precision);
 167                 disasm_a3xx(fd_bo_map(v->bo), v->info.sizedwords, 0, v->type);
 168         }
 169
 170         return v;
 171
 172 fail:
 173         delete_variant(v);
 174         return NULL;
 175 }
 176
 177 struct ir3_shader_variant *
 178 ir3_shader_variant(struct ir3_shader *shader, struct ir3_shader_key key)
 179 {
 180         struct ir3_shader_variant *v;
 181
 182         /* some shader key values only apply to vertex or frag shader,
 183          * so normalize the key to avoid constructing multiple identical
 184          * variants:
 185          */
 186         if (shader->type == SHADER_FRAGMENT) {
 187                 key.binning_pass = false;
 188                 key.vsaturate_s = 0;
 189                 key.vsaturate_t = 0;
 190                 key.vsaturate_r = 0;
 191         }
 192         if (shader->type == SHADER_VERTEX) {
 193                 key.color_two_side = false;
 194                 key.half_precision = false;
 195                 key.alpha = false;
 196                 key.fsaturate_s = 0;
 197                 key.fsaturate_t = 0;
 198                 key.fsaturate_r = 0;
 199         }
 200
 201         for (v = shader->variants; v; v = v->next)
 202                 if (!memcmp(&key, &v->key, sizeof(key)))
 203                         return v;
 204
 205         /* compile new variant if it doesn't exist already: */
 206         v = create_variant(shader, key);
 207         v->next = shader->variants;
 208         shader->variants = v;
 209
 210         return v;
 211 }
 212
 213
 214 void
 215 ir3_shader_destroy(struct ir3_shader *shader)
 216 {
 217         struct ir3_shader_variant *v, *t;
 218         for (v = shader->variants; v; ) {
 219                 t = v;
 220                 v = v->next;
 221                 delete_variant(t);
 222         }
 223         free((void *)shader->tokens);
 224         free(shader);
 225 }
 226
 227 struct ir3_shader *
 228 ir3_shader_create(struct pipe_context *pctx, const struct tgsi_token *tokens,
 229                 enum shader_t type)
 230 {
 231         struct ir3_shader *shader = CALLOC_STRUCT(ir3_shader);
 232         shader->pctx = pctx;
 233         shader->type = type;
 234         shader->tokens = tgsi_dup_tokens(tokens);
 235         return shader;
 236 }