Remove simple Intermediate.h functions

src/compiler/translator/IntermNode.cpp

@@ -1043,6 +1043,24 @@ TQualifier TIntermTernary::DetermineQualifier(TIntermTyped *cond,
     return EvqTemporary;
 }
 
+TIntermTyped *TIntermTernary::fold()
+{
+    if (mCondition->getAsConstantUnion())
+    {
+        if (mCondition->getAsConstantUnion()->getBConst(0))
+        {
+            mTrueExpression->getTypePointer()->setQualifier(mType.getQualifier());
+            return mTrueExpression;
+        }
+        else
+        {
+            mFalseExpression->getTypePointer()->setQualifier(mType.getQualifier());
+            return mFalseExpression;
+        }
+    }
+    return this;
+}
+
 void TIntermSwizzle::promote()
 {
     TQualifier resultQualifier = EvqTemporary;
@@ -1116,7 +1134,8 @@ void TIntermBinary::promote()
     ASSERT(!isMultiplication() ||
            mOp == GetMulOpBasedOnOperands(mLeft->getType(), mRight->getType()));
 
-    // Comma is handled as a special case.
+    // Comma is handled as a special case. Note that the comma node qualifier depends on the shader
+    // version and so is not being set here.
     if (mOp == EOpComma)
     {
         setType(mRight->getType());
@@ -1351,7 +1370,7 @@ TIntermTyped *TIntermSwizzle::fold()
     TIntermConstantUnion *operandConstant = mOperand->getAsConstantUnion();
     if (operandConstant == nullptr)
     {
-        return nullptr;
+        return this;
     }
 
     TConstantUnion *constArray = new TConstantUnion[mSwizzleOffsets.size()];
@@ -1368,22 +1387,35 @@ TIntermTyped *TIntermBinary::fold(TDiagnostics *diagnostics)
     TIntermConstantUnion *rightConstant = mRight->getAsConstantUnion();
     switch (mOp)
     {
+        case EOpComma:
+        {
+            if (mLeft->hasSideEffects())
+            {
+                return this;
+            }
+            mRight->getTypePointer()->setQualifier(mType.getQualifier());
+            return mRight;
+        }
         case EOpIndexDirect:
         {
             if (leftConstant == nullptr || rightConstant == nullptr)
             {
-                return nullptr;
+                return this;
             }
             int index = rightConstant->getIConst(0);
 
             const TConstantUnion *constArray = leftConstant->foldIndexing(index);
+            if (!constArray)
+            {
+                return this;
+            }
             return CreateFoldedNode(constArray, this, mType.getQualifier());
         }
         case EOpIndexDirectStruct:
         {
             if (leftConstant == nullptr || rightConstant == nullptr)
             {
-                return nullptr;
+                return this;
             }
             const TFieldList &fields = mLeft->getType().getStruct()->fields();
             size_t index             = static_cast<size_t>(rightConstant->getIConst(0));
@@ -1400,15 +1432,19 @@ TIntermTyped *TIntermBinary::fold(TDiagnostics *diagnostics)
         case EOpIndexIndirect:
         case EOpIndexDirectInterfaceBlock:
             // Can never be constant folded.
-            return nullptr;
+            return this;
         default:
         {
             if (leftConstant == nullptr || rightConstant == nullptr)
             {
-                return nullptr;
+                return this;
             }
             TConstantUnion *constArray =
                 leftConstant->foldBinary(mOp, rightConstant, diagnostics, mLeft->getLine());
+            if (!constArray)
+            {
+                return this;
+            }
 
             // Nodes may be constant folded without being qualified as constant.
             return CreateFoldedNode(constArray, this, mType.getQualifier());
@@ -1421,7 +1457,7 @@ TIntermTyped *TIntermUnary::fold(TDiagnostics *diagnostics)
     TIntermConstantUnion *operandConstant = mOperand->getAsConstantUnion();
     if (operandConstant == nullptr)
     {
-        return nullptr;
+        return this;
     }
 
     TConstantUnion *constArray = nullptr;
@@ -1449,6 +1485,10 @@ TIntermTyped *TIntermUnary::fold(TDiagnostics *diagnostics)
             constArray = operandConstant->foldUnaryComponentWise(mOp, diagnostics);
             break;
     }
+    if (constArray == nullptr)
+    {
+        return this;
+    }
 
     // Nodes may be constant folded without being qualified as constant.
     return CreateFoldedNode(constArray, this, mType.getQualifier());
@@ -1461,7 +1501,7 @@ TIntermTyped *TIntermAggregate::fold(TDiagnostics *diagnostics)
     {
         if (param->getAsConstantUnion() == nullptr)
         {
-            return nullptr;
+            return this;
         }
     }
     TConstantUnion *constArray = nullptr;
@@ -2617,6 +2657,42 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateConstructor(TIntermAggregate
     return resultArray;
 }
 
+bool TIntermAggregate::CanFoldAggregateBuiltInOp(TOperator op)
+{
+    switch (op)
+    {
+        case EOpAtan:
+        case EOpPow:
+        case EOpMod:
+        case EOpMin:
+        case EOpMax:
+        case EOpClamp:
+        case EOpMix:
+        case EOpStep:
+        case EOpSmoothStep:
+        case EOpLdexp:
+        case EOpMulMatrixComponentWise:
+        case EOpOuterProduct:
+        case EOpEqualComponentWise:
+        case EOpNotEqualComponentWise:
+        case EOpLessThanComponentWise:
+        case EOpLessThanEqualComponentWise:
+        case EOpGreaterThanComponentWise:
+        case EOpGreaterThanEqualComponentWise:
+        case EOpDistance:
+        case EOpDot:
+        case EOpCross:
+        case EOpFaceforward:
+        case EOpReflect:
+        case EOpRefract:
+        case EOpBitfieldExtract:
+        case EOpBitfieldInsert:
+            return true;
+        default:
+            return false;
+    }
+}
+
 // static
 TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *aggregate,
                                                            TDiagnostics *diagnostics)

src/compiler/translator/IntermNode.h

@@ -630,6 +630,7 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
 
     bool hasSideEffects() const override;
 
+    static bool CanFoldAggregateBuiltInOp(TOperator op);
     TIntermTyped *fold(TDiagnostics *diagnostics);
 
     TIntermSequence *getSequence() override { return &mArguments; }
@@ -831,13 +832,15 @@ class TIntermTernary : public TIntermTyped
                mFalseExpression->hasSideEffects();
     }
 
-    static TQualifier DetermineQualifier(TIntermTyped *cond,
-                                         TIntermTyped *trueExpression,
-                                         TIntermTyped *falseExpression);
+    TIntermTyped *fold();
 
   private:
     TIntermTernary(const TIntermTernary &node);  // Note: not deleted, just private!
 
+    static TQualifier DetermineQualifier(TIntermTyped *cond,
+                                         TIntermTyped *trueExpression,
+                                         TIntermTyped *falseExpression);
+
     TIntermTyped *mCondition;
     TIntermTyped *mTrueExpression;
     TIntermTyped *mFalseExpression;

src/compiler/translator/Intermediate.cpp

@@ -26,47 +26,6 @@ namespace sh
 //
 /////////////////////////////////////////////////////////////////////////////
 
-//
-// Add a terminal node for an identifier in an expression.
-//
-// Returns the added node.
-//
-TIntermSymbol *TIntermediate::addSymbol(int id,
-                                        const TString &name,
-                                        const TType &type,
-                                        const TSourceLoc &line)
-{
-    TIntermSymbol *node = new TIntermSymbol(id, name, type);
-    node->setLine(line);
-
-    return node;
-}
-
-//
-// Connect two nodes through an index operator, where the left node is the base
-// of an array or struct, and the right node is a direct or indirect offset.
-//
-// Returns the added node.
-// The caller should set the type of the returned node.
-//
-TIntermTyped *TIntermediate::addIndex(TOperator op,
-                                      TIntermTyped *base,
-                                      TIntermTyped *index,
-                                      const TSourceLoc &line,
-                                      TDiagnostics *diagnostics)
-{
-    TIntermBinary *node = new TIntermBinary(op, base, index);
-    node->setLine(line);
-
-    TIntermTyped *folded = node->fold(diagnostics);
-    if (folded)
-    {
-        return folded;
-    }
-
-    return node;
-}
-
 // If the input node is nullptr, return nullptr.
 // If the input node is a block node, return it.
 // If the input node is not a block node, put it inside a block node and return that.
@@ -84,80 +43,6 @@ TIntermBlock *TIntermediate::EnsureBlock(TIntermNode *node)
     return blockNode;
 }
 
-TIntermTyped *TIntermediate::AddComma(TIntermTyped *left,
-                                      TIntermTyped *right,
-                                      const TSourceLoc &line,
-                                      int shaderVersion)
-{
-    TIntermTyped *commaNode = nullptr;
-    if (!left->hasSideEffects())
-    {
-        commaNode = right;
-    }
-    else
-    {
-        commaNode = new TIntermBinary(EOpComma, left, right);
-        commaNode->setLine(line);
-    }
-    TQualifier resultQualifier = TIntermBinary::GetCommaQualifier(shaderVersion, left, right);
-    commaNode->getTypePointer()->setQualifier(resultQualifier);
-    return commaNode;
-}
-
-// For "?:" test nodes.  There are three children; a condition,
-// a true path, and a false path.  The two paths are specified
-// as separate parameters.
-//
-// Returns the ternary node created, or one of trueExpression and falseExpression if the expression
-// could be folded.
-TIntermTyped *TIntermediate::AddTernarySelection(TIntermTyped *cond,
-                                                 TIntermTyped *trueExpression,
-                                                 TIntermTyped *falseExpression,
-                                                 const TSourceLoc &line)
-{
-    // Note that the node resulting from here can be a constant union without being qualified as
-    // constant.
-    if (cond->getAsConstantUnion())
-    {
-        TQualifier resultQualifier =
-            TIntermTernary::DetermineQualifier(cond, trueExpression, falseExpression);
-        if (cond->getAsConstantUnion()->getBConst(0))
-        {
-            trueExpression->getTypePointer()->setQualifier(resultQualifier);
-            return trueExpression;
-        }
-        else
-        {
-            falseExpression->getTypePointer()->setQualifier(resultQualifier);
-            return falseExpression;
-        }
-    }
-
-    // Make a ternary node.
-    TIntermTernary *node = new TIntermTernary(cond, trueExpression, falseExpression);
-    node->setLine(line);
-
-    return node;
-}
-
-TIntermSwitch *TIntermediate::addSwitch(TIntermTyped *init,
-                                        TIntermBlock *statementList,
-                                        const TSourceLoc &line)
-{
-    TIntermSwitch *node = new TIntermSwitch(init, statementList);
-    node->setLine(line);
-
-    return node;
-}
-
-TIntermCase *TIntermediate::addCase(TIntermTyped *condition, const TSourceLoc &line)
-{
-    TIntermCase *node = new TIntermCase(condition);
-    node->setLine(line);
-
-    return node;
-}
-
 //
 // Constant terminal nodes.  Has a union that contains bool, float or int constants
 //
@@ -174,68 +59,4 @@ TIntermConstantUnion *TIntermediate::addConstantUnion(const TConstantUnion *cons
     return node;
 }
 
-TIntermTyped *TIntermediate::AddSwizzle(TIntermTyped *baseExpression,
-                                        const TVectorFields &fields,
-                                        const TSourceLoc &dotLocation)
-{
-    TVector<int> fieldsVector;
-    for (int i = 0; i < fields.num; ++i)
-    {
-        fieldsVector.push_back(fields.offsets[i]);
-    }
-    TIntermSwizzle *node = new TIntermSwizzle(baseExpression, fieldsVector);
-    node->setLine(dotLocation);
-
-    TIntermTyped *folded = node->fold();
-    if (folded)
-    {
-        return folded;
-    }
-
-    return node;
-}
-
-TIntermTyped *TIntermediate::foldAggregateBuiltIn(TIntermAggregate *aggregate,
-                                                  TDiagnostics *diagnostics)
-{
-    switch (aggregate->getOp())
-    {
-        case EOpAtan:
-        case EOpPow:
-        case EOpMod:
-        case EOpMin:
-        case EOpMax:
-        case EOpClamp:
-        case EOpMix:
-        case EOpStep:
-        case EOpSmoothStep:
-        case EOpLdexp:
-        case EOpMulMatrixComponentWise:
-        case EOpOuterProduct:
-        case EOpEqualComponentWise:
-        case EOpNotEqualComponentWise:
-        case EOpLessThanComponentWise:
-        case EOpLessThanEqualComponentWise:
-        case EOpGreaterThanComponentWise:
-        case EOpGreaterThanEqualComponentWise:
-        case EOpDistance:
-        case EOpDot:
-        case EOpCross:
-        case EOpFaceforward:
-        case EOpReflect:
-        case EOpRefract:
-        case EOpBitfieldExtract:
-        case EOpBitfieldInsert:
-            return aggregate->fold(diagnostics);
-        default:
-            // TODO: Add support for folding array constructors
-            if (aggregate->isConstructor() && !aggregate->isArray())
-            {
-                return aggregate->fold(diagnostics);
-            }
-            // Constant folding not supported for the built-in.
-            return nullptr;
-    }
-}
-
 }  // namespace sh

