projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
glsl: make max array trackers ints and use -1 as base. (v2)
[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 this->array_elements = NULL;
667 }
668
669 ir_constant::ir_constant(const struct glsl_type *type,
670 const ir_constant_data *data)
671 : ir_rvalue(ir_type_constant)
672 {
673 this->array_elements = NULL;
674
675 assert((type->base_type >= GLSL_TYPE_UINT)
676 && (type->base_type <= GLSL_TYPE_BOOL));
677
678 this->type = type;
679 memcpy(& this->value, data, sizeof(this->value));
680 }
681
682 ir_constant::ir_constant(float f, unsigned vector_elements)
683 : ir_rvalue(ir_type_constant)
684 {
685 assert(vector_elements <= 4);
686 this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT, vector_elements, 1);
687 for (unsigned i = 0; i < vector_elements; i++) {
688 this->value.f[i] = f;
689 }
690 for (unsigned i = vector_elements; i < 16; i++) {
691 this->value.f[i] = 0;
692 }
693 }
694
695 ir_constant::ir_constant(double d, unsigned vector_elements)
696 : ir_rvalue(ir_type_constant)
697 {
698 assert(vector_elements <= 4);
699 this->type = glsl_type::get_instance(GLSL_TYPE_DOUBLE, vector_elements, 1);
700 for (unsigned i = 0; i < vector_elements; i++) {
701 this->value.d[i] = d;
702 }
703 for (unsigned i = vector_elements; i < 16; i++) {
704 this->value.d[i] = 0.0;
705 }
706 }
707
708 ir_constant::ir_constant(unsigned int u, unsigned vector_elements)
709 : ir_rvalue(ir_type_constant)
710 {
711 assert(vector_elements <= 4);
712 this->type = glsl_type::get_instance(GLSL_TYPE_UINT, vector_elements, 1);
713 for (unsigned i = 0; i < vector_elements; i++) {
714 this->value.u[i] = u;
715 }
716 for (unsigned i = vector_elements; i < 16; i++) {
717 this->value.u[i] = 0;
718 }
719 }
720
721 ir_constant::ir_constant(int integer, unsigned vector_elements)
722 : ir_rvalue(ir_type_constant)
723 {
724 assert(vector_elements <= 4);
725 this->type = glsl_type::get_instance(GLSL_TYPE_INT, vector_elements, 1);
726 for (unsigned i = 0; i < vector_elements; i++) {
727 this->value.i[i] = integer;
728 }
729 for (unsigned i = vector_elements; i < 16; i++) {
730 this->value.i[i] = 0;
731 }
732 }
733
734 ir_constant::ir_constant(bool b, unsigned vector_elements)
735 : ir_rvalue(ir_type_constant)
736 {
737 assert(vector_elements <= 4);
738 this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, vector_elements, 1);
739 for (unsigned i = 0; i < vector_elements; i++) {
740 this->value.b[i] = b;
741 }
742 for (unsigned i = vector_elements; i < 16; i++) {
743 this->value.b[i] = false;
744 }
745 }
746
747 ir_constant::ir_constant(const ir_constant *c, unsigned i)
748 : ir_rvalue(ir_type_constant)
749 {
750 this->array_elements = NULL;
751 this->type = c->type->get_base_type();
752
753 switch (this->type->base_type) {
754 case GLSL_TYPE_UINT: this->value.u[0] = c->value.u[i]; break;
755 case GLSL_TYPE_INT: this->value.i[0] = c->value.i[i]; break;
756 case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
757 case GLSL_TYPE_BOOL: this->value.b[0] = c->value.b[i]; break;
758 case GLSL_TYPE_DOUBLE: this->value.d[0] = c->value.d[i]; break;
759 default: assert(!"Should not get here."); break;
760 }
761 }
762
763 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
764 : ir_rvalue(ir_type_constant)
765 {
766 this->array_elements = NULL;
767 this->type = type;
768
769 assert(type->is_scalar() || type->is_vector() || type->is_matrix()
770 || type->is_record() || type->is_array());
771
772 if (type->is_array()) {
773 this->array_elements = ralloc_array(this, ir_constant *, type->length);
774 unsigned i = 0;
775 foreach_in_list(ir_constant, value, value_list) {
776 assert(value->as_constant() != NULL);
777
778 this->array_elements[i++] = value;
779 }
780 return;
781 }
782
783 /* If the constant is a record, the types of each of the entries in
784 * value_list must be a 1-for-1 match with the structure components. Each
785 * entry must also be a constant. Just move the nodes from the value_list
786 * to the list in the ir_constant.
787 */
788 /* FINISHME: Should there be some type checking and / or assertions here? */
789 /* FINISHME: Should the new constant take ownership of the nodes from
790 * FINISHME: value_list, or should it make copies?
791 */
792 if (type->is_record()) {
793 value_list->move_nodes_to(& this->components);
794 return;
795 }
796
797 for (unsigned i = 0; i < 16; i++) {
798 this->value.u[i] = 0;
799 }
800
801 ir_constant *value = (ir_constant *) (value_list->head);
802
803 /* Constructors with exactly one scalar argument are special for vectors
804 * and matrices. For vectors, the scalar value is replicated to fill all
805 * the components. For matrices, the scalar fills the components of the
806 * diagonal while the rest is filled with 0.
807 */
808 if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
809 if (type->is_matrix()) {
810 /* Matrix - fill diagonal (rest is already set to 0) */
811 assert(type->base_type == GLSL_TYPE_FLOAT ||
812 type->base_type == GLSL_TYPE_DOUBLE);
813 for (unsigned i = 0; i < type->matrix_columns; i++) {
814 if (type->base_type == GLSL_TYPE_FLOAT)
815 this->value.f[i * type->vector_elements + i] =
816 value->value.f[0];
817 else
818 this->value.d[i * type->vector_elements + i] =
819 value->value.d[0];
820 }
821 } else {
822 /* Vector or scalar - fill all components */
823 switch (type->base_type) {
824 case GLSL_TYPE_UINT:
825 case GLSL_TYPE_INT:
826 for (unsigned i = 0; i < type->components(); i++)
827 this->value.u[i] = value->value.u[0];
828 break;
829 case GLSL_TYPE_FLOAT:
830 for (unsigned i = 0; i < type->components(); i++)
831 this->value.f[i] = value->value.f[0];
832 break;
833 case GLSL_TYPE_DOUBLE:
834 for (unsigned i = 0; i < type->components(); i++)
835 this->value.d[i] = value->value.d[0];
836 break;
837 case GLSL_TYPE_BOOL:
838 for (unsigned i = 0; i < type->components(); i++)
839 this->value.b[i] = value->value.b[0];
840 break;
841 default:
842 assert(!"Should not get here.");
843 break;
844 }
845 }
846 return;
847 }
848
849 if (type->is_matrix() && value->type->is_matrix()) {
850 assert(value->next->is_tail_sentinel());
851
852 /* From section 5.4.2 of the GLSL 1.20 spec:
853 * "If a matrix is constructed from a matrix, then each component
854 * (column i, row j) in the result that has a corresponding component
855 * (column i, row j) in the argument will be initialized from there."
856 */
857 unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
858 unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
859 for (unsigned i = 0; i < cols; i++) {
860 for (unsigned j = 0; j < rows; j++) {
861 const unsigned src = i * value->type->vector_elements + j;
862 const unsigned dst = i * type->vector_elements + j;
863 this->value.f[dst] = value->value.f[src];
864 }
865 }
866
867 /* "All other components will be initialized to the identity matrix." */
868 for (unsigned i = cols; i < type->matrix_columns; i++)
869 this->value.f[i * type->vector_elements + i] = 1.0;
870
871 return;
872 }
873
874 /* Use each component from each entry in the value_list to initialize one
875 * component of the constant being constructed.
876 */
877 unsigned i = 0;
878 for (;;) {
879 assert(value->as_constant() != NULL);
880 assert(!value->is_tail_sentinel());
881
882 for (unsigned j = 0; j < value->type->components(); j++) {
883 switch (type->base_type) {
884 case GLSL_TYPE_UINT:
885 this->value.u[i] = value->get_uint_component(j);
886 break;
887 case GLSL_TYPE_INT:
888 this->value.i[i] = value->get_int_component(j);
889 break;
890 case GLSL_TYPE_FLOAT:
891 this->value.f[i] = value->get_float_component(j);
892 break;
893 case GLSL_TYPE_BOOL:
894 this->value.b[i] = value->get_bool_component(j);
895 break;
896 case GLSL_TYPE_DOUBLE:
897 this->value.d[i] = value->get_double_component(j);
898 break;
899 default:
900 /* FINISHME: What to do? Exceptions are not the answer.
901 */
902 break;
903 }
904
905 i++;
906 if (i >= type->components())
907 break;
908 }
909
910 if (i >= type->components())
911 break; /* avoid downcasting a list sentinel */
912 value = (ir_constant *) value->next;
913 }
914 }
915
916 ir_constant *
917 ir_constant::zero(void *mem_ctx, const glsl_type *type)
918 {
919 assert(type->is_scalar() || type->is_vector() || type->is_matrix()
920 || type->is_record() || type->is_array());
921
922 ir_constant *c = new(mem_ctx) ir_constant;
923 c->type = type;
924 memset(&c->value, 0, sizeof(c->value));
925
926 if (type->is_array()) {
927 c->array_elements = ralloc_array(c, ir_constant *, type->length);
928
929 for (unsigned i = 0; i < type->length; i++)
930 c->array_elements[i] = ir_constant::zero(c, type->fields.array);
931 }
932
933 if (type->is_record()) {
934 for (unsigned i = 0; i < type->length; i++) {
935 ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
936 c->components.push_tail(comp);
937 }
938 }
939
940 return c;
941 }
942
943 bool
944 ir_constant::get_bool_component(unsigned i) const
945 {
946 switch (this->type->base_type) {
947 case GLSL_TYPE_UINT: return this->value.u[i] != 0;
948 case GLSL_TYPE_INT: return this->value.i[i] != 0;
949 case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
950 case GLSL_TYPE_BOOL: return this->value.b[i];
951 case GLSL_TYPE_DOUBLE: return this->value.d[i] != 0.0;
952 default: assert(!"Should not get here."); break;
953 }
954
955 /* Must return something to make the compiler happy. This is clearly an
956 * error case.
957 */
958 return false;
959 }
960
961 float
962 ir_constant::get_float_component(unsigned i) const
963 {
964 switch (this->type->base_type) {
965 case GLSL_TYPE_UINT: return (float) this->value.u[i];
966 case GLSL_TYPE_INT: return (float) this->value.i[i];
967 case GLSL_TYPE_FLOAT: return this->value.f[i];
968 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0f : 0.0f;
969 case GLSL_TYPE_DOUBLE: return (float) this->value.d[i];
970 default: assert(!"Should not get here."); break;
971 }
972
973 /* Must return something to make the compiler happy. This is clearly an
974 * error case.
975 */
976 return 0.0;
977 }
978
979 double
980 ir_constant::get_double_component(unsigned i) const
981 {
982 switch (this->type->base_type) {
983 case GLSL_TYPE_UINT: return (double) this->value.u[i];
984 case GLSL_TYPE_INT: return (double) this->value.i[i];
985 case GLSL_TYPE_FLOAT: return (double) this->value.f[i];
986 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0;
987 case GLSL_TYPE_DOUBLE: return this->value.d[i];
988 default: assert(!"Should not get here."); break;
989 }
990
991 /* Must return something to make the compiler happy. This is clearly an
992 * error case.
993 */
994 return 0.0;
995 }
996
997 int
998 ir_constant::get_int_component(unsigned i) const
999 {
1000 switch (this->type->base_type) {
1001 case GLSL_TYPE_UINT: return this->value.u[i];
1002 case GLSL_TYPE_INT: return this->value.i[i];
1003 case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
1004 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
1005 case GLSL_TYPE_DOUBLE: return (int) this->value.d[i];
1006 default: assert(!"Should not get here."); break;
1007 }
1008
1009 /* Must return something to make the compiler happy. This is clearly an
1010 * error case.
1011 */
1012 return 0;
1013 }
1014
1015 unsigned
1016 ir_constant::get_uint_component(unsigned i) const
1017 {
1018 switch (this->type->base_type) {
1019 case GLSL_TYPE_UINT: return this->value.u[i];
1020 case GLSL_TYPE_INT: return this->value.i[i];
1021 case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
1022 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
1023 case GLSL_TYPE_DOUBLE: return (unsigned) this->value.d[i];
1024 default: assert(!"Should not get here."); break;
1025 }
1026
1027 /* Must return something to make the compiler happy. This is clearly an
1028 * error case.
1029 */
1030 return 0;
1031 }
1032
1033 ir_constant *
1034 ir_constant::get_array_element(unsigned i) const
1035 {
1036 assert(this->type->is_array());
1037
1038 /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
1039 *
1040 * "Behavior is undefined if a shader subscripts an array with an index
1041 * less than 0 or greater than or equal to the size the array was
1042 * declared with."
1043 *
1044 * Most out-of-bounds accesses are removed before things could get this far.
1045 * There are cases where non-constant array index values can get constant
1046 * folded.
1047 */
1048 if (int(i) < 0)
1049 i = 0;
1050 else if (i >= this->type->length)
1051 i = this->type->length - 1;
1052
1053 return array_elements[i];
1054 }
1055
1056 ir_constant *
1057 ir_constant::get_record_field(const char *name)
1058 {
1059 int idx = this->type->field_index(name);
1060
1061 if (idx < 0)
1062 return NULL;
1063
1064 if (this->components.is_empty())
1065 return NULL;
1066
1067 exec_node *node = this->components.head;
1068 for (int i = 0; i < idx; i++) {
1069 node = node->next;
1070
1071 /* If the end of the list is encountered before the element matching the
1072 * requested field is found, return NULL.
1073 */
1074 if (node->is_tail_sentinel())
1075 return NULL;
1076 }
1077
1078 return (ir_constant *) node;
1079 }
1080
1081 void
1082 ir_constant::copy_offset(ir_constant *src, int offset)
1083 {
1084 switch (this->type->base_type) {
1085 case GLSL_TYPE_UINT:
1086 case GLSL_TYPE_INT:
1087 case GLSL_TYPE_FLOAT:
1088 case GLSL_TYPE_DOUBLE:
1089 case GLSL_TYPE_BOOL: {
1090 unsigned int size = src->type->components();
1091 assert (size <= this->type->components() - offset);
1092 for (unsigned int i=0; i<size; i++) {
1093 switch (this->type->base_type) {
1094 case GLSL_TYPE_UINT:
1095 value.u[i+offset] = src->get_uint_component(i);
1096 break;
1097 case GLSL_TYPE_INT:
1098 value.i[i+offset] = src->get_int_component(i);
1099 break;
1100 case GLSL_TYPE_FLOAT:
1101 value.f[i+offset] = src->get_float_component(i);
1102 break;
1103 case GLSL_TYPE_BOOL:
1104 value.b[i+offset] = src->get_bool_component(i);
1105 break;
1106 case GLSL_TYPE_DOUBLE:
1107 value.d[i+offset] = src->get_double_component(i);
1108 break;
1109 default: // Shut up the compiler
1110 break;
1111 }
1112 }
1113 break;
1114 }
1115
1116 case GLSL_TYPE_STRUCT: {
1117 assert (src->type == this->type);
1118 this->components.make_empty();
1119 foreach_in_list(ir_constant, orig, &src->components) {
1120 this->components.push_tail(orig->clone(this, NULL));
1121 }
1122 break;
1123 }
1124
1125 case GLSL_TYPE_ARRAY: {
1126 assert (src->type == this->type);
1127 for (unsigned i = 0; i < this->type->length; i++) {
1128 this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
1129 }
1130 break;
1131 }
1132
1133 default:
1134 assert(!"Should not get here.");
1135 break;
1136 }
1137 }
1138
1139 void
1140 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
1141 {
1142 assert (!type->is_array() && !type->is_record());
1143
1144 if (!type->is_vector() && !type->is_matrix()) {
1145 offset = 0;
1146 mask = 1;
1147 }
1148
1149 int id = 0;
1150 for (int i=0; i<4; i++) {
1151 if (mask & (1 << i)) {
1152 switch (this->type->base_type) {
1153 case GLSL_TYPE_UINT:
1154 value.u[i+offset] = src->get_uint_component(id++);
1155 break;
1156 case GLSL_TYPE_INT:
1157 value.i[i+offset] = src->get_int_component(id++);
1158 break;
1159 case GLSL_TYPE_FLOAT:
1160 value.f[i+offset] = src->get_float_component(id++);
1161 break;
1162 case GLSL_TYPE_BOOL:
1163 value.b[i+offset] = src->get_bool_component(id++);
1164 break;
1165 case GLSL_TYPE_DOUBLE:
1166 value.d[i+offset] = src->get_double_component(id++);
1167 break;
1168 default:
1169 assert(!"Should not get here.");
1170 return;
1171 }
1172 }
1173 }
1174 }
1175
1176 bool
1177 ir_constant::has_value(const ir_constant *c) const
1178 {
1179 if (this->type != c->type)
1180 return false;
1181
1182 if (this->type->is_array()) {
1183 for (unsigned i = 0; i < this->type->length; i++) {
1184 if (!this->array_elements[i]->has_value(c->array_elements[i]))
1185 return false;
1186 }
1187 return true;
1188 }
1189
1190 if (this->type->base_type == GLSL_TYPE_STRUCT) {
1191 const exec_node *a_node = this->components.head;
1192 const exec_node *b_node = c->components.head;
1193
1194 while (!a_node->is_tail_sentinel()) {
1195 assert(!b_node->is_tail_sentinel());
1196
1197 const ir_constant *const a_field = (ir_constant *) a_node;
1198 const ir_constant *const b_field = (ir_constant *) b_node;
1199
1200 if (!a_field->has_value(b_field))
1201 return false;
1202
1203 a_node = a_node->next;
1204 b_node = b_node->next;
1205 }
1206
1207 return true;
1208 }
1209
1210 for (unsigned i = 0; i < this->type->components(); i++) {
1211 switch (this->type->base_type) {
1212 case GLSL_TYPE_UINT:
1213 if (this->value.u[i] != c->value.u[i])
1214 return false;
1215 break;
1216 case GLSL_TYPE_INT:
1217 if (this->value.i[i] != c->value.i[i])
1218 return false;
1219 break;
1220 case GLSL_TYPE_FLOAT:
1221 if (this->value.f[i] != c->value.f[i])
1222 return false;
1223 break;
1224 case GLSL_TYPE_BOOL:
1225 if (this->value.b[i] != c->value.b[i])
1226 return false;
1227 break;
1228 case GLSL_TYPE_DOUBLE:
1229 if (this->value.d[i] != c->value.d[i])
1230 return false;
1231 break;
1232 default:
1233 assert(!"Should not get here.");
1234 return false;
1235 }
1236 }
1237
1238 return true;
1239 }
1240
1241 bool
1242 ir_constant::is_value(float f, int i) const
1243 {
1244 if (!this->type->is_scalar() && !this->type->is_vector())
1245 return false;
1246
1247 /* Only accept boolean values for 0/1. */
1248 if (int(bool(i)) != i && this->type->is_boolean())
1249 return false;
1250
1251 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1252 switch (this->type->base_type) {
1253 case GLSL_TYPE_FLOAT:
1254 if (this->value.f[c] != f)
1255 return false;
1256 break;
1257 case GLSL_TYPE_INT:
1258 if (this->value.i[c] != i)
1259 return false;
1260 break;
1261 case GLSL_TYPE_UINT:
1262 if (this->value.u[c] != unsigned(i))
1263 return false;
1264 break;
1265 case GLSL_TYPE_BOOL:
1266 if (this->value.b[c] != bool(i))
1267 return false;
1268 break;
1269 case GLSL_TYPE_DOUBLE:
1270 if (this->value.d[c] != double(f))
1271 return false;
1272 break;
1273 default:
1274 /* The only other base types are structures, arrays, and samplers.
1275 * Samplers cannot be constants, and the others should have been
1276 * filtered out above.
1277 */
1278 assert(!"Should not get here.");
1279 return false;
1280 }
1281 }
1282
1283 return true;
1284 }
1285
1286 bool
1287 ir_constant::is_zero() const
1288 {
1289 return is_value(0.0, 0);
1290 }
1291
1292 bool
1293 ir_constant::is_one() const
1294 {
1295 return is_value(1.0, 1);
1296 }
1297
1298 bool
1299 ir_constant::is_negative_one() const
1300 {
1301 return is_value(-1.0, -1);
1302 }
1303
1304 bool
1305 ir_constant::is_uint16_constant() const
1306 {
1307 if (!type->is_integer())
1308 return false;
1309
1310 return value.u[0] < (1 << 16);
1311 }
1312
1313 ir_loop::ir_loop()
1314 : ir_instruction(ir_type_loop)
1315 {
1316 }
1317
1318
1319 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1320 : ir_dereference(ir_type_dereference_variable)
1321 {
1322 assert(var != NULL);
1323
1324 this->var = var;
1325 this->type = var->type;
1326 }
1327
1328
1329 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1330 ir_rvalue *array_index)
1331 : ir_dereference(ir_type_dereference_array)
1332 {
1333 this->array_index = array_index;
1334 this->set_array(value);
1335 }
1336
1337
1338 ir_dereference_array::ir_dereference_array(ir_variable *var,
1339 ir_rvalue *array_index)
1340 : ir_dereference(ir_type_dereference_array)
1341 {
1342 void *ctx = ralloc_parent(var);
1343
1344 this->array_index = array_index;
1345 this->set_array(new(ctx) ir_dereference_variable(var));
1346 }
1347
1348
1349 void
1350 ir_dereference_array::set_array(ir_rvalue *value)
1351 {
1352 assert(value != NULL);
1353
1354 this->array = value;
1355
1356 const glsl_type *const vt = this->array->type;
1357
1358 if (vt->is_array()) {
1359 type = vt->fields.array;
1360 } else if (vt->is_matrix()) {
1361 type = vt->column_type();
1362 } else if (vt->is_vector()) {
1363 type = vt->get_base_type();
1364 }
1365 }
1366
1367
1368 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1369 const char *field)
1370 : ir_dereference(ir_type_dereference_record)
1371 {
1372 assert(value != NULL);
1373
1374 this->record = value;
1375 this->field = ralloc_strdup(this, field);
1376 this->type = this->record->type->field_type(field);
1377 }
1378
1379
1380 ir_dereference_record::ir_dereference_record(ir_variable *var,
1381 const char *field)
1382 : ir_dereference(ir_type_dereference_record)
1383 {
1384 void *ctx = ralloc_parent(var);
1385
1386 this->record = new(ctx) ir_dereference_variable(var);
1387 this->field = ralloc_strdup(this, field);
1388 this->type = this->record->type->field_type(field);
1389 }
1390
1391 bool
1392 ir_dereference::is_lvalue() const
1393 {
1394 ir_variable *var = this->variable_referenced();
1395
1396 /* Every l-value derference chain eventually ends in a variable.
1397 */
1398 if ((var == NULL) || var->data.read_only)
1399 return false;
1400
1401 /* From section 4.1.7 of the GLSL 4.40 spec:
1402 *
1403 * "Opaque variables cannot be treated as l-values; hence cannot
1404 * be used as out or inout function parameters, nor can they be
1405 * assigned into."
1406 */
1407 if (this->type->contains_opaque())
1408 return false;
1409
1410 return true;
1411 }
1412
1413
1414 static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels", "texture_samples", "samples_identical" };
1415
1416 const char *ir_texture::opcode_string()
1417 {
1418 assert((unsigned int) op < ARRAY_SIZE(tex_opcode_strs));
1419 return tex_opcode_strs[op];
1420 }
1421
1422 ir_texture_opcode
1423 ir_texture::get_opcode(const char *str)
1424 {
1425 const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1426 for (int op = 0; op < count; op++) {
1427 if (strcmp(str, tex_opcode_strs[op]) == 0)
1428 return (ir_texture_opcode) op;
1429 }
1430 return (ir_texture_opcode) -1;
1431 }
1432
1433
1434 void
1435 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1436 {
1437 assert(sampler != NULL);
1438 assert(type != NULL);
1439 this->sampler = sampler;
1440 this->type = type;
1441
1442 if (this->op == ir_txs || this->op == ir_query_levels ||
1443 this->op == ir_texture_samples) {
1444 assert(type->base_type == GLSL_TYPE_INT);
1445 } else if (this->op == ir_lod) {
1446 assert(type->vector_elements == 2);
1447 assert(type->base_type == GLSL_TYPE_FLOAT);
1448 } else if (this->op == ir_samples_identical) {
1449 assert(type == glsl_type::bool_type);
1450 assert(sampler->type->base_type == GLSL_TYPE_SAMPLER);
1451 assert(sampler->type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS);
1452 } else {
1453 assert(sampler->type->sampled_type == (int) type->base_type);
1454 if (sampler->type->sampler_shadow)
1455 assert(type->vector_elements == 4 || type->vector_elements == 1);
1456 else
1457 assert(type->vector_elements == 4);
1458 }
1459 }
1460
1461
1462 void
1463 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1464 {
1465 assert((count >= 1) && (count <= 4));
1466
1467 memset(&this->mask, 0, sizeof(this->mask));
1468 this->mask.num_components = count;
1469
1470 unsigned dup_mask = 0;
1471 switch (count) {
1472 case 4:
1473 assert(comp[3] <= 3);
1474 dup_mask |= (1U << comp[3])
1475 & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1476 this->mask.w = comp[3];
1477
1478 case 3:
1479 assert(comp[2] <= 3);
1480 dup_mask |= (1U << comp[2])
1481 & ((1U << comp[0]) | (1U << comp[1]));
1482 this->mask.z = comp[2];
1483
1484 case 2:
1485 assert(comp[1] <= 3);
1486 dup_mask |= (1U << comp[1])
1487 & ((1U << comp[0]));
1488 this->mask.y = comp[1];
1489
1490 case 1:
1491 assert(comp[0] <= 3);
1492 this->mask.x = comp[0];
1493 }
1494
1495 this->mask.has_duplicates = dup_mask != 0;
1496
1497 /* Based on the number of elements in the swizzle and the base type
1498 * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1499 * generate the type of the resulting value.
1500 */
1501 type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1502 }
1503
1504 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1505 unsigned w, unsigned count)
1506 : ir_rvalue(ir_type_swizzle), val(val)
1507 {
1508 const unsigned components[4] = { x, y, z, w };
1509 this->init_mask(components, count);
1510 }
1511
1512 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1513 unsigned count)
1514 : ir_rvalue(ir_type_swizzle), val(val)
1515 {
1516 this->init_mask(comp, count);
1517 }
1518
1519 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1520 : ir_rvalue(ir_type_swizzle)
1521 {
1522 this->val = val;
1523 this->mask = mask;
1524 this->type = glsl_type::get_instance(val->type->base_type,
1525 mask.num_components, 1);
1526 }
1527
1528 #define X 1
1529 #define R 5
1530 #define S 9
1531 #define I 13
1532
1533 ir_swizzle *
1534 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1535 {
1536 void *ctx = ralloc_parent(val);
1537
1538 /* For each possible swizzle character, this table encodes the value in
1539 * \c idx_map that represents the 0th element of the vector. For invalid
1540 * swizzle characters (e.g., 'k'), a special value is used that will allow
1541 * detection of errors.
1542 */
1543 static const unsigned char base_idx[26] = {
1544 /* a b c d e f g h i j k l m */
1545 R, R, I, I, I, I, R, I, I, I, I, I, I,
1546 /* n o p q r s t u v w x y z */
1547 I, I, S, S, R, S, S, I, I, X, X, X, X
1548 };
1549
1550 /* Each valid swizzle character has an entry in the previous table. This
1551 * table encodes the base index encoded in the previous table plus the actual
1552 * index of the swizzle character. When processing swizzles, the first
1553 * character in the string is indexed in the previous table. Each character
1554 * in the string is indexed in this table, and the value found there has the
1555 * value form the first table subtracted. The result must be on the range
1556 * [0,3].
1557 *
1558 * For example, the string "wzyx" will get X from the first table. Each of
1559 * the charcaters will get X+3, X+2, X+1, and X+0 from this table. After
1560 * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1561 *
1562 * The string "wzrg" will get X from the first table. Each of the characters
1563 * will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the
1564 * swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range
1565 * [0,3], the error is detected.
1566 */
1567 static const unsigned char idx_map[26] = {
1568 /* a b c d e f g h i j k l m */
1569 R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,
1570 /* n o p q r s t u v w x y z */
1571 0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2
1572 };
1573
1574 int swiz_idx[4] = { 0, 0, 0, 0 };
1575 unsigned i;
1576
1577
1578 /* Validate the first character in the swizzle string and look up the base
1579 * index value as described above.
1580 */
1581 if ((str[0] < 'a') || (str[0] > 'z'))
1582 return NULL;
1583
1584 const unsigned base = base_idx[str[0] - 'a'];
1585
1586
1587 for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1588 /* Validate the next character, and, as described above, convert it to a
1589 * swizzle index.
1590 */
1591 if ((str[i] < 'a') || (str[i] > 'z'))
1592 return NULL;
1593
1594 swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1595 if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1596 return NULL;
1597 }
1598
1599 if (str[i] != '\0')
1600 return NULL;
1601
1602 return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1603 swiz_idx[3], i);
1604 }
1605
1606 #undef X
1607 #undef R
1608 #undef S
1609 #undef I
1610
1611 ir_variable *
1612 ir_swizzle::variable_referenced() const
1613 {
1614 return this->val->variable_referenced();
1615 }
1616
1617
1618 bool ir_variable::temporaries_allocate_names = false;
1619
1620 const char ir_variable::tmp_name[] = "compiler_temp";
1621
1622 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1623 ir_variable_mode mode)
1624 : ir_instruction(ir_type_variable)
1625 {
1626 this->type = type;
1627
1628 if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)
1629 name = NULL;
1630
1631 /* The ir_variable clone method may call this constructor with name set to
1632 * tmp_name.
1633 */
1634 assert(name != NULL
1635 || mode == ir_var_temporary
1636 || mode == ir_var_function_in
1637 || mode == ir_var_function_out
1638 || mode == ir_var_function_inout);
1639 assert(name != ir_variable::tmp_name
1640 || mode == ir_var_temporary);
1641 if (mode == ir_var_temporary
1642 && (name == NULL || name == ir_variable::tmp_name)) {
1643 this->name = ir_variable::tmp_name;
1644 } else {
1645 this->name = ralloc_strdup(this, name);
1646 }
1647
1648 this->u.max_ifc_array_access = NULL;
1649
1650 this->data.explicit_location = false;
1651 this->data.has_initializer = false;
1652 this->data.location = -1;
1653 this->data.location_frac = 0;
1654 this->data.binding = 0;
1655 this->data.warn_extension_index = 0;
1656 this->constant_value = NULL;
1657 this->constant_initializer = NULL;
1658 this->data.origin_upper_left = false;
1659 this->data.pixel_center_integer = false;
1660 this->data.depth_layout = ir_depth_layout_none;
1661 this->data.used = false;
1662 this->data.always_active_io = false;
1663 this->data.read_only = false;
1664 this->data.centroid = false;
1665 this->data.sample = false;
1666 this->data.patch = false;
1667 this->data.invariant = false;
1668 this->data.how_declared = ir_var_declared_normally;
1669 this->data.mode = mode;
1670 this->data.interpolation = INTERP_QUALIFIER_NONE;
1671 this->data.max_array_access = -1;
1672 this->data.offset = 0;
1673 this->data.precision = GLSL_PRECISION_NONE;
1674 this->data.image_read_only = false;
1675 this->data.image_write_only = false;
1676 this->data.image_coherent = false;
1677 this->data.image_volatile = false;
1678 this->data.image_restrict = false;
1679 this->data.from_ssbo_unsized_array = false;
1680
1681 if (type != NULL) {
1682 if (type->base_type == GLSL_TYPE_SAMPLER)
1683 this->data.read_only = true;
1684
1685 if (type->is_interface())
1686 this->init_interface_type(type);
1687 else if (type->without_array()->is_interface())
1688 this->init_interface_type(type->without_array());
1689 }
1690 }
1691
1692
1693 const char *
1694 interpolation_string(unsigned interpolation)
1695 {
1696 switch (interpolation) {
1697 case INTERP_QUALIFIER_NONE: return "no";
1698 case INTERP_QUALIFIER_SMOOTH: return "smooth";
1699 case INTERP_QUALIFIER_FLAT: return "flat";
1700 case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective";
1701 }
1702
1703 assert(!"Should not get here.");
1704 return "";
1705 }
1706
1707 const char *const ir_variable::warn_extension_table[] = {
1708 "",
1709 "GL_ARB_shader_stencil_export",
1710 "GL_AMD_shader_stencil_export",
1711 };
1712
1713 void
1714 ir_variable::enable_extension_warning(const char *extension)
1715 {
1716 for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {
1717 if (strcmp(warn_extension_table[i], extension) == 0) {
1718 this->data.warn_extension_index = i;
1719 return;
1720 }
1721 }
1722
1723 assert(!"Should not get here.");
1724 this->data.warn_extension_index = 0;
1725 }
1726
1727 const char *
1728 ir_variable::get_extension_warning() const
1729 {
1730 return this->data.warn_extension_index == 0
1731 ? NULL : warn_extension_table[this->data.warn_extension_index];
1732 }
1733
1734 ir_function_signature::ir_function_signature(const glsl_type *return_type,
1735 builtin_available_predicate b)
1736 : ir_instruction(ir_type_function_signature),
1737 return_type(return_type), is_defined(false), is_intrinsic(false),
1738 builtin_avail(b), _function(NULL)
1739 {
1740 this->origin = NULL;
1741 }
1742
1743
1744 bool
1745 ir_function_signature::is_builtin() const
1746 {
1747 return builtin_avail != NULL;
1748 }
1749
1750
1751 bool
1752 ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const
1753 {
1754 /* We can't call the predicate without a state pointer, so just say that
1755 * the signature is available. At compile time, we need the filtering,
1756 * but also receive a valid state pointer. At link time, we're resolving
1757 * imported built-in prototypes to their definitions, which will always
1758 * be an exact match. So we can skip the filtering.
1759 */
1760 if (state == NULL)
1761 return true;
1762
1763 assert(builtin_avail != NULL);
1764 return builtin_avail(state);
1765 }
1766
1767
1768 static bool
1769 modes_match(unsigned a, unsigned b)
1770 {
1771 if (a == b)
1772 return true;
1773
1774 /* Accept "in" vs. "const in" */
1775 if ((a == ir_var_const_in && b == ir_var_function_in) ||
1776 (b == ir_var_const_in && a == ir_var_function_in))
1777 return true;
1778
1779 return false;
1780 }
1781
1782
1783 const char *
1784 ir_function_signature::qualifiers_match(exec_list *params)
1785 {
1786 /* check that the qualifiers match. */
1787 foreach_two_lists(a_node, &this->parameters, b_node, params) {
1788 ir_variable *a = (ir_variable *) a_node;
1789 ir_variable *b = (ir_variable *) b_node;
1790
1791 if (a->data.read_only != b->data.read_only ||
1792 !modes_match(a->data.mode, b->data.mode) ||
1793 a->data.interpolation != b->data.interpolation ||
1794 a->data.centroid != b->data.centroid ||
1795 a->data.sample != b->data.sample ||
1796 a->data.patch != b->data.patch ||
1797 a->data.image_read_only != b->data.image_read_only ||
1798 a->data.image_write_only != b->data.image_write_only ||
1799 a->data.image_coherent != b->data.image_coherent ||
1800 a->data.image_volatile != b->data.image_volatile ||
1801 a->data.image_restrict != b->data.image_restrict) {
1802
1803 /* parameter a's qualifiers don't match */
1804 return a->name;
1805 }
1806 }
1807 return NULL;
1808 }
1809
1810
1811 void
1812 ir_function_signature::replace_parameters(exec_list *new_params)
1813 {
1814 /* Destroy all of the previous parameter information. If the previous
1815 * parameter information comes from the function prototype, it may either
1816 * specify incorrect parameter names or not have names at all.
1817 */
1818 new_params->move_nodes_to(&parameters);
1819 }
1820
1821
1822 ir_function::ir_function(const char *name)
1823 : ir_instruction(ir_type_function)
1824 {
1825 this->subroutine_index = -1;
1826 this->name = ralloc_strdup(this, name);
1827 }
1828
1829
1830 bool
1831 ir_function::has_user_signature()
1832 {
1833 foreach_in_list(ir_function_signature, sig, &this->signatures) {
1834 if (!sig->is_builtin())
1835 return true;
1836 }
1837 return false;
1838 }
1839
1840
1841 ir_rvalue *
1842 ir_rvalue::error_value(void *mem_ctx)
1843 {
1844 ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);
1845
1846 v->type = glsl_type::error_type;
1847 return v;
1848 }
1849
1850
1851 void
1852 visit_exec_list(exec_list *list, ir_visitor *visitor)
1853 {
1854 foreach_in_list_safe(ir_instruction, node, list) {
1855 node->accept(visitor);
1856 }
1857 }
1858
1859
1860 static void
1861 steal_memory(ir_instruction *ir, void *new_ctx)
1862 {
1863 ir_variable *var = ir->as_variable();
1864 ir_function *fn = ir->as_function();
1865 ir_constant *constant = ir->as_constant();
1866 if (var != NULL && var->constant_value != NULL)
1867 steal_memory(var->constant_value, ir);
1868
1869 if (var != NULL && var->constant_initializer != NULL)
1870 steal_memory(var->constant_initializer, ir);
1871
1872 if (fn != NULL && fn->subroutine_types)
1873 ralloc_steal(new_ctx, fn->subroutine_types);
1874
1875 /* The components of aggregate constants are not visited by the normal
1876 * visitor, so steal their values by hand.
1877 */
1878 if (constant != NULL) {
1879 if (constant->type->is_record()) {
1880 foreach_in_list(ir_constant, field, &constant->components) {
1881 steal_memory(field, ir);
1882 }
1883 } else if (constant->type->is_array()) {
1884 for (unsigned int i = 0; i < constant->type->length; i++) {
1885 steal_memory(constant->array_elements[i], ir);
1886 }
1887 }
1888 }
1889
1890 ralloc_steal(new_ctx, ir);
1891 }
1892
1893
1894 void
1895 reparent_ir(exec_list *list, void *mem_ctx)
1896 {
1897 foreach_in_list(ir_instruction, node, list) {
1898 visit_tree(node, steal_memory, mem_ctx);
1899 }
1900 }
1901
1902
1903 static ir_rvalue *
1904 try_min_one(ir_rvalue *ir)
1905 {
1906 ir_expression *expr = ir->as_expression();
1907
1908 if (!expr || expr->operation != ir_binop_min)
1909 return NULL;
1910
1911 if (expr->operands[0]->is_one())
1912 return expr->operands[1];
1913
1914 if (expr->operands[1]->is_one())
1915 return expr->operands[0];
1916
1917 return NULL;
1918 }
1919
1920 static ir_rvalue *
1921 try_max_zero(ir_rvalue *ir)
1922 {
1923 ir_expression *expr = ir->as_expression();
1924
1925 if (!expr || expr->operation != ir_binop_max)
1926 return NULL;
1927
1928 if (expr->operands[0]->is_zero())
1929 return expr->operands[1];
1930
1931 if (expr->operands[1]->is_zero())
1932 return expr->operands[0];
1933
1934 return NULL;
1935 }
1936
1937 ir_rvalue *
1938 ir_rvalue::as_rvalue_to_saturate()
1939 {
1940 ir_expression *expr = this->as_expression();
1941
1942 if (!expr)
1943 return NULL;
1944
1945 ir_rvalue *max_zero = try_max_zero(expr);
1946 if (max_zero) {
1947 return try_min_one(max_zero);
1948 } else {
1949 ir_rvalue *min_one = try_min_one(expr);
1950 if (min_one) {
1951 return try_max_zero(min_one);
1952 }
1953 }
1954
1955 return NULL;
1956 }
1957
1958
1959 unsigned
1960 vertices_per_prim(GLenum prim)
1961 {
1962 switch (prim) {
1963 case GL_POINTS:
1964 return 1;
1965 case GL_LINES:
1966 return 2;
1967 case GL_TRIANGLES:
1968 return 3;
1969 case GL_LINES_ADJACENCY:
1970 return 4;
1971 case GL_TRIANGLES_ADJACENCY:
1972 return 6;
1973 default:
1974 assert(!"Bad primitive");
1975 return 3;
1976 }
1977 }
1978
1979 /**
1980 * Generate a string describing the mode of a variable
1981 */
1982 const char *
1983 mode_string(const ir_variable *var)
1984 {
1985 switch (var->data.mode) {
1986 case ir_var_auto:
1987 return (var->data.read_only) ? "global constant" : "global variable";
1988
1989 case ir_var_uniform:
1990 return "uniform";
1991
1992 case ir_var_shader_storage:
1993 return "buffer";
1994
1995 case ir_var_shader_in:
1996 return "shader input";
1997
1998 case ir_var_shader_out:
1999 return "shader output";
2000
2001 case ir_var_function_in:
2002 case ir_var_const_in:
2003 return "function input";
2004
2005 case ir_var_function_out:
2006 return "function output";
2007
2008 case ir_var_function_inout:
2009 return "function inout";
2010
2011 case ir_var_system_value:
2012 return "shader input";
2013
2014 case ir_var_temporary:
2015 return "compiler temporary";
2016
2017 case ir_var_mode_count:
2018 break;
2019 }
2020
2021 assert(!"Should not get here.");
2022 return "invalid variable";
2023 }