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