projects / mesa.git / blob
? search:


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