src/mesa/drivers/dri/i965/brw_fs_vector_splitting.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file brw_wm_vector_splitting.cpp
  26  *
  27  * If a vector is only ever referenced by its components, then
  28  * split those components out to individual variables so they can be
  29  * handled normally by other optimization passes.
  30  *
  31  * This skips vectors in uniforms and varyings, which need to be
  32  * accessible as vectors for their access by the GL.  Also, vector
  33  * results of non-variable-derefs in assignments aren't handled
  34  * because to do so we would have to store the vector result to a
  35  * temporary in order to unload each channel, and to do so would just
  36  * loop us back to where we started.  For the 965, this is exactly the
  37  * behavior we want for the results of texture lookups, but probably not for
  38  */
  39
  40 extern "C" {
  41 #include "main/core.h"
  42 #include "brw_context.h"
  43 }
  44 #include "glsl/ir.h"
  45 #include "glsl/ir_visitor.h"
  46 #include "glsl/ir_rvalue_visitor.h"
  47 #include "glsl/glsl_types.h"
  48
  49 static bool debug = false;
  50
  51 class variable_entry : public exec_node
  52 {
  53 public:
  54    variable_entry(ir_variable *var)
  55    {
  56       this->var = var;
  57       this->whole_vector_access = 0;
  58       this->mem_ctx = NULL;
  59    }
  60
  61    ir_variable *var; /* The key: the variable's pointer. */
  62
  63    /** Number of times the variable is referenced, including assignments. */
  64    unsigned whole_vector_access;
  65
  66    ir_variable *components[4];
  67
  68    /** ralloc_parent(this->var) -- the shader's ralloc context. */
  69    void *mem_ctx;
  70 };
  71
  72 class ir_vector_reference_visitor : public ir_hierarchical_visitor {
  73 public:
  74    ir_vector_reference_visitor(void)
  75    {
  76       this->mem_ctx = ralloc_context(NULL);
  77       this->variable_list.make_empty();
  78    }
  79
  80    ~ir_vector_reference_visitor(void)
  81    {
  82       ralloc_free(mem_ctx);
  83    }
  84
  85    virtual ir_visitor_status visit(ir_variable *);
  86    virtual ir_visitor_status visit(ir_dereference_variable *);
  87    virtual ir_visitor_status visit_enter(ir_swizzle *);
  88    virtual ir_visitor_status visit_enter(ir_assignment *);
  89    virtual ir_visitor_status visit_enter(ir_function_signature *);
  90
  91    variable_entry *get_variable_entry(ir_variable *var);
  92
  93    /* List of variable_entry */
  94    exec_list variable_list;
  95
  96    void *mem_ctx;
  97 };
  98
  99 variable_entry *
 100 ir_vector_reference_visitor::get_variable_entry(ir_variable *var)
 101 {
 102    assert(var);
 103
 104    if (!var->type->is_vector())
 105       return NULL;
 106
 107    switch (var->data.mode) {
 108    case ir_var_uniform:
 109    case ir_var_shader_in:
 110    case ir_var_shader_out:
 111    case ir_var_system_value:
 112    case ir_var_function_in:
 113    case ir_var_function_out:
 114    case ir_var_function_inout:
 115       /* Can't split varyings or uniforms.  Function in/outs won't get split
 116        * either.
 117        */
 118       return NULL;
 119    case ir_var_auto:
 120    case ir_var_temporary:
 121       break;
 122    }
 123
 124    foreach_in_list(variable_entry, entry, &variable_list) {
 125       if (entry->var == var)
 126          return entry;
 127    }
 128
 129    variable_entry *entry = new(mem_ctx) variable_entry(var);
 130    this->variable_list.push_tail(entry);
 131    return entry;
 132 }
 133
 134
 135 ir_visitor_status
 136 ir_vector_reference_visitor::visit(ir_variable *ir)
 137 {
 138    /* Make sure splitting looks at splitting this variable */
 139    (void)this->get_variable_entry(ir);
 140
 141    return visit_continue;
 142 }
 143
 144 ir_visitor_status
 145 ir_vector_reference_visitor::visit(ir_dereference_variable *ir)
 146 {
 147    ir_variable *const var = ir->var;
 148    variable_entry *entry = this->get_variable_entry(var);
 149
 150    if (entry)
 151       entry->whole_vector_access++;
 152
 153    return visit_continue;
 154 }
 155
 156 ir_visitor_status
 157 ir_vector_reference_visitor::visit_enter(ir_swizzle *ir)
 158 {
 159    /* Don't descend into a vector ir_dereference_variable below. */
 160    if (ir->val->as_dereference_variable() && ir->type->is_scalar())
 161       return visit_continue_with_parent;
 162
 163    return visit_continue;
 164 }
 165
 166 ir_visitor_status
 167 ir_vector_reference_visitor::visit_enter(ir_assignment *ir)
 168 {
 169    if (ir->lhs->as_dereference_variable() &&
 170        ir->rhs->as_dereference_variable() &&
 171        !ir->condition) {
 172       /* We'll split copies of a vector to copies of channels, so don't
 173        * descend to the ir_dereference_variables.
 174        */
 175       return visit_continue_with_parent;
 176    }
 177    if (ir->lhs->as_dereference_variable() &&
 178        is_power_of_two(ir->write_mask) &&
 179        !ir->condition) {
 180       /* If we're writing just a channel, then channel-splitting the LHS is OK.
 181        */
 182       ir->rhs->accept(this);
 183       return visit_continue_with_parent;
 184    }
 185    return visit_continue;
 186 }
 187
 188 ir_visitor_status
 189 ir_vector_reference_visitor::visit_enter(ir_function_signature *ir)
 190 {
 191    /* We don't want to descend into the function parameters and
 192     * split them, so just accept the body here.
 193     */
 194    visit_list_elements(this, &ir->body);
 195    return visit_continue_with_parent;
 196 }
 197
 198 class ir_vector_splitting_visitor : public ir_rvalue_visitor {
 199 public:
 200    ir_vector_splitting_visitor(exec_list *vars)
 201    {
 202       this->variable_list = vars;
 203    }
 204
 205    virtual ir_visitor_status visit_leave(ir_assignment *);
 206
 207    void handle_rvalue(ir_rvalue **rvalue);
 208    variable_entry *get_splitting_entry(ir_variable *var);
 209
 210    exec_list *variable_list;
 211 };
 212
 213 variable_entry *
 214 ir_vector_splitting_visitor::get_splitting_entry(ir_variable *var)
 215 {
 216    assert(var);
 217
 218    if (!var->type->is_vector())
 219       return NULL;
 220
 221    foreach_in_list(variable_entry, entry, variable_list) {
 222       if (entry->var == var) {
 223          return entry;
 224       }
 225    }
 226
 227    return NULL;
 228 }
 229
 230 void
 231 ir_vector_splitting_visitor::handle_rvalue(ir_rvalue **rvalue)
 232 {
 233    if (!*rvalue)
 234       return;
 235
 236    ir_swizzle *swiz = (*rvalue)->as_swizzle();
 237    if (!swiz || !swiz->type->is_scalar())
 238       return;
 239
 240    ir_dereference_variable *deref_var = swiz->val->as_dereference_variable();
 241    if (!deref_var)
 242       return;
 243
 244    variable_entry *entry = get_splitting_entry(deref_var->var);
 245    if (!entry)
 246       return;
 247
 248    ir_variable *var = entry->components[swiz->mask.x];
 249    *rvalue = new(entry->mem_ctx) ir_dereference_variable(var);
 250 }
 251
 252 ir_visitor_status
 253 ir_vector_splitting_visitor::visit_leave(ir_assignment *ir)
 254 {
 255    ir_dereference_variable *lhs_deref = ir->lhs->as_dereference_variable();
 256    ir_dereference_variable *rhs_deref = ir->rhs->as_dereference_variable();
 257    variable_entry *lhs = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
 258    variable_entry *rhs = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
 259
 260    if (lhs_deref && rhs_deref && (lhs || rhs) && !ir->condition) {
 261       unsigned int rhs_chan = 0;
 262
 263       /* Straight assignment of vector variables. */
 264       for (unsigned int i = 0; i < ir->lhs->type->vector_elements; i++) {
 265          ir_dereference *new_lhs;
 266          ir_rvalue *new_rhs;
 267          void *mem_ctx = lhs ? lhs->mem_ctx : rhs->mem_ctx;
 268          unsigned int writemask;
 269
 270          if (!(ir->write_mask & (1 << i)))
 271             continue;
 272
 273          if (lhs) {
 274             new_lhs = new(mem_ctx) ir_dereference_variable(lhs->components[i]);
 275             writemask = 1;
 276          } else {
 277             new_lhs = ir->lhs->clone(mem_ctx, NULL);
 278             writemask = 1 << i;
 279          }
 280
 281          if (rhs) {
 282             new_rhs =
 283                new(mem_ctx) ir_dereference_variable(rhs->components[rhs_chan]);
 284          } else {
 285             new_rhs = new(mem_ctx) ir_swizzle(ir->rhs->clone(mem_ctx, NULL),
 286                                               rhs_chan, 0, 0, 0, 1);
 287          }
 288
 289          ir->insert_before(new(mem_ctx) ir_assignment(new_lhs,
 290                                                       new_rhs,
 291                                                       NULL, writemask));
 292
 293          rhs_chan++;
 294       }
 295       ir->remove();
 296    } else if (lhs) {
 297       void *mem_ctx = lhs->mem_ctx;
 298       int elem = -1;
 299
 300       switch (ir->write_mask) {
 301       case (1 << 0):
 302          elem = 0;
 303          break;
 304       case (1 << 1):
 305          elem = 1;
 306          break;
 307       case (1 << 2):
 308          elem = 2;
 309          break;
 310       case (1 << 3):
 311          elem = 3;
 312          break;
 313       default:
 314          ir->fprint(stderr);
 315          unreachable("not reached: non-channelwise dereference of LHS.");
 316       }
 317
 318       ir->lhs = new(mem_ctx) ir_dereference_variable(lhs->components[elem]);
 319       ir->write_mask = (1 << 0);
 320
 321       handle_rvalue(&ir->rhs);
 322    } else {
 323       handle_rvalue(&ir->rhs);
 324    }
 325
 326    handle_rvalue(&ir->condition);
 327
 328    return visit_continue;
 329 }
 330
 331 bool
 332 brw_do_vector_splitting(exec_list *instructions)
 333 {
 334    ir_vector_reference_visitor refs;
 335
 336    visit_list_elements(&refs, instructions);
 337
 338    /* Trim out variables we can't split. */
 339    foreach_in_list_safe(variable_entry, entry, &refs.variable_list) {
 340       if (debug) {
 341          fprintf(stderr, "vector %s@%p: whole_access %d\n",
 342                  entry->var->name, (void *) entry->var,
 343                  entry->whole_vector_access);
 344       }
 345
 346       if (entry->whole_vector_access) {
 347          entry->remove();
 348       }
 349    }
 350
 351    if (refs.variable_list.is_empty())
 352       return false;
 353
 354    void *mem_ctx = ralloc_context(NULL);
 355
 356    /* Replace the decls of the vectors to be split with their split
 357     * components.
 358     */
 359    foreach_in_list(variable_entry, entry, &refs.variable_list) {
 360       const struct glsl_type *type;
 361       type = glsl_type::get_instance(entry->var->type->base_type, 1, 1);
 362
 363       entry->mem_ctx = ralloc_parent(entry->var);
 364
 365       for (unsigned int i = 0; i < entry->var->type->vector_elements; i++) {
 366          char *const name = ir_variable::temporaries_allocate_names
 367             ? ralloc_asprintf(mem_ctx, "%s_%c",
 368                               entry->var->name,
 369                               "xyzw"[i])
 370             : NULL;
 371
 372          entry->components[i] = new(entry->mem_ctx) ir_variable(type, name,
 373                                                                 ir_var_temporary);
 374
 375          ralloc_free(name);
 376
 377          entry->var->insert_before(entry->components[i]);
 378       }
 379
 380       entry->var->remove();
 381    }
 382
 383    ir_vector_splitting_visitor split(&refs.variable_list);
 384    visit_list_elements(&split, instructions);
 385
 386    ralloc_free(mem_ctx);
 387
 388    return true;
 389 }