src/glsl/ir_constant_expression.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_constant_expression.cpp
  26  * Evaluate and process constant valued expressions
  27  *
  28  * In GLSL, constant valued expressions are used in several places.  These
  29  * must be processed and evaluated very early in the compilation process.
  30  *
  31  *    * Sizes of arrays
  32  *    * Initializers for uniforms
  33  *    * Initializers for \c const variables
  34  */
  35
  36 #include <math.h>
  37 #include "ir.h"
  38 #include "ir_visitor.h"
  39 #include "glsl_types.h"
  40
  41 /**
  42  * Visitor class for evaluating constant expressions
  43  */
  44 class ir_constant_visitor : public ir_visitor {
  45 public:
  46    ir_constant_visitor()
  47       : value(NULL)
  48    {
  49       /* empty */
  50    }
  51
  52    virtual ~ir_constant_visitor()
  53    {
  54       /* empty */
  55    }
  56
  57    /**
  58     * \name Visit methods
  59     *
  60     * As typical for the visitor pattern, there must be one \c visit method for
  61     * each concrete subclass of \c ir_instruction.  Virtual base classes within
  62     * the hierarchy should not have \c visit methods.
  63     */
  64    /*@{*/
  65    virtual void visit(ir_variable *);
  66    virtual void visit(ir_function_signature *);
  67    virtual void visit(ir_function *);
  68    virtual void visit(ir_expression *);
  69    virtual void visit(ir_texture *);
  70    virtual void visit(ir_swizzle *);
  71    virtual void visit(ir_dereference_variable *);
  72    virtual void visit(ir_dereference_array *);
  73    virtual void visit(ir_dereference_record *);
  74    virtual void visit(ir_assignment *);
  75    virtual void visit(ir_constant *);
  76    virtual void visit(ir_call *);
  77    virtual void visit(ir_return *);
  78    virtual void visit(ir_if *);
  79    virtual void visit(ir_loop *);
  80    virtual void visit(ir_loop_jump *);
  81    /*@}*/
  82
  83    /**
  84     * Value of the constant expression.
  85     *
  86     * \note
  87     * This field will be \c NULL if the expression is not constant valued.
  88     */
  89    /* FINIHSME: This cannot hold values for constant arrays or structures. */
  90    ir_constant *value;
  91 };
  92
  93
  94 ir_constant *
  95 ir_instruction::constant_expression_value()
  96 {
  97    ir_constant_visitor visitor;
  98
  99    this->accept(& visitor);
 100    return visitor.value;
 101 }
 102
 103
 104 void
 105 ir_constant_visitor::visit(ir_variable *ir)
 106 {
 107    (void) ir;
 108    value = NULL;
 109 }
 110
 111
 112 void
 113 ir_constant_visitor::visit(ir_function_signature *ir)
 114 {
 115    (void) ir;
 116    value = NULL;
 117 }
 118
 119
 120 void
 121 ir_constant_visitor::visit(ir_function *ir)
 122 {
 123    (void) ir;
 124    value = NULL;
 125 }
 126
 127 void
 128 ir_constant_visitor::visit(ir_expression *ir)
 129 {
 130    value = NULL;
 131    ir_constant *op[2];
 132    unsigned int operand, c;
 133    ir_constant_data data;
 134
 135    for (operand = 0; operand < ir->get_num_operands(); operand++) {
 136       op[operand] = ir->operands[operand]->constant_expression_value();
 137       if (!op[operand])
 138          return;
 139    }
 140
 141    switch (ir->operation) {
 142    case ir_unop_logic_not:
 143       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 144       for (c = 0; c < ir->operands[0]->type->components(); c++)
 145          data.b[c] = !op[0]->value.b[c];
 146       break;
 147
 148    case ir_unop_f2i:
 149       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 150       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 151          data.i[c] = op[0]->value.f[c];
 152       }
 153       break;
 154    case ir_unop_i2f:
 155       assert(op[0]->type->base_type == GLSL_TYPE_UINT ||
 156              op[0]->type->base_type == GLSL_TYPE_INT);
 157       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 158          if (op[0]->type->base_type == GLSL_TYPE_INT)
 159             data.f[c] = op[0]->value.i[c];
 160          else
 161             data.f[c] = op[0]->value.u[c];
 162       }
 163       break;
 164    case ir_unop_b2f:
 165       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 166       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 167          data.f[c] = op[0]->value.b[c] ? 1.0 : 0.0;
 168       }
 169       break;
 170    case ir_unop_f2b:
 171       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 172       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 173          data.b[c] = bool(op[0]->value.f[c]);
 174       }
 175       break;
 176    case ir_unop_b2i:
 177       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 178       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 179          data.u[c] = op[0]->value.b[c] ? 1 : 0;
 180       }
 181       break;
 182    case ir_unop_i2b:
 183       assert(op[0]->type->is_integer());
 184       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 185          data.b[c] = bool(op[0]->value.u[c]);
 186       }
 187       break;
 188
 189    case ir_unop_neg:
 190       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 191          switch (ir->type->base_type) {
 192          case GLSL_TYPE_UINT:
 193             data.u[c] = -op[0]->value.u[c];
 194             break;
 195          case GLSL_TYPE_INT:
 196             data.i[c] = -op[0]->value.i[c];
 197             break;
 198          case GLSL_TYPE_FLOAT:
 199             data.f[c] = -op[0]->value.f[c];
 200             break;
 201          default:
 202             assert(0);
 203          }
 204       }
 205       break;
 206
 207    case ir_unop_abs:
 208       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 209       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 210          switch (ir->type->base_type) {
 211          case GLSL_TYPE_UINT:
 212             data.u[c] = op[0]->value.u[c];
 213             break;
 214          case GLSL_TYPE_INT:
 215             data.i[c] = op[0]->value.i[c];
 216             if (data.i[c] < 0)
 217                data.i[c] = -data.i[c];
 218             break;
 219          case GLSL_TYPE_FLOAT:
 220             data.f[c] = fabs(op[0]->value.f[c]);
 221             break;
 222          default:
 223             assert(0);
 224          }
 225       }
 226       break;
 227
 228    case ir_unop_rcp:
 229       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 230       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 231          switch (ir->type->base_type) {
 232          case GLSL_TYPE_UINT:
 233             if (op[0]->value.u[c] != 0.0)
 234                data.u[c] = 1 / op[0]->value.u[c];
 235             break;
 236          case GLSL_TYPE_INT:
 237             if (op[0]->value.i[c] != 0.0)
 238                data.i[c] = 1 / op[0]->value.i[c];
 239             break;
 240          case GLSL_TYPE_FLOAT:
 241             if (op[0]->value.f[c] != 0.0)
 242                data.f[c] = 1.0 / op[0]->value.f[c];
 243             break;
 244          default:
 245             assert(0);
 246          }
 247       }
 248       break;
 249
 250    case ir_unop_rsq:
 251       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 252       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 253          data.f[c] = 1.0 / sqrtf(op[0]->value.f[c]);
 254       }
 255       break;
 256
 257    case ir_unop_sqrt:
 258       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 259       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 260          data.f[c] = sqrtf(op[0]->value.f[c]);
 261       }
 262       break;
 263
 264    case ir_unop_exp:
 265       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 266       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 267          data.f[c] = expf(op[0]->value.f[c]);
 268       }
 269       break;
 270
 271    case ir_unop_log:
 272       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 273       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 274          data.f[c] = logf(op[0]->value.f[c]);
 275       }
 276       break;
 277
 278    case ir_unop_dFdx:
 279    case ir_unop_dFdy:
 280       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 281       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 282          data.f[c] = 0.0;
 283       }
 284       break;
 285
 286    case ir_binop_add:
 287       if (ir->operands[0]->type == ir->operands[1]->type) {
 288          for (c = 0; c < ir->operands[0]->type->components(); c++) {
 289             switch (ir->operands[0]->type->base_type) {
 290             case GLSL_TYPE_UINT:
 291                data.u[c] = op[0]->value.u[c] + op[1]->value.u[c];
 292                break;
 293             case GLSL_TYPE_INT:
 294                data.i[c] = op[0]->value.i[c] + op[1]->value.i[c];
 295                break;
 296             case GLSL_TYPE_FLOAT:
 297                data.f[c] = op[0]->value.f[c] + op[1]->value.f[c];
 298                break;
 299             default:
 300                assert(0);
 301             }
 302          }
 303       } else
 304          /* FINISHME: Support operations with non-equal types. */
 305          return;
 306
 307       break;
 308    case ir_binop_sub:
 309       if (ir->operands[0]->type == ir->operands[1]->type) {
 310          for (c = 0; c < ir->operands[0]->type->components(); c++) {
 311             switch (ir->operands[0]->type->base_type) {
 312             case GLSL_TYPE_UINT:
 313                data.u[c] = op[0]->value.u[c] - op[1]->value.u[c];
 314                break;
 315             case GLSL_TYPE_INT:
 316                data.i[c] = op[0]->value.i[c] - op[1]->value.i[c];
 317                break;
 318             case GLSL_TYPE_FLOAT:
 319                data.f[c] = op[0]->value.f[c] - op[1]->value.f[c];
 320                break;
 321             default:
 322                assert(0);
 323             }
 324          }
 325       } else
 326          /* FINISHME: Support operations with non-equal types. */
 327          return;
 328
 329       break;
 330    case ir_binop_mul:
 331       if (ir->operands[0]->type == ir->operands[1]->type &&
 332           !ir->operands[0]->type->is_matrix()) {
 333          for (c = 0; c < ir->operands[0]->type->components(); c++) {
 334             switch (ir->operands[0]->type->base_type) {
 335             case GLSL_TYPE_UINT:
 336                data.u[c] = op[0]->value.u[c] * op[1]->value.u[c];
 337                break;
 338             case GLSL_TYPE_INT:
 339                data.i[c] = op[0]->value.i[c] * op[1]->value.i[c];
 340                break;
 341             case GLSL_TYPE_FLOAT:
 342                data.f[c] = op[0]->value.f[c] * op[1]->value.f[c];
 343                break;
 344             default:
 345                assert(0);
 346             }
 347          }
 348       } else
 349          /* FINISHME: Support operations with non-equal types. */
 350          return;
 351
 352       break;
 353    case ir_binop_div:
 354       if (ir->operands[0]->type == ir->operands[1]->type) {
 355          for (c = 0; c < ir->operands[0]->type->components(); c++) {
 356             switch (ir->operands[0]->type->base_type) {
 357             case GLSL_TYPE_UINT:
 358                data.u[c] = op[0]->value.u[c] / op[1]->value.u[c];
 359                break;
 360             case GLSL_TYPE_INT:
 361                data.i[c] = op[0]->value.i[c] / op[1]->value.i[c];
 362                break;
 363             case GLSL_TYPE_FLOAT:
 364                data.f[c] = op[0]->value.f[c] / op[1]->value.f[c];
 365                break;
 366             default:
 367                assert(0);
 368             }
 369          }
 370       } else
 371          /* FINISHME: Support operations with non-equal types. */
 372          return;
 373
 374       break;
 375    case ir_binop_logic_and:
 376       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 377       for (c = 0; c < ir->operands[0]->type->components(); c++)
 378          data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
 379       break;
 380    case ir_binop_logic_xor:
 381       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 382       for (c = 0; c < ir->operands[0]->type->components(); c++)
 383          data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
 384       break;
 385    case ir_binop_logic_or:
 386       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 387       for (c = 0; c < ir->operands[0]->type->components(); c++)
 388          data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
 389       break;
 390
 391    case ir_binop_less:
 392       switch (ir->operands[0]->type->base_type) {
 393       case GLSL_TYPE_UINT:
 394          data.b[0] = op[0]->value.u[0] < op[1]->value.u[0];
 395          break;
 396       case GLSL_TYPE_INT:
 397          data.b[0] = op[0]->value.i[0] < op[1]->value.i[0];
 398          break;
 399       case GLSL_TYPE_FLOAT:
 400          data.b[0] = op[0]->value.f[0] < op[1]->value.f[0];
 401          break;
 402       default:
 403          assert(0);
 404       }
 405       break;
 406    case ir_binop_greater:
 407       switch (ir->operands[0]->type->base_type) {
 408       case GLSL_TYPE_UINT:
 409          data.b[0] = op[0]->value.u[0] > op[1]->value.u[0];
 410          break;
 411       case GLSL_TYPE_INT:
 412          data.b[0] = op[0]->value.i[0] > op[1]->value.i[0];
 413          break;
 414       case GLSL_TYPE_FLOAT:
 415          data.b[0] = op[0]->value.f[0] > op[1]->value.f[0];
 416          break;
 417       default:
 418          assert(0);
 419       }
 420       break;
 421    case ir_binop_lequal:
 422       switch (ir->operands[0]->type->base_type) {
 423       case GLSL_TYPE_UINT:
 424          data.b[0] = op[0]->value.u[0] <= op[1]->value.u[0];
 425          break;
 426       case GLSL_TYPE_INT:
 427          data.b[0] = op[0]->value.i[0] <= op[1]->value.i[0];
 428          break;
 429       case GLSL_TYPE_FLOAT:
 430          data.b[0] = op[0]->value.f[0] <= op[1]->value.f[0];
 431          break;
 432       default:
 433          assert(0);
 434       }
 435       break;
 436    case ir_binop_gequal:
 437       switch (ir->operands[0]->type->base_type) {
 438       case GLSL_TYPE_UINT:
 439          data.b[0] = op[0]->value.u[0] >= op[1]->value.u[0];
 440          break;
 441       case GLSL_TYPE_INT:
 442          data.b[0] = op[0]->value.i[0] >= op[1]->value.i[0];
 443          break;
 444       case GLSL_TYPE_FLOAT:
 445          data.b[0] = op[0]->value.f[0] >= op[1]->value.f[0];
 446          break;
 447       default:
 448          assert(0);
 449       }
 450       break;
 451
 452    case ir_binop_equal:
 453       data.b[0] = true;
 454       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 455          switch (ir->operands[0]->type->base_type) {
 456          case GLSL_TYPE_UINT:
 457             data.b[0] = data.b[0] && op[0]->value.u[c] == op[1]->value.u[c];
 458             break;
 459          case GLSL_TYPE_INT:
 460             data.b[0] = data.b[0] && op[0]->value.i[c] == op[1]->value.i[c];
 461             break;
 462          case GLSL_TYPE_FLOAT:
 463             data.b[0] = data.b[0] && op[0]->value.f[c] == op[1]->value.f[c];
 464             break;
 465          case GLSL_TYPE_BOOL:
 466             data.b[0] = data.b[0] && op[0]->value.b[c] == op[1]->value.b[c];
 467             break;
 468          default:
 469             assert(0);
 470          }
 471       }
 472       break;
 473    case ir_binop_nequal:
 474       data.b[0] = false;
 475       for (c = 0; c < ir->operands[0]->type->components(); c++) {
 476          switch (ir->operands[0]->type->base_type) {
 477          case GLSL_TYPE_UINT:
 478             data.b[0] = data.b[0] || op[0]->value.u[c] != op[1]->value.u[c];
 479             break;
 480          case GLSL_TYPE_INT:
 481             data.b[0] = data.b[0] || op[0]->value.i[c] != op[1]->value.i[c];
 482             break;
 483          case GLSL_TYPE_FLOAT:
 484             data.b[0] = data.b[0] || op[0]->value.f[c] != op[1]->value.f[c];
 485             break;
 486          case GLSL_TYPE_BOOL:
 487             data.b[0] = data.b[0] || op[0]->value.b[c] != op[1]->value.b[c];
 488             break;
 489          default:
 490             assert(0);
 491          }
 492       }
 493       break;
 494
 495    default:
 496       /* FINISHME: Should handle all expression types. */
 497       return;
 498    }
 499
 500    void *ctx = talloc_parent(ir);
 501    this->value = new(ctx) ir_constant(ir->type, &data);
 502 }
 503
 504
 505 void
 506 ir_constant_visitor::visit(ir_texture *ir)
 507 {
 508    // FINISHME: Do stuff with texture lookups
 509    (void) ir;
 510    value = NULL;
 511 }
 512
 513
 514 void
 515 ir_constant_visitor::visit(ir_swizzle *ir)
 516 {
 517    ir_constant *v = ir->val->constant_expression_value();
 518
 519    this->value = NULL;
 520
 521    if (v != NULL) {
 522       ir_constant_data data;
 523
 524       const unsigned swiz_idx[4] = {
 525          ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w
 526       };
 527
 528       for (unsigned i = 0; i < ir->mask.num_components; i++) {
 529          switch (v->type->base_type) {
 530          case GLSL_TYPE_UINT:
 531          case GLSL_TYPE_INT:   data.u[i] = v->value.u[swiz_idx[i]]; break;
 532          case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
 533          case GLSL_TYPE_BOOL:  data.b[i] = v->value.b[swiz_idx[i]]; break;
 534          default:              assert(!"Should not get here."); break;
 535          }
 536       }
 537
 538       void *ctx = talloc_parent(ir);
 539       this->value = new(ctx) ir_constant(ir->type, &data);
 540    }
 541 }
 542
 543
 544 void
 545 ir_constant_visitor::visit(ir_dereference_variable *ir)
 546 {
 547    value = NULL;
 548
 549    ir_variable *var = ir->variable_referenced();
 550    if (var && var->constant_value)
 551       value = (ir_constant *)var->constant_value->clone(NULL);
 552 }
 553
 554
 555 void
 556 ir_constant_visitor::visit(ir_dereference_array *ir)
 557 {
 558    void *ctx = talloc_parent(ir);
 559    ir_constant *array = ir->array->constant_expression_value();
 560    ir_constant *idx = ir->array_index->constant_expression_value();
 561
 562    this->value = NULL;
 563
 564    if ((array != NULL) && (idx != NULL)) {
 565       if (array->type->is_matrix()) {
 566          /* Array access of a matrix results in a vector.
 567           */
 568          const unsigned column = idx->value.u[0];
 569
 570          const glsl_type *const column_type = array->type->column_type();
 571
 572          /* Offset in the constant matrix to the first element of the column
 573           * to be extracted.
 574           */
 575          const unsigned mat_idx = column * column_type->vector_elements;
 576
 577          ir_constant_data data;
 578
 579          switch (column_type->base_type) {
 580          case GLSL_TYPE_UINT:
 581          case GLSL_TYPE_INT:
 582             for (unsigned i = 0; i < column_type->vector_elements; i++)
 583                data.u[i] = array->value.u[mat_idx + i];
 584
 585             break;
 586
 587          case GLSL_TYPE_FLOAT:
 588             for (unsigned i = 0; i < column_type->vector_elements; i++)
 589                data.f[i] = array->value.f[mat_idx + i];
 590
 591             break;
 592
 593          default:
 594             assert(!"Should not get here.");
 595             break;
 596          }
 597
 598          this->value = new(ctx) ir_constant(column_type, &data);
 599       } else if (array->type->is_vector()) {
 600          const unsigned component = idx->value.u[0];
 601
 602          this->value = new(ctx) ir_constant(array, component);
 603       } else {
 604          /* FINISHME: Handle access of constant arrays. */
 605       }
 606    }
 607 }
 608
 609
 610 void
 611 ir_constant_visitor::visit(ir_dereference_record *ir)
 612 {
 613    ir_constant *v = ir->record->constant_expression_value();
 614
 615    this->value = (v != NULL) ? v->get_record_field(ir->field) : NULL;
 616 }
 617
 618
 619 void
 620 ir_constant_visitor::visit(ir_assignment *ir)
 621 {
 622    (void) ir;
 623    value = NULL;
 624 }
 625
 626
 627 void
 628 ir_constant_visitor::visit(ir_constant *ir)
 629 {
 630    value = ir;
 631 }
 632
 633
 634 void
 635 ir_constant_visitor::visit(ir_call *ir)
 636 {
 637    (void) ir;
 638    value = NULL;
 639 }
 640
 641
 642 void
 643 ir_constant_visitor::visit(ir_return *ir)
 644 {
 645    (void) ir;
 646    value = NULL;
 647 }
 648
 649
 650 void
 651 ir_constant_visitor::visit(ir_if *ir)
 652 {
 653    (void) ir;
 654    value = NULL;
 655 }
 656
 657
 658 void
 659 ir_constant_visitor::visit(ir_loop *ir)
 660 {
 661    (void) ir;
 662    value = NULL;
 663 }
 664
 665
 666 void
 667 ir_constant_visitor::visit(ir_loop_jump *ir)
 668 {
 669    (void) ir;
 670    value = NULL;
 671 }