Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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 "ir_visitor.h"
  27. #include "glsl_types.h"
  28.  
  29. ir_rvalue::ir_rvalue()
  30. {
  31.    this->type = glsl_type::error_type;
  32. }
  33.  
  34. bool ir_rvalue::is_zero() const
  35. {
  36.    return false;
  37. }
  38.  
  39. bool ir_rvalue::is_one() const
  40. {
  41.    return false;
  42. }
  43.  
  44. bool ir_rvalue::is_negative_one() const
  45. {
  46.    return false;
  47. }
  48.  
  49. bool ir_rvalue::is_basis() const
  50. {
  51.    return false;
  52. }
  53.  
  54. /**
  55.  * Modify the swizzle make to move one component to another
  56.  *
  57.  * \param m    IR swizzle to be modified
  58.  * \param from Component in the RHS that is to be swizzled
  59.  * \param to   Desired swizzle location of \c from
  60.  */
  61. static void
  62. update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to)
  63. {
  64.    switch (to) {
  65.    case 0: m.x = from; break;
  66.    case 1: m.y = from; break;
  67.    case 2: m.z = from; break;
  68.    case 3: m.w = from; break;
  69.    default: assert(!"Should not get here.");
  70.    }
  71.  
  72.    m.num_components = MAX2(m.num_components, (to + 1));
  73. }
  74.  
  75. void
  76. ir_assignment::set_lhs(ir_rvalue *lhs)
  77. {
  78.    void *mem_ctx = this;
  79.    bool swizzled = false;
  80.  
  81.    while (lhs != NULL) {
  82.       ir_swizzle *swiz = lhs->as_swizzle();
  83.  
  84.       if (swiz == NULL)
  85.          break;
  86.  
  87.       unsigned write_mask = 0;
  88.       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
  89.  
  90.       for (unsigned i = 0; i < swiz->mask.num_components; i++) {
  91.          unsigned c = 0;
  92.  
  93.          switch (i) {
  94.          case 0: c = swiz->mask.x; break;
  95.          case 1: c = swiz->mask.y; break;
  96.          case 2: c = swiz->mask.z; break;
  97.          case 3: c = swiz->mask.w; break;
  98.          default: assert(!"Should not get here.");
  99.          }
  100.  
  101.          write_mask |= (((this->write_mask >> i) & 1) << c);
  102.          update_rhs_swizzle(rhs_swiz, i, c);
  103.       }
  104.  
  105.       this->write_mask = write_mask;
  106.       lhs = swiz->val;
  107.  
  108.       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
  109.       swizzled = true;
  110.    }
  111.  
  112.    if (swizzled) {
  113.       /* Now, RHS channels line up with the LHS writemask.  Collapse it
  114.        * to just the channels that will be written.
  115.        */
  116.       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
  117.       int rhs_chan = 0;
  118.       for (int i = 0; i < 4; i++) {
  119.          if (write_mask & (1 << i))
  120.             update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
  121.       }
  122.       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
  123.    }
  124.  
  125.    assert((lhs == NULL) || lhs->as_dereference());
  126.  
  127.    this->lhs = (ir_dereference *) lhs;
  128. }
  129.  
  130. ir_variable *
  131. ir_assignment::whole_variable_written()
  132. {
  133.    ir_variable *v = this->lhs->whole_variable_referenced();
  134.  
  135.    if (v == NULL)
  136.       return NULL;
  137.  
  138.    if (v->type->is_scalar())
  139.       return v;
  140.  
  141.    if (v->type->is_vector()) {
  142.       const unsigned mask = (1U << v->type->vector_elements) - 1;
  143.  
  144.       if (mask != this->write_mask)
  145.          return NULL;
  146.    }
  147.  
  148.    /* Either all the vector components are assigned or the variable is some
  149.     * composite type (and the whole thing is assigned.
  150.     */
  151.    return v;
  152. }
  153.  
  154. ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs,
  155.                              ir_rvalue *condition, unsigned write_mask)
  156. {
  157.    this->ir_type = ir_type_assignment;
  158.    this->condition = condition;
  159.    this->rhs = rhs;
  160.    this->lhs = lhs;
  161.    this->write_mask = write_mask;
  162.  
  163.    if (lhs->type->is_scalar() || lhs->type->is_vector()) {
  164.       int lhs_components = 0;
  165.       for (int i = 0; i < 4; i++) {
  166.          if (write_mask & (1 << i))
  167.             lhs_components++;
  168.       }
  169.  
  170.       assert(lhs_components == this->rhs->type->vector_elements);
  171.    }
  172. }
  173.  
  174. ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
  175.                              ir_rvalue *condition)
  176. {
  177.    this->ir_type = ir_type_assignment;
  178.    this->condition = condition;
  179.    this->rhs = rhs;
  180.  
  181.    /* If the RHS is a vector type, assume that all components of the vector
  182.     * type are being written to the LHS.  The write mask comes from the RHS
  183.     * because we can have a case where the LHS is a vec4 and the RHS is a
  184.     * vec3.  In that case, the assignment is:
  185.     *
  186.     *     (assign (...) (xyz) (var_ref lhs) (var_ref rhs))
  187.     */
  188.    if (rhs->type->is_vector())
  189.       this->write_mask = (1U << rhs->type->vector_elements) - 1;
  190.    else if (rhs->type->is_scalar())
  191.       this->write_mask = 1;
  192.    else
  193.       this->write_mask = 0;
  194.  
  195.    this->set_lhs(lhs);
  196. }
  197.  
  198. ir_expression::ir_expression(int op, const struct glsl_type *type,
  199.                              ir_rvalue *op0, ir_rvalue *op1,
  200.                              ir_rvalue *op2, ir_rvalue *op3)
  201. {
  202.    this->ir_type = ir_type_expression;
  203.    this->type = type;
  204.    this->operation = ir_expression_operation(op);
  205.    this->operands[0] = op0;
  206.    this->operands[1] = op1;
  207.    this->operands[2] = op2;
  208.    this->operands[3] = op3;
  209. #ifndef NDEBUG
  210.    int num_operands = get_num_operands(this->operation);
  211.    for (int i = num_operands; i < 4; i++) {
  212.       assert(this->operands[i] == NULL);
  213.    }
  214. #endif
  215. }
  216.  
  217. ir_expression::ir_expression(int op, ir_rvalue *op0)
  218. {
  219.    this->ir_type = ir_type_expression;
  220.  
  221.    this->operation = ir_expression_operation(op);
  222.    this->operands[0] = op0;
  223.    this->operands[1] = NULL;
  224.    this->operands[2] = NULL;
  225.    this->operands[3] = NULL;
  226.  
  227.    assert(op <= ir_last_unop);
  228.  
  229.    switch (this->operation) {
  230.    case ir_unop_bit_not:
  231.    case ir_unop_logic_not:
  232.    case ir_unop_neg:
  233.    case ir_unop_abs:
  234.    case ir_unop_sign:
  235.    case ir_unop_rcp:
  236.    case ir_unop_rsq:
  237.    case ir_unop_sqrt:
  238.    case ir_unop_exp:
  239.    case ir_unop_log:
  240.    case ir_unop_exp2:
  241.    case ir_unop_log2:
  242.    case ir_unop_trunc:
  243.    case ir_unop_ceil:
  244.    case ir_unop_floor:
  245.    case ir_unop_fract:
  246.    case ir_unop_round_even:
  247.    case ir_unop_sin:
  248.    case ir_unop_cos:
  249.    case ir_unop_sin_reduced:
  250.    case ir_unop_cos_reduced:
  251.    case ir_unop_dFdx:
  252.    case ir_unop_dFdy:
  253.       this->type = op0->type;
  254.       break;
  255.  
  256.    case ir_unop_f2i:
  257.    case ir_unop_b2i:
  258.    case ir_unop_u2i:
  259.    case ir_unop_bitcast_f2i:
  260.       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
  261.                                            op0->type->vector_elements, 1);
  262.       break;
  263.  
  264.    case ir_unop_b2f:
  265.    case ir_unop_i2f:
  266.    case ir_unop_u2f:
  267.    case ir_unop_bitcast_i2f:
  268.    case ir_unop_bitcast_u2f:
  269.       this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
  270.                                            op0->type->vector_elements, 1);
  271.       break;
  272.  
  273.    case ir_unop_f2b:
  274.    case ir_unop_i2b:
  275.       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
  276.                                            op0->type->vector_elements, 1);
  277.       break;
  278.  
  279.    case ir_unop_i2u:
  280.    case ir_unop_f2u:
  281.    case ir_unop_bitcast_f2u:
  282.       this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
  283.                                            op0->type->vector_elements, 1);
  284.       break;
  285.  
  286.    case ir_unop_noise:
  287.    case ir_unop_unpack_half_2x16_split_x:
  288.    case ir_unop_unpack_half_2x16_split_y:
  289.       this->type = glsl_type::float_type;
  290.       break;
  291.  
  292.    case ir_unop_any:
  293.       this->type = glsl_type::bool_type;
  294.       break;
  295.  
  296.    case ir_unop_pack_snorm_2x16:
  297.    case ir_unop_pack_snorm_4x8:
  298.    case ir_unop_pack_unorm_2x16:
  299.    case ir_unop_pack_unorm_4x8:
  300.    case ir_unop_pack_half_2x16:
  301.       this->type = glsl_type::uint_type;
  302.       break;
  303.  
  304.    case ir_unop_unpack_snorm_2x16:
  305.    case ir_unop_unpack_unorm_2x16:
  306.    case ir_unop_unpack_half_2x16:
  307.       this->type = glsl_type::vec2_type;
  308.       break;
  309.  
  310.    case ir_unop_unpack_snorm_4x8:
  311.    case ir_unop_unpack_unorm_4x8:
  312.       this->type = glsl_type::vec4_type;
  313.       break;
  314.  
  315.    default:
  316.       assert(!"not reached: missing automatic type setup for ir_expression");
  317.       this->type = op0->type;
  318.       break;
  319.    }
  320. }
  321.  
  322. ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
  323. {
  324.    this->ir_type = ir_type_expression;
  325.  
  326.    this->operation = ir_expression_operation(op);
  327.    this->operands[0] = op0;
  328.    this->operands[1] = op1;
  329.    this->operands[2] = NULL;
  330.    this->operands[3] = NULL;
  331.  
  332.    assert(op > ir_last_unop);
  333.  
  334.    switch (this->operation) {
  335.    case ir_binop_all_equal:
  336.    case ir_binop_any_nequal:
  337.       this->type = glsl_type::bool_type;
  338.       break;
  339.  
  340.    case ir_binop_add:
  341.    case ir_binop_sub:
  342.    case ir_binop_min:
  343.    case ir_binop_max:
  344.    case ir_binop_pow:
  345.    case ir_binop_mul:
  346.    case ir_binop_div:
  347.    case ir_binop_mod:
  348.       if (op0->type->is_scalar()) {
  349.          this->type = op1->type;
  350.       } else if (op1->type->is_scalar()) {
  351.          this->type = op0->type;
  352.       } else {
  353.          /* FINISHME: matrix types */
  354.          assert(!op0->type->is_matrix() && !op1->type->is_matrix());
  355.          assert(op0->type == op1->type);
  356.          this->type = op0->type;
  357.       }
  358.       break;
  359.  
  360.    case ir_binop_logic_and:
  361.    case ir_binop_logic_xor:
  362.    case ir_binop_logic_or:
  363.    case ir_binop_bit_and:
  364.    case ir_binop_bit_xor:
  365.    case ir_binop_bit_or:
  366.        assert(!op0->type->is_matrix());
  367.        assert(!op1->type->is_matrix());
  368.       if (op0->type->is_scalar()) {
  369.          this->type = op1->type;
  370.       } else if (op1->type->is_scalar()) {
  371.          this->type = op0->type;
  372.       } else {
  373.           assert(op0->type->vector_elements == op1->type->vector_elements);
  374.           this->type = op0->type;
  375.       }
  376.       break;
  377.  
  378.    case ir_binop_equal:
  379.    case ir_binop_nequal:
  380.    case ir_binop_lequal:
  381.    case ir_binop_gequal:
  382.    case ir_binop_less:
  383.    case ir_binop_greater:
  384.       assert(op0->type == op1->type);
  385.       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
  386.                                            op0->type->vector_elements, 1);
  387.       break;
  388.  
  389.    case ir_binop_dot:
  390.       this->type = glsl_type::float_type;
  391.       break;
  392.  
  393.    case ir_binop_pack_half_2x16_split:
  394.       this->type = glsl_type::uint_type;
  395.       break;
  396.  
  397.    case ir_binop_lshift:
  398.    case ir_binop_rshift:
  399.       this->type = op0->type;
  400.       break;
  401.  
  402.    case ir_binop_vector_extract:
  403.       this->type = op0->type->get_scalar_type();
  404.       break;
  405.  
  406.    default:
  407.       assert(!"not reached: missing automatic type setup for ir_expression");
  408.       this->type = glsl_type::float_type;
  409.    }
  410. }
  411.  
  412. unsigned int
  413. ir_expression::get_num_operands(ir_expression_operation op)
  414. {
  415.    assert(op <= ir_last_opcode);
  416.  
  417.    if (op <= ir_last_unop)
  418.       return 1;
  419.  
  420.    if (op <= ir_last_binop)
  421.       return 2;
  422.  
  423.    if (op <= ir_last_triop)
  424.       return 3;
  425.  
  426.    if (op <= ir_last_quadop)
  427.       return 4;
  428.  
  429.    assert(false);
  430.    return 0;
  431. }
  432.  
  433. static const char *const operator_strs[] = {
  434.    "~",
  435.    "!",
  436.    "neg",
  437.    "abs",
  438.    "sign",
  439.    "rcp",
  440.    "rsq",
  441.    "sqrt",
  442.    "exp",
  443.    "log",
  444.    "exp2",
  445.    "log2",
  446.    "f2i",
  447.    "f2u",
  448.    "i2f",
  449.    "f2b",
  450.    "b2f",
  451.    "i2b",
  452.    "b2i",
  453.    "u2f",
  454.    "i2u",
  455.    "u2i",
  456.    "bitcast_i2f",
  457.    "bitcast_f2i",
  458.    "bitcast_u2f",
  459.    "bitcast_f2u",
  460.    "any",
  461.    "trunc",
  462.    "ceil",
  463.    "floor",
  464.    "fract",
  465.    "round_even",
  466.    "sin",
  467.    "cos",
  468.    "sin_reduced",
  469.    "cos_reduced",
  470.    "dFdx",
  471.    "dFdy",
  472.    "packSnorm2x16",
  473.    "packSnorm4x8",
  474.    "packUnorm2x16",
  475.    "packUnorm4x8",
  476.    "packHalf2x16",
  477.    "unpackSnorm2x16",
  478.    "unpackSnorm4x8",
  479.    "unpackUnorm2x16",
  480.    "unpackUnorm4x8",
  481.    "unpackHalf2x16",
  482.    "unpackHalf2x16_split_x",
  483.    "unpackHalf2x16_split_y",
  484.    "bitfield_reverse",
  485.    "bit_count",
  486.    "find_msb",
  487.    "find_lsb",
  488.    "noise",
  489.    "+",
  490.    "-",
  491.    "*",
  492.    "/",
  493.    "%",
  494.    "<",
  495.    ">",
  496.    "<=",
  497.    ">=",
  498.    "==",
  499.    "!=",
  500.    "all_equal",
  501.    "any_nequal",
  502.    "<<",
  503.    ">>",
  504.    "&",
  505.    "^",
  506.    "|",
  507.    "&&",
  508.    "^^",
  509.    "||",
  510.    "dot",
  511.    "min",
  512.    "max",
  513.    "pow",
  514.    "packHalf2x16_split",
  515.    "bfm",
  516.    "ubo_load",
  517.    "vector_extract",
  518.    "lrp",
  519.    "bfi",
  520.    "bitfield_extract",
  521.    "vector_insert",
  522.    "bitfield_insert",
  523.    "vector",
  524. };
  525.  
  526. const char *ir_expression::operator_string(ir_expression_operation op)
  527. {
  528.    assert((unsigned int) op < Elements(operator_strs));
  529.    assert(Elements(operator_strs) == (ir_quadop_vector + 1));
  530.    return operator_strs[op];
  531. }
  532.  
  533. const char *ir_expression::operator_string()
  534. {
  535.    return operator_string(this->operation);
  536. }
  537.  
  538. const char*
  539. depth_layout_string(ir_depth_layout layout)
  540. {
  541.    switch(layout) {
  542.    case ir_depth_layout_none:      return "";
  543.    case ir_depth_layout_any:       return "depth_any";
  544.    case ir_depth_layout_greater:   return "depth_greater";
  545.    case ir_depth_layout_less:      return "depth_less";
  546.    case ir_depth_layout_unchanged: return "depth_unchanged";
  547.  
  548.    default:
  549.       assert(0);
  550.       return "";
  551.    }
  552. }
  553.  
  554. ir_expression_operation
  555. ir_expression::get_operator(const char *str)
  556. {
  557.    const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
  558.    for (int op = 0; op < operator_count; op++) {
  559.       if (strcmp(str, operator_strs[op]) == 0)
  560.          return (ir_expression_operation) op;
  561.    }
  562.    return (ir_expression_operation) -1;
  563. }
  564.  
  565. ir_constant::ir_constant()
  566. {
  567.    this->ir_type = ir_type_constant;
  568. }
  569.  
  570. ir_constant::ir_constant(const struct glsl_type *type,
  571.                          const ir_constant_data *data)
  572. {
  573.    assert((type->base_type >= GLSL_TYPE_UINT)
  574.           && (type->base_type <= GLSL_TYPE_BOOL));
  575.  
  576.    this->ir_type = ir_type_constant;
  577.    this->type = type;
  578.    memcpy(& this->value, data, sizeof(this->value));
  579. }
  580.  
  581. ir_constant::ir_constant(float f)
  582. {
  583.    this->ir_type = ir_type_constant;
  584.    this->type = glsl_type::float_type;
  585.    this->value.f[0] = f;
  586.    for (int i = 1; i < 16; i++)  {
  587.       this->value.f[i] = 0;
  588.    }
  589. }
  590.  
  591. ir_constant::ir_constant(unsigned int u)
  592. {
  593.    this->ir_type = ir_type_constant;
  594.    this->type = glsl_type::uint_type;
  595.    this->value.u[0] = u;
  596.    for (int i = 1; i < 16; i++) {
  597.       this->value.u[i] = 0;
  598.    }
  599. }
  600.  
  601. ir_constant::ir_constant(int i)
  602. {
  603.    this->ir_type = ir_type_constant;
  604.    this->type = glsl_type::int_type;
  605.    this->value.i[0] = i;
  606.    for (int i = 1; i < 16; i++) {
  607.       this->value.i[i] = 0;
  608.    }
  609. }
  610.  
  611. ir_constant::ir_constant(bool b)
  612. {
  613.    this->ir_type = ir_type_constant;
  614.    this->type = glsl_type::bool_type;
  615.    this->value.b[0] = b;
  616.    for (int i = 1; i < 16; i++) {
  617.       this->value.b[i] = false;
  618.    }
  619. }
  620.  
  621. ir_constant::ir_constant(const ir_constant *c, unsigned i)
  622. {
  623.    this->ir_type = ir_type_constant;
  624.    this->type = c->type->get_base_type();
  625.  
  626.    switch (this->type->base_type) {
  627.    case GLSL_TYPE_UINT:  this->value.u[0] = c->value.u[i]; break;
  628.    case GLSL_TYPE_INT:   this->value.i[0] = c->value.i[i]; break;
  629.    case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
  630.    case GLSL_TYPE_BOOL:  this->value.b[0] = c->value.b[i]; break;
  631.    default:              assert(!"Should not get here."); break;
  632.    }
  633. }
  634.  
  635. ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
  636. {
  637.    this->ir_type = ir_type_constant;
  638.    this->type = type;
  639.  
  640.    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
  641.           || type->is_record() || type->is_array());
  642.  
  643.    if (type->is_array()) {
  644.       this->array_elements = ralloc_array(this, ir_constant *, type->length);
  645.       unsigned i = 0;
  646.       foreach_list(node, value_list) {
  647.          ir_constant *value = (ir_constant *) node;
  648.          assert(value->as_constant() != NULL);
  649.  
  650.          this->array_elements[i++] = value;
  651.       }
  652.       return;
  653.    }
  654.  
  655.    /* If the constant is a record, the types of each of the entries in
  656.     * value_list must be a 1-for-1 match with the structure components.  Each
  657.     * entry must also be a constant.  Just move the nodes from the value_list
  658.     * to the list in the ir_constant.
  659.     */
  660.    /* FINISHME: Should there be some type checking and / or assertions here? */
  661.    /* FINISHME: Should the new constant take ownership of the nodes from
  662.     * FINISHME: value_list, or should it make copies?
  663.     */
  664.    if (type->is_record()) {
  665.       value_list->move_nodes_to(& this->components);
  666.       return;
  667.    }
  668.  
  669.    for (unsigned i = 0; i < 16; i++) {
  670.       this->value.u[i] = 0;
  671.    }
  672.  
  673.    ir_constant *value = (ir_constant *) (value_list->head);
  674.  
  675.    /* Constructors with exactly one scalar argument are special for vectors
  676.     * and matrices.  For vectors, the scalar value is replicated to fill all
  677.     * the components.  For matrices, the scalar fills the components of the
  678.     * diagonal while the rest is filled with 0.
  679.     */
  680.    if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
  681.       if (type->is_matrix()) {
  682.          /* Matrix - fill diagonal (rest is already set to 0) */
  683.          assert(type->base_type == GLSL_TYPE_FLOAT);
  684.          for (unsigned i = 0; i < type->matrix_columns; i++)
  685.             this->value.f[i * type->vector_elements + i] = value->value.f[0];
  686.       } else {
  687.          /* Vector or scalar - fill all components */
  688.          switch (type->base_type) {
  689.          case GLSL_TYPE_UINT:
  690.          case GLSL_TYPE_INT:
  691.             for (unsigned i = 0; i < type->components(); i++)
  692.                this->value.u[i] = value->value.u[0];
  693.             break;
  694.          case GLSL_TYPE_FLOAT:
  695.             for (unsigned i = 0; i < type->components(); i++)
  696.                this->value.f[i] = value->value.f[0];
  697.             break;
  698.          case GLSL_TYPE_BOOL:
  699.             for (unsigned i = 0; i < type->components(); i++)
  700.                this->value.b[i] = value->value.b[0];
  701.             break;
  702.          default:
  703.             assert(!"Should not get here.");
  704.             break;
  705.          }
  706.       }
  707.       return;
  708.    }
  709.  
  710.    if (type->is_matrix() && value->type->is_matrix()) {
  711.       assert(value->next->is_tail_sentinel());
  712.  
  713.       /* From section 5.4.2 of the GLSL 1.20 spec:
  714.        * "If a matrix is constructed from a matrix, then each component
  715.        *  (column i, row j) in the result that has a corresponding component
  716.        *  (column i, row j) in the argument will be initialized from there."
  717.        */
  718.       unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
  719.       unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
  720.       for (unsigned i = 0; i < cols; i++) {
  721.          for (unsigned j = 0; j < rows; j++) {
  722.             const unsigned src = i * value->type->vector_elements + j;
  723.             const unsigned dst = i * type->vector_elements + j;
  724.             this->value.f[dst] = value->value.f[src];
  725.          }
  726.       }
  727.  
  728.       /* "All other components will be initialized to the identity matrix." */
  729.       for (unsigned i = cols; i < type->matrix_columns; i++)
  730.          this->value.f[i * type->vector_elements + i] = 1.0;
  731.  
  732.       return;
  733.    }
  734.  
  735.    /* Use each component from each entry in the value_list to initialize one
  736.     * component of the constant being constructed.
  737.     */
  738.    for (unsigned i = 0; i < type->components(); /* empty */) {
  739.       assert(value->as_constant() != NULL);
  740.       assert(!value->is_tail_sentinel());
  741.  
  742.       for (unsigned j = 0; j < value->type->components(); j++) {
  743.          switch (type->base_type) {
  744.          case GLSL_TYPE_UINT:
  745.             this->value.u[i] = value->get_uint_component(j);
  746.             break;
  747.          case GLSL_TYPE_INT:
  748.             this->value.i[i] = value->get_int_component(j);
  749.             break;
  750.          case GLSL_TYPE_FLOAT:
  751.             this->value.f[i] = value->get_float_component(j);
  752.             break;
  753.          case GLSL_TYPE_BOOL:
  754.             this->value.b[i] = value->get_bool_component(j);
  755.             break;
  756.          default:
  757.             /* FINISHME: What to do?  Exceptions are not the answer.
  758.              */
  759.             break;
  760.          }
  761.  
  762.          i++;
  763.          if (i >= type->components())
  764.             break;
  765.       }
  766.  
  767.       value = (ir_constant *) value->next;
  768.    }
  769. }
  770.  
  771. ir_constant *
  772. ir_constant::zero(void *mem_ctx, const glsl_type *type)
  773. {
  774.    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
  775.           || type->is_record() || type->is_array());
  776.  
  777.    ir_constant *c = new(mem_ctx) ir_constant;
  778.    c->type = type;
  779.    memset(&c->value, 0, sizeof(c->value));
  780.  
  781.    if (type->is_array()) {
  782.       c->array_elements = ralloc_array(c, ir_constant *, type->length);
  783.  
  784.       for (unsigned i = 0; i < type->length; i++)
  785.          c->array_elements[i] = ir_constant::zero(c, type->element_type());
  786.    }
  787.  
  788.    if (type->is_record()) {
  789.       for (unsigned i = 0; i < type->length; i++) {
  790.          ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
  791.          c->components.push_tail(comp);
  792.       }
  793.    }
  794.  
  795.    return c;
  796. }
  797.  
  798. bool
  799. ir_constant::get_bool_component(unsigned i) const
  800. {
  801.    switch (this->type->base_type) {
  802.    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
  803.    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
  804.    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
  805.    case GLSL_TYPE_BOOL:  return this->value.b[i];
  806.    default:              assert(!"Should not get here."); break;
  807.    }
  808.  
  809.    /* Must return something to make the compiler happy.  This is clearly an
  810.     * error case.
  811.     */
  812.    return false;
  813. }
  814.  
  815. float
  816. ir_constant::get_float_component(unsigned i) const
  817. {
  818.    switch (this->type->base_type) {
  819.    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
  820.    case GLSL_TYPE_INT:   return (float) this->value.i[i];
  821.    case GLSL_TYPE_FLOAT: return this->value.f[i];
  822.    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0f : 0.0f;
  823.    default:              assert(!"Should not get here."); break;
  824.    }
  825.  
  826.    /* Must return something to make the compiler happy.  This is clearly an
  827.     * error case.
  828.     */
  829.    return 0.0;
  830. }
  831.  
  832. int
  833. ir_constant::get_int_component(unsigned i) const
  834. {
  835.    switch (this->type->base_type) {
  836.    case GLSL_TYPE_UINT:  return this->value.u[i];
  837.    case GLSL_TYPE_INT:   return this->value.i[i];
  838.    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
  839.    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
  840.    default:              assert(!"Should not get here."); break;
  841.    }
  842.  
  843.    /* Must return something to make the compiler happy.  This is clearly an
  844.     * error case.
  845.     */
  846.    return 0;
  847. }
  848.  
  849. unsigned
  850. ir_constant::get_uint_component(unsigned i) const
  851. {
  852.    switch (this->type->base_type) {
  853.    case GLSL_TYPE_UINT:  return this->value.u[i];
  854.    case GLSL_TYPE_INT:   return this->value.i[i];
  855.    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
  856.    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
  857.    default:              assert(!"Should not get here."); break;
  858.    }
  859.  
  860.    /* Must return something to make the compiler happy.  This is clearly an
  861.     * error case.
  862.     */
  863.    return 0;
  864. }
  865.  
  866. ir_constant *
  867. ir_constant::get_array_element(unsigned i) const
  868. {
  869.    assert(this->type->is_array());
  870.  
  871.    /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
  872.     *
  873.     *     "Behavior is undefined if a shader subscripts an array with an index
  874.     *     less than 0 or greater than or equal to the size the array was
  875.     *     declared with."
  876.     *
  877.     * Most out-of-bounds accesses are removed before things could get this far.
  878.     * There are cases where non-constant array index values can get constant
  879.     * folded.
  880.     */
  881.    if (int(i) < 0)
  882.       i = 0;
  883.    else if (i >= this->type->length)
  884.       i = this->type->length - 1;
  885.  
  886.    return array_elements[i];
  887. }
  888.  
  889. ir_constant *
  890. ir_constant::get_record_field(const char *name)
  891. {
  892.    int idx = this->type->field_index(name);
  893.  
  894.    if (idx < 0)
  895.       return NULL;
  896.  
  897.    if (this->components.is_empty())
  898.       return NULL;
  899.  
  900.    exec_node *node = this->components.head;
  901.    for (int i = 0; i < idx; i++) {
  902.       node = node->next;
  903.  
  904.       /* If the end of the list is encountered before the element matching the
  905.        * requested field is found, return NULL.
  906.        */
  907.       if (node->is_tail_sentinel())
  908.          return NULL;
  909.    }
  910.  
  911.    return (ir_constant *) node;
  912. }
  913.  
  914. void
  915. ir_constant::copy_offset(ir_constant *src, int offset)
  916. {
  917.    switch (this->type->base_type) {
  918.    case GLSL_TYPE_UINT:
  919.    case GLSL_TYPE_INT:
  920.    case GLSL_TYPE_FLOAT:
  921.    case GLSL_TYPE_BOOL: {
  922.       unsigned int size = src->type->components();
  923.       assert (size <= this->type->components() - offset);
  924.       for (unsigned int i=0; i<size; i++) {
  925.          switch (this->type->base_type) {
  926.          case GLSL_TYPE_UINT:
  927.             value.u[i+offset] = src->get_uint_component(i);
  928.             break;
  929.          case GLSL_TYPE_INT:
  930.             value.i[i+offset] = src->get_int_component(i);
  931.             break;
  932.          case GLSL_TYPE_FLOAT:
  933.             value.f[i+offset] = src->get_float_component(i);
  934.             break;
  935.          case GLSL_TYPE_BOOL:
  936.             value.b[i+offset] = src->get_bool_component(i);
  937.             break;
  938.          default: // Shut up the compiler
  939.             break;
  940.          }
  941.       }
  942.       break;
  943.    }
  944.  
  945.    case GLSL_TYPE_STRUCT: {
  946.       assert (src->type == this->type);
  947.       this->components.make_empty();
  948.       foreach_list(node, &src->components) {
  949.          ir_constant *const orig = (ir_constant *) node;
  950.  
  951.          this->components.push_tail(orig->clone(this, NULL));
  952.       }
  953.       break;
  954.    }
  955.  
  956.    case GLSL_TYPE_ARRAY: {
  957.       assert (src->type == this->type);
  958.       for (unsigned i = 0; i < this->type->length; i++) {
  959.          this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
  960.       }
  961.       break;
  962.    }
  963.  
  964.    default:
  965.       assert(!"Should not get here.");
  966.       break;
  967.    }
  968. }
  969.  
  970. void
  971. ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
  972. {
  973.    assert (!type->is_array() && !type->is_record());
  974.  
  975.    if (!type->is_vector() && !type->is_matrix()) {
  976.       offset = 0;
  977.       mask = 1;
  978.    }
  979.  
  980.    int id = 0;
  981.    for (int i=0; i<4; i++) {
  982.       if (mask & (1 << i)) {
  983.          switch (this->type->base_type) {
  984.          case GLSL_TYPE_UINT:
  985.             value.u[i+offset] = src->get_uint_component(id++);
  986.             break;
  987.          case GLSL_TYPE_INT:
  988.             value.i[i+offset] = src->get_int_component(id++);
  989.             break;
  990.          case GLSL_TYPE_FLOAT:
  991.             value.f[i+offset] = src->get_float_component(id++);
  992.             break;
  993.          case GLSL_TYPE_BOOL:
  994.             value.b[i+offset] = src->get_bool_component(id++);
  995.             break;
  996.          default:
  997.             assert(!"Should not get here.");
  998.             return;
  999.          }
  1000.       }
  1001.    }
  1002. }
  1003.  
  1004. bool
  1005. ir_constant::has_value(const ir_constant *c) const
  1006. {
  1007.    if (this->type != c->type)
  1008.       return false;
  1009.  
  1010.    if (this->type->is_array()) {
  1011.       for (unsigned i = 0; i < this->type->length; i++) {
  1012.          if (!this->array_elements[i]->has_value(c->array_elements[i]))
  1013.             return false;
  1014.       }
  1015.       return true;
  1016.    }
  1017.  
  1018.    if (this->type->base_type == GLSL_TYPE_STRUCT) {
  1019.       const exec_node *a_node = this->components.head;
  1020.       const exec_node *b_node = c->components.head;
  1021.  
  1022.       while (!a_node->is_tail_sentinel()) {
  1023.          assert(!b_node->is_tail_sentinel());
  1024.  
  1025.          const ir_constant *const a_field = (ir_constant *) a_node;
  1026.          const ir_constant *const b_field = (ir_constant *) b_node;
  1027.  
  1028.          if (!a_field->has_value(b_field))
  1029.             return false;
  1030.  
  1031.          a_node = a_node->next;
  1032.          b_node = b_node->next;
  1033.       }
  1034.  
  1035.       return true;
  1036.    }
  1037.  
  1038.    for (unsigned i = 0; i < this->type->components(); i++) {
  1039.       switch (this->type->base_type) {
  1040.       case GLSL_TYPE_UINT:
  1041.          if (this->value.u[i] != c->value.u[i])
  1042.             return false;
  1043.          break;
  1044.       case GLSL_TYPE_INT:
  1045.          if (this->value.i[i] != c->value.i[i])
  1046.             return false;
  1047.          break;
  1048.       case GLSL_TYPE_FLOAT:
  1049.          if (this->value.f[i] != c->value.f[i])
  1050.             return false;
  1051.          break;
  1052.       case GLSL_TYPE_BOOL:
  1053.          if (this->value.b[i] != c->value.b[i])
  1054.             return false;
  1055.          break;
  1056.       default:
  1057.          assert(!"Should not get here.");
  1058.          return false;
  1059.       }
  1060.    }
  1061.  
  1062.    return true;
  1063. }
  1064.  
  1065. bool
  1066. ir_constant::is_zero() const
  1067. {
  1068.    if (!this->type->is_scalar() && !this->type->is_vector())
  1069.       return false;
  1070.  
  1071.    for (unsigned c = 0; c < this->type->vector_elements; c++) {
  1072.       switch (this->type->base_type) {
  1073.       case GLSL_TYPE_FLOAT:
  1074.          if (this->value.f[c] != 0.0)
  1075.             return false;
  1076.          break;
  1077.       case GLSL_TYPE_INT:
  1078.          if (this->value.i[c] != 0)
  1079.             return false;
  1080.          break;
  1081.       case GLSL_TYPE_UINT:
  1082.          if (this->value.u[c] != 0)
  1083.             return false;
  1084.          break;
  1085.       case GLSL_TYPE_BOOL:
  1086.          if (this->value.b[c] != false)
  1087.             return false;
  1088.          break;
  1089.       default:
  1090.          /* The only other base types are structures, arrays, and samplers.
  1091.           * Samplers cannot be constants, and the others should have been
  1092.           * filtered out above.
  1093.           */
  1094.          assert(!"Should not get here.");
  1095.          return false;
  1096.       }
  1097.    }
  1098.  
  1099.    return true;
  1100. }
  1101.  
  1102. bool
  1103. ir_constant::is_one() const
  1104. {
  1105.    if (!this->type->is_scalar() && !this->type->is_vector())
  1106.       return false;
  1107.  
  1108.    for (unsigned c = 0; c < this->type->vector_elements; c++) {
  1109.       switch (this->type->base_type) {
  1110.       case GLSL_TYPE_FLOAT:
  1111.          if (this->value.f[c] != 1.0)
  1112.             return false;
  1113.          break;
  1114.       case GLSL_TYPE_INT:
  1115.          if (this->value.i[c] != 1)
  1116.             return false;
  1117.          break;
  1118.       case GLSL_TYPE_UINT:
  1119.          if (this->value.u[c] != 1)
  1120.             return false;
  1121.          break;
  1122.       case GLSL_TYPE_BOOL:
  1123.          if (this->value.b[c] != true)
  1124.             return false;
  1125.          break;
  1126.       default:
  1127.          /* The only other base types are structures, arrays, and samplers.
  1128.           * Samplers cannot be constants, and the others should have been
  1129.           * filtered out above.
  1130.           */
  1131.          assert(!"Should not get here.");
  1132.          return false;
  1133.       }
  1134.    }
  1135.  
  1136.    return true;
  1137. }
  1138.  
  1139. bool
  1140. ir_constant::is_negative_one() const
  1141. {
  1142.    if (!this->type->is_scalar() && !this->type->is_vector())
  1143.       return false;
  1144.  
  1145.    if (this->type->is_boolean())
  1146.       return false;
  1147.  
  1148.    for (unsigned c = 0; c < this->type->vector_elements; c++) {
  1149.       switch (this->type->base_type) {
  1150.       case GLSL_TYPE_FLOAT:
  1151.          if (this->value.f[c] != -1.0)
  1152.             return false;
  1153.          break;
  1154.       case GLSL_TYPE_INT:
  1155.          if (this->value.i[c] != -1)
  1156.             return false;
  1157.          break;
  1158.       case GLSL_TYPE_UINT:
  1159.          if (int(this->value.u[c]) != -1)
  1160.             return false;
  1161.          break;
  1162.       default:
  1163.          /* The only other base types are structures, arrays, samplers, and
  1164.           * booleans.  Samplers cannot be constants, and the others should
  1165.           * have been filtered out above.
  1166.           */
  1167.          assert(!"Should not get here.");
  1168.          return false;
  1169.       }
  1170.    }
  1171.  
  1172.    return true;
  1173. }
  1174.  
  1175. bool
  1176. ir_constant::is_basis() const
  1177. {
  1178.    if (!this->type->is_scalar() && !this->type->is_vector())
  1179.       return false;
  1180.  
  1181.    if (this->type->is_boolean())
  1182.       return false;
  1183.  
  1184.    unsigned ones = 0;
  1185.    for (unsigned c = 0; c < this->type->vector_elements; c++) {
  1186.       switch (this->type->base_type) {
  1187.       case GLSL_TYPE_FLOAT:
  1188.          if (this->value.f[c] == 1.0)
  1189.             ones++;
  1190.          else if (this->value.f[c] != 0.0)
  1191.             return false;
  1192.          break;
  1193.       case GLSL_TYPE_INT:
  1194.          if (this->value.i[c] == 1)
  1195.             ones++;
  1196.          else if (this->value.i[c] != 0)
  1197.             return false;
  1198.          break;
  1199.       case GLSL_TYPE_UINT:
  1200.          if (int(this->value.u[c]) == 1)
  1201.             ones++;
  1202.          else if (int(this->value.u[c]) != 0)
  1203.             return false;
  1204.          break;
  1205.       default:
  1206.          /* The only other base types are structures, arrays, samplers, and
  1207.           * booleans.  Samplers cannot be constants, and the others should
  1208.           * have been filtered out above.
  1209.           */
  1210.          assert(!"Should not get here.");
  1211.          return false;
  1212.       }
  1213.    }
  1214.  
  1215.    return ones == 1;
  1216. }
  1217.  
  1218. ir_loop::ir_loop()
  1219. {
  1220.    this->ir_type = ir_type_loop;
  1221.    this->cmp = ir_unop_neg;
  1222.    this->from = NULL;
  1223.    this->to = NULL;
  1224.    this->increment = NULL;
  1225.    this->counter = NULL;
  1226. }
  1227.  
  1228.  
  1229. ir_dereference_variable::ir_dereference_variable(ir_variable *var)
  1230. {
  1231.    assert(var != NULL);
  1232.  
  1233.    this->ir_type = ir_type_dereference_variable;
  1234.    this->var = var;
  1235.    this->type = var->type;
  1236. }
  1237.  
  1238.  
  1239. ir_dereference_array::ir_dereference_array(ir_rvalue *value,
  1240.                                            ir_rvalue *array_index)
  1241. {
  1242.    this->ir_type = ir_type_dereference_array;
  1243.    this->array_index = array_index;
  1244.    this->set_array(value);
  1245. }
  1246.  
  1247.  
  1248. ir_dereference_array::ir_dereference_array(ir_variable *var,
  1249.                                            ir_rvalue *array_index)
  1250. {
  1251.    void *ctx = ralloc_parent(var);
  1252.  
  1253.    this->ir_type = ir_type_dereference_array;
  1254.    this->array_index = array_index;
  1255.    this->set_array(new(ctx) ir_dereference_variable(var));
  1256. }
  1257.  
  1258.  
  1259. void
  1260. ir_dereference_array::set_array(ir_rvalue *value)
  1261. {
  1262.    assert(value != NULL);
  1263.  
  1264.    this->array = value;
  1265.  
  1266.    const glsl_type *const vt = this->array->type;
  1267.  
  1268.    if (vt->is_array()) {
  1269.       type = vt->element_type();
  1270.    } else if (vt->is_matrix()) {
  1271.       type = vt->column_type();
  1272.    } else if (vt->is_vector()) {
  1273.       type = vt->get_base_type();
  1274.    }
  1275. }
  1276.  
  1277.  
  1278. ir_dereference_record::ir_dereference_record(ir_rvalue *value,
  1279.                                              const char *field)
  1280. {
  1281.    assert(value != NULL);
  1282.  
  1283.    this->ir_type = ir_type_dereference_record;
  1284.    this->record = value;
  1285.    this->field = ralloc_strdup(this, field);
  1286.    this->type = this->record->type->field_type(field);
  1287. }
  1288.  
  1289.  
  1290. ir_dereference_record::ir_dereference_record(ir_variable *var,
  1291.                                              const char *field)
  1292. {
  1293.    void *ctx = ralloc_parent(var);
  1294.  
  1295.    this->ir_type = ir_type_dereference_record;
  1296.    this->record = new(ctx) ir_dereference_variable(var);
  1297.    this->field = ralloc_strdup(this, field);
  1298.    this->type = this->record->type->field_type(field);
  1299. }
  1300.  
  1301. bool
  1302. ir_dereference::is_lvalue() const
  1303. {
  1304.    ir_variable *var = this->variable_referenced();
  1305.  
  1306.    /* Every l-value derference chain eventually ends in a variable.
  1307.     */
  1308.    if ((var == NULL) || var->read_only)
  1309.       return false;
  1310.  
  1311.    /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
  1312.     *
  1313.     *    "Samplers cannot be treated as l-values; hence cannot be used
  1314.     *     as out or inout function parameters, nor can they be
  1315.     *     assigned into."
  1316.     */
  1317.    if (this->type->contains_sampler())
  1318.       return false;
  1319.  
  1320.    return true;
  1321. }
  1322.  
  1323.  
  1324. static const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod" };
  1325.  
  1326. const char *ir_texture::opcode_string()
  1327. {
  1328.    assert((unsigned int) op <=
  1329.           sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
  1330.    return tex_opcode_strs[op];
  1331. }
  1332.  
  1333. ir_texture_opcode
  1334. ir_texture::get_opcode(const char *str)
  1335. {
  1336.    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
  1337.    for (int op = 0; op < count; op++) {
  1338.       if (strcmp(str, tex_opcode_strs[op]) == 0)
  1339.          return (ir_texture_opcode) op;
  1340.    }
  1341.    return (ir_texture_opcode) -1;
  1342. }
  1343.  
  1344.  
  1345. void
  1346. ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
  1347. {
  1348.    assert(sampler != NULL);
  1349.    assert(type != NULL);
  1350.    this->sampler = sampler;
  1351.    this->type = type;
  1352.  
  1353.    if (this->op == ir_txs) {
  1354.       assert(type->base_type == GLSL_TYPE_INT);
  1355.    } else if (this->op == ir_lod) {
  1356.       assert(type->vector_elements == 2);
  1357.       assert(type->base_type == GLSL_TYPE_FLOAT);
  1358.    } else {
  1359.       assert(sampler->type->sampler_type == (int) type->base_type);
  1360.       if (sampler->type->sampler_shadow)
  1361.          assert(type->vector_elements == 4 || type->vector_elements == 1);
  1362.       else
  1363.          assert(type->vector_elements == 4);
  1364.    }
  1365. }
  1366.  
  1367.  
  1368. void
  1369. ir_swizzle::init_mask(const unsigned *comp, unsigned count)
  1370. {
  1371.    assert((count >= 1) && (count <= 4));
  1372.  
  1373.    memset(&this->mask, 0, sizeof(this->mask));
  1374.    this->mask.num_components = count;
  1375.  
  1376.    unsigned dup_mask = 0;
  1377.    switch (count) {
  1378.    case 4:
  1379.       assert(comp[3] <= 3);
  1380.       dup_mask |= (1U << comp[3])
  1381.          & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
  1382.       this->mask.w = comp[3];
  1383.  
  1384.    case 3:
  1385.       assert(comp[2] <= 3);
  1386.       dup_mask |= (1U << comp[2])
  1387.          & ((1U << comp[0]) | (1U << comp[1]));
  1388.       this->mask.z = comp[2];
  1389.  
  1390.    case 2:
  1391.       assert(comp[1] <= 3);
  1392.       dup_mask |= (1U << comp[1])
  1393.          & ((1U << comp[0]));
  1394.       this->mask.y = comp[1];
  1395.  
  1396.    case 1:
  1397.       assert(comp[0] <= 3);
  1398.       this->mask.x = comp[0];
  1399.    }
  1400.  
  1401.    this->mask.has_duplicates = dup_mask != 0;
  1402.  
  1403.    /* Based on the number of elements in the swizzle and the base type
  1404.     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
  1405.     * generate the type of the resulting value.
  1406.     */
  1407.    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
  1408. }
  1409.  
  1410. ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
  1411.                        unsigned w, unsigned count)
  1412.    : val(val)
  1413. {
  1414.    const unsigned components[4] = { x, y, z, w };
  1415.    this->ir_type = ir_type_swizzle;
  1416.    this->init_mask(components, count);
  1417. }
  1418.  
  1419. ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
  1420.                        unsigned count)
  1421.    : val(val)
  1422. {
  1423.    this->ir_type = ir_type_swizzle;
  1424.    this->init_mask(comp, count);
  1425. }
  1426.  
  1427. ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
  1428. {
  1429.    this->ir_type = ir_type_swizzle;
  1430.    this->val = val;
  1431.    this->mask = mask;
  1432.    this->type = glsl_type::get_instance(val->type->base_type,
  1433.                                         mask.num_components, 1);
  1434. }
  1435.  
  1436. #define X 1
  1437. #define R 5
  1438. #define S 9
  1439. #define I 13
  1440.  
  1441. ir_swizzle *
  1442. ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
  1443. {
  1444.    void *ctx = ralloc_parent(val);
  1445.  
  1446.    /* For each possible swizzle character, this table encodes the value in
  1447.     * \c idx_map that represents the 0th element of the vector.  For invalid
  1448.     * swizzle characters (e.g., 'k'), a special value is used that will allow
  1449.     * detection of errors.
  1450.     */
  1451.    static const unsigned char base_idx[26] = {
  1452.    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
  1453.       R, R, I, I, I, I, R, I, I, I, I, I, I,
  1454.    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
  1455.       I, I, S, S, R, S, S, I, I, X, X, X, X
  1456.    };
  1457.  
  1458.    /* Each valid swizzle character has an entry in the previous table.  This
  1459.     * table encodes the base index encoded in the previous table plus the actual
  1460.     * index of the swizzle character.  When processing swizzles, the first
  1461.     * character in the string is indexed in the previous table.  Each character
  1462.     * in the string is indexed in this table, and the value found there has the
  1463.     * value form the first table subtracted.  The result must be on the range
  1464.     * [0,3].
  1465.     *
  1466.     * For example, the string "wzyx" will get X from the first table.  Each of
  1467.     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
  1468.     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
  1469.     *
  1470.     * The string "wzrg" will get X from the first table.  Each of the characters
  1471.     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
  1472.     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
  1473.     * [0,3], the error is detected.
  1474.     */
  1475.    static const unsigned char idx_map[26] = {
  1476.    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
  1477.       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
  1478.    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
  1479.       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
  1480.    };
  1481.  
  1482.    int swiz_idx[4] = { 0, 0, 0, 0 };
  1483.    unsigned i;
  1484.  
  1485.  
  1486.    /* Validate the first character in the swizzle string and look up the base
  1487.     * index value as described above.
  1488.     */
  1489.    if ((str[0] < 'a') || (str[0] > 'z'))
  1490.       return NULL;
  1491.  
  1492.    const unsigned base = base_idx[str[0] - 'a'];
  1493.  
  1494.  
  1495.    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
  1496.       /* Validate the next character, and, as described above, convert it to a
  1497.        * swizzle index.
  1498.        */
  1499.       if ((str[i] < 'a') || (str[i] > 'z'))
  1500.          return NULL;
  1501.  
  1502.       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
  1503.       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
  1504.          return NULL;
  1505.    }
  1506.  
  1507.    if (str[i] != '\0')
  1508.          return NULL;
  1509.  
  1510.    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
  1511.                               swiz_idx[3], i);
  1512. }
  1513.  
  1514. #undef X
  1515. #undef R
  1516. #undef S
  1517. #undef I
  1518.  
  1519. ir_variable *
  1520. ir_swizzle::variable_referenced() const
  1521. {
  1522.    return this->val->variable_referenced();
  1523. }
  1524.  
  1525.  
  1526. ir_variable::ir_variable(const struct glsl_type *type, const char *name,
  1527.                          ir_variable_mode mode)
  1528.    : max_array_access(0), read_only(false), centroid(false), invariant(false),
  1529.      mode(mode), interpolation(INTERP_QUALIFIER_NONE)
  1530. {
  1531.    this->ir_type = ir_type_variable;
  1532.    this->type = type;
  1533.    this->name = ralloc_strdup(this, name);
  1534.    this->explicit_location = false;
  1535.    this->has_initializer = false;
  1536.    this->location = -1;
  1537.    this->location_frac = 0;
  1538.    this->warn_extension = NULL;
  1539.    this->constant_value = NULL;
  1540.    this->constant_initializer = NULL;
  1541.    this->origin_upper_left = false;
  1542.    this->pixel_center_integer = false;
  1543.    this->depth_layout = ir_depth_layout_none;
  1544.    this->used = false;
  1545.  
  1546.    if (type && type->base_type == GLSL_TYPE_SAMPLER)
  1547.       this->read_only = true;
  1548. }
  1549.  
  1550.  
  1551. const char *
  1552. ir_variable::interpolation_string() const
  1553. {
  1554.    switch (this->interpolation) {
  1555.    case INTERP_QUALIFIER_NONE:          return "no";
  1556.    case INTERP_QUALIFIER_SMOOTH:        return "smooth";
  1557.    case INTERP_QUALIFIER_FLAT:          return "flat";
  1558.    case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective";
  1559.    }
  1560.  
  1561.    assert(!"Should not get here.");
  1562.    return "";
  1563. }
  1564.  
  1565.  
  1566. glsl_interp_qualifier
  1567. ir_variable::determine_interpolation_mode(bool flat_shade)
  1568. {
  1569.    if (this->interpolation != INTERP_QUALIFIER_NONE)
  1570.       return (glsl_interp_qualifier) this->interpolation;
  1571.    int location = this->location;
  1572.    bool is_gl_Color =
  1573.       location == VARYING_SLOT_COL0 || location == VARYING_SLOT_COL1;
  1574.    if (flat_shade && is_gl_Color)
  1575.       return INTERP_QUALIFIER_FLAT;
  1576.    else
  1577.       return INTERP_QUALIFIER_SMOOTH;
  1578. }
  1579.  
  1580.  
  1581. ir_function_signature::ir_function_signature(const glsl_type *return_type)
  1582.    : return_type(return_type), is_defined(false), _function(NULL)
  1583. {
  1584.    this->ir_type = ir_type_function_signature;
  1585.    this->is_builtin = false;
  1586.    this->origin = NULL;
  1587. }
  1588.  
  1589.  
  1590. static bool
  1591. modes_match(unsigned a, unsigned b)
  1592. {
  1593.    if (a == b)
  1594.       return true;
  1595.  
  1596.    /* Accept "in" vs. "const in" */
  1597.    if ((a == ir_var_const_in && b == ir_var_function_in) ||
  1598.        (b == ir_var_const_in && a == ir_var_function_in))
  1599.       return true;
  1600.  
  1601.    return false;
  1602. }
  1603.  
  1604.  
  1605. const char *
  1606. ir_function_signature::qualifiers_match(exec_list *params)
  1607. {
  1608.    exec_list_iterator iter_a = parameters.iterator();
  1609.    exec_list_iterator iter_b = params->iterator();
  1610.  
  1611.    /* check that the qualifiers match. */
  1612.    while (iter_a.has_next()) {
  1613.       ir_variable *a = (ir_variable *)iter_a.get();
  1614.       ir_variable *b = (ir_variable *)iter_b.get();
  1615.  
  1616.       if (a->read_only != b->read_only ||
  1617.           !modes_match(a->mode, b->mode) ||
  1618.           a->interpolation != b->interpolation ||
  1619.           a->centroid != b->centroid) {
  1620.  
  1621.          /* parameter a's qualifiers don't match */
  1622.          return a->name;
  1623.       }
  1624.  
  1625.       iter_a.next();
  1626.       iter_b.next();
  1627.    }
  1628.    return NULL;
  1629. }
  1630.  
  1631.  
  1632. void
  1633. ir_function_signature::replace_parameters(exec_list *new_params)
  1634. {
  1635.    /* Destroy all of the previous parameter information.  If the previous
  1636.     * parameter information comes from the function prototype, it may either
  1637.     * specify incorrect parameter names or not have names at all.
  1638.     */
  1639.    foreach_iter(exec_list_iterator, iter, parameters) {
  1640.       assert(((ir_instruction *) iter.get())->as_variable() != NULL);
  1641.  
  1642.       iter.remove();
  1643.    }
  1644.  
  1645.    new_params->move_nodes_to(&parameters);
  1646. }
  1647.  
  1648.  
  1649. ir_function::ir_function(const char *name)
  1650. {
  1651.    this->ir_type = ir_type_function;
  1652.    this->name = ralloc_strdup(this, name);
  1653. }
  1654.  
  1655.  
  1656. bool
  1657. ir_function::has_user_signature()
  1658. {
  1659.    foreach_list(n, &this->signatures) {
  1660.       ir_function_signature *const sig = (ir_function_signature *) n;
  1661.       if (!sig->is_builtin)
  1662.          return true;
  1663.    }
  1664.    return false;
  1665. }
  1666.  
  1667.  
  1668. ir_rvalue *
  1669. ir_rvalue::error_value(void *mem_ctx)
  1670. {
  1671.    ir_rvalue *v = new(mem_ctx) ir_rvalue;
  1672.  
  1673.    v->type = glsl_type::error_type;
  1674.    return v;
  1675. }
  1676.  
  1677.  
  1678. void
  1679. visit_exec_list(exec_list *list, ir_visitor *visitor)
  1680. {
  1681.    foreach_iter(exec_list_iterator, iter, *list) {
  1682.       ((ir_instruction *)iter.get())->accept(visitor);
  1683.    }
  1684. }
  1685.  
  1686.  
  1687. static void
  1688. steal_memory(ir_instruction *ir, void *new_ctx)
  1689. {
  1690.    ir_variable *var = ir->as_variable();
  1691.    ir_constant *constant = ir->as_constant();
  1692.    if (var != NULL && var->constant_value != NULL)
  1693.       steal_memory(var->constant_value, ir);
  1694.  
  1695.    if (var != NULL && var->constant_initializer != NULL)
  1696.       steal_memory(var->constant_initializer, ir);
  1697.  
  1698.    /* The components of aggregate constants are not visited by the normal
  1699.     * visitor, so steal their values by hand.
  1700.     */
  1701.    if (constant != NULL) {
  1702.       if (constant->type->is_record()) {
  1703.          foreach_iter(exec_list_iterator, iter, constant->components) {
  1704.             ir_constant *field = (ir_constant *)iter.get();
  1705.             steal_memory(field, ir);
  1706.          }
  1707.       } else if (constant->type->is_array()) {
  1708.          for (unsigned int i = 0; i < constant->type->length; i++) {
  1709.             steal_memory(constant->array_elements[i], ir);
  1710.          }
  1711.       }
  1712.    }
  1713.  
  1714.    ralloc_steal(new_ctx, ir);
  1715. }
  1716.  
  1717.  
  1718. void
  1719. reparent_ir(exec_list *list, void *mem_ctx)
  1720. {
  1721.    foreach_list(node, list) {
  1722.       visit_tree((ir_instruction *) node, steal_memory, mem_ctx);
  1723.    }
  1724. }
  1725.  
  1726.  
  1727. static ir_rvalue *
  1728. try_min_one(ir_rvalue *ir)
  1729. {
  1730.    ir_expression *expr = ir->as_expression();
  1731.  
  1732.    if (!expr || expr->operation != ir_binop_min)
  1733.       return NULL;
  1734.  
  1735.    if (expr->operands[0]->is_one())
  1736.       return expr->operands[1];
  1737.  
  1738.    if (expr->operands[1]->is_one())
  1739.       return expr->operands[0];
  1740.  
  1741.    return NULL;
  1742. }
  1743.  
  1744. static ir_rvalue *
  1745. try_max_zero(ir_rvalue *ir)
  1746. {
  1747.    ir_expression *expr = ir->as_expression();
  1748.  
  1749.    if (!expr || expr->operation != ir_binop_max)
  1750.       return NULL;
  1751.  
  1752.    if (expr->operands[0]->is_zero())
  1753.       return expr->operands[1];
  1754.  
  1755.    if (expr->operands[1]->is_zero())
  1756.       return expr->operands[0];
  1757.  
  1758.    return NULL;
  1759. }
  1760.  
  1761. ir_rvalue *
  1762. ir_rvalue::as_rvalue_to_saturate()
  1763. {
  1764.    ir_expression *expr = this->as_expression();
  1765.  
  1766.    if (!expr)
  1767.       return NULL;
  1768.  
  1769.    ir_rvalue *max_zero = try_max_zero(expr);
  1770.    if (max_zero) {
  1771.       return try_min_one(max_zero);
  1772.    } else {
  1773.       ir_rvalue *min_one = try_min_one(expr);
  1774.       if (min_one) {
  1775.          return try_max_zero(min_one);
  1776.       }
  1777.    }
  1778.  
  1779.    return NULL;
  1780. }
  1781.