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