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 21 static TPrecision GetHigherPrecision( TPrecision left, TPrecision right ){ 22 return left > right ? left : right; 23 } 24 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 // 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 // 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 // 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 // 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 // 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 // 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 // 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 // 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 // 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 // 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 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 // 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 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 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 // 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 // 712 TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TSourceLoc line) 713 { 714 return addBranch(branchOp, 0, line); 715 } 716 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 // 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 // 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 // 764 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 // 789 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 // 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 // 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 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 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 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 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 1449 void TIntermAggregate::addToPragmaTable(const TPragmaTable& pTable) 1450 { 1451 assert(!pragmaTable); 1452 pragmaTable = new TPragmaTable(); 1453 *pragmaTable = pTable; 1454 } 1455
