src/compiler/glsl/ir.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 #include <string.h>
  24 #include "main/core.h" /* for MAX2 */
  25 #include "ir.h"
  26 #include "compiler/glsl_types.h"
  27 #include "glsl_parser_extras.h"
  28
  29
  30 ir_rvalue::ir_rvalue(enum ir_node_type t)
  31    : ir_instruction(t)
  32 {
  33    this->type = glsl_type::error_type;
  34 }
  35
  36 bool ir_rvalue::is_zero() const
  37 {
  38    return false;
  39 }
  40
  41 bool ir_rvalue::is_one() const
  42 {
  43    return false;
  44 }
  45
  46 bool ir_rvalue::is_negative_one() const
  47 {
  48    return false;
  49 }
  50
  51 /**
  52  * Modify the swizzle make to move one component to another
  53  *
  54  * \param m    IR swizzle to be modified
  55  * \param from Component in the RHS that is to be swizzled
  56  * \param to   Desired swizzle location of \c from
  57  */
  58 static void
  59 update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to)
  60 {
  61    switch (to) {
  62    case 0: m.x = from; break;
  63    case 1: m.y = from; break;
  64    case 2: m.z = from; break;
  65    case 3: m.w = from; break;
  66    default: assert(!"Should not get here.");
  67    }
  68 }
  69
  70 void
  71 ir_assignment::set_lhs(ir_rvalue *lhs)
  72 {
  73    void *mem_ctx = this;
  74    bool swizzled = false;
  75
  76    while (lhs != NULL) {
  77       ir_swizzle *swiz = lhs->as_swizzle();
  78
  79       if (swiz == NULL)
  80          break;
  81
  82       unsigned write_mask = 0;
  83       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
  84
  85       for (unsigned i = 0; i < swiz->mask.num_components; i++) {
  86          unsigned c = 0;
  87
  88          switch (i) {
  89          case 0: c = swiz->mask.x; break;
  90          case 1: c = swiz->mask.y; break;
  91          case 2: c = swiz->mask.z; break;
  92          case 3: c = swiz->mask.w; break;
  93          default: assert(!"Should not get here.");
  94          }
  95
  96          write_mask |= (((this->write_mask >> i) & 1) << c);
  97          update_rhs_swizzle(rhs_swiz, i, c);
  98          rhs_swiz.num_components = swiz->val->type->vector_elements;
  99       }
 100
 101       this->write_mask = write_mask;
 102       lhs = swiz->val;
 103
 104       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
 105       swizzled = true;
 106    }
 107
 108    if (swizzled) {
 109       /* Now, RHS channels line up with the LHS writemask.  Collapse it
 110        * to just the channels that will be written.
 111        */
 112       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
 113       int rhs_chan = 0;
 114       for (int i = 0; i < 4; i++) {
 115          if (write_mask & (1 << i))
 116             update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
 117       }
 118       rhs_swiz.num_components = rhs_chan;
 119       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
 120    }
 121
 122    assert((lhs == NULL) || lhs->as_dereference());
 123
 124    this->lhs = (ir_dereference *) lhs;
 125 }
 126
 127 ir_variable *
 128 ir_assignment::whole_variable_written()
 129 {
 130    ir_variable *v = this->lhs->whole_variable_referenced();
 131
 132    if (v == NULL)
 133       return NULL;
 134
 135    if (v->type->is_scalar())
 136       return v;
 137
 138    if (v->type->is_vector()) {
 139       const unsigned mask = (1U << v->type->vector_elements) - 1;
 140
 141       if (mask != this->write_mask)
 142          return NULL;
 143    }
 144
 145    /* Either all the vector components are assigned or the variable is some
 146     * composite type (and the whole thing is assigned.
 147     */
 148    return v;
 149 }
 150
 151 ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs,
 152                              ir_rvalue *condition, unsigned write_mask)
 153    : ir_instruction(ir_type_assignment)
 154 {
 155    this->condition = condition;
 156    this->rhs = rhs;
 157    this->lhs = lhs;
 158    this->write_mask = write_mask;
 159
 160    if (lhs->type->is_scalar() || lhs->type->is_vector()) {
 161       int lhs_components = 0;
 162       for (int i = 0; i < 4; i++) {
 163          if (write_mask & (1 << i))
 164             lhs_components++;
 165       }
 166
 167       assert(lhs_components == this->rhs->type->vector_elements);
 168    }
 169 }
 170
 171 ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
 172                              ir_rvalue *condition)
 173    : ir_instruction(ir_type_assignment)
 174 {
 175    this->condition = condition;
 176    this->rhs = rhs;
 177
 178    /* If the RHS is a vector type, assume that all components of the vector
 179     * type are being written to the LHS.  The write mask comes from the RHS
 180     * because we can have a case where the LHS is a vec4 and the RHS is a
 181     * vec3.  In that case, the assignment is:
 182     *
 183     *     (assign (...) (xyz) (var_ref lhs) (var_ref rhs))
 184     */
 185    if (rhs->type->is_vector())
 186       this->write_mask = (1U << rhs->type->vector_elements) - 1;
 187    else if (rhs->type->is_scalar())
 188       this->write_mask = 1;
 189    else
 190       this->write_mask = 0;
 191
 192    this->set_lhs(lhs);
 193 }
 194
 195 ir_expression::ir_expression(int op, const struct glsl_type *type,
 196                              ir_rvalue *op0, ir_rvalue *op1,
 197                              ir_rvalue *op2, ir_rvalue *op3)
 198    : ir_rvalue(ir_type_expression)
 199 {
 200    this->type = type;
 201    this->operation = ir_expression_operation(op);
 202    this->operands[0] = op0;
 203    this->operands[1] = op1;
 204    this->operands[2] = op2;
 205    this->operands[3] = op3;
 206 #ifndef NDEBUG
 207    int num_operands = get_num_operands(this->operation);
 208    for (int i = num_operands; i < 4; i++) {
 209       assert(this->operands[i] == NULL);
 210    }
 211 #endif
 212 }
 213
 214 ir_expression::ir_expression(int op, ir_rvalue *op0)
 215    : ir_rvalue(ir_type_expression)
 216 {
 217    this->operation = ir_expression_operation(op);
 218    this->operands[0] = op0;
 219    this->operands[1] = NULL;
 220    this->operands[2] = NULL;
 221    this->operands[3] = NULL;
 222
 223    assert(op <= ir_last_unop);
 224
 225    switch (this->operation) {
 226    case ir_unop_bit_not:
 227    case ir_unop_logic_not:
 228    case ir_unop_neg:
 229    case ir_unop_abs:
 230    case ir_unop_sign:
 231    case ir_unop_rcp:
 232    case ir_unop_rsq:
 233    case ir_unop_sqrt:
 234    case ir_unop_exp:
 235    case ir_unop_log:
 236    case ir_unop_exp2:
 237    case ir_unop_log2:
 238    case ir_unop_trunc:
 239    case ir_unop_ceil:
 240    case ir_unop_floor:
 241    case ir_unop_fract:
 242    case ir_unop_round_even:
 243    case ir_unop_sin:
 244    case ir_unop_cos:
 245    case ir_unop_dFdx:
 246    case ir_unop_dFdx_coarse:
 247    case ir_unop_dFdx_fine:
 248    case ir_unop_dFdy:
 249    case ir_unop_dFdy_coarse:
 250    case ir_unop_dFdy_fine:
 251    case ir_unop_bitfield_reverse:
 252    case ir_unop_interpolate_at_centroid:
 253    case ir_unop_saturate:
 254       this->type = op0->type;
 255       break;
 256
 257    case ir_unop_f2i:
 258    case ir_unop_b2i:
 259    case ir_unop_u2i:
 260    case ir_unop_d2i:
 261    case ir_unop_bitcast_f2i:
 262    case ir_unop_bit_count:
 263    case ir_unop_find_msb:
 264    case ir_unop_find_lsb:
 265    case ir_unop_subroutine_to_int:
 266    case ir_unop_i642i:
 267    case ir_unop_u642i:
 268       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
 269                                            op0->type->vector_elements, 1);
 270       break;
 271
 272    case ir_unop_b2f:
 273    case ir_unop_i2f:
 274    case ir_unop_u2f:
 275    case ir_unop_d2f:
 276    case ir_unop_bitcast_i2f:
 277    case ir_unop_bitcast_u2f:
 278    case ir_unop_i642f:
 279    case ir_unop_u642f:
 280       this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
 281                                            op0->type->vector_elements, 1);
 282       break;
 283
 284    case ir_unop_f2b:
 285    case ir_unop_i2b:
 286    case ir_unop_d2b:
 287    case ir_unop_i642b:
 288       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
 289                                            op0->type->vector_elements, 1);
 290       break;
 291
 292    case ir_unop_f2d:
 293    case ir_unop_i2d:
 294    case ir_unop_u2d:
 295    case ir_unop_i642d:
 296    case ir_unop_u642d:
 297       this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE,
 298                                            op0->type->vector_elements, 1);
 299       break;
 300
 301    case ir_unop_i2u:
 302    case ir_unop_f2u:
 303    case ir_unop_d2u:
 304    case ir_unop_bitcast_f2u:
 305    case ir_unop_i642u:
 306    case ir_unop_u642u:
 307       this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
 308                                            op0->type->vector_elements, 1);
 309       break;
 310
 311    case ir_unop_i2i64:
 312    case ir_unop_u2i64:
 313    case ir_unop_b2i64:
 314    case ir_unop_f2i64:
 315    case ir_unop_d2i64:
 316    case ir_unop_u642i64:
 317       this->type = glsl_type::get_instance(GLSL_TYPE_INT64,
 318                                            op0->type->vector_elements, 1);
 319       break;
 320
 321    case ir_unop_i2u64:
 322    case ir_unop_u2u64:
 323    case ir_unop_f2u64:
 324    case ir_unop_d2u64:
 325    case ir_unop_i642u64:
 326       this->type = glsl_type::get_instance(GLSL_TYPE_UINT64,
 327                                            op0->type->vector_elements, 1);
 328       break;
 329    case ir_unop_noise:
 330       this->type = glsl_type::float_type;
 331       break;
 332
 333    case ir_unop_unpack_double_2x32:
 334    case ir_unop_unpack_uint_2x32:
 335       this->type = glsl_type::uvec2_type;
 336       break;
 337
 338    case ir_unop_unpack_int_2x32:
 339       this->type = glsl_type::ivec2_type;
 340       break;
 341
 342    case ir_unop_pack_snorm_2x16:
 343    case ir_unop_pack_snorm_4x8:
 344    case ir_unop_pack_unorm_2x16:
 345    case ir_unop_pack_unorm_4x8:
 346    case ir_unop_pack_half_2x16:
 347       this->type = glsl_type::uint_type;
 348       break;
 349
 350    case ir_unop_pack_double_2x32:
 351       this->type = glsl_type::double_type;
 352       break;
 353
 354    case ir_unop_pack_int_2x32:
 355       this->type = glsl_type::int64_t_type;
 356       break;
 357
 358    case ir_unop_pack_uint_2x32:
 359       this->type = glsl_type::uint64_t_type;
 360       break;
 361
 362    case ir_unop_unpack_snorm_2x16:
 363    case ir_unop_unpack_unorm_2x16:
 364    case ir_unop_unpack_half_2x16:
 365       this->type = glsl_type::vec2_type;
 366       break;
 367
 368    case ir_unop_unpack_snorm_4x8:
 369    case ir_unop_unpack_unorm_4x8:
 370       this->type = glsl_type::vec4_type;
 371       break;
 372
 373    case ir_unop_unpack_sampler_2x32:
 374    case ir_unop_unpack_image_2x32:
 375       this->type = glsl_type::uvec2_type;
 376       break;
 377
 378    case ir_unop_pack_sampler_2x32:
 379    case ir_unop_pack_image_2x32:
 380       this->type = op0->type;
 381       break;
 382
 383    case ir_unop_frexp_sig:
 384       this->type = op0->type;
 385       break;
 386    case ir_unop_frexp_exp:
 387       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
 388                                            op0->type->vector_elements, 1);
 389       break;
 390
 391    case ir_unop_get_buffer_size:
 392    case ir_unop_ssbo_unsized_array_length:
 393       this->type = glsl_type::int_type;
 394       break;
 395
 396    case ir_unop_bitcast_i642d:
 397    case ir_unop_bitcast_u642d:
 398       this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE,
 399                                            op0->type->vector_elements, 1);
 400       break;
 401
 402    case ir_unop_bitcast_d2i64:
 403       this->type = glsl_type::get_instance(GLSL_TYPE_INT64,
 404                                            op0->type->vector_elements, 1);
 405       break;
 406    case ir_unop_bitcast_d2u64:
 407       this->type = glsl_type::get_instance(GLSL_TYPE_UINT64,
 408                                            op0->type->vector_elements, 1);
 409       break;
 410
 411    default:
 412       assert(!"not reached: missing automatic type setup for ir_expression");
 413       this->type = op0->type;
 414       break;
 415    }
 416 }
 417
 418 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
 419    : ir_rvalue(ir_type_expression)
 420 {
 421    this->operation = ir_expression_operation(op);
 422    this->operands[0] = op0;
 423    this->operands[1] = op1;
 424    this->operands[2] = NULL;
 425    this->operands[3] = NULL;
 426
 427    assert(op > ir_last_unop);
 428
 429    switch (this->operation) {
 430    case ir_binop_all_equal:
 431    case ir_binop_any_nequal:
 432       this->type = glsl_type::bool_type;
 433       break;
 434
 435    case ir_binop_add:
 436    case ir_binop_sub:
 437    case ir_binop_min:
 438    case ir_binop_max:
 439    case ir_binop_pow:
 440    case ir_binop_mul:
 441    case ir_binop_div:
 442    case ir_binop_mod:
 443       if (op0->type->is_scalar()) {
 444          this->type = op1->type;
 445       } else if (op1->type->is_scalar()) {
 446          this->type = op0->type;
 447       } else {
 448          if (this->operation == ir_binop_mul) {
 449             this->type = glsl_type::get_mul_type(op0->type, op1->type);
 450          } else {
 451             assert(op0->type == op1->type);
 452             this->type = op0->type;
 453          }
 454       }
 455       break;
 456
 457    case ir_binop_logic_and:
 458    case ir_binop_logic_xor:
 459    case ir_binop_logic_or:
 460    case ir_binop_bit_and:
 461    case ir_binop_bit_xor:
 462    case ir_binop_bit_or:
 463        assert(!op0->type->is_matrix());
 464        assert(!op1->type->is_matrix());
 465       if (op0->type->is_scalar()) {
 466          this->type = op1->type;
 467       } else if (op1->type->is_scalar()) {
 468          this->type = op0->type;
 469       } else {
 470           assert(op0->type->vector_elements == op1->type->vector_elements);
 471           this->type = op0->type;
 472       }
 473       break;
 474
 475    case ir_binop_equal:
 476    case ir_binop_nequal:
 477    case ir_binop_lequal:
 478    case ir_binop_gequal:
 479    case ir_binop_less:
 480    case ir_binop_greater:
 481       assert(op0->type == op1->type);
 482       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
 483                                            op0->type->vector_elements, 1);
 484       break;
 485
 486    case ir_binop_dot:
 487       this->type = op0->type->get_base_type();
 488       break;
 489
 490    case ir_binop_imul_high:
 491    case ir_binop_carry:
 492    case ir_binop_borrow:
 493    case ir_binop_lshift:
 494    case ir_binop_rshift:
 495    case ir_binop_ldexp:
 496    case ir_binop_interpolate_at_offset:
 497    case ir_binop_interpolate_at_sample:
 498       this->type = op0->type;
 499       break;
 500
 501    case ir_binop_vector_extract:
 502       this->type = op0->type->get_scalar_type();
 503       break;
 504
 505    default:
 506       assert(!"not reached: missing automatic type setup for ir_expression");
 507       this->type = glsl_type::float_type;
 508    }
 509 }
 510
 511 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1,
 512                              ir_rvalue *op2)
 513    : ir_rvalue(ir_type_expression)
 514 {
 515    this->operation = ir_expression_operation(op);
 516    this->operands[0] = op0;
 517    this->operands[1] = op1;
 518    this->operands[2] = op2;
 519    this->operands[3] = NULL;
 520
 521    assert(op > ir_last_binop && op <= ir_last_triop);
 522
 523    switch (this->operation) {
 524    case ir_triop_fma:
 525    case ir_triop_lrp:
 526    case ir_triop_bitfield_extract:
 527    case ir_triop_vector_insert:
 528       this->type = op0->type;
 529       break;
 530
 531    case ir_triop_csel:
 532       this->type = op1->type;
 533       break;
 534
 535    default:
 536       assert(!"not reached: missing automatic type setup for ir_expression");
 537       this->type = glsl_type::float_type;
 538    }
 539 }
 540
 541 unsigned int
 542 ir_expression::get_num_operands(ir_expression_operation op)
 543 {
 544    assert(op <= ir_last_opcode);
 545
 546    if (op <= ir_last_unop)
 547       return 1;
 548
 549    if (op <= ir_last_binop)
 550       return 2;
 551
 552    if (op <= ir_last_triop)
 553       return 3;
 554
 555    if (op <= ir_last_quadop)
 556       return 4;
 557
 558    assert(false);
 559    return 0;
 560 }
 561
 562 #include "ir_expression_operation_strings.h"
 563
 564 const char*
 565 depth_layout_string(ir_depth_layout layout)
 566 {
 567    switch(layout) {
 568    case ir_depth_layout_none:      return "";
 569    case ir_depth_layout_any:       return "depth_any";
 570    case ir_depth_layout_greater:   return "depth_greater";
 571    case ir_depth_layout_less:      return "depth_less";
 572    case ir_depth_layout_unchanged: return "depth_unchanged";
 573
 574    default:
 575       assert(0);
 576       return "";
 577    }
 578 }
 579
 580 ir_expression_operation
 581 ir_expression::get_operator(const char *str)
 582 {
 583    for (int op = 0; op <= int(ir_last_opcode); op++) {
 584       if (strcmp(str, ir_expression_operation_strings[op]) == 0)
 585          return (ir_expression_operation) op;
 586    }
 587    return (ir_expression_operation) -1;
 588 }
 589
 590 ir_variable *
 591 ir_expression::variable_referenced() const
 592 {
 593    switch (operation) {
 594       case ir_binop_vector_extract:
 595       case ir_triop_vector_insert:
 596          /* We get these for things like a[0] where a is a vector type. In these
 597           * cases we want variable_referenced() to return the actual vector
 598           * variable this is wrapping.
 599           */
 600          return operands[0]->variable_referenced();
 601       default:
 602          return ir_rvalue::variable_referenced();
 603    }
 604 }
 605
 606 ir_constant::ir_constant()
 607    : ir_rvalue(ir_type_constant)
 608 {
 609    this->array_elements = NULL;
 610 }
 611
 612 ir_constant::ir_constant(const struct glsl_type *type,
 613                          const ir_constant_data *data)
 614    : ir_rvalue(ir_type_constant)
 615 {
 616    this->array_elements = NULL;
 617
 618    assert((type->base_type >= GLSL_TYPE_UINT)
 619           && (type->base_type <= GLSL_TYPE_IMAGE));
 620
 621    this->type = type;
 622    memcpy(& this->value, data, sizeof(this->value));
 623 }
 624
 625 ir_constant::ir_constant(float f, unsigned vector_elements)
 626    : ir_rvalue(ir_type_constant)
 627 {
 628    assert(vector_elements <= 4);
 629    this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT, vector_elements, 1);
 630    for (unsigned i = 0; i < vector_elements; i++) {
 631       this->value.f[i] = f;
 632    }
 633    for (unsigned i = vector_elements; i < 16; i++)  {
 634       this->value.f[i] = 0;
 635    }
 636 }
 637
 638 ir_constant::ir_constant(double d, unsigned vector_elements)
 639    : ir_rvalue(ir_type_constant)
 640 {
 641    assert(vector_elements <= 4);
 642    this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE, vector_elements, 1);
 643    for (unsigned i = 0; i < vector_elements; i++) {
 644       this->value.d[i] = d;
 645    }
 646    for (unsigned i = vector_elements; i < 16; i++)  {
 647       this->value.d[i] = 0.0;
 648    }
 649 }
 650
 651 ir_constant::ir_constant(unsigned int u, unsigned vector_elements)
 652    : ir_rvalue(ir_type_constant)
 653 {
 654    assert(vector_elements <= 4);
 655    this->type = glsl_type::get_instance(GLSL_TYPE_UINT, vector_elements, 1);
 656    for (unsigned i = 0; i < vector_elements; i++) {
 657       this->value.u[i] = u;
 658    }
 659    for (unsigned i = vector_elements; i < 16; i++) {
 660       this->value.u[i] = 0;
 661    }
 662 }
 663
 664 ir_constant::ir_constant(int integer, unsigned vector_elements)
 665    : ir_rvalue(ir_type_constant)
 666 {
 667    assert(vector_elements <= 4);
 668    this->type = glsl_type::get_instance(GLSL_TYPE_INT, vector_elements, 1);
 669    for (unsigned i = 0; i < vector_elements; i++) {
 670       this->value.i[i] = integer;
 671    }
 672    for (unsigned i = vector_elements; i < 16; i++) {
 673       this->value.i[i] = 0;
 674    }
 675 }
 676
 677 ir_constant::ir_constant(uint64_t u64, unsigned vector_elements)
 678    : ir_rvalue(ir_type_constant)
 679 {
 680    assert(vector_elements <= 4);
 681    this->type = glsl_type::get_instance(GLSL_TYPE_UINT64, vector_elements, 1);
 682    for (unsigned i = 0; i < vector_elements; i++) {
 683       this->value.u64[i] = u64;
 684    }
 685    for (unsigned i = vector_elements; i < 16; i++) {
 686       this->value.u64[i] = 0;
 687    }
 688 }
 689
 690 ir_constant::ir_constant(int64_t int64, unsigned vector_elements)
 691    : ir_rvalue(ir_type_constant)
 692 {
 693    assert(vector_elements <= 4);
 694    this->type = glsl_type::get_instance(GLSL_TYPE_INT64, vector_elements, 1);
 695    for (unsigned i = 0; i < vector_elements; i++) {
 696       this->value.i64[i] = int64;
 697    }
 698    for (unsigned i = vector_elements; i < 16; i++) {
 699       this->value.i64[i] = 0;
 700    }
 701 }
 702
 703 ir_constant::ir_constant(bool b, unsigned vector_elements)
 704    : ir_rvalue(ir_type_constant)
 705 {
 706    assert(vector_elements <= 4);
 707    this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, vector_elements, 1);
 708    for (unsigned i = 0; i < vector_elements; i++) {
 709       this->value.b[i] = b;
 710    }
 711    for (unsigned i = vector_elements; i < 16; i++) {
 712       this->value.b[i] = false;
 713    }
 714 }
 715
 716 ir_constant::ir_constant(const ir_constant *c, unsigned i)
 717    : ir_rvalue(ir_type_constant)
 718 {
 719    this->array_elements = NULL;
 720    this->type = c->type->get_base_type();
 721
 722    switch (this->type->base_type) {
 723    case GLSL_TYPE_UINT:  this->value.u[0] = c->value.u[i]; break;
 724    case GLSL_TYPE_INT:   this->value.i[0] = c->value.i[i]; break;
 725    case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
 726    case GLSL_TYPE_BOOL:  this->value.b[0] = c->value.b[i]; break;
 727    case GLSL_TYPE_DOUBLE: this->value.d[0] = c->value.d[i]; break;
 728    default:              assert(!"Should not get here."); break;
 729    }
 730 }
 731
 732 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
 733    : ir_rvalue(ir_type_constant)
 734 {
 735    this->array_elements = NULL;
 736    this->type = type;
 737
 738    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 739           || type->is_record() || type->is_array());
 740
 741    if (type->is_array()) {
 742       this->array_elements = ralloc_array(this, ir_constant *, type->length);
 743       unsigned i = 0;
 744       foreach_in_list(ir_constant, value, value_list) {
 745          assert(value->as_constant() != NULL);
 746
 747          this->array_elements[i++] = value;
 748       }
 749       return;
 750    }
 751
 752    /* If the constant is a record, the types of each of the entries in
 753     * value_list must be a 1-for-1 match with the structure components.  Each
 754     * entry must also be a constant.  Just move the nodes from the value_list
 755     * to the list in the ir_constant.
 756     */
 757    /* FINISHME: Should there be some type checking and / or assertions here? */
 758    /* FINISHME: Should the new constant take ownership of the nodes from
 759     * FINISHME: value_list, or should it make copies?
 760     */
 761    if (type->is_record()) {
 762       value_list->move_nodes_to(& this->components);
 763       return;
 764    }
 765
 766    for (unsigned i = 0; i < 16; i++) {
 767       this->value.u[i] = 0;
 768    }
 769
 770    ir_constant *value = (ir_constant *) (value_list->get_head_raw());
 771
 772    /* Constructors with exactly one scalar argument are special for vectors
 773     * and matrices.  For vectors, the scalar value is replicated to fill all
 774     * the components.  For matrices, the scalar fills the components of the
 775     * diagonal while the rest is filled with 0.
 776     */
 777    if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
 778       if (type->is_matrix()) {
 779          /* Matrix - fill diagonal (rest is already set to 0) */
 780          assert(type->is_float() || type->is_double());
 781          for (unsigned i = 0; i < type->matrix_columns; i++) {
 782             if (type->is_float())
 783                this->value.f[i * type->vector_elements + i] =
 784                   value->value.f[0];
 785             else
 786                this->value.d[i * type->vector_elements + i] =
 787                   value->value.d[0];
 788          }
 789       } else {
 790          /* Vector or scalar - fill all components */
 791          switch (type->base_type) {
 792          case GLSL_TYPE_UINT:
 793          case GLSL_TYPE_INT:
 794             for (unsigned i = 0; i < type->components(); i++)
 795                this->value.u[i] = value->value.u[0];
 796             break;
 797          case GLSL_TYPE_FLOAT:
 798             for (unsigned i = 0; i < type->components(); i++)
 799                this->value.f[i] = value->value.f[0];
 800             break;
 801          case GLSL_TYPE_DOUBLE:
 802             for (unsigned i = 0; i < type->components(); i++)
 803                this->value.d[i] = value->value.d[0];
 804             break;
 805          case GLSL_TYPE_UINT64:
 806          case GLSL_TYPE_INT64:
 807             for (unsigned i = 0; i < type->components(); i++)
 808                this->value.u64[i] = value->value.u64[0];
 809             break;
 810          case GLSL_TYPE_BOOL:
 811             for (unsigned i = 0; i < type->components(); i++)
 812                this->value.b[i] = value->value.b[0];
 813             break;
 814          default:
 815             assert(!"Should not get here.");
 816             break;
 817          }
 818       }
 819       return;
 820    }
 821
 822    if (type->is_matrix() && value->type->is_matrix()) {
 823       assert(value->next->is_tail_sentinel());
 824
 825       /* From section 5.4.2 of the GLSL 1.20 spec:
 826        * "If a matrix is constructed from a matrix, then each component
 827        *  (column i, row j) in the result that has a corresponding component
 828        *  (column i, row j) in the argument will be initialized from there."
 829        */
 830       unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
 831       unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
 832       for (unsigned i = 0; i < cols; i++) {
 833          for (unsigned j = 0; j < rows; j++) {
 834             const unsigned src = i * value->type->vector_elements + j;
 835             const unsigned dst = i * type->vector_elements + j;
 836             this->value.f[dst] = value->value.f[src];
 837          }
 838       }
 839
 840       /* "All other components will be initialized to the identity matrix." */
 841       for (unsigned i = cols; i < type->matrix_columns; i++)
 842          this->value.f[i * type->vector_elements + i] = 1.0;
 843
 844       return;
 845    }
 846
 847    /* Use each component from each entry in the value_list to initialize one
 848     * component of the constant being constructed.
 849     */
 850    unsigned i = 0;
 851    for (;;) {
 852       assert(value->as_constant() != NULL);
 853       assert(!value->is_tail_sentinel());
 854
 855       for (unsigned j = 0; j < value->type->components(); j++) {
 856          switch (type->base_type) {
 857          case GLSL_TYPE_UINT:
 858             this->value.u[i] = value->get_uint_component(j);
 859             break;
 860          case GLSL_TYPE_INT:
 861             this->value.i[i] = value->get_int_component(j);
 862             break;
 863          case GLSL_TYPE_FLOAT:
 864             this->value.f[i] = value->get_float_component(j);
 865             break;
 866          case GLSL_TYPE_BOOL:
 867             this->value.b[i] = value->get_bool_component(j);
 868             break;
 869          case GLSL_TYPE_DOUBLE:
 870             this->value.d[i] = value->get_double_component(j);
 871             break;
 872          case GLSL_TYPE_UINT64:
 873             this->value.u64[i] = value->get_uint64_component(j);
 874             break;
 875          case GLSL_TYPE_INT64:
 876             this->value.i64[i] = value->get_int64_component(j);
 877             break;
 878          default:
 879             /* FINISHME: What to do?  Exceptions are not the answer.
 880              */
 881             break;
 882          }
 883
 884          i++;
 885          if (i >= type->components())
 886             break;
 887       }
 888
 889       if (i >= type->components())
 890          break; /* avoid downcasting a list sentinel */
 891       value = (ir_constant *) value->next;
 892    }
 893 }
 894
 895 ir_constant *
 896 ir_constant::zero(void *mem_ctx, const glsl_type *type)
 897 {
 898    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 899           || type->is_record() || type->is_array());
 900
 901    ir_constant *c = new(mem_ctx) ir_constant;
 902    c->type = type;
 903    memset(&c->value, 0, sizeof(c->value));
 904
 905    if (type->is_array()) {
 906       c->array_elements = ralloc_array(c, ir_constant *, type->length);
 907
 908       for (unsigned i = 0; i < type->length; i++)
 909          c->array_elements[i] = ir_constant::zero(c, type->fields.array);
 910    }
 911
 912    if (type->is_record()) {
 913       for (unsigned i = 0; i < type->length; i++) {
 914          ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
 915          c->components.push_tail(comp);
 916       }
 917    }
 918
 919    return c;
 920 }
 921
 922 bool
 923 ir_constant::get_bool_component(unsigned i) const
 924 {
 925    switch (this->type->base_type) {
 926    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
 927    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
 928    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
 929    case GLSL_TYPE_BOOL:  return this->value.b[i];
 930    case GLSL_TYPE_DOUBLE: return this->value.d[i] != 0.0;
 931    case GLSL_TYPE_UINT64: return this->value.u64[i] != 0;
 932    case GLSL_TYPE_INT64:  return this->value.i64[i] != 0;
 933    default:              assert(!"Should not get here."); break;
 934    }
 935
 936    /* Must return something to make the compiler happy.  This is clearly an
 937     * error case.
 938     */
 939    return false;
 940 }
 941
 942 float
 943 ir_constant::get_float_component(unsigned i) const
 944 {
 945    switch (this->type->base_type) {
 946    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
 947    case GLSL_TYPE_INT:   return (float) this->value.i[i];
 948    case GLSL_TYPE_FLOAT: return this->value.f[i];
 949    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0f : 0.0f;
 950    case GLSL_TYPE_DOUBLE: return (float) this->value.d[i];
 951    case GLSL_TYPE_UINT64: return (float) this->value.u64[i];
 952    case GLSL_TYPE_INT64:  return (float) this->value.i64[i];
 953    default:              assert(!"Should not get here."); break;
 954    }
 955
 956    /* Must return something to make the compiler happy.  This is clearly an
 957     * error case.
 958     */
 959    return 0.0;
 960 }
 961
 962 double
 963 ir_constant::get_double_component(unsigned i) const
 964 {
 965    switch (this->type->base_type) {
 966    case GLSL_TYPE_UINT:  return (double) this->value.u[i];
 967    case GLSL_TYPE_INT:   return (double) this->value.i[i];
 968    case GLSL_TYPE_FLOAT: return (double) this->value.f[i];
 969    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0 : 0.0;
 970    case GLSL_TYPE_DOUBLE: return this->value.d[i];
 971    case GLSL_TYPE_UINT64: return (double) this->value.u64[i];
 972    case GLSL_TYPE_INT64:  return (double) this->value.i64[i];
 973    default:              assert(!"Should not get here."); break;
 974    }
 975
 976    /* Must return something to make the compiler happy.  This is clearly an
 977     * error case.
 978     */
 979    return 0.0;
 980 }
 981
 982 int
 983 ir_constant::get_int_component(unsigned i) const
 984 {
 985    switch (this->type->base_type) {
 986    case GLSL_TYPE_UINT:  return this->value.u[i];
 987    case GLSL_TYPE_INT:   return this->value.i[i];
 988    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
 989    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 990    case GLSL_TYPE_DOUBLE: return (int) this->value.d[i];
 991    case GLSL_TYPE_UINT64: return (int) this->value.u64[i];
 992    case GLSL_TYPE_INT64:  return (int) this->value.i64[i];
 993    default:              assert(!"Should not get here."); break;
 994    }
 995
 996    /* Must return something to make the compiler happy.  This is clearly an
 997     * error case.
 998     */
 999    return 0;
1000 }
1001
1002 unsigned
1003 ir_constant::get_uint_component(unsigned i) const
1004 {
1005    switch (this->type->base_type) {
1006    case GLSL_TYPE_UINT:  return this->value.u[i];
1007    case GLSL_TYPE_INT:   return this->value.i[i];
1008    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
1009    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1010    case GLSL_TYPE_DOUBLE: return (unsigned) this->value.d[i];
1011    case GLSL_TYPE_UINT64: return (unsigned) this->value.u64[i];
1012    case GLSL_TYPE_INT64:  return (unsigned) this->value.i64[i];
1013    default:              assert(!"Should not get here."); break;
1014    }
1015
1016    /* Must return something to make the compiler happy.  This is clearly an
1017     * error case.
1018     */
1019    return 0;
1020 }
1021
1022 int64_t
1023 ir_constant::get_int64_component(unsigned i) const
1024 {
1025    switch (this->type->base_type) {
1026    case GLSL_TYPE_UINT:  return this->value.u[i];
1027    case GLSL_TYPE_INT:   return this->value.i[i];
1028    case GLSL_TYPE_FLOAT: return (int64_t) this->value.f[i];
1029    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1030    case GLSL_TYPE_DOUBLE: return (int64_t) this->value.d[i];
1031    case GLSL_TYPE_UINT64: return (int64_t) this->value.u64[i];
1032    case GLSL_TYPE_INT64:  return this->value.i64[i];
1033    default:              assert(!"Should not get here."); break;
1034    }
1035
1036    /* Must return something to make the compiler happy.  This is clearly an
1037     * error case.
1038     */
1039    return 0;
1040 }
1041
1042 uint64_t
1043 ir_constant::get_uint64_component(unsigned i) const
1044 {
1045    switch (this->type->base_type) {
1046    case GLSL_TYPE_UINT:  return this->value.u[i];
1047    case GLSL_TYPE_INT:   return this->value.i[i];
1048    case GLSL_TYPE_FLOAT: return (uint64_t) this->value.f[i];
1049    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1050    case GLSL_TYPE_DOUBLE: return (uint64_t) this->value.d[i];
1051    case GLSL_TYPE_UINT64: return this->value.u64[i];
1052    case GLSL_TYPE_INT64:  return (uint64_t) this->value.i64[i];
1053    default:              assert(!"Should not get here."); break;
1054    }
1055
1056    /* Must return something to make the compiler happy.  This is clearly an
1057     * error case.
1058     */
1059    return 0;
1060 }
1061
1062 ir_constant *
1063 ir_constant::get_array_element(unsigned i) const
1064 {
1065    assert(this->type->is_array());
1066
1067    /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
1068     *
1069     *     "Behavior is undefined if a shader subscripts an array with an index
1070     *     less than 0 or greater than or equal to the size the array was
1071     *     declared with."
1072     *
1073     * Most out-of-bounds accesses are removed before things could get this far.
1074     * There are cases where non-constant array index values can get constant
1075     * folded.
1076     */
1077    if (int(i) < 0)
1078       i = 0;
1079    else if (i >= this->type->length)
1080       i = this->type->length - 1;
1081
1082    return array_elements[i];
1083 }
1084
1085 ir_constant *
1086 ir_constant::get_record_field(const char *name)
1087 {
1088    int idx = this->type->field_index(name);
1089
1090    if (idx < 0)
1091       return NULL;
1092
1093    if (this->components.is_empty())
1094       return NULL;
1095
1096    exec_node *node = this->components.get_head_raw();
1097    for (int i = 0; i < idx; i++) {
1098       node = node->next;
1099
1100       /* If the end of the list is encountered before the element matching the
1101        * requested field is found, return NULL.
1102        */
1103       if (node->is_tail_sentinel())
1104          return NULL;
1105    }
1106
1107    return (ir_constant *) node;
1108 }
1109
1110 void
1111 ir_constant::copy_offset(ir_constant *src, int offset)
1112 {
1113    switch (this->type->base_type) {
1114    case GLSL_TYPE_UINT:
1115    case GLSL_TYPE_INT:
1116    case GLSL_TYPE_FLOAT:
1117    case GLSL_TYPE_DOUBLE:
1118    case GLSL_TYPE_UINT64:
1119    case GLSL_TYPE_INT64:
1120    case GLSL_TYPE_BOOL: {
1121       unsigned int size = src->type->components();
1122       assert (size <= this->type->components() - offset);
1123       for (unsigned int i=0; i<size; i++) {
1124          switch (this->type->base_type) {
1125          case GLSL_TYPE_UINT:
1126             value.u[i+offset] = src->get_uint_component(i);
1127             break;
1128          case GLSL_TYPE_INT:
1129             value.i[i+offset] = src->get_int_component(i);
1130             break;
1131          case GLSL_TYPE_FLOAT:
1132             value.f[i+offset] = src->get_float_component(i);
1133             break;
1134          case GLSL_TYPE_BOOL:
1135             value.b[i+offset] = src->get_bool_component(i);
1136             break;
1137          case GLSL_TYPE_DOUBLE:
1138             value.d[i+offset] = src->get_double_component(i);
1139             break;
1140          case GLSL_TYPE_UINT64:
1141             value.u64[i+offset] = src->get_uint64_component(i);
1142             break;
1143          case GLSL_TYPE_INT64:
1144             value.i64[i+offset] = src->get_int64_component(i);
1145             break;
1146          default: // Shut up the compiler
1147             break;
1148          }
1149       }
1150       break;
1151    }
1152
1153    case GLSL_TYPE_STRUCT: {
1154       assert (src->type == this->type);
1155       this->components.make_empty();
1156       foreach_in_list(ir_constant, orig, &src->components) {
1157          this->components.push_tail(orig->clone(this, NULL));
1158       }
1159       break;
1160    }
1161
1162    case GLSL_TYPE_ARRAY: {
1163       assert (src->type == this->type);
1164       for (unsigned i = 0; i < this->type->length; i++) {
1165          this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
1166       }
1167       break;
1168    }
1169
1170    default:
1171       assert(!"Should not get here.");
1172       break;
1173    }
1174 }
1175
1176 void
1177 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
1178 {
1179    assert (!type->is_array() && !type->is_record());
1180
1181    if (!type->is_vector() && !type->is_matrix()) {
1182       offset = 0;
1183       mask = 1;
1184    }
1185
1186    int id = 0;
1187    for (int i=0; i<4; i++) {
1188       if (mask & (1 << i)) {
1189          switch (this->type->base_type) {
1190          case GLSL_TYPE_UINT:
1191             value.u[i+offset] = src->get_uint_component(id++);
1192             break;
1193          case GLSL_TYPE_INT:
1194             value.i[i+offset] = src->get_int_component(id++);
1195             break;
1196          case GLSL_TYPE_FLOAT:
1197             value.f[i+offset] = src->get_float_component(id++);
1198             break;
1199          case GLSL_TYPE_BOOL:
1200             value.b[i+offset] = src->get_bool_component(id++);
1201             break;
1202          case GLSL_TYPE_DOUBLE:
1203             value.d[i+offset] = src->get_double_component(id++);
1204             break;
1205          case GLSL_TYPE_UINT64:
1206             value.u64[i+offset] = src->get_uint64_component(id++);
1207             break;
1208          case GLSL_TYPE_INT64:
1209             value.i64[i+offset] = src->get_int64_component(id++);
1210             break;
1211          default:
1212             assert(!"Should not get here.");
1213             return;
1214          }
1215       }
1216    }
1217 }
1218
1219 bool
1220 ir_constant::has_value(const ir_constant *c) const
1221 {
1222    if (this->type != c->type)
1223       return false;
1224
1225    if (this->type->is_array()) {
1226       for (unsigned i = 0; i < this->type->length; i++) {
1227          if (!this->array_elements[i]->has_value(c->array_elements[i]))
1228             return false;
1229       }
1230       return true;
1231    }
1232
1233    if (this->type->is_record()) {
1234       const exec_node *a_node = this->components.get_head_raw();
1235       const exec_node *b_node = c->components.get_head_raw();
1236
1237       while (!a_node->is_tail_sentinel()) {
1238          assert(!b_node->is_tail_sentinel());
1239
1240          const ir_constant *const a_field = (ir_constant *) a_node;
1241          const ir_constant *const b_field = (ir_constant *) b_node;
1242
1243          if (!a_field->has_value(b_field))
1244             return false;
1245
1246          a_node = a_node->next;
1247          b_node = b_node->next;
1248       }
1249
1250       return true;
1251    }
1252
1253    for (unsigned i = 0; i < this->type->components(); i++) {
1254       switch (this->type->base_type) {
1255       case GLSL_TYPE_UINT:
1256          if (this->value.u[i] != c->value.u[i])
1257             return false;
1258          break;
1259       case GLSL_TYPE_INT:
1260          if (this->value.i[i] != c->value.i[i])
1261             return false;
1262          break;
1263       case GLSL_TYPE_FLOAT:
1264          if (this->value.f[i] != c->value.f[i])
1265             return false;
1266          break;
1267       case GLSL_TYPE_BOOL:
1268          if (this->value.b[i] != c->value.b[i])
1269             return false;
1270          break;
1271       case GLSL_TYPE_DOUBLE:
1272          if (this->value.d[i] != c->value.d[i])
1273             return false;
1274          break;
1275       case GLSL_TYPE_UINT64:
1276          if (this->value.u64[i] != c->value.u64[i])
1277             return false;
1278          break;
1279       case GLSL_TYPE_INT64:
1280          if (this->value.i64[i] != c->value.i64[i])
1281             return false;
1282          break;
1283       default:
1284          assert(!"Should not get here.");
1285          return false;
1286       }
1287    }
1288
1289    return true;
1290 }
1291
1292 bool
1293 ir_constant::is_value(float f, int i) const
1294 {
1295    if (!this->type->is_scalar() && !this->type->is_vector())
1296       return false;
1297
1298    /* Only accept boolean values for 0/1. */
1299    if (int(bool(i)) != i && this->type->is_boolean())
1300       return false;
1301
1302    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1303       switch (this->type->base_type) {
1304       case GLSL_TYPE_FLOAT:
1305          if (this->value.f[c] != f)
1306             return false;
1307          break;
1308       case GLSL_TYPE_INT:
1309          if (this->value.i[c] != i)
1310             return false;
1311          break;
1312       case GLSL_TYPE_UINT:
1313          if (this->value.u[c] != unsigned(i))
1314             return false;
1315          break;
1316       case GLSL_TYPE_BOOL:
1317          if (this->value.b[c] != bool(i))
1318             return false;
1319          break;
1320       case GLSL_TYPE_DOUBLE:
1321          if (this->value.d[c] != double(f))
1322             return false;
1323          break;
1324       case GLSL_TYPE_UINT64:
1325          if (this->value.u64[c] != uint64_t(i))
1326             return false;
1327          break;
1328       case GLSL_TYPE_INT64:
1329          if (this->value.i64[c] != i)
1330             return false;
1331          break;
1332       default:
1333          /* The only other base types are structures, arrays, and samplers.
1334           * Samplers cannot be constants, and the others should have been
1335           * filtered out above.
1336           */
1337          assert(!"Should not get here.");
1338          return false;
1339       }
1340    }
1341
1342    return true;
1343 }
1344
1345 bool
1346 ir_constant::is_zero() const
1347 {
1348    return is_value(0.0, 0);
1349 }
1350
1351 bool
1352 ir_constant::is_one() const
1353 {
1354    return is_value(1.0, 1);
1355 }
1356
1357 bool
1358 ir_constant::is_negative_one() const
1359 {
1360    return is_value(-1.0, -1);
1361 }
1362
1363 bool
1364 ir_constant::is_uint16_constant() const
1365 {
1366    if (!type->is_integer())
1367       return false;
1368
1369    return value.u[0] < (1 << 16);
1370 }
1371
1372 ir_loop::ir_loop()
1373    : ir_instruction(ir_type_loop)
1374 {
1375 }
1376
1377
1378 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1379    : ir_dereference(ir_type_dereference_variable)
1380 {
1381    assert(var != NULL);
1382
1383    this->var = var;
1384    this->type = var->type;
1385 }
1386
1387
1388 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1389                                            ir_rvalue *array_index)
1390    : ir_dereference(ir_type_dereference_array)
1391 {
1392    this->array_index = array_index;
1393    this->set_array(value);
1394 }
1395
1396
1397 ir_dereference_array::ir_dereference_array(ir_variable *var,
1398                                            ir_rvalue *array_index)
1399    : ir_dereference(ir_type_dereference_array)
1400 {
1401    void *ctx = ralloc_parent(var);
1402
1403    this->array_index = array_index;
1404    this->set_array(new(ctx) ir_dereference_variable(var));
1405 }
1406
1407
1408 void
1409 ir_dereference_array::set_array(ir_rvalue *value)
1410 {
1411    assert(value != NULL);
1412
1413    this->array = value;
1414
1415    const glsl_type *const vt = this->array->type;
1416
1417    if (vt->is_array()) {
1418       type = vt->fields.array;
1419    } else if (vt->is_matrix()) {
1420       type = vt->column_type();
1421    } else if (vt->is_vector()) {
1422       type = vt->get_base_type();
1423    }
1424 }
1425
1426
1427 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1428                                              const char *field)
1429    : ir_dereference(ir_type_dereference_record)
1430 {
1431    assert(value != NULL);
1432
1433    this->record = value;
1434    this->field = ralloc_strdup(this, field);
1435    this->type = this->record->type->field_type(field);
1436 }
1437
1438
1439 ir_dereference_record::ir_dereference_record(ir_variable *var,
1440                                              const char *field)
1441    : ir_dereference(ir_type_dereference_record)
1442 {
1443    void *ctx = ralloc_parent(var);
1444
1445    this->record = new(ctx) ir_dereference_variable(var);
1446    this->field = ralloc_strdup(this, field);
1447    this->type = this->record->type->field_type(field);
1448 }
1449
1450 bool
1451 ir_dereference::is_lvalue(const struct _mesa_glsl_parse_state *state) const
1452 {
1453    ir_variable *var = this->variable_referenced();
1454
1455    /* Every l-value derference chain eventually ends in a variable.
1456     */
1457    if ((var == NULL) || var->data.read_only)
1458       return false;
1459
1460    /* From section 4.1.7 of the ARB_bindless_texture spec:
1461     *
1462     * "Samplers can be used as l-values, so can be assigned into and used as
1463     *  "out" and "inout" function parameters."
1464     *
1465     * From section 4.1.X of the ARB_bindless_texture spec:
1466     *
1467     * "Images can be used as l-values, so can be assigned into and used as
1468     *  "out" and "inout" function parameters."
1469     */
1470    if ((!state || state->has_bindless()) &&
1471        (this->type->contains_sampler() || this->type->contains_image()))
1472       return true;
1473
1474    /* From section 4.1.7 of the GLSL 4.40 spec:
1475     *
1476     *   "Opaque variables cannot be treated as l-values; hence cannot
1477     *    be used as out or inout function parameters, nor can they be
1478     *    assigned into."
1479     */
1480    if (this->type->contains_opaque())
1481       return false;
1482
1483    return true;
1484 }
1485
1486
1487 static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels", "texture_samples", "samples_identical" };
1488
1489 const char *ir_texture::opcode_string()
1490 {
1491    assert((unsigned int) op < ARRAY_SIZE(tex_opcode_strs));
1492    return tex_opcode_strs[op];
1493 }
1494
1495 ir_texture_opcode
1496 ir_texture::get_opcode(const char *str)
1497 {
1498    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1499    for (int op = 0; op < count; op++) {
1500       if (strcmp(str, tex_opcode_strs[op]) == 0)
1501          return (ir_texture_opcode) op;
1502    }
1503    return (ir_texture_opcode) -1;
1504 }
1505
1506
1507 void
1508 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1509 {
1510    assert(sampler != NULL);
1511    assert(type != NULL);
1512    this->sampler = sampler;
1513    this->type = type;
1514
1515    if (this->op == ir_txs || this->op == ir_query_levels ||
1516        this->op == ir_texture_samples) {
1517       assert(type->base_type == GLSL_TYPE_INT);
1518    } else if (this->op == ir_lod) {
1519       assert(type->vector_elements == 2);
1520       assert(type->is_float());
1521    } else if (this->op == ir_samples_identical) {
1522       assert(type == glsl_type::bool_type);
1523       assert(sampler->type->is_sampler());
1524       assert(sampler->type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS);
1525    } else {
1526       assert(sampler->type->sampled_type == (int) type->base_type);
1527       if (sampler->type->sampler_shadow)
1528          assert(type->vector_elements == 4 || type->vector_elements == 1);
1529       else
1530          assert(type->vector_elements == 4);
1531    }
1532 }
1533
1534
1535 void
1536 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1537 {
1538    assert((count >= 1) && (count <= 4));
1539
1540    memset(&this->mask, 0, sizeof(this->mask));
1541    this->mask.num_components = count;
1542
1543    unsigned dup_mask = 0;
1544    switch (count) {
1545    case 4:
1546       assert(comp[3] <= 3);
1547       dup_mask |= (1U << comp[3])
1548          & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1549       this->mask.w = comp[3];
1550
1551    case 3:
1552       assert(comp[2] <= 3);
1553       dup_mask |= (1U << comp[2])
1554          & ((1U << comp[0]) | (1U << comp[1]));
1555       this->mask.z = comp[2];
1556
1557    case 2:
1558       assert(comp[1] <= 3);
1559       dup_mask |= (1U << comp[1])
1560          & ((1U << comp[0]));
1561       this->mask.y = comp[1];
1562
1563    case 1:
1564       assert(comp[0] <= 3);
1565       this->mask.x = comp[0];
1566    }
1567
1568    this->mask.has_duplicates = dup_mask != 0;
1569
1570    /* Based on the number of elements in the swizzle and the base type
1571     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1572     * generate the type of the resulting value.
1573     */
1574    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1575 }
1576
1577 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1578                        unsigned w, unsigned count)
1579    : ir_rvalue(ir_type_swizzle), val(val)
1580 {
1581    const unsigned components[4] = { x, y, z, w };
1582    this->init_mask(components, count);
1583 }
1584
1585 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1586                        unsigned count)
1587    : ir_rvalue(ir_type_swizzle), val(val)
1588 {
1589    this->init_mask(comp, count);
1590 }
1591
1592 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1593    : ir_rvalue(ir_type_swizzle), mask(mask), val(val)
1594 {
1595    this->type = glsl_type::get_instance(val->type->base_type,
1596                                         mask.num_components, 1);
1597 }
1598
1599 #define X 1
1600 #define R 5
1601 #define S 9
1602 #define I 13
1603
1604 ir_swizzle *
1605 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1606 {
1607    void *ctx = ralloc_parent(val);
1608
1609    /* For each possible swizzle character, this table encodes the value in
1610     * \c idx_map that represents the 0th element of the vector.  For invalid
1611     * swizzle characters (e.g., 'k'), a special value is used that will allow
1612     * detection of errors.
1613     */
1614    static const unsigned char base_idx[26] = {
1615    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
1616       R, R, I, I, I, I, R, I, I, I, I, I, I,
1617    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
1618       I, I, S, S, R, S, S, I, I, X, X, X, X
1619    };
1620
1621    /* Each valid swizzle character has an entry in the previous table.  This
1622     * table encodes the base index encoded in the previous table plus the actual
1623     * index of the swizzle character.  When processing swizzles, the first
1624     * character in the string is indexed in the previous table.  Each character
1625     * in the string is indexed in this table, and the value found there has the
1626     * value form the first table subtracted.  The result must be on the range
1627     * [0,3].
1628     *
1629     * For example, the string "wzyx" will get X from the first table.  Each of
1630     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
1631     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1632     *
1633     * The string "wzrg" will get X from the first table.  Each of the characters
1634     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
1635     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
1636     * [0,3], the error is detected.
1637     */
1638    static const unsigned char idx_map[26] = {
1639    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
1640       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
1641    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
1642       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
1643    };
1644
1645    int swiz_idx[4] = { 0, 0, 0, 0 };
1646    unsigned i;
1647
1648
1649    /* Validate the first character in the swizzle string and look up the base
1650     * index value as described above.
1651     */
1652    if ((str[0] < 'a') || (str[0] > 'z'))
1653       return NULL;
1654
1655    const unsigned base = base_idx[str[0] - 'a'];
1656
1657
1658    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1659       /* Validate the next character, and, as described above, convert it to a
1660        * swizzle index.
1661        */
1662       if ((str[i] < 'a') || (str[i] > 'z'))
1663          return NULL;
1664
1665       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1666       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1667          return NULL;
1668    }
1669
1670    if (str[i] != '\0')
1671          return NULL;
1672
1673    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1674                               swiz_idx[3], i);
1675 }
1676
1677 #undef X
1678 #undef R
1679 #undef S
1680 #undef I
1681
1682 ir_variable *
1683 ir_swizzle::variable_referenced() const
1684 {
1685    return this->val->variable_referenced();
1686 }
1687
1688
1689 bool ir_variable::temporaries_allocate_names = false;
1690
1691 const char ir_variable::tmp_name[] = "compiler_temp";
1692
1693 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1694                          ir_variable_mode mode)
1695    : ir_instruction(ir_type_variable)
1696 {
1697    this->type = type;
1698
1699    if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)
1700       name = NULL;
1701
1702    /* The ir_variable clone method may call this constructor with name set to
1703     * tmp_name.
1704     */
1705    assert(name != NULL
1706           || mode == ir_var_temporary
1707           || mode == ir_var_function_in
1708           || mode == ir_var_function_out
1709           || mode == ir_var_function_inout);
1710    assert(name != ir_variable::tmp_name
1711           || mode == ir_var_temporary);
1712    if (mode == ir_var_temporary
1713        && (name == NULL || name == ir_variable::tmp_name)) {
1714       this->name = ir_variable::tmp_name;
1715    } else if (name == NULL ||
1716               strlen(name) < ARRAY_SIZE(this->name_storage)) {
1717       strcpy(this->name_storage, name ? name : "");
1718       this->name = this->name_storage;
1719    } else {
1720       this->name = ralloc_strdup(this, name);
1721    }
1722
1723    this->u.max_ifc_array_access = NULL;
1724
1725    this->data.explicit_location = false;
1726    this->data.has_initializer = false;
1727    this->data.location = -1;
1728    this->data.location_frac = 0;
1729    this->data.binding = 0;
1730    this->data.warn_extension_index = 0;
1731    this->constant_value = NULL;
1732    this->constant_initializer = NULL;
1733    this->data.origin_upper_left = false;
1734    this->data.pixel_center_integer = false;
1735    this->data.depth_layout = ir_depth_layout_none;
1736    this->data.used = false;
1737    this->data.always_active_io = false;
1738    this->data.read_only = false;
1739    this->data.centroid = false;
1740    this->data.sample = false;
1741    this->data.patch = false;
1742    this->data.invariant = false;
1743    this->data.how_declared = ir_var_declared_normally;
1744    this->data.mode = mode;
1745    this->data.interpolation = INTERP_MODE_NONE;
1746    this->data.max_array_access = -1;
1747    this->data.offset = 0;
1748    this->data.precision = GLSL_PRECISION_NONE;
1749    this->data.memory_read_only = false;
1750    this->data.memory_write_only = false;
1751    this->data.memory_coherent = false;
1752    this->data.memory_volatile = false;
1753    this->data.memory_restrict = false;
1754    this->data.from_ssbo_unsized_array = false;
1755    this->data.fb_fetch_output = false;
1756    this->data.bindless = false;
1757    this->data.bound = false;
1758
1759    if (type != NULL) {
1760       if (type->is_interface())
1761          this->init_interface_type(type);
1762       else if (type->without_array()->is_interface())
1763          this->init_interface_type(type->without_array());
1764    }
1765 }
1766
1767
1768 const char *
1769 interpolation_string(unsigned interpolation)
1770 {
1771    switch (interpolation) {
1772    case INTERP_MODE_NONE:          return "no";
1773    case INTERP_MODE_SMOOTH:        return "smooth";
1774    case INTERP_MODE_FLAT:          return "flat";
1775    case INTERP_MODE_NOPERSPECTIVE: return "noperspective";
1776    }
1777
1778    assert(!"Should not get here.");
1779    return "";
1780 }
1781
1782 const char *const ir_variable::warn_extension_table[] = {
1783    "",
1784    "GL_ARB_shader_stencil_export",
1785    "GL_AMD_shader_stencil_export",
1786 };
1787
1788 void
1789 ir_variable::enable_extension_warning(const char *extension)
1790 {
1791    for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {
1792       if (strcmp(warn_extension_table[i], extension) == 0) {
1793          this->data.warn_extension_index = i;
1794          return;
1795       }
1796    }
1797
1798    assert(!"Should not get here.");
1799    this->data.warn_extension_index = 0;
1800 }
1801
1802 const char *
1803 ir_variable::get_extension_warning() const
1804 {
1805    return this->data.warn_extension_index == 0
1806       ? NULL : warn_extension_table[this->data.warn_extension_index];
1807 }
1808
1809 ir_function_signature::ir_function_signature(const glsl_type *return_type,
1810                                              builtin_available_predicate b)
1811    : ir_instruction(ir_type_function_signature),
1812      return_type(return_type), is_defined(false),
1813      intrinsic_id(ir_intrinsic_invalid), builtin_avail(b), _function(NULL)
1814 {
1815    this->origin = NULL;
1816 }
1817
1818
1819 bool
1820 ir_function_signature::is_builtin() const
1821 {
1822    return builtin_avail != NULL;
1823 }
1824
1825
1826 bool
1827 ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const
1828 {
1829    /* We can't call the predicate without a state pointer, so just say that
1830     * the signature is available.  At compile time, we need the filtering,
1831     * but also receive a valid state pointer.  At link time, we're resolving
1832     * imported built-in prototypes to their definitions, which will always
1833     * be an exact match.  So we can skip the filtering.
1834     */
1835    if (state == NULL)
1836       return true;
1837
1838    assert(builtin_avail != NULL);
1839    return builtin_avail(state);
1840 }
1841
1842
1843 static bool
1844 modes_match(unsigned a, unsigned b)
1845 {
1846    if (a == b)
1847       return true;
1848
1849    /* Accept "in" vs. "const in" */
1850    if ((a == ir_var_const_in && b == ir_var_function_in) ||
1851        (b == ir_var_const_in && a == ir_var_function_in))
1852       return true;
1853
1854    return false;
1855 }
1856
1857
1858 const char *
1859 ir_function_signature::qualifiers_match(exec_list *params)
1860 {
1861    /* check that the qualifiers match. */
1862    foreach_two_lists(a_node, &this->parameters, b_node, params) {
1863       ir_variable *a = (ir_variable *) a_node;
1864       ir_variable *b = (ir_variable *) b_node;
1865
1866       if (a->data.read_only != b->data.read_only ||
1867           !modes_match(a->data.mode, b->data.mode) ||
1868           a->data.interpolation != b->data.interpolation ||
1869           a->data.centroid != b->data.centroid ||
1870           a->data.sample != b->data.sample ||
1871           a->data.patch != b->data.patch ||
1872           a->data.memory_read_only != b->data.memory_read_only ||
1873           a->data.memory_write_only != b->data.memory_write_only ||
1874           a->data.memory_coherent != b->data.memory_coherent ||
1875           a->data.memory_volatile != b->data.memory_volatile ||
1876           a->data.memory_restrict != b->data.memory_restrict) {
1877
1878          /* parameter a's qualifiers don't match */
1879          return a->name;
1880       }
1881    }
1882    return NULL;
1883 }
1884
1885
1886 void
1887 ir_function_signature::replace_parameters(exec_list *new_params)
1888 {
1889    /* Destroy all of the previous parameter information.  If the previous
1890     * parameter information comes from the function prototype, it may either
1891     * specify incorrect parameter names or not have names at all.
1892     */
1893    new_params->move_nodes_to(&parameters);
1894 }
1895
1896
1897 ir_function::ir_function(const char *name)
1898    : ir_instruction(ir_type_function)
1899 {
1900    this->subroutine_index = -1;
1901    this->name = ralloc_strdup(this, name);
1902 }
1903
1904
1905 bool
1906 ir_function::has_user_signature()
1907 {
1908    foreach_in_list(ir_function_signature, sig, &this->signatures) {
1909       if (!sig->is_builtin())
1910          return true;
1911    }
1912    return false;
1913 }
1914
1915
1916 ir_rvalue *
1917 ir_rvalue::error_value(void *mem_ctx)
1918 {
1919    ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);
1920
1921    v->type = glsl_type::error_type;
1922    return v;
1923 }
1924
1925
1926 void
1927 visit_exec_list(exec_list *list, ir_visitor *visitor)
1928 {
1929    foreach_in_list_safe(ir_instruction, node, list) {
1930       node->accept(visitor);
1931    }
1932 }
1933
1934
1935 static void
1936 steal_memory(ir_instruction *ir, void *new_ctx)
1937 {
1938    ir_variable *var = ir->as_variable();
1939    ir_function *fn = ir->as_function();
1940    ir_constant *constant = ir->as_constant();
1941    if (var != NULL && var->constant_value != NULL)
1942       steal_memory(var->constant_value, ir);
1943
1944    if (var != NULL && var->constant_initializer != NULL)
1945       steal_memory(var->constant_initializer, ir);
1946
1947    if (fn != NULL && fn->subroutine_types)
1948       ralloc_steal(new_ctx, fn->subroutine_types);
1949
1950    /* The components of aggregate constants are not visited by the normal
1951     * visitor, so steal their values by hand.
1952     */
1953    if (constant != NULL) {
1954       if (constant->type->is_record()) {
1955          foreach_in_list(ir_constant, field, &constant->components) {
1956             steal_memory(field, ir);
1957          }
1958       } else if (constant->type->is_array()) {
1959          for (unsigned int i = 0; i < constant->type->length; i++) {
1960             steal_memory(constant->array_elements[i], ir);
1961          }
1962       }
1963    }
1964
1965    ralloc_steal(new_ctx, ir);
1966 }
1967
1968
1969 void
1970 reparent_ir(exec_list *list, void *mem_ctx)
1971 {
1972    foreach_in_list(ir_instruction, node, list) {
1973       visit_tree(node, steal_memory, mem_ctx);
1974    }
1975 }
1976
1977
1978 static ir_rvalue *
1979 try_min_one(ir_rvalue *ir)
1980 {
1981    ir_expression *expr = ir->as_expression();
1982
1983    if (!expr || expr->operation != ir_binop_min)
1984       return NULL;
1985
1986    if (expr->operands[0]->is_one())
1987       return expr->operands[1];
1988
1989    if (expr->operands[1]->is_one())
1990       return expr->operands[0];
1991
1992    return NULL;
1993 }
1994
1995 static ir_rvalue *
1996 try_max_zero(ir_rvalue *ir)
1997 {
1998    ir_expression *expr = ir->as_expression();
1999
2000    if (!expr || expr->operation != ir_binop_max)
2001       return NULL;
2002
2003    if (expr->operands[0]->is_zero())
2004       return expr->operands[1];
2005
2006    if (expr->operands[1]->is_zero())
2007       return expr->operands[0];
2008
2009    return NULL;
2010 }
2011
2012 ir_rvalue *
2013 ir_rvalue::as_rvalue_to_saturate()
2014 {
2015    ir_expression *expr = this->as_expression();
2016
2017    if (!expr)
2018       return NULL;
2019
2020    ir_rvalue *max_zero = try_max_zero(expr);
2021    if (max_zero) {
2022       return try_min_one(max_zero);
2023    } else {
2024       ir_rvalue *min_one = try_min_one(expr);
2025       if (min_one) {
2026          return try_max_zero(min_one);
2027       }
2028    }
2029
2030    return NULL;
2031 }
2032
2033
2034 unsigned
2035 vertices_per_prim(GLenum prim)
2036 {
2037    switch (prim) {
2038    case GL_POINTS:
2039       return 1;
2040    case GL_LINES:
2041       return 2;
2042    case GL_TRIANGLES:
2043       return 3;
2044    case GL_LINES_ADJACENCY:
2045       return 4;
2046    case GL_TRIANGLES_ADJACENCY:
2047       return 6;
2048    default:
2049       assert(!"Bad primitive");
2050       return 3;
2051    }
2052 }
2053
2054 /**
2055  * Generate a string describing the mode of a variable
2056  */
2057 const char *
2058 mode_string(const ir_variable *var)
2059 {
2060    switch (var->data.mode) {
2061    case ir_var_auto:
2062       return (var->data.read_only) ? "global constant" : "global variable";
2063
2064    case ir_var_uniform:
2065       return "uniform";
2066
2067    case ir_var_shader_storage:
2068       return "buffer";
2069
2070    case ir_var_shader_in:
2071       return "shader input";
2072
2073    case ir_var_shader_out:
2074       return "shader output";
2075
2076    case ir_var_function_in:
2077    case ir_var_const_in:
2078       return "function input";
2079
2080    case ir_var_function_out:
2081       return "function output";
2082
2083    case ir_var_function_inout:
2084       return "function inout";
2085
2086    case ir_var_system_value:
2087       return "shader input";
2088
2089    case ir_var_temporary:
2090       return "compiler temporary";
2091
2092    case ir_var_mode_count:
2093       break;
2094    }
2095
2096    assert(!"Should not get here.");
2097    return "invalid variable";
2098 }