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]) ||
 217           is_vec_zero(op_const[1])) {
 218          ir_constant_data zero_data;
 219          memset(&zero_data, 0, sizeof(zero_data));
 220
 221          this->progress = true;
 222          return new(ir) ir_constant(ir->type, &zero_data);
 223       }
 224       break;
 225
 226    case ir_binop_div:
 227       if (is_vec_one(op_const[0]) && ir->type->base_type == GLSL_TYPE_FLOAT) {
 228          this->progress = true;
 229          return new(ir) ir_expression(ir_unop_rcp,
 230                                       ir->type,
 231                                       ir->operands[1],
 232                                       NULL);
 233       }
 234       if (is_vec_one(op_const[1])) {
 235          this->progress = true;
 236          return ir->operands[0];
 237       }
 238       break;
 239
 240    case ir_unop_rcp:
 241       if (op_expr[0] && op_expr[0]->operation == ir_unop_rcp) {
 242          this->progress = true;
 243          return op_expr[0]->operands[0];
 244       }
 245
 246       /* FINISHME: We should do rcp(rsq(x)) -> sqrt(x) for some
 247        * backends, except that some backends will have done sqrt ->
 248        * rcp(rsq(x)) and we don't want to undo it for them.
 249        */
 250
 251       /* As far as we know, all backends are OK with rsq. */
 252       if (op_expr[0] && op_expr[0]->operation == ir_unop_sqrt) {
 253          this->progress = true;
 254          return new(ir) ir_expression(ir_unop_rsq,
 255                                       ir->type,
 256                                       op_expr[0]->operands[0],
 257                                       NULL);
 258       }
 259
 260       break;
 261
 262    default:
 263       break;
 264    }
 265
 266    return in_ir;
 267 }
 268
 269 ir_visitor_status
 270 ir_algebraic_visitor::visit_leave(ir_expression *ir)
 271 {
 272    unsigned int operand;
 273
 274    for (operand = 0; operand < ir->get_num_operands(); operand++) {
 275       ir->operands[operand] = handle_expression(ir->operands[operand]);
 276    }
 277
 278    return visit_continue;
 279 }
 280
 281 ir_visitor_status
 282 ir_algebraic_visitor::visit_leave(ir_texture *ir)
 283 {
 284    ir->coordinate = handle_expression(ir->coordinate);
 285    ir->projector = handle_expression(ir->projector);
 286    ir->shadow_comparitor = handle_expression(ir->shadow_comparitor);
 287
 288    switch (ir->op) {
 289    case ir_tex:
 290       break;
 291    case ir_txb:
 292       ir->lod_info.bias = handle_expression(ir->lod_info.bias);
 293       break;
 294    case ir_txf:
 295    case ir_txl:
 296       ir->lod_info.lod = handle_expression(ir->lod_info.lod);
 297       break;
 298    case ir_txd:
 299       ir->lod_info.grad.dPdx = handle_expression(ir->lod_info.grad.dPdx);
 300       ir->lod_info.grad.dPdy = handle_expression(ir->lod_info.grad.dPdy);
 301       break;
 302    }
 303
 304    return visit_continue;
 305 }
 306
 307 ir_visitor_status
 308 ir_algebraic_visitor::visit_leave(ir_swizzle *ir)
 309 {
 310    ir->val = handle_expression(ir->val);
 311    return visit_continue;
 312 }
 313
 314 ir_visitor_status
 315 ir_algebraic_visitor::visit_leave(ir_dereference_array *ir)
 316 {
 317    ir->array_index = handle_expression(ir->array_index);
 318    return visit_continue;
 319 }
 320
 321 ir_visitor_status
 322 ir_algebraic_visitor::visit_leave(ir_assignment *ir)
 323 {
 324    ir->rhs = handle_expression(ir->rhs);
 325    ir->condition = handle_expression(ir->condition);
 326    return visit_continue;
 327 }
 328
 329 ir_visitor_status
 330 ir_algebraic_visitor::visit_leave(ir_call *ir)
 331 {
 332    foreach_iter(exec_list_iterator, iter, *ir) {
 333       ir_rvalue *param = (ir_rvalue *)iter.get();
 334       ir_rvalue *new_param = handle_expression(param);
 335
 336       if (new_param != param) {
 337          param->replace_with(new_param);
 338       }
 339    }
 340    return visit_continue;
 341 }
 342
 343 ir_visitor_status
 344 ir_algebraic_visitor::visit_leave(ir_return *ir)
 345 {
 346    ir->value = handle_expression(ir->value);;
 347    return visit_continue;
 348 }
 349
 350 ir_visitor_status
 351 ir_algebraic_visitor::visit_leave(ir_if *ir)
 352 {
 353    ir->condition = handle_expression(ir->condition);
 354    return visit_continue;
 355 }
 356
 357
 358 bool
 359 do_algebraic(exec_list *instructions)
 360 {
 361    ir_algebraic_visitor v;
 362
 363    visit_list_elements(&v, instructions);
 364
 365    return v.progress;
 366 }