• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2010 Intel Corporation
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  */
23 #include <string.h>
24 #include "main/core.h" /* for MAX2 */
25 #include "ir.h"
26 #include "compiler/glsl_types.h"
27 
ir_rvalue(enum ir_node_type t)28 ir_rvalue::ir_rvalue(enum ir_node_type t)
29    : ir_instruction(t)
30 {
31    this->type = glsl_type::error_type;
32 }
33 
is_zero() const34 bool ir_rvalue::is_zero() const
35 {
36    return false;
37 }
38 
is_one() const39 bool ir_rvalue::is_one() const
40 {
41    return false;
42 }
43 
is_negative_one() const44 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
update_rhs_swizzle(ir_swizzle_mask & m,unsigned from,unsigned to)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 
68 void
set_lhs(ir_rvalue * lhs)69 ir_assignment::set_lhs(ir_rvalue *lhs)
70 {
71    void *mem_ctx = this;
72    bool swizzled = false;
73 
74    while (lhs != NULL) {
75       ir_swizzle *swiz = lhs->as_swizzle();
76 
77       if (swiz == NULL)
78 	 break;
79 
80       unsigned write_mask = 0;
81       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
82 
83       for (unsigned i = 0; i < swiz->mask.num_components; i++) {
84 	 unsigned c = 0;
85 
86 	 switch (i) {
87 	 case 0: c = swiz->mask.x; break;
88 	 case 1: c = swiz->mask.y; break;
89 	 case 2: c = swiz->mask.z; break;
90 	 case 3: c = swiz->mask.w; break;
91 	 default: assert(!"Should not get here.");
92 	 }
93 
94 	 write_mask |= (((this->write_mask >> i) & 1) << c);
95 	 update_rhs_swizzle(rhs_swiz, i, c);
96          rhs_swiz.num_components = swiz->val->type->vector_elements;
97       }
98 
99       this->write_mask = write_mask;
100       lhs = swiz->val;
101 
102       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
103       swizzled = true;
104    }
105 
106    if (swizzled) {
107       /* Now, RHS channels line up with the LHS writemask.  Collapse it
108        * to just the channels that will be written.
109        */
110       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
111       int rhs_chan = 0;
112       for (int i = 0; i < 4; i++) {
113 	 if (write_mask & (1 << i))
114 	    update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
115       }
116       rhs_swiz.num_components = rhs_chan;
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 *
whole_variable_written()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 
ir_assignment(ir_dereference * lhs,ir_rvalue * rhs,ir_rvalue * condition,unsigned write_mask)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 
ir_assignment(ir_rvalue * lhs,ir_rvalue * rhs,ir_rvalue * condition)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 
ir_expression(int op,const struct glsl_type * type,ir_rvalue * op0,ir_rvalue * op1,ir_rvalue * op2,ir_rvalue * op3)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 
ir_expression(int op,ir_rvalue * op0)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    case ir_unop_subroutine_to_int:
264       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
265 					   op0->type->vector_elements, 1);
266       break;
267 
268    case ir_unop_b2f:
269    case ir_unop_i2f:
270    case ir_unop_u2f:
271    case ir_unop_d2f:
272    case ir_unop_bitcast_i2f:
273    case ir_unop_bitcast_u2f:
274       this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
275 					   op0->type->vector_elements, 1);
276       break;
277 
278    case ir_unop_f2b:
279    case ir_unop_i2b:
280    case ir_unop_d2b:
281       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
282 					   op0->type->vector_elements, 1);
283       break;
284 
285    case ir_unop_f2d:
286    case ir_unop_i2d:
287    case ir_unop_u2d:
288       this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE,
289 					   op0->type->vector_elements, 1);
290       break;
291 
292    case ir_unop_i2u:
293    case ir_unop_f2u:
294    case ir_unop_d2u:
295    case ir_unop_bitcast_f2u:
296       this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
297 					   op0->type->vector_elements, 1);
298       break;
299 
300    case ir_unop_noise:
301       this->type = glsl_type::float_type;
302       break;
303 
304    case ir_unop_unpack_double_2x32:
305       this->type = glsl_type::uvec2_type;
306       break;
307 
308    case ir_unop_pack_snorm_2x16:
309    case ir_unop_pack_snorm_4x8:
310    case ir_unop_pack_unorm_2x16:
311    case ir_unop_pack_unorm_4x8:
312    case ir_unop_pack_half_2x16:
313       this->type = glsl_type::uint_type;
314       break;
315 
316    case ir_unop_pack_double_2x32:
317       this->type = glsl_type::double_type;
318       break;
319 
320    case ir_unop_unpack_snorm_2x16:
321    case ir_unop_unpack_unorm_2x16:
322    case ir_unop_unpack_half_2x16:
323       this->type = glsl_type::vec2_type;
324       break;
325 
326    case ir_unop_unpack_snorm_4x8:
327    case ir_unop_unpack_unorm_4x8:
328       this->type = glsl_type::vec4_type;
329       break;
330 
331    case ir_unop_frexp_sig:
332       this->type = op0->type;
333       break;
334    case ir_unop_frexp_exp:
335       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
336 					   op0->type->vector_elements, 1);
337       break;
338 
339    case ir_unop_get_buffer_size:
340    case ir_unop_ssbo_unsized_array_length:
341       this->type = glsl_type::int_type;
342       break;
343 
344    case ir_unop_vote_any:
345    case ir_unop_vote_all:
346    case ir_unop_vote_eq:
347       this->type = glsl_type::bool_type;
348       break;
349 
350    default:
351       assert(!"not reached: missing automatic type setup for ir_expression");
352       this->type = op0->type;
353       break;
354    }
355 }
356 
ir_expression(int op,ir_rvalue * op0,ir_rvalue * op1)357 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
358    : ir_rvalue(ir_type_expression)
359 {
360    this->operation = ir_expression_operation(op);
361    this->operands[0] = op0;
362    this->operands[1] = op1;
363    this->operands[2] = NULL;
364    this->operands[3] = NULL;
365 
366    assert(op > ir_last_unop);
367 
368    switch (this->operation) {
369    case ir_binop_all_equal:
370    case ir_binop_any_nequal:
371       this->type = glsl_type::bool_type;
372       break;
373 
374    case ir_binop_add:
375    case ir_binop_sub:
376    case ir_binop_min:
377    case ir_binop_max:
378    case ir_binop_pow:
379    case ir_binop_mul:
380    case ir_binop_div:
381    case ir_binop_mod:
382       if (op0->type->is_scalar()) {
383 	 this->type = op1->type;
384       } else if (op1->type->is_scalar()) {
385 	 this->type = op0->type;
386       } else {
387          if (this->operation == ir_binop_mul) {
388             this->type = glsl_type::get_mul_type(op0->type, op1->type);
389          } else {
390             assert(op0->type == op1->type);
391             this->type = op0->type;
392          }
393       }
394       break;
395 
396    case ir_binop_logic_and:
397    case ir_binop_logic_xor:
398    case ir_binop_logic_or:
399    case ir_binop_bit_and:
400    case ir_binop_bit_xor:
401    case ir_binop_bit_or:
402        assert(!op0->type->is_matrix());
403        assert(!op1->type->is_matrix());
404       if (op0->type->is_scalar()) {
405          this->type = op1->type;
406       } else if (op1->type->is_scalar()) {
407          this->type = op0->type;
408       } else {
409           assert(op0->type->vector_elements == op1->type->vector_elements);
410           this->type = op0->type;
411       }
412       break;
413 
414    case ir_binop_equal:
415    case ir_binop_nequal:
416    case ir_binop_lequal:
417    case ir_binop_gequal:
418    case ir_binop_less:
419    case ir_binop_greater:
420       assert(op0->type == op1->type);
421       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
422 					   op0->type->vector_elements, 1);
423       break;
424 
425    case ir_binop_dot:
426       this->type = op0->type->get_base_type();
427       break;
428 
429    case ir_binop_imul_high:
430    case ir_binop_carry:
431    case ir_binop_borrow:
432    case ir_binop_lshift:
433    case ir_binop_rshift:
434    case ir_binop_ldexp:
435    case ir_binop_interpolate_at_offset:
436    case ir_binop_interpolate_at_sample:
437       this->type = op0->type;
438       break;
439 
440    case ir_binop_vector_extract:
441       this->type = op0->type->get_scalar_type();
442       break;
443 
444    default:
445       assert(!"not reached: missing automatic type setup for ir_expression");
446       this->type = glsl_type::float_type;
447    }
448 }
449 
ir_expression(int op,ir_rvalue * op0,ir_rvalue * op1,ir_rvalue * op2)450 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1,
451                              ir_rvalue *op2)
452    : ir_rvalue(ir_type_expression)
453 {
454    this->operation = ir_expression_operation(op);
455    this->operands[0] = op0;
456    this->operands[1] = op1;
457    this->operands[2] = op2;
458    this->operands[3] = NULL;
459 
460    assert(op > ir_last_binop && op <= ir_last_triop);
461 
462    switch (this->operation) {
463    case ir_triop_fma:
464    case ir_triop_lrp:
465    case ir_triop_bitfield_extract:
466    case ir_triop_vector_insert:
467       this->type = op0->type;
468       break;
469 
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
get_num_operands(ir_expression_operation op)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 #include "ir_expression_operation_strings.h"
502 
503 const char*
depth_layout_string(ir_depth_layout layout)504 depth_layout_string(ir_depth_layout layout)
505 {
506    switch(layout) {
507    case ir_depth_layout_none:      return "";
508    case ir_depth_layout_any:       return "depth_any";
509    case ir_depth_layout_greater:   return "depth_greater";
510    case ir_depth_layout_less:      return "depth_less";
511    case ir_depth_layout_unchanged: return "depth_unchanged";
512 
513    default:
514       assert(0);
515       return "";
516    }
517 }
518 
519 ir_expression_operation
get_operator(const char * str)520 ir_expression::get_operator(const char *str)
521 {
522    for (int op = 0; op <= int(ir_last_opcode); op++) {
523       if (strcmp(str, ir_expression_operation_strings[op]) == 0)
524 	 return (ir_expression_operation) op;
525    }
526    return (ir_expression_operation) -1;
527 }
528 
529 ir_variable *
variable_referenced() const530 ir_expression::variable_referenced() const
531 {
532    switch (operation) {
533       case ir_binop_vector_extract:
534       case ir_triop_vector_insert:
535          /* We get these for things like a[0] where a is a vector type. In these
536           * cases we want variable_referenced() to return the actual vector
537           * variable this is wrapping.
538           */
539          return operands[0]->variable_referenced();
540       default:
541          return ir_rvalue::variable_referenced();
542    }
543 }
544 
ir_constant()545 ir_constant::ir_constant()
546    : ir_rvalue(ir_type_constant)
547 {
548    this->array_elements = NULL;
549 }
550 
ir_constant(const struct glsl_type * type,const ir_constant_data * data)551 ir_constant::ir_constant(const struct glsl_type *type,
552 			 const ir_constant_data *data)
553    : ir_rvalue(ir_type_constant)
554 {
555    this->array_elements = NULL;
556 
557    assert((type->base_type >= GLSL_TYPE_UINT)
558 	  && (type->base_type <= GLSL_TYPE_BOOL));
559 
560    this->type = type;
561    memcpy(& this->value, data, sizeof(this->value));
562 }
563 
ir_constant(float f,unsigned vector_elements)564 ir_constant::ir_constant(float f, unsigned vector_elements)
565    : ir_rvalue(ir_type_constant)
566 {
567    assert(vector_elements <= 4);
568    this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT, vector_elements, 1);
569    for (unsigned i = 0; i < vector_elements; i++) {
570       this->value.f[i] = f;
571    }
572    for (unsigned i = vector_elements; i < 16; i++)  {
573       this->value.f[i] = 0;
574    }
575 }
576 
ir_constant(double d,unsigned vector_elements)577 ir_constant::ir_constant(double d, unsigned vector_elements)
578    : ir_rvalue(ir_type_constant)
579 {
580    assert(vector_elements <= 4);
581    this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE, vector_elements, 1);
582    for (unsigned i = 0; i < vector_elements; i++) {
583       this->value.d[i] = d;
584    }
585    for (unsigned i = vector_elements; i < 16; i++)  {
586       this->value.d[i] = 0.0;
587    }
588 }
589 
ir_constant(unsigned int u,unsigned vector_elements)590 ir_constant::ir_constant(unsigned int u, unsigned vector_elements)
591    : ir_rvalue(ir_type_constant)
592 {
593    assert(vector_elements <= 4);
594    this->type = glsl_type::get_instance(GLSL_TYPE_UINT, vector_elements, 1);
595    for (unsigned i = 0; i < vector_elements; i++) {
596       this->value.u[i] = u;
597    }
598    for (unsigned i = vector_elements; i < 16; i++) {
599       this->value.u[i] = 0;
600    }
601 }
602 
ir_constant(int integer,unsigned vector_elements)603 ir_constant::ir_constant(int integer, unsigned vector_elements)
604    : ir_rvalue(ir_type_constant)
605 {
606    assert(vector_elements <= 4);
607    this->type = glsl_type::get_instance(GLSL_TYPE_INT, vector_elements, 1);
608    for (unsigned i = 0; i < vector_elements; i++) {
609       this->value.i[i] = integer;
610    }
611    for (unsigned i = vector_elements; i < 16; i++) {
612       this->value.i[i] = 0;
613    }
614 }
615 
ir_constant(bool b,unsigned vector_elements)616 ir_constant::ir_constant(bool b, unsigned vector_elements)
617    : ir_rvalue(ir_type_constant)
618 {
619    assert(vector_elements <= 4);
620    this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, vector_elements, 1);
621    for (unsigned i = 0; i < vector_elements; i++) {
622       this->value.b[i] = b;
623    }
624    for (unsigned i = vector_elements; i < 16; i++) {
625       this->value.b[i] = false;
626    }
627 }
628 
ir_constant(const ir_constant * c,unsigned i)629 ir_constant::ir_constant(const ir_constant *c, unsigned i)
630    : ir_rvalue(ir_type_constant)
631 {
632    this->array_elements = NULL;
633    this->type = c->type->get_base_type();
634 
635    switch (this->type->base_type) {
636    case GLSL_TYPE_UINT:  this->value.u[0] = c->value.u[i]; break;
637    case GLSL_TYPE_INT:   this->value.i[0] = c->value.i[i]; break;
638    case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
639    case GLSL_TYPE_BOOL:  this->value.b[0] = c->value.b[i]; break;
640    case GLSL_TYPE_DOUBLE: this->value.d[0] = c->value.d[i]; break;
641    default:              assert(!"Should not get here."); break;
642    }
643 }
644 
ir_constant(const struct glsl_type * type,exec_list * value_list)645 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
646    : ir_rvalue(ir_type_constant)
647 {
648    this->array_elements = NULL;
649    this->type = type;
650 
651    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
652 	  || type->is_record() || type->is_array());
653 
654    if (type->is_array()) {
655       this->array_elements = ralloc_array(this, ir_constant *, type->length);
656       unsigned i = 0;
657       foreach_in_list(ir_constant, value, value_list) {
658 	 assert(value->as_constant() != NULL);
659 
660 	 this->array_elements[i++] = value;
661       }
662       return;
663    }
664 
665    /* If the constant is a record, the types of each of the entries in
666     * value_list must be a 1-for-1 match with the structure components.  Each
667     * entry must also be a constant.  Just move the nodes from the value_list
668     * to the list in the ir_constant.
669     */
670    /* FINISHME: Should there be some type checking and / or assertions here? */
671    /* FINISHME: Should the new constant take ownership of the nodes from
672     * FINISHME: value_list, or should it make copies?
673     */
674    if (type->is_record()) {
675       value_list->move_nodes_to(& this->components);
676       return;
677    }
678 
679    for (unsigned i = 0; i < 16; i++) {
680       this->value.u[i] = 0;
681    }
682 
683    ir_constant *value = (ir_constant *) (value_list->get_head_raw());
684 
685    /* Constructors with exactly one scalar argument are special for vectors
686     * and matrices.  For vectors, the scalar value is replicated to fill all
687     * the components.  For matrices, the scalar fills the components of the
688     * diagonal while the rest is filled with 0.
689     */
690    if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
691       if (type->is_matrix()) {
692 	 /* Matrix - fill diagonal (rest is already set to 0) */
693          assert(type->base_type == GLSL_TYPE_FLOAT ||
694                 type->base_type == GLSL_TYPE_DOUBLE);
695          for (unsigned i = 0; i < type->matrix_columns; i++) {
696             if (type->base_type == GLSL_TYPE_FLOAT)
697                this->value.f[i * type->vector_elements + i] =
698                   value->value.f[0];
699             else
700                this->value.d[i * type->vector_elements + i] =
701                   value->value.d[0];
702          }
703       } else {
704 	 /* Vector or scalar - fill all components */
705 	 switch (type->base_type) {
706 	 case GLSL_TYPE_UINT:
707 	 case GLSL_TYPE_INT:
708 	    for (unsigned i = 0; i < type->components(); i++)
709 	       this->value.u[i] = value->value.u[0];
710 	    break;
711 	 case GLSL_TYPE_FLOAT:
712 	    for (unsigned i = 0; i < type->components(); i++)
713 	       this->value.f[i] = value->value.f[0];
714 	    break;
715 	 case GLSL_TYPE_DOUBLE:
716 	    for (unsigned i = 0; i < type->components(); i++)
717 	       this->value.d[i] = value->value.d[0];
718 	    break;
719 	 case GLSL_TYPE_BOOL:
720 	    for (unsigned i = 0; i < type->components(); i++)
721 	       this->value.b[i] = value->value.b[0];
722 	    break;
723 	 default:
724 	    assert(!"Should not get here.");
725 	    break;
726 	 }
727       }
728       return;
729    }
730 
731    if (type->is_matrix() && value->type->is_matrix()) {
732       assert(value->next->is_tail_sentinel());
733 
734       /* From section 5.4.2 of the GLSL 1.20 spec:
735        * "If a matrix is constructed from a matrix, then each component
736        *  (column i, row j) in the result that has a corresponding component
737        *  (column i, row j) in the argument will be initialized from there."
738        */
739       unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
740       unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
741       for (unsigned i = 0; i < cols; i++) {
742 	 for (unsigned j = 0; j < rows; j++) {
743 	    const unsigned src = i * value->type->vector_elements + j;
744 	    const unsigned dst = i * type->vector_elements + j;
745 	    this->value.f[dst] = value->value.f[src];
746 	 }
747       }
748 
749       /* "All other components will be initialized to the identity matrix." */
750       for (unsigned i = cols; i < type->matrix_columns; i++)
751 	 this->value.f[i * type->vector_elements + i] = 1.0;
752 
753       return;
754    }
755 
756    /* Use each component from each entry in the value_list to initialize one
757     * component of the constant being constructed.
758     */
759    unsigned i = 0;
760    for (;;) {
761       assert(value->as_constant() != NULL);
762       assert(!value->is_tail_sentinel());
763 
764       for (unsigned j = 0; j < value->type->components(); j++) {
765 	 switch (type->base_type) {
766 	 case GLSL_TYPE_UINT:
767 	    this->value.u[i] = value->get_uint_component(j);
768 	    break;
769 	 case GLSL_TYPE_INT:
770 	    this->value.i[i] = value->get_int_component(j);
771 	    break;
772 	 case GLSL_TYPE_FLOAT:
773 	    this->value.f[i] = value->get_float_component(j);
774 	    break;
775 	 case GLSL_TYPE_BOOL:
776 	    this->value.b[i] = value->get_bool_component(j);
777 	    break;
778 	 case GLSL_TYPE_DOUBLE:
779 	    this->value.d[i] = value->get_double_component(j);
780 	    break;
781 	 default:
782 	    /* FINISHME: What to do?  Exceptions are not the answer.
783 	     */
784 	    break;
785 	 }
786 
787 	 i++;
788 	 if (i >= type->components())
789 	    break;
790       }
791 
792       if (i >= type->components())
793 	 break; /* avoid downcasting a list sentinel */
794       value = (ir_constant *) value->next;
795    }
796 }
797 
798 ir_constant *
zero(void * mem_ctx,const glsl_type * type)799 ir_constant::zero(void *mem_ctx, const glsl_type *type)
800 {
801    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
802 	  || type->is_record() || type->is_array());
803 
804    ir_constant *c = new(mem_ctx) ir_constant;
805    c->type = type;
806    memset(&c->value, 0, sizeof(c->value));
807 
808    if (type->is_array()) {
809       c->array_elements = ralloc_array(c, ir_constant *, type->length);
810 
811       for (unsigned i = 0; i < type->length; i++)
812 	 c->array_elements[i] = ir_constant::zero(c, type->fields.array);
813    }
814 
815    if (type->is_record()) {
816       for (unsigned i = 0; i < type->length; i++) {
817 	 ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
818 	 c->components.push_tail(comp);
819       }
820    }
821 
822    return c;
823 }
824 
825 bool
get_bool_component(unsigned i) const826 ir_constant::get_bool_component(unsigned i) const
827 {
828    switch (this->type->base_type) {
829    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
830    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
831    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
832    case GLSL_TYPE_BOOL:  return this->value.b[i];
833    case GLSL_TYPE_DOUBLE: return this->value.d[i] != 0.0;
834    default:              assert(!"Should not get here."); break;
835    }
836 
837    /* Must return something to make the compiler happy.  This is clearly an
838     * error case.
839     */
840    return false;
841 }
842 
843 float
get_float_component(unsigned i) const844 ir_constant::get_float_component(unsigned i) const
845 {
846    switch (this->type->base_type) {
847    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
848    case GLSL_TYPE_INT:   return (float) this->value.i[i];
849    case GLSL_TYPE_FLOAT: return this->value.f[i];
850    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0f : 0.0f;
851    case GLSL_TYPE_DOUBLE: return (float) this->value.d[i];
852    default:              assert(!"Should not get here."); break;
853    }
854 
855    /* Must return something to make the compiler happy.  This is clearly an
856     * error case.
857     */
858    return 0.0;
859 }
860 
861 double
get_double_component(unsigned i) const862 ir_constant::get_double_component(unsigned i) const
863 {
864    switch (this->type->base_type) {
865    case GLSL_TYPE_UINT:  return (double) this->value.u[i];
866    case GLSL_TYPE_INT:   return (double) this->value.i[i];
867    case GLSL_TYPE_FLOAT: return (double) this->value.f[i];
868    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0 : 0.0;
869    case GLSL_TYPE_DOUBLE: return this->value.d[i];
870    default:              assert(!"Should not get here."); break;
871    }
872 
873    /* Must return something to make the compiler happy.  This is clearly an
874     * error case.
875     */
876    return 0.0;
877 }
878 
879 int
get_int_component(unsigned i) const880 ir_constant::get_int_component(unsigned i) const
881 {
882    switch (this->type->base_type) {
883    case GLSL_TYPE_UINT:  return this->value.u[i];
884    case GLSL_TYPE_INT:   return this->value.i[i];
885    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
886    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
887    case GLSL_TYPE_DOUBLE: return (int) this->value.d[i];
888    default:              assert(!"Should not get here."); break;
889    }
890 
891    /* Must return something to make the compiler happy.  This is clearly an
892     * error case.
893     */
894    return 0;
895 }
896 
897 unsigned
get_uint_component(unsigned i) const898 ir_constant::get_uint_component(unsigned i) const
899 {
900    switch (this->type->base_type) {
901    case GLSL_TYPE_UINT:  return this->value.u[i];
902    case GLSL_TYPE_INT:   return this->value.i[i];
903    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
904    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
905    case GLSL_TYPE_DOUBLE: return (unsigned) this->value.d[i];
906    default:              assert(!"Should not get here."); break;
907    }
908 
909    /* Must return something to make the compiler happy.  This is clearly an
910     * error case.
911     */
912    return 0;
913 }
914 
915 ir_constant *
get_array_element(unsigned i) const916 ir_constant::get_array_element(unsigned i) const
917 {
918    assert(this->type->is_array());
919 
920    /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
921     *
922     *     "Behavior is undefined if a shader subscripts an array with an index
923     *     less than 0 or greater than or equal to the size the array was
924     *     declared with."
925     *
926     * Most out-of-bounds accesses are removed before things could get this far.
927     * There are cases where non-constant array index values can get constant
928     * folded.
929     */
930    if (int(i) < 0)
931       i = 0;
932    else if (i >= this->type->length)
933       i = this->type->length - 1;
934 
935    return array_elements[i];
936 }
937 
938 ir_constant *
get_record_field(const char * name)939 ir_constant::get_record_field(const char *name)
940 {
941    int idx = this->type->field_index(name);
942 
943    if (idx < 0)
944       return NULL;
945 
946    if (this->components.is_empty())
947       return NULL;
948 
949    exec_node *node = this->components.get_head_raw();
950    for (int i = 0; i < idx; i++) {
951       node = node->next;
952 
953       /* If the end of the list is encountered before the element matching the
954        * requested field is found, return NULL.
955        */
956       if (node->is_tail_sentinel())
957 	 return NULL;
958    }
959 
960    return (ir_constant *) node;
961 }
962 
963 void
copy_offset(ir_constant * src,int offset)964 ir_constant::copy_offset(ir_constant *src, int offset)
965 {
966    switch (this->type->base_type) {
967    case GLSL_TYPE_UINT:
968    case GLSL_TYPE_INT:
969    case GLSL_TYPE_FLOAT:
970    case GLSL_TYPE_DOUBLE:
971    case GLSL_TYPE_BOOL: {
972       unsigned int size = src->type->components();
973       assert (size <= this->type->components() - offset);
974       for (unsigned int i=0; i<size; i++) {
975 	 switch (this->type->base_type) {
976 	 case GLSL_TYPE_UINT:
977 	    value.u[i+offset] = src->get_uint_component(i);
978 	    break;
979 	 case GLSL_TYPE_INT:
980 	    value.i[i+offset] = src->get_int_component(i);
981 	    break;
982 	 case GLSL_TYPE_FLOAT:
983 	    value.f[i+offset] = src->get_float_component(i);
984 	    break;
985 	 case GLSL_TYPE_BOOL:
986 	    value.b[i+offset] = src->get_bool_component(i);
987 	    break;
988 	 case GLSL_TYPE_DOUBLE:
989 	    value.d[i+offset] = src->get_double_component(i);
990 	    break;
991 	 default: // Shut up the compiler
992 	    break;
993 	 }
994       }
995       break;
996    }
997 
998    case GLSL_TYPE_STRUCT: {
999       assert (src->type == this->type);
1000       this->components.make_empty();
1001       foreach_in_list(ir_constant, orig, &src->components) {
1002 	 this->components.push_tail(orig->clone(this, NULL));
1003       }
1004       break;
1005    }
1006 
1007    case GLSL_TYPE_ARRAY: {
1008       assert (src->type == this->type);
1009       for (unsigned i = 0; i < this->type->length; i++) {
1010 	 this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
1011       }
1012       break;
1013    }
1014 
1015    default:
1016       assert(!"Should not get here.");
1017       break;
1018    }
1019 }
1020 
1021 void
copy_masked_offset(ir_constant * src,int offset,unsigned int mask)1022 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
1023 {
1024    assert (!type->is_array() && !type->is_record());
1025 
1026    if (!type->is_vector() && !type->is_matrix()) {
1027       offset = 0;
1028       mask = 1;
1029    }
1030 
1031    int id = 0;
1032    for (int i=0; i<4; i++) {
1033       if (mask & (1 << i)) {
1034 	 switch (this->type->base_type) {
1035 	 case GLSL_TYPE_UINT:
1036 	    value.u[i+offset] = src->get_uint_component(id++);
1037 	    break;
1038 	 case GLSL_TYPE_INT:
1039 	    value.i[i+offset] = src->get_int_component(id++);
1040 	    break;
1041 	 case GLSL_TYPE_FLOAT:
1042 	    value.f[i+offset] = src->get_float_component(id++);
1043 	    break;
1044 	 case GLSL_TYPE_BOOL:
1045 	    value.b[i+offset] = src->get_bool_component(id++);
1046 	    break;
1047 	 case GLSL_TYPE_DOUBLE:
1048 	    value.d[i+offset] = src->get_double_component(id++);
1049 	    break;
1050 	 default:
1051 	    assert(!"Should not get here.");
1052 	    return;
1053 	 }
1054       }
1055    }
1056 }
1057 
1058 bool
has_value(const ir_constant * c) const1059 ir_constant::has_value(const ir_constant *c) const
1060 {
1061    if (this->type != c->type)
1062       return false;
1063 
1064    if (this->type->is_array()) {
1065       for (unsigned i = 0; i < this->type->length; i++) {
1066 	 if (!this->array_elements[i]->has_value(c->array_elements[i]))
1067 	    return false;
1068       }
1069       return true;
1070    }
1071 
1072    if (this->type->base_type == GLSL_TYPE_STRUCT) {
1073       const exec_node *a_node = this->components.get_head_raw();
1074       const exec_node *b_node = c->components.get_head_raw();
1075 
1076       while (!a_node->is_tail_sentinel()) {
1077 	 assert(!b_node->is_tail_sentinel());
1078 
1079 	 const ir_constant *const a_field = (ir_constant *) a_node;
1080 	 const ir_constant *const b_field = (ir_constant *) b_node;
1081 
1082 	 if (!a_field->has_value(b_field))
1083 	    return false;
1084 
1085 	 a_node = a_node->next;
1086 	 b_node = b_node->next;
1087       }
1088 
1089       return true;
1090    }
1091 
1092    for (unsigned i = 0; i < this->type->components(); i++) {
1093       switch (this->type->base_type) {
1094       case GLSL_TYPE_UINT:
1095 	 if (this->value.u[i] != c->value.u[i])
1096 	    return false;
1097 	 break;
1098       case GLSL_TYPE_INT:
1099 	 if (this->value.i[i] != c->value.i[i])
1100 	    return false;
1101 	 break;
1102       case GLSL_TYPE_FLOAT:
1103 	 if (this->value.f[i] != c->value.f[i])
1104 	    return false;
1105 	 break;
1106       case GLSL_TYPE_BOOL:
1107 	 if (this->value.b[i] != c->value.b[i])
1108 	    return false;
1109 	 break;
1110       case GLSL_TYPE_DOUBLE:
1111 	 if (this->value.d[i] != c->value.d[i])
1112 	    return false;
1113 	 break;
1114       default:
1115 	 assert(!"Should not get here.");
1116 	 return false;
1117       }
1118    }
1119 
1120    return true;
1121 }
1122 
1123 bool
is_value(float f,int i) const1124 ir_constant::is_value(float f, int i) const
1125 {
1126    if (!this->type->is_scalar() && !this->type->is_vector())
1127       return false;
1128 
1129    /* Only accept boolean values for 0/1. */
1130    if (int(bool(i)) != i && this->type->is_boolean())
1131       return false;
1132 
1133    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1134       switch (this->type->base_type) {
1135       case GLSL_TYPE_FLOAT:
1136 	 if (this->value.f[c] != f)
1137 	    return false;
1138 	 break;
1139       case GLSL_TYPE_INT:
1140 	 if (this->value.i[c] != i)
1141 	    return false;
1142 	 break;
1143       case GLSL_TYPE_UINT:
1144 	 if (this->value.u[c] != unsigned(i))
1145 	    return false;
1146 	 break;
1147       case GLSL_TYPE_BOOL:
1148 	 if (this->value.b[c] != bool(i))
1149 	    return false;
1150 	 break;
1151       case GLSL_TYPE_DOUBLE:
1152 	 if (this->value.d[c] != double(f))
1153 	    return false;
1154 	 break;
1155       default:
1156 	 /* The only other base types are structures, arrays, and samplers.
1157 	  * Samplers cannot be constants, and the others should have been
1158 	  * filtered out above.
1159 	  */
1160 	 assert(!"Should not get here.");
1161 	 return false;
1162       }
1163    }
1164 
1165    return true;
1166 }
1167 
1168 bool
is_zero() const1169 ir_constant::is_zero() const
1170 {
1171    return is_value(0.0, 0);
1172 }
1173 
1174 bool
is_one() const1175 ir_constant::is_one() const
1176 {
1177    return is_value(1.0, 1);
1178 }
1179 
1180 bool
is_negative_one() const1181 ir_constant::is_negative_one() const
1182 {
1183    return is_value(-1.0, -1);
1184 }
1185 
1186 bool
is_uint16_constant() const1187 ir_constant::is_uint16_constant() const
1188 {
1189    if (!type->is_integer())
1190       return false;
1191 
1192    return value.u[0] < (1 << 16);
1193 }
1194 
ir_loop()1195 ir_loop::ir_loop()
1196    : ir_instruction(ir_type_loop)
1197 {
1198 }
1199 
1200 
ir_dereference_variable(ir_variable * var)1201 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1202    : ir_dereference(ir_type_dereference_variable)
1203 {
1204    assert(var != NULL);
1205 
1206    this->var = var;
1207    this->type = var->type;
1208 }
1209 
1210 
ir_dereference_array(ir_rvalue * value,ir_rvalue * array_index)1211 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1212 					   ir_rvalue *array_index)
1213    : ir_dereference(ir_type_dereference_array)
1214 {
1215    this->array_index = array_index;
1216    this->set_array(value);
1217 }
1218 
1219 
ir_dereference_array(ir_variable * var,ir_rvalue * array_index)1220 ir_dereference_array::ir_dereference_array(ir_variable *var,
1221 					   ir_rvalue *array_index)
1222    : ir_dereference(ir_type_dereference_array)
1223 {
1224    void *ctx = ralloc_parent(var);
1225 
1226    this->array_index = array_index;
1227    this->set_array(new(ctx) ir_dereference_variable(var));
1228 }
1229 
1230 
1231 void
set_array(ir_rvalue * value)1232 ir_dereference_array::set_array(ir_rvalue *value)
1233 {
1234    assert(value != NULL);
1235 
1236    this->array = value;
1237 
1238    const glsl_type *const vt = this->array->type;
1239 
1240    if (vt->is_array()) {
1241       type = vt->fields.array;
1242    } else if (vt->is_matrix()) {
1243       type = vt->column_type();
1244    } else if (vt->is_vector()) {
1245       type = vt->get_base_type();
1246    }
1247 }
1248 
1249 
ir_dereference_record(ir_rvalue * value,const char * field)1250 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1251 					     const char *field)
1252    : ir_dereference(ir_type_dereference_record)
1253 {
1254    assert(value != NULL);
1255 
1256    this->record = value;
1257    this->field = ralloc_strdup(this, field);
1258    this->type = this->record->type->field_type(field);
1259 }
1260 
1261 
ir_dereference_record(ir_variable * var,const char * field)1262 ir_dereference_record::ir_dereference_record(ir_variable *var,
1263 					     const char *field)
1264    : ir_dereference(ir_type_dereference_record)
1265 {
1266    void *ctx = ralloc_parent(var);
1267 
1268    this->record = new(ctx) ir_dereference_variable(var);
1269    this->field = ralloc_strdup(this, field);
1270    this->type = this->record->type->field_type(field);
1271 }
1272 
1273 bool
is_lvalue() const1274 ir_dereference::is_lvalue() const
1275 {
1276    ir_variable *var = this->variable_referenced();
1277 
1278    /* Every l-value derference chain eventually ends in a variable.
1279     */
1280    if ((var == NULL) || var->data.read_only)
1281       return false;
1282 
1283    /* From section 4.1.7 of the GLSL 4.40 spec:
1284     *
1285     *   "Opaque variables cannot be treated as l-values; hence cannot
1286     *    be used as out or inout function parameters, nor can they be
1287     *    assigned into."
1288     */
1289    if (this->type->contains_opaque())
1290       return false;
1291 
1292    return true;
1293 }
1294 
1295 
1296 static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels", "texture_samples", "samples_identical" };
1297 
opcode_string()1298 const char *ir_texture::opcode_string()
1299 {
1300    assert((unsigned int) op < ARRAY_SIZE(tex_opcode_strs));
1301    return tex_opcode_strs[op];
1302 }
1303 
1304 ir_texture_opcode
get_opcode(const char * str)1305 ir_texture::get_opcode(const char *str)
1306 {
1307    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1308    for (int op = 0; op < count; op++) {
1309       if (strcmp(str, tex_opcode_strs[op]) == 0)
1310 	 return (ir_texture_opcode) op;
1311    }
1312    return (ir_texture_opcode) -1;
1313 }
1314 
1315 
1316 void
set_sampler(ir_dereference * sampler,const glsl_type * type)1317 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1318 {
1319    assert(sampler != NULL);
1320    assert(type != NULL);
1321    this->sampler = sampler;
1322    this->type = type;
1323 
1324    if (this->op == ir_txs || this->op == ir_query_levels ||
1325        this->op == ir_texture_samples) {
1326       assert(type->base_type == GLSL_TYPE_INT);
1327    } else if (this->op == ir_lod) {
1328       assert(type->vector_elements == 2);
1329       assert(type->base_type == GLSL_TYPE_FLOAT);
1330    } else if (this->op == ir_samples_identical) {
1331       assert(type == glsl_type::bool_type);
1332       assert(sampler->type->base_type == GLSL_TYPE_SAMPLER);
1333       assert(sampler->type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS);
1334    } else {
1335       assert(sampler->type->sampled_type == (int) type->base_type);
1336       if (sampler->type->sampler_shadow)
1337 	 assert(type->vector_elements == 4 || type->vector_elements == 1);
1338       else
1339 	 assert(type->vector_elements == 4);
1340    }
1341 }
1342 
1343 
1344 void
init_mask(const unsigned * comp,unsigned count)1345 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1346 {
1347    assert((count >= 1) && (count <= 4));
1348 
1349    memset(&this->mask, 0, sizeof(this->mask));
1350    this->mask.num_components = count;
1351 
1352    unsigned dup_mask = 0;
1353    switch (count) {
1354    case 4:
1355       assert(comp[3] <= 3);
1356       dup_mask |= (1U << comp[3])
1357 	 & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1358       this->mask.w = comp[3];
1359 
1360    case 3:
1361       assert(comp[2] <= 3);
1362       dup_mask |= (1U << comp[2])
1363 	 & ((1U << comp[0]) | (1U << comp[1]));
1364       this->mask.z = comp[2];
1365 
1366    case 2:
1367       assert(comp[1] <= 3);
1368       dup_mask |= (1U << comp[1])
1369 	 & ((1U << comp[0]));
1370       this->mask.y = comp[1];
1371 
1372    case 1:
1373       assert(comp[0] <= 3);
1374       this->mask.x = comp[0];
1375    }
1376 
1377    this->mask.has_duplicates = dup_mask != 0;
1378 
1379    /* Based on the number of elements in the swizzle and the base type
1380     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1381     * generate the type of the resulting value.
1382     */
1383    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1384 }
1385 
ir_swizzle(ir_rvalue * val,unsigned x,unsigned y,unsigned z,unsigned w,unsigned count)1386 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1387 		       unsigned w, unsigned count)
1388    : ir_rvalue(ir_type_swizzle), val(val)
1389 {
1390    const unsigned components[4] = { x, y, z, w };
1391    this->init_mask(components, count);
1392 }
1393 
ir_swizzle(ir_rvalue * val,const unsigned * comp,unsigned count)1394 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1395 		       unsigned count)
1396    : ir_rvalue(ir_type_swizzle), val(val)
1397 {
1398    this->init_mask(comp, count);
1399 }
1400 
ir_swizzle(ir_rvalue * val,ir_swizzle_mask mask)1401 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1402    : ir_rvalue(ir_type_swizzle)
1403 {
1404    this->val = val;
1405    this->mask = mask;
1406    this->type = glsl_type::get_instance(val->type->base_type,
1407 					mask.num_components, 1);
1408 }
1409 
1410 #define X 1
1411 #define R 5
1412 #define S 9
1413 #define I 13
1414 
1415 ir_swizzle *
create(ir_rvalue * val,const char * str,unsigned vector_length)1416 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1417 {
1418    void *ctx = ralloc_parent(val);
1419 
1420    /* For each possible swizzle character, this table encodes the value in
1421     * \c idx_map that represents the 0th element of the vector.  For invalid
1422     * swizzle characters (e.g., 'k'), a special value is used that will allow
1423     * detection of errors.
1424     */
1425    static const unsigned char base_idx[26] = {
1426    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
1427       R, R, I, I, I, I, R, I, I, I, I, I, I,
1428    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
1429       I, I, S, S, R, S, S, I, I, X, X, X, X
1430    };
1431 
1432    /* Each valid swizzle character has an entry in the previous table.  This
1433     * table encodes the base index encoded in the previous table plus the actual
1434     * index of the swizzle character.  When processing swizzles, the first
1435     * character in the string is indexed in the previous table.  Each character
1436     * in the string is indexed in this table, and the value found there has the
1437     * value form the first table subtracted.  The result must be on the range
1438     * [0,3].
1439     *
1440     * For example, the string "wzyx" will get X from the first table.  Each of
1441     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
1442     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1443     *
1444     * The string "wzrg" will get X from the first table.  Each of the characters
1445     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
1446     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
1447     * [0,3], the error is detected.
1448     */
1449    static const unsigned char idx_map[26] = {
1450    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
1451       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
1452    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
1453       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
1454    };
1455 
1456    int swiz_idx[4] = { 0, 0, 0, 0 };
1457    unsigned i;
1458 
1459 
1460    /* Validate the first character in the swizzle string and look up the base
1461     * index value as described above.
1462     */
1463    if ((str[0] < 'a') || (str[0] > 'z'))
1464       return NULL;
1465 
1466    const unsigned base = base_idx[str[0] - 'a'];
1467 
1468 
1469    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1470       /* Validate the next character, and, as described above, convert it to a
1471        * swizzle index.
1472        */
1473       if ((str[i] < 'a') || (str[i] > 'z'))
1474 	 return NULL;
1475 
1476       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1477       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1478 	 return NULL;
1479    }
1480 
1481    if (str[i] != '\0')
1482 	 return NULL;
1483 
1484    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1485 			      swiz_idx[3], i);
1486 }
1487 
1488 #undef X
1489 #undef R
1490 #undef S
1491 #undef I
1492 
1493 ir_variable *
variable_referenced() const1494 ir_swizzle::variable_referenced() const
1495 {
1496    return this->val->variable_referenced();
1497 }
1498 
1499 
1500 bool ir_variable::temporaries_allocate_names = false;
1501 
1502 const char ir_variable::tmp_name[] = "compiler_temp";
1503 
ir_variable(const struct glsl_type * type,const char * name,ir_variable_mode mode)1504 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1505 			 ir_variable_mode mode)
1506    : ir_instruction(ir_type_variable)
1507 {
1508    this->type = type;
1509 
1510    if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)
1511       name = NULL;
1512 
1513    /* The ir_variable clone method may call this constructor with name set to
1514     * tmp_name.
1515     */
1516    assert(name != NULL
1517           || mode == ir_var_temporary
1518           || mode == ir_var_function_in
1519           || mode == ir_var_function_out
1520           || mode == ir_var_function_inout);
1521    assert(name != ir_variable::tmp_name
1522           || mode == ir_var_temporary);
1523    if (mode == ir_var_temporary
1524        && (name == NULL || name == ir_variable::tmp_name)) {
1525       this->name = ir_variable::tmp_name;
1526    } else if (name == NULL ||
1527               strlen(name) < ARRAY_SIZE(this->name_storage)) {
1528       strcpy(this->name_storage, name ? name : "");
1529       this->name = this->name_storage;
1530    } else {
1531       this->name = ralloc_strdup(this, name);
1532    }
1533 
1534    this->u.max_ifc_array_access = NULL;
1535 
1536    this->data.explicit_location = false;
1537    this->data.has_initializer = false;
1538    this->data.location = -1;
1539    this->data.location_frac = 0;
1540    this->data.binding = 0;
1541    this->data.warn_extension_index = 0;
1542    this->constant_value = NULL;
1543    this->constant_initializer = NULL;
1544    this->data.origin_upper_left = false;
1545    this->data.pixel_center_integer = false;
1546    this->data.depth_layout = ir_depth_layout_none;
1547    this->data.used = false;
1548    this->data.always_active_io = false;
1549    this->data.read_only = false;
1550    this->data.centroid = false;
1551    this->data.sample = false;
1552    this->data.patch = false;
1553    this->data.invariant = false;
1554    this->data.how_declared = ir_var_declared_normally;
1555    this->data.mode = mode;
1556    this->data.interpolation = INTERP_MODE_NONE;
1557    this->data.max_array_access = -1;
1558    this->data.offset = 0;
1559    this->data.precision = GLSL_PRECISION_NONE;
1560    this->data.image_read_only = false;
1561    this->data.image_write_only = false;
1562    this->data.image_coherent = false;
1563    this->data.image_volatile = false;
1564    this->data.image_restrict = false;
1565    this->data.from_ssbo_unsized_array = false;
1566    this->data.fb_fetch_output = false;
1567 
1568    if (type != NULL) {
1569       if (type->base_type == GLSL_TYPE_SAMPLER)
1570          this->data.read_only = true;
1571 
1572       if (type->is_interface())
1573          this->init_interface_type(type);
1574       else if (type->without_array()->is_interface())
1575          this->init_interface_type(type->without_array());
1576    }
1577 }
1578 
1579 
1580 const char *
interpolation_string(unsigned interpolation)1581 interpolation_string(unsigned interpolation)
1582 {
1583    switch (interpolation) {
1584    case INTERP_MODE_NONE:          return "no";
1585    case INTERP_MODE_SMOOTH:        return "smooth";
1586    case INTERP_MODE_FLAT:          return "flat";
1587    case INTERP_MODE_NOPERSPECTIVE: return "noperspective";
1588    }
1589 
1590    assert(!"Should not get here.");
1591    return "";
1592 }
1593 
1594 const char *const ir_variable::warn_extension_table[] = {
1595    "",
1596    "GL_ARB_shader_stencil_export",
1597    "GL_AMD_shader_stencil_export",
1598 };
1599 
1600 void
enable_extension_warning(const char * extension)1601 ir_variable::enable_extension_warning(const char *extension)
1602 {
1603    for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {
1604       if (strcmp(warn_extension_table[i], extension) == 0) {
1605          this->data.warn_extension_index = i;
1606          return;
1607       }
1608    }
1609 
1610    assert(!"Should not get here.");
1611    this->data.warn_extension_index = 0;
1612 }
1613 
1614 const char *
get_extension_warning() const1615 ir_variable::get_extension_warning() const
1616 {
1617    return this->data.warn_extension_index == 0
1618       ? NULL : warn_extension_table[this->data.warn_extension_index];
1619 }
1620 
ir_function_signature(const glsl_type * return_type,builtin_available_predicate b)1621 ir_function_signature::ir_function_signature(const glsl_type *return_type,
1622                                              builtin_available_predicate b)
1623    : ir_instruction(ir_type_function_signature),
1624      return_type(return_type), is_defined(false),
1625      intrinsic_id(ir_intrinsic_invalid), builtin_avail(b), _function(NULL)
1626 {
1627    this->origin = NULL;
1628 }
1629 
1630 
1631 bool
is_builtin() const1632 ir_function_signature::is_builtin() const
1633 {
1634    return builtin_avail != NULL;
1635 }
1636 
1637 
1638 bool
is_builtin_available(const _mesa_glsl_parse_state * state) const1639 ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const
1640 {
1641    /* We can't call the predicate without a state pointer, so just say that
1642     * the signature is available.  At compile time, we need the filtering,
1643     * but also receive a valid state pointer.  At link time, we're resolving
1644     * imported built-in prototypes to their definitions, which will always
1645     * be an exact match.  So we can skip the filtering.
1646     */
1647    if (state == NULL)
1648       return true;
1649 
1650    assert(builtin_avail != NULL);
1651    return builtin_avail(state);
1652 }
1653 
1654 
1655 static bool
modes_match(unsigned a,unsigned b)1656 modes_match(unsigned a, unsigned b)
1657 {
1658    if (a == b)
1659       return true;
1660 
1661    /* Accept "in" vs. "const in" */
1662    if ((a == ir_var_const_in && b == ir_var_function_in) ||
1663        (b == ir_var_const_in && a == ir_var_function_in))
1664       return true;
1665 
1666    return false;
1667 }
1668 
1669 
1670 const char *
qualifiers_match(exec_list * params)1671 ir_function_signature::qualifiers_match(exec_list *params)
1672 {
1673    /* check that the qualifiers match. */
1674    foreach_two_lists(a_node, &this->parameters, b_node, params) {
1675       ir_variable *a = (ir_variable *) a_node;
1676       ir_variable *b = (ir_variable *) b_node;
1677 
1678       if (a->data.read_only != b->data.read_only ||
1679 	  !modes_match(a->data.mode, b->data.mode) ||
1680 	  a->data.interpolation != b->data.interpolation ||
1681 	  a->data.centroid != b->data.centroid ||
1682           a->data.sample != b->data.sample ||
1683           a->data.patch != b->data.patch ||
1684           a->data.image_read_only != b->data.image_read_only ||
1685           a->data.image_write_only != b->data.image_write_only ||
1686           a->data.image_coherent != b->data.image_coherent ||
1687           a->data.image_volatile != b->data.image_volatile ||
1688           a->data.image_restrict != b->data.image_restrict) {
1689 
1690 	 /* parameter a's qualifiers don't match */
1691 	 return a->name;
1692       }
1693    }
1694    return NULL;
1695 }
1696 
1697 
1698 void
replace_parameters(exec_list * new_params)1699 ir_function_signature::replace_parameters(exec_list *new_params)
1700 {
1701    /* Destroy all of the previous parameter information.  If the previous
1702     * parameter information comes from the function prototype, it may either
1703     * specify incorrect parameter names or not have names at all.
1704     */
1705    new_params->move_nodes_to(&parameters);
1706 }
1707 
1708 
ir_function(const char * name)1709 ir_function::ir_function(const char *name)
1710    : ir_instruction(ir_type_function)
1711 {
1712    this->subroutine_index = -1;
1713    this->name = ralloc_strdup(this, name);
1714 }
1715 
1716 
1717 bool
has_user_signature()1718 ir_function::has_user_signature()
1719 {
1720    foreach_in_list(ir_function_signature, sig, &this->signatures) {
1721       if (!sig->is_builtin())
1722 	 return true;
1723    }
1724    return false;
1725 }
1726 
1727 
1728 ir_rvalue *
error_value(void * mem_ctx)1729 ir_rvalue::error_value(void *mem_ctx)
1730 {
1731    ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);
1732 
1733    v->type = glsl_type::error_type;
1734    return v;
1735 }
1736 
1737 
1738 void
visit_exec_list(exec_list * list,ir_visitor * visitor)1739 visit_exec_list(exec_list *list, ir_visitor *visitor)
1740 {
1741    foreach_in_list_safe(ir_instruction, node, list) {
1742       node->accept(visitor);
1743    }
1744 }
1745 
1746 
1747 static void
steal_memory(ir_instruction * ir,void * new_ctx)1748 steal_memory(ir_instruction *ir, void *new_ctx)
1749 {
1750    ir_variable *var = ir->as_variable();
1751    ir_function *fn = ir->as_function();
1752    ir_constant *constant = ir->as_constant();
1753    if (var != NULL && var->constant_value != NULL)
1754       steal_memory(var->constant_value, ir);
1755 
1756    if (var != NULL && var->constant_initializer != NULL)
1757       steal_memory(var->constant_initializer, ir);
1758 
1759    if (fn != NULL && fn->subroutine_types)
1760       ralloc_steal(new_ctx, fn->subroutine_types);
1761 
1762    /* The components of aggregate constants are not visited by the normal
1763     * visitor, so steal their values by hand.
1764     */
1765    if (constant != NULL) {
1766       if (constant->type->is_record()) {
1767 	 foreach_in_list(ir_constant, field, &constant->components) {
1768 	    steal_memory(field, ir);
1769 	 }
1770       } else if (constant->type->is_array()) {
1771 	 for (unsigned int i = 0; i < constant->type->length; i++) {
1772 	    steal_memory(constant->array_elements[i], ir);
1773 	 }
1774       }
1775    }
1776 
1777    ralloc_steal(new_ctx, ir);
1778 }
1779 
1780 
1781 void
reparent_ir(exec_list * list,void * mem_ctx)1782 reparent_ir(exec_list *list, void *mem_ctx)
1783 {
1784    foreach_in_list(ir_instruction, node, list) {
1785       visit_tree(node, steal_memory, mem_ctx);
1786    }
1787 }
1788 
1789 
1790 static ir_rvalue *
try_min_one(ir_rvalue * ir)1791 try_min_one(ir_rvalue *ir)
1792 {
1793    ir_expression *expr = ir->as_expression();
1794 
1795    if (!expr || expr->operation != ir_binop_min)
1796       return NULL;
1797 
1798    if (expr->operands[0]->is_one())
1799       return expr->operands[1];
1800 
1801    if (expr->operands[1]->is_one())
1802       return expr->operands[0];
1803 
1804    return NULL;
1805 }
1806 
1807 static ir_rvalue *
try_max_zero(ir_rvalue * ir)1808 try_max_zero(ir_rvalue *ir)
1809 {
1810    ir_expression *expr = ir->as_expression();
1811 
1812    if (!expr || expr->operation != ir_binop_max)
1813       return NULL;
1814 
1815    if (expr->operands[0]->is_zero())
1816       return expr->operands[1];
1817 
1818    if (expr->operands[1]->is_zero())
1819       return expr->operands[0];
1820 
1821    return NULL;
1822 }
1823 
1824 ir_rvalue *
as_rvalue_to_saturate()1825 ir_rvalue::as_rvalue_to_saturate()
1826 {
1827    ir_expression *expr = this->as_expression();
1828 
1829    if (!expr)
1830       return NULL;
1831 
1832    ir_rvalue *max_zero = try_max_zero(expr);
1833    if (max_zero) {
1834       return try_min_one(max_zero);
1835    } else {
1836       ir_rvalue *min_one = try_min_one(expr);
1837       if (min_one) {
1838 	 return try_max_zero(min_one);
1839       }
1840    }
1841 
1842    return NULL;
1843 }
1844 
1845 
1846 unsigned
vertices_per_prim(GLenum prim)1847 vertices_per_prim(GLenum prim)
1848 {
1849    switch (prim) {
1850    case GL_POINTS:
1851       return 1;
1852    case GL_LINES:
1853       return 2;
1854    case GL_TRIANGLES:
1855       return 3;
1856    case GL_LINES_ADJACENCY:
1857       return 4;
1858    case GL_TRIANGLES_ADJACENCY:
1859       return 6;
1860    default:
1861       assert(!"Bad primitive");
1862       return 3;
1863    }
1864 }
1865 
1866 /**
1867  * Generate a string describing the mode of a variable
1868  */
1869 const char *
mode_string(const ir_variable * var)1870 mode_string(const ir_variable *var)
1871 {
1872    switch (var->data.mode) {
1873    case ir_var_auto:
1874       return (var->data.read_only) ? "global constant" : "global variable";
1875 
1876    case ir_var_uniform:
1877       return "uniform";
1878 
1879    case ir_var_shader_storage:
1880       return "buffer";
1881 
1882    case ir_var_shader_in:
1883       return "shader input";
1884 
1885    case ir_var_shader_out:
1886       return "shader output";
1887 
1888    case ir_var_function_in:
1889    case ir_var_const_in:
1890       return "function input";
1891 
1892    case ir_var_function_out:
1893       return "function output";
1894 
1895    case ir_var_function_inout:
1896       return "function inout";
1897 
1898    case ir_var_system_value:
1899       return "shader input";
1900 
1901    case ir_var_temporary:
1902       return "compiler temporary";
1903 
1904    case ir_var_mode_count:
1905       break;
1906    }
1907 
1908    assert(!"Should not get here.");
1909    return "invalid variable";
1910 }
1911