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