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 "ir_visitor.h"
27 #include "glsl_types.h"
28
ir_rvalue()29 ir_rvalue::ir_rvalue()
30 {
31 this->type = glsl_type::error_type;
32 }
33
is_zero() const34 bool ir_rvalue::is_zero() const
35 {
36 return false;
37 }
38
is_one() const39 bool ir_rvalue::is_one() const
40 {
41 return false;
42 }
43
is_negative_one() const44 bool ir_rvalue::is_negative_one() const
45 {
46 return false;
47 }
48
is_basis() const49 bool ir_rvalue::is_basis() const
50 {
51 return false;
52 }
53
54 /**
55 * Modify the swizzle make to move one component to another
56 *
57 * \param m IR swizzle to be modified
58 * \param from Component in the RHS that is to be swizzled
59 * \param to Desired swizzle location of \c from
60 */
61 static void
update_rhs_swizzle(ir_swizzle_mask & m,unsigned from,unsigned to)62 update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to)
63 {
64 switch (to) {
65 case 0: m.x = from; break;
66 case 1: m.y = from; break;
67 case 2: m.z = from; break;
68 case 3: m.w = from; break;
69 default: assert(!"Should not get here.");
70 }
71
72 m.num_components = MAX2(m.num_components, (to + 1));
73 }
74
75 void
set_lhs(ir_rvalue * lhs)76 ir_assignment::set_lhs(ir_rvalue *lhs)
77 {
78 void *mem_ctx = this;
79 bool swizzled = false;
80
81 while (lhs != NULL) {
82 ir_swizzle *swiz = lhs->as_swizzle();
83
84 if (swiz == NULL)
85 break;
86
87 unsigned write_mask = 0;
88 ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
89
90 for (unsigned i = 0; i < swiz->mask.num_components; i++) {
91 unsigned c = 0;
92
93 switch (i) {
94 case 0: c = swiz->mask.x; break;
95 case 1: c = swiz->mask.y; break;
96 case 2: c = swiz->mask.z; break;
97 case 3: c = swiz->mask.w; break;
98 default: assert(!"Should not get here.");
99 }
100
101 write_mask |= (((this->write_mask >> i) & 1) << c);
102 update_rhs_swizzle(rhs_swiz, i, c);
103 }
104
105 this->write_mask = write_mask;
106 lhs = swiz->val;
107
108 this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
109 swizzled = true;
110 }
111
112 if (swizzled) {
113 /* Now, RHS channels line up with the LHS writemask. Collapse it
114 * to just the channels that will be written.
115 */
116 ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
117 int rhs_chan = 0;
118 for (int i = 0; i < 4; i++) {
119 if (write_mask & (1 << i))
120 update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
121 }
122 this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
123 }
124
125 assert((lhs == NULL) || lhs->as_dereference());
126
127 this->lhs = (ir_dereference *) lhs;
128 }
129
130 ir_variable *
whole_variable_written()131 ir_assignment::whole_variable_written()
132 {
133 ir_variable *v = this->lhs->whole_variable_referenced();
134
135 if (v == NULL)
136 return NULL;
137
138 if (v->type->is_scalar())
139 return v;
140
141 if (v->type->is_vector()) {
142 const unsigned mask = (1U << v->type->vector_elements) - 1;
143
144 if (mask != this->write_mask)
145 return NULL;
146 }
147
148 /* Either all the vector components are assigned or the variable is some
149 * composite type (and the whole thing is assigned.
150 */
151 return v;
152 }
153
ir_assignment(ir_dereference * lhs,ir_rvalue * rhs,ir_rvalue * condition,unsigned write_mask)154 ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs,
155 ir_rvalue *condition, unsigned write_mask)
156 {
157 this->ir_type = ir_type_assignment;
158 this->condition = condition;
159 this->rhs = rhs;
160 this->lhs = lhs;
161 this->write_mask = write_mask;
162
163 if (lhs->type->is_scalar() || lhs->type->is_vector()) {
164 int lhs_components = 0;
165 for (int i = 0; i < 4; i++) {
166 if (write_mask & (1 << i))
167 lhs_components++;
168 }
169
170 assert(lhs_components == this->rhs->type->vector_elements);
171 }
172 }
173
ir_assignment(ir_rvalue * lhs,ir_rvalue * rhs,ir_rvalue * condition)174 ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
175 ir_rvalue *condition)
176 {
177 this->ir_type = ir_type_assignment;
178 this->condition = condition;
179 this->rhs = rhs;
180
181 /* If the RHS is a vector type, assume that all components of the vector
182 * type are being written to the LHS. The write mask comes from the RHS
183 * because we can have a case where the LHS is a vec4 and the RHS is a
184 * vec3. In that case, the assignment is:
185 *
186 * (assign (...) (xyz) (var_ref lhs) (var_ref rhs))
187 */
188 if (rhs->type->is_vector())
189 this->write_mask = (1U << rhs->type->vector_elements) - 1;
190 else if (rhs->type->is_scalar())
191 this->write_mask = 1;
192 else
193 this->write_mask = 0;
194
195 this->set_lhs(lhs);
196 }
197
198
ir_expression(int op,const struct glsl_type * type,ir_rvalue * op0)199 ir_expression::ir_expression(int op, const struct glsl_type *type,
200 ir_rvalue *op0)
201 {
202 assert(get_num_operands(ir_expression_operation(op)) == 1);
203 this->ir_type = ir_type_expression;
204 this->type = type;
205 this->operation = ir_expression_operation(op);
206 this->operands[0] = op0;
207 this->operands[1] = NULL;
208 this->operands[2] = NULL;
209 this->operands[3] = NULL;
210 }
211
ir_expression(int op,const struct glsl_type * type,ir_rvalue * op0,ir_rvalue * op1)212 ir_expression::ir_expression(int op, const struct glsl_type *type,
213 ir_rvalue *op0, ir_rvalue *op1)
214 {
215 assert(((op1 == NULL) && (get_num_operands(ir_expression_operation(op)) == 1))
216 || (get_num_operands(ir_expression_operation(op)) == 2));
217 this->ir_type = ir_type_expression;
218 this->type = type;
219 this->operation = ir_expression_operation(op);
220 this->operands[0] = op0;
221 this->operands[1] = op1;
222 this->operands[2] = NULL;
223 this->operands[3] = NULL;
224 }
225
ir_expression(int op,const struct glsl_type * type,ir_rvalue * op0,ir_rvalue * op1,ir_rvalue * op2,ir_rvalue * op3)226 ir_expression::ir_expression(int op, const struct glsl_type *type,
227 ir_rvalue *op0, ir_rvalue *op1,
228 ir_rvalue *op2, ir_rvalue *op3)
229 {
230 this->ir_type = ir_type_expression;
231 this->type = type;
232 this->operation = ir_expression_operation(op);
233 this->operands[0] = op0;
234 this->operands[1] = op1;
235 this->operands[2] = op2;
236 this->operands[3] = op3;
237 }
238
ir_expression(int op,ir_rvalue * op0)239 ir_expression::ir_expression(int op, ir_rvalue *op0)
240 {
241 this->ir_type = ir_type_expression;
242
243 this->operation = ir_expression_operation(op);
244 this->operands[0] = op0;
245 this->operands[1] = NULL;
246 this->operands[2] = NULL;
247 this->operands[3] = NULL;
248
249 assert(op <= ir_last_unop);
250
251 switch (this->operation) {
252 case ir_unop_bit_not:
253 case ir_unop_logic_not:
254 case ir_unop_neg:
255 case ir_unop_abs:
256 case ir_unop_sign:
257 case ir_unop_rcp:
258 case ir_unop_rsq:
259 case ir_unop_sqrt:
260 case ir_unop_exp:
261 case ir_unop_log:
262 case ir_unop_exp2:
263 case ir_unop_log2:
264 case ir_unop_trunc:
265 case ir_unop_ceil:
266 case ir_unop_floor:
267 case ir_unop_fract:
268 case ir_unop_round_even:
269 case ir_unop_sin:
270 case ir_unop_cos:
271 case ir_unop_sin_reduced:
272 case ir_unop_cos_reduced:
273 case ir_unop_dFdx:
274 case ir_unop_dFdy:
275 this->type = op0->type;
276 break;
277
278 case ir_unop_f2i:
279 case ir_unop_b2i:
280 case ir_unop_u2i:
281 case ir_unop_bitcast_f2i:
282 this->type = glsl_type::get_instance(GLSL_TYPE_INT,
283 op0->type->vector_elements, 1);
284 break;
285
286 case ir_unop_b2f:
287 case ir_unop_i2f:
288 case ir_unop_u2f:
289 case ir_unop_bitcast_i2f:
290 case ir_unop_bitcast_u2f:
291 this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
292 op0->type->vector_elements, 1);
293 break;
294
295 case ir_unop_f2b:
296 case ir_unop_i2b:
297 this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
298 op0->type->vector_elements, 1);
299 break;
300
301 case ir_unop_i2u:
302 case ir_unop_f2u:
303 case ir_unop_bitcast_f2u:
304 this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
305 op0->type->vector_elements, 1);
306 break;
307
308 case ir_unop_noise:
309 this->type = glsl_type::float_type;
310 break;
311
312 case ir_unop_any:
313 this->type = glsl_type::bool_type;
314 break;
315
316 default:
317 assert(!"not reached: missing automatic type setup for ir_expression");
318 this->type = op0->type;
319 break;
320 }
321 }
322
ir_expression(int op,ir_rvalue * op0,ir_rvalue * op1)323 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
324 {
325 this->ir_type = ir_type_expression;
326
327 this->operation = ir_expression_operation(op);
328 this->operands[0] = op0;
329 this->operands[1] = op1;
330 this->operands[2] = NULL;
331 this->operands[3] = NULL;
332
333 assert(op > ir_last_unop);
334
335 switch (this->operation) {
336 case ir_binop_all_equal:
337 case ir_binop_any_nequal:
338 this->type = glsl_type::bool_type;
339 break;
340
341 case ir_binop_add:
342 case ir_binop_sub:
343 case ir_binop_min:
344 case ir_binop_max:
345 case ir_binop_pow:
346 case ir_binop_mul:
347 case ir_binop_div:
348 case ir_binop_mod:
349 if (op0->type->is_scalar()) {
350 this->type = op1->type;
351 } else if (op1->type->is_scalar()) {
352 this->type = op0->type;
353 } else {
354 /* FINISHME: matrix types */
355 assert(!op0->type->is_matrix() && !op1->type->is_matrix());
356 assert(op0->type == op1->type);
357 this->type = op0->type;
358 }
359 break;
360
361 case ir_binop_logic_and:
362 case ir_binop_logic_xor:
363 case ir_binop_logic_or:
364 case ir_binop_bit_and:
365 case ir_binop_bit_xor:
366 case ir_binop_bit_or:
367 if (op0->type->is_scalar()) {
368 this->type = op1->type;
369 } else if (op1->type->is_scalar()) {
370 this->type = op0->type;
371 }
372 break;
373
374 case ir_binop_equal:
375 case ir_binop_nequal:
376 case ir_binop_lequal:
377 case ir_binop_gequal:
378 case ir_binop_less:
379 case ir_binop_greater:
380 assert(op0->type == op1->type);
381 this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
382 op0->type->vector_elements, 1);
383 break;
384
385 case ir_binop_dot:
386 this->type = glsl_type::float_type;
387 break;
388
389 case ir_binop_lshift:
390 case ir_binop_rshift:
391 this->type = op0->type;
392 break;
393
394 default:
395 assert(!"not reached: missing automatic type setup for ir_expression");
396 this->type = glsl_type::float_type;
397 }
398 }
399
400 unsigned int
get_num_operands(ir_expression_operation op)401 ir_expression::get_num_operands(ir_expression_operation op)
402 {
403 assert(op <= ir_last_opcode);
404
405 if (op <= ir_last_unop)
406 return 1;
407
408 if (op <= ir_last_binop)
409 return 2;
410
411 if (op == ir_quadop_vector)
412 return 4;
413
414 assert(false);
415 return 0;
416 }
417
418 static const char *const operator_strs[] = {
419 "~",
420 "!",
421 "neg",
422 "abs",
423 "sign",
424 "rcp",
425 "rsq",
426 "sqrt",
427 "exp",
428 "log",
429 "exp2",
430 "log2",
431 "f2i",
432 "f2u",
433 "i2f",
434 "f2b",
435 "b2f",
436 "i2b",
437 "b2i",
438 "u2f",
439 "i2u",
440 "u2i",
441 "bitcast_i2f",
442 "bitcast_f2i",
443 "bitcast_u2f",
444 "bitcast_f2u",
445 "any",
446 "trunc",
447 "ceil",
448 "floor",
449 "fract",
450 "round_even",
451 "sin",
452 "cos",
453 "sin_reduced",
454 "cos_reduced",
455 "dFdx",
456 "dFdy",
457 "noise",
458 "+",
459 "-",
460 "*",
461 "/",
462 "%",
463 "<",
464 ">",
465 "<=",
466 ">=",
467 "==",
468 "!=",
469 "all_equal",
470 "any_nequal",
471 "<<",
472 ">>",
473 "&",
474 "^",
475 "|",
476 "&&",
477 "^^",
478 "||",
479 "dot",
480 "min",
481 "max",
482 "pow",
483 "ubo_load",
484 "vector",
485 };
486
operator_string(ir_expression_operation op)487 const char *ir_expression::operator_string(ir_expression_operation op)
488 {
489 assert((unsigned int) op < Elements(operator_strs));
490 assert(Elements(operator_strs) == (ir_quadop_vector + 1));
491 return operator_strs[op];
492 }
493
operator_string()494 const char *ir_expression::operator_string()
495 {
496 return operator_string(this->operation);
497 }
498
499 const char*
depth_layout_string(ir_depth_layout layout)500 depth_layout_string(ir_depth_layout layout)
501 {
502 switch(layout) {
503 case ir_depth_layout_none: return "";
504 case ir_depth_layout_any: return "depth_any";
505 case ir_depth_layout_greater: return "depth_greater";
506 case ir_depth_layout_less: return "depth_less";
507 case ir_depth_layout_unchanged: return "depth_unchanged";
508
509 default:
510 assert(0);
511 return "";
512 }
513 }
514
515 ir_expression_operation
get_operator(const char * str)516 ir_expression::get_operator(const char *str)
517 {
518 const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
519 for (int op = 0; op < operator_count; op++) {
520 if (strcmp(str, operator_strs[op]) == 0)
521 return (ir_expression_operation) op;
522 }
523 return (ir_expression_operation) -1;
524 }
525
ir_constant()526 ir_constant::ir_constant()
527 {
528 this->ir_type = ir_type_constant;
529 }
530
ir_constant(const struct glsl_type * type,const ir_constant_data * data)531 ir_constant::ir_constant(const struct glsl_type *type,
532 const ir_constant_data *data)
533 {
534 assert((type->base_type >= GLSL_TYPE_UINT)
535 && (type->base_type <= GLSL_TYPE_BOOL));
536
537 this->ir_type = ir_type_constant;
538 this->type = type;
539 memcpy(& this->value, data, sizeof(this->value));
540 }
541
ir_constant(float f)542 ir_constant::ir_constant(float f)
543 {
544 this->ir_type = ir_type_constant;
545 this->type = glsl_type::float_type;
546 this->value.f[0] = f;
547 for (int i = 1; i < 16; i++) {
548 this->value.f[i] = 0;
549 }
550 }
551
ir_constant(unsigned int u)552 ir_constant::ir_constant(unsigned int u)
553 {
554 this->ir_type = ir_type_constant;
555 this->type = glsl_type::uint_type;
556 this->value.u[0] = u;
557 for (int i = 1; i < 16; i++) {
558 this->value.u[i] = 0;
559 }
560 }
561
ir_constant(int i)562 ir_constant::ir_constant(int i)
563 {
564 this->ir_type = ir_type_constant;
565 this->type = glsl_type::int_type;
566 this->value.i[0] = i;
567 for (int i = 1; i < 16; i++) {
568 this->value.i[i] = 0;
569 }
570 }
571
ir_constant(bool b)572 ir_constant::ir_constant(bool b)
573 {
574 this->ir_type = ir_type_constant;
575 this->type = glsl_type::bool_type;
576 this->value.b[0] = b;
577 for (int i = 1; i < 16; i++) {
578 this->value.b[i] = false;
579 }
580 }
581
ir_constant(const ir_constant * c,unsigned i)582 ir_constant::ir_constant(const ir_constant *c, unsigned i)
583 {
584 this->ir_type = ir_type_constant;
585 this->type = c->type->get_base_type();
586
587 switch (this->type->base_type) {
588 case GLSL_TYPE_UINT: this->value.u[0] = c->value.u[i]; break;
589 case GLSL_TYPE_INT: this->value.i[0] = c->value.i[i]; break;
590 case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
591 case GLSL_TYPE_BOOL: this->value.b[0] = c->value.b[i]; break;
592 default: assert(!"Should not get here."); break;
593 }
594 }
595
ir_constant(const struct glsl_type * type,exec_list * value_list)596 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
597 {
598 this->ir_type = ir_type_constant;
599 this->type = type;
600
601 assert(type->is_scalar() || type->is_vector() || type->is_matrix()
602 || type->is_record() || type->is_array());
603
604 if (type->is_array()) {
605 this->array_elements = ralloc_array(this, ir_constant *, type->length);
606 unsigned i = 0;
607 foreach_list(node, value_list) {
608 ir_constant *value = (ir_constant *) node;
609 assert(value->as_constant() != NULL);
610
611 this->array_elements[i++] = value;
612 }
613 return;
614 }
615
616 /* If the constant is a record, the types of each of the entries in
617 * value_list must be a 1-for-1 match with the structure components. Each
618 * entry must also be a constant. Just move the nodes from the value_list
619 * to the list in the ir_constant.
620 */
621 /* FINISHME: Should there be some type checking and / or assertions here? */
622 /* FINISHME: Should the new constant take ownership of the nodes from
623 * FINISHME: value_list, or should it make copies?
624 */
625 if (type->is_record()) {
626 value_list->move_nodes_to(& this->components);
627 return;
628 }
629
630 for (unsigned i = 0; i < 16; i++) {
631 this->value.u[i] = 0;
632 }
633
634 ir_constant *value = (ir_constant *) (value_list->head);
635
636 /* Constructors with exactly one scalar argument are special for vectors
637 * and matrices. For vectors, the scalar value is replicated to fill all
638 * the components. For matrices, the scalar fills the components of the
639 * diagonal while the rest is filled with 0.
640 */
641 if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
642 if (type->is_matrix()) {
643 /* Matrix - fill diagonal (rest is already set to 0) */
644 assert(type->base_type == GLSL_TYPE_FLOAT);
645 for (unsigned i = 0; i < type->matrix_columns; i++)
646 this->value.f[i * type->vector_elements + i] = value->value.f[0];
647 } else {
648 /* Vector or scalar - fill all components */
649 switch (type->base_type) {
650 case GLSL_TYPE_UINT:
651 case GLSL_TYPE_INT:
652 for (unsigned i = 0; i < type->components(); i++)
653 this->value.u[i] = value->value.u[0];
654 break;
655 case GLSL_TYPE_FLOAT:
656 for (unsigned i = 0; i < type->components(); i++)
657 this->value.f[i] = value->value.f[0];
658 break;
659 case GLSL_TYPE_BOOL:
660 for (unsigned i = 0; i < type->components(); i++)
661 this->value.b[i] = value->value.b[0];
662 break;
663 default:
664 assert(!"Should not get here.");
665 break;
666 }
667 }
668 return;
669 }
670
671 if (type->is_matrix() && value->type->is_matrix()) {
672 assert(value->next->is_tail_sentinel());
673
674 /* From section 5.4.2 of the GLSL 1.20 spec:
675 * "If a matrix is constructed from a matrix, then each component
676 * (column i, row j) in the result that has a corresponding component
677 * (column i, row j) in the argument will be initialized from there."
678 */
679 unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
680 unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
681 for (unsigned i = 0; i < cols; i++) {
682 for (unsigned j = 0; j < rows; j++) {
683 const unsigned src = i * value->type->vector_elements + j;
684 const unsigned dst = i * type->vector_elements + j;
685 this->value.f[dst] = value->value.f[src];
686 }
687 }
688
689 /* "All other components will be initialized to the identity matrix." */
690 for (unsigned i = cols; i < type->matrix_columns; i++)
691 this->value.f[i * type->vector_elements + i] = 1.0;
692
693 return;
694 }
695
696 /* Use each component from each entry in the value_list to initialize one
697 * component of the constant being constructed.
698 */
699 for (unsigned i = 0; i < type->components(); /* empty */) {
700 assert(value->as_constant() != NULL);
701 assert(!value->is_tail_sentinel());
702
703 for (unsigned j = 0; j < value->type->components(); j++) {
704 switch (type->base_type) {
705 case GLSL_TYPE_UINT:
706 this->value.u[i] = value->get_uint_component(j);
707 break;
708 case GLSL_TYPE_INT:
709 this->value.i[i] = value->get_int_component(j);
710 break;
711 case GLSL_TYPE_FLOAT:
712 this->value.f[i] = value->get_float_component(j);
713 break;
714 case GLSL_TYPE_BOOL:
715 this->value.b[i] = value->get_bool_component(j);
716 break;
717 default:
718 /* FINISHME: What to do? Exceptions are not the answer.
719 */
720 break;
721 }
722
723 i++;
724 if (i >= type->components())
725 break;
726 }
727
728 value = (ir_constant *) value->next;
729 }
730 }
731
732 ir_constant *
zero(void * mem_ctx,const glsl_type * type)733 ir_constant::zero(void *mem_ctx, const glsl_type *type)
734 {
735 assert(type->is_scalar() || type->is_vector() || type->is_matrix()
736 || type->is_record() || type->is_array());
737
738 ir_constant *c = new(mem_ctx) ir_constant;
739 c->type = type;
740 memset(&c->value, 0, sizeof(c->value));
741
742 if (type->is_array()) {
743 c->array_elements = ralloc_array(c, ir_constant *, type->length);
744
745 for (unsigned i = 0; i < type->length; i++)
746 c->array_elements[i] = ir_constant::zero(c, type->element_type());
747 }
748
749 if (type->is_record()) {
750 for (unsigned i = 0; i < type->length; i++) {
751 ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
752 c->components.push_tail(comp);
753 }
754 }
755
756 return c;
757 }
758
759 bool
get_bool_component(unsigned i) const760 ir_constant::get_bool_component(unsigned i) const
761 {
762 switch (this->type->base_type) {
763 case GLSL_TYPE_UINT: return this->value.u[i] != 0;
764 case GLSL_TYPE_INT: return this->value.i[i] != 0;
765 case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
766 case GLSL_TYPE_BOOL: return this->value.b[i];
767 default: assert(!"Should not get here."); break;
768 }
769
770 /* Must return something to make the compiler happy. This is clearly an
771 * error case.
772 */
773 return false;
774 }
775
776 float
get_float_component(unsigned i) const777 ir_constant::get_float_component(unsigned i) const
778 {
779 switch (this->type->base_type) {
780 case GLSL_TYPE_UINT: return (float) this->value.u[i];
781 case GLSL_TYPE_INT: return (float) this->value.i[i];
782 case GLSL_TYPE_FLOAT: return this->value.f[i];
783 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0;
784 default: assert(!"Should not get here."); break;
785 }
786
787 /* Must return something to make the compiler happy. This is clearly an
788 * error case.
789 */
790 return 0.0;
791 }
792
793 int
get_int_component(unsigned i) const794 ir_constant::get_int_component(unsigned i) const
795 {
796 switch (this->type->base_type) {
797 case GLSL_TYPE_UINT: return this->value.u[i];
798 case GLSL_TYPE_INT: return this->value.i[i];
799 case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
800 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
801 default: assert(!"Should not get here."); break;
802 }
803
804 /* Must return something to make the compiler happy. This is clearly an
805 * error case.
806 */
807 return 0;
808 }
809
810 unsigned
get_uint_component(unsigned i) const811 ir_constant::get_uint_component(unsigned i) const
812 {
813 switch (this->type->base_type) {
814 case GLSL_TYPE_UINT: return this->value.u[i];
815 case GLSL_TYPE_INT: return this->value.i[i];
816 case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
817 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
818 default: assert(!"Should not get here."); break;
819 }
820
821 /* Must return something to make the compiler happy. This is clearly an
822 * error case.
823 */
824 return 0;
825 }
826
827 ir_constant *
get_array_element(unsigned i) const828 ir_constant::get_array_element(unsigned i) const
829 {
830 assert(this->type->is_array());
831
832 /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
833 *
834 * "Behavior is undefined if a shader subscripts an array with an index
835 * less than 0 or greater than or equal to the size the array was
836 * declared with."
837 *
838 * Most out-of-bounds accesses are removed before things could get this far.
839 * There are cases where non-constant array index values can get constant
840 * folded.
841 */
842 if (int(i) < 0)
843 i = 0;
844 else if (i >= this->type->length)
845 i = this->type->length - 1;
846
847 return array_elements[i];
848 }
849
850 ir_constant *
get_record_field(const char * name)851 ir_constant::get_record_field(const char *name)
852 {
853 int idx = this->type->field_index(name);
854
855 if (idx < 0)
856 return NULL;
857
858 if (this->components.is_empty())
859 return NULL;
860
861 exec_node *node = this->components.head;
862 for (int i = 0; i < idx; i++) {
863 node = node->next;
864
865 /* If the end of the list is encountered before the element matching the
866 * requested field is found, return NULL.
867 */
868 if (node->is_tail_sentinel())
869 return NULL;
870 }
871
872 return (ir_constant *) node;
873 }
874
875 void
copy_offset(ir_constant * src,int offset)876 ir_constant::copy_offset(ir_constant *src, int offset)
877 {
878 switch (this->type->base_type) {
879 case GLSL_TYPE_UINT:
880 case GLSL_TYPE_INT:
881 case GLSL_TYPE_FLOAT:
882 case GLSL_TYPE_BOOL: {
883 unsigned int size = src->type->components();
884 assert (size <= this->type->components() - offset);
885 for (unsigned int i=0; i<size; i++) {
886 switch (this->type->base_type) {
887 case GLSL_TYPE_UINT:
888 value.u[i+offset] = src->get_uint_component(i);
889 break;
890 case GLSL_TYPE_INT:
891 value.i[i+offset] = src->get_int_component(i);
892 break;
893 case GLSL_TYPE_FLOAT:
894 value.f[i+offset] = src->get_float_component(i);
895 break;
896 case GLSL_TYPE_BOOL:
897 value.b[i+offset] = src->get_bool_component(i);
898 break;
899 default: // Shut up the compiler
900 break;
901 }
902 }
903 break;
904 }
905
906 case GLSL_TYPE_STRUCT: {
907 assert (src->type == this->type);
908 this->components.make_empty();
909 foreach_list(node, &src->components) {
910 ir_constant *const orig = (ir_constant *) node;
911
912 this->components.push_tail(orig->clone(this, NULL));
913 }
914 break;
915 }
916
917 case GLSL_TYPE_ARRAY: {
918 assert (src->type == this->type);
919 for (unsigned i = 0; i < this->type->length; i++) {
920 this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
921 }
922 break;
923 }
924
925 default:
926 assert(!"Should not get here.");
927 break;
928 }
929 }
930
931 void
copy_masked_offset(ir_constant * src,int offset,unsigned int mask)932 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
933 {
934 assert (!type->is_array() && !type->is_record());
935
936 if (!type->is_vector() && !type->is_matrix()) {
937 offset = 0;
938 mask = 1;
939 }
940
941 int id = 0;
942 for (int i=0; i<4; i++) {
943 if (mask & (1 << i)) {
944 switch (this->type->base_type) {
945 case GLSL_TYPE_UINT:
946 value.u[i+offset] = src->get_uint_component(id++);
947 break;
948 case GLSL_TYPE_INT:
949 value.i[i+offset] = src->get_int_component(id++);
950 break;
951 case GLSL_TYPE_FLOAT:
952 value.f[i+offset] = src->get_float_component(id++);
953 break;
954 case GLSL_TYPE_BOOL:
955 value.b[i+offset] = src->get_bool_component(id++);
956 break;
957 default:
958 assert(!"Should not get here.");
959 return;
960 }
961 }
962 }
963 }
964
965 bool
has_value(const ir_constant * c) const966 ir_constant::has_value(const ir_constant *c) const
967 {
968 if (this->type != c->type)
969 return false;
970
971 if (this->type->is_array()) {
972 for (unsigned i = 0; i < this->type->length; i++) {
973 if (!this->array_elements[i]->has_value(c->array_elements[i]))
974 return false;
975 }
976 return true;
977 }
978
979 if (this->type->base_type == GLSL_TYPE_STRUCT) {
980 const exec_node *a_node = this->components.head;
981 const exec_node *b_node = c->components.head;
982
983 while (!a_node->is_tail_sentinel()) {
984 assert(!b_node->is_tail_sentinel());
985
986 const ir_constant *const a_field = (ir_constant *) a_node;
987 const ir_constant *const b_field = (ir_constant *) b_node;
988
989 if (!a_field->has_value(b_field))
990 return false;
991
992 a_node = a_node->next;
993 b_node = b_node->next;
994 }
995
996 return true;
997 }
998
999 for (unsigned i = 0; i < this->type->components(); i++) {
1000 switch (this->type->base_type) {
1001 case GLSL_TYPE_UINT:
1002 if (this->value.u[i] != c->value.u[i])
1003 return false;
1004 break;
1005 case GLSL_TYPE_INT:
1006 if (this->value.i[i] != c->value.i[i])
1007 return false;
1008 break;
1009 case GLSL_TYPE_FLOAT:
1010 if (this->value.f[i] != c->value.f[i])
1011 return false;
1012 break;
1013 case GLSL_TYPE_BOOL:
1014 if (this->value.b[i] != c->value.b[i])
1015 return false;
1016 break;
1017 default:
1018 assert(!"Should not get here.");
1019 return false;
1020 }
1021 }
1022
1023 return true;
1024 }
1025
1026 bool
is_zero() const1027 ir_constant::is_zero() const
1028 {
1029 if (!this->type->is_scalar() && !this->type->is_vector())
1030 return false;
1031
1032 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1033 switch (this->type->base_type) {
1034 case GLSL_TYPE_FLOAT:
1035 if (this->value.f[c] != 0.0)
1036 return false;
1037 break;
1038 case GLSL_TYPE_INT:
1039 if (this->value.i[c] != 0)
1040 return false;
1041 break;
1042 case GLSL_TYPE_UINT:
1043 if (this->value.u[c] != 0)
1044 return false;
1045 break;
1046 case GLSL_TYPE_BOOL:
1047 if (this->value.b[c] != false)
1048 return false;
1049 break;
1050 default:
1051 /* The only other base types are structures, arrays, and samplers.
1052 * Samplers cannot be constants, and the others should have been
1053 * filtered out above.
1054 */
1055 assert(!"Should not get here.");
1056 return false;
1057 }
1058 }
1059
1060 return true;
1061 }
1062
1063 bool
is_one() const1064 ir_constant::is_one() const
1065 {
1066 if (!this->type->is_scalar() && !this->type->is_vector())
1067 return false;
1068
1069 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1070 switch (this->type->base_type) {
1071 case GLSL_TYPE_FLOAT:
1072 if (this->value.f[c] != 1.0)
1073 return false;
1074 break;
1075 case GLSL_TYPE_INT:
1076 if (this->value.i[c] != 1)
1077 return false;
1078 break;
1079 case GLSL_TYPE_UINT:
1080 if (this->value.u[c] != 1)
1081 return false;
1082 break;
1083 case GLSL_TYPE_BOOL:
1084 if (this->value.b[c] != true)
1085 return false;
1086 break;
1087 default:
1088 /* The only other base types are structures, arrays, and samplers.
1089 * Samplers cannot be constants, and the others should have been
1090 * filtered out above.
1091 */
1092 assert(!"Should not get here.");
1093 return false;
1094 }
1095 }
1096
1097 return true;
1098 }
1099
1100 bool
is_negative_one() const1101 ir_constant::is_negative_one() const
1102 {
1103 if (!this->type->is_scalar() && !this->type->is_vector())
1104 return false;
1105
1106 if (this->type->is_boolean())
1107 return false;
1108
1109 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1110 switch (this->type->base_type) {
1111 case GLSL_TYPE_FLOAT:
1112 if (this->value.f[c] != -1.0)
1113 return false;
1114 break;
1115 case GLSL_TYPE_INT:
1116 if (this->value.i[c] != -1)
1117 return false;
1118 break;
1119 case GLSL_TYPE_UINT:
1120 if (int(this->value.u[c]) != -1)
1121 return false;
1122 break;
1123 default:
1124 /* The only other base types are structures, arrays, samplers, and
1125 * booleans. Samplers cannot be constants, and the others should
1126 * have been filtered out above.
1127 */
1128 assert(!"Should not get here.");
1129 return false;
1130 }
1131 }
1132
1133 return true;
1134 }
1135
1136 bool
is_basis() const1137 ir_constant::is_basis() const
1138 {
1139 if (!this->type->is_scalar() && !this->type->is_vector())
1140 return false;
1141
1142 if (this->type->is_boolean())
1143 return false;
1144
1145 unsigned ones = 0;
1146 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1147 switch (this->type->base_type) {
1148 case GLSL_TYPE_FLOAT:
1149 if (this->value.f[c] == 1.0)
1150 ones++;
1151 else if (this->value.f[c] != 0.0)
1152 return false;
1153 break;
1154 case GLSL_TYPE_INT:
1155 if (this->value.i[c] == 1)
1156 ones++;
1157 else if (this->value.i[c] != 0)
1158 return false;
1159 break;
1160 case GLSL_TYPE_UINT:
1161 if (int(this->value.u[c]) == 1)
1162 ones++;
1163 else if (int(this->value.u[c]) != 0)
1164 return false;
1165 break;
1166 default:
1167 /* The only other base types are structures, arrays, samplers, and
1168 * booleans. Samplers cannot be constants, and the others should
1169 * have been filtered out above.
1170 */
1171 assert(!"Should not get here.");
1172 return false;
1173 }
1174 }
1175
1176 return ones == 1;
1177 }
1178
ir_loop()1179 ir_loop::ir_loop()
1180 {
1181 this->ir_type = ir_type_loop;
1182 this->cmp = ir_unop_neg;
1183 this->from = NULL;
1184 this->to = NULL;
1185 this->increment = NULL;
1186 this->counter = NULL;
1187 }
1188
1189
ir_dereference_variable(ir_variable * var)1190 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1191 {
1192 assert(var != NULL);
1193
1194 this->ir_type = ir_type_dereference_variable;
1195 this->var = var;
1196 this->type = var->type;
1197 }
1198
1199
ir_dereference_array(ir_rvalue * value,ir_rvalue * array_index)1200 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1201 ir_rvalue *array_index)
1202 {
1203 this->ir_type = ir_type_dereference_array;
1204 this->array_index = array_index;
1205 this->set_array(value);
1206 }
1207
1208
ir_dereference_array(ir_variable * var,ir_rvalue * array_index)1209 ir_dereference_array::ir_dereference_array(ir_variable *var,
1210 ir_rvalue *array_index)
1211 {
1212 void *ctx = ralloc_parent(var);
1213
1214 this->ir_type = ir_type_dereference_array;
1215 this->array_index = array_index;
1216 this->set_array(new(ctx) ir_dereference_variable(var));
1217 }
1218
1219
1220 void
set_array(ir_rvalue * value)1221 ir_dereference_array::set_array(ir_rvalue *value)
1222 {
1223 assert(value != NULL);
1224
1225 this->array = value;
1226
1227 const glsl_type *const vt = this->array->type;
1228
1229 if (vt->is_array()) {
1230 type = vt->element_type();
1231 } else if (vt->is_matrix()) {
1232 type = vt->column_type();
1233 } else if (vt->is_vector()) {
1234 type = vt->get_base_type();
1235 }
1236 }
1237
1238
ir_dereference_record(ir_rvalue * value,const char * field)1239 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1240 const char *field)
1241 {
1242 assert(value != NULL);
1243
1244 this->ir_type = ir_type_dereference_record;
1245 this->record = value;
1246 this->field = ralloc_strdup(this, field);
1247 this->type = this->record->type->field_type(field);
1248 }
1249
1250
ir_dereference_record(ir_variable * var,const char * field)1251 ir_dereference_record::ir_dereference_record(ir_variable *var,
1252 const char *field)
1253 {
1254 void *ctx = ralloc_parent(var);
1255
1256 this->ir_type = ir_type_dereference_record;
1257 this->record = new(ctx) ir_dereference_variable(var);
1258 this->field = ralloc_strdup(this, field);
1259 this->type = this->record->type->field_type(field);
1260 }
1261
1262 bool
is_lvalue() const1263 ir_dereference::is_lvalue() const
1264 {
1265 ir_variable *var = this->variable_referenced();
1266
1267 /* Every l-value derference chain eventually ends in a variable.
1268 */
1269 if ((var == NULL) || var->read_only)
1270 return false;
1271
1272 /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
1273 *
1274 * "Samplers cannot be treated as l-values; hence cannot be used
1275 * as out or inout function parameters, nor can they be
1276 * assigned into."
1277 */
1278 if (this->type->contains_sampler())
1279 return false;
1280
1281 return true;
1282 }
1283
1284
1285 const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txs" };
1286
opcode_string()1287 const char *ir_texture::opcode_string()
1288 {
1289 assert((unsigned int) op <=
1290 sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
1291 return tex_opcode_strs[op];
1292 }
1293
1294 ir_texture_opcode
get_opcode(const char * str)1295 ir_texture::get_opcode(const char *str)
1296 {
1297 const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1298 for (int op = 0; op < count; op++) {
1299 if (strcmp(str, tex_opcode_strs[op]) == 0)
1300 return (ir_texture_opcode) op;
1301 }
1302 return (ir_texture_opcode) -1;
1303 }
1304
1305
1306 void
set_sampler(ir_dereference * sampler,const glsl_type * type)1307 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1308 {
1309 assert(sampler != NULL);
1310 assert(type != NULL);
1311 this->sampler = sampler;
1312 this->type = type;
1313
1314 if (this->op == ir_txs) {
1315 assert(type->base_type == GLSL_TYPE_INT);
1316 } else {
1317 assert(sampler->type->sampler_type == (int) type->base_type);
1318 if (sampler->type->sampler_shadow)
1319 assert(type->vector_elements == 4 || type->vector_elements == 1);
1320 else
1321 assert(type->vector_elements == 4);
1322 }
1323 }
1324
1325
1326 void
init_mask(const unsigned * comp,unsigned count)1327 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1328 {
1329 assert((count >= 1) && (count <= 4));
1330
1331 memset(&this->mask, 0, sizeof(this->mask));
1332 this->mask.num_components = count;
1333
1334 unsigned dup_mask = 0;
1335 switch (count) {
1336 case 4:
1337 assert(comp[3] <= 3);
1338 dup_mask |= (1U << comp[3])
1339 & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1340 this->mask.w = comp[3];
1341
1342 case 3:
1343 assert(comp[2] <= 3);
1344 dup_mask |= (1U << comp[2])
1345 & ((1U << comp[0]) | (1U << comp[1]));
1346 this->mask.z = comp[2];
1347
1348 case 2:
1349 assert(comp[1] <= 3);
1350 dup_mask |= (1U << comp[1])
1351 & ((1U << comp[0]));
1352 this->mask.y = comp[1];
1353
1354 case 1:
1355 assert(comp[0] <= 3);
1356 this->mask.x = comp[0];
1357 }
1358
1359 this->mask.has_duplicates = dup_mask != 0;
1360
1361 /* Based on the number of elements in the swizzle and the base type
1362 * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1363 * generate the type of the resulting value.
1364 */
1365 type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1366 }
1367
ir_swizzle(ir_rvalue * val,unsigned x,unsigned y,unsigned z,unsigned w,unsigned count)1368 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1369 unsigned w, unsigned count)
1370 : val(val)
1371 {
1372 const unsigned components[4] = { x, y, z, w };
1373 this->ir_type = ir_type_swizzle;
1374 this->init_mask(components, count);
1375 }
1376
ir_swizzle(ir_rvalue * val,const unsigned * comp,unsigned count)1377 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1378 unsigned count)
1379 : val(val)
1380 {
1381 this->ir_type = ir_type_swizzle;
1382 this->init_mask(comp, count);
1383 }
1384
ir_swizzle(ir_rvalue * val,ir_swizzle_mask mask)1385 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1386 {
1387 this->ir_type = ir_type_swizzle;
1388 this->val = val;
1389 this->mask = mask;
1390 this->type = glsl_type::get_instance(val->type->base_type,
1391 mask.num_components, 1);
1392 }
1393
1394 #define X 1
1395 #define R 5
1396 #define S 9
1397 #define I 13
1398
1399 ir_swizzle *
create(ir_rvalue * val,const char * str,unsigned vector_length)1400 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1401 {
1402 void *ctx = ralloc_parent(val);
1403
1404 /* For each possible swizzle character, this table encodes the value in
1405 * \c idx_map that represents the 0th element of the vector. For invalid
1406 * swizzle characters (e.g., 'k'), a special value is used that will allow
1407 * detection of errors.
1408 */
1409 static const unsigned char base_idx[26] = {
1410 /* a b c d e f g h i j k l m */
1411 R, R, I, I, I, I, R, I, I, I, I, I, I,
1412 /* n o p q r s t u v w x y z */
1413 I, I, S, S, R, S, S, I, I, X, X, X, X
1414 };
1415
1416 /* Each valid swizzle character has an entry in the previous table. This
1417 * table encodes the base index encoded in the previous table plus the actual
1418 * index of the swizzle character. When processing swizzles, the first
1419 * character in the string is indexed in the previous table. Each character
1420 * in the string is indexed in this table, and the value found there has the
1421 * value form the first table subtracted. The result must be on the range
1422 * [0,3].
1423 *
1424 * For example, the string "wzyx" will get X from the first table. Each of
1425 * the charcaters will get X+3, X+2, X+1, and X+0 from this table. After
1426 * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1427 *
1428 * The string "wzrg" will get X from the first table. Each of the characters
1429 * will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the
1430 * swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range
1431 * [0,3], the error is detected.
1432 */
1433 static const unsigned char idx_map[26] = {
1434 /* a b c d e f g h i j k l m */
1435 R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,
1436 /* n o p q r s t u v w x y z */
1437 0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2
1438 };
1439
1440 int swiz_idx[4] = { 0, 0, 0, 0 };
1441 unsigned i;
1442
1443
1444 /* Validate the first character in the swizzle string and look up the base
1445 * index value as described above.
1446 */
1447 if ((str[0] < 'a') || (str[0] > 'z'))
1448 return NULL;
1449
1450 const unsigned base = base_idx[str[0] - 'a'];
1451
1452
1453 for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1454 /* Validate the next character, and, as described above, convert it to a
1455 * swizzle index.
1456 */
1457 if ((str[i] < 'a') || (str[i] > 'z'))
1458 return NULL;
1459
1460 swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1461 if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1462 return NULL;
1463 }
1464
1465 if (str[i] != '\0')
1466 return NULL;
1467
1468 return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1469 swiz_idx[3], i);
1470 }
1471
1472 #undef X
1473 #undef R
1474 #undef S
1475 #undef I
1476
1477 ir_variable *
variable_referenced() const1478 ir_swizzle::variable_referenced() const
1479 {
1480 return this->val->variable_referenced();
1481 }
1482
1483
ir_variable(const struct glsl_type * type,const char * name,ir_variable_mode mode)1484 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1485 ir_variable_mode mode)
1486 : max_array_access(0), read_only(false), centroid(false), invariant(false),
1487 mode(mode), interpolation(INTERP_QUALIFIER_NONE)
1488 {
1489 this->ir_type = ir_type_variable;
1490 this->type = type;
1491 this->name = ralloc_strdup(this, name);
1492 this->explicit_location = false;
1493 this->has_initializer = false;
1494 this->location = -1;
1495 this->uniform_block = -1;
1496 this->warn_extension = NULL;
1497 this->constant_value = NULL;
1498 this->constant_initializer = NULL;
1499 this->origin_upper_left = false;
1500 this->pixel_center_integer = false;
1501 this->depth_layout = ir_depth_layout_none;
1502 this->used = false;
1503
1504 if (type && type->base_type == GLSL_TYPE_SAMPLER)
1505 this->read_only = true;
1506 }
1507
1508
1509 const char *
interpolation_string() const1510 ir_variable::interpolation_string() const
1511 {
1512 switch (this->interpolation) {
1513 case INTERP_QUALIFIER_NONE: return "no";
1514 case INTERP_QUALIFIER_SMOOTH: return "smooth";
1515 case INTERP_QUALIFIER_FLAT: return "flat";
1516 case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective";
1517 }
1518
1519 assert(!"Should not get here.");
1520 return "";
1521 }
1522
1523
1524 glsl_interp_qualifier
determine_interpolation_mode(bool flat_shade)1525 ir_variable::determine_interpolation_mode(bool flat_shade)
1526 {
1527 if (this->interpolation != INTERP_QUALIFIER_NONE)
1528 return (glsl_interp_qualifier) this->interpolation;
1529 int location = this->location;
1530 bool is_gl_Color =
1531 location == FRAG_ATTRIB_COL0 || location == FRAG_ATTRIB_COL1;
1532 if (flat_shade && is_gl_Color)
1533 return INTERP_QUALIFIER_FLAT;
1534 else
1535 return INTERP_QUALIFIER_SMOOTH;
1536 }
1537
1538
ir_function_signature(const glsl_type * return_type)1539 ir_function_signature::ir_function_signature(const glsl_type *return_type)
1540 : return_type(return_type), is_defined(false), _function(NULL)
1541 {
1542 this->ir_type = ir_type_function_signature;
1543 this->is_builtin = false;
1544 this->origin = NULL;
1545 }
1546
1547
1548 static bool
modes_match(unsigned a,unsigned b)1549 modes_match(unsigned a, unsigned b)
1550 {
1551 if (a == b)
1552 return true;
1553
1554 /* Accept "in" vs. "const in" */
1555 if ((a == ir_var_const_in && b == ir_var_in) ||
1556 (b == ir_var_const_in && a == ir_var_in))
1557 return true;
1558
1559 return false;
1560 }
1561
1562
1563 const char *
qualifiers_match(exec_list * params)1564 ir_function_signature::qualifiers_match(exec_list *params)
1565 {
1566 exec_list_iterator iter_a = parameters.iterator();
1567 exec_list_iterator iter_b = params->iterator();
1568
1569 /* check that the qualifiers match. */
1570 while (iter_a.has_next()) {
1571 ir_variable *a = (ir_variable *)iter_a.get();
1572 ir_variable *b = (ir_variable *)iter_b.get();
1573
1574 if (a->read_only != b->read_only ||
1575 !modes_match(a->mode, b->mode) ||
1576 a->interpolation != b->interpolation ||
1577 a->centroid != b->centroid) {
1578
1579 /* parameter a's qualifiers don't match */
1580 return a->name;
1581 }
1582
1583 iter_a.next();
1584 iter_b.next();
1585 }
1586 return NULL;
1587 }
1588
1589
1590 void
replace_parameters(exec_list * new_params)1591 ir_function_signature::replace_parameters(exec_list *new_params)
1592 {
1593 /* Destroy all of the previous parameter information. If the previous
1594 * parameter information comes from the function prototype, it may either
1595 * specify incorrect parameter names or not have names at all.
1596 */
1597 foreach_iter(exec_list_iterator, iter, parameters) {
1598 assert(((ir_instruction *) iter.get())->as_variable() != NULL);
1599
1600 iter.remove();
1601 }
1602
1603 new_params->move_nodes_to(¶meters);
1604 }
1605
1606
ir_function(const char * name)1607 ir_function::ir_function(const char *name)
1608 {
1609 this->ir_type = ir_type_function;
1610 this->name = ralloc_strdup(this, name);
1611 }
1612
1613
1614 bool
has_user_signature()1615 ir_function::has_user_signature()
1616 {
1617 foreach_list(n, &this->signatures) {
1618 ir_function_signature *const sig = (ir_function_signature *) n;
1619 if (!sig->is_builtin)
1620 return true;
1621 }
1622 return false;
1623 }
1624
1625
1626 ir_rvalue *
error_value(void * mem_ctx)1627 ir_rvalue::error_value(void *mem_ctx)
1628 {
1629 ir_rvalue *v = new(mem_ctx) ir_rvalue;
1630
1631 v->type = glsl_type::error_type;
1632 return v;
1633 }
1634
1635
1636 void
visit_exec_list(exec_list * list,ir_visitor * visitor)1637 visit_exec_list(exec_list *list, ir_visitor *visitor)
1638 {
1639 foreach_iter(exec_list_iterator, iter, *list) {
1640 ((ir_instruction *)iter.get())->accept(visitor);
1641 }
1642 }
1643
1644
1645 static void
steal_memory(ir_instruction * ir,void * new_ctx)1646 steal_memory(ir_instruction *ir, void *new_ctx)
1647 {
1648 ir_variable *var = ir->as_variable();
1649 ir_constant *constant = ir->as_constant();
1650 if (var != NULL && var->constant_value != NULL)
1651 steal_memory(var->constant_value, ir);
1652
1653 if (var != NULL && var->constant_initializer != NULL)
1654 steal_memory(var->constant_initializer, ir);
1655
1656 /* The components of aggregate constants are not visited by the normal
1657 * visitor, so steal their values by hand.
1658 */
1659 if (constant != NULL) {
1660 if (constant->type->is_record()) {
1661 foreach_iter(exec_list_iterator, iter, constant->components) {
1662 ir_constant *field = (ir_constant *)iter.get();
1663 steal_memory(field, ir);
1664 }
1665 } else if (constant->type->is_array()) {
1666 for (unsigned int i = 0; i < constant->type->length; i++) {
1667 steal_memory(constant->array_elements[i], ir);
1668 }
1669 }
1670 }
1671
1672 ralloc_steal(new_ctx, ir);
1673 }
1674
1675
1676 void
reparent_ir(exec_list * list,void * mem_ctx)1677 reparent_ir(exec_list *list, void *mem_ctx)
1678 {
1679 foreach_list(node, list) {
1680 visit_tree((ir_instruction *) node, steal_memory, mem_ctx);
1681 }
1682 }
1683
1684
1685 static ir_rvalue *
try_min_one(ir_rvalue * ir)1686 try_min_one(ir_rvalue *ir)
1687 {
1688 ir_expression *expr = ir->as_expression();
1689
1690 if (!expr || expr->operation != ir_binop_min)
1691 return NULL;
1692
1693 if (expr->operands[0]->is_one())
1694 return expr->operands[1];
1695
1696 if (expr->operands[1]->is_one())
1697 return expr->operands[0];
1698
1699 return NULL;
1700 }
1701
1702 static ir_rvalue *
try_max_zero(ir_rvalue * ir)1703 try_max_zero(ir_rvalue *ir)
1704 {
1705 ir_expression *expr = ir->as_expression();
1706
1707 if (!expr || expr->operation != ir_binop_max)
1708 return NULL;
1709
1710 if (expr->operands[0]->is_zero())
1711 return expr->operands[1];
1712
1713 if (expr->operands[1]->is_zero())
1714 return expr->operands[0];
1715
1716 return NULL;
1717 }
1718
1719 ir_rvalue *
as_rvalue_to_saturate()1720 ir_rvalue::as_rvalue_to_saturate()
1721 {
1722 ir_expression *expr = this->as_expression();
1723
1724 if (!expr)
1725 return NULL;
1726
1727 ir_rvalue *max_zero = try_max_zero(expr);
1728 if (max_zero) {
1729 return try_min_one(max_zero);
1730 } else {
1731 ir_rvalue *min_one = try_min_one(expr);
1732 if (min_one) {
1733 return try_max_zero(min_one);
1734 }
1735 }
1736
1737 return NULL;
1738 }
1739