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