2
* Copyright © 2010 Intel Corporation
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:
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
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.
24
#include "main/core.h" /* for MAX2 */
26
#include "ir_visitor.h"
27
#include "glsl_types.h"
29
ir_rvalue::ir_rvalue()
31
this->type = glsl_type::error_type;
35
* Modify the swizzle make to move one component to another
37
* \param m IR swizzle to be modified
38
* \param from Component in the RHS that is to be swizzled
39
* \param to Desired swizzle location of \c from
42
update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to)
45
case 0: m.x = from; break;
46
case 1: m.y = from; break;
47
case 2: m.z = from; break;
48
case 3: m.w = from; break;
49
default: assert(!"Should not get here.");
52
m.num_components = MAX2(m.num_components, (to + 1));
56
ir_assignment::set_lhs(ir_rvalue *lhs)
59
ir_swizzle *swiz = lhs->as_swizzle();
64
unsigned write_mask = 0;
65
ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
67
for (unsigned i = 0; i < swiz->mask.num_components; i++) {
71
case 0: c = swiz->mask.x; break;
72
case 1: c = swiz->mask.y; break;
73
case 2: c = swiz->mask.z; break;
74
case 3: c = swiz->mask.w; break;
75
default: assert(!"Should not get here.");
78
write_mask |= (((this->write_mask >> i) & 1) << c);
79
update_rhs_swizzle(rhs_swiz, i, c);
82
this->write_mask = write_mask;
85
this->rhs = new(this) ir_swizzle(this->rhs, rhs_swiz);
88
assert((lhs == NULL) || lhs->as_dereference());
90
this->lhs = (ir_dereference *) lhs;
94
ir_assignment::whole_variable_written()
96
ir_variable *v = this->lhs->whole_variable_referenced();
101
if (v->type->is_scalar())
104
if (v->type->is_vector()) {
105
const unsigned mask = (1U << v->type->vector_elements) - 1;
107
if (mask != this->write_mask)
111
/* Either all the vector components are assigned or the variable is some
112
* composite type (and the whole thing is assigned.
117
ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs,
118
ir_rvalue *condition, unsigned write_mask)
120
this->ir_type = ir_type_assignment;
121
this->condition = condition;
124
this->write_mask = write_mask;
127
ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
128
ir_rvalue *condition)
130
this->ir_type = ir_type_assignment;
131
this->condition = condition;
134
/* If the RHS is a vector type, assume that all components of the vector
135
* type are being written to the LHS. The write mask comes from the RHS
136
* because we can have a case where the LHS is a vec4 and the RHS is a
137
* vec3. In that case, the assignment is:
139
* (assign (...) (xyz) (var_ref lhs) (var_ref rhs))
141
if (rhs->type->is_vector())
142
this->write_mask = (1U << rhs->type->vector_elements) - 1;
143
else if (rhs->type->is_scalar())
144
this->write_mask = 1;
146
this->write_mask = 0;
152
ir_expression::ir_expression(int op, const struct glsl_type *type,
153
ir_rvalue *op0, ir_rvalue *op1)
155
this->ir_type = ir_type_expression;
157
this->operation = ir_expression_operation(op);
158
this->operands[0] = op0;
159
this->operands[1] = op1;
163
ir_expression::get_num_operands(ir_expression_operation op)
165
/* Update ir_print_visitor.cpp when updating this list. */
166
const int num_operands[] = {
167
1, /* ir_unop_bit_not */
168
1, /* ir_unop_logic_not */
171
1, /* ir_unop_sign */
174
1, /* ir_unop_sqrt */
177
1, /* ir_unop_exp2 */
178
1, /* ir_unop_log2 */
188
1, /* ir_unop_trunc */
189
1, /* ir_unop_ceil */
190
1, /* ir_unop_floor */
191
1, /* ir_unop_fract */
196
1, /* ir_unop_dFdx */
197
1, /* ir_unop_dFdy */
199
2, /* ir_binop_add */
200
2, /* ir_binop_sub */
201
2, /* ir_binop_mul */
202
2, /* ir_binop_div */
203
2, /* ir_binop_mod */
205
2, /* ir_binop_less */
206
2, /* ir_binop_greater */
207
2, /* ir_binop_lequal */
208
2, /* ir_binop_gequal */
209
2, /* ir_binop_equal */
210
2, /* ir_binop_nequal */
212
2, /* ir_binop_lshift */
213
2, /* ir_binop_rshift */
214
2, /* ir_binop_bit_and */
215
2, /* ir_binop_bit_xor */
216
2, /* ir_binop_bit_or */
218
2, /* ir_binop_logic_and */
219
2, /* ir_binop_logic_xor */
220
2, /* ir_binop_logic_or */
222
2, /* ir_binop_dot */
223
2, /* ir_binop_cross */
224
2, /* ir_binop_min */
225
2, /* ir_binop_max */
227
2, /* ir_binop_pow */
230
assert(sizeof(num_operands) / sizeof(num_operands[0]) == ir_binop_pow + 1);
232
return num_operands[op];
235
static const char *const operator_strs[] = {
290
const char *ir_expression::operator_string(ir_expression_operation op)
292
assert((unsigned int) op < Elements(operator_strs));
293
return operator_strs[op];
296
const char *ir_expression::operator_string()
298
return operator_string(this->operation);
301
ir_expression_operation
302
ir_expression::get_operator(const char *str)
304
const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
305
for (int op = 0; op < operator_count; op++) {
306
if (strcmp(str, operator_strs[op]) == 0)
307
return (ir_expression_operation) op;
309
return (ir_expression_operation) -1;
312
ir_constant::ir_constant()
314
this->ir_type = ir_type_constant;
317
ir_constant::ir_constant(const struct glsl_type *type,
318
const ir_constant_data *data)
320
assert((type->base_type >= GLSL_TYPE_UINT)
321
&& (type->base_type <= GLSL_TYPE_BOOL));
323
this->ir_type = ir_type_constant;
325
memcpy(& this->value, data, sizeof(this->value));
328
ir_constant::ir_constant(float f)
330
this->ir_type = ir_type_constant;
331
this->type = glsl_type::float_type;
332
this->value.f[0] = f;
333
for (int i = 1; i < 16; i++) {
334
this->value.f[i] = 0;
338
ir_constant::ir_constant(unsigned int u)
340
this->ir_type = ir_type_constant;
341
this->type = glsl_type::uint_type;
342
this->value.u[0] = u;
343
for (int i = 1; i < 16; i++) {
344
this->value.u[i] = 0;
348
ir_constant::ir_constant(int i)
350
this->ir_type = ir_type_constant;
351
this->type = glsl_type::int_type;
352
this->value.i[0] = i;
353
for (int i = 1; i < 16; i++) {
354
this->value.i[i] = 0;
358
ir_constant::ir_constant(bool b)
360
this->ir_type = ir_type_constant;
361
this->type = glsl_type::bool_type;
362
this->value.b[0] = b;
363
for (int i = 1; i < 16; i++) {
364
this->value.b[i] = false;
368
ir_constant::ir_constant(const ir_constant *c, unsigned i)
370
this->ir_type = ir_type_constant;
371
this->type = c->type->get_base_type();
373
switch (this->type->base_type) {
374
case GLSL_TYPE_UINT: this->value.u[0] = c->value.u[i]; break;
375
case GLSL_TYPE_INT: this->value.i[0] = c->value.i[i]; break;
376
case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
377
case GLSL_TYPE_BOOL: this->value.b[0] = c->value.b[i]; break;
378
default: assert(!"Should not get here."); break;
382
ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
384
this->ir_type = ir_type_constant;
387
assert(type->is_scalar() || type->is_vector() || type->is_matrix()
388
|| type->is_record() || type->is_array());
390
if (type->is_array()) {
391
this->array_elements = talloc_array(this, ir_constant *, type->length);
393
foreach_list(node, value_list) {
394
ir_constant *value = (ir_constant *) node;
395
assert(value->as_constant() != NULL);
397
this->array_elements[i++] = value;
402
/* If the constant is a record, the types of each of the entries in
403
* value_list must be a 1-for-1 match with the structure components. Each
404
* entry must also be a constant. Just move the nodes from the value_list
405
* to the list in the ir_constant.
407
/* FINISHME: Should there be some type checking and / or assertions here? */
408
/* FINISHME: Should the new constant take ownership of the nodes from
409
* FINISHME: value_list, or should it make copies?
411
if (type->is_record()) {
412
value_list->move_nodes_to(& this->components);
416
for (unsigned i = 0; i < 16; i++) {
417
this->value.u[i] = 0;
420
ir_constant *value = (ir_constant *) (value_list->head);
422
/* Constructors with exactly one scalar argument are special for vectors
423
* and matrices. For vectors, the scalar value is replicated to fill all
424
* the components. For matrices, the scalar fills the components of the
425
* diagonal while the rest is filled with 0.
427
if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
428
if (type->is_matrix()) {
429
/* Matrix - fill diagonal (rest is already set to 0) */
430
assert(type->base_type == GLSL_TYPE_FLOAT);
431
for (unsigned i = 0; i < type->matrix_columns; i++)
432
this->value.f[i * type->vector_elements + i] = value->value.f[0];
434
/* Vector or scalar - fill all components */
435
switch (type->base_type) {
438
for (unsigned i = 0; i < type->components(); i++)
439
this->value.u[i] = value->value.u[0];
441
case GLSL_TYPE_FLOAT:
442
for (unsigned i = 0; i < type->components(); i++)
443
this->value.f[i] = value->value.f[0];
446
for (unsigned i = 0; i < type->components(); i++)
447
this->value.b[i] = value->value.b[0];
450
assert(!"Should not get here.");
457
if (type->is_matrix() && value->type->is_matrix()) {
458
assert(value->next->is_tail_sentinel());
460
/* From section 5.4.2 of the GLSL 1.20 spec:
461
* "If a matrix is constructed from a matrix, then each component
462
* (column i, row j) in the result that has a corresponding component
463
* (column i, row j) in the argument will be initialized from there."
465
unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
466
unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
467
for (unsigned i = 0; i < cols; i++) {
468
for (unsigned j = 0; j < rows; j++) {
469
const unsigned src = i * value->type->vector_elements + j;
470
const unsigned dst = i * type->vector_elements + j;
471
this->value.f[dst] = value->value.f[src];
475
/* "All other components will be initialized to the identity matrix." */
476
for (unsigned i = cols; i < type->matrix_columns; i++)
477
this->value.f[i * type->vector_elements + i] = 1.0;
482
/* Use each component from each entry in the value_list to initialize one
483
* component of the constant being constructed.
485
for (unsigned i = 0; i < type->components(); /* empty */) {
486
assert(value->as_constant() != NULL);
487
assert(!value->is_tail_sentinel());
489
for (unsigned j = 0; j < value->type->components(); j++) {
490
switch (type->base_type) {
492
this->value.u[i] = value->get_uint_component(j);
495
this->value.i[i] = value->get_int_component(j);
497
case GLSL_TYPE_FLOAT:
498
this->value.f[i] = value->get_float_component(j);
501
this->value.b[i] = value->get_bool_component(j);
504
/* FINISHME: What to do? Exceptions are not the answer.
510
if (i >= type->components())
514
value = (ir_constant *) value->next;
519
ir_constant::zero(void *mem_ctx, const glsl_type *type)
521
assert(type->is_numeric() || type->is_boolean());
523
ir_constant *c = new(mem_ctx) ir_constant;
525
memset(&c->value, 0, sizeof(c->value));
531
ir_constant::get_bool_component(unsigned i) const
533
switch (this->type->base_type) {
534
case GLSL_TYPE_UINT: return this->value.u[i] != 0;
535
case GLSL_TYPE_INT: return this->value.i[i] != 0;
536
case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
537
case GLSL_TYPE_BOOL: return this->value.b[i];
538
default: assert(!"Should not get here."); break;
541
/* Must return something to make the compiler happy. This is clearly an
548
ir_constant::get_float_component(unsigned i) const
550
switch (this->type->base_type) {
551
case GLSL_TYPE_UINT: return (float) this->value.u[i];
552
case GLSL_TYPE_INT: return (float) this->value.i[i];
553
case GLSL_TYPE_FLOAT: return this->value.f[i];
554
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0;
555
default: assert(!"Should not get here."); break;
558
/* Must return something to make the compiler happy. This is clearly an
565
ir_constant::get_int_component(unsigned i) const
567
switch (this->type->base_type) {
568
case GLSL_TYPE_UINT: return this->value.u[i];
569
case GLSL_TYPE_INT: return this->value.i[i];
570
case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
571
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
572
default: assert(!"Should not get here."); break;
575
/* Must return something to make the compiler happy. This is clearly an
582
ir_constant::get_uint_component(unsigned i) const
584
switch (this->type->base_type) {
585
case GLSL_TYPE_UINT: return this->value.u[i];
586
case GLSL_TYPE_INT: return this->value.i[i];
587
case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
588
case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0;
589
default: assert(!"Should not get here."); break;
592
/* Must return something to make the compiler happy. This is clearly an
599
ir_constant::get_array_element(unsigned i) const
601
assert(this->type->is_array());
603
/* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
605
* "Behavior is undefined if a shader subscripts an array with an index
606
* less than 0 or greater than or equal to the size the array was
609
* Most out-of-bounds accesses are removed before things could get this far.
610
* There are cases where non-constant array index values can get constant
615
else if (i >= this->type->length)
616
i = this->type->length - 1;
618
return array_elements[i];
622
ir_constant::get_record_field(const char *name)
624
int idx = this->type->field_index(name);
629
if (this->components.is_empty())
632
exec_node *node = this->components.head;
633
for (int i = 0; i < idx; i++) {
636
/* If the end of the list is encountered before the element matching the
637
* requested field is found, return NULL.
639
if (node->is_tail_sentinel())
643
return (ir_constant *) node;
648
ir_constant::has_value(const ir_constant *c) const
650
if (this->type != c->type)
653
if (this->type->is_array()) {
654
for (unsigned i = 0; i < this->type->length; i++) {
655
if (this->array_elements[i]->has_value(c->array_elements[i]))
661
if (this->type->base_type == GLSL_TYPE_STRUCT) {
662
const exec_node *a_node = this->components.head;
663
const exec_node *b_node = c->components.head;
665
while (!a_node->is_tail_sentinel()) {
666
assert(!b_node->is_tail_sentinel());
668
const ir_constant *const a_field = (ir_constant *) a_node;
669
const ir_constant *const b_field = (ir_constant *) b_node;
671
if (!a_field->has_value(b_field))
674
a_node = a_node->next;
675
b_node = b_node->next;
681
for (unsigned i = 0; i < this->type->components(); i++) {
682
switch (this->type->base_type) {
684
if (this->value.u[i] != c->value.u[i])
688
if (this->value.i[i] != c->value.i[i])
691
case GLSL_TYPE_FLOAT:
692
if (this->value.f[i] != c->value.f[i])
696
if (this->value.b[i] != c->value.b[i])
700
assert(!"Should not get here.");
711
this->ir_type = ir_type_loop;
712
this->cmp = ir_unop_neg;
715
this->increment = NULL;
716
this->counter = NULL;
720
ir_dereference_variable::ir_dereference_variable(ir_variable *var)
722
this->ir_type = ir_type_dereference_variable;
724
this->type = (var != NULL) ? var->type : glsl_type::error_type;
728
ir_dereference_array::ir_dereference_array(ir_rvalue *value,
729
ir_rvalue *array_index)
731
this->ir_type = ir_type_dereference_array;
732
this->array_index = array_index;
733
this->set_array(value);
737
ir_dereference_array::ir_dereference_array(ir_variable *var,
738
ir_rvalue *array_index)
740
void *ctx = talloc_parent(var);
742
this->ir_type = ir_type_dereference_array;
743
this->array_index = array_index;
744
this->set_array(new(ctx) ir_dereference_variable(var));
749
ir_dereference_array::set_array(ir_rvalue *value)
752
this->type = glsl_type::error_type;
754
if (this->array != NULL) {
755
const glsl_type *const vt = this->array->type;
757
if (vt->is_array()) {
758
type = vt->element_type();
759
} else if (vt->is_matrix()) {
760
type = vt->column_type();
761
} else if (vt->is_vector()) {
762
type = vt->get_base_type();
768
ir_dereference_record::ir_dereference_record(ir_rvalue *value,
771
this->ir_type = ir_type_dereference_record;
772
this->record = value;
773
this->field = talloc_strdup(this, field);
774
this->type = (this->record != NULL)
775
? this->record->type->field_type(field) : glsl_type::error_type;
779
ir_dereference_record::ir_dereference_record(ir_variable *var,
782
void *ctx = talloc_parent(var);
784
this->ir_type = ir_type_dereference_record;
785
this->record = new(ctx) ir_dereference_variable(var);
786
this->field = talloc_strdup(this, field);
787
this->type = (this->record != NULL)
788
? this->record->type->field_type(field) : glsl_type::error_type;
791
bool type_contains_sampler(const glsl_type *type)
793
if (type->is_array()) {
794
return type_contains_sampler(type->fields.array);
795
} else if (type->is_record()) {
796
for (unsigned int i = 0; i < type->length; i++) {
797
if (type_contains_sampler(type->fields.structure[i].type))
802
return type->is_sampler();
807
ir_dereference::is_lvalue()
809
ir_variable *var = this->variable_referenced();
811
/* Every l-value derference chain eventually ends in a variable.
813
if ((var == NULL) || var->read_only)
816
if (this->type->is_array() && !var->array_lvalue)
819
/* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
821
* "Samplers cannot be treated as l-values; hence cannot be used
822
* as out or inout function parameters, nor can they be
825
if (type_contains_sampler(this->type))
832
const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf" };
834
const char *ir_texture::opcode_string()
836
assert((unsigned int) op <=
837
sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
838
return tex_opcode_strs[op];
842
ir_texture::get_opcode(const char *str)
844
const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
845
for (int op = 0; op < count; op++) {
846
if (strcmp(str, tex_opcode_strs[op]) == 0)
847
return (ir_texture_opcode) op;
849
return (ir_texture_opcode) -1;
854
ir_texture::set_sampler(ir_dereference *sampler)
856
assert(sampler != NULL);
857
this->sampler = sampler;
859
switch (sampler->type->sampler_type) {
860
case GLSL_TYPE_FLOAT:
861
this->type = glsl_type::vec4_type;
864
this->type = glsl_type::ivec4_type;
867
this->type = glsl_type::uvec4_type;
874
ir_swizzle::init_mask(const unsigned *comp, unsigned count)
876
assert((count >= 1) && (count <= 4));
878
memset(&this->mask, 0, sizeof(this->mask));
879
this->mask.num_components = count;
881
unsigned dup_mask = 0;
884
assert(comp[3] <= 3);
885
dup_mask |= (1U << comp[3])
886
& ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
887
this->mask.w = comp[3];
890
assert(comp[2] <= 3);
891
dup_mask |= (1U << comp[2])
892
& ((1U << comp[0]) | (1U << comp[1]));
893
this->mask.z = comp[2];
896
assert(comp[1] <= 3);
897
dup_mask |= (1U << comp[1])
899
this->mask.y = comp[1];
902
assert(comp[0] <= 3);
903
this->mask.x = comp[0];
906
this->mask.has_duplicates = dup_mask != 0;
908
/* Based on the number of elements in the swizzle and the base type
909
* (i.e., float, int, unsigned, or bool) of the vector being swizzled,
910
* generate the type of the resulting value.
912
type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
915
ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
916
unsigned w, unsigned count)
919
const unsigned components[4] = { x, y, z, w };
920
this->ir_type = ir_type_swizzle;
921
this->init_mask(components, count);
924
ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
928
this->ir_type = ir_type_swizzle;
929
this->init_mask(comp, count);
932
ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
934
this->ir_type = ir_type_swizzle;
937
this->type = glsl_type::get_instance(val->type->base_type,
938
mask.num_components, 1);
947
ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
949
void *ctx = talloc_parent(val);
951
/* For each possible swizzle character, this table encodes the value in
952
* \c idx_map that represents the 0th element of the vector. For invalid
953
* swizzle characters (e.g., 'k'), a special value is used that will allow
954
* detection of errors.
956
static const unsigned char base_idx[26] = {
957
/* a b c d e f g h i j k l m */
958
R, R, I, I, I, I, R, I, I, I, I, I, I,
959
/* n o p q r s t u v w x y z */
960
I, I, S, S, R, S, S, I, I, X, X, X, X
963
/* Each valid swizzle character has an entry in the previous table. This
964
* table encodes the base index encoded in the previous table plus the actual
965
* index of the swizzle character. When processing swizzles, the first
966
* character in the string is indexed in the previous table. Each character
967
* in the string is indexed in this table, and the value found there has the
968
* value form the first table subtracted. The result must be on the range
971
* For example, the string "wzyx" will get X from the first table. Each of
972
* the charcaters will get X+3, X+2, X+1, and X+0 from this table. After
973
* subtraction, the swizzle values are { 3, 2, 1, 0 }.
975
* The string "wzrg" will get X from the first table. Each of the characters
976
* will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the
977
* swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range
978
* [0,3], the error is detected.
980
static const unsigned char idx_map[26] = {
981
/* a b c d e f g h i j k l m */
982
R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,
983
/* n o p q r s t u v w x y z */
984
0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2
987
int swiz_idx[4] = { 0, 0, 0, 0 };
991
/* Validate the first character in the swizzle string and look up the base
992
* index value as described above.
994
if ((str[0] < 'a') || (str[0] > 'z'))
997
const unsigned base = base_idx[str[0] - 'a'];
1000
for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1001
/* Validate the next character, and, as described above, convert it to a
1004
if ((str[i] < 'a') || (str[i] > 'z'))
1007
swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1008
if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1015
return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1025
ir_swizzle::variable_referenced()
1027
return this->val->variable_referenced();
1031
ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1032
ir_variable_mode mode)
1033
: max_array_access(0), read_only(false), centroid(false), invariant(false),
1034
mode(mode), interpolation(ir_var_smooth), array_lvalue(false)
1036
this->ir_type = ir_type_variable;
1038
this->name = talloc_strdup(this, name);
1039
this->location = -1;
1040
this->warn_extension = NULL;
1041
this->constant_value = NULL;
1042
this->origin_upper_left = false;
1043
this->pixel_center_integer = false;
1045
if (type && type->base_type == GLSL_TYPE_SAMPLER)
1046
this->read_only = true;
1051
ir_variable::interpolation_string() const
1053
switch (this->interpolation) {
1054
case ir_var_smooth: return "smooth";
1055
case ir_var_flat: return "flat";
1056
case ir_var_noperspective: return "noperspective";
1059
assert(!"Should not get here.");
1065
ir_variable::component_slots() const
1067
/* FINISHME: Sparsely accessed arrays require fewer slots. */
1068
return this->type->component_slots();
1072
ir_function_signature::ir_function_signature(const glsl_type *return_type)
1073
: return_type(return_type), is_defined(false), _function(NULL)
1075
this->ir_type = ir_type_function_signature;
1076
this->is_builtin = false;
1081
ir_function_signature::qualifiers_match(exec_list *params)
1083
exec_list_iterator iter_a = parameters.iterator();
1084
exec_list_iterator iter_b = params->iterator();
1086
/* check that the qualifiers match. */
1087
while (iter_a.has_next()) {
1088
ir_variable *a = (ir_variable *)iter_a.get();
1089
ir_variable *b = (ir_variable *)iter_b.get();
1091
if (a->read_only != b->read_only ||
1092
a->mode != b->mode ||
1093
a->interpolation != b->interpolation ||
1094
a->centroid != b->centroid) {
1096
/* parameter a's qualifiers don't match */
1108
ir_function_signature::replace_parameters(exec_list *new_params)
1110
/* Destroy all of the previous parameter information. If the previous
1111
* parameter information comes from the function prototype, it may either
1112
* specify incorrect parameter names or not have names at all.
1114
foreach_iter(exec_list_iterator, iter, parameters) {
1115
assert(((ir_instruction *) iter.get())->as_variable() != NULL);
1120
new_params->move_nodes_to(¶meters);
1124
ir_function::ir_function(const char *name)
1126
this->ir_type = ir_type_function;
1127
this->name = talloc_strdup(this, name);
1132
ir_function::has_builtin_signature()
1134
foreach_list(n, &this->signatures) {
1135
ir_function_signature *const sig = (ir_function_signature *) n;
1136
if (sig->is_builtin)
1144
ir_call::get_error_instruction(void *ctx)
1146
ir_call *call = new(ctx) ir_call;
1148
call->type = glsl_type::error_type;
1153
ir_call::set_callee(ir_function_signature *sig)
1155
assert((this->type == NULL) || (this->type == sig->return_type));
1161
visit_exec_list(exec_list *list, ir_visitor *visitor)
1163
foreach_iter(exec_list_iterator, iter, *list) {
1164
((ir_instruction *)iter.get())->accept(visitor);
1170
steal_memory(ir_instruction *ir, void *new_ctx)
1172
ir_variable *var = ir->as_variable();
1173
ir_constant *constant = ir->as_constant();
1174
if (var != NULL && var->constant_value != NULL)
1175
steal_memory(var->constant_value, ir);
1177
/* The components of aggregate constants are not visited by the normal
1178
* visitor, so steal their values by hand.
1180
if (constant != NULL) {
1181
if (constant->type->is_record()) {
1182
foreach_iter(exec_list_iterator, iter, constant->components) {
1183
ir_constant *field = (ir_constant *)iter.get();
1184
steal_memory(field, ir);
1186
} else if (constant->type->is_array()) {
1187
for (unsigned int i = 0; i < constant->type->length; i++) {
1188
steal_memory(constant->array_elements[i], ir);
1193
talloc_steal(new_ctx, ir);
1198
reparent_ir(exec_list *list, void *mem_ctx)
1200
foreach_list(node, list) {
1201
visit_tree((ir_instruction *) node, steal_memory, mem_ctx);
added
removed
src/glsl/ir.cpp
