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 /* Using C99 rounding functions for roundToEven() implementation is
44  * difficult, because round(), rint, and nearbyint() are affected by
45  * fesetenv(), which the application may have done for its own
46  * purposes.  Mesa's IROUND macro is close to what we want, but it
47  * rounds away from 0 on n + 0.5.
48  */
49 static int
round_to_even(float val)50 round_to_even(float val)
51 {
52    int rounded = IROUND(val);
53 
54    if (val - floor(val) == 0.5) {
55       if (rounded % 2 != 0)
56 	 rounded += val > 0 ? -1 : 1;
57    }
58 
59    return rounded;
60 }
61 
62 static float
dot(ir_constant * op0,ir_constant * op1)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
bitcast_u2f(unsigned int u)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
bitcast_f2u(float f)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 ir_constant *
constant_expression_value(struct hash_table * variable_context)98 ir_rvalue::constant_expression_value(struct hash_table *variable_context)
99 {
100    assert(this->type->is_error());
101    return NULL;
102 }
103 
104 ir_constant *
constant_expression_value(struct hash_table * variable_context)105 ir_expression::constant_expression_value(struct hash_table *variable_context)
106 {
107    if (this->type->is_error())
108       return NULL;
109 
110    ir_constant *op[Elements(this->operands)] = { NULL, };
111    ir_constant_data data;
112 
113    memset(&data, 0, sizeof(data));
114 
115    for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
116       op[operand] = this->operands[operand]->constant_expression_value(variable_context);
117       if (!op[operand])
118 	 return NULL;
119    }
120 
121    if (op[1] != NULL)
122       assert(op[0]->type->base_type == op[1]->type->base_type ||
123 	     this->operation == ir_binop_lshift ||
124 	     this->operation == ir_binop_rshift);
125 
126    bool op0_scalar = op[0]->type->is_scalar();
127    bool op1_scalar = op[1] != NULL && op[1]->type->is_scalar();
128 
129    /* When iterating over a vector or matrix's components, we want to increase
130     * the loop counter.  However, for scalars, we want to stay at 0.
131     */
132    unsigned c0_inc = op0_scalar ? 0 : 1;
133    unsigned c1_inc = op1_scalar ? 0 : 1;
134    unsigned components;
135    if (op1_scalar || !op[1]) {
136       components = op[0]->type->components();
137    } else {
138       components = op[1]->type->components();
139    }
140 
141    void *ctx = ralloc_parent(this);
142 
143    /* Handle array operations here, rather than below. */
144    if (op[0]->type->is_array()) {
145       assert(op[1] != NULL && op[1]->type->is_array());
146       switch (this->operation) {
147       case ir_binop_all_equal:
148 	 return new(ctx) ir_constant(op[0]->has_value(op[1]));
149       case ir_binop_any_nequal:
150 	 return new(ctx) ir_constant(!op[0]->has_value(op[1]));
151       default:
152 	 break;
153       }
154       return NULL;
155    }
156 
157    switch (this->operation) {
158    case ir_unop_bit_not:
159        switch (op[0]->type->base_type) {
160        case GLSL_TYPE_INT:
161            for (unsigned c = 0; c < components; c++)
162                data.i[c] = ~ op[0]->value.i[c];
163            break;
164        case GLSL_TYPE_UINT:
165            for (unsigned c = 0; c < components; c++)
166                data.u[c] = ~ op[0]->value.u[c];
167            break;
168        default:
169            assert(0);
170        }
171        break;
172 
173    case ir_unop_logic_not:
174       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
175       for (unsigned c = 0; c < op[0]->type->components(); c++)
176 	 data.b[c] = !op[0]->value.b[c];
177       break;
178 
179    case ir_unop_f2i:
180       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
181       for (unsigned c = 0; c < op[0]->type->components(); c++) {
182 	 data.i[c] = (int) op[0]->value.f[c];
183       }
184       break;
185    case ir_unop_f2u:
186       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
187       for (unsigned c = 0; c < op[0]->type->components(); c++) {
188          data.i[c] = (unsigned) op[0]->value.f[c];
189       }
190       break;
191    case ir_unop_i2f:
192       assert(op[0]->type->base_type == GLSL_TYPE_INT);
193       for (unsigned c = 0; c < op[0]->type->components(); c++) {
194 	 data.f[c] = (float) op[0]->value.i[c];
195       }
196       break;
197    case ir_unop_u2f:
198       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
199       for (unsigned c = 0; c < op[0]->type->components(); c++) {
200 	 data.f[c] = (float) op[0]->value.u[c];
201       }
202       break;
203    case ir_unop_b2f:
204       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
205       for (unsigned c = 0; c < op[0]->type->components(); c++) {
206 	 data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
207       }
208       break;
209    case ir_unop_f2b:
210       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
211       for (unsigned c = 0; c < op[0]->type->components(); c++) {
212 	 data.b[c] = op[0]->value.f[c] != 0.0F ? true : false;
213       }
214       break;
215    case ir_unop_b2i:
216       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
217       for (unsigned c = 0; c < op[0]->type->components(); c++) {
218 	 data.u[c] = op[0]->value.b[c] ? 1 : 0;
219       }
220       break;
221    case ir_unop_i2b:
222       assert(op[0]->type->is_integer());
223       for (unsigned c = 0; c < op[0]->type->components(); c++) {
224 	 data.b[c] = op[0]->value.u[c] ? true : false;
225       }
226       break;
227    case ir_unop_u2i:
228       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
229       for (unsigned c = 0; c < op[0]->type->components(); c++) {
230 	 data.i[c] = op[0]->value.u[c];
231       }
232       break;
233    case ir_unop_i2u:
234       assert(op[0]->type->base_type == GLSL_TYPE_INT);
235       for (unsigned c = 0; c < op[0]->type->components(); c++) {
236 	 data.u[c] = op[0]->value.i[c];
237       }
238       break;
239    case ir_unop_bitcast_i2f:
240       assert(op[0]->type->base_type == GLSL_TYPE_INT);
241       for (unsigned c = 0; c < op[0]->type->components(); c++) {
242 	 data.f[c] = bitcast_u2f(op[0]->value.i[c]);
243       }
244       break;
245    case ir_unop_bitcast_f2i:
246       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
247       for (unsigned c = 0; c < op[0]->type->components(); c++) {
248 	 data.i[c] = bitcast_f2u(op[0]->value.f[c]);
249       }
250       break;
251    case ir_unop_bitcast_u2f:
252       assert(op[0]->type->base_type == GLSL_TYPE_UINT);
253       for (unsigned c = 0; c < op[0]->type->components(); c++) {
254 	 data.f[c] = bitcast_u2f(op[0]->value.u[c]);
255       }
256       break;
257    case ir_unop_bitcast_f2u:
258       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
259       for (unsigned c = 0; c < op[0]->type->components(); c++) {
260 	 data.u[c] = bitcast_f2u(op[0]->value.f[c]);
261       }
262       break;
263    case ir_unop_any:
264       assert(op[0]->type->is_boolean());
265       data.b[0] = false;
266       for (unsigned c = 0; c < op[0]->type->components(); c++) {
267 	 if (op[0]->value.b[c])
268 	    data.b[0] = true;
269       }
270       break;
271 
272    case ir_unop_trunc:
273       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
274       for (unsigned c = 0; c < op[0]->type->components(); c++) {
275 	 data.f[c] = truncf(op[0]->value.f[c]);
276       }
277       break;
278 
279    case ir_unop_round_even:
280       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
281       for (unsigned c = 0; c < op[0]->type->components(); c++) {
282 	 data.f[c] = round_to_even(op[0]->value.f[c]);
283       }
284       break;
285 
286    case ir_unop_ceil:
287       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
288       for (unsigned c = 0; c < op[0]->type->components(); c++) {
289 	 data.f[c] = ceilf(op[0]->value.f[c]);
290       }
291       break;
292 
293    case ir_unop_floor:
294       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
295       for (unsigned c = 0; c < op[0]->type->components(); c++) {
296 	 data.f[c] = floorf(op[0]->value.f[c]);
297       }
298       break;
299 
300    case ir_unop_fract:
301       for (unsigned c = 0; c < op[0]->type->components(); c++) {
302 	 switch (this->type->base_type) {
303 	 case GLSL_TYPE_UINT:
304 	    data.u[c] = 0;
305 	    break;
306 	 case GLSL_TYPE_INT:
307 	    data.i[c] = 0;
308 	    break;
309 	 case GLSL_TYPE_FLOAT:
310 	    data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
311 	    break;
312 	 default:
313 	    assert(0);
314 	 }
315       }
316       break;
317 
318    case ir_unop_sin:
319    case ir_unop_sin_reduced:
320       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
321       for (unsigned c = 0; c < op[0]->type->components(); c++) {
322 	 data.f[c] = sinf(op[0]->value.f[c]);
323       }
324       break;
325 
326    case ir_unop_cos:
327    case ir_unop_cos_reduced:
328       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
329       for (unsigned c = 0; c < op[0]->type->components(); c++) {
330 	 data.f[c] = cosf(op[0]->value.f[c]);
331       }
332       break;
333 
334    case ir_unop_neg:
335       for (unsigned c = 0; c < op[0]->type->components(); c++) {
336 	 switch (this->type->base_type) {
337 	 case GLSL_TYPE_UINT:
338 	    data.u[c] = -((int) op[0]->value.u[c]);
339 	    break;
340 	 case GLSL_TYPE_INT:
341 	    data.i[c] = -op[0]->value.i[c];
342 	    break;
343 	 case GLSL_TYPE_FLOAT:
344 	    data.f[c] = -op[0]->value.f[c];
345 	    break;
346 	 default:
347 	    assert(0);
348 	 }
349       }
350       break;
351 
352    case ir_unop_abs:
353       for (unsigned c = 0; c < op[0]->type->components(); c++) {
354 	 switch (this->type->base_type) {
355 	 case GLSL_TYPE_UINT:
356 	    data.u[c] = op[0]->value.u[c];
357 	    break;
358 	 case GLSL_TYPE_INT:
359 	    data.i[c] = op[0]->value.i[c];
360 	    if (data.i[c] < 0)
361 	       data.i[c] = -data.i[c];
362 	    break;
363 	 case GLSL_TYPE_FLOAT:
364 	    data.f[c] = fabs(op[0]->value.f[c]);
365 	    break;
366 	 default:
367 	    assert(0);
368 	 }
369       }
370       break;
371 
372    case ir_unop_sign:
373       for (unsigned c = 0; c < op[0]->type->components(); c++) {
374 	 switch (this->type->base_type) {
375 	 case GLSL_TYPE_UINT:
376 	    data.u[c] = op[0]->value.i[c] > 0;
377 	    break;
378 	 case GLSL_TYPE_INT:
379 	    data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
380 	    break;
381 	 case GLSL_TYPE_FLOAT:
382 	    data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
383 	    break;
384 	 default:
385 	    assert(0);
386 	 }
387       }
388       break;
389 
390    case ir_unop_rcp:
391       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
392       for (unsigned c = 0; c < op[0]->type->components(); c++) {
393 	 switch (this->type->base_type) {
394 	 case GLSL_TYPE_UINT:
395 	    if (op[0]->value.u[c] != 0.0)
396 	       data.u[c] = 1 / op[0]->value.u[c];
397 	    break;
398 	 case GLSL_TYPE_INT:
399 	    if (op[0]->value.i[c] != 0.0)
400 	       data.i[c] = 1 / op[0]->value.i[c];
401 	    break;
402 	 case GLSL_TYPE_FLOAT:
403 	    if (op[0]->value.f[c] != 0.0)
404 	       data.f[c] = 1.0F / op[0]->value.f[c];
405 	    break;
406 	 default:
407 	    assert(0);
408 	 }
409       }
410       break;
411 
412    case ir_unop_rsq:
413       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
414       for (unsigned c = 0; c < op[0]->type->components(); c++) {
415 	 data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
416       }
417       break;
418 
419    case ir_unop_sqrt:
420       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
421       for (unsigned c = 0; c < op[0]->type->components(); c++) {
422 	 data.f[c] = sqrtf(op[0]->value.f[c]);
423       }
424       break;
425 
426    case ir_unop_exp:
427       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
428       for (unsigned c = 0; c < op[0]->type->components(); c++) {
429 	 data.f[c] = expf(op[0]->value.f[c]);
430       }
431       break;
432 
433    case ir_unop_exp2:
434       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
435       for (unsigned c = 0; c < op[0]->type->components(); c++) {
436 	 data.f[c] = exp2f(op[0]->value.f[c]);
437       }
438       break;
439 
440    case ir_unop_log:
441       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
442       for (unsigned c = 0; c < op[0]->type->components(); c++) {
443 	 data.f[c] = logf(op[0]->value.f[c]);
444       }
445       break;
446 
447    case ir_unop_log2:
448       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
449       for (unsigned c = 0; c < op[0]->type->components(); c++) {
450 	 data.f[c] = log2f(op[0]->value.f[c]);
451       }
452       break;
453 
454    case ir_unop_dFdx:
455    case ir_unop_dFdy:
456       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
457       for (unsigned c = 0; c < op[0]->type->components(); c++) {
458 	 data.f[c] = 0.0;
459       }
460       break;
461 
462    case ir_binop_pow:
463       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
464       for (unsigned c = 0; c < op[0]->type->components(); c++) {
465 	 data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
466       }
467       break;
468 
469    case ir_binop_dot:
470       data.f[0] = dot(op[0], op[1]);
471       break;
472 
473    case ir_binop_min:
474       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
475       for (unsigned c = 0, c0 = 0, c1 = 0;
476 	   c < components;
477 	   c0 += c0_inc, c1 += c1_inc, c++) {
478 
479 	 switch (op[0]->type->base_type) {
480 	 case GLSL_TYPE_UINT:
481 	    data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
482 	    break;
483 	 case GLSL_TYPE_INT:
484 	    data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
485 	    break;
486 	 case GLSL_TYPE_FLOAT:
487 	    data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
488 	    break;
489 	 default:
490 	    assert(0);
491 	 }
492       }
493 
494       break;
495    case ir_binop_max:
496       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
497       for (unsigned c = 0, c0 = 0, c1 = 0;
498 	   c < components;
499 	   c0 += c0_inc, c1 += c1_inc, c++) {
500 
501 	 switch (op[0]->type->base_type) {
502 	 case GLSL_TYPE_UINT:
503 	    data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
504 	    break;
505 	 case GLSL_TYPE_INT:
506 	    data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
507 	    break;
508 	 case GLSL_TYPE_FLOAT:
509 	    data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
510 	    break;
511 	 default:
512 	    assert(0);
513 	 }
514       }
515       break;
516 
517    case ir_binop_add:
518       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
519       for (unsigned c = 0, c0 = 0, c1 = 0;
520 	   c < components;
521 	   c0 += c0_inc, c1 += c1_inc, c++) {
522 
523 	 switch (op[0]->type->base_type) {
524 	 case GLSL_TYPE_UINT:
525 	    data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
526 	    break;
527 	 case GLSL_TYPE_INT:
528 	    data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
529 	    break;
530 	 case GLSL_TYPE_FLOAT:
531 	    data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
532 	    break;
533 	 default:
534 	    assert(0);
535 	 }
536       }
537 
538       break;
539    case ir_binop_sub:
540       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
541       for (unsigned c = 0, c0 = 0, c1 = 0;
542 	   c < components;
543 	   c0 += c0_inc, c1 += c1_inc, c++) {
544 
545 	 switch (op[0]->type->base_type) {
546 	 case GLSL_TYPE_UINT:
547 	    data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
548 	    break;
549 	 case GLSL_TYPE_INT:
550 	    data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
551 	    break;
552 	 case GLSL_TYPE_FLOAT:
553 	    data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
554 	    break;
555 	 default:
556 	    assert(0);
557 	 }
558       }
559 
560       break;
561    case ir_binop_mul:
562       /* Check for equal types, or unequal types involving scalars */
563       if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
564 	  || op0_scalar || op1_scalar) {
565 	 for (unsigned c = 0, c0 = 0, c1 = 0;
566 	      c < components;
567 	      c0 += c0_inc, c1 += c1_inc, c++) {
568 
569 	    switch (op[0]->type->base_type) {
570 	    case GLSL_TYPE_UINT:
571 	       data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
572 	       break;
573 	    case GLSL_TYPE_INT:
574 	       data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
575 	       break;
576 	    case GLSL_TYPE_FLOAT:
577 	       data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
578 	       break;
579 	    default:
580 	       assert(0);
581 	    }
582 	 }
583       } else {
584 	 assert(op[0]->type->is_matrix() || op[1]->type->is_matrix());
585 
586 	 /* Multiply an N-by-M matrix with an M-by-P matrix.  Since either
587 	  * matrix can be a GLSL vector, either N or P can be 1.
588 	  *
589 	  * For vec*mat, the vector is treated as a row vector.  This
590 	  * means the vector is a 1-row x M-column matrix.
591 	  *
592 	  * For mat*vec, the vector is treated as a column vector.  Since
593 	  * matrix_columns is 1 for vectors, this just works.
594 	  */
595 	 const unsigned n = op[0]->type->is_vector()
596 	    ? 1 : op[0]->type->vector_elements;
597 	 const unsigned m = op[1]->type->vector_elements;
598 	 const unsigned p = op[1]->type->matrix_columns;
599 	 for (unsigned j = 0; j < p; j++) {
600 	    for (unsigned i = 0; i < n; i++) {
601 	       for (unsigned k = 0; k < m; k++) {
602 		  data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
603 	       }
604 	    }
605 	 }
606       }
607 
608       break;
609    case ir_binop_div:
610       /* FINISHME: Emit warning when division-by-zero is detected. */
611       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
612       for (unsigned c = 0, c0 = 0, c1 = 0;
613 	   c < components;
614 	   c0 += c0_inc, c1 += c1_inc, c++) {
615 
616 	 switch (op[0]->type->base_type) {
617 	 case GLSL_TYPE_UINT:
618 	    if (op[1]->value.u[c1] == 0) {
619 	       data.u[c] = 0;
620 	    } else {
621 	       data.u[c] = op[0]->value.u[c0] / op[1]->value.u[c1];
622 	    }
623 	    break;
624 	 case GLSL_TYPE_INT:
625 	    if (op[1]->value.i[c1] == 0) {
626 	       data.i[c] = 0;
627 	    } else {
628 	       data.i[c] = op[0]->value.i[c0] / op[1]->value.i[c1];
629 	    }
630 	    break;
631 	 case GLSL_TYPE_FLOAT:
632 	    data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
633 	    break;
634 	 default:
635 	    assert(0);
636 	 }
637       }
638 
639       break;
640    case ir_binop_mod:
641       /* FINISHME: Emit warning when division-by-zero is detected. */
642       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
643       for (unsigned c = 0, c0 = 0, c1 = 0;
644 	   c < components;
645 	   c0 += c0_inc, c1 += c1_inc, c++) {
646 
647 	 switch (op[0]->type->base_type) {
648 	 case GLSL_TYPE_UINT:
649 	    if (op[1]->value.u[c1] == 0) {
650 	       data.u[c] = 0;
651 	    } else {
652 	       data.u[c] = op[0]->value.u[c0] % op[1]->value.u[c1];
653 	    }
654 	    break;
655 	 case GLSL_TYPE_INT:
656 	    if (op[1]->value.i[c1] == 0) {
657 	       data.i[c] = 0;
658 	    } else {
659 	       data.i[c] = op[0]->value.i[c0] % op[1]->value.i[c1];
660 	    }
661 	    break;
662 	 case GLSL_TYPE_FLOAT:
663 	    /* We don't use fmod because it rounds toward zero; GLSL specifies
664 	     * the use of floor.
665 	     */
666 	    data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
667 	       * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
668 	    break;
669 	 default:
670 	    assert(0);
671 	 }
672       }
673 
674       break;
675 
676    case ir_binop_logic_and:
677       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
678       for (unsigned c = 0; c < op[0]->type->components(); c++)
679 	 data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
680       break;
681    case ir_binop_logic_xor:
682       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
683       for (unsigned c = 0; c < op[0]->type->components(); c++)
684 	 data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
685       break;
686    case ir_binop_logic_or:
687       assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
688       for (unsigned c = 0; c < op[0]->type->components(); c++)
689 	 data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
690       break;
691 
692    case ir_binop_less:
693       assert(op[0]->type == op[1]->type);
694       for (unsigned c = 0; c < op[0]->type->components(); c++) {
695 	 switch (op[0]->type->base_type) {
696 	 case GLSL_TYPE_UINT:
697 	    data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
698 	    break;
699 	 case GLSL_TYPE_INT:
700 	    data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
701 	    break;
702 	 case GLSL_TYPE_FLOAT:
703 	    data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
704 	    break;
705 	 default:
706 	    assert(0);
707 	 }
708       }
709       break;
710    case ir_binop_greater:
711       assert(op[0]->type == op[1]->type);
712       for (unsigned c = 0; c < op[0]->type->components(); c++) {
713 	 switch (op[0]->type->base_type) {
714 	 case GLSL_TYPE_UINT:
715 	    data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
716 	    break;
717 	 case GLSL_TYPE_INT:
718 	    data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
719 	    break;
720 	 case GLSL_TYPE_FLOAT:
721 	    data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
722 	    break;
723 	 default:
724 	    assert(0);
725 	 }
726       }
727       break;
728    case ir_binop_lequal:
729       assert(op[0]->type == op[1]->type);
730       for (unsigned c = 0; c < op[0]->type->components(); c++) {
731 	 switch (op[0]->type->base_type) {
732 	 case GLSL_TYPE_UINT:
733 	    data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
734 	    break;
735 	 case GLSL_TYPE_INT:
736 	    data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
737 	    break;
738 	 case GLSL_TYPE_FLOAT:
739 	    data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
740 	    break;
741 	 default:
742 	    assert(0);
743 	 }
744       }
745       break;
746    case ir_binop_gequal:
747       assert(op[0]->type == op[1]->type);
748       for (unsigned c = 0; c < op[0]->type->components(); c++) {
749 	 switch (op[0]->type->base_type) {
750 	 case GLSL_TYPE_UINT:
751 	    data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
752 	    break;
753 	 case GLSL_TYPE_INT:
754 	    data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
755 	    break;
756 	 case GLSL_TYPE_FLOAT:
757 	    data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
758 	    break;
759 	 default:
760 	    assert(0);
761 	 }
762       }
763       break;
764    case ir_binop_equal:
765       assert(op[0]->type == op[1]->type);
766       for (unsigned c = 0; c < components; c++) {
767 	 switch (op[0]->type->base_type) {
768 	 case GLSL_TYPE_UINT:
769 	    data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
770 	    break;
771 	 case GLSL_TYPE_INT:
772 	    data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
773 	    break;
774 	 case GLSL_TYPE_FLOAT:
775 	    data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
776 	    break;
777 	 case GLSL_TYPE_BOOL:
778 	    data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
779 	    break;
780 	 default:
781 	    assert(0);
782 	 }
783       }
784       break;
785    case ir_binop_nequal:
786       assert(op[0]->type == op[1]->type);
787       for (unsigned c = 0; c < components; c++) {
788 	 switch (op[0]->type->base_type) {
789 	 case GLSL_TYPE_UINT:
790 	    data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
791 	    break;
792 	 case GLSL_TYPE_INT:
793 	    data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
794 	    break;
795 	 case GLSL_TYPE_FLOAT:
796 	    data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
797 	    break;
798 	 case GLSL_TYPE_BOOL:
799 	    data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
800 	    break;
801 	 default:
802 	    assert(0);
803 	 }
804       }
805       break;
806    case ir_binop_all_equal:
807       data.b[0] = op[0]->has_value(op[1]);
808       break;
809    case ir_binop_any_nequal:
810       data.b[0] = !op[0]->has_value(op[1]);
811       break;
812 
813    case ir_binop_lshift:
814       for (unsigned c = 0, c0 = 0, c1 = 0;
815            c < components;
816            c0 += c0_inc, c1 += c1_inc, c++) {
817 
818           if (op[0]->type->base_type == GLSL_TYPE_INT &&
819               op[1]->type->base_type == GLSL_TYPE_INT) {
820               data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1];
821 
822           } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
823                      op[1]->type->base_type == GLSL_TYPE_UINT) {
824               data.i[c] = op[0]->value.i[c0] << op[1]->value.u[c1];
825 
826           } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
827                      op[1]->type->base_type == GLSL_TYPE_INT) {
828               data.u[c] = op[0]->value.u[c0] << op[1]->value.i[c1];
829 
830           } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
831                      op[1]->type->base_type == GLSL_TYPE_UINT) {
832               data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1];
833           }
834       }
835       break;
836 
837    case ir_binop_rshift:
838        for (unsigned c = 0, c0 = 0, c1 = 0;
839             c < components;
840             c0 += c0_inc, c1 += c1_inc, c++) {
841 
842            if (op[0]->type->base_type == GLSL_TYPE_INT &&
843                op[1]->type->base_type == GLSL_TYPE_INT) {
844                data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1];
845 
846            } else if (op[0]->type->base_type == GLSL_TYPE_INT &&
847                       op[1]->type->base_type == GLSL_TYPE_UINT) {
848                data.i[c] = op[0]->value.i[c0] >> op[1]->value.u[c1];
849 
850            } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
851                       op[1]->type->base_type == GLSL_TYPE_INT) {
852                data.u[c] = op[0]->value.u[c0] >> op[1]->value.i[c1];
853 
854            } else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
855                       op[1]->type->base_type == GLSL_TYPE_UINT) {
856                data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1];
857            }
858        }
859        break;
860 
861    case ir_binop_bit_and:
862       for (unsigned c = 0, c0 = 0, c1 = 0;
863            c < components;
864            c0 += c0_inc, c1 += c1_inc, c++) {
865 
866           switch (op[0]->type->base_type) {
867           case GLSL_TYPE_INT:
868               data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1];
869               break;
870           case GLSL_TYPE_UINT:
871               data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
872               break;
873           default:
874               assert(0);
875           }
876       }
877       break;
878 
879    case ir_binop_bit_or:
880       for (unsigned c = 0, c0 = 0, c1 = 0;
881            c < components;
882            c0 += c0_inc, c1 += c1_inc, c++) {
883 
884           switch (op[0]->type->base_type) {
885           case GLSL_TYPE_INT:
886               data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1];
887               break;
888           case GLSL_TYPE_UINT:
889               data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1];
890               break;
891           default:
892               assert(0);
893           }
894       }
895       break;
896 
897    case ir_binop_bit_xor:
898       for (unsigned c = 0, c0 = 0, c1 = 0;
899            c < components;
900            c0 += c0_inc, c1 += c1_inc, c++) {
901 
902           switch (op[0]->type->base_type) {
903           case GLSL_TYPE_INT:
904               data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1];
905               break;
906           case GLSL_TYPE_UINT:
907               data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
908               break;
909           default:
910               assert(0);
911           }
912       }
913       break;
914 
915    case ir_quadop_vector:
916       for (unsigned c = 0; c < this->type->vector_elements; c++) {
917 	 switch (this->type->base_type) {
918 	 case GLSL_TYPE_INT:
919 	    data.i[c] = op[c]->value.i[0];
920 	    break;
921 	 case GLSL_TYPE_UINT:
922 	    data.u[c] = op[c]->value.u[0];
923 	    break;
924 	 case GLSL_TYPE_FLOAT:
925 	    data.f[c] = op[c]->value.f[0];
926 	    break;
927 	 default:
928 	    assert(0);
929 	 }
930       }
931       break;
932 
933    default:
934       /* FINISHME: Should handle all expression types. */
935       return NULL;
936    }
937 
938    return new(ctx) ir_constant(this->type, &data);
939 }
940 
941 
942 ir_constant *
constant_expression_value(struct hash_table * variable_context)943 ir_texture::constant_expression_value(struct hash_table *variable_context)
944 {
945    /* texture lookups aren't constant expressions */
946    return NULL;
947 }
948 
949 
950 ir_constant *
constant_expression_value(struct hash_table * variable_context)951 ir_swizzle::constant_expression_value(struct hash_table *variable_context)
952 {
953    ir_constant *v = this->val->constant_expression_value(variable_context);
954 
955    if (v != NULL) {
956       ir_constant_data data = { { 0 } };
957 
958       const unsigned swiz_idx[4] = {
959 	 this->mask.x, this->mask.y, this->mask.z, this->mask.w
960       };
961 
962       for (unsigned i = 0; i < this->mask.num_components; i++) {
963 	 switch (v->type->base_type) {
964 	 case GLSL_TYPE_UINT:
965 	 case GLSL_TYPE_INT:   data.u[i] = v->value.u[swiz_idx[i]]; break;
966 	 case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
967 	 case GLSL_TYPE_BOOL:  data.b[i] = v->value.b[swiz_idx[i]]; break;
968 	 default:              assert(!"Should not get here."); break;
969 	 }
970       }
971 
972       void *ctx = ralloc_parent(this);
973       return new(ctx) ir_constant(this->type, &data);
974    }
975    return NULL;
976 }
977 
978 
979 void
constant_referenced(struct hash_table * variable_context,ir_constant * & store,int & offset) const980 ir_dereference_variable::constant_referenced(struct hash_table *variable_context,
981 					     ir_constant *&store, int &offset) const
982 {
983    if (variable_context) {
984       store = (ir_constant *)hash_table_find(variable_context, var);
985       offset = 0;
986    } else {
987       store = NULL;
988       offset = 0;
989    }
990 }
991 
992 ir_constant *
constant_expression_value(struct hash_table * variable_context)993 ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
994 {
995    /* This may occur during compile and var->type is glsl_type::error_type */
996    if (!var)
997       return NULL;
998 
999    /* Give priority to the context hashtable, if it exists */
1000    if (variable_context) {
1001       ir_constant *value = (ir_constant *)hash_table_find(variable_context, var);
1002       if(value)
1003 	 return value;
1004    }
1005 
1006    /* The constant_value of a uniform variable is its initializer,
1007     * not the lifetime constant value of the uniform.
1008     */
1009    if (var->mode == ir_var_uniform)
1010       return NULL;
1011 
1012    if (!var->constant_value)
1013       return NULL;
1014 
1015    return var->constant_value->clone(ralloc_parent(var), NULL);
1016 }
1017 
1018 
1019 void
constant_referenced(struct hash_table * variable_context,ir_constant * & store,int & offset) const1020 ir_dereference_array::constant_referenced(struct hash_table *variable_context,
1021 					  ir_constant *&store, int &offset) const
1022 {
1023    ir_constant *index_c = array_index->constant_expression_value(variable_context);
1024 
1025    if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer()) {
1026       store = 0;
1027       offset = 0;
1028       return;
1029    }
1030 
1031    int index = index_c->type->base_type == GLSL_TYPE_INT ?
1032       index_c->get_int_component(0) :
1033       index_c->get_uint_component(0);
1034 
1035    ir_constant *substore;
1036    int suboffset;
1037    const ir_dereference *deref = array->as_dereference();
1038    if (!deref) {
1039       store = 0;
1040       offset = 0;
1041       return;
1042    }
1043 
1044    deref->constant_referenced(variable_context, substore, suboffset);
1045 
1046    if (!substore) {
1047       store = 0;
1048       offset = 0;
1049       return;
1050    }
1051 
1052    const glsl_type *vt = substore->type;
1053    if (vt->is_array()) {
1054       store = substore->get_array_element(index);
1055       offset = 0;
1056       return;
1057    }
1058    if (vt->is_matrix()) {
1059       store = substore;
1060       offset = index * vt->vector_elements;
1061       return;
1062    }
1063    if (vt->is_vector()) {
1064       store = substore;
1065       offset = suboffset + index;
1066       return;
1067    }
1068 
1069    store = 0;
1070    offset = 0;
1071 }
1072 
1073 ir_constant *
constant_expression_value(struct hash_table * variable_context)1074 ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
1075 {
1076    ir_constant *array = this->array->constant_expression_value(variable_context);
1077    ir_constant *idx = this->array_index->constant_expression_value(variable_context);
1078 
1079    if ((array != NULL) && (idx != NULL)) {
1080       void *ctx = ralloc_parent(this);
1081       if (array->type->is_matrix()) {
1082 	 /* Array access of a matrix results in a vector.
1083 	  */
1084 	 const unsigned column = idx->value.u[0];
1085 
1086 	 const glsl_type *const column_type = array->type->column_type();
1087 
1088 	 /* Offset in the constant matrix to the first element of the column
1089 	  * to be extracted.
1090 	  */
1091 	 const unsigned mat_idx = column * column_type->vector_elements;
1092 
1093 	 ir_constant_data data = { { 0 } };
1094 
1095 	 switch (column_type->base_type) {
1096 	 case GLSL_TYPE_UINT:
1097 	 case GLSL_TYPE_INT:
1098 	    for (unsigned i = 0; i < column_type->vector_elements; i++)
1099 	       data.u[i] = array->value.u[mat_idx + i];
1100 
1101 	    break;
1102 
1103 	 case GLSL_TYPE_FLOAT:
1104 	    for (unsigned i = 0; i < column_type->vector_elements; i++)
1105 	       data.f[i] = array->value.f[mat_idx + i];
1106 
1107 	    break;
1108 
1109 	 default:
1110 	    assert(!"Should not get here.");
1111 	    break;
1112 	 }
1113 
1114 	 return new(ctx) ir_constant(column_type, &data);
1115       } else if (array->type->is_vector()) {
1116 	 const unsigned component = idx->value.u[0];
1117 
1118 	 return new(ctx) ir_constant(array, component);
1119       } else {
1120 	 const unsigned index = idx->value.u[0];
1121 	 return array->get_array_element(index)->clone(ctx, NULL);
1122       }
1123    }
1124    return NULL;
1125 }
1126 
1127 
1128 void
constant_referenced(struct hash_table * variable_context,ir_constant * & store,int & offset) const1129 ir_dereference_record::constant_referenced(struct hash_table *variable_context,
1130 					   ir_constant *&store, int &offset) const
1131 {
1132    ir_constant *substore;
1133    int suboffset;
1134    const ir_dereference *deref = record->as_dereference();
1135    if (!deref) {
1136       store = 0;
1137       offset = 0;
1138       return;
1139    }
1140 
1141    deref->constant_referenced(variable_context, substore, suboffset);
1142 
1143    if (!substore) {
1144       store = 0;
1145       offset = 0;
1146       return;
1147    }
1148 
1149    store = substore->get_record_field(field);
1150    offset = 0;
1151 }
1152 
1153 ir_constant *
constant_expression_value(struct hash_table * variable_context)1154 ir_dereference_record::constant_expression_value(struct hash_table *variable_context)
1155 {
1156    ir_constant *v = this->record->constant_expression_value();
1157 
1158    return (v != NULL) ? v->get_record_field(this->field) : NULL;
1159 }
1160 
1161 
1162 ir_constant *
constant_expression_value(struct hash_table * variable_context)1163 ir_assignment::constant_expression_value(struct hash_table *variable_context)
1164 {
1165    /* FINISHME: Handle CEs involving assignment (return RHS) */
1166    return NULL;
1167 }
1168 
1169 
1170 ir_constant *
constant_expression_value(struct hash_table * variable_context)1171 ir_constant::constant_expression_value(struct hash_table *variable_context)
1172 {
1173    return this;
1174 }
1175 
1176 
1177 ir_constant *
constant_expression_value(struct hash_table * variable_context)1178 ir_call::constant_expression_value(struct hash_table *variable_context)
1179 {
1180    return this->callee->constant_expression_value(&this->actual_parameters, variable_context);
1181 }
1182 
1183 
constant_expression_evaluate_expression_list(const struct exec_list & body,struct hash_table * variable_context,ir_constant ** result)1184 bool ir_function_signature::constant_expression_evaluate_expression_list(const struct exec_list &body,
1185 									 struct hash_table *variable_context,
1186 									 ir_constant **result)
1187 {
1188    foreach_list(n, &body) {
1189       ir_instruction *inst = (ir_instruction *)n;
1190       switch(inst->ir_type) {
1191 
1192 	 /* (declare () type symbol) */
1193       case ir_type_variable: {
1194 	 ir_variable *var = inst->as_variable();
1195 	 hash_table_insert(variable_context, ir_constant::zero(this, var->type), var);
1196 	 break;
1197       }
1198 
1199 	 /* (assign [condition] (write-mask) (ref) (value)) */
1200       case ir_type_assignment: {
1201 	 ir_assignment *asg = inst->as_assignment();
1202 	 if (asg->condition) {
1203 	    ir_constant *cond = asg->condition->constant_expression_value(variable_context);
1204 	    if (!cond)
1205 	       return false;
1206 	    if (!cond->get_bool_component(0))
1207 	       break;
1208 	 }
1209 
1210 	 ir_constant *store = NULL;
1211 	 int offset = 0;
1212 	 asg->lhs->constant_referenced(variable_context, store, offset);
1213 
1214 	 if (!store)
1215 	    return false;
1216 
1217 	 ir_constant *value = asg->rhs->constant_expression_value(variable_context);
1218 
1219 	 if (!value)
1220 	    return false;
1221 
1222 	 store->copy_masked_offset(value, offset, asg->write_mask);
1223 	 break;
1224       }
1225 
1226 	 /* (return (expression)) */
1227       case ir_type_return:
1228 	 assert (result);
1229 	 *result = inst->as_return()->value->constant_expression_value(variable_context);
1230 	 return *result != NULL;
1231 
1232 	 /* (call name (ref) (params))*/
1233       case ir_type_call: {
1234 	 ir_call *call = inst->as_call();
1235 
1236 	 /* Just say no to void functions in constant expressions.  We
1237 	  * don't need them at that point.
1238 	  */
1239 
1240 	 if (!call->return_deref)
1241 	    return false;
1242 
1243 	 ir_constant *store = NULL;
1244 	 int offset = 0;
1245 	 call->return_deref->constant_referenced(variable_context, store, offset);
1246 
1247 	 if (!store)
1248 	    return false;
1249 
1250 	 ir_constant *value = call->constant_expression_value(variable_context);
1251 
1252 	 if(!value)
1253 	    return false;
1254 
1255 	 store->copy_offset(value, offset);
1256 	 break;
1257       }
1258 
1259 	 /* (if condition (then-instructions) (else-instructions)) */
1260       case ir_type_if: {
1261 	 ir_if *iif = inst->as_if();
1262 
1263 	 ir_constant *cond = iif->condition->constant_expression_value(variable_context);
1264 	 if (!cond || !cond->type->is_boolean())
1265 	    return false;
1266 
1267 	 exec_list &branch = cond->get_bool_component(0) ? iif->then_instructions : iif->else_instructions;
1268 
1269 	 *result = NULL;
1270 	 if (!constant_expression_evaluate_expression_list(branch, variable_context, result))
1271 	    return false;
1272 
1273 	 /* If there was a return in the branch chosen, drop out now. */
1274 	 if (*result)
1275 	    return true;
1276 
1277 	 break;
1278       }
1279 
1280 	 /* Every other expression type, we drop out. */
1281       default:
1282 	 return false;
1283       }
1284    }
1285 
1286    /* Reaching the end of the block is not an error condition */
1287    if (result)
1288       *result = NULL;
1289 
1290    return true;
1291 }
1292 
1293 ir_constant *
constant_expression_value(exec_list * actual_parameters,struct hash_table * variable_context)1294 ir_function_signature::constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context)
1295 {
1296    const glsl_type *type = this->return_type;
1297    if (type == glsl_type::void_type)
1298       return NULL;
1299 
1300    /* From the GLSL 1.20 spec, page 23:
1301     * "Function calls to user-defined functions (non-built-in functions)
1302     *  cannot be used to form constant expressions."
1303     */
1304    if (!this->is_builtin)
1305       return NULL;
1306 
1307    /*
1308     * Of the builtin functions, only the texture lookups and the noise
1309     * ones must not be used in constant expressions.  They all include
1310     * specific opcodes so they don't need to be special-cased at this
1311     * point.
1312     */
1313 
1314    /* Initialize the table of dereferencable names with the function
1315     * parameters.  Verify their const-ness on the way.
1316     *
1317     * We expect the correctness of the number of parameters to have
1318     * been checked earlier.
1319     */
1320    hash_table *deref_hash = hash_table_ctor(8, hash_table_pointer_hash,
1321 					    hash_table_pointer_compare);
1322 
1323    /* If "origin" is non-NULL, then the function body is there.  So we
1324     * have to use the variable objects from the object with the body,
1325     * but the parameter instanciation on the current object.
1326     */
1327    const exec_node *parameter_info = origin ? origin->parameters.head : parameters.head;
1328 
1329    foreach_list(n, actual_parameters) {
1330       ir_constant *constant = ((ir_rvalue *) n)->constant_expression_value(variable_context);
1331       if (constant == NULL) {
1332          hash_table_dtor(deref_hash);
1333          return NULL;
1334       }
1335 
1336 
1337       ir_variable *var = (ir_variable *)parameter_info;
1338       hash_table_insert(deref_hash, constant, var);
1339 
1340       parameter_info = parameter_info->next;
1341    }
1342 
1343    ir_constant *result = NULL;
1344 
1345    /* Now run the builtin function until something non-constant
1346     * happens or we get the result.
1347     */
1348    if (constant_expression_evaluate_expression_list(origin ? origin->body : body, deref_hash, &result) && result)
1349       result = result->clone(ralloc_parent(this), NULL);
1350 
1351    hash_table_dtor(deref_hash);
1352 
1353    return result;
1354 }
1355