?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ir_to_mesa: Support texture rectangle targets
[mesa/nouveau-pmpeg.git] / src / glsl / ir_constant_expression.cpp
blob0a924246da1d3d224e28978a48b11be9f32fdf91
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 /* The constant_value of a uniform variable is its initializer,
678 * not the lifetime constant value of the uniform.
679 */
680 if (var->mode == ir_var_uniform)
681 return NULL;
682
683 if (!var->constant_value)
684 return NULL;
685
686 return var->constant_value->clone(talloc_parent(var), NULL);
687 }
688
689
690 ir_constant *
691 ir_dereference_array::constant_expression_value()
692 {
693 ir_constant *array = this->array->constant_expression_value();
694 ir_constant *idx = this->array_index->constant_expression_value();
695
696 if ((array != NULL) && (idx != NULL)) {
697 void *ctx = talloc_parent(this);
698 if (array->type->is_matrix()) {
699 /* Array access of a matrix results in a vector.
700 */
701 const unsigned column = idx->value.u[0];
702
703 const glsl_type *const column_type = array->type->column_type();
704
705 /* Offset in the constant matrix to the first element of the column
706 * to be extracted.
707 */
708 const unsigned mat_idx = column * column_type->vector_elements;
709
710 ir_constant_data data;
711
712 switch (column_type->base_type) {
713 case GLSL_TYPE_UINT:
714 case GLSL_TYPE_INT:
715 for (unsigned i = 0; i < column_type->vector_elements; i++)
716 data.u[i] = array->value.u[mat_idx + i];
717
718 break;
719
720 case GLSL_TYPE_FLOAT:
721 for (unsigned i = 0; i < column_type->vector_elements; i++)
722 data.f[i] = array->value.f[mat_idx + i];
723
724 break;
725
726 default:
727 assert(!"Should not get here.");
728 break;
729 }
730
731 return new(ctx) ir_constant(column_type, &data);
732 } else if (array->type->is_vector()) {
733 const unsigned component = idx->value.u[0];
734
735 return new(ctx) ir_constant(array, component);
736 } else {
737 const unsigned index = idx->value.u[0];
738 return array->get_array_element(index)->clone(ctx, NULL);
739 }
740 }
741 return NULL;
742 }
743
744
745 ir_constant *
746 ir_dereference_record::constant_expression_value()
747 {
748 ir_constant *v = this->record->constant_expression_value();
749
750 return (v != NULL) ? v->get_record_field(this->field) : NULL;
751 }
752
753
754 ir_constant *
755 ir_assignment::constant_expression_value()
756 {
757 /* FINISHME: Handle CEs involving assignment (return RHS) */
758 return NULL;
759 }
760
761
762 ir_constant *
763 ir_constant::constant_expression_value()
764 {
765 return this;
766 }
767
768
769 ir_constant *
770 ir_call::constant_expression_value()
771 {
772 if (this->type == glsl_type::error_type)
773 return NULL;
774
775 /* From the GLSL 1.20 spec, page 23:
776 * "Function calls to user-defined functions (non-built-in functions)
777 * cannot be used to form constant expressions."
778 */
779 if (!this->callee->is_built_in)
780 return NULL;
781
782 unsigned num_parameters = 0;
783
784 /* Check if all parameters are constant */
785 ir_constant *op[3];
786 foreach_list(n, &this->actual_parameters) {
787 ir_constant *constant = ((ir_rvalue *) n)->constant_expression_value();
788 if (constant == NULL)
789 return NULL;
790
791 op[num_parameters] = constant;
792
793 assert(num_parameters < 3);
794 num_parameters++;
795 }
796
797 /* Individual cases below can either:
798 * - Assign "expr" a new ir_expression to evaluate (for basic opcodes)
799 * - Fill "data" with appopriate constant data
800 * - Return an ir_constant directly.
801 */
802 void *mem_ctx = talloc_parent(this);
803 ir_expression *expr = NULL;
804
805 ir_constant_data data;
806 memset(&data, 0, sizeof(data));
807
808 const char *callee = this->callee_name();
809 if (strcmp(callee, "abs") == 0) {
810 expr = new(mem_ctx) ir_expression(ir_unop_abs, type, op[0], NULL);
811 } else if (strcmp(callee, "all") == 0) {
812 assert(op[0]->type->is_boolean());
813 for (unsigned c = 0; c < op[0]->type->components(); c++) {
814 if (!op[0]->value.b[c])
815 return new(mem_ctx) ir_constant(false);
816 }
817 return new(mem_ctx) ir_constant(true);
818 } else if (strcmp(callee, "any") == 0) {
819 assert(op[0]->type->is_boolean());
820 for (unsigned c = 0; c < op[0]->type->components(); c++) {
821 if (op[0]->value.b[c])
822 return new(mem_ctx) ir_constant(true);
823 }
824 return new(mem_ctx) ir_constant(false);
825 } else if (strcmp(callee, "acos") == 0) {
826 assert(op[0]->type->is_float());
827 for (unsigned c = 0; c < op[0]->type->components(); c++)
828 data.f[c] = acosf(op[0]->value.f[c]);
829 } else if (strcmp(callee, "asin") == 0) {
830 assert(op[0]->type->is_float());
831 for (unsigned c = 0; c < op[0]->type->components(); c++)
832 data.f[c] = asinf(op[0]->value.f[c]);
833 } else if (strcmp(callee, "atan") == 0) {
834 assert(op[0]->type->is_float());
835 if (num_parameters == 2) {
836 assert(op[1]->type->is_float());
837 for (unsigned c = 0; c < op[0]->type->components(); c++)
838 data.f[c] = atan2f(op[0]->value.f[c], op[1]->value.f[c]);
839 } else {
840 for (unsigned c = 0; c < op[0]->type->components(); c++)
841 data.f[c] = atanf(op[0]->value.f[c]);
842 }
843 } else if (strcmp(callee, "dFdx") == 0 || strcmp(callee, "dFdy") == 0) {
844 return ir_constant::zero(mem_ctx, this->type);
845 } else if (strcmp(callee, "ceil") == 0) {
846 expr = new(mem_ctx) ir_expression(ir_unop_ceil, type, op[0], NULL);
847 } else if (strcmp(callee, "clamp") == 0) {
848 assert(num_parameters == 3);
849 unsigned c1_inc = op[1]->type->is_scalar() ? 0 : 1;
850 unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
851 for (unsigned c = 0, c1 = 0, c2 = 0;
852 c < op[0]->type->components();
853 c1 += c1_inc, c2 += c2_inc, c++) {
854
855 switch (op[0]->type->base_type) {
856 case GLSL_TYPE_UINT:
857 data.u[c] = CLAMP(op[0]->value.u[c], op[1]->value.u[c1],
858 op[2]->value.u[c2]);
859 break;
860 case GLSL_TYPE_INT:
861 data.i[c] = CLAMP(op[0]->value.i[c], op[1]->value.i[c1],
862 op[2]->value.i[c2]);
863 break;
864 case GLSL_TYPE_FLOAT:
865 data.f[c] = CLAMP(op[0]->value.f[c], op[1]->value.f[c1],
866 op[2]->value.f[c2]);
867 break;
868 default:
869 assert(!"Should not get here.");
870 }
871 }
872 } else if (strcmp(callee, "cos") == 0) {
873 expr = new(mem_ctx) ir_expression(ir_unop_cos, type, op[0], NULL);
874 } else if (strcmp(callee, "cosh") == 0) {
875 assert(op[0]->type->is_float());
876 for (unsigned c = 0; c < op[0]->type->components(); c++)
877 data.f[c] = coshf(op[0]->value.f[c]);
878 } else if (strcmp(callee, "cross") == 0) {
879 expr = new(mem_ctx) ir_expression(ir_binop_cross, type, op[0], op[1]);
880 } else if (strcmp(callee, "degrees") == 0) {
881 assert(op[0]->type->is_float());
882 for (unsigned c = 0; c < op[0]->type->components(); c++)
883 data.f[c] = 180.0/M_PI * op[0]->value.f[c];
884 } else if (strcmp(callee, "distance") == 0) {
885 assert(op[0]->type->is_float() && op[1]->type->is_float());
886 float length_squared = 0.0;
887 for (unsigned c = 0; c < op[0]->type->components(); c++) {
888 float t = op[0]->value.f[c] - op[1]->value.f[c];
889 length_squared += t * t;
890 }
891 return new(mem_ctx) ir_constant(sqrtf(length_squared));
892 } else if (strcmp(callee, "dot") == 0) {
893 return new(mem_ctx) ir_constant(dot(op[0], op[1]));
894 } else if (strcmp(callee, "equal") == 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, "exp") == 0) {
912 expr = new(mem_ctx) ir_expression(ir_unop_exp, type, op[0], NULL);
913 } else if (strcmp(callee, "exp2") == 0) {
914 expr = new(mem_ctx) ir_expression(ir_unop_exp2, type, op[0], NULL);
915 } else if (strcmp(callee, "faceforward") == 0) {
916 if (dot(op[2], op[1]) < 0)
917 return op[0];
918 for (unsigned c = 0; c < op[0]->type->components(); c++)
919 data.f[c] = -op[0]->value.f[c];
920 } else if (strcmp(callee, "floor") == 0) {
921 expr = new(mem_ctx) ir_expression(ir_unop_floor, type, op[0], NULL);
922 } else if (strcmp(callee, "fract") == 0) {
923 expr = new(mem_ctx) ir_expression(ir_unop_fract, type, op[0], NULL);
924 } else if (strcmp(callee, "fwidth") == 0) {
925 return ir_constant::zero(mem_ctx, this->type);
926 } else if (strcmp(callee, "greaterThan") == 0) {
927 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
928 for (unsigned c = 0; c < op[0]->type->components(); c++) {
929 switch (op[0]->type->base_type) {
930 case GLSL_TYPE_UINT:
931 data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
932 break;
933 case GLSL_TYPE_INT:
934 data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
935 break;
936 case GLSL_TYPE_FLOAT:
937 data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
938 break;
939 default:
940 assert(!"Should not get here.");
941 }
942 }
943 } else if (strcmp(callee, "greaterThanEqual") == 0) {
944 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
945 for (unsigned c = 0; c < op[0]->type->components(); c++) {
946 switch (op[0]->type->base_type) {
947 case GLSL_TYPE_UINT:
948 data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
949 break;
950 case GLSL_TYPE_INT:
951 data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
952 break;
953 case GLSL_TYPE_FLOAT:
954 data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
955 break;
956 default:
957 assert(!"Should not get here.");
958 }
959 }
960 } else if (strcmp(callee, "inversesqrt") == 0) {
961 expr = new(mem_ctx) ir_expression(ir_unop_rsq, type, op[0], NULL);
962 } else if (strcmp(callee, "length") == 0) {
963 return new(mem_ctx) ir_constant(sqrtf(dot(op[0], op[0])));
964 } else if (strcmp(callee, "lessThan") == 0) {
965 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
966 for (unsigned c = 0; c < op[0]->type->components(); c++) {
967 switch (op[0]->type->base_type) {
968 case GLSL_TYPE_UINT:
969 data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
970 break;
971 case GLSL_TYPE_INT:
972 data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
973 break;
974 case GLSL_TYPE_FLOAT:
975 data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
976 break;
977 default:
978 assert(!"Should not get here.");
979 }
980 }
981 } else if (strcmp(callee, "lessThanEqual") == 0) {
982 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
983 for (unsigned c = 0; c < op[0]->type->components(); c++) {
984 switch (op[0]->type->base_type) {
985 case GLSL_TYPE_UINT:
986 data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
987 break;
988 case GLSL_TYPE_INT:
989 data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
990 break;
991 case GLSL_TYPE_FLOAT:
992 data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
993 break;
994 default:
995 assert(!"Should not get here.");
996 }
997 }
998 } else if (strcmp(callee, "log") == 0) {
999 expr = new(mem_ctx) ir_expression(ir_unop_log, type, op[0], NULL);
1000 } else if (strcmp(callee, "log2") == 0) {
1001 expr = new(mem_ctx) ir_expression(ir_unop_log2, type, op[0], NULL);
1002 } else if (strcmp(callee, "matrixCompMult") == 0) {
1003 assert(op[0]->type->is_float() && op[1]->type->is_float());
1004 for (unsigned c = 0; c < op[0]->type->components(); c++)
1005 data.f[c] = op[0]->value.f[c] * op[1]->value.f[c];
1006 } else if (strcmp(callee, "max") == 0) {
1007 expr = new(mem_ctx) ir_expression(ir_binop_max, type, op[0], op[1]);
1008 } else if (strcmp(callee, "min") == 0) {
1009 expr = new(mem_ctx) ir_expression(ir_binop_min, type, op[0], op[1]);
1010 } else if (strcmp(callee, "mix") == 0) {
1011 assert(op[0]->type->is_float() && op[1]->type->is_float());
1012 if (op[2]->type->is_float()) {
1013 unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
1014 unsigned components = op[0]->type->components();
1015 for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
1016 data.f[c] = op[0]->value.f[c] * (1 - op[2]->value.f[c2]) +
1017 op[1]->value.f[c] * op[2]->value.f[c2];
1018 }
1019 } else {
1020 assert(op[2]->type->is_boolean());
1021 for (unsigned c = 0; c < op[0]->type->components(); c++)
1022 data.f[c] = op[op[2]->value.b[c] ? 1 : 0]->value.f[c];
1023 }
1024 } else if (strcmp(callee, "mod") == 0) {
1025 expr = new(mem_ctx) ir_expression(ir_binop_mod, type, op[0], op[1]);
1026 } else if (strcmp(callee, "normalize") == 0) {
1027 assert(op[0]->type->is_float());
1028 float length = sqrtf(dot(op[0], op[0]));
1029
1030 if (length == 0)
1031 return ir_constant::zero(mem_ctx, this->type);
1032
1033 for (unsigned c = 0; c < op[0]->type->components(); c++)
1034 data.f[c] = op[0]->value.f[c] / length;
1035 } else if (strcmp(callee, "not") == 0) {
1036 expr = new(mem_ctx) ir_expression(ir_unop_logic_not, type, op[0], NULL);
1037 } else if (strcmp(callee, "notEqual") == 0) {
1038 assert(op[0]->type->is_vector() && op[1] && op[1]->type->is_vector());
1039 for (unsigned c = 0; c < op[0]->type->components(); c++) {
1040 switch (op[0]->type->base_type) {
1041 case GLSL_TYPE_UINT:
1042 data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
1043 break;
1044 case GLSL_TYPE_INT:
1045 data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
1046 break;
1047 case GLSL_TYPE_FLOAT:
1048 data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
1049 break;
1050 default:
1051 assert(!"Should not get here.");
1052 }
1053 }
1054 } else if (strcmp(callee, "outerProduct") == 0) {
1055 assert(op[0]->type->is_vector() && op[1]->type->is_vector());
1056 const unsigned m = op[0]->type->vector_elements;
1057 const unsigned n = op[1]->type->vector_elements;
1058 for (unsigned j = 0; j < n; j++) {
1059 for (unsigned i = 0; i < m; i++) {
1060 data.f[i+m*j] = op[0]->value.f[i] * op[1]->value.f[j];
1061 }
1062 }
1063 } else if (strcmp(callee, "pow") == 0) {
1064 expr = new(mem_ctx) ir_expression(ir_binop_pow, type, op[0], op[1]);
1065 } else if (strcmp(callee, "radians") == 0) {
1066 assert(op[0]->type->is_float());
1067 for (unsigned c = 0; c < op[0]->type->components(); c++)
1068 data.f[c] = M_PI/180.0 * op[0]->value.f[c];
1069 } else if (strcmp(callee, "reflect") == 0) {
1070 assert(op[0]->type->is_float());
1071 float dot_NI = dot(op[1], op[0]);
1072 for (unsigned c = 0; c < op[0]->type->components(); c++)
1073 data.f[c] = op[0]->value.f[c] - 2 * dot_NI * op[1]->value.f[c];
1074 } else if (strcmp(callee, "refract") == 0) {
1075 const float eta = op[2]->value.f[0];
1076 const float dot_NI = dot(op[1], op[0]);
1077 const float k = 1.0 - eta * eta * (1.0 - dot_NI * dot_NI);
1078 if (k < 0.0) {
1079 return ir_constant::zero(mem_ctx, this->type);
1080 } else {
1081 for (unsigned c = 0; c < type->components(); c++) {
1082 data.f[c] = eta * op[0]->value.f[c] - (eta * dot_NI + sqrtf(k))
1083 * op[1]->value.f[c];
1084 }
1085 }
1086 } else if (strcmp(callee, "sign") == 0) {
1087 expr = new(mem_ctx) ir_expression(ir_unop_sign, type, op[0], NULL);
1088 } else if (strcmp(callee, "sin") == 0) {
1089 expr = new(mem_ctx) ir_expression(ir_unop_sin, type, op[0], NULL);
1090 } else if (strcmp(callee, "sinh") == 0) {
1091 assert(op[0]->type->is_float());
1092 for (unsigned c = 0; c < op[0]->type->components(); c++)
1093 data.f[c] = sinhf(op[0]->value.f[c]);
1094 } else if (strcmp(callee, "smoothstep") == 0) {
1095 assert(num_parameters == 3);
1096 assert(op[1]->type == op[0]->type);
1097 unsigned edge_inc = op[0]->type->is_scalar() ? 0 : 1;
1098 for (unsigned c = 0, e = 0; c < type->components(); e += edge_inc, c++) {
1099 const float edge0 = op[0]->value.f[e];
1100 const float edge1 = op[1]->value.f[e];
1101 if (edge0 == edge1) {
1102 data.f[c] = 0.0; /* Avoid a crash - results are undefined anyway */
1103 } else {
1104 const float numerator = op[2]->value.f[c] - edge0;
1105 const float denominator = edge1 - edge0;
1106 const float t = CLAMP(numerator/denominator, 0, 1);
1107 data.f[c] = t * t * (3 - 2 * t);
1108 }
1109 }
1110 } else if (strcmp(callee, "sqrt") == 0) {
1111 expr = new(mem_ctx) ir_expression(ir_unop_sqrt, type, op[0], NULL);
1112 } else if (strcmp(callee, "step") == 0) {
1113 assert(op[0]->type->is_float() && op[1]->type->is_float());
1114 /* op[0] (edge) may be either a scalar or a vector */
1115 const unsigned c0_inc = op[0]->type->is_scalar() ? 0 : 1;
1116 for (unsigned c = 0, c0 = 0; c < type->components(); c0 += c0_inc, c++)
1117 data.f[c] = (op[1]->value.f[c] < op[0]->value.f[c0]) ? 0.0 : 1.0;
1118 } else if (strcmp(callee, "tan") == 0) {
1119 assert(op[0]->type->is_float());
1120 for (unsigned c = 0; c < op[0]->type->components(); c++)
1121 data.f[c] = tanf(op[0]->value.f[c]);
1122 } else if (strcmp(callee, "tanh") == 0) {
1123 assert(op[0]->type->is_float());
1124 for (unsigned c = 0; c < op[0]->type->components(); c++)
1125 data.f[c] = tanhf(op[0]->value.f[c]);
1126 } else if (strcmp(callee, "transpose") == 0) {
1127 assert(op[0]->type->is_matrix());
1128 const unsigned n = op[0]->type->vector_elements;
1129 const unsigned m = op[0]->type->matrix_columns;
1130 for (unsigned j = 0; j < m; j++) {
1131 for (unsigned i = 0; i < n; i++) {
1132 data.f[m*i+j] += op[0]->value.f[i+n*j];
1133 }
1134 }
1135 } else {
1136 /* Unsupported builtin - some are not allowed in constant expressions. */
1137 return NULL;
1138 }
1139
1140 if (expr != NULL)
1141 return expr->constant_expression_value();
1142
1143 return new(mem_ctx) ir_constant(this->type, &data);
1144 }