src/glsl/ir_algebraic.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 ir_algebraic.cpp
  26  *
  27  * Takes advantage of association, commutivity, and other algebraic
  28  * properties to simplify expressions.
  29  */
  30
  31 #include "ir.h"
  32 #include "ir_visitor.h"
  33 #include "ir_optimization.h"
  34 #include "glsl_types.h"
  35
  36 /**
  37  * Visitor class for replacing expressions with ir_constant values.
  38  */
  39
  40 class ir_algebraic_visitor : public ir_hierarchical_visitor {
  41 public:
  42    ir_algebraic_visitor()
  43    {
  44       this->progress = false;
  45    }
  46
  47    virtual ~ir_algebraic_visitor()
  48    {
  49    }
  50
  51    virtual ir_visitor_status visit_leave(ir_assignment *);
  52    virtual ir_visitor_status visit_leave(ir_call *);
  53    virtual ir_visitor_status visit_leave(ir_dereference_array *);
  54    virtual ir_visitor_status visit_leave(ir_expression *);
  55    virtual ir_visitor_status visit_leave(ir_if *);
  56    virtual ir_visitor_status visit_leave(ir_return *);
  57    virtual ir_visitor_status visit_leave(ir_swizzle *);
  58    virtual ir_visitor_status visit_leave(ir_texture *);
  59
  60    ir_rvalue *handle_expression(ir_rvalue *in_ir);
  61
  62    bool progress;
  63 };
  64
  65 static bool
  66 is_vec_zero(ir_constant *ir)
  67 {
  68    int c;
  69
  70    if (!ir)
  71       return false;
  72    if (!ir->type->is_scalar() &&
  73        !ir->type->is_vector())
  74       return false;
  75
  76    for (c = 0; c < ir->type->vector_elements; c++) {
  77       switch (ir->type->base_type) {
  78       case GLSL_TYPE_FLOAT:
  79          if (ir->value.f[c] != 0.0)
  80             return false;
  81          break;
  82       case GLSL_TYPE_INT:
  83          if (ir->value.i[c] != 0)
  84             return false;
  85          break;
  86       case GLSL_TYPE_UINT:
  87          if (ir->value.u[c] != 0)
  88             return false;
  89          break;
  90       case GLSL_TYPE_BOOL:
  91          if (ir->value.b[c] != false)
  92             return false;
  93          break;
  94       default:
  95          assert(!"bad base type");
  96          return false;
  97       }
  98    }
  99
 100    return true;
 101 }
 102
 103 static bool
 104 is_vec_one(ir_constant *ir)
 105 {
 106    int c;
 107
 108    if (!ir)
 109       return false;
 110    if (!ir->type->is_scalar() &&
 111        !ir->type->is_vector())
 112       return false;
 113
 114    for (c = 0; c < ir->type->vector_elements; c++) {
 115       switch (ir->type->base_type) {
 116       case GLSL_TYPE_FLOAT:
 117          if (ir->value.f[c] != 1.0)
 118             return false;
 119          break;
 120       case GLSL_TYPE_INT:
 121          if (ir->value.i[c] != 1)
 122             return false;
 123          break;
 124       case GLSL_TYPE_UINT:
 125          if (ir->value.u[c] != 1)
 126             return false;
 127          break;
 128       case GLSL_TYPE_BOOL:
 129          if (ir->value.b[c] != true)
 130             return false;
 131          break;
 132       default:
 133          assert(!"bad base type");
 134          return false;
 135       }
 136    }
 137
 138    return true;
 139 }
 140
 141 ir_rvalue *
 142 ir_algebraic_visitor::handle_expression(ir_rvalue *in_ir)
 143 {
 144    ir_expression *ir = (ir_expression *)in_ir;
 145    ir_constant *op_const[2] = {NULL, NULL};
 146    ir_expression *op_expr[2] = {NULL, NULL};
 147    unsigned int i;
 148
 149    if (!in_ir)
 150       return NULL;
 151
 152    if (in_ir->ir_type != ir_type_expression)
 153       return in_ir;
 154
 155    for (i = 0; i < ir->get_num_operands(); i++) {
 156       if (ir->operands[i]->type->is_matrix())
 157          return in_ir;
 158
 159       op_const[i] = ir->operands[i]->constant_expression_value();
 160       op_expr[i] = ir->operands[i]->as_expression();
 161    }
 162
 163    switch (ir->operation) {
 164    case ir_unop_logic_not:
 165       if (op_expr[0] && op_expr[0]->operation == ir_binop_equal) {
 166          this->progress = true;
 167          return new(ir) ir_expression(ir_binop_nequal,
 168                                       ir->type,
 169                                       op_expr[0]->operands[0],
 170                                       op_expr[0]->operands[1]);
 171       }
 172       if (op_expr[0] && op_expr[0]->operation == ir_binop_nequal) {
 173          this->progress = true;
 174          return new(ir) ir_expression(ir_binop_equal,
 175                                       ir->type,
 176                                       op_expr[0]->operands[0],
 177                                       op_expr[0]->operands[1]);
 178       }
 179       break;
 180
 181    case ir_binop_add:
 182       if (is_vec_zero(op_const[0])) {
 183          this->progress = true;
 184          return ir->operands[1];
 185       }
 186       if (is_vec_zero(op_const[1])) {
 187          this->progress = true;
 188          return ir->operands[0];
 189       }
 190       break;
 191
 192    case ir_binop_sub:
 193       if (is_vec_zero(op_const[0])) {
 194          this->progress = true;
 195          return new(ir) ir_expression(ir_unop_neg,
 196                                       ir->type,
 197                                       ir->operands[1],
 198                                       NULL);
 199       }
 200       if (is_vec_zero(op_const[1])) {
 201          this->progress = true;
 202          return ir->operands[0];
 203       }
 204       break;
 205
 206    case ir_binop_mul:
 207       if (is_vec_one(op_const[0])) {
 208          this->progress = true;
 209          return ir->operands[1];
 210       }
 211       if (is_vec_one(op_const[1])) {
 212          this->progress = true;
 213          return ir->operands[0];
 214       }
 215
 216       if (is_vec_zero(op_const[0]) || is_vec_zero(op_const[1])) {
 217          this->progress = true;
 218          return ir_constant::zero(ir, ir->type);
 219       }
 220       break;
 221
 222    case ir_binop_div:
 223       if (is_vec_one(op_const[0]) && ir->type->base_type == GLSL_TYPE_FLOAT) {
 224          this->progress = true;
 225          return new(ir) ir_expression(ir_unop_rcp,
 226                                       ir->type,
 227                                       ir->operands[1],
 228                                       NULL);
 229       }
 230       if (is_vec_one(op_const[1])) {
 231          this->progress = true;
 232          return ir->operands[0];
 233       }
 234       break;
 235
 236    case ir_unop_rcp:
 237       if (op_expr[0] && op_expr[0]->operation == ir_unop_rcp) {
 238          this->progress = true;
 239          return op_expr[0]->operands[0];
 240       }
 241
 242       /* FINISHME: We should do rcp(rsq(x)) -> sqrt(x) for some
 243        * backends, except that some backends will have done sqrt ->
 244        * rcp(rsq(x)) and we don't want to undo it for them.
 245        */
 246
 247       /* As far as we know, all backends are OK with rsq. */
 248       if (op_expr[0] && op_expr[0]->operation == ir_unop_sqrt) {
 249          this->progress = true;
 250          return new(ir) ir_expression(ir_unop_rsq,
 251                                       ir->type,
 252                                       op_expr[0]->operands[0],
 253                                       NULL);
 254       }
 255
 256       break;
 257
 258    default:
 259       break;
 260    }
 261
 262    return in_ir;
 263 }
 264
 265 ir_visitor_status
 266 ir_algebraic_visitor::visit_leave(ir_expression *ir)
 267 {
 268    unsigned int operand;
 269
 270    for (operand = 0; operand < ir->get_num_operands(); operand++) {
 271       ir->operands[operand] = handle_expression(ir->operands[operand]);
 272    }
 273
 274    return visit_continue;
 275 }
 276
 277 ir_visitor_status
 278 ir_algebraic_visitor::visit_leave(ir_texture *ir)
 279 {
 280    ir->coordinate = handle_expression(ir->coordinate);
 281    ir->projector = handle_expression(ir->projector);
 282    ir->shadow_comparitor = handle_expression(ir->shadow_comparitor);
 283
 284    switch (ir->op) {
 285    case ir_tex:
 286       break;
 287    case ir_txb:
 288       ir->lod_info.bias = handle_expression(ir->lod_info.bias);
 289       break;
 290    case ir_txf:
 291    case ir_txl:
 292       ir->lod_info.lod = handle_expression(ir->lod_info.lod);
 293       break;
 294    case ir_txd:
 295       ir->lod_info.grad.dPdx = handle_expression(ir->lod_info.grad.dPdx);
 296       ir->lod_info.grad.dPdy = handle_expression(ir->lod_info.grad.dPdy);
 297       break;
 298    }
 299
 300    return visit_continue;
 301 }
 302
 303 ir_visitor_status
 304 ir_algebraic_visitor::visit_leave(ir_swizzle *ir)
 305 {
 306    ir->val = handle_expression(ir->val);
 307    return visit_continue;
 308 }
 309
 310 ir_visitor_status
 311 ir_algebraic_visitor::visit_leave(ir_dereference_array *ir)
 312 {
 313    ir->array_index = handle_expression(ir->array_index);
 314    return visit_continue;
 315 }
 316
 317 ir_visitor_status
 318 ir_algebraic_visitor::visit_leave(ir_assignment *ir)
 319 {
 320    ir->rhs = handle_expression(ir->rhs);
 321    ir->condition = handle_expression(ir->condition);
 322    return visit_continue;
 323 }
 324
 325 ir_visitor_status
 326 ir_algebraic_visitor::visit_leave(ir_call *ir)
 327 {
 328    foreach_iter(exec_list_iterator, iter, *ir) {
 329       ir_rvalue *param = (ir_rvalue *)iter.get();
 330       ir_rvalue *new_param = handle_expression(param);
 331
 332       if (new_param != param) {
 333          param->replace_with(new_param);
 334       }
 335    }
 336    return visit_continue;
 337 }
 338
 339 ir_visitor_status
 340 ir_algebraic_visitor::visit_leave(ir_return *ir)
 341 {
 342    ir->value = handle_expression(ir->value);;
 343    return visit_continue;
 344 }
 345
 346 ir_visitor_status
 347 ir_algebraic_visitor::visit_leave(ir_if *ir)
 348 {
 349    ir->condition = handle_expression(ir->condition);
 350    return visit_continue;
 351 }
 352
 353
 354 bool
 355 do_algebraic(exec_list *instructions)
 356 {
 357    ir_algebraic_visitor v;
 358
 359    visit_list_elements(&v, instructions);
 360
 361    return v.progress;
 362 }