projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ir_constant_expression: Add support for the "step" builtin.
[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/macros.h"
38 #include "ir.h"
39 #include "ir_visitor.h"
40 #include "glsl_types.h"
41
42 static float
43 dot(ir_constant *op0, ir_constant *op1)
44 {
45 assert(op0->type->is_float() && op1->type->is_float());
46
47 float result = 0;
48 for (unsigned c = 0; c < op0->type->components(); c++)
49 result += op0->value.f[c] * op1->value.f[c];
50
51 return result;
52 }
53
54 ir_constant *
55 ir_expression::constant_expression_value()
56 {
57 ir_constant *op[2] = { NULL, NULL };
58 ir_constant_data data;
59
60 memset(&data, 0, sizeof(data));
61
62 for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
63 op[operand] = this->operands[operand]->constant_expression_value();
64 if (!op[operand])
65 return NULL;
66 }
67
68 if (op[1] != NULL)
69 assert(op[0]->type->base_type == op[1]->type->base_type);
70
71 bool op0_scalar = op[0]->type->is_scalar();
72 bool op1_scalar = op[1] != NULL && op[1]->type->is_scalar();
73
74 /* When iterating over a vector or matrix's components, we want to increase
75 * the loop counter. However, for scalars, we want to stay at 0.
76 */
77 unsigned c0_inc = op0_scalar ? 0 : 1;
78 unsigned c1_inc = op1_scalar ? 0 : 1;
79 unsigned components;
80 if (op1_scalar || !op[1]) {
81 components = op[0]->type->components();
82 } else {
83 components = op[1]->type->components();
84 }
85
86 void *ctx = talloc_parent(this);
87
88 /* Handle array operations here, rather than below. */
89 if (op[0]->type->is_array()) {
90 assert(op[1] != NULL && op[1]->type->is_array());
91 switch (this->operation) {
92 case ir_binop_equal:
93 return new(ctx) ir_constant(op[0]->has_value(op[1]));
94 case ir_binop_nequal:
95 return new(ctx) ir_constant(!op[0]->has_value(op[1]));
96 default:
97 break;
98 }
99 return NULL;
100 }
101
102 switch (this->operation) {
103 case ir_unop_logic_not:
104 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
105 for (unsigned c = 0; c < op[0]->type->components(); c++)
106 data.b[c] = !op[0]->value.b[c];
107 break;
108
109 case ir_unop_f2i:
110 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
111 for (unsigned c = 0; c < op[0]->type->components(); c++) {
112 data.i[c] = op[0]->value.f[c];
113 }
114 break;
115 case ir_unop_i2f:
116 assert(op[0]->type->base_type == GLSL_TYPE_INT);
117 for (unsigned c = 0; c < op[0]->type->components(); c++) {
118 data.f[c] = op[0]->value.i[c];
119 }
120 break;
121 case ir_unop_u2f:
122 assert(op[0]->type->base_type == GLSL_TYPE_UINT);
123 for (unsigned c = 0; c < op[0]->type->components(); c++) {
124 data.f[c] = op[0]->value.u[c];
125 }
126 break;
127 case ir_unop_b2f:
128 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
129 for (unsigned c = 0; c < op[0]->type->components(); c++) {
130 data.f[c] = op[0]->value.b[c] ? 1.0 : 0.0;
131 }
132 break;
133 case ir_unop_f2b:
134 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
135 for (unsigned c = 0; c < op[0]->type->components(); c++) {
136 data.b[c] = bool(op[0]->value.f[c]);
137 }
138 break;
139 case ir_unop_b2i:
140 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
141 for (unsigned c = 0; c < op[0]->type->components(); c++) {
142 data.u[c] = op[0]->value.b[c] ? 1 : 0;
143 }
144 break;
145 case ir_unop_i2b:
146 assert(op[0]->type->is_integer());
147 for (unsigned c = 0; c < op[0]->type->components(); c++) {
148 data.b[c] = bool(op[0]->value.u[c]);
149 }
150 break;
151
152 case ir_unop_trunc:
153 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
154 for (unsigned c = 0; c < op[0]->type->components(); c++) {
155 data.f[c] = truncf(op[0]->value.f[c]);
156 }
157 break;
158
159 case ir_unop_ceil:
160 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
161 for (unsigned c = 0; c < op[0]->type->components(); c++) {
162 data.f[c] = ceilf(op[0]->value.f[c]);
163 }
164 break;
165
166 case ir_unop_floor:
167 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
168 for (unsigned c = 0; c < op[0]->type->components(); c++) {
169 data.f[c] = floorf(op[0]->value.f[c]);
170 }
171 break;
172
173 case ir_unop_fract:
174 for (unsigned c = 0; c < op[0]->type->components(); c++) {
175 switch (this->type->base_type) {
176 case GLSL_TYPE_UINT:
177 data.u[c] = 0;
178 break;
179 case GLSL_TYPE_INT:
180 data.i[c] = 0;
181 break;
182 case GLSL_TYPE_FLOAT:
183 data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
184 break;
185 default:
186 assert(0);
187 }
188 }
189 break;
190
191 case ir_unop_sin:
192 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
193 for (unsigned c = 0; c < op[0]->type->components(); c++) {
194 data.f[c] = sinf(op[0]->value.f[c]);
195 }
196 break;
197
198 case ir_unop_cos:
199 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
200 for (unsigned c = 0; c < op[0]->type->components(); c++) {
201 data.f[c] = cosf(op[0]->value.f[c]);
202 }
203 break;
204
205 case ir_unop_neg:
206 for (unsigned c = 0; c < op[0]->type->components(); c++) {
207 switch (this->type->base_type) {
208 case GLSL_TYPE_UINT:
209 data.u[c] = -op[0]->value.u[c];
210 break;
211 case GLSL_TYPE_INT:
212 data.i[c] = -op[0]->value.i[c];
213 break;
214 case GLSL_TYPE_FLOAT:
215 data.f[c] = -op[0]->value.f[c];
216 break;
217 default:
218 assert(0);
219 }
220 }
221 break;
222
223 case ir_unop_abs:
224 for (unsigned c = 0; c < op[0]->type->components(); c++) {
225 switch (this->type->base_type) {
226 case GLSL_TYPE_UINT:
227 data.u[c] = op[0]->value.u[c];
228 break;
229 case GLSL_TYPE_INT:
230 data.i[c] = op[0]->value.i[c];
231 if (data.i[c] < 0)
232 data.i[c] = -data.i[c];
233 break;
234 case GLSL_TYPE_FLOAT:
235 data.f[c] = fabs(op[0]->value.f[c]);
236 break;
237 default:
238 assert(0);
239 }
240 }
241 break;
242
243 case ir_unop_sign:
244 for (unsigned c = 0; c < op[0]->type->components(); c++) {
245 switch (this->type->base_type) {
246 case GLSL_TYPE_UINT:
247 data.u[c] = op[0]->value.i[c] > 0;
248 break;
249 case GLSL_TYPE_INT:
250 data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
251 break;
252 case GLSL_TYPE_FLOAT:
253 data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
254 break;
255 default:
256 assert(0);
257 }
258 }
259 break;
260
261 case ir_unop_rcp:
262 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
263 for (unsigned c = 0; c < op[0]->type->components(); c++) {
264 switch (this->type->base_type) {
265 case GLSL_TYPE_UINT:
266 if (op[0]->value.u[c] != 0.0)
267 data.u[c] = 1 / op[0]->value.u[c];
268 break;
269 case GLSL_TYPE_INT:
270 if (op[0]->value.i[c] != 0.0)
271 data.i[c] = 1 / op[0]->value.i[c];
272 break;
273 case GLSL_TYPE_FLOAT:
274 if (op[0]->value.f[c] != 0.0)
275 data.f[c] = 1.0 / op[0]->value.f[c];
276 break;
277 default:
278 assert(0);
279 }
280 }
281 break;
282
283 case ir_unop_rsq:
284 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
285 for (unsigned c = 0; c < op[0]->type->components(); c++) {
286 data.f[c] = 1.0 / sqrtf(op[0]->value.f[c]);
287 }
288 break;
289
290 case ir_unop_sqrt:
291 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
292 for (unsigned c = 0; c < op[0]->type->components(); c++) {
293 data.f[c] = sqrtf(op[0]->value.f[c]);
294 }
295 break;
296
297 case ir_unop_exp:
298 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
299 for (unsigned c = 0; c < op[0]->type->components(); c++) {
300 data.f[c] = expf(op[0]->value.f[c]);
301 }
302 break;
303
304 case ir_unop_exp2:
305 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
306 for (unsigned c = 0; c < op[0]->type->components(); c++) {
307 data.f[c] = exp2f(op[0]->value.f[c]);
308 }
309 break;
310
311 case ir_unop_log:
312 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
313 for (unsigned c = 0; c < op[0]->type->components(); c++) {
314 data.f[c] = logf(op[0]->value.f[c]);
315 }
316 break;
317
318 case ir_unop_log2:
319 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
320 for (unsigned c = 0; c < op[0]->type->components(); c++) {
321 data.f[c] = log2f(op[0]->value.f[c]);
322 }
323 break;
324
325 case ir_unop_dFdx:
326 case ir_unop_dFdy:
327 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
328 for (unsigned c = 0; c < op[0]->type->components(); c++) {
329 data.f[c] = 0.0;
330 }
331 break;
332
333 case ir_binop_pow:
334 assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
335 for (unsigned c = 0; c < op[0]->type->components(); c++) {
336 data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
337 }
338 break;
339
340 case ir_binop_dot:
341 data.f[0] = dot(op[0], op[1]);
342 break;
343
344 case ir_binop_min:
345 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
346 for (unsigned c = 0, c0 = 0, c1 = 0;
347 c < components;
348 c0 += c0_inc, c1 += c1_inc, c++) {
349
350 switch (op[0]->type->base_type) {
351 case GLSL_TYPE_UINT:
352 data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
353 break;
354 case GLSL_TYPE_INT:
355 data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
356 break;
357 case GLSL_TYPE_FLOAT:
358 data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
359 break;
360 default:
361 assert(0);
362 }
363 }
364
365 break;
366 case ir_binop_max:
367 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
368 for (unsigned c = 0, c0 = 0, c1 = 0;
369 c < components;
370 c0 += c0_inc, c1 += c1_inc, c++) {
371
372 switch (op[0]->type->base_type) {
373 case GLSL_TYPE_UINT:
374 data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
375 break;
376 case GLSL_TYPE_INT:
377 data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
378 break;
379 case GLSL_TYPE_FLOAT:
380 data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
381 break;
382 default:
383 assert(0);
384 }
385 }
386 break;
387
388 case ir_binop_cross:
389 assert(op[0]->type == glsl_type::vec3_type);
390 assert(op[1]->type == glsl_type::vec3_type);
391 data.f[0] = (op[0]->value.f[1] * op[1]->value.f[2] -
392 op[1]->value.f[1] * op[0]->value.f[2]);
393 data.f[1] = (op[0]->value.f[2] * op[1]->value.f[0] -
394 op[1]->value.f[2] * op[0]->value.f[0]);
395 data.f[2] = (op[0]->value.f[0] * op[1]->value.f[1] -
396 op[1]->value.f[0] * op[0]->value.f[1]);
397 break;
398
399 case ir_binop_add:
400 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
401 for (unsigned c = 0, c0 = 0, c1 = 0;
402 c < components;
403 c0 += c0_inc, c1 += c1_inc, c++) {
404
405 switch (op[0]->type->base_type) {
406 case GLSL_TYPE_UINT:
407 data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
408 break;
409 case GLSL_TYPE_INT:
410 data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
411 break;
412 case GLSL_TYPE_FLOAT:
413 data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
414 break;
415 default:
416 assert(0);
417 }
418 }
419
420 break;
421 case ir_binop_sub:
422 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
423 for (unsigned c = 0, c0 = 0, c1 = 0;
424 c < components;
425 c0 += c0_inc, c1 += c1_inc, c++) {
426
427 switch (op[0]->type->base_type) {
428 case GLSL_TYPE_UINT:
429 data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
430 break;
431 case GLSL_TYPE_INT:
432 data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
433 break;
434 case GLSL_TYPE_FLOAT:
435 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
436 break;
437 default:
438 assert(0);
439 }
440 }
441
442 break;
443 case ir_binop_mul:
444 /* Check for equal types, or unequal types involving scalars */
445 if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
446 || op0_scalar || op1_scalar) {
447 for (unsigned c = 0, c0 = 0, c1 = 0;
448 c < components;
449 c0 += c0_inc, c1 += c1_inc, c++) {
450
451 switch (op[0]->type->base_type) {
452 case GLSL_TYPE_UINT:
453 data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
454 break;
455 case GLSL_TYPE_INT:
456 data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
457 break;
458 case GLSL_TYPE_FLOAT:
459 data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
460 break;
461 default:
462 assert(0);
463 }
464 }
465 } else {
466 assert(op[0]->type->is_matrix() || op[1]->type->is_matrix());
467
468 /* Multiply an N-by-M matrix with an M-by-P matrix. Since either
469 * matrix can be a GLSL vector, either N or P can be 1.
470 *
471 * For vec*mat, the vector is treated as a row vector. This
472 * means the vector is a 1-row x M-column matrix.
473 *
474 * For mat*vec, the vector is treated as a column vector. Since
475 * matrix_columns is 1 for vectors, this just works.
476 */
477 const unsigned n = op[0]->type->is_vector()
478 ? 1 : op[0]->type->vector_elements;
479 const unsigned m = op[1]->type->vector_elements;
480 const unsigned p = op[1]->type->matrix_columns;
481 for (unsigned j = 0; j < p; j++) {
482 for (unsigned i = 0; i < n; i++) {
483 for (unsigned k = 0; k < m; k++) {
484 data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
485 }
486 }
487 }
488 }
489
490 break;
491 case ir_binop_div:
492 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
493 for (unsigned c = 0, c0 = 0, c1 = 0;
494 c < components;
495 c0 += c0_inc, c1 += c1_inc, c++) {
496
497 switch (op[0]->type->base_type) {
498 case GLSL_TYPE_UINT:
499 data.u[c] = op[0]->value.u[c0] / op[1]->value.u[c1];
500 break;
501 case GLSL_TYPE_INT:
502 data.i[c] = op[0]->value.i[c0] / op[1]->value.i[c1];
503 break;
504 case GLSL_TYPE_FLOAT:
505 data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
506 break;
507 default:
508 assert(0);
509 }
510 }
511
512 break;
513 case ir_binop_mod:
514 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
515 for (unsigned c = 0, c0 = 0, c1 = 0;
516 c < components;
517 c0 += c0_inc, c1 += c1_inc, c++) {
518
519 switch (op[0]->type->base_type) {
520 case GLSL_TYPE_UINT:
521 data.u[c] = op[0]->value.u[c0] % op[1]->value.u[c1];
522 break;
523 case GLSL_TYPE_INT:
524 data.i[c] = op[0]->value.i[c0] % op[1]->value.i[c1];
525 break;
526 case GLSL_TYPE_FLOAT:
527 /* We don't use fmod because it rounds toward zero; GLSL specifies
528 * the use of floor.
529 */
530 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
531 * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
532 break;
533 default:
534 assert(0);
535 }
536 }
537
538 break;
539
540 case ir_binop_logic_and:
541 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
542 for (unsigned c = 0; c < op[0]->type->components(); c++)
543 data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
544 break;
545 case ir_binop_logic_xor:
546 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
547 for (unsigned c = 0; c < op[0]->type->components(); c++)
548 data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
549 break;
550 case ir_binop_logic_or:
551 assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
552 for (unsigned c = 0; c < op[0]->type->components(); c++)
553 data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
554 break;
555
556 case ir_binop_less:
557 switch (op[0]->type->base_type) {
558 case GLSL_TYPE_UINT:
559 data.b[0] = op[0]->value.u[0] < op[1]->value.u[0];
560 break;
561 case GLSL_TYPE_INT:
562 data.b[0] = op[0]->value.i[0] < op[1]->value.i[0];
563 break;
564 case GLSL_TYPE_FLOAT:
565 data.b[0] = op[0]->value.f[0] < op[1]->value.f[0];
566 break;
567 default:
568 assert(0);
569 }
570 break;
571 case ir_binop_greater:
572 switch (op[0]->type->base_type) {
573 case GLSL_TYPE_UINT:
574 data.b[0] = op[0]->value.u[0] > op[1]->value.u[0];
575 break;
576 case GLSL_TYPE_INT:
577 data.b[0] = op[0]->value.i[0] > op[1]->value.i[0];
578 break;
579 case GLSL_TYPE_FLOAT:
580 data.b[0] = op[0]->value.f[0] > op[1]->value.f[0];
581 break;
582 default:
583 assert(0);
584 }
585 break;
586 case ir_binop_lequal:
587 switch (op[0]->type->base_type) {
588 case GLSL_TYPE_UINT:
589 data.b[0] = op[0]->value.u[0] <= op[1]->value.u[0];
590 break;
591 case GLSL_TYPE_INT:
592 data.b[0] = op[0]->value.i[0] <= op[1]->value.i[0];
593 break;
594 case GLSL_TYPE_FLOAT:
595 data.b[0] = op[0]->value.f[0] <= op[1]->value.f[0];
596 break;
597 default:
598 assert(0);
599 }
600 break;
601 case ir_binop_gequal:
602 switch (op[0]->type->base_type) {
603 case GLSL_TYPE_UINT:
604 data.b[0] = op[0]->value.u[0] >= op[1]->value.u[0];
605 break;
606 case GLSL_TYPE_INT:
607 data.b[0] = op[0]->value.i[0] >= op[1]->value.i[0];
608 break;
609 case GLSL_TYPE_FLOAT:
610 data.b[0] = op[0]->value.f[0] >= op[1]->value.f[0];
611 break;
612 default:
613 assert(0);
614 }
615 break;
616
617 case ir_binop_equal:
618 data.b[0] = op[0]->has_value(op[1]);
619 break;
620 case ir_binop_nequal:
621 data.b[0] = !op[0]->has_value(op[1]);
622 break;
623
624 default:
625 /* FINISHME: Should handle all expression types. */
626 return NULL;
627 }
628
629 return new(ctx) ir_constant(this->type, &data);
630 }
631
632
633 ir_constant *
634 ir_texture::constant_expression_value()
635 {
636 /* texture lookups aren't constant expressions */
637 return NULL;
638 }
639
640
641 ir_constant *
642 ir_swizzle::constant_expression_value()
643 {
644 ir_constant *v = this->val->constant_expression_value();
645
646 if (v != NULL) {
647 ir_constant_data data;
648
649 const unsigned swiz_idx[4] = {
650 this->mask.x, this->mask.y, this->mask.z, this->mask.w
651 };
652
653 for (unsigned i = 0; i < this->mask.num_components; i++) {
654 switch (v->type->base_type) {
655 case GLSL_TYPE_UINT:
656 case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
657 case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
658 case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
659 default: assert(!"Should not get here."); break;
660 }
661 }
662
663 void *ctx = talloc_parent(this);
664 return new(ctx) ir_constant(this->type, &data);
665 }
666 return NULL;
667 }
668
669
670 ir_constant *
671 ir_dereference_variable::constant_expression_value()
672 {
673 /* This may occur during compile and var->type is glsl_type::error_type */
674 if (!var)
675 return NULL;
676
677 return var->constant_value ? var->constant_value->clone(NULL) : NULL;
678 }
679
680
681 ir_constant *
682 ir_dereference_array::constant_expression_value()
683 {
684 void *ctx = talloc_parent(this);
685 ir_constant *array = this->array->constant_expression_value();
686 ir_constant *idx = this->array_index->constant_expression_value();
687
688 if ((array != NULL) && (idx != NULL)) {
689 if (array->type->is_matrix()) {
690 /* Array access of a matrix results in a vector.
691 */
692 const unsigned column = idx->value.u[0];
693
694 const glsl_type *const column_type = array->type->column_type();
695
696 /* Offset in the constant matrix to the first element of the column
697 * to be extracted.
698 */
699 const unsigned mat_idx = column * column_type->vector_elements;
700
701 ir_constant_data data;
702
703 switch (column_type->base_type) {
704 case GLSL_TYPE_UINT:
705 case GLSL_TYPE_INT:
706 for (unsigned i = 0; i < column_type->vector_elements; i++)
707 data.u[i] = array->value.u[mat_idx + i];
708
709 break;
710
711 case GLSL_TYPE_FLOAT:
712 for (unsigned i = 0; i < column_type->vector_elements; i++)
713 data.f[i] = array->value.f[mat_idx + i];
714
715 break;
716
717 default:
718 assert(!"Should not get here.");
719 break;
720 }
721
722 return new(ctx) ir_constant(column_type, &data);
723 } else if (array->type->is_vector()) {
724 const unsigned component = idx->value.u[0];
725
726 return new(ctx) ir_constant(array, component);
727 } else {
728 const unsigned index = idx->value.u[0];
729 return array->get_array_element(index)->clone(NULL);
730 }
731 }
732 return NULL;
733 }
734
735
736 ir_constant *
737 ir_dereference_record::constant_expression_value()
738 {
739 ir_constant *v = this->record->constant_expression_value();
740
741 return (v != NULL) ? v->get_record_field(this->field) : NULL;
742 }
743
744
745 ir_constant *
746 ir_assignment::constant_expression_value()
747 {
748 /* FINISHME: Handle CEs involving assignment (return RHS) */
749 return NULL;
750 }
751
752
753 ir_constant *
754 ir_constant::constant_expression_value()
755 {
756 return this;
757 }
758
759
760 ir_constant *
761 ir_call::constant_expression_value()
762 {
763 if (this->type == glsl_type::error_type)
764 return NULL;
765
766 /* From the GLSL 1.20 spec, page 23:
767 * "Function calls to user-defined functions (non-built-in functions)
768 * cannot be used to form constant expressions."
769 */
770 if (!this->callee->is_built_in)
771 return NULL;
772
773 unsigned num_parameters = 0;
774
775 /* Check if all parameters are constant */
776 ir_constant *op[3];
777 foreach_list(n, &this->actual_parameters) {
778 ir_constant *constant = ((ir_rvalue *) n)->constant_expression_value();
779 if (constant == NULL)
780 return NULL;
781
782 op[num_parameters] = constant;
783
784 assert(num_parameters < 3);
785 num_parameters++;
786 }
787
788 /* Individual cases below can either:
789 * - Assign "expr" a new ir_expression to evaluate (for basic opcodes)
790 * - Fill "data" with appopriate constant data
791 * - Return an ir_constant directly.
792 */
793 void *mem_ctx = talloc_parent(this);
794 ir_expression *expr = NULL;
795
796 ir_constant_data data;
797 memset(&data, 0, sizeof(data));
798
799 const char *callee = this->callee_name();
800 if (strcmp(callee, "abs") == 0) {
801 expr = new(mem_ctx) ir_expression(ir_unop_abs, type, op[0], NULL);
802 } else if (strcmp(callee, "all") == 0) {
803 assert(op[0]->type->is_boolean());
804 for (unsigned c = 0; c < op[0]->type->components(); c++) {
805 if (!op[0]->value.b[c])
806 return new(mem_ctx) ir_constant(false);
807 }
808 return new(mem_ctx) ir_constant(true);
809 } else if (strcmp(callee, "any") == 0) {
810 assert(op[0]->type->is_boolean());
811 for (unsigned c = 0; c < op[0]->type->components(); c++) {
812 if (op[0]->value.b[c])
813 return new(mem_ctx) ir_constant(true);
814 }
815 return new(mem_ctx) ir_constant(false);
816 } else if (strcmp(callee, "acos") == 0) {
817 assert(op[0]->type->is_float());
818 for (unsigned c = 0; c < op[0]->type->components(); c++)
819 data.f[c] = acosf(op[0]->value.f[c]);
820 } else if (strcmp(callee, "asin") == 0) {
821 assert(op[0]->type->is_float());
822 for (unsigned c = 0; c < op[0]->type->components(); c++)
823 data.f[c] = asinf(op[0]->value.f[c]);
824 } else if (strcmp(callee, "atan") == 0) {
825 assert(op[0]->type->is_float());
826 if (num_parameters == 2) {
827 assert(op[1]->type->is_float());
828 for (unsigned c = 0; c < op[0]->type->components(); c++)
829 data.f[c] = atan2f(op[0]->value.f[c], op[1]->value.f[c]);
830 } else {
831 for (unsigned c = 0; c < op[0]->type->components(); c++)
832 data.f[c] = atanf(op[0]->value.f[c]);
833 }
834 } else if (strcmp(callee, "dFdx") == 0 || strcmp(callee, "dFdy") == 0) {
835 return ir_constant::zero(mem_ctx, this->type);
836 } else if (strcmp(callee, "ceil") == 0) {
837 expr = new(mem_ctx) ir_expression(ir_unop_ceil, type, op[0], NULL);
838 } else if (strcmp(callee, "clamp") == 0) {
839 return NULL; /* FINISHME: implement this */
840 } else if (strcmp(callee, "cos") == 0) {
841 expr = new(mem_ctx) ir_expression(ir_unop_cos, type, op[0], NULL);
842 } else if (strcmp(callee, "cosh") == 0) {
843 assert(op[0]->type->is_float());
844 for (unsigned c = 0; c < op[0]->type->components(); c++)
845 data.f[c] = coshf(op[0]->value.f[c]);
846 } else if (strcmp(callee, "cross") == 0) {
847 expr = new(mem_ctx) ir_expression(ir_binop_cross, type, op[0], op[1]);
848 } else if (strcmp(callee, "degrees") == 0) {
849 assert(op[0]->type->is_float());
850 for (unsigned c = 0; c < op[0]->type->components(); c++)
851 data.f[c] = 180.0/M_PI * op[0]->value.f[c];
852 } else if (strcmp(callee, "distance") == 0) {
853 assert(op[0]->type->is_float() && op[1]->type->is_float());
854 float length_squared = 0.0;
855 for (unsigned c = 0; c < op[0]->type->components(); c++) {
856 float t = op[0]->value.f[c] - op[1]->value.f[c];
857 length_squared += t * t;
858 }
859 return new(mem_ctx) ir_constant(sqrtf(length_squared));
860 } else if (strcmp(callee, "dot") == 0) {
861 return new(mem_ctx) ir_constant(dot(op[0], op[1]));
862 } else if (strcmp(callee, "equal") == 0) {
863 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
864 for (unsigned c = 0; c < op[0]->type->components(); c++) {
865 switch (op[0]->type->base_type) {
866 case GLSL_TYPE_UINT:
867 data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
868 break;
869 case GLSL_TYPE_INT:
870 data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
871 break;
872 case GLSL_TYPE_FLOAT:
873 data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
874 break;
875 default:
876 assert(!"Should not get here.");
877 }
878 }
879 } else if (strcmp(callee, "exp") == 0) {
880 expr = new(mem_ctx) ir_expression(ir_unop_exp, type, op[0], NULL);
881 } else if (strcmp(callee, "exp2") == 0) {
882 expr = new(mem_ctx) ir_expression(ir_unop_exp2, type, op[0], NULL);
883 } else if (strcmp(callee, "faceforward") == 0) {
884 if (dot(op[2], op[1]) < 0)
885 return op[0];
886 for (unsigned c = 0; c < op[0]->type->components(); c++)
887 data.f[c] = -op[0]->value.f[c];
888 } else if (strcmp(callee, "floor") == 0) {
889 expr = new(mem_ctx) ir_expression(ir_unop_floor, type, op[0], NULL);
890 } else if (strcmp(callee, "fract") == 0) {
891 expr = new(mem_ctx) ir_expression(ir_unop_fract, type, op[0], NULL);
892 } else if (strcmp(callee, "fwidth") == 0) {
893 return ir_constant::zero(mem_ctx, this->type);
894 } else if (strcmp(callee, "greaterThan") == 0) {
895 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
896 for (unsigned c = 0; c < op[0]->type->components(); c++) {
897 switch (op[0]->type->base_type) {
898 case GLSL_TYPE_UINT:
899 data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
900 break;
901 case GLSL_TYPE_INT:
902 data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
903 break;
904 case GLSL_TYPE_FLOAT:
905 data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
906 break;
907 default:
908 assert(!"Should not get here.");
909 }
910 }
911 } else if (strcmp(callee, "greaterThanEqual") == 0) {
912 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
913 for (unsigned c = 0; c < op[0]->type->components(); c++) {
914 switch (op[0]->type->base_type) {
915 case GLSL_TYPE_UINT:
916 data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
917 break;
918 case GLSL_TYPE_INT:
919 data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
920 break;
921 case GLSL_TYPE_FLOAT:
922 data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
923 break;
924 default:
925 assert(!"Should not get here.");
926 }
927 }
928 } else if (strcmp(callee, "inversesqrt") == 0) {
929 expr = new(mem_ctx) ir_expression(ir_unop_rsq, type, op[0], NULL);
930 } else if (strcmp(callee, "length") == 0) {
931 return new(mem_ctx) ir_constant(sqrtf(dot(op[0], op[0])));
932 } else if (strcmp(callee, "lessThan") == 0) {
933 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
934 for (unsigned c = 0; c < op[0]->type->components(); c++) {
935 switch (op[0]->type->base_type) {
936 case GLSL_TYPE_UINT:
937 data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
938 break;
939 case GLSL_TYPE_INT:
940 data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
941 break;
942 case GLSL_TYPE_FLOAT:
943 data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
944 break;
945 default:
946 assert(!"Should not get here.");
947 }
948 }
949 } else if (strcmp(callee, "lessThanEqual") == 0) {
950 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
951 for (unsigned c = 0; c < op[0]->type->components(); c++) {
952 switch (op[0]->type->base_type) {
953 case GLSL_TYPE_UINT:
954 data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
955 break;
956 case GLSL_TYPE_INT:
957 data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
958 break;
959 case GLSL_TYPE_FLOAT:
960 data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
961 break;
962 default:
963 assert(!"Should not get here.");
964 }
965 }
966 } else if (strcmp(callee, "log") == 0) {
967 expr = new(mem_ctx) ir_expression(ir_unop_log, type, op[0], NULL);
968 } else if (strcmp(callee, "log2") == 0) {
969 expr = new(mem_ctx) ir_expression(ir_unop_log2, type, op[0], NULL);
970 } else if (strcmp(callee, "matrixCompMult") == 0) {
971 assert(op[0]->type->is_float() && op[1]->type->is_float());
972 for (unsigned c = 0; c < op[0]->type->components(); c++)
973 data.f[c] = op[0]->value.f[c] * op[1]->value.f[c];
974 } else if (strcmp(callee, "max") == 0) {
975 expr = new(mem_ctx) ir_expression(ir_binop_max, type, op[0], op[1]);
976 } else if (strcmp(callee, "min") == 0) {
977 expr = new(mem_ctx) ir_expression(ir_binop_min, type, op[0], op[1]);
978 } else if (strcmp(callee, "mix") == 0) {
979 return NULL; /* FINISHME: implement this */
980 } else if (strcmp(callee, "mod") == 0) {
981 expr = new(mem_ctx) ir_expression(ir_binop_mod, type, op[0], op[1]);
982 } else if (strcmp(callee, "normalize") == 0) {
983 assert(op[0]->type->is_float());
984 float length = sqrtf(dot(op[0], op[0]));
985
986 if (length == 0)
987 return ir_constant::zero(mem_ctx, this->type);
988
989 for (unsigned c = 0; c < op[0]->type->components(); c++)
990 data.f[c] = op[0]->value.f[c] / length;
991 } else if (strcmp(callee, "not") == 0) {
992 expr = new(mem_ctx) ir_expression(ir_unop_logic_not, type, op[0], NULL);
993 } else if (strcmp(callee, "notEqual") == 0) {
994 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
995 for (unsigned c = 0; c < op[0]->type->components(); c++) {
996 switch (op[0]->type->base_type) {
997 case GLSL_TYPE_UINT:
998 data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
999 break;
1000 case GLSL_TYPE_INT:
1001 data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
1002 break;
1003 case GLSL_TYPE_FLOAT:
1004 data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
1005 break;
1006 default:
1007 assert(!"Should not get here.");
1008 }
1009 }
1010 } else if (strcmp(callee, "outerProduct") == 0) {
1011 return NULL; /* FINISHME: implement this */
1012 } else if (strcmp(callee, "pow") == 0) {
1013 expr = new(mem_ctx) ir_expression(ir_binop_pow, type, op[0], op[1]);
1014 } else if (strcmp(callee, "radians") == 0) {
1015 assert(op[0]->type->is_float());
1016 for (unsigned c = 0; c < op[0]->type->components(); c++)
1017 data.f[c] = M_PI/180.0 * op[0]->value.f[c];
1018 } else if (strcmp(callee, "reflect") == 0) {
1019 assert(op[0]->type->is_float());
1020 float dot_NI = dot(op[1], op[0]);
1021 for (unsigned c = 0; c < op[0]->type->components(); c++)
1022 data.f[c] = op[0]->value.f[c] - 2 * dot_NI * op[1]->value.f[c];
1023 } else if (strcmp(callee, "refract") == 0) {
1024 const float eta = op[2]->value.f[0];
1025 const float dot_NI = dot(op[1], op[0]);
1026 const float k = 1.0 - eta * eta * (1.0 - dot_NI * dot_NI);
1027 if (k < 0.0) {
1028 return ir_constant::zero(mem_ctx, this->type);
1029 } else {
1030 for (unsigned c = 0; c < type->components(); c++) {
1031 data.f[c] = eta * op[0]->value.f[c] - (eta * dot_NI + sqrtf(k))
1032 * op[1]->value.f[c];
1033 }
1034 }
1035 } else if (strcmp(callee, "sign") == 0) {
1036 expr = new(mem_ctx) ir_expression(ir_unop_sign, type, op[0], NULL);
1037 } else if (strcmp(callee, "sin") == 0) {
1038 expr = new(mem_ctx) ir_expression(ir_unop_sin, type, op[0], NULL);
1039 } else if (strcmp(callee, "sinh") == 0) {
1040 assert(op[0]->type->is_float());
1041 for (unsigned c = 0; c < op[0]->type->components(); c++)
1042 data.f[c] = sinhf(op[0]->value.f[c]);
1043 } else if (strcmp(callee, "smoothstep") == 0) {
1044 return NULL; /* FINISHME: implement this */
1045 } else if (strcmp(callee, "sqrt") == 0) {
1046 expr = new(mem_ctx) ir_expression(ir_unop_sqrt, type, op[0], NULL);
1047 } else if (strcmp(callee, "step") == 0) {
1048 assert(op[0]->type->is_float() && op[1]->type->is_float());
1049 /* op[0] (edge) may be either a scalar or a vector */
1050 const unsigned c0_inc = op[0]->type->is_scalar() ? 0 : 1;
1051 for (unsigned c = 0, c0 = 0; c < type->components(); c0 += c0_inc, c++)
1052 data.f[c] = (op[1]->value.f[c] < op[0]->value.f[c0]) ? 0.0 : 1.0;
1053 } else if (strcmp(callee, "tan") == 0) {
1054 assert(op[0]->type->is_float());
1055 for (unsigned c = 0; c < op[0]->type->components(); c++)
1056 data.f[c] = tanf(op[0]->value.f[c]);
1057 } else if (strcmp(callee, "tanh") == 0) {
1058 assert(op[0]->type->is_float());
1059 for (unsigned c = 0; c < op[0]->type->components(); c++)
1060 data.f[c] = tanhf(op[0]->value.f[c]);
1061 } else if (strcmp(callee, "transpose") == 0) {
1062 return NULL; /* FINISHME: implement this */
1063 } else {
1064 /* Unsupported builtin - some are not allowed in constant expressions. */
1065 return NULL;
1066 }
1067
1068 if (expr != NULL)
1069 return expr->constant_expression_value();
1070
1071 return new(mem_ctx) ir_constant(this->type, &data);
1072 }