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 "main/core.h" /* for MAX2, MIN2, CLAMP */
  38 #include "ir.h"
  39 #include "ir_visitor.h"
  40 #include "glsl_types.h"
  41 #include "program/hash_table.h"
  42
  43 /* Using C99 rounding functions for roundToEven() implementation is
  44  * difficult, because round(), rint, and nearbyint() are affected by
  45  * fesetenv(), which the application may have done for its own
  46  * purposes.  Mesa's IROUND macro is close to what we want, but it
  47  * rounds away from 0 on n + 0.5.
  48  */
  49 static int
  50 round_to_even(float val)
  51 {
  52    int rounded = IROUND(val);
  53
  54    if (val - floor(val) == 0.5) {
  55       if (rounded % 2 != 0)
  56          rounded += val > 0 ? -1 : 1;
  57    }
  58
  59    return rounded;
  60 }
  61
  62 static float
  63 dot(ir_constant *op0, ir_constant *op1)
  64 {
  65    assert(op0->type->is_float() && op1->type->is_float());
  66
  67    float result = 0;
  68    for (unsigned c = 0; c < op0->type->components(); c++)
  69       result += op0->value.f[c] * op1->value.f[c];
  70
  71    return result;
  72 }
  73
  74 /* This method is the only one supported by gcc.  Unions in particular
  75  * are iffy, and read-through-converted-pointer is killed by strict
  76  * aliasing.  OTOH, the compiler sees through the memcpy, so the
  77  * resulting asm is reasonable.
  78  */
  79 static float
  80 bitcast_u2f(unsigned int u)
  81 {
  82    assert(sizeof(float) == sizeof(unsigned int));
  83    float f;
  84    memcpy(&f, &u, sizeof(f));
  85    return f;
  86 }
  87
  88 static unsigned int
  89 bitcast_f2u(float f)
  90 {
  91    assert(sizeof(float) == sizeof(unsigned int));
  92    unsigned int u;
  93    memcpy(&u, &f, sizeof(f));
  94    return u;
  95 }
  96
  97 ir_constant *
  98 ir_rvalue::constant_expression_value(struct hash_table *variable_context)
  99 {
 100    assert(this->type->is_error());
 101    return NULL;
 102 }
 103
 104 ir_constant *
 105 ir_expression::constant_expression_value(struct hash_table *variable_context)
 106 {
 107    if (this->type->is_error())
 108       return NULL;
 109
 110    ir_constant *op[Elements(this->operands)] = { NULL, };
 111    ir_constant_data data;
 112
 113    memset(&data, 0, sizeof(data));
 114
 115    for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
 116       op[operand] = this->operands[operand]->constant_expression_value(variable_context);
 117       if (!op[operand])
 118          return NULL;
 119    }
 120
 121    if (op[1] != NULL)
 122       assert(op[0]->type->base_type == op[1]->type->base_type ||
 123              this->operation == ir_binop_lshift ||
 124              this->operation == ir_binop_rshift);
 125
 126    bool op0_scalar = op[0]->type->is_scalar();
 127    bool op1_scalar = op[1] != NULL && op[1]->type->is_scalar();
 128
 129    /* When iterating over a vector or matrix's components, we want to increase
 130     * the loop counter.  However, for scalars, we want to stay at 0.
 131     */
 132    unsigned c0_inc = op0_scalar ? 0 : 1;
 133    unsigned c1_inc = op1_scalar ? 0 : 1;
 134    unsigned components;
 135    if (op1_scalar || !op[1]) {
 136       components = op[0]->type->components();
 137    } else {
 138       components = op[1]->type->components();
 139    }
 140
 141    void *ctx = ralloc_parent(this);
 142
 143    /* Handle array operations here, rather than below. */
 144    if (op[0]->type->is_array()) {
 145       assert(op[1] != NULL && op[1]->type->is_array());
 146       switch (this->operation) {
 147       case ir_binop_all_equal:
 148          return new(ctx) ir_constant(op[0]->has_value(op[1]));
 149       case ir_binop_any_nequal:
 150          return new(ctx) ir_constant(!op[0]->has_value(op[1]));
 151       default:
 152          break;
 153       }
 154       return NULL;
 155    }
 156
 157    switch (this->operation) {
 158    case ir_unop_bit_not:
 159        switch (op[0]->type->base_type) {
 160        case GLSL_TYPE_INT:
 161            for (unsigned c = 0; c < components; c++)
 162                data.i[c] = ~ op[0]->value.i[c];
 163            break;
 164        case GLSL_TYPE_UINT:
 165            for (unsigned c = 0; c < components; c++)
 166                data.u[c] = ~ op[0]->value.u[c];
 167            break;
 168        default:
 169            assert(0);
 170        }
 171        break;
 172
 173    case ir_unop_logic_not:
 174       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 175       for (unsigned c = 0; c < op[0]->type->components(); c++)
 176          data.b[c] = !op[0]->value.b[c];
 177       break;
 178
 179    case ir_unop_f2i:
 180       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 181       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 182          data.i[c] = (int) op[0]->value.f[c];
 183       }
 184       break;
 185    case ir_unop_f2u:
 186       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 187       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 188          data.i[c] = (unsigned) op[0]->value.f[c];
 189       }
 190       break;
 191    case ir_unop_i2f:
 192       assert(op[0]->type->base_type == GLSL_TYPE_INT);
 193       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 194          data.f[c] = (float) op[0]->value.i[c];
 195       }
 196       break;
 197    case ir_unop_u2f:
 198       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
 199       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 200          data.f[c] = (float) op[0]->value.u[c];
 201       }
 202       break;
 203    case ir_unop_b2f:
 204       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 205       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 206          data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
 207       }
 208       break;
 209    case ir_unop_f2b:
 210       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 211       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 212          data.b[c] = op[0]->value.f[c] != 0.0F ? true : false;
 213       }
 214       break;
 215    case ir_unop_b2i:
 216       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 217       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 218          data.u[c] = op[0]->value.b[c] ? 1 : 0;
 219       }
 220       break;
 221    case ir_unop_i2b:
 222       assert(op[0]->type->is_integer());
 223       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 224          data.b[c] = op[0]->value.u[c] ? true : false;
 225       }
 226       break;
 227    case ir_unop_u2i:
 228       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
 229       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 230          data.i[c] = op[0]->value.u[c];
 231       }
 232       break;
 233    case ir_unop_i2u:
 234       assert(op[0]->type->base_type == GLSL_TYPE_INT);
 235       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 236          data.u[c] = op[0]->value.i[c];
 237       }
 238       break;
 239    case ir_unop_bitcast_i2f:
 240       assert(op[0]->type->base_type == GLSL_TYPE_INT);
 241       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 242          data.f[c] = bitcast_u2f(op[0]->value.i[c]);
 243       }
 244       break;
 245    case ir_unop_bitcast_f2i:
 246       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 247       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 248          data.i[c] = bitcast_f2u(op[0]->value.f[c]);
 249       }
 250       break;
 251    case ir_unop_bitcast_u2f:
 252       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
 253       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 254          data.f[c] = bitcast_u2f(op[0]->value.u[c]);
 255       }
 256       break;
 257    case ir_unop_bitcast_f2u:
 258       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 259       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 260          data.u[c] = bitcast_f2u(op[0]->value.f[c]);
 261       }
 262       break;
 263    case ir_unop_any:
 264       assert(op[0]->type->is_boolean());
 265       data.b[0] = false;
 266       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 267          if (op[0]->value.b[c])
 268             data.b[0] = true;
 269       }
 270       break;
 271
 272    case ir_unop_trunc:
 273       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 274       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 275          data.f[c] = truncf(op[0]->value.f[c]);
 276       }
 277       break;
 278
 279    case ir_unop_round_even:
 280       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 281       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 282          data.f[c] = round_to_even(op[0]->value.f[c]);
 283       }
 284       break;
 285
 286    case ir_unop_ceil:
 287       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 288       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 289          data.f[c] = ceilf(op[0]->value.f[c]);
 290       }
 291       break;
 292
 293    case ir_unop_floor:
 294       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 295       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 296          data.f[c] = floorf(op[0]->value.f[c]);
 297       }
 298       break;
 299
 300    case ir_unop_fract:
 301       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 302          switch (this->type->base_type) {
 303          case GLSL_TYPE_UINT:
 304             data.u[c] = 0;
 305             break;
 306          case GLSL_TYPE_INT:
 307             data.i[c] = 0;
 308             break;
 309          case GLSL_TYPE_FLOAT:
 310             data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
 311             break;
 312          default:
 313             assert(0);
 314          }
 315       }
 316       break;
 317
 318    case ir_unop_sin:
 319    case ir_unop_sin_reduced:
 320       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 321       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 322          data.f[c] = sinf(op[0]->value.f[c]);
 323       }
 324       break;
 325
 326    case ir_unop_cos:
 327    case ir_unop_cos_reduced:
 328       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 329       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 330          data.f[c] = cosf(op[0]->value.f[c]);
 331       }
 332       break;
 333
 334    case ir_unop_neg:
 335       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 336          switch (this->type->base_type) {
 337          case GLSL_TYPE_UINT:
 338             data.u[c] = -((int) op[0]->value.u[c]);
 339             break;
 340          case GLSL_TYPE_INT:
 341             data.i[c] = -op[0]->value.i[c];
 342             break;
 343          case GLSL_TYPE_FLOAT:
 344             data.f[c] = -op[0]->value.f[c];
 345             break;
 346          default:
 347             assert(0);
 348          }
 349       }
 350       break;
 351
 352    case ir_unop_abs:
 353       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 354          switch (this->type->base_type) {
 355          case GLSL_TYPE_UINT:
 356             data.u[c] = op[0]->value.u[c];
 357             break;
 358          case GLSL_TYPE_INT:
 359             data.i[c] = op[0]->value.i[c];
 360             if (data.i[c] < 0)
 361                data.i[c] = -data.i[c];
 362             break;
 363          case GLSL_TYPE_FLOAT:
 364             data.f[c] = fabs(op[0]->value.f[c]);
 365             break;
 366          default:
 367             assert(0);
 368          }
 369       }
 370       break;
 371
 372    case ir_unop_sign:
 373       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 374          switch (this->type->base_type) {
 375          case GLSL_TYPE_UINT:
 376             data.u[c] = op[0]->value.i[c] > 0;
 377             break;
 378          case GLSL_TYPE_INT:
 379             data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
 380             break;
 381          case GLSL_TYPE_FLOAT:
 382             data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
 383             break;
 384          default:
 385             assert(0);
 386          }
 387       }
 388       break;
 389
 390    case ir_unop_rcp:
 391       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 392       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 393          switch (this->type->base_type) {
 394          case GLSL_TYPE_UINT:
 395             if (op[0]->value.u[c] != 0.0)
 396                data.u[c] = 1 / op[0]->value.u[c];
 397             break;
 398          case GLSL_TYPE_INT:
 399             if (op[0]->value.i[c] != 0.0)
 400                data.i[c] = 1 / op[0]->value.i[c];
 401             break;
 402          case GLSL_TYPE_FLOAT:
 403             if (op[0]->value.f[c] != 0.0)
 404                data.f[c] = 1.0F / op[0]->value.f[c];
 405             break;
 406          default:
 407             assert(0);
 408          }
 409       }
 410       break;
 411
 412    case ir_unop_rsq:
 413       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 414       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 415          data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
 416       }
 417       break;
 418
 419    case ir_unop_sqrt:
 420       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 421       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 422          data.f[c] = sqrtf(op[0]->value.f[c]);
 423       }
 424       break;
 425
 426    case ir_unop_exp:
 427       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 428       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 429          data.f[c] = expf(op[0]->value.f[c]);
 430       }
 431       break;
 432
 433    case ir_unop_exp2:
 434       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 435       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 436          data.f[c] = exp2f(op[0]->value.f[c]);
 437       }
 438       break;
 439
 440    case ir_unop_log:
 441       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 442       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 443          data.f[c] = logf(op[0]->value.f[c]);
 444       }
 445       break;
 446
 447    case ir_unop_log2:
 448       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 449       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 450          data.f[c] = log2f(op[0]->value.f[c]);
 451       }
 452       break;
 453
 454    case ir_unop_dFdx:
 455    case ir_unop_dFdy:
 456       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 457       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 458          data.f[c] = 0.0;
 459       }
 460       break;
 461
 462    case ir_binop_pow:
 463       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
 464       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 465          data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
 466       }
 467       break;
 468
 469    case ir_binop_dot:
 470       data.f[0] = dot(op[0], op[1]);
 471       break;
 472
 473    case ir_binop_min:
 474       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 475       for (unsigned c = 0, c0 = 0, c1 = 0;
 476            c < components;
 477            c0 += c0_inc, c1 += c1_inc, c++) {
 478
 479          switch (op[0]->type->base_type) {
 480          case GLSL_TYPE_UINT:
 481             data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
 482             break;
 483          case GLSL_TYPE_INT:
 484             data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
 485             break;
 486          case GLSL_TYPE_FLOAT:
 487             data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
 488             break;
 489          default:
 490             assert(0);
 491          }
 492       }
 493
 494       break;
 495    case ir_binop_max:
 496       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 497       for (unsigned c = 0, c0 = 0, c1 = 0;
 498            c < components;
 499            c0 += c0_inc, c1 += c1_inc, c++) {
 500
 501          switch (op[0]->type->base_type) {
 502          case GLSL_TYPE_UINT:
 503             data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
 504             break;
 505          case GLSL_TYPE_INT:
 506             data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
 507             break;
 508          case GLSL_TYPE_FLOAT:
 509             data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
 510             break;
 511          default:
 512             assert(0);
 513          }
 514       }
 515       break;
 516
 517    case ir_binop_add:
 518       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 519       for (unsigned c = 0, c0 = 0, c1 = 0;
 520            c < components;
 521            c0 += c0_inc, c1 += c1_inc, c++) {
 522
 523          switch (op[0]->type->base_type) {
 524          case GLSL_TYPE_UINT:
 525             data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
 526             break;
 527          case GLSL_TYPE_INT:
 528             data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
 529             break;
 530          case GLSL_TYPE_FLOAT:
 531             data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
 532             break;
 533          default:
 534             assert(0);
 535          }
 536       }
 537
 538       break;
 539    case ir_binop_sub:
 540       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 541       for (unsigned c = 0, c0 = 0, c1 = 0;
 542            c < components;
 543            c0 += c0_inc, c1 += c1_inc, c++) {
 544
 545          switch (op[0]->type->base_type) {
 546          case GLSL_TYPE_UINT:
 547             data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
 548             break;
 549          case GLSL_TYPE_INT:
 550             data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
 551             break;
 552          case GLSL_TYPE_FLOAT:
 553             data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
 554             break;
 555          default:
 556             assert(0);
 557          }
 558       }
 559
 560       break;
 561    case ir_binop_mul:
 562       /* Check for equal types, or unequal types involving scalars */
 563       if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
 564           || op0_scalar || op1_scalar) {
 565          for (unsigned c = 0, c0 = 0, c1 = 0;
 566               c < components;
 567               c0 += c0_inc, c1 += c1_inc, c++) {
 568
 569             switch (op[0]->type->base_type) {
 570             case GLSL_TYPE_UINT:
 571                data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
 572                break;
 573             case GLSL_TYPE_INT:
 574                data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
 575                break;
 576             case GLSL_TYPE_FLOAT:
 577                data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
 578                break;
 579             default:
 580                assert(0);
 581             }
 582          }
 583       } else {
 584          assert(op[0]->type->is_matrix() || op[1]->type->is_matrix());
 585
 586          /* Multiply an N-by-M matrix with an M-by-P matrix.  Since either
 587           * matrix can be a GLSL vector, either N or P can be 1.
 588           *
 589           * For vec*mat, the vector is treated as a row vector.  This
 590           * means the vector is a 1-row x M-column matrix.
 591           *
 592           * For mat*vec, the vector is treated as a column vector.  Since
 593           * matrix_columns is 1 for vectors, this just works.
 594           */
 595          const unsigned n = op[0]->type->is_vector()
 596             ? 1 : op[0]->type->vector_elements;
 597          const unsigned m = op[1]->type->vector_elements;
 598          const unsigned p = op[1]->type->matrix_columns;
 599          for (unsigned j = 0; j < p; j++) {
 600             for (unsigned i = 0; i < n; i++) {
 601                for (unsigned k = 0; k < m; k++) {
 602                   data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
 603                }
 604             }
 605          }
 606       }
 607
 608       break;
 609    case ir_binop_div:
 610       /* FINISHME: Emit warning when division-by-zero is detected. */
 611       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 612       for (unsigned c = 0, c0 = 0, c1 = 0;
 613            c < components;
 614            c0 += c0_inc, c1 += c1_inc, c++) {
 615
 616          switch (op[0]->type->base_type) {
 617          case GLSL_TYPE_UINT:
 618             if (op[1]->value.u[c1] == 0) {
 619                data.u[c] = 0;
 620             } else {
 621                data.u[c] = op[0]->value.u[c0] / op[1]->value.u[c1];
 622             }
 623             break;
 624          case GLSL_TYPE_INT:
 625             if (op[1]->value.i[c1] == 0) {
 626                data.i[c] = 0;
 627             } else {
 628                data.i[c] = op[0]->value.i[c0] / op[1]->value.i[c1];
 629             }
 630             break;
 631          case GLSL_TYPE_FLOAT:
 632             data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
 633             break;
 634          default:
 635             assert(0);
 636          }
 637       }
 638
 639       break;
 640    case ir_binop_mod:
 641       /* FINISHME: Emit warning when division-by-zero is detected. */
 642       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
 643       for (unsigned c = 0, c0 = 0, c1 = 0;
 644            c < components;
 645            c0 += c0_inc, c1 += c1_inc, c++) {
 646
 647          switch (op[0]->type->base_type) {
 648          case GLSL_TYPE_UINT:
 649             if (op[1]->value.u[c1] == 0) {
 650                data.u[c] = 0;
 651             } else {
 652                data.u[c] = op[0]->value.u[c0] % op[1]->value.u[c1];
 653             }
 654             break;
 655          case GLSL_TYPE_INT:
 656             if (op[1]->value.i[c1] == 0) {
 657                data.i[c] = 0;
 658             } else {
 659                data.i[c] = op[0]->value.i[c0] % op[1]->value.i[c1];
 660             }
 661             break;
 662          case GLSL_TYPE_FLOAT:
 663             /* We don't use fmod because it rounds toward zero; GLSL specifies
 664              * the use of floor.
 665              */
 666             data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
 667                * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
 668             break;
 669          default:
 670             assert(0);
 671          }
 672       }
 673
 674       break;
 675
 676    case ir_binop_logic_and:
 677       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 678       for (unsigned c = 0; c < op[0]->type->components(); c++)
 679          data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
 680       break;
 681    case ir_binop_logic_xor:
 682       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 683       for (unsigned c = 0; c < op[0]->type->components(); c++)
 684          data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
 685       break;
 686    case ir_binop_logic_or:
 687       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
 688       for (unsigned c = 0; c < op[0]->type->components(); c++)
 689          data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
 690       break;
 691
 692    case ir_binop_less:
 693       assert(op[0]->type == op[1]->type);
 694       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 695          switch (op[0]->type->base_type) {
 696          case GLSL_TYPE_UINT:
 697             data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
 698             break;
 699          case GLSL_TYPE_INT:
 700             data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
 701             break;
 702          case GLSL_TYPE_FLOAT:
 703             data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
 704             break;
 705          default:
 706             assert(0);
 707          }
 708       }
 709       break;
 710    case ir_binop_greater:
 711       assert(op[0]->type == op[1]->type);
 712       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 713          switch (op[0]->type->base_type) {
 714          case GLSL_TYPE_UINT:
 715             data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
 716             break;
 717          case GLSL_TYPE_INT:
 718             data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
 719             break;
 720          case GLSL_TYPE_FLOAT:
 721             data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
 722             break;
 723          default:
 724             assert(0);
 725          }
 726       }
 727       break;
 728    case ir_binop_lequal:
 729       assert(op[0]->type == op[1]->type);
 730       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 731          switch (op[0]->type->base_type) {
 732          case GLSL_TYPE_UINT:
 733             data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
 734             break;
 735          case GLSL_TYPE_INT:
 736             data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
 737             break;
 738          case GLSL_TYPE_FLOAT:
 739             data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
 740             break;
 741          default:
 742             assert(0);
 743          }
 744       }
 745       break;
 746    case ir_binop_gequal:
 747       assert(op[0]->type == op[1]->type);
 748       for (unsigned c = 0; c < op[0]->type->components(); c++) {
 749          switch (op[0]->type->base_type) {
 750          case GLSL_TYPE_UINT:
 751             data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
 752             break;
 753          case GLSL_TYPE_INT:
 754             data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
 755             break;
 756          case GLSL_TYPE_FLOAT:
 757             data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
 758             break;
 759          default:
 760             assert(0);
 761          }
 762       }
 763       break;
 764    case ir_binop_equal:
 765       assert(op[0]->type == op[1]->type);
 766       for (unsigned c = 0; c < components; c++) {
 767          switch (op[0]->type->base_type) {
 768          case GLSL_TYPE_UINT:
 769             data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
 770             break;
 771          case GLSL_TYPE_INT:
 772             data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
 773             break;
 774          case GLSL_TYPE_FLOAT:
 775             data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
 776             break;
 777          case GLSL_TYPE_BOOL:
 778             data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
 779             break;
 780          default:
 781             assert(0);
 782          }
 783       }
 784       break;
 785    case ir_binop_nequal:
 786       assert(op[0]->type == op[1]->type);
 787       for (unsigned c = 0; c < components; c++) {
 788          switch (op[0]->type->base_type) {
 789          case GLSL_TYPE_UINT:
 790             data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
 791             break;
 792          case GLSL_TYPE_INT:
 793             data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
 794             break;
 795          case GLSL_TYPE_FLOAT:
 796             data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
 797             break;
 798          case GLSL_TYPE_BOOL:
 799             data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
 800             break;
 801          default:
 802             assert(0);
 803          }
 804       }
 805       break;
 806    case ir_binop_all_equal:
 807       data.b[0] = op[0]->has_value(op[1]);
 808       break;
 809    case ir_binop_any_nequal:
 810       data.b[0] = !op[0]->has_value(op[1]);
 811       break;
 812
 813    case ir_binop_lshift:
 814       for (unsigned c = 0, c0 = 0, c1 = 0;
 815            c < components;
 816            c0 += c0_inc, c1 += c1_inc, c++) {
 817
 818           if (op[0]->type->base_type == GLSL_TYPE_INT &&
 819               op[1]->type->base_type == GLSL_TYPE_INT) {
 820               data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1];
 821
 822           } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
 823                      op[1]->type->base_type == GLSL_TYPE_UINT) {
 824               data.i[c] = op[0]->value.i[c0] << op[1]->value.u[c1];
 825
 826           } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
 827                      op[1]->type->base_type == GLSL_TYPE_INT) {
 828               data.u[c] = op[0]->value.u[c0] << op[1]->value.i[c1];
 829
 830           } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
 831                      op[1]->type->base_type == GLSL_TYPE_UINT) {
 832               data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1];
 833           }
 834       }
 835       break;
 836
 837    case ir_binop_rshift:
 838        for (unsigned c = 0, c0 = 0, c1 = 0;
 839             c < components;
 840             c0 += c0_inc, c1 += c1_inc, c++) {
 841
 842            if (op[0]->type->base_type == GLSL_TYPE_INT &&
 843                op[1]->type->base_type == GLSL_TYPE_INT) {
 844                data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1];
 845
 846            } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
 847                       op[1]->type->base_type == GLSL_TYPE_UINT) {
 848                data.i[c] = op[0]->value.i[c0] >> op[1]->value.u[c1];
 849
 850            } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
 851                       op[1]->type->base_type == GLSL_TYPE_INT) {
 852                data.u[c] = op[0]->value.u[c0] >> op[1]->value.i[c1];
 853
 854            } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
 855                       op[1]->type->base_type == GLSL_TYPE_UINT) {
 856                data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1];
 857            }
 858        }
 859        break;
 860
 861    case ir_binop_bit_and:
 862       for (unsigned c = 0, c0 = 0, c1 = 0;
 863            c < components;
 864            c0 += c0_inc, c1 += c1_inc, c++) {
 865
 866           switch (op[0]->type->base_type) {
 867           case GLSL_TYPE_INT:
 868               data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1];
 869               break;
 870           case GLSL_TYPE_UINT:
 871               data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
 872               break;
 873           default:
 874               assert(0);
 875           }
 876       }
 877       break;
 878
 879    case ir_binop_bit_or:
 880       for (unsigned c = 0, c0 = 0, c1 = 0;
 881            c < components;
 882            c0 += c0_inc, c1 += c1_inc, c++) {
 883
 884           switch (op[0]->type->base_type) {
 885           case GLSL_TYPE_INT:
 886               data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1];
 887               break;
 888           case GLSL_TYPE_UINT:
 889               data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1];
 890               break;
 891           default:
 892               assert(0);
 893           }
 894       }
 895       break;
 896
 897    case ir_binop_bit_xor:
 898       for (unsigned c = 0, c0 = 0, c1 = 0;
 899            c < components;
 900            c0 += c0_inc, c1 += c1_inc, c++) {
 901
 902           switch (op[0]->type->base_type) {
 903           case GLSL_TYPE_INT:
 904               data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1];
 905               break;
 906           case GLSL_TYPE_UINT:
 907               data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
 908               break;
 909           default:
 910               assert(0);
 911           }
 912       }
 913       break;
 914
 915    case ir_quadop_vector:
 916       for (unsigned c = 0; c < this->type->vector_elements; c++) {
 917          switch (this->type->base_type) {
 918          case GLSL_TYPE_INT:
 919             data.i[c] = op[c]->value.i[0];
 920             break;
 921          case GLSL_TYPE_UINT:
 922             data.u[c] = op[c]->value.u[0];
 923             break;
 924          case GLSL_TYPE_FLOAT:
 925             data.f[c] = op[c]->value.f[0];
 926             break;
 927          default:
 928             assert(0);
 929          }
 930       }
 931       break;
 932
 933    default:
 934       /* FINISHME: Should handle all expression types. */
 935       return NULL;
 936    }
 937
 938    return new(ctx) ir_constant(this->type, &data);
 939 }
 940
 941
 942 ir_constant *
 943 ir_texture::constant_expression_value(struct hash_table *variable_context)
 944 {
 945    /* texture lookups aren't constant expressions */
 946    return NULL;
 947 }
 948
 949
 950 ir_constant *
 951 ir_swizzle::constant_expression_value(struct hash_table *variable_context)
 952 {
 953    ir_constant *v = this->val->constant_expression_value(variable_context);
 954
 955    if (v != NULL) {
 956       ir_constant_data data = { { 0 } };
 957
 958       const unsigned swiz_idx[4] = {
 959          this->mask.x, this->mask.y, this->mask.z, this->mask.w
 960       };
 961
 962       for (unsigned i = 0; i < this->mask.num_components; i++) {
 963          switch (v->type->base_type) {
 964          case GLSL_TYPE_UINT:
 965          case GLSL_TYPE_INT:   data.u[i] = v->value.u[swiz_idx[i]]; break;
 966          case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
 967          case GLSL_TYPE_BOOL:  data.b[i] = v->value.b[swiz_idx[i]]; break;
 968          default:              assert(!"Should not get here."); break;
 969          }
 970       }
 971
 972       void *ctx = ralloc_parent(this);
 973       return new(ctx) ir_constant(this->type, &data);
 974    }
 975    return NULL;
 976 }
 977
 978
 979 void
 980 ir_dereference_variable::constant_referenced(struct hash_table *variable_context,
 981                                              ir_constant *&store, int &offset) const
 982 {
 983    if (variable_context) {
 984       store = (ir_constant *)hash_table_find(variable_context, var);
 985       offset = 0;
 986    } else {
 987       store = NULL;
 988       offset = 0;
 989    }
 990 }
 991
 992 ir_constant *
 993 ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
 994 {
 995    /* This may occur during compile and var->type is glsl_type::error_type */
 996    if (!var)
 997       return NULL;
 998
 999    /* Give priority to the context hashtable, if it exists */
1000    if (variable_context) {
1001       ir_constant *value = (ir_constant *)hash_table_find(variable_context, var);
1002       if(value)
1003          return value;
1004    }
1005
1006    /* The constant_value of a uniform variable is its initializer,
1007     * not the lifetime constant value of the uniform.
1008     */
1009    if (var->mode == ir_var_uniform)
1010       return NULL;
1011
1012    if (!var->constant_value)
1013       return NULL;
1014
1015    return var->constant_value->clone(ralloc_parent(var), NULL);
1016 }
1017
1018
1019 void
1020 ir_dereference_array::constant_referenced(struct hash_table *variable_context,
1021                                           ir_constant *&store, int &offset) const
1022 {
1023    ir_constant *index_c = array_index->constant_expression_value(variable_context);
1024
1025    if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer()) {
1026       store = 0;
1027       offset = 0;
1028       return;
1029    }
1030
1031    int index = index_c->type->base_type == GLSL_TYPE_INT ?
1032       index_c->get_int_component(0) :
1033       index_c->get_uint_component(0);
1034
1035    ir_constant *substore;
1036    int suboffset;
1037    const ir_dereference *deref = array->as_dereference();
1038    if (!deref) {
1039       store = 0;
1040       offset = 0;
1041       return;
1042    }
1043
1044    deref->constant_referenced(variable_context, substore, suboffset);
1045
1046    if (!substore) {
1047       store = 0;
1048       offset = 0;
1049       return;
1050    }
1051
1052    const glsl_type *vt = substore->type;
1053    if (vt->is_array()) {
1054       store = substore->get_array_element(index);
1055       offset = 0;
1056       return;
1057    }
1058    if (vt->is_matrix()) {
1059       store = substore;
1060       offset = index * vt->vector_elements;
1061       return;
1062    }
1063    if (vt->is_vector()) {
1064       store = substore;
1065       offset = suboffset + index;
1066       return;
1067    }
1068
1069    store = 0;
1070    offset = 0;
1071 }
1072
1073 ir_constant *
1074 ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
1075 {
1076    ir_constant *array = this->array->constant_expression_value(variable_context);
1077    ir_constant *idx = this->array_index->constant_expression_value(variable_context);
1078
1079    if ((array != NULL) && (idx != NULL)) {
1080       void *ctx = ralloc_parent(this);
1081       if (array->type->is_matrix()) {
1082          /* Array access of a matrix results in a vector.
1083           */
1084          const unsigned column = idx->value.u[0];
1085
1086          const glsl_type *const column_type = array->type->column_type();
1087
1088          /* Offset in the constant matrix to the first element of the column
1089           * to be extracted.
1090           */
1091          const unsigned mat_idx = column * column_type->vector_elements;
1092
1093          ir_constant_data data = { { 0 } };
1094
1095          switch (column_type->base_type) {
1096          case GLSL_TYPE_UINT:
1097          case GLSL_TYPE_INT:
1098             for (unsigned i = 0; i < column_type->vector_elements; i++)
1099                data.u[i] = array->value.u[mat_idx + i];
1100
1101             break;
1102
1103          case GLSL_TYPE_FLOAT:
1104             for (unsigned i = 0; i < column_type->vector_elements; i++)
1105                data.f[i] = array->value.f[mat_idx + i];
1106
1107             break;
1108
1109          default:
1110             assert(!"Should not get here.");
1111             break;
1112          }
1113
1114          return new(ctx) ir_constant(column_type, &data);
1115       } else if (array->type->is_vector()) {
1116          const unsigned component = idx->value.u[0];
1117
1118          return new(ctx) ir_constant(array, component);
1119       } else {
1120          const unsigned index = idx->value.u[0];
1121          return array->get_array_element(index)->clone(ctx, NULL);
1122       }
1123    }
1124    return NULL;
1125 }
1126
1127
1128 void
1129 ir_dereference_record::constant_referenced(struct hash_table *variable_context,
1130                                            ir_constant *&store, int &offset) const
1131 {
1132    ir_constant *substore;
1133    int suboffset;
1134    const ir_dereference *deref = record->as_dereference();
1135    if (!deref) {
1136       store = 0;
1137       offset = 0;
1138       return;
1139    }
1140
1141    deref->constant_referenced(variable_context, substore, suboffset);
1142
1143    if (!substore) {
1144       store = 0;
1145       offset = 0;
1146       return;
1147    }
1148
1149    store = substore->get_record_field(field);
1150    offset = 0;
1151 }
1152
1153 ir_constant *
1154 ir_dereference_record::constant_expression_value(struct hash_table *variable_context)
1155 {
1156    ir_constant *v = this->record->constant_expression_value();
1157
1158    return (v != NULL) ? v->get_record_field(this->field) : NULL;
1159 }
1160
1161
1162 ir_constant *
1163 ir_assignment::constant_expression_value(struct hash_table *variable_context)
1164 {
1165    /* FINISHME: Handle CEs involving assignment (return RHS) */
1166    return NULL;
1167 }
1168
1169
1170 ir_constant *
1171 ir_constant::constant_expression_value(struct hash_table *variable_context)
1172 {
1173    return this;
1174 }
1175
1176
1177 ir_constant *
1178 ir_call::constant_expression_value(struct hash_table *variable_context)
1179 {
1180    return this->callee->constant_expression_value(&this->actual_parameters, variable_context);
1181 }
1182
1183
1184 bool ir_function_signature::constant_expression_evaluate_expression_list(const struct exec_list &body,
1185                                                                          struct hash_table *variable_context,
1186                                                                          ir_constant **result)
1187 {
1188    foreach_list(n, &body) {
1189       ir_instruction *inst = (ir_instruction *)n;
1190       switch(inst->ir_type) {
1191
1192          /* (declare () type symbol) */
1193       case ir_type_variable: {
1194          ir_variable *var = inst->as_variable();
1195          hash_table_insert(variable_context, ir_constant::zero(this, var->type), var);
1196          break;
1197       }
1198
1199          /* (assign [condition] (write-mask) (ref) (value)) */
1200       case ir_type_assignment: {
1201          ir_assignment *asg = inst->as_assignment();
1202          if (asg->condition) {
1203             ir_constant *cond = asg->condition->constant_expression_value(variable_context);
1204             if (!cond)
1205                return false;
1206             if (!cond->get_bool_component(0))
1207                break;
1208          }
1209
1210          ir_constant *store = NULL;
1211          int offset = 0;
1212          asg->lhs->constant_referenced(variable_context, store, offset);
1213
1214          if (!store)
1215             return false;
1216
1217          ir_constant *value = asg->rhs->constant_expression_value(variable_context);
1218
1219          if (!value)
1220             return false;
1221
1222          store->copy_masked_offset(value, offset, asg->write_mask);
1223          break;
1224       }
1225
1226          /* (return (expression)) */
1227       case ir_type_return:
1228          assert (result);
1229          *result = inst->as_return()->value->constant_expression_value(variable_context);
1230          return *result != NULL;
1231
1232          /* (call name (ref) (params))*/
1233       case ir_type_call: {
1234          ir_call *call = inst->as_call();
1235
1236          /* Just say no to void functions in constant expressions.  We
1237           * don't need them at that point.
1238           */
1239
1240          if (!call->return_deref)
1241             return false;
1242
1243          ir_constant *store = NULL;
1244          int offset = 0;
1245          call->return_deref->constant_referenced(variable_context, store, offset);
1246
1247          if (!store)
1248             return false;
1249
1250          ir_constant *value = call->constant_expression_value(variable_context);
1251
1252          if(!value)
1253             return false;
1254
1255          store->copy_offset(value, offset);
1256          break;
1257       }
1258
1259          /* (if condition (then-instructions) (else-instructions)) */
1260       case ir_type_if: {
1261          ir_if *iif = inst->as_if();
1262
1263          ir_constant *cond = iif->condition->constant_expression_value(variable_context);
1264          if (!cond || !cond->type->is_boolean())
1265             return false;
1266
1267          exec_list &branch = cond->get_bool_component(0) ? iif->then_instructions : iif->else_instructions;
1268
1269          *result = NULL;
1270          if (!constant_expression_evaluate_expression_list(branch, variable_context, result))
1271             return false;
1272
1273          /* If there was a return in the branch chosen, drop out now. */
1274          if (*result)
1275             return true;
1276
1277          break;
1278       }
1279
1280          /* Every other expression type, we drop out. */
1281       default:
1282          return false;
1283       }
1284    }
1285
1286    /* Reaching the end of the block is not an error condition */
1287    if (result)
1288       *result = NULL;
1289
1290    return true;
1291 }
1292
1293 ir_constant *
1294 ir_function_signature::constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context)
1295 {
1296    const glsl_type *type = this->return_type;
1297    if (type == glsl_type::void_type)
1298       return NULL;
1299
1300    /* From the GLSL 1.20 spec, page 23:
1301     * "Function calls to user-defined functions (non-built-in functions)
1302     *  cannot be used to form constant expressions."
1303     */
1304    if (!this->is_builtin)
1305       return NULL;
1306
1307    /*
1308     * Of the builtin functions, only the texture lookups and the noise
1309     * ones must not be used in constant expressions.  They all include
1310     * specific opcodes so they don't need to be special-cased at this
1311     * point.
1312     */
1313
1314    /* Initialize the table of dereferencable names with the function
1315     * parameters.  Verify their const-ness on the way.
1316     *
1317     * We expect the correctness of the number of parameters to have
1318     * been checked earlier.
1319     */
1320    hash_table *deref_hash = hash_table_ctor(8, hash_table_pointer_hash,
1321                                             hash_table_pointer_compare);
1322
1323    /* If "origin" is non-NULL, then the function body is there.  So we
1324     * have to use the variable objects from the object with the body,
1325     * but the parameter instanciation on the current object.
1326     */
1327    const exec_node *parameter_info = origin ? origin->parameters.head : parameters.head;
1328
1329    foreach_list(n, actual_parameters) {
1330       ir_constant *constant = ((ir_rvalue *) n)->constant_expression_value(variable_context);
1331       if (constant == NULL) {
1332          hash_table_dtor(deref_hash);
1333          return NULL;
1334       }
1335
1336
1337       ir_variable *var = (ir_variable *)parameter_info;
1338       hash_table_insert(deref_hash, constant, var);
1339
1340       parameter_info = parameter_info->next;
1341    }
1342
1343    ir_constant *result = NULL;
1344
1345    /* Now run the builtin function until something non-constant
1346     * happens or we get the result.
1347     */
1348    if (constant_expression_evaluate_expression_list(origin ? origin->body : body, deref_hash, &result) && result)
1349       result = result->clone(ralloc_parent(this), NULL);
1350
1351    hash_table_dtor(deref_hash);
1352
1353    return result;
1354 }