projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
glsl: add missing null check in tfeedback_decl::init()
[mesa.git] / src / glsl / ir_constant_expression.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
24 /**
25 * \file ir_constant_expression.cpp
26 * Evaluate and process constant valued expressions
27 *
28 * In GLSL, constant valued expressions are used in several places. These
29 * must be processed and evaluated very early in the compilation process.
30 *
31 * * Sizes of arrays
32 * * Initializers for uniforms
33 * * Initializers for \c const variables
34 */
35
36 #include <math.h>
37 #include "main/core.h" /* for MAX2, MIN2, CLAMP */
38 #include "ir.h"
39 #include "glsl_types.h"
40 #include "program/hash_table.h"
41
42 #if defined(_MSC_VER) && (_MSC_VER < 1800)
43 static int isnormal(double x)
44 {
45 return _fpclass(x) == _FPCLASS_NN || _fpclass(x) == _FPCLASS_PN;
46 }
47 #elif defined(__SUNPRO_CC)
48 #include <ieeefp.h>
49 static int isnormal(double x)
50 {
51 return fpclass(x) == FP_NORMAL;
52 }
53 #endif
54
55 #if defined(_MSC_VER)
56 static double copysign(double x, double y)
57 {
58 return _copysign(x, y);
59 }
60 #endif
61
62 static float
63 dot(ir_constant *op0, ir_constant *op1)
64 {
65 assert(op0->type->is_float() && op1->type->is_float());
66
67 float result = 0;
68 for (unsigned c = 0; c < op0->type->components(); c++)
69 result += op0->value.f[c] * op1->value.f[c];
70
71 return result;
72 }
73
74 /* This method is the only one supported by gcc. Unions in particular
75 * are iffy, and read-through-converted-pointer is killed by strict
76 * aliasing. OTOH, the compiler sees through the memcpy, so the
77 * resulting asm is reasonable.
78 */
79 static float
80 bitcast_u2f(unsigned int u)
81 {
82 assert(sizeof(float) == sizeof(unsigned int));
83 float f;
84 memcpy(&f, &u, sizeof(f));
85 return f;
86 }
87
88 static unsigned int
89 bitcast_f2u(float f)
90 {
91 assert(sizeof(float) == sizeof(unsigned int));
92 unsigned int u;
93 memcpy(&u, &f, sizeof(f));
94 return u;
95 }
96
97 /**
98 * Evaluate one component of a floating-point 4x8 unpacking function.
99 */
100 typedef uint8_t
101 (*pack_1x8_func_t)(float);
102
103 /**
104 * Evaluate one component of a floating-point 2x16 unpacking function.
105 */
106 typedef uint16_t
107 (*pack_1x16_func_t)(float);
108
109 /**
110 * Evaluate one component of a floating-point 4x8 unpacking function.
111 */
112 typedef float
113 (*unpack_1x8_func_t)(uint8_t);
114
115 /**
116 * Evaluate one component of a floating-point 2x16 unpacking function.
117 */
118 typedef float
119 (*unpack_1x16_func_t)(uint16_t);
120
121 /**
122 * Evaluate a 2x16 floating-point packing function.
123 */
124 static uint32_t
125 pack_2x16(pack_1x16_func_t pack_1x16,
126 float x, float y)
127 {
128 /* From section 8.4 of the GLSL ES 3.00 spec:
129 *
130 * packSnorm2x16
131 * -------------
132 * The first component of the vector will be written to the least
133 * significant bits of the output; the last component will be written to
134 * the most significant bits.
135 *
136 * The specifications for the other packing functions contain similar
137 * language.
138 */
139 uint32_t u = 0;
140 u |= ((uint32_t) pack_1x16(x) << 0);
141 u |= ((uint32_t) pack_1x16(y) << 16);
142 return u;
143 }
144
145 /**
146 * Evaluate a 4x8 floating-point packing function.
147 */
148 static uint32_t
149 pack_4x8(pack_1x8_func_t pack_1x8,
150 float x, float y, float z, float w)
151 {
152 /* From section 8.4 of the GLSL 4.30 spec:
153 *
154 * packSnorm4x8
155 * ------------
156 * The first component of the vector will be written to the least
157 * significant bits of the output; the last component will be written to
158 * the most significant bits.
159 *
160 * The specifications for the other packing functions contain similar
161 * language.
162 */
163 uint32_t u = 0;
164 u |= ((uint32_t) pack_1x8(x) << 0);
165 u |= ((uint32_t) pack_1x8(y) << 8);
166 u |= ((uint32_t) pack_1x8(z) << 16);
167 u |= ((uint32_t) pack_1x8(w) << 24);
168 return u;
169 }
170
171 /**
172 * Evaluate a 2x16 floating-point unpacking function.
173 */
174 static void
175 unpack_2x16(unpack_1x16_func_t unpack_1x16,
176 uint32_t u,
177 float *x, float *y)
178 {
179 /* From section 8.4 of the GLSL ES 3.00 spec:
180 *
181 * unpackSnorm2x16
182 * ---------------
183 * The first component of the returned vector will be extracted from
184 * the least significant bits of the input; the last component will be
185 * extracted from the most significant bits.
186 *
187 * The specifications for the other unpacking functions contain similar
188 * language.
189 */
190 *x = unpack_1x16((uint16_t) (u & 0xffff));
191 *y = unpack_1x16((uint16_t) (u >> 16));
192 }
193
194 /**
195 * Evaluate a 4x8 floating-point unpacking function.
196 */
197 static void
198 unpack_4x8(unpack_1x8_func_t unpack_1x8, uint32_t u,
199 float *x, float *y, float *z, float *w)
200 {
201 /* From section 8.4 of the GLSL 4.30 spec:
202 *
203 * unpackSnorm4x8
204 * --------------
205 * The first component of the returned vector will be extracted from
206 * the least significant bits of the input; the last component will be
207 * extracted from the most significant bits.
208 *
209 * The specifications for the other unpacking functions contain similar
210 * language.
211 */
212 *x = unpack_1x8((uint8_t) (u & 0xff));
213 *y = unpack_1x8((uint8_t) (u >> 8));
214 *z = unpack_1x8((uint8_t) (u >> 16));
215 *w = unpack_1x8((uint8_t) (u >> 24));
216 }
217
218 /**
219 * Evaluate one component of packSnorm4x8.
220 */
221 static uint8_t
222 pack_snorm_1x8(float x)
223 {
224 /* From section 8.4 of the GLSL 4.30 spec:
225 *
226 * packSnorm4x8
227 * ------------
228 * The conversion for component c of v to fixed point is done as
229 * follows:
230 *
231 * packSnorm4x8: round(clamp(c, -1, +1) * 127.0)
232 *
233 * We must first cast the float to an int, because casting a negative
234 * float to a uint is undefined.
235 */
236 return (uint8_t) (int8_t)
237 _mesa_round_to_even(CLAMP(x, -1.0f, +1.0f) * 127.0f);
238 }
239
240 /**
241 * Evaluate one component of packSnorm2x16.
242 */
243 static uint16_t
244 pack_snorm_1x16(float x)
245 {
246 /* From section 8.4 of the GLSL ES 3.00 spec:
247 *
248 * packSnorm2x16
249 * -------------
250 * The conversion for component c of v to fixed point is done as
251 * follows:
252 *
253 * packSnorm2x16: round(clamp(c, -1, +1) * 32767.0)
254 *
255 * We must first cast the float to an int, because casting a negative
256 * float to a uint is undefined.
257 */
258 return (uint16_t) (int16_t)
259 _mesa_round_to_even(CLAMP(x, -1.0f, +1.0f) * 32767.0f);
260 }
261
262 /**
263 * Evaluate one component of unpackSnorm4x8.
264 */
265 static float
266 unpack_snorm_1x8(uint8_t u)
267 {
268 /* From section 8.4 of the GLSL 4.30 spec:
269 *
270 * unpackSnorm4x8
271 * --------------
272 * The conversion for unpacked fixed-point value f to floating point is
273 * done as follows:
274 *
275 * unpackSnorm4x8: clamp(f / 127.0, -1, +1)
276 */
277 return CLAMP((int8_t) u / 127.0f, -1.0f, +1.0f);
278 }
279
280 /**
281 * Evaluate one component of unpackSnorm2x16.
282 */
283 static float
284 unpack_snorm_1x16(uint16_t u)
285 {
286 /* From section 8.4 of the GLSL ES 3.00 spec:
287 *
288 * unpackSnorm2x16
289 * ---------------
290 * The conversion for unpacked fixed-point value f to floating point is
291 * done as follows:
292 *
293 * unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
294 */
295 return CLAMP((int16_t) u / 32767.0f, -1.0f, +1.0f);
296 }
297
298 /**
299 * Evaluate one component packUnorm4x8.
300 */
301 static uint8_t
302 pack_unorm_1x8(float x)
303 {
304 /* From section 8.4 of the GLSL 4.30 spec:
305 *
306 * packUnorm4x8
307 * ------------
308 * The conversion for component c of v to fixed point is done as
309 * follows:
310 *
311 * packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
312 */
313 return (uint8_t) _mesa_round_to_even(CLAMP(x, 0.0f, 1.0f) * 255.0f);
314 }
315
316 /**
317 * Evaluate one component packUnorm2x16.
318 */
319 static uint16_t
320 pack_unorm_1x16(float x)
321 {
322 /* From section 8.4 of the GLSL ES 3.00 spec:
323 *
324 * packUnorm2x16
325 * -------------
326 * The conversion for component c of v to fixed point is done as
327 * follows:
328 *
329 * packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
330 */
331 return (uint16_t) _mesa_round_to_even(CLAMP(x, 0.0f, 1.0f) * 65535.0f);
332 }
333
334 /**
335 * Evaluate one component of unpackUnorm4x8.
336 */
337 static float
338 unpack_unorm_1x8(uint8_t u)
339 {
340 /* From section 8.4 of the GLSL 4.30 spec:
341 *
342 * unpackUnorm4x8
343 * --------------
344 * The conversion for unpacked fixed-point value f to floating point is
345 * done as follows:
346 *
347 * unpackUnorm4x8: f / 255.0
348 */
349 return (float) u / 255.0f;
350 }
351
352 /**
353 * Evaluate one component of unpackUnorm2x16.
354 */
355 static float
356 unpack_unorm_1x16(uint16_t u)
357 {
358 /* From section 8.4 of the GLSL ES 3.00 spec:
359 *
360 * unpackUnorm2x16
361 * ---------------
362 * The conversion for unpacked fixed-point value f to floating point is
363 * done as follows:
364 *
365 * unpackUnorm2x16: f / 65535.0
366 */
367 return (float) u / 65535.0f;
368 }
369
370 /**
371 * Evaluate one component of packHalf2x16.
372 */
373 static uint16_t
374 pack_half_1x16(float x)
375 {
376 return _mesa_float_to_half(x);
377 }
378
379 /**
380 * Evaluate one component of unpackHalf2x16.
381 */
382 static float
383 unpack_half_1x16(uint16_t u)
384 {
385 return _mesa_half_to_float(u);
386 }
387
388 /**
389 * Get the constant that is ultimately referenced by an r-value, in a constant
390 * expression evaluation context.
391 *
392 * The offset is used when the reference is to a specific column of a matrix.
393 */
394 static bool
395 constant_referenced(const ir_dereference *deref,
396 struct hash_table *variable_context,
397 ir_constant *&store, int &offset)
398 {
399 store = NULL;
400 offset = 0;
401
402 if (variable_context == NULL)
403 return false;
404
405 switch (deref->ir_type) {
406 case ir_type_dereference_array: {
407 const ir_dereference_array *const da =
408 (const ir_dereference_array *) deref;
409
410 ir_constant *const index_c =
411 da->array_index->constant_expression_value(variable_context);
412
413 if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer())
414 break;
415
416 const int index = index_c->type->base_type == GLSL_TYPE_INT ?
417 index_c->get_int_component(0) :
418 index_c->get_uint_component(0);
419
420 ir_constant *substore;
421 int suboffset;
422
423 const ir_dereference *const deref = da->array->as_dereference();
424 if (!deref)
425 break;
426
427 if (!constant_referenced(deref, variable_context, substore, suboffset))
428 break;
429
430 const glsl_type *const vt = da->array->type;
431 if (vt->is_array()) {
432 store = substore->get_array_element(index);
433 offset = 0;
434 } else if (vt->is_matrix()) {
435 store = substore;
436 offset = index * vt->vector_elements;
437 } else if (vt->is_vector()) {
438 store = substore;
439 offset = suboffset + index;
440 }
441
442 break;
443 }
444
445 case ir_type_dereference_record: {
446 const ir_dereference_record *const dr =
447 (const ir_dereference_record *) deref;
448
449 const ir_dereference *const deref = dr->record->as_dereference();
450 if (!deref)
451 break;
452
453 ir_constant *substore;
454 int suboffset;
455
456 if (!constant_referenced(deref, variable_context, substore, suboffset))
457 break;
458
459 /* Since we're dropping it on the floor...
460 */
461 assert(suboffset == 0);
462
463 store = substore->get_record_field(dr->field);
464 break;
465 }
466
467 case ir_type_dereference_variable: {
468 const ir_dereference_variable *const dv =
469 (const ir_dereference_variable *) deref;
470
471 store = (ir_constant *) hash_table_find(variable_context, dv->var);
472 break;
473 }
474
475 default:
476 assert(!"Should not get here.");
477 break;
478 }
479
480 return store != NULL;
481 }
482
483
484 ir_constant *
485 ir_rvalue::constant_expression_value(struct hash_table *)
486 {
487 assert(this->type->is_error());
488 return NULL;
489 }
490
491 ir_constant *
492 ir_expression::constant_expression_value(struct hash_table *variable_context)
493 {
494 if (this->type->is_error())
495 return NULL;
496
497 ir_constant *op[Elements(this->operands)] = { NULL, };
498 ir_constant_data data;
499
500 memset(&data, 0, sizeof(data));
501
502 for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
503 op[operand] = this->operands[operand]->constant_expression_value(variable_context);
504 if (!op[operand])
505 return NULL;
506 }
507
508 if (op[1] != NULL)
509 switch (this->operation) {
510 case ir_binop_lshift:
511 case ir_binop_rshift:
512 case ir_binop_ldexp:
513 case ir_binop_interpolate_at_offset:
514 case ir_binop_interpolate_at_sample:
515 case ir_binop_vector_extract:
516 case ir_triop_csel:
517 case ir_triop_bitfield_extract:
518 break;
519
520 default:
521 assert(op[0]->type->base_type == op[1]->type->base_type);
522 break;
523 }
524
525 bool op0_scalar = op[0]->type->is_scalar();
526 bool op1_scalar = op[1] != NULL && op[1]->type->is_scalar();
527
528 /* When iterating over a vector or matrix's components, we want to increase
529 * the loop counter. However, for scalars, we want to stay at 0.
530 */
531 unsigned c0_inc = op0_scalar ? 0 : 1;
532 unsigned c1_inc = op1_scalar ? 0 : 1;
533 unsigned components;
534 if (op1_scalar || !op[1]) {
535 components = op[0]->type->components();
536 } else {
537 components = op[1]->type->components();
538 }
539
540 void *ctx = ralloc_parent(this);
541
542 /* Handle array operations here, rather than below. */
543 if (op[0]->type->is_array()) {
544 assert(op[1] != NULL && op[1]->type->is_array());
545 switch (this->operation) {
546 case ir_binop_all_equal:
547 return new(ctx) ir_constant(op[0]->has_value(op[1]));
548 case ir_binop_any_nequal:
549 return new(ctx) ir_constant(!op[0]->has_value(op[1]));
550 default:
551 break;
552 }
553 return NULL;
554 }
555
556 switch (this->operation) {
557 case ir_unop_bit_not:
558 switch (op[0]->type->base_type) {
559 case GLSL_TYPE_INT:
560 for (unsigned c = 0; c < components; c++)
561 data.i[c] = ~ op[0]->value.i[c];
562 break;
563 case GLSL_TYPE_UINT:
564 for (unsigned c = 0; c < components; c++)
565 data.u[c] = ~ op[0]->value.u[c];
566 break;
567 default:
568 assert(0);
569 }
570 break;
571
572 case ir_unop_logic_not:
573 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
574 for (unsigned c = 0; c < op[0]->type->components(); c++)
575 data.b[c] = !op[0]->value.b[c];
576 break;
577
578 case ir_unop_f2i:
579 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
580 for (unsigned c = 0; c < op[0]->type->components(); c++) {
581 data.i[c] = (int) op[0]->value.f[c];
582 }
583 break;
584 case ir_unop_f2u:
585 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
586 for (unsigned c = 0; c < op[0]->type->components(); c++) {
587 data.i[c] = (unsigned) op[0]->value.f[c];
588 }
589 break;
590 case ir_unop_i2f:
591 assert(op[0]->type->base_type == GLSL_TYPE_INT);
592 for (unsigned c = 0; c < op[0]->type->components(); c++) {
593 data.f[c] = (float) op[0]->value.i[c];
594 }
595 break;
596 case ir_unop_u2f:
597 assert(op[0]->type->base_type == GLSL_TYPE_UINT);
598 for (unsigned c = 0; c < op[0]->type->components(); c++) {
599 data.f[c] = (float) op[0]->value.u[c];
600 }
601 break;
602 case ir_unop_b2f:
603 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
604 for (unsigned c = 0; c < op[0]->type->components(); c++) {
605 data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
606 }
607 break;
608 case ir_unop_f2b:
609 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
610 for (unsigned c = 0; c < op[0]->type->components(); c++) {
611 data.b[c] = op[0]->value.f[c] != 0.0F ? true : false;
612 }
613 break;
614 case ir_unop_b2i:
615 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
616 for (unsigned c = 0; c < op[0]->type->components(); c++) {
617 data.u[c] = op[0]->value.b[c] ? 1 : 0;
618 }
619 break;
620 case ir_unop_i2b:
621 assert(op[0]->type->is_integer());
622 for (unsigned c = 0; c < op[0]->type->components(); c++) {
623 data.b[c] = op[0]->value.u[c] ? true : false;
624 }
625 break;
626 case ir_unop_u2i:
627 assert(op[0]->type->base_type == GLSL_TYPE_UINT);
628 for (unsigned c = 0; c < op[0]->type->components(); c++) {
629 data.i[c] = op[0]->value.u[c];
630 }
631 break;
632 case ir_unop_i2u:
633 assert(op[0]->type->base_type == GLSL_TYPE_INT);
634 for (unsigned c = 0; c < op[0]->type->components(); c++) {
635 data.u[c] = op[0]->value.i[c];
636 }
637 break;
638 case ir_unop_bitcast_i2f:
639 assert(op[0]->type->base_type == GLSL_TYPE_INT);
640 for (unsigned c = 0; c < op[0]->type->components(); c++) {
641 data.f[c] = bitcast_u2f(op[0]->value.i[c]);
642 }
643 break;
644 case ir_unop_bitcast_f2i:
645 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
646 for (unsigned c = 0; c < op[0]->type->components(); c++) {
647 data.i[c] = bitcast_f2u(op[0]->value.f[c]);
648 }
649 break;
650 case ir_unop_bitcast_u2f:
651 assert(op[0]->type->base_type == GLSL_TYPE_UINT);
652 for (unsigned c = 0; c < op[0]->type->components(); c++) {
653 data.f[c] = bitcast_u2f(op[0]->value.u[c]);
654 }
655 break;
656 case ir_unop_bitcast_f2u:
657 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
658 for (unsigned c = 0; c < op[0]->type->components(); c++) {
659 data.u[c] = bitcast_f2u(op[0]->value.f[c]);
660 }
661 break;
662 case ir_unop_any:
663 assert(op[0]->type->is_boolean());
664 data.b[0] = false;
665 for (unsigned c = 0; c < op[0]->type->components(); c++) {
666 if (op[0]->value.b[c])
667 data.b[0] = true;
668 }
669 break;
670
671 case ir_unop_trunc:
672 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
673 for (unsigned c = 0; c < op[0]->type->components(); c++) {
674 data.f[c] = truncf(op[0]->value.f[c]);
675 }
676 break;
677
678 case ir_unop_round_even:
679 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
680 for (unsigned c = 0; c < op[0]->type->components(); c++) {
681 data.f[c] = _mesa_round_to_even(op[0]->value.f[c]);
682 }
683 break;
684
685 case ir_unop_ceil:
686 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
687 for (unsigned c = 0; c < op[0]->type->components(); c++) {
688 data.f[c] = ceilf(op[0]->value.f[c]);
689 }
690 break;
691
692 case ir_unop_floor:
693 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
694 for (unsigned c = 0; c < op[0]->type->components(); c++) {
695 data.f[c] = floorf(op[0]->value.f[c]);
696 }
697 break;
698
699 case ir_unop_fract:
700 for (unsigned c = 0; c < op[0]->type->components(); c++) {
701 switch (this->type->base_type) {
702 case GLSL_TYPE_UINT:
703 data.u[c] = 0;
704 break;
705 case GLSL_TYPE_INT:
706 data.i[c] = 0;
707 break;
708 case GLSL_TYPE_FLOAT:
709 data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
710 break;
711 default:
712 assert(0);
713 }
714 }
715 break;
716
717 case ir_unop_sin:
718 case ir_unop_sin_reduced:
719 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
720 for (unsigned c = 0; c < op[0]->type->components(); c++) {
721 data.f[c] = sinf(op[0]->value.f[c]);
722 }
723 break;
724
725 case ir_unop_cos:
726 case ir_unop_cos_reduced:
727 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
728 for (unsigned c = 0; c < op[0]->type->components(); c++) {
729 data.f[c] = cosf(op[0]->value.f[c]);
730 }
731 break;
732
733 case ir_unop_neg:
734 for (unsigned c = 0; c < op[0]->type->components(); c++) {
735 switch (this->type->base_type) {
736 case GLSL_TYPE_UINT:
737 data.u[c] = -((int) op[0]->value.u[c]);
738 break;
739 case GLSL_TYPE_INT:
740 data.i[c] = -op[0]->value.i[c];
741 break;
742 case GLSL_TYPE_FLOAT:
743 data.f[c] = -op[0]->value.f[c];
744 break;
745 default:
746 assert(0);
747 }
748 }
749 break;
750
751 case ir_unop_abs:
752 for (unsigned c = 0; c < op[0]->type->components(); c++) {
753 switch (this->type->base_type) {
754 case GLSL_TYPE_UINT:
755 data.u[c] = op[0]->value.u[c];
756 break;
757 case GLSL_TYPE_INT:
758 data.i[c] = op[0]->value.i[c];
759 if (data.i[c] < 0)
760 data.i[c] = -data.i[c];
761 break;
762 case GLSL_TYPE_FLOAT:
763 data.f[c] = fabs(op[0]->value.f[c]);
764 break;
765 default:
766 assert(0);
767 }
768 }
769 break;
770
771 case ir_unop_sign:
772 for (unsigned c = 0; c < op[0]->type->components(); c++) {
773 switch (this->type->base_type) {
774 case GLSL_TYPE_UINT:
775 data.u[c] = op[0]->value.i[c] > 0;
776 break;
777 case GLSL_TYPE_INT:
778 data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
779 break;
780 case GLSL_TYPE_FLOAT:
781 data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
782 break;
783 default:
784 assert(0);
785 }
786 }
787 break;
788
789 case ir_unop_rcp:
790 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
791 for (unsigned c = 0; c < op[0]->type->components(); c++) {
792 switch (this->type->base_type) {
793 case GLSL_TYPE_UINT:
794 if (op[0]->value.u[c] != 0.0)
795 data.u[c] = 1 / op[0]->value.u[c];
796 break;
797 case GLSL_TYPE_INT:
798 if (op[0]->value.i[c] != 0.0)
799 data.i[c] = 1 / op[0]->value.i[c];
800 break;
801 case GLSL_TYPE_FLOAT:
802 if (op[0]->value.f[c] != 0.0)
803 data.f[c] = 1.0F / op[0]->value.f[c];
804 break;
805 default:
806 assert(0);
807 }
808 }
809 break;
810
811 case ir_unop_rsq:
812 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
813 for (unsigned c = 0; c < op[0]->type->components(); c++) {
814 data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
815 }
816 break;
817
818 case ir_unop_sqrt:
819 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
820 for (unsigned c = 0; c < op[0]->type->components(); c++) {
821 data.f[c] = sqrtf(op[0]->value.f[c]);
822 }
823 break;
824
825 case ir_unop_exp:
826 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
827 for (unsigned c = 0; c < op[0]->type->components(); c++) {
828 data.f[c] = expf(op[0]->value.f[c]);
829 }
830 break;
831
832 case ir_unop_exp2:
833 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
834 for (unsigned c = 0; c < op[0]->type->components(); c++) {
835 data.f[c] = exp2f(op[0]->value.f[c]);
836 }
837 break;
838
839 case ir_unop_log:
840 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
841 for (unsigned c = 0; c < op[0]->type->components(); c++) {
842 data.f[c] = logf(op[0]->value.f[c]);
843 }
844 break;
845
846 case ir_unop_log2:
847 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
848 for (unsigned c = 0; c < op[0]->type->components(); c++) {
849 data.f[c] = log2f(op[0]->value.f[c]);
850 }
851 break;
852
853 case ir_unop_dFdx:
854 case ir_unop_dFdx_coarse:
855 case ir_unop_dFdx_fine:
856 case ir_unop_dFdy:
857 case ir_unop_dFdy_coarse:
858 case ir_unop_dFdy_fine:
859 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
860 for (unsigned c = 0; c < op[0]->type->components(); c++) {
861 data.f[c] = 0.0;
862 }
863 break;
864
865 case ir_unop_pack_snorm_2x16:
866 assert(op[0]->type == glsl_type::vec2_type);
867 data.u[0] = pack_2x16(pack_snorm_1x16,
868 op[0]->value.f[0],
869 op[0]->value.f[1]);
870 break;
871 case ir_unop_pack_snorm_4x8:
872 assert(op[0]->type == glsl_type::vec4_type);
873 data.u[0] = pack_4x8(pack_snorm_1x8,
874 op[0]->value.f[0],
875 op[0]->value.f[1],
876 op[0]->value.f[2],
877 op[0]->value.f[3]);
878 break;
879 case ir_unop_unpack_snorm_2x16:
880 assert(op[0]->type == glsl_type::uint_type);
881 unpack_2x16(unpack_snorm_1x16,
882 op[0]->value.u[0],
883 &data.f[0], &data.f[1]);
884 break;
885 case ir_unop_unpack_snorm_4x8:
886 assert(op[0]->type == glsl_type::uint_type);
887 unpack_4x8(unpack_snorm_1x8,
888 op[0]->value.u[0],
889 &data.f[0], &data.f[1], &data.f[2], &data.f[3]);
890 break;
891 case ir_unop_pack_unorm_2x16:
892 assert(op[0]->type == glsl_type::vec2_type);
893 data.u[0] = pack_2x16(pack_unorm_1x16,
894 op[0]->value.f[0],
895 op[0]->value.f[1]);
896 break;
897 case ir_unop_pack_unorm_4x8:
898 assert(op[0]->type == glsl_type::vec4_type);
899 data.u[0] = pack_4x8(pack_unorm_1x8,
900 op[0]->value.f[0],
901 op[0]->value.f[1],
902 op[0]->value.f[2],
903 op[0]->value.f[3]);
904 break;
905 case ir_unop_unpack_unorm_2x16:
906 assert(op[0]->type == glsl_type::uint_type);
907 unpack_2x16(unpack_unorm_1x16,
908 op[0]->value.u[0],
909 &data.f[0], &data.f[1]);
910 break;
911 case ir_unop_unpack_unorm_4x8:
912 assert(op[0]->type == glsl_type::uint_type);
913 unpack_4x8(unpack_unorm_1x8,
914 op[0]->value.u[0],
915 &data.f[0], &data.f[1], &data.f[2], &data.f[3]);
916 break;
917 case ir_unop_pack_half_2x16:
918 assert(op[0]->type == glsl_type::vec2_type);
919 data.u[0] = pack_2x16(pack_half_1x16,
920 op[0]->value.f[0],
921 op[0]->value.f[1]);
922 break;
923 case ir_unop_unpack_half_2x16:
924 assert(op[0]->type == glsl_type::uint_type);
925 unpack_2x16(unpack_half_1x16,
926 op[0]->value.u[0],
927 &data.f[0], &data.f[1]);
928 break;
929 case ir_binop_pow:
930 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
931 for (unsigned c = 0; c < op[0]->type->components(); c++) {
932 data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
933 }
934 break;
935
936 case ir_binop_dot:
937 data.f[0] = dot(op[0], op[1]);
938 break;
939
940 case ir_binop_min:
941 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
942 for (unsigned c = 0, c0 = 0, c1 = 0;
943 c < components;
944 c0 += c0_inc, c1 += c1_inc, c++) {
945
946 switch (op[0]->type->base_type) {
947 case GLSL_TYPE_UINT:
948 data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
949 break;
950 case GLSL_TYPE_INT:
951 data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
952 break;
953 case GLSL_TYPE_FLOAT:
954 data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
955 break;
956 default:
957 assert(0);
958 }
959 }
960
961 break;
962 case ir_binop_max:
963 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
964 for (unsigned c = 0, c0 = 0, c1 = 0;
965 c < components;
966 c0 += c0_inc, c1 += c1_inc, c++) {
967
968 switch (op[0]->type->base_type) {
969 case GLSL_TYPE_UINT:
970 data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
971 break;
972 case GLSL_TYPE_INT:
973 data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
974 break;
975 case GLSL_TYPE_FLOAT:
976 data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
977 break;
978 default:
979 assert(0);
980 }
981 }
982 break;
983
984 case ir_binop_add:
985 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
986 for (unsigned c = 0, c0 = 0, c1 = 0;
987 c < components;
988 c0 += c0_inc, c1 += c1_inc, c++) {
989
990 switch (op[0]->type->base_type) {
991 case GLSL_TYPE_UINT:
992 data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
993 break;
994 case GLSL_TYPE_INT:
995 data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
996 break;
997 case GLSL_TYPE_FLOAT:
998 data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
999 break;
1000 default:
1001 assert(0);
1002 }
1003 }
1004
1005 break;
1006 case ir_binop_sub:
1007 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1008 for (unsigned c = 0, c0 = 0, c1 = 0;
1009 c < components;
1010 c0 += c0_inc, c1 += c1_inc, c++) {
1011
1012 switch (op[0]->type->base_type) {
1013 case GLSL_TYPE_UINT:
1014 data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
1015 break;
1016 case GLSL_TYPE_INT:
1017 data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
1018 break;
1019 case GLSL_TYPE_FLOAT:
1020 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
1021 break;
1022 default:
1023 assert(0);
1024 }
1025 }
1026
1027 break;
1028 case ir_binop_mul:
1029 /* Check for equal types, or unequal types involving scalars */
1030 if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
1031 || op0_scalar || op1_scalar) {
1032 for (unsigned c = 0, c0 = 0, c1 = 0;
1033 c < components;
1034 c0 += c0_inc, c1 += c1_inc, c++) {
1035
1036 switch (op[0]->type->base_type) {
1037 case GLSL_TYPE_UINT:
1038 data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
1039 break;
1040 case GLSL_TYPE_INT:
1041 data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
1042 break;
1043 case GLSL_TYPE_FLOAT:
1044 data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
1045 break;
1046 default:
1047 assert(0);
1048 }
1049 }
1050 } else {
1051 assert(op[0]->type->is_matrix() || op[1]->type->is_matrix());
1052
1053 /* Multiply an N-by-M matrix with an M-by-P matrix. Since either
1054 * matrix can be a GLSL vector, either N or P can be 1.
1055 *
1056 * For vec*mat, the vector is treated as a row vector. This
1057 * means the vector is a 1-row x M-column matrix.
1058 *
1059 * For mat*vec, the vector is treated as a column vector. Since
1060 * matrix_columns is 1 for vectors, this just works.
1061 */
1062 const unsigned n = op[0]->type->is_vector()
1063 ? 1 : op[0]->type->vector_elements;
1064 const unsigned m = op[1]->type->vector_elements;
1065 const unsigned p = op[1]->type->matrix_columns;
1066 for (unsigned j = 0; j < p; j++) {
1067 for (unsigned i = 0; i < n; i++) {
1068 for (unsigned k = 0; k < m; k++) {
1069 data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
1070 }
1071 }
1072 }
1073 }
1074
1075 break;
1076 case ir_binop_div:
1077 /* FINISHME: Emit warning when division-by-zero is detected. */
1078 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1079 for (unsigned c = 0, c0 = 0, c1 = 0;
1080 c < components;
1081 c0 += c0_inc, c1 += c1_inc, c++) {
1082
1083 switch (op[0]->type->base_type) {
1084 case GLSL_TYPE_UINT:
1085 if (op[1]->value.u[c1] == 0) {
1086 data.u[c] = 0;
1087 } else {
1088 data.u[c] = op[0]->value.u[c0] / op[1]->value.u[c1];
1089 }
1090 break;
1091 case GLSL_TYPE_INT:
1092 if (op[1]->value.i[c1] == 0) {
1093 data.i[c] = 0;
1094 } else {
1095 data.i[c] = op[0]->value.i[c0] / op[1]->value.i[c1];
1096 }
1097 break;
1098 case GLSL_TYPE_FLOAT:
1099 data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
1100 break;
1101 default:
1102 assert(0);
1103 }
1104 }
1105
1106 break;
1107 case ir_binop_mod:
1108 /* FINISHME: Emit warning when division-by-zero is detected. */
1109 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1110 for (unsigned c = 0, c0 = 0, c1 = 0;
1111 c < components;
1112 c0 += c0_inc, c1 += c1_inc, c++) {
1113
1114 switch (op[0]->type->base_type) {
1115 case GLSL_TYPE_UINT:
1116 if (op[1]->value.u[c1] == 0) {
1117 data.u[c] = 0;
1118 } else {
1119 data.u[c] = op[0]->value.u[c0] % op[1]->value.u[c1];
1120 }
1121 break;
1122 case GLSL_TYPE_INT:
1123 if (op[1]->value.i[c1] == 0) {
1124 data.i[c] = 0;
1125 } else {
1126 data.i[c] = op[0]->value.i[c0] % op[1]->value.i[c1];
1127 }
1128 break;
1129 case GLSL_TYPE_FLOAT:
1130 /* We don't use fmod because it rounds toward zero; GLSL specifies
1131 * the use of floor.
1132 */
1133 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
1134 * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
1135 break;
1136 default:
1137 assert(0);
1138 }
1139 }
1140
1141 break;
1142
1143 case ir_binop_logic_and:
1144 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
1145 for (unsigned c = 0; c < op[0]->type->components(); c++)
1146 data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
1147 break;
1148 case ir_binop_logic_xor:
1149 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
1150 for (unsigned c = 0; c < op[0]->type->components(); c++)
1151 data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
1152 break;
1153 case ir_binop_logic_or:
1154 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
1155 for (unsigned c = 0; c < op[0]->type->components(); c++)
1156 data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
1157 break;
1158
1159 case ir_binop_less:
1160 assert(op[0]->type == op[1]->type);
1161 for (unsigned c = 0; c < op[0]->type->components(); c++) {
1162 switch (op[0]->type->base_type) {
1163 case GLSL_TYPE_UINT:
1164 data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
1165 break;
1166 case GLSL_TYPE_INT:
1167 data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
1168 break;
1169 case GLSL_TYPE_FLOAT:
1170 data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
1171 break;
1172 default:
1173 assert(0);
1174 }
1175 }
1176 break;
1177 case ir_binop_greater:
1178 assert(op[0]->type == op[1]->type);
1179 for (unsigned c = 0; c < op[0]->type->components(); c++) {
1180 switch (op[0]->type->base_type) {
1181 case GLSL_TYPE_UINT:
1182 data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
1183 break;
1184 case GLSL_TYPE_INT:
1185 data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
1186 break;
1187 case GLSL_TYPE_FLOAT:
1188 data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
1189 break;
1190 default:
1191 assert(0);
1192 }
1193 }
1194 break;
1195 case ir_binop_lequal:
1196 assert(op[0]->type == op[1]->type);
1197 for (unsigned c = 0; c < op[0]->type->components(); c++) {
1198 switch (op[0]->type->base_type) {
1199 case GLSL_TYPE_UINT:
1200 data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
1201 break;
1202 case GLSL_TYPE_INT:
1203 data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
1204 break;
1205 case GLSL_TYPE_FLOAT:
1206 data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
1207 break;
1208 default:
1209 assert(0);
1210 }
1211 }
1212 break;
1213 case ir_binop_gequal:
1214 assert(op[0]->type == op[1]->type);
1215 for (unsigned c = 0; c < op[0]->type->components(); c++) {
1216 switch (op[0]->type->base_type) {
1217 case GLSL_TYPE_UINT:
1218 data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
1219 break;
1220 case GLSL_TYPE_INT:
1221 data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
1222 break;
1223 case GLSL_TYPE_FLOAT:
1224 data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
1225 break;
1226 default:
1227 assert(0);
1228 }
1229 }
1230 break;
1231 case ir_binop_equal:
1232 assert(op[0]->type == op[1]->type);
1233 for (unsigned c = 0; c < components; c++) {
1234 switch (op[0]->type->base_type) {
1235 case GLSL_TYPE_UINT:
1236 data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
1237 break;
1238 case GLSL_TYPE_INT:
1239 data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
1240 break;
1241 case GLSL_TYPE_FLOAT:
1242 data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
1243 break;
1244 case GLSL_TYPE_BOOL:
1245 data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
1246 break;
1247 default:
1248 assert(0);
1249 }
1250 }
1251 break;
1252 case ir_binop_nequal:
1253 assert(op[0]->type == op[1]->type);
1254 for (unsigned c = 0; c < components; c++) {
1255 switch (op[0]->type->base_type) {
1256 case GLSL_TYPE_UINT:
1257 data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
1258 break;
1259 case GLSL_TYPE_INT:
1260 data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
1261 break;
1262 case GLSL_TYPE_FLOAT:
1263 data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
1264 break;
1265 case GLSL_TYPE_BOOL:
1266 data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
1267 break;
1268 default:
1269 assert(0);
1270 }
1271 }
1272 break;
1273 case ir_binop_all_equal:
1274 data.b[0] = op[0]->has_value(op[1]);
1275 break;
1276 case ir_binop_any_nequal:
1277 data.b[0] = !op[0]->has_value(op[1]);
1278 break;
1279
1280 case ir_binop_lshift:
1281 for (unsigned c = 0, c0 = 0, c1 = 0;
1282 c < components;
1283 c0 += c0_inc, c1 += c1_inc, c++) {
1284
1285 if (op[0]->type->base_type == GLSL_TYPE_INT &&
1286 op[1]->type->base_type == GLSL_TYPE_INT) {
1287 data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1];
1288
1289 } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
1290 op[1]->type->base_type == GLSL_TYPE_UINT) {
1291 data.i[c] = op[0]->value.i[c0] << op[1]->value.u[c1];
1292
1293 } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
1294 op[1]->type->base_type == GLSL_TYPE_INT) {
1295 data.u[c] = op[0]->value.u[c0] << op[1]->value.i[c1];
1296
1297 } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
1298 op[1]->type->base_type == GLSL_TYPE_UINT) {
1299 data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1];
1300 }
1301 }
1302 break;
1303
1304 case ir_binop_rshift:
1305 for (unsigned c = 0, c0 = 0, c1 = 0;
1306 c < components;
1307 c0 += c0_inc, c1 += c1_inc, c++) {
1308
1309 if (op[0]->type->base_type == GLSL_TYPE_INT &&
1310 op[1]->type->base_type == GLSL_TYPE_INT) {
1311 data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1];
1312
1313 } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
1314 op[1]->type->base_type == GLSL_TYPE_UINT) {
1315 data.i[c] = op[0]->value.i[c0] >> op[1]->value.u[c1];
1316
1317 } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
1318 op[1]->type->base_type == GLSL_TYPE_INT) {
1319 data.u[c] = op[0]->value.u[c0] >> op[1]->value.i[c1];
1320
1321 } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
1322 op[1]->type->base_type == GLSL_TYPE_UINT) {
1323 data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1];
1324 }
1325 }
1326 break;
1327
1328 case ir_binop_bit_and:
1329 for (unsigned c = 0, c0 = 0, c1 = 0;
1330 c < components;
1331 c0 += c0_inc, c1 += c1_inc, c++) {
1332
1333 switch (op[0]->type->base_type) {
1334 case GLSL_TYPE_INT:
1335 data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1];
1336 break;
1337 case GLSL_TYPE_UINT:
1338 data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
1339 break;
1340 default:
1341 assert(0);
1342 }
1343 }
1344 break;
1345
1346 case ir_binop_bit_or:
1347 for (unsigned c = 0, c0 = 0, c1 = 0;
1348 c < components;
1349 c0 += c0_inc, c1 += c1_inc, c++) {
1350
1351 switch (op[0]->type->base_type) {
1352 case GLSL_TYPE_INT:
1353 data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1];
1354 break;
1355 case GLSL_TYPE_UINT:
1356 data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1];
1357 break;
1358 default:
1359 assert(0);
1360 }
1361 }
1362 break;
1363
1364 case ir_binop_vector_extract: {
1365 const int c = CLAMP(op[1]->value.i[0], 0,
1366 (int) op[0]->type->vector_elements - 1);
1367
1368 switch (op[0]->type->base_type) {
1369 case GLSL_TYPE_UINT:
1370 data.u[0] = op[0]->value.u[c];
1371 break;
1372 case GLSL_TYPE_INT:
1373 data.i[0] = op[0]->value.i[c];
1374 break;
1375 case GLSL_TYPE_FLOAT:
1376 data.f[0] = op[0]->value.f[c];
1377 break;
1378 case GLSL_TYPE_BOOL:
1379 data.b[0] = op[0]->value.b[c];
1380 break;
1381 default:
1382 assert(0);
1383 }
1384 break;
1385 }
1386
1387 case ir_binop_bit_xor:
1388 for (unsigned c = 0, c0 = 0, c1 = 0;
1389 c < components;
1390 c0 += c0_inc, c1 += c1_inc, c++) {
1391
1392 switch (op[0]->type->base_type) {
1393 case GLSL_TYPE_INT:
1394 data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1];
1395 break;
1396 case GLSL_TYPE_UINT:
1397 data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
1398 break;
1399 default:
1400 assert(0);
1401 }
1402 }
1403 break;
1404
1405 case ir_unop_bitfield_reverse:
1406 /* http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious */
1407 for (unsigned c = 0; c < components; c++) {
1408 unsigned int v = op[0]->value.u[c]; // input bits to be reversed
1409 unsigned int r = v; // r will be reversed bits of v; first get LSB of v
1410 int s = sizeof(v) * CHAR_BIT - 1; // extra shift needed at end
1411
1412 for (v >>= 1; v; v >>= 1) {
1413 r <<= 1;
1414 r |= v & 1;
1415 s--;
1416 }
1417 r <<= s; // shift when v's highest bits are zero
1418
1419 data.u[c] = r;
1420 }
1421 break;
1422
1423 case ir_unop_bit_count:
1424 for (unsigned c = 0; c < components; c++) {
1425 unsigned count = 0;
1426 unsigned v = op[0]->value.u[c];
1427
1428 for (; v; count++) {
1429 v &= v - 1;
1430 }
1431 data.u[c] = count;
1432 }
1433 break;
1434
1435 case ir_unop_find_msb:
1436 for (unsigned c = 0; c < components; c++) {
1437 int v = op[0]->value.i[c];
1438
1439 if (v == 0 || (op[0]->type->base_type == GLSL_TYPE_INT && v == -1))
1440 data.i[c] = -1;
1441 else {
1442 int count = 0;
1443 int top_bit = op[0]->type->base_type == GLSL_TYPE_UINT
1444 ? 0 : v & (1 << 31);
1445
1446 while (((v & (1 << 31)) == top_bit) && count != 32) {
1447 count++;
1448 v <<= 1;
1449 }
1450
1451 data.i[c] = 31 - count;
1452 }
1453 }
1454 break;
1455
1456 case ir_unop_find_lsb:
1457 for (unsigned c = 0; c < components; c++) {
1458 if (op[0]->value.i[c] == 0)
1459 data.i[c] = -1;
1460 else {
1461 unsigned pos = 0;
1462 unsigned v = op[0]->value.u[c];
1463
1464 for (; !(v & 1); v >>= 1) {
1465 pos++;
1466 }
1467 data.u[c] = pos;
1468 }
1469 }
1470 break;
1471
1472 case ir_unop_saturate:
1473 for (unsigned c = 0; c < components; c++) {
1474 data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f);
1475 }
1476 break;
1477
1478 case ir_triop_bitfield_extract: {
1479 int offset = op[1]->value.i[0];
1480 int bits = op[2]->value.i[0];
1481
1482 for (unsigned c = 0; c < components; c++) {
1483 if (bits == 0)
1484 data.u[c] = 0;
1485 else if (offset < 0 || bits < 0)
1486 data.u[c] = 0; /* Undefined, per spec. */
1487 else if (offset + bits > 32)
1488 data.u[c] = 0; /* Undefined, per spec. */
1489 else {
1490 if (op[0]->type->base_type == GLSL_TYPE_INT) {
1491 /* int so that the right shift will sign-extend. */
1492 int value = op[0]->value.i[c];
1493 value <<= 32 - bits - offset;
1494 value >>= 32 - bits;
1495 data.i[c] = value;
1496 } else {
1497 unsigned value = op[0]->value.u[c];
1498 value <<= 32 - bits - offset;
1499 value >>= 32 - bits;
1500 data.u[c] = value;
1501 }
1502 }
1503 }
1504 break;
1505 }
1506
1507 case ir_binop_bfm: {
1508 int bits = op[0]->value.i[0];
1509 int offset = op[1]->value.i[0];
1510
1511 for (unsigned c = 0; c < components; c++) {
1512 if (bits == 0)
1513 data.u[c] = op[0]->value.u[c];
1514 else if (offset < 0 || bits < 0)
1515 data.u[c] = 0; /* Undefined for bitfieldInsert, per spec. */
1516 else if (offset + bits > 32)
1517 data.u[c] = 0; /* Undefined for bitfieldInsert, per spec. */
1518 else
1519 data.u[c] = ((1 << bits) - 1) << offset;
1520 }
1521 break;
1522 }
1523
1524 case ir_binop_ldexp:
1525 for (unsigned c = 0; c < components; c++) {
1526 data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
1527 /* Flush subnormal values to zero. */
1528 if (!isnormal(data.f[c]))
1529 data.f[c] = copysign(0.0f, op[0]->value.f[c]);
1530 }
1531 break;
1532
1533 case ir_triop_fma:
1534 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
1535 assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
1536 assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
1537
1538 for (unsigned c = 0; c < components; c++) {
1539 data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
1540 + op[2]->value.f[c];
1541 }
1542 break;
1543
1544 case ir_triop_lrp: {
1545 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
1546 assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
1547 assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
1548
1549 unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
1550 for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
1551 data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
1552 (op[1]->value.f[c] * op[2]->value.f[c2]);
1553 }
1554 break;
1555 }
1556
1557 case ir_triop_csel:
1558 for (unsigned c = 0; c < components; c++) {
1559 data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
1560 : op[2]->value.u[c];
1561 }
1562 break;
1563
1564 case ir_triop_vector_insert: {
1565 const unsigned idx = op[2]->value.u[0];
1566
1567 memcpy(&data, &op[0]->value, sizeof(data));
1568
1569 switch (this->type->base_type) {
1570 case GLSL_TYPE_INT:
1571 data.i[idx] = op[1]->value.i[0];
1572 break;
1573 case GLSL_TYPE_UINT:
1574 data.u[idx] = op[1]->value.u[0];
1575 break;
1576 case GLSL_TYPE_FLOAT:
1577 data.f[idx] = op[1]->value.f[0];
1578 break;
1579 case GLSL_TYPE_BOOL:
1580 data.b[idx] = op[1]->value.b[0];
1581 break;
1582 default:
1583 assert(!"Should not get here.");
1584 break;
1585 }
1586 break;
1587 }
1588
1589 case ir_quadop_bitfield_insert: {
1590 int offset = op[2]->value.i[0];
1591 int bits = op[3]->value.i[0];
1592
1593 for (unsigned c = 0; c < components; c++) {
1594 if (bits == 0)
1595 data.u[c] = op[0]->value.u[c];
1596 else if (offset < 0 || bits < 0)
1597 data.u[c] = 0; /* Undefined, per spec. */
1598 else if (offset + bits > 32)
1599 data.u[c] = 0; /* Undefined, per spec. */
1600 else {
1601 unsigned insert_mask = ((1 << bits) - 1) << offset;
1602
1603 unsigned insert = op[1]->value.u[c];
1604 insert <<= offset;
1605 insert &= insert_mask;
1606
1607 unsigned base = op[0]->value.u[c];
1608 base &= ~insert_mask;
1609
1610 data.u[c] = base | insert;
1611 }
1612 }
1613 break;
1614 }
1615
1616 case ir_quadop_vector:
1617 for (unsigned c = 0; c < this->type->vector_elements; c++) {
1618 switch (this->type->base_type) {
1619 case GLSL_TYPE_INT:
1620 data.i[c] = op[c]->value.i[0];
1621 break;
1622 case GLSL_TYPE_UINT:
1623 data.u[c] = op[c]->value.u[0];
1624 break;
1625 case GLSL_TYPE_FLOAT:
1626 data.f[c] = op[c]->value.f[0];
1627 break;
1628 default:
1629 assert(0);
1630 }
1631 }
1632 break;
1633
1634 default:
1635 /* FINISHME: Should handle all expression types. */
1636 return NULL;
1637 }
1638
1639 return new(ctx) ir_constant(this->type, &data);
1640 }
1641
1642
1643 ir_constant *
1644 ir_texture::constant_expression_value(struct hash_table *)
1645 {
1646 /* texture lookups aren't constant expressions */
1647 return NULL;
1648 }
1649
1650
1651 ir_constant *
1652 ir_swizzle::constant_expression_value(struct hash_table *variable_context)
1653 {
1654 ir_constant *v = this->val->constant_expression_value(variable_context);
1655
1656 if (v != NULL) {
1657 ir_constant_data data = { { 0 } };
1658
1659 const unsigned swiz_idx[4] = {
1660 this->mask.x, this->mask.y, this->mask.z, this->mask.w
1661 };
1662
1663 for (unsigned i = 0; i < this->mask.num_components; i++) {
1664 switch (v->type->base_type) {
1665 case GLSL_TYPE_UINT:
1666 case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
1667 case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
1668 case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
1669 default: assert(!"Should not get here."); break;
1670 }
1671 }
1672
1673 void *ctx = ralloc_parent(this);
1674 return new(ctx) ir_constant(this->type, &data);
1675 }
1676 return NULL;
1677 }
1678
1679
1680 ir_constant *
1681 ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
1682 {
1683 /* This may occur during compile and var->type is glsl_type::error_type */
1684 if (!var)
1685 return NULL;
1686
1687 /* Give priority to the context hashtable, if it exists */
1688 if (variable_context) {
1689 ir_constant *value = (ir_constant *)hash_table_find(variable_context, var);
1690 if(value)
1691 return value;
1692 }
1693
1694 /* The constant_value of a uniform variable is its initializer,
1695 * not the lifetime constant value of the uniform.
1696 */
1697 if (var->data.mode == ir_var_uniform)
1698 return NULL;
1699
1700 if (!var->constant_value)
1701 return NULL;
1702
1703 return var->constant_value->clone(ralloc_parent(var), NULL);
1704 }
1705
1706
1707 ir_constant *
1708 ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
1709 {
1710 ir_constant *array = this->array->constant_expression_value(variable_context);
1711 ir_constant *idx = this->array_index->constant_expression_value(variable_context);
1712
1713 if ((array != NULL) && (idx != NULL)) {
1714 void *ctx = ralloc_parent(this);
1715 if (array->type->is_matrix()) {
1716 /* Array access of a matrix results in a vector.
1717 */
1718 const unsigned column = idx->value.u[0];
1719
1720 const glsl_type *const column_type = array->type->column_type();
1721
1722 /* Offset in the constant matrix to the first element of the column
1723 * to be extracted.
1724 */
1725 const unsigned mat_idx = column * column_type->vector_elements;
1726
1727 ir_constant_data data = { { 0 } };
1728
1729 switch (column_type->base_type) {
1730 case GLSL_TYPE_UINT:
1731 case GLSL_TYPE_INT:
1732 for (unsigned i = 0; i < column_type->vector_elements; i++)
1733 data.u[i] = array->value.u[mat_idx + i];
1734
1735 break;
1736
1737 case GLSL_TYPE_FLOAT:
1738 for (unsigned i = 0; i < column_type->vector_elements; i++)
1739 data.f[i] = array->value.f[mat_idx + i];
1740
1741 break;
1742
1743 default:
1744 assert(!"Should not get here.");
1745 break;
1746 }
1747
1748 return new(ctx) ir_constant(column_type, &data);
1749 } else if (array->type->is_vector()) {
1750 const unsigned component = idx->value.u[0];
1751
1752 return new(ctx) ir_constant(array, component);
1753 } else {
1754 const unsigned index = idx->value.u[0];
1755 return array->get_array_element(index)->clone(ctx, NULL);
1756 }
1757 }
1758 return NULL;
1759 }
1760
1761
1762 ir_constant *
1763 ir_dereference_record::constant_expression_value(struct hash_table *)
1764 {
1765 ir_constant *v = this->record->constant_expression_value();
1766
1767 return (v != NULL) ? v->get_record_field(this->field) : NULL;
1768 }
1769
1770
1771 ir_constant *
1772 ir_assignment::constant_expression_value(struct hash_table *)
1773 {
1774 /* FINISHME: Handle CEs involving assignment (return RHS) */
1775 return NULL;
1776 }
1777
1778
1779 ir_constant *
1780 ir_constant::constant_expression_value(struct hash_table *)
1781 {
1782 return this;
1783 }
1784
1785
1786 ir_constant *
1787 ir_call::constant_expression_value(struct hash_table *variable_context)
1788 {
1789 return this->callee->constant_expression_value(&this->actual_parameters, variable_context);
1790 }
1791
1792
1793 bool ir_function_signature::constant_expression_evaluate_expression_list(const struct exec_list &body,
1794 struct hash_table *variable_context,
1795 ir_constant **result)
1796 {
1797 foreach_in_list(ir_instruction, inst, &body) {
1798 switch(inst->ir_type) {
1799
1800 /* (declare () type symbol) */
1801 case ir_type_variable: {
1802 ir_variable *var = inst->as_variable();
1803 hash_table_insert(variable_context, ir_constant::zero(this, var->type), var);
1804 break;
1805 }
1806
1807 /* (assign [condition] (write-mask) (ref) (value)) */
1808 case ir_type_assignment: {
1809 ir_assignment *asg = inst->as_assignment();
1810 if (asg->condition) {
1811 ir_constant *cond = asg->condition->constant_expression_value(variable_context);
1812 if (!cond)
1813 return false;
1814 if (!cond->get_bool_component(0))
1815 break;
1816 }
1817
1818 ir_constant *store = NULL;
1819 int offset = 0;
1820
1821 if (!constant_referenced(asg->lhs, variable_context, store, offset))
1822 return false;
1823
1824 ir_constant *value = asg->rhs->constant_expression_value(variable_context);
1825
1826 if (!value)
1827 return false;
1828
1829 store->copy_masked_offset(value, offset, asg->write_mask);
1830 break;
1831 }
1832
1833 /* (return (expression)) */
1834 case ir_type_return:
1835 assert (result);
1836 *result = inst->as_return()->value->constant_expression_value(variable_context);
1837 return *result != NULL;
1838
1839 /* (call name (ref) (params))*/
1840 case ir_type_call: {
1841 ir_call *call = inst->as_call();
1842
1843 /* Just say no to void functions in constant expressions. We
1844 * don't need them at that point.
1845 */
1846
1847 if (!call->return_deref)
1848 return false;
1849
1850 ir_constant *store = NULL;
1851 int offset = 0;
1852
1853 if (!constant_referenced(call->return_deref, variable_context,
1854 store, offset))
1855 return false;
1856
1857 ir_constant *value = call->constant_expression_value(variable_context);
1858
1859 if(!value)
1860 return false;
1861
1862 store->copy_offset(value, offset);
1863 break;
1864 }
1865
1866 /* (if condition (then-instructions) (else-instructions)) */
1867 case ir_type_if: {
1868 ir_if *iif = inst->as_if();
1869
1870 ir_constant *cond = iif->condition->constant_expression_value(variable_context);
1871 if (!cond || !cond->type->is_boolean())
1872 return false;
1873
1874 exec_list &branch = cond->get_bool_component(0) ? iif->then_instructions : iif->else_instructions;
1875
1876 *result = NULL;
1877 if (!constant_expression_evaluate_expression_list(branch, variable_context, result))
1878 return false;
1879
1880 /* If there was a return in the branch chosen, drop out now. */
1881 if (*result)
1882 return true;
1883
1884 break;
1885 }
1886
1887 /* Every other expression type, we drop out. */
1888 default:
1889 return false;
1890 }
1891 }
1892
1893 /* Reaching the end of the block is not an error condition */
1894 if (result)
1895 *result = NULL;
1896
1897 return true;
1898 }
1899
1900 ir_constant *
1901 ir_function_signature::constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context)
1902 {
1903 const glsl_type *type = this->return_type;
1904 if (type == glsl_type::void_type)
1905 return NULL;
1906
1907 /* From the GLSL 1.20 spec, page 23:
1908 * "Function calls to user-defined functions (non-built-in functions)
1909 * cannot be used to form constant expressions."
1910 */
1911 if (!this->is_builtin())
1912 return NULL;
1913
1914 /*
1915 * Of the builtin functions, only the texture lookups and the noise
1916 * ones must not be used in constant expressions. They all include
1917 * specific opcodes so they don't need to be special-cased at this
1918 * point.
1919 */
1920
1921 /* Initialize the table of dereferencable names with the function
1922 * parameters. Verify their const-ness on the way.
1923 *
1924 * We expect the correctness of the number of parameters to have
1925 * been checked earlier.
1926 */
1927 hash_table *deref_hash = hash_table_ctor(8, hash_table_pointer_hash,
1928 hash_table_pointer_compare);
1929
1930 /* If "origin" is non-NULL, then the function body is there. So we
1931 * have to use the variable objects from the object with the body,
1932 * but the parameter instanciation on the current object.
1933 */
1934 const exec_node *parameter_info = origin ? origin->parameters.head : parameters.head;
1935
1936 foreach_in_list(ir_rvalue, n, actual_parameters) {
1937 ir_constant *constant = n->constant_expression_value(variable_context);
1938 if (constant == NULL) {
1939 hash_table_dtor(deref_hash);
1940 return NULL;
1941 }
1942
1943
1944 ir_variable *var = (ir_variable *)parameter_info;
1945 hash_table_insert(deref_hash, constant, var);
1946
1947 parameter_info = parameter_info->next;
1948 }
1949
1950 ir_constant *result = NULL;
1951
1952 /* Now run the builtin function until something non-constant
1953 * happens or we get the result.
1954 */
1955 if (constant_expression_evaluate_expression_list(origin ? origin->body : body, deref_hash, &result) && result)
1956 result = result->clone(ralloc_parent(this), NULL);
1957
1958 hash_table_dtor(deref_hash);
1959
1960 return result;
1961 }