Subversion Repositories Kolibri OS

Rev

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