src/compiler/translator/Intermediate.h

@@ -12,12 +12,6 @@
 namespace sh
 {
 
-struct TVectorFields
-{
-    int offsets[4];
-    int num;
-};
-
 //
 // Set of helper functions to help build the tree.
 //
@@ -27,35 +21,11 @@ class TIntermediate
     POOL_ALLOCATOR_NEW_DELETE();
     TIntermediate() {}
 
-    TIntermSymbol *addSymbol(int id, const TString &, const TType &, const TSourceLoc &);
-    TIntermTyped *addIndex(TOperator op,
-                           TIntermTyped *base,
-                           TIntermTyped *index,
-                           const TSourceLoc &line,
-                           TDiagnostics *diagnostics);
     static TIntermBlock *EnsureBlock(TIntermNode *node);
-    static TIntermTyped *AddTernarySelection(TIntermTyped *cond,
-                                             TIntermTyped *trueExpression,
-                                             TIntermTyped *falseExpression,
-                                             const TSourceLoc &line);
-    TIntermSwitch *addSwitch(TIntermTyped *init,
-                             TIntermBlock *statementList,
-                             const TSourceLoc &line);
-    TIntermCase *addCase(TIntermTyped *condition, const TSourceLoc &line);
-    static TIntermTyped *AddComma(TIntermTyped *left,
-                                  TIntermTyped *right,
-                                  const TSourceLoc &line,
-                                  int shaderVersion);
     TIntermConstantUnion *addConstantUnion(const TConstantUnion *constantUnion,
                                            const TType &type,
                                            const TSourceLoc &line);
 
-    static TIntermTyped *AddSwizzle(TIntermTyped *baseExpression,
-                                    const TVectorFields &fields,
-                                    const TSourceLoc &dotLocation);
-
-    TIntermTyped *foldAggregateBuiltIn(TIntermAggregate *aggregate, TDiagnostics *diagnostics);
-
   private:
     void operator=(TIntermediate &);  // prevent assignments
 };

src/compiler/translator/ParseContext.h

@@ -98,7 +98,11 @@ class TParseContext : angle::NonCopyable
                                           const TString *name,
                                           const TSymbol *symbol);
 
-    bool parseVectorFields(const TString &, int vecSize, TVectorFields &, const TSourceLoc &line);
+    // Look at a '.' field selector string and change it into offsets for a vector.
+    bool parseVectorFields(const TSourceLoc &line,
+                           const TString &compString,
+                           int vecSize,
+                           TVector<int> *fieldOffsets);
 
     void assignError(const TSourceLoc &line, const char *op, TString left, TString right);
     void unaryOpError(const TSourceLoc &line, const char *op, TString operand);