1 //
2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 //
8 // Build the intermediate representation.
9 //
10
11 #include <float.h>
12 #include <limits.h>
13 #include <algorithm>
14
15 #include "compiler/localintermediate.h"
16 #include "compiler/QualifierAlive.h"
17 #include "compiler/RemoveTree.h"
18
19 bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray);
20
GetHigherPrecision(TPrecision left,TPrecision right)21 static TPrecision GetHigherPrecision( TPrecision left, TPrecision right ){
22 return left > right ? left : right;
23 }
24
getOperatorString(TOperator op)25 const char* getOperatorString(TOperator op) {
26 switch (op) {
27 case EOpInitialize: return "=";
28 case EOpAssign: return "=";
29 case EOpAddAssign: return "+=";
30 case EOpSubAssign: return "-=";
31 case EOpDivAssign: return "/=";
32
33 // Fall-through.
34 case EOpMulAssign:
35 case EOpVectorTimesMatrixAssign:
36 case EOpVectorTimesScalarAssign:
37 case EOpMatrixTimesScalarAssign:
38 case EOpMatrixTimesMatrixAssign: return "*=";
39
40 // Fall-through.
41 case EOpIndexDirect:
42 case EOpIndexIndirect: return "[]";
43
44 case EOpIndexDirectStruct: return ".";
45 case EOpVectorSwizzle: return ".";
46 case EOpAdd: return "+";
47 case EOpSub: return "-";
48 case EOpMul: return "*";
49 case EOpDiv: return "/";
50 case EOpMod: UNIMPLEMENTED(); break;
51 case EOpEqual: return "==";
52 case EOpNotEqual: return "!=";
53 case EOpLessThan: return "<";
54 case EOpGreaterThan: return ">";
55 case EOpLessThanEqual: return "<=";
56 case EOpGreaterThanEqual: return ">=";
57
58 // Fall-through.
59 case EOpVectorTimesScalar:
60 case EOpVectorTimesMatrix:
61 case EOpMatrixTimesVector:
62 case EOpMatrixTimesScalar:
63 case EOpMatrixTimesMatrix: return "*";
64
65 case EOpLogicalOr: return "||";
66 case EOpLogicalXor: return "^^";
67 case EOpLogicalAnd: return "&&";
68 case EOpNegative: return "-";
69 case EOpVectorLogicalNot: return "not";
70 case EOpLogicalNot: return "!";
71 case EOpPostIncrement: return "++";
72 case EOpPostDecrement: return "--";
73 case EOpPreIncrement: return "++";
74 case EOpPreDecrement: return "--";
75
76 // Fall-through.
77 case EOpConvIntToBool:
78 case EOpConvFloatToBool: return "bool";
79
80 // Fall-through.
81 case EOpConvBoolToFloat:
82 case EOpConvIntToFloat: return "float";
83
84 // Fall-through.
85 case EOpConvFloatToInt:
86 case EOpConvBoolToInt: return "int";
87
88 case EOpRadians: return "radians";
89 case EOpDegrees: return "degrees";
90 case EOpSin: return "sin";
91 case EOpCos: return "cos";
92 case EOpTan: return "tan";
93 case EOpAsin: return "asin";
94 case EOpAcos: return "acos";
95 case EOpAtan: return "atan";
96 case EOpExp: return "exp";
97 case EOpLog: return "log";
98 case EOpExp2: return "exp2";
99 case EOpLog2: return "log2";
100 case EOpSqrt: return "sqrt";
101 case EOpInverseSqrt: return "inversesqrt";
102 case EOpAbs: return "abs";
103 case EOpSign: return "sign";
104 case EOpFloor: return "floor";
105 case EOpCeil: return "ceil";
106 case EOpFract: return "fract";
107 case EOpLength: return "length";
108 case EOpNormalize: return "normalize";
109 case EOpDFdx: return "dFdx";
110 case EOpDFdy: return "dFdy";
111 case EOpFwidth: return "fwidth";
112 case EOpAny: return "any";
113 case EOpAll: return "all";
114
115 default: break;
116 }
117 return "";
118 }
119
120 ////////////////////////////////////////////////////////////////////////////
121 //
122 // First set of functions are to help build the intermediate representation.
123 // These functions are not member functions of the nodes.
124 // They are called from parser productions.
125 //
126 /////////////////////////////////////////////////////////////////////////////
127
128 //
129 // Add a terminal node for an identifier in an expression.
130 //
131 // Returns the added node.
132 //
addSymbol(int id,const TString & name,const TType & type,TSourceLoc line)133 TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType& type, TSourceLoc line)
134 {
135 TIntermSymbol* node = new TIntermSymbol(id, name, type);
136 node->setLine(line);
137
138 return node;
139 }
140
141 //
142 // Connect two nodes with a new parent that does a binary operation on the nodes.
143 //
144 // Returns the added node.
145 //
addBinaryMath(TOperator op,TIntermTyped * left,TIntermTyped * right,TSourceLoc line,TSymbolTable & symbolTable)146 TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line, TSymbolTable& symbolTable)
147 {
148 switch (op) {
149 case EOpEqual:
150 case EOpNotEqual:
151 if (left->isArray())
152 return 0;
153 break;
154 case EOpLessThan:
155 case EOpGreaterThan:
156 case EOpLessThanEqual:
157 case EOpGreaterThanEqual:
158 if (left->isMatrix() || left->isArray() || left->isVector() || left->getBasicType() == EbtStruct) {
159 return 0;
160 }
161 break;
162 case EOpLogicalOr:
163 case EOpLogicalXor:
164 case EOpLogicalAnd:
165 if (left->getBasicType() != EbtBool || left->isMatrix() || left->isArray() || left->isVector()) {
166 return 0;
167 }
168 break;
169 case EOpAdd:
170 case EOpSub:
171 case EOpDiv:
172 case EOpMul:
173 if (left->getBasicType() == EbtStruct || left->getBasicType() == EbtBool)
174 return 0;
175 default: break;
176 }
177
178 //
179 // First try converting the children to compatible types.
180 //
181 if (left->getType().getStruct() && right->getType().getStruct()) {
182 if (left->getType() != right->getType())
183 return 0;
184 } else {
185 TIntermTyped* child = addConversion(op, left->getType(), right);
186 if (child)
187 right = child;
188 else {
189 child = addConversion(op, right->getType(), left);
190 if (child)
191 left = child;
192 else
193 return 0;
194 }
195 }
196
197 //
198 // Need a new node holding things together then. Make
199 // one and promote it to the right type.
200 //
201 TIntermBinary* node = new TIntermBinary(op);
202 if (line == 0)
203 line = right->getLine();
204 node->setLine(line);
205
206 node->setLeft(left);
207 node->setRight(right);
208 if (!node->promote(infoSink))
209 return 0;
210
211 //
212 // See if we can fold constants.
213 //
214 TIntermTyped* typedReturnNode = 0;
215 TIntermConstantUnion *leftTempConstant = left->getAsConstantUnion();
216 TIntermConstantUnion *rightTempConstant = right->getAsConstantUnion();
217 if (leftTempConstant && rightTempConstant) {
218 typedReturnNode = leftTempConstant->fold(node->getOp(), rightTempConstant, infoSink);
219
220 if (typedReturnNode)
221 return typedReturnNode;
222 }
223
224 return node;
225 }
226
227 //
228 // Connect two nodes through an assignment.
229 //
230 // Returns the added node.
231 //
addAssign(TOperator op,TIntermTyped * left,TIntermTyped * right,TSourceLoc line)232 TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
233 {
234 //
235 // Like adding binary math, except the conversion can only go
236 // from right to left.
237 //
238 TIntermBinary* node = new TIntermBinary(op);
239 if (line == 0)
240 line = left->getLine();
241 node->setLine(line);
242
243 TIntermTyped* child = addConversion(op, left->getType(), right);
244 if (child == 0)
245 return 0;
246
247 node->setLeft(left);
248 node->setRight(child);
249 if (! node->promote(infoSink))
250 return 0;
251
252 return node;
253 }
254
255 //
256 // Connect two nodes through an index operator, where the left node is the base
257 // of an array or struct, and the right node is a direct or indirect offset.
258 //
259 // Returns the added node.
260 // The caller should set the type of the returned node.
261 //
addIndex(TOperator op,TIntermTyped * base,TIntermTyped * index,TSourceLoc line)262 TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, TSourceLoc line)
263 {
264 TIntermBinary* node = new TIntermBinary(op);
265 if (line == 0)
266 line = index->getLine();
267 node->setLine(line);
268 node->setLeft(base);
269 node->setRight(index);
270
271 // caller should set the type
272
273 return node;
274 }
275
276 //
277 // Add one node as the parent of another that it operates on.
278 //
279 // Returns the added node.
280 //
addUnaryMath(TOperator op,TIntermNode * childNode,TSourceLoc line,TSymbolTable & symbolTable)281 TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode, TSourceLoc line, TSymbolTable& symbolTable)
282 {
283 TIntermUnary* node;
284 TIntermTyped* child = childNode->getAsTyped();
285
286 if (child == 0) {
287 infoSink.info.message(EPrefixInternalError, "Bad type in AddUnaryMath", line);
288 return 0;
289 }
290
291 switch (op) {
292 case EOpLogicalNot:
293 if (child->getType().getBasicType() != EbtBool || child->getType().isMatrix() || child->getType().isArray() || child->getType().isVector()) {
294 return 0;
295 }
296 break;
297
298 case EOpPostIncrement:
299 case EOpPreIncrement:
300 case EOpPostDecrement:
301 case EOpPreDecrement:
302 case EOpNegative:
303 if (child->getType().getBasicType() == EbtStruct || child->getType().isArray())
304 return 0;
305 default: break;
306 }
307
308 //
309 // Do we need to promote the operand?
310 //
311 // Note: Implicit promotions were removed from the language.
312 //
313 TBasicType newType = EbtVoid;
314 switch (op) {
315 case EOpConstructInt: newType = EbtInt; break;
316 case EOpConstructBool: newType = EbtBool; break;
317 case EOpConstructFloat: newType = EbtFloat; break;
318 default: break;
319 }
320
321 if (newType != EbtVoid) {
322 child = addConversion(op, TType(newType, child->getPrecision(), EvqTemporary,
323 child->getNominalSize(),
324 child->isMatrix(),
325 child->isArray()),
326 child);
327 if (child == 0)
328 return 0;
329 }
330
331 //
332 // For constructors, we are now done, it's all in the conversion.
333 //
334 switch (op) {
335 case EOpConstructInt:
336 case EOpConstructBool:
337 case EOpConstructFloat:
338 return child;
339 default: break;
340 }
341
342 TIntermConstantUnion *childTempConstant = 0;
343 if (child->getAsConstantUnion())
344 childTempConstant = child->getAsConstantUnion();
345
346 //
347 // Make a new node for the operator.
348 //
349 node = new TIntermUnary(op);
350 if (line == 0)
351 line = child->getLine();
352 node->setLine(line);
353 node->setOperand(child);
354
355 if (! node->promote(infoSink))
356 return 0;
357
358 if (childTempConstant) {
359 TIntermTyped* newChild = childTempConstant->fold(op, 0, infoSink);
360
361 if (newChild)
362 return newChild;
363 }
364
365 return node;
366 }
367
368 //
369 // This is the safe way to change the operator on an aggregate, as it
370 // does lots of error checking and fixing. Especially for establishing
371 // a function call's operation on it's set of parameters. Sequences
372 // of instructions are also aggregates, but they just direnctly set
373 // their operator to EOpSequence.
374 //
375 // Returns an aggregate node, which could be the one passed in if
376 // it was already an aggregate.
377 //
setAggregateOperator(TIntermNode * node,TOperator op,TSourceLoc line)378 TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, TSourceLoc line)
379 {
380 TIntermAggregate* aggNode;
381
382 //
383 // Make sure we have an aggregate. If not turn it into one.
384 //
385 if (node) {
386 aggNode = node->getAsAggregate();
387 if (aggNode == 0 || aggNode->getOp() != EOpNull) {
388 //
389 // Make an aggregate containing this node.
390 //
391 aggNode = new TIntermAggregate();
392 aggNode->getSequence().push_back(node);
393 if (line == 0)
394 line = node->getLine();
395 }
396 } else
397 aggNode = new TIntermAggregate();
398
399 //
400 // Set the operator.
401 //
402 aggNode->setOp(op);
403 if (line != 0)
404 aggNode->setLine(line);
405
406 return aggNode;
407 }
408
409 //
410 // Convert one type to another.
411 //
412 // Returns the node representing the conversion, which could be the same
413 // node passed in if no conversion was needed.
414 //
415 // Return 0 if a conversion can't be done.
416 //
addConversion(TOperator op,const TType & type,TIntermTyped * node)417 TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TIntermTyped* node)
418 {
419 //
420 // Does the base type allow operation?
421 //
422 switch (node->getBasicType()) {
423 case EbtVoid:
424 case EbtSampler2D:
425 case EbtSamplerCube:
426 return 0;
427 default: break;
428 }
429
430 //
431 // Otherwise, if types are identical, no problem
432 //
433 if (type == node->getType())
434 return node;
435
436 //
437 // If one's a structure, then no conversions.
438 //
439 if (type.getStruct() || node->getType().getStruct())
440 return 0;
441
442 //
443 // If one's an array, then no conversions.
444 //
445 if (type.isArray() || node->getType().isArray())
446 return 0;
447
448 TBasicType promoteTo;
449
450 switch (op) {
451 //
452 // Explicit conversions
453 //
454 case EOpConstructBool:
455 promoteTo = EbtBool;
456 break;
457 case EOpConstructFloat:
458 promoteTo = EbtFloat;
459 break;
460 case EOpConstructInt:
461 promoteTo = EbtInt;
462 break;
463 default:
464 //
465 // implicit conversions were removed from the language.
466 //
467 if (type.getBasicType() != node->getType().getBasicType())
468 return 0;
469 //
470 // Size and structure could still differ, but that's
471 // handled by operator promotion.
472 //
473 return node;
474 }
475
476 if (node->getAsConstantUnion()) {
477
478 return (promoteConstantUnion(promoteTo, node->getAsConstantUnion()));
479 } else {
480
481 //
482 // Add a new newNode for the conversion.
483 //
484 TIntermUnary* newNode = 0;
485
486 TOperator newOp = EOpNull;
487 switch (promoteTo) {
488 case EbtFloat:
489 switch (node->getBasicType()) {
490 case EbtInt: newOp = EOpConvIntToFloat; break;
491 case EbtBool: newOp = EOpConvBoolToFloat; break;
492 default:
493 infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
494 return 0;
495 }
496 break;
497 case EbtBool:
498 switch (node->getBasicType()) {
499 case EbtInt: newOp = EOpConvIntToBool; break;
500 case EbtFloat: newOp = EOpConvFloatToBool; break;
501 default:
502 infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
503 return 0;
504 }
505 break;
506 case EbtInt:
507 switch (node->getBasicType()) {
508 case EbtBool: newOp = EOpConvBoolToInt; break;
509 case EbtFloat: newOp = EOpConvFloatToInt; break;
510 default:
511 infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
512 return 0;
513 }
514 break;
515 default:
516 infoSink.info.message(EPrefixInternalError, "Bad promotion type", node->getLine());
517 return 0;
518 }
519
520 TType type(promoteTo, node->getPrecision(), EvqTemporary, node->getNominalSize(), node->isMatrix(), node->isArray());
521 newNode = new TIntermUnary(newOp, type);
522 newNode->setLine(node->getLine());
523 newNode->setOperand(node);
524
525 return newNode;
526 }
527 }
528
529 //
530 // Safe way to combine two nodes into an aggregate. Works with null pointers,
531 // a node that's not a aggregate yet, etc.
532 //
533 // Returns the resulting aggregate, unless 0 was passed in for
534 // both existing nodes.
535 //
growAggregate(TIntermNode * left,TIntermNode * right,TSourceLoc line)536 TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* right, TSourceLoc line)
537 {
538 if (left == 0 && right == 0)
539 return 0;
540
541 TIntermAggregate* aggNode = 0;
542 if (left)
543 aggNode = left->getAsAggregate();
544 if (!aggNode || aggNode->getOp() != EOpNull) {
545 aggNode = new TIntermAggregate;
546 if (left)
547 aggNode->getSequence().push_back(left);
548 }
549
550 if (right)
551 aggNode->getSequence().push_back(right);
552
553 if (line != 0)
554 aggNode->setLine(line);
555
556 return aggNode;
557 }
558
559 //
560 // Turn an existing node into an aggregate.
561 //
562 // Returns an aggregate, unless 0 was passed in for the existing node.
563 //
makeAggregate(TIntermNode * node,TSourceLoc line)564 TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, TSourceLoc line)
565 {
566 if (node == 0)
567 return 0;
568
569 TIntermAggregate* aggNode = new TIntermAggregate;
570 aggNode->getSequence().push_back(node);
571
572 if (line != 0)
573 aggNode->setLine(line);
574 else
575 aggNode->setLine(node->getLine());
576
577 return aggNode;
578 }
579
580 //
581 // For "if" test nodes. There are three children; a condition,
582 // a true path, and a false path. The two paths are in the
583 // nodePair.
584 //
585 // Returns the selection node created.
586 //
addSelection(TIntermTyped * cond,TIntermNodePair nodePair,TSourceLoc line)587 TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line)
588 {
589 //
590 // For compile time constant selections, prune the code and
591 // test now.
592 //
593
594 if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) {
595 if (cond->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
596 return nodePair.node1;
597 else
598 return nodePair.node2;
599 }
600
601 TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
602 node->setLine(line);
603
604 return node;
605 }
606
607
addComma(TIntermTyped * left,TIntermTyped * right,TSourceLoc line)608 TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
609 {
610 if (left->getType().getQualifier() == EvqConst && right->getType().getQualifier() == EvqConst) {
611 return right;
612 } else {
613 TIntermTyped *commaAggregate = growAggregate(left, right, line);
614 commaAggregate->getAsAggregate()->setOp(EOpComma);
615 commaAggregate->setType(right->getType());
616 commaAggregate->getTypePointer()->setQualifier(EvqTemporary);
617 return commaAggregate;
618 }
619 }
620
621 //
622 // For "?:" test nodes. There are three children; a condition,
623 // a true path, and a false path. The two paths are specified
624 // as separate parameters.
625 //
626 // Returns the selection node created, or 0 if one could not be.
627 //
addSelection(TIntermTyped * cond,TIntermTyped * trueBlock,TIntermTyped * falseBlock,TSourceLoc line)628 TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc line)
629 {
630 //
631 // Get compatible types.
632 //
633 TIntermTyped* child = addConversion(EOpSequence, trueBlock->getType(), falseBlock);
634 if (child)
635 falseBlock = child;
636 else {
637 child = addConversion(EOpSequence, falseBlock->getType(), trueBlock);
638 if (child)
639 trueBlock = child;
640 else
641 return 0;
642 }
643
644 //
645 // See if all the operands are constant, then fold it otherwise not.
646 //
647
648 if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) {
649 if (cond->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
650 return trueBlock;
651 else
652 return falseBlock;
653 }
654
655 //
656 // Make a selection node.
657 //
658 TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
659 node->setLine(line);
660
661 return node;
662 }
663
664 //
665 // Constant terminal nodes. Has a union that contains bool, float or int constants
666 //
667 // Returns the constant union node created.
668 //
669
addConstantUnion(ConstantUnion * unionArrayPointer,const TType & t,TSourceLoc line)670 TIntermConstantUnion* TIntermediate::addConstantUnion(ConstantUnion* unionArrayPointer, const TType& t, TSourceLoc line)
671 {
672 TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t);
673 node->setLine(line);
674
675 return node;
676 }
677
addSwizzle(TVectorFields & fields,TSourceLoc line)678 TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc line)
679 {
680
681 TIntermAggregate* node = new TIntermAggregate(EOpSequence);
682
683 node->setLine(line);
684 TIntermConstantUnion* constIntNode;
685 TIntermSequence &sequenceVector = node->getSequence();
686 ConstantUnion* unionArray;
687
688 for (int i = 0; i < fields.num; i++) {
689 unionArray = new ConstantUnion[1];
690 unionArray->setIConst(fields.offsets[i]);
691 constIntNode = addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), line);
692 sequenceVector.push_back(constIntNode);
693 }
694
695 return node;
696 }
697
698 //
699 // Create loop nodes.
700 //
addLoop(TLoopType type,TIntermNode * init,TIntermTyped * cond,TIntermTyped * expr,TIntermNode * body,TSourceLoc line)701 TIntermNode* TIntermediate::addLoop(TLoopType type, TIntermNode* init, TIntermTyped* cond, TIntermTyped* expr, TIntermNode* body, TSourceLoc line)
702 {
703 TIntermNode* node = new TIntermLoop(type, init, cond, expr, body);
704 node->setLine(line);
705
706 return node;
707 }
708
709 //
710 // Add branches.
711 //
addBranch(TOperator branchOp,TSourceLoc line)712 TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TSourceLoc line)
713 {
714 return addBranch(branchOp, 0, line);
715 }
716
addBranch(TOperator branchOp,TIntermTyped * expression,TSourceLoc line)717 TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expression, TSourceLoc line)
718 {
719 TIntermBranch* node = new TIntermBranch(branchOp, expression);
720 node->setLine(line);
721
722 return node;
723 }
724
725 //
726 // This is to be executed once the final root is put on top by the parsing
727 // process.
728 //
postProcess(TIntermNode * root)729 bool TIntermediate::postProcess(TIntermNode* root)
730 {
731 if (root == 0)
732 return true;
733
734 //
735 // First, finish off the top level sequence, if any
736 //
737 TIntermAggregate* aggRoot = root->getAsAggregate();
738 if (aggRoot && aggRoot->getOp() == EOpNull)
739 aggRoot->setOp(EOpSequence);
740
741 return true;
742 }
743
744 //
745 // This deletes the tree.
746 //
remove(TIntermNode * root)747 void TIntermediate::remove(TIntermNode* root)
748 {
749 if (root)
750 RemoveAllTreeNodes(root);
751 }
752
753 ////////////////////////////////////////////////////////////////
754 //
755 // Member functions of the nodes used for building the tree.
756 //
757 ////////////////////////////////////////////////////////////////
758
759 //
760 // Say whether or not an operation node changes the value of a variable.
761 //
762 // Returns true if state is modified.
763 //
modifiesState() const764 bool TIntermOperator::modifiesState() const
765 {
766 switch (op) {
767 case EOpPostIncrement:
768 case EOpPostDecrement:
769 case EOpPreIncrement:
770 case EOpPreDecrement:
771 case EOpAssign:
772 case EOpAddAssign:
773 case EOpSubAssign:
774 case EOpMulAssign:
775 case EOpVectorTimesMatrixAssign:
776 case EOpVectorTimesScalarAssign:
777 case EOpMatrixTimesScalarAssign:
778 case EOpMatrixTimesMatrixAssign:
779 case EOpDivAssign:
780 return true;
781 default:
782 return false;
783 }
784 }
785
786 //
787 // returns true if the operator is for one of the constructors
788 //
isConstructor() const789 bool TIntermOperator::isConstructor() const
790 {
791 switch (op) {
792 case EOpConstructVec2:
793 case EOpConstructVec3:
794 case EOpConstructVec4:
795 case EOpConstructMat2:
796 case EOpConstructMat3:
797 case EOpConstructMat4:
798 case EOpConstructFloat:
799 case EOpConstructIVec2:
800 case EOpConstructIVec3:
801 case EOpConstructIVec4:
802 case EOpConstructInt:
803 case EOpConstructBVec2:
804 case EOpConstructBVec3:
805 case EOpConstructBVec4:
806 case EOpConstructBool:
807 case EOpConstructStruct:
808 return true;
809 default:
810 return false;
811 }
812 }
813 //
814 // Make sure the type of a unary operator is appropriate for its
815 // combination of operation and operand type.
816 //
817 // Returns false in nothing makes sense.
818 //
promote(TInfoSink &)819 bool TIntermUnary::promote(TInfoSink&)
820 {
821 switch (op) {
822 case EOpLogicalNot:
823 if (operand->getBasicType() != EbtBool)
824 return false;
825 break;
826 case EOpNegative:
827 case EOpPostIncrement:
828 case EOpPostDecrement:
829 case EOpPreIncrement:
830 case EOpPreDecrement:
831 if (operand->getBasicType() == EbtBool)
832 return false;
833 break;
834
835 // operators for built-ins are already type checked against their prototype
836 case EOpAny:
837 case EOpAll:
838 case EOpVectorLogicalNot:
839 return true;
840
841 default:
842 if (operand->getBasicType() != EbtFloat)
843 return false;
844 }
845
846 setType(operand->getType());
847
848 return true;
849 }
850
851 //
852 // Establishes the type of the resultant operation, as well as
853 // makes the operator the correct one for the operands.
854 //
855 // Returns false if operator can't work on operands.
856 //
promote(TInfoSink & infoSink)857 bool TIntermBinary::promote(TInfoSink& infoSink)
858 {
859 // This function only handles scalars, vectors, and matrices.
860 if (left->isArray() || right->isArray()) {
861 infoSink.info.message(EPrefixInternalError, "Invalid operation for arrays", getLine());
862 return false;
863 }
864
865 // GLSL ES 2.0 does not support implicit type casting.
866 // So the basic type should always match.
867 if (left->getBasicType() != right->getBasicType())
868 return false;
869
870 //
871 // Base assumption: just make the type the same as the left
872 // operand. Then only deviations from this need be coded.
873 //
874 setType(left->getType());
875
876 // The result gets promoted to the highest precision.
877 TPrecision higherPrecision = GetHigherPrecision(left->getPrecision(), right->getPrecision());
878 getTypePointer()->setPrecision(higherPrecision);
879
880 // Binary operations results in temporary variables unless both
881 // operands are const.
882 if (left->getQualifier() != EvqConst || right->getQualifier() != EvqConst) {
883 getTypePointer()->setQualifier(EvqTemporary);
884 }
885
886 int size = std::max(left->getNominalSize(), right->getNominalSize());
887
888 //
889 // All scalars. Code after this test assumes this case is removed!
890 //
891 if (size == 1) {
892 switch (op) {
893 //
894 // Promote to conditional
895 //
896 case EOpEqual:
897 case EOpNotEqual:
898 case EOpLessThan:
899 case EOpGreaterThan:
900 case EOpLessThanEqual:
901 case EOpGreaterThanEqual:
902 setType(TType(EbtBool, EbpUndefined));
903 break;
904
905 //
906 // And and Or operate on conditionals
907 //
908 case EOpLogicalAnd:
909 case EOpLogicalOr:
910 // Both operands must be of type bool.
911 if (left->getBasicType() != EbtBool || right->getBasicType() != EbtBool)
912 return false;
913 setType(TType(EbtBool, EbpUndefined));
914 break;
915
916 default:
917 break;
918 }
919 return true;
920 }
921
922 // If we reach here, at least one of the operands is vector or matrix.
923 // The other operand could be a scalar, vector, or matrix.
924 // Are the sizes compatible?
925 //
926 if (left->getNominalSize() != right->getNominalSize()) {
927 // If the nominal size of operands do not match:
928 // One of them must be scalar.
929 if (left->getNominalSize() != 1 && right->getNominalSize() != 1)
930 return false;
931 // Operator cannot be of type pure assignment.
932 if (op == EOpAssign || op == EOpInitialize)
933 return false;
934 }
935
936 //
937 // Can these two operands be combined?
938 //
939 TBasicType basicType = left->getBasicType();
940 switch (op) {
941 case EOpMul:
942 if (!left->isMatrix() && right->isMatrix()) {
943 if (left->isVector())
944 op = EOpVectorTimesMatrix;
945 else {
946 op = EOpMatrixTimesScalar;
947 setType(TType(basicType, higherPrecision, EvqTemporary, size, true));
948 }
949 } else if (left->isMatrix() && !right->isMatrix()) {
950 if (right->isVector()) {
951 op = EOpMatrixTimesVector;
952 setType(TType(basicType, higherPrecision, EvqTemporary, size, false));
953 } else {
954 op = EOpMatrixTimesScalar;
955 }
956 } else if (left->isMatrix() && right->isMatrix()) {
957 op = EOpMatrixTimesMatrix;
958 } else if (!left->isMatrix() && !right->isMatrix()) {
959 if (left->isVector() && right->isVector()) {
960 // leave as component product
961 } else if (left->isVector() || right->isVector()) {
962 op = EOpVectorTimesScalar;
963 setType(TType(basicType, higherPrecision, EvqTemporary, size, false));
964 }
965 } else {
966 infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
967 return false;
968 }
969 break;
970 case EOpMulAssign:
971 if (!left->isMatrix() && right->isMatrix()) {
972 if (left->isVector())
973 op = EOpVectorTimesMatrixAssign;
974 else {
975 return false;
976 }
977 } else if (left->isMatrix() && !right->isMatrix()) {
978 if (right->isVector()) {
979 return false;
980 } else {
981 op = EOpMatrixTimesScalarAssign;
982 }
983 } else if (left->isMatrix() && right->isMatrix()) {
984 op = EOpMatrixTimesMatrixAssign;
985 } else if (!left->isMatrix() && !right->isMatrix()) {
986 if (left->isVector() && right->isVector()) {
987 // leave as component product
988 } else if (left->isVector() || right->isVector()) {
989 if (! left->isVector())
990 return false;
991 op = EOpVectorTimesScalarAssign;
992 setType(TType(basicType, higherPrecision, EvqTemporary, size, false));
993 }
994 } else {
995 infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
996 return false;
997 }
998 break;
999
1000 case EOpAssign:
1001 case EOpInitialize:
1002 case EOpAdd:
1003 case EOpSub:
1004 case EOpDiv:
1005 case EOpAddAssign:
1006 case EOpSubAssign:
1007 case EOpDivAssign:
1008 if (left->isMatrix() && right->isVector() ||
1009 left->isVector() && right->isMatrix())
1010 return false;
1011 setType(TType(basicType, higherPrecision, EvqTemporary, size, left->isMatrix() || right->isMatrix()));
1012 break;
1013
1014 case EOpEqual:
1015 case EOpNotEqual:
1016 case EOpLessThan:
1017 case EOpGreaterThan:
1018 case EOpLessThanEqual:
1019 case EOpGreaterThanEqual:
1020 if (left->isMatrix() && right->isVector() ||
1021 left->isVector() && right->isMatrix())
1022 return false;
1023 setType(TType(EbtBool, EbpUndefined));
1024 break;
1025
1026 default:
1027 return false;
1028 }
1029
1030 return true;
1031 }
1032
CompareStruct(const TType & leftNodeType,ConstantUnion * rightUnionArray,ConstantUnion * leftUnionArray)1033 bool CompareStruct(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray)
1034 {
1035 const TTypeList* fields = leftNodeType.getStruct();
1036
1037 size_t structSize = fields->size();
1038 int index = 0;
1039
1040 for (size_t j = 0; j < structSize; j++) {
1041 int size = (*fields)[j].type->getObjectSize();
1042 for (int i = 0; i < size; i++) {
1043 if ((*fields)[j].type->getBasicType() == EbtStruct) {
1044 if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
1045 return false;
1046 } else {
1047 if (leftUnionArray[index] != rightUnionArray[index])
1048 return false;
1049 index++;
1050 }
1051
1052 }
1053 }
1054 return true;
1055 }
1056
CompareStructure(const TType & leftNodeType,ConstantUnion * rightUnionArray,ConstantUnion * leftUnionArray)1057 bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray)
1058 {
1059 if (leftNodeType.isArray()) {
1060 TType typeWithoutArrayness = leftNodeType;
1061 typeWithoutArrayness.clearArrayness();
1062
1063 int arraySize = leftNodeType.getArraySize();
1064
1065 for (int i = 0; i < arraySize; ++i) {
1066 int offset = typeWithoutArrayness.getObjectSize() * i;
1067 if (!CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset]))
1068 return false;
1069 }
1070 } else
1071 return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray);
1072
1073 return true;
1074 }
1075
1076 //
1077 // The fold functions see if an operation on a constant can be done in place,
1078 // without generating run-time code.
1079 //
1080 // Returns the node to keep using, which may or may not be the node passed in.
1081 //
1082
fold(TOperator op,TIntermTyped * constantNode,TInfoSink & infoSink)1083 TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink)
1084 {
1085 ConstantUnion *unionArray = getUnionArrayPointer();
1086 int objectSize = getType().getObjectSize();
1087
1088 if (constantNode) { // binary operations
1089 TIntermConstantUnion *node = constantNode->getAsConstantUnion();
1090 ConstantUnion *rightUnionArray = node->getUnionArrayPointer();
1091 TType returnType = getType();
1092
1093 // for a case like float f = 1.2 + vec4(2,3,4,5);
1094 if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
1095 rightUnionArray = new ConstantUnion[objectSize];
1096 for (int i = 0; i < objectSize; ++i)
1097 rightUnionArray[i] = *node->getUnionArrayPointer();
1098 returnType = getType();
1099 } else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
1100 // for a case like float f = vec4(2,3,4,5) + 1.2;
1101 unionArray = new ConstantUnion[constantNode->getType().getObjectSize()];
1102 for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
1103 unionArray[i] = *getUnionArrayPointer();
1104 returnType = node->getType();
1105 objectSize = constantNode->getType().getObjectSize();
1106 }
1107
1108 ConstantUnion* tempConstArray = 0;
1109 TIntermConstantUnion *tempNode;
1110
1111 bool boolNodeFlag = false;
1112 switch(op) {
1113 case EOpAdd:
1114 tempConstArray = new ConstantUnion[objectSize];
1115 {// support MSVC++6.0
1116 for (int i = 0; i < objectSize; i++)
1117 tempConstArray[i] = unionArray[i] + rightUnionArray[i];
1118 }
1119 break;
1120 case EOpSub:
1121 tempConstArray = new ConstantUnion[objectSize];
1122 {// support MSVC++6.0
1123 for (int i = 0; i < objectSize; i++)
1124 tempConstArray[i] = unionArray[i] - rightUnionArray[i];
1125 }
1126 break;
1127
1128 case EOpMul:
1129 case EOpVectorTimesScalar:
1130 case EOpMatrixTimesScalar:
1131 tempConstArray = new ConstantUnion[objectSize];
1132 {// support MSVC++6.0
1133 for (int i = 0; i < objectSize; i++)
1134 tempConstArray[i] = unionArray[i] * rightUnionArray[i];
1135 }
1136 break;
1137 case EOpMatrixTimesMatrix:
1138 if (getType().getBasicType() != EbtFloat || node->getBasicType() != EbtFloat) {
1139 infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix multiply", getLine());
1140 return 0;
1141 }
1142 {// support MSVC++6.0
1143 int size = getNominalSize();
1144 tempConstArray = new ConstantUnion[size*size];
1145 for (int row = 0; row < size; row++) {
1146 for (int column = 0; column < size; column++) {
1147 tempConstArray[size * column + row].setFConst(0.0f);
1148 for (int i = 0; i < size; i++) {
1149 tempConstArray[size * column + row].setFConst(tempConstArray[size * column + row].getFConst() + unionArray[i * size + row].getFConst() * (rightUnionArray[column * size + i].getFConst()));
1150 }
1151 }
1152 }
1153 }
1154 break;
1155 case EOpDiv:
1156 tempConstArray = new ConstantUnion[objectSize];
1157 {// support MSVC++6.0
1158 for (int i = 0; i < objectSize; i++) {
1159 switch (getType().getBasicType()) {
1160 case EbtFloat:
1161 if (rightUnionArray[i] == 0.0f) {
1162 infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
1163 tempConstArray[i].setFConst(FLT_MAX);
1164 } else
1165 tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
1166 break;
1167
1168 case EbtInt:
1169 if (rightUnionArray[i] == 0) {
1170 infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
1171 tempConstArray[i].setIConst(INT_MAX);
1172 } else
1173 tempConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst());
1174 break;
1175 default:
1176 infoSink.info.message(EPrefixInternalError, "Constant folding cannot be done for \"/\"", getLine());
1177 return 0;
1178 }
1179 }
1180 }
1181 break;
1182
1183 case EOpMatrixTimesVector:
1184 if (node->getBasicType() != EbtFloat) {
1185 infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix times vector", getLine());
1186 return 0;
1187 }
1188 tempConstArray = new ConstantUnion[getNominalSize()];
1189
1190 {// support MSVC++6.0
1191 for (int size = getNominalSize(), i = 0; i < size; i++) {
1192 tempConstArray[i].setFConst(0.0f);
1193 for (int j = 0; j < size; j++) {
1194 tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j*size + i].getFConst()) * rightUnionArray[j].getFConst()));
1195 }
1196 }
1197 }
1198
1199 tempNode = new TIntermConstantUnion(tempConstArray, node->getType());
1200 tempNode->setLine(getLine());
1201
1202 return tempNode;
1203
1204 case EOpVectorTimesMatrix:
1205 if (getType().getBasicType() != EbtFloat) {
1206 infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for vector times matrix", getLine());
1207 return 0;
1208 }
1209
1210 tempConstArray = new ConstantUnion[getNominalSize()];
1211 {// support MSVC++6.0
1212 for (int size = getNominalSize(), i = 0; i < size; i++) {
1213 tempConstArray[i].setFConst(0.0f);
1214 for (int j = 0; j < size; j++) {
1215 tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j].getFConst()) * rightUnionArray[i*size + j].getFConst()));
1216 }
1217 }
1218 }
1219 break;
1220
1221 case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
1222 tempConstArray = new ConstantUnion[objectSize];
1223 {// support MSVC++6.0
1224 for (int i = 0; i < objectSize; i++)
1225 tempConstArray[i] = unionArray[i] && rightUnionArray[i];
1226 }
1227 break;
1228
1229 case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
1230 tempConstArray = new ConstantUnion[objectSize];
1231 {// support MSVC++6.0
1232 for (int i = 0; i < objectSize; i++)
1233 tempConstArray[i] = unionArray[i] || rightUnionArray[i];
1234 }
1235 break;
1236
1237 case EOpLogicalXor:
1238 tempConstArray = new ConstantUnion[objectSize];
1239 {// support MSVC++6.0
1240 for (int i = 0; i < objectSize; i++)
1241 switch (getType().getBasicType()) {
1242 case EbtBool: tempConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
1243 default: assert(false && "Default missing");
1244 }
1245 }
1246 break;
1247
1248 case EOpLessThan:
1249 assert(objectSize == 1);
1250 tempConstArray = new ConstantUnion[1];
1251 tempConstArray->setBConst(*unionArray < *rightUnionArray);
1252 returnType = TType(EbtBool, EbpUndefined, EvqConst);
1253 break;
1254 case EOpGreaterThan:
1255 assert(objectSize == 1);
1256 tempConstArray = new ConstantUnion[1];
1257 tempConstArray->setBConst(*unionArray > *rightUnionArray);
1258 returnType = TType(EbtBool, EbpUndefined, EvqConst);
1259 break;
1260 case EOpLessThanEqual:
1261 {
1262 assert(objectSize == 1);
1263 ConstantUnion constant;
1264 constant.setBConst(*unionArray > *rightUnionArray);
1265 tempConstArray = new ConstantUnion[1];
1266 tempConstArray->setBConst(!constant.getBConst());
1267 returnType = TType(EbtBool, EbpUndefined, EvqConst);
1268 break;
1269 }
1270 case EOpGreaterThanEqual:
1271 {
1272 assert(objectSize == 1);
1273 ConstantUnion constant;
1274 constant.setBConst(*unionArray < *rightUnionArray);
1275 tempConstArray = new ConstantUnion[1];
1276 tempConstArray->setBConst(!constant.getBConst());
1277 returnType = TType(EbtBool, EbpUndefined, EvqConst);
1278 break;
1279 }
1280
1281 case EOpEqual:
1282 if (getType().getBasicType() == EbtStruct) {
1283 if (!CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
1284 boolNodeFlag = true;
1285 } else {
1286 for (int i = 0; i < objectSize; i++) {
1287 if (unionArray[i] != rightUnionArray[i]) {
1288 boolNodeFlag = true;
1289 break; // break out of for loop
1290 }
1291 }
1292 }
1293
1294 tempConstArray = new ConstantUnion[1];
1295 if (!boolNodeFlag) {
1296 tempConstArray->setBConst(true);
1297 }
1298 else {
1299 tempConstArray->setBConst(false);
1300 }
1301
1302 tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EbpUndefined, EvqConst));
1303 tempNode->setLine(getLine());
1304
1305 return tempNode;
1306
1307 case EOpNotEqual:
1308 if (getType().getBasicType() == EbtStruct) {
1309 if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
1310 boolNodeFlag = true;
1311 } else {
1312 for (int i = 0; i < objectSize; i++) {
1313 if (unionArray[i] == rightUnionArray[i]) {
1314 boolNodeFlag = true;
1315 break; // break out of for loop
1316 }
1317 }
1318 }
1319
1320 tempConstArray = new ConstantUnion[1];
1321 if (!boolNodeFlag) {
1322 tempConstArray->setBConst(true);
1323 }
1324 else {
1325 tempConstArray->setBConst(false);
1326 }
1327
1328 tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EbpUndefined, EvqConst));
1329 tempNode->setLine(getLine());
1330
1331 return tempNode;
1332
1333 default:
1334 infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
1335 return 0;
1336 }
1337 tempNode = new TIntermConstantUnion(tempConstArray, returnType);
1338 tempNode->setLine(getLine());
1339
1340 return tempNode;
1341 } else {
1342 //
1343 // Do unary operations
1344 //
1345 TIntermConstantUnion *newNode = 0;
1346 ConstantUnion* tempConstArray = new ConstantUnion[objectSize];
1347 for (int i = 0; i < objectSize; i++) {
1348 switch(op) {
1349 case EOpNegative:
1350 switch (getType().getBasicType()) {
1351 case EbtFloat: tempConstArray[i].setFConst(-unionArray[i].getFConst()); break;
1352 case EbtInt: tempConstArray[i].setIConst(-unionArray[i].getIConst()); break;
1353 default:
1354 infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
1355 return 0;
1356 }
1357 break;
1358 case EOpLogicalNot: // this code is written for possible future use, will not get executed currently
1359 switch (getType().getBasicType()) {
1360 case EbtBool: tempConstArray[i].setBConst(!unionArray[i].getBConst()); break;
1361 default:
1362 infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
1363 return 0;
1364 }
1365 break;
1366 default:
1367 return 0;
1368 }
1369 }
1370 newNode = new TIntermConstantUnion(tempConstArray, getType());
1371 newNode->setLine(getLine());
1372 return newNode;
1373 }
1374
1375 return this;
1376 }
1377
promoteConstantUnion(TBasicType promoteTo,TIntermConstantUnion * node)1378 TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermConstantUnion* node)
1379 {
1380 ConstantUnion *rightUnionArray = node->getUnionArrayPointer();
1381 int size = node->getType().getObjectSize();
1382
1383 ConstantUnion *leftUnionArray = new ConstantUnion[size];
1384
1385 for (int i=0; i < size; i++) {
1386
1387 switch (promoteTo) {
1388 case EbtFloat:
1389 switch (node->getType().getBasicType()) {
1390 case EbtInt:
1391 leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getIConst()));
1392 break;
1393 case EbtBool:
1394 leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
1395 break;
1396 case EbtFloat:
1397 leftUnionArray[i] = rightUnionArray[i];
1398 break;
1399 default:
1400 infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
1401 return 0;
1402 }
1403 break;
1404 case EbtInt:
1405 switch (node->getType().getBasicType()) {
1406 case EbtInt:
1407 leftUnionArray[i] = rightUnionArray[i];
1408 break;
1409 case EbtBool:
1410 leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
1411 break;
1412 case EbtFloat:
1413 leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst()));
1414 break;
1415 default:
1416 infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
1417 return 0;
1418 }
1419 break;
1420 case EbtBool:
1421 switch (node->getType().getBasicType()) {
1422 case EbtInt:
1423 leftUnionArray[i].setBConst(rightUnionArray[i].getIConst() != 0);
1424 break;
1425 case EbtBool:
1426 leftUnionArray[i] = rightUnionArray[i];
1427 break;
1428 case EbtFloat:
1429 leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f);
1430 break;
1431 default:
1432 infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
1433 return 0;
1434 }
1435
1436 break;
1437 default:
1438 infoSink.info.message(EPrefixInternalError, "Incorrect data type found", node->getLine());
1439 return 0;
1440 }
1441
1442 }
1443
1444 const TType& t = node->getType();
1445
1446 return addConstantUnion(leftUnionArray, TType(promoteTo, t.getPrecision(), t.getQualifier(), t.getNominalSize(), t.isMatrix(), t.isArray()), node->getLine());
1447 }
1448
addToPragmaTable(const TPragmaTable & pTable)1449 void TIntermAggregate::addToPragmaTable(const TPragmaTable& pTable)
1450 {
1451 assert(!pragmaTable);
1452 pragmaTable = new TPragmaTable();
1453 *pragmaTable = pTable;
1454 }
1455