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