Track parameter qualifiers of functions in call nodes

src/compiler/translator/ArrayReturnValueToOutParameter.cpp

@@ -128,9 +128,16 @@ bool ArrayReturnValueToOutParameterTraverser::visitFunctionPrototype(Visit visit
             changedFunction.returnValueVariable =
                 new TVariable(mSymbolTable, mReturnValueVariableName, returnValueVariableType,
                               SymbolType::AngleInternal);
-            changedFunction.func = new TFunction(mSymbolTable, &node->getFunction()->name(),
-                                                 StaticType::GetBasic<EbtVoid>(),
-                                                 node->getFunction()->symbolType(), false);
+            TFunction *func = new TFunction(mSymbolTable, &node->getFunction()->name(),
+                                            StaticType::GetBasic<EbtVoid>(),
+                                            node->getFunction()->symbolType(), false);
+            for (size_t i = 0; i < node->getFunction()->getParamCount(); ++i)
+            {
+                func->addParameter(node->getFunction()->getParam(i));
+            }
+            func->addParameter(TConstParameter(
+                mReturnValueVariableName, static_cast<const TType *>(returnValueVariableType)));
+            changedFunction.func                = func;
             mChangedFunctions[functionId.get()] = changedFunction;
         }
         TIntermFunctionPrototype *replacement =

src/compiler/translator/Compiler.cpp

@@ -402,7 +402,7 @@ bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
     }
 
     if (shouldRunLoopAndIndexingValidation(compileOptions) &&
-        !ValidateLimitations(root, shaderType, &symbolTable, shaderVersion, &mDiagnostics))
+        !ValidateLimitations(root, shaderType, &symbolTable, &mDiagnostics))
     {
         return false;
     }
@@ -533,14 +533,14 @@ bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
     SimplifyLoopConditions(root,
                            IntermNodePatternMatcher::kMultiDeclaration |
                                IntermNodePatternMatcher::kArrayLengthMethod | simplifyScalarized,
-                           &getSymbolTable(), getShaderVersion());
+                           &getSymbolTable());
 
     // Note that separate declarations need to be run before other AST transformations that
     // generate new statements from expressions.
     SeparateDeclarations(root);
 
     SplitSequenceOperator(root, IntermNodePatternMatcher::kArrayLengthMethod | simplifyScalarized,
-                          &getSymbolTable(), getShaderVersion());
+                          &getSymbolTable());
 
     RemoveArrayLengthMethod(root);
 
@@ -630,7 +630,7 @@ bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
             SimplifyLoopConditions(root,
                                    IntermNodePatternMatcher::kArrayDeclaration |
                                        IntermNodePatternMatcher::kNamelessStructDeclaration,
-                                   &getSymbolTable(), getShaderVersion());
+                                   &getSymbolTable());
         }
 
         InitializeUninitializedLocals(root, getShaderVersion(), canUseLoopsToInitialize,

src/compiler/translator/EmulatePrecision.cpp

@@ -470,9 +470,11 @@ bool ParentConstructorTakesCareOfRounding(TIntermNode *parent, TIntermTyped *nod
 
 }  // namespace anonymous
 
-EmulatePrecision::EmulatePrecision(TSymbolTable *symbolTable, int shaderVersion)
-    : TLValueTrackingTraverser(true, true, true, symbolTable, shaderVersion),
-      mDeclaringVariables(false)
+EmulatePrecision::EmulatePrecision(TSymbolTable *symbolTable)
+    : TLValueTrackingTraverser(true, true, true, symbolTable),
+      mDeclaringVariables(false),
+      mParamXName(NewPoolTString("x")),
+      mParamYName(NewPoolTString("y"))
 {
 }
 
@@ -705,17 +707,23 @@ bool EmulatePrecision::SupportedInLanguage(const ShShaderOutput outputLanguage)
     }
 }
 
-TFunction *EmulatePrecision::getInternalFunction(TString *functionName,
-                                                 const TType &returnType,
-                                                 TIntermSequence *arguments,
-                                                 bool knownToNotHaveSideEffects)
+const TFunction *EmulatePrecision::getInternalFunction(TString *functionName,
+                                                       const TType &returnType,
+                                                       TIntermSequence *arguments,
+                                                       const TVector<TConstParameter> &parameters,
+                                                       bool knownToNotHaveSideEffects)
 {
     TString mangledName = TFunction::GetMangledNameFromCall(*functionName, *arguments);
     if (mInternalFunctions.find(mangledName) == mInternalFunctions.end())
     {
-        mInternalFunctions[mangledName] =
-            new TFunction(mSymbolTable, functionName, new TType(returnType),
-                          SymbolType::AngleInternal, knownToNotHaveSideEffects);
+        TFunction *func = new TFunction(mSymbolTable, functionName, new TType(returnType),
+                                        SymbolType::AngleInternal, knownToNotHaveSideEffects);
+        ASSERT(parameters.size() == arguments->size());
+        for (size_t i = 0; i < parameters.size(); ++i)
+        {
+            func->addParameter(parameters[i]);
+        }
+        mInternalFunctions[mangledName] = func;
     }
     return mInternalFunctions[mangledName];
 }
@@ -730,8 +738,16 @@ TIntermAggregate *EmulatePrecision::createRoundingFunctionCallNode(TIntermTyped
     TString *functionName      = NewPoolTString(roundFunctionName);
     TIntermSequence *arguments = new TIntermSequence();
     arguments->push_back(roundedChild);
+
+    TVector<TConstParameter> parameters;
+    TType *paramType = new TType(roundedChild->getType());
+    paramType->setPrecision(EbpHigh);
+    paramType->setQualifier(EvqIn);
+    parameters.push_back(TConstParameter(mParamXName, static_cast<const TType *>(paramType)));
+
     return TIntermAggregate::CreateRawFunctionCall(
-        *getInternalFunction(functionName, roundedChild->getType(), arguments, true), arguments);
+        *getInternalFunction(functionName, roundedChild->getType(), arguments, parameters, true),
+        arguments);
 }
 
 TIntermAggregate *EmulatePrecision::createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
@@ -747,8 +763,20 @@ TIntermAggregate *EmulatePrecision::createCompoundAssignmentFunctionCallNode(TIn
     TIntermSequence *arguments = new TIntermSequence();
     arguments->push_back(left);
     arguments->push_back(right);
+
+    TVector<TConstParameter> parameters;
+    TType *leftParamType = new TType(left->getType());
+    leftParamType->setPrecision(EbpHigh);
+    leftParamType->setQualifier(EvqOut);
+    parameters.push_back(TConstParameter(mParamXName, static_cast<const TType *>(leftParamType)));
+    TType *rightParamType = new TType(right->getType());
+    rightParamType->setPrecision(EbpHigh);
+    rightParamType->setQualifier(EvqIn);
+    parameters.push_back(TConstParameter(mParamYName, static_cast<const TType *>(rightParamType)));
+
     return TIntermAggregate::CreateRawFunctionCall(
-        *getInternalFunction(functionName, left->getType(), arguments, false), arguments);
+        *getInternalFunction(functionName, left->getType(), arguments, parameters, false),
+        arguments);
 }
 
 }  // namespace sh

src/compiler/translator/EmulatePrecision.h

@@ -24,7 +24,7 @@ namespace sh
 class EmulatePrecision : public TLValueTrackingTraverser
 {
   public:
-    EmulatePrecision(TSymbolTable *symbolTable, int shaderVersion);
+    EmulatePrecision(TSymbolTable *symbolTable);
 
     void visitSymbol(TIntermSymbol *node) override;
     bool visitBinary(Visit visit, TIntermBinary *node) override;
@@ -59,10 +59,11 @@ class EmulatePrecision : public TLValueTrackingTraverser
         }
     };
 
-    TFunction *getInternalFunction(TString *functionName,
-                                   const TType &returnType,
-                                   TIntermSequence *arguments,
-                                   bool knownToNotHaveSideEffects);
+    const TFunction *getInternalFunction(TString *functionName,
+                                         const TType &returnType,
+                                         TIntermSequence *arguments,
+                                         const TVector<TConstParameter> &parameters,
+                                         bool knownToNotHaveSideEffects);
     TIntermAggregate *createRoundingFunctionCallNode(TIntermTyped *roundedChild);
     TIntermAggregate *createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
                                                                TIntermTyped *right,
@@ -75,9 +76,12 @@ class EmulatePrecision : public TLValueTrackingTraverser
     EmulationSet mEmulateCompoundDiv;
 
     // Map from mangled name to function.
-    TMap<TString, TFunction *> mInternalFunctions;
+    TMap<TString, const TFunction *> mInternalFunctions;
 
     bool mDeclaringVariables;
+
+    const TString *mParamXName;
+    const TString *mParamYName;
 };
 
 }  // namespace sh

src/compiler/translator/IntermNode.cpp

@@ -364,7 +364,7 @@ TIntermAggregate *TIntermAggregate::CreateConstructor(const TType &type,
     return new TIntermAggregate(nullptr, type, EOpConstruct, arguments);
 }
 
-TIntermAggregate *TIntermAggregate::Create(const TType &type,
+TIntermAggregate *TIntermAggregate::Create(const TFunction &func,
                                            TOperator op,
                                            TIntermSequence *arguments)
 {
@@ -372,7 +372,7 @@ TIntermAggregate *TIntermAggregate::Create(const TType &type,
     ASSERT(op != EOpCallInternalRawFunction);  // Should use CreateRawFunctionCall
     ASSERT(op != EOpCallBuiltInFunction);  // Should use CreateBuiltInFunctionCall
     ASSERT(op != EOpConstruct);            // Should use CreateConstructor
-    return new TIntermAggregate(nullptr, type, op, arguments);
+    return new TIntermAggregate(&func, func.getReturnType(), op, arguments);
 }
 
 TIntermAggregate::TIntermAggregate(const TFunction *func,

src/compiler/translator/IntermNode.h

@@ -575,7 +575,9 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
                                                        TIntermSequence *arguments);
     static TIntermAggregate *CreateConstructor(const TType &type,
                                                TIntermSequence *arguments);
-    static TIntermAggregate *Create(const TType &type, TOperator op, TIntermSequence *arguments);
+    static TIntermAggregate *Create(const TFunction &func,
+                                    TOperator op,
+                                    TIntermSequence *arguments);
     ~TIntermAggregate() {}
 
     // Note: only supported for nodes that can be a part of an expression.

src/compiler/translator/IntermNode_util.cpp

@@ -264,7 +264,7 @@ TIntermTyped *CreateBuiltInFunctionCallNode(const TString &name,
         {
             return new TIntermUnary(op, arguments->at(0)->getAsTyped());
         }
-        return TIntermAggregate::Create(fn->getReturnType(), op, arguments);
+        return TIntermAggregate::Create(*fn, op, arguments);
     }
     return TIntermAggregate::CreateBuiltInFunctionCall(*fn, arguments);
 }

src/compiler/translator/IntermTraverse.cpp

@@ -176,24 +176,6 @@ void TIntermTraverser::insertStatementInParentBlock(TIntermNode *statement)
     insertStatementsInParentBlock(insertions);
 }
 
-void TLValueTrackingTraverser::addToFunctionMap(const TSymbolUniqueId &id,
-                                                TIntermSequence *paramSequence)
-{
-    mFunctionMap[id.get()] = paramSequence;
-}
-
-bool TLValueTrackingTraverser::isInFunctionMap(const TIntermAggregate *callNode) const
-{
-    ASSERT(callNode->getOp() == EOpCallFunctionInAST);
-    return (mFunctionMap.find(callNode->getFunction()->uniqueId().get()) != mFunctionMap.end());
-}
-
-TIntermSequence *TLValueTrackingTraverser::getFunctionParameters(const TIntermAggregate *callNode)
-{
-    ASSERT(isInFunctionMap(callNode));
-    return mFunctionMap[callNode->getFunction()->uniqueId().get()];
-}
-
 void TLValueTrackingTraverser::setInFunctionCallOutParameter(bool inOutParameter)
 {
     mInFunctionCallOutParameter = inOutParameter;
@@ -662,24 +644,14 @@ void TIntermTraverser::queueReplacementWithParent(TIntermNode *parent,
 TLValueTrackingTraverser::TLValueTrackingTraverser(bool preVisit,
                                                    bool inVisit,
                                                    bool postVisit,
-                                                   TSymbolTable *symbolTable,
-                                                   int shaderVersion)
+                                                   TSymbolTable *symbolTable)
     : TIntermTraverser(preVisit, inVisit, postVisit, symbolTable),
       mOperatorRequiresLValue(false),
-      mInFunctionCallOutParameter(false),
-      mShaderVersion(shaderVersion)
+      mInFunctionCallOutParameter(false)
 {
     ASSERT(symbolTable);
 }
 
-void TLValueTrackingTraverser::traverseFunctionPrototype(TIntermFunctionPrototype *node)
-{
-    TIntermSequence *sequence = node->getSequence();
-    addToFunctionMap(node->getFunction()->uniqueId(), sequence);
-
-    TIntermTraverser::traverseFunctionPrototype(node);
-}
-
 void TLValueTrackingTraverser::traverseAggregate(TIntermAggregate *node)
 {
     ScopedNodeInTraversalPath addToPath(this, node);
@@ -693,81 +665,31 @@ void TLValueTrackingTraverser::traverseAggregate(TIntermAggregate *node)
 
     if (visit)
     {
-        if (node->getOp() == EOpCallFunctionInAST)
+        size_t paramIndex = 0u;
+        for (auto *child : *sequence)
         {
-            if (isInFunctionMap(node))
+            if (node->getFunction())
             {
-                TIntermSequence *params             = getFunctionParameters(node);
-                TIntermSequence::iterator paramIter = params->begin();
-                for (auto *child : *sequence)
-                {
-                    ASSERT(paramIter != params->end());
-                    TQualifier qualifier = (*paramIter)->getAsTyped()->getQualifier();
-                    setInFunctionCallOutParameter(qualifier == EvqOut || qualifier == EvqInOut);
-
-                    child->traverse(this);
-                    if (visit && inVisit)
-                    {
-                        if (child != sequence->back())
-                            visit = visitAggregate(InVisit, node);
-                    }
-
-                    ++paramIter;
-                }
+                // Both built-ins and user defined functions should have the function symbol set.
+                ASSERT(paramIndex < node->getFunction()->getParamCount());
+                TQualifier qualifier =
+                    node->getFunction()->getParam(paramIndex).type->getQualifier();
+                setInFunctionCallOutParameter(qualifier == EvqOut || qualifier == EvqInOut);
+                ++paramIndex;
             }
             else
             {
-                // The node might not be in the function map in case we're in the middle of
-                // transforming the AST, and have inserted function call nodes without inserting the
-                // function definitions yet.
-                setInFunctionCallOutParameter(false);
-                for (auto *child : *sequence)
-                {
-                    child->traverse(this);
-                    if (visit && inVisit)
-                    {
-                        if (child != sequence->back())
-                            visit = visitAggregate(InVisit, node);
-                    }
-                }
+                ASSERT(node->isConstructor());
             }
 
-            setInFunctionCallOutParameter(false);
-        }
-        else
-        {
-            // Find the built-in function corresponding to this op so that we can determine the
-            // in/out qualifiers of its parameters.
-            const TFunction *builtInFunc = nullptr;
-            if (!node->isFunctionCall() && !node->isConstructor())
-            {
-                builtInFunc = static_cast<const TFunction *>(
-                    mSymbolTable->findBuiltIn(node->getSymbolTableMangledName(), mShaderVersion));
-            }
-
-            size_t paramIndex = 0;
-
-            for (auto *child : *sequence)
+            child->traverse(this);
+            if (visit && inVisit)
             {
-                // This assumes that raw functions called with
-                // EOpCallInternalRawFunction don't have out parameters.
-                TQualifier qualifier = EvqIn;
-                if (builtInFunc != nullptr)
-                    qualifier = builtInFunc->getParam(paramIndex).type->getQualifier();
-                setInFunctionCallOutParameter(qualifier == EvqOut || qualifier == EvqInOut);
-                child->traverse(this);
-
-                if (visit && inVisit)
-                {
-                    if (child != sequence->back())
-                        visit = visitAggregate(InVisit, node);
-                }
-
-                ++paramIndex;
+                if (child != sequence->back())
+                    visit = visitAggregate(InVisit, node);
             }
-
-            setInFunctionCallOutParameter(false);
         }
+        setInFunctionCallOutParameter(false);
     }
 
     if (visit && postVisit)

src/compiler/translator/IntermTraverse.h

@@ -284,13 +284,11 @@ class TLValueTrackingTraverser : public TIntermTraverser
     TLValueTrackingTraverser(bool preVisit,
                              bool inVisit,
                              bool postVisit,
-                             TSymbolTable *symbolTable,
-                             int shaderVersion);
+                             TSymbolTable *symbolTable);
     virtual ~TLValueTrackingTraverser() {}
 
     void traverseBinary(TIntermBinary *node) final;
     void traverseUnary(TIntermUnary *node) final;
-    void traverseFunctionPrototype(TIntermFunctionPrototype *node) final;
     void traverseAggregate(TIntermAggregate *node) final;
 
   protected:
@@ -309,27 +307,12 @@ class TLValueTrackingTraverser : public TIntermTraverser
     }
     bool operatorRequiresLValue() const { return mOperatorRequiresLValue; }
 
-    // Add a function encountered during traversal to the function map.
-    void addToFunctionMap(const TSymbolUniqueId &id, TIntermSequence *paramSequence);
-
-    // Return true if the prototype or definition of the function being called has been encountered
-    // during traversal.
-    bool isInFunctionMap(const TIntermAggregate *callNode) const;
-
-    // Return the parameters sequence from the function definition or prototype.
-    TIntermSequence *getFunctionParameters(const TIntermAggregate *callNode);
-
     // Track whether an l-value is required inside a function call.
     void setInFunctionCallOutParameter(bool inOutParameter);
     bool isInFunctionCallOutParameter() const;
 
     bool mOperatorRequiresLValue;
     bool mInFunctionCallOutParameter;
-
-    // Map from function symbol id values to their parameter sequences
-    TMap<int, TIntermSequence *> mFunctionMap;
-
-    const int mShaderVersion;
 };
 
 }  // namespace sh

src/compiler/translator/ParseContext.cpp

@@ -5854,7 +5854,7 @@ TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
                 else
                 {
                     TIntermAggregate *callNode =
-                        TIntermAggregate::Create(fnCandidate->getReturnType(), op, arguments);
+                        TIntermAggregate::Create(*fnCandidate, op, arguments);
                     callNode->setLine(loc);
 
                     // Some built-in functions have out parameters too.

src/compiler/translator/RemoveDynamicIndexing.cpp

@@ -23,6 +23,8 @@ namespace sh
 namespace
 {
 
+const TType *kIndexType = StaticType::Get<EbtInt, EbpHigh, EvqIn, 1, 1>();
+
 std::string GetIndexFunctionName(const TType &type, bool write)
 {
     TInfoSinkBase nameSink;
@@ -59,31 +61,11 @@ std::string GetIndexFunctionName(const TType &type, bool write)
     return nameSink.str();
 }
 
-TIntermSymbol *CreateBaseSymbol(const TType *type, TSymbolTable *symbolTable)
-{
-    TString *baseString = NewPoolTString("base");
-    TVariable *baseVariable =
-        new TVariable(symbolTable, baseString, type, SymbolType::AngleInternal);
-    return new TIntermSymbol(baseVariable);
-}
-
-TIntermSymbol *CreateIndexSymbol(TSymbolTable *symbolTable)
+TIntermSymbol *CreateParameterSymbol(const TConstParameter &parameter, TSymbolTable *symbolTable)
 {
-    TString *indexString     = NewPoolTString("index");
-    TVariable *indexVariable =
-        new TVariable(symbolTable, indexString, StaticType::Get<EbtInt, EbpHigh, EvqIn, 1, 1>(),
-                      SymbolType::AngleInternal);
-    return new TIntermSymbol(indexVariable);
-}
-
-TIntermSymbol *CreateValueSymbol(const TType &type, TSymbolTable *symbolTable)
-{
-    TString *valueString = NewPoolTString("value");
-    TType *valueType     = new TType(type);
-    valueType->setQualifier(EvqIn);
-    TVariable *valueVariable =
-        new TVariable(symbolTable, valueString, valueType, SymbolType::AngleInternal);
-    return new TIntermSymbol(valueVariable);
+    TVariable *variable =
+        new TVariable(symbolTable, parameter.name, parameter.type, SymbolType::AngleInternal);
+    return new TIntermSymbol(variable);
 }
 
 TIntermConstantUnion *CreateIntConstantNode(int i)
@@ -117,6 +99,20 @@ TType *GetFieldType(const TType &indexedType)
     }
 }
 
+const TType *GetBaseType(const TType &type, bool write)
+{
+    TType *baseType = new TType(type);
+    // Conservatively use highp here, even if the indexed type is not highp. That way the code can't
+    // end up using mediump version of an indexing function for a highp value, if both mediump and
+    // highp values are being indexed in the shader. For HLSL precision doesn't matter, but in
+    // principle this code could be used with multiple backends.
+    baseType->setPrecision(EbpHigh);
+    baseType->setQualifier(EvqInOut);
+    if (!write)
+        baseType->setQualifier(EvqIn);
+    return baseType;
+}
+
 // Generate a read or write function for one field in a vector/matrix.
 // Out-of-range indices are clamped. This is consistent with how ANGLE handles out-of-range
 // indices in other places.
@@ -167,7 +163,6 @@ TIntermFunctionDefinition *GetIndexFunctionDefinition(const TType &type,
 {
     ASSERT(!type.isArray());
 
-    const TType *fieldType = GetFieldType(type);
     int numCases    = 0;
     if (type.isMatrix())
     {
@@ -181,24 +176,14 @@ TIntermFunctionDefinition *GetIndexFunctionDefinition(const TType &type,
     std::string functionName                = GetIndexFunctionName(type, write);
     TIntermFunctionPrototype *prototypeNode = CreateInternalFunctionPrototypeNode(func);
 
-    TType *baseType = new TType(type);
-    // Conservatively use highp here, even if the indexed type is not highp. That way the code can't
-    // end up using mediump version of an indexing function for a highp value, if both mediump and
-    // highp values are being indexed in the shader. For HLSL precision doesn't matter, but in
-    // principle this code could be used with multiple backends.
-    baseType->setPrecision(EbpHigh);
-    baseType->setQualifier(EvqInOut);
-    if (!write)
-        baseType->setQualifier(EvqIn);
-
-    TIntermSymbol *baseParam = CreateBaseSymbol(baseType, symbolTable);
+    TIntermSymbol *baseParam = CreateParameterSymbol(func.getParam(0), symbolTable);
     prototypeNode->getSequence()->push_back(baseParam);
-    TIntermSymbol *indexParam = CreateIndexSymbol(symbolTable);
+    TIntermSymbol *indexParam = CreateParameterSymbol(func.getParam(1), symbolTable);
     prototypeNode->getSequence()->push_back(indexParam);
     TIntermSymbol *valueParam = nullptr;
     if (write)
     {
-        valueParam = CreateValueSymbol(*fieldType, symbolTable);
+        valueParam = CreateParameterSymbol(func.getParam(2), symbolTable);
         prototypeNode->getSequence()->push_back(valueParam);
     }
 
@@ -280,7 +265,6 @@ class RemoveDynamicIndexingTraverser : public TLValueTrackingTraverser
 {
   public:
     RemoveDynamicIndexingTraverser(TSymbolTable *symbolTable,
-                                   int shaderVersion,
                                    PerformanceDiagnostics *perfDiagnostics);
 
     bool visitBinary(Visit visit, TIntermBinary *node) override;
@@ -307,16 +291,22 @@ class RemoveDynamicIndexingTraverser : public TLValueTrackingTraverser
     bool mRemoveIndexSideEffectsInSubtree;
 
     PerformanceDiagnostics *mPerfDiagnostics;
+
+    const TString *mBaseName;
+    const TString *mIndexName;
+    const TString *mValueName;
 };
 
 RemoveDynamicIndexingTraverser::RemoveDynamicIndexingTraverser(
     TSymbolTable *symbolTable,
-    int shaderVersion,
     PerformanceDiagnostics *perfDiagnostics)
-    : TLValueTrackingTraverser(true, false, false, symbolTable, shaderVersion),
+    : TLValueTrackingTraverser(true, false, false, symbolTable),
       mUsedTreeInsertion(false),
       mRemoveIndexSideEffectsInSubtree(false),
-      mPerfDiagnostics(perfDiagnostics)
+      mPerfDiagnostics(perfDiagnostics),
+      mBaseName(NewPoolTString("base")),
+      mIndexName(NewPoolTString("index")),
+      mValueName(NewPoolTString("value"))
 {
 }
 
@@ -422,6 +412,9 @@ bool RemoveDynamicIndexingTraverser::visitBinary(Visit visit, TIntermBinary *nod
                 indexingFunction =
                     new TFunction(mSymbolTable, indexingFunctionName, GetFieldType(type),
                                   SymbolType::AngleInternal, true);
+                indexingFunction->addParameter(
+                    TConstParameter(mBaseName, GetBaseType(type, false)));
+                indexingFunction->addParameter(TConstParameter(mIndexName, kIndexType));
                 mIndexedVecAndMatrixTypes[type] = indexingFunction;
             }
             else
@@ -467,8 +460,15 @@ bool RemoveDynamicIndexingTraverser::visitBinary(Visit visit, TIntermBinary *nod
                     TString *functionName = NewPoolTString(
                         GetIndexFunctionName(node->getLeft()->getType(), true).c_str());
                     indexedWriteFunction =
-                        new TFunction(mSymbolTable, functionName, new TType(EbtVoid),
+                        new TFunction(mSymbolTable, functionName, StaticType::GetBasic<EbtVoid>(),
                                       SymbolType::AngleInternal, false);
+                    indexedWriteFunction->addParameter(
+                        TConstParameter(mBaseName, GetBaseType(type, true)));
+                    indexedWriteFunction->addParameter(TConstParameter(mIndexName, kIndexType));
+                    TType *valueType = GetFieldType(type);
+                    valueType->setQualifier(EvqIn);
+                    indexedWriteFunction->addParameter(
+                        TConstParameter(mValueName, static_cast<const TType *>(valueType)));
                     mWrittenVecAndMatrixTypes[type] = indexedWriteFunction;
                 }
                 else
@@ -532,10 +532,9 @@ void RemoveDynamicIndexingTraverser::nextIteration()
 
 void RemoveDynamicIndexing(TIntermNode *root,
                            TSymbolTable *symbolTable,
-                           int shaderVersion,
                            PerformanceDiagnostics *perfDiagnostics)
 {
-    RemoveDynamicIndexingTraverser traverser(symbolTable, shaderVersion, perfDiagnostics);
+    RemoveDynamicIndexingTraverser traverser(symbolTable, perfDiagnostics);
     do
     {
         traverser.nextIteration();

src/compiler/translator/RemoveDynamicIndexing.h

@@ -19,7 +19,6 @@ class PerformanceDiagnostics;
 
 void RemoveDynamicIndexing(TIntermNode *root,
                            TSymbolTable *symbolTable,
-                           int shaderVersion,
                            PerformanceDiagnostics *perfDiagnostics);
 
 }  // namespace sh

src/compiler/translator/SimplifyLoopConditions.cpp

@@ -25,8 +25,7 @@ class SimplifyLoopConditionsTraverser : public TLValueTrackingTraverser
 {
   public:
     SimplifyLoopConditionsTraverser(unsigned int conditionsToSimplifyMask,
-                                    TSymbolTable *symbolTable,
-                                    int shaderVersion);
+                                    TSymbolTable *symbolTable);
 
     void traverseLoop(TIntermLoop *node) override;
 
@@ -48,9 +47,8 @@ class SimplifyLoopConditionsTraverser : public TLValueTrackingTraverser
 
 SimplifyLoopConditionsTraverser::SimplifyLoopConditionsTraverser(
     unsigned int conditionsToSimplifyMask,
-    TSymbolTable *symbolTable,
-    int shaderVersion)
-    : TLValueTrackingTraverser(true, false, false, symbolTable, shaderVersion),
+    TSymbolTable *symbolTable)
+    : TLValueTrackingTraverser(true, false, false, symbolTable),
       mFoundLoopToChange(false),
       mInsideLoopInitConditionOrExpression(false),
       mConditionsToSimplify(conditionsToSimplifyMask)
@@ -292,10 +290,9 @@ void SimplifyLoopConditionsTraverser::traverseLoop(TIntermLoop *node)
 
 void SimplifyLoopConditions(TIntermNode *root,
                             unsigned int conditionsToSimplifyMask,
-                            TSymbolTable *symbolTable,
-                            int shaderVersion)
+                            TSymbolTable *symbolTable)
 {
-    SimplifyLoopConditionsTraverser traverser(conditionsToSimplifyMask, symbolTable, shaderVersion);
+    SimplifyLoopConditionsTraverser traverser(conditionsToSimplifyMask, symbolTable);
     root->traverse(&traverser);
     traverser.updateTree();
 }

src/compiler/translator/SimplifyLoopConditions.h

@@ -18,8 +18,7 @@ class TSymbolTable;
 
 void SimplifyLoopConditions(TIntermNode *root,
                             unsigned int conditionsToSimplify,
-                            TSymbolTable *symbolTable,
-                            int shaderVersion);
+                            TSymbolTable *symbolTable);
 }  // namespace sh
 
 #endif  // COMPILER_TRANSLATOR_SIMPLIFYLOOPCONDITIONS_H_

src/compiler/translator/SplitSequenceOperator.cpp

@@ -23,9 +23,7 @@ namespace
 class SplitSequenceOperatorTraverser : public TLValueTrackingTraverser
 {
   public:
-    SplitSequenceOperatorTraverser(unsigned int patternsToSplitMask,
-                                   TSymbolTable *symbolTable,
-                                   int shaderVersion);
+    SplitSequenceOperatorTraverser(unsigned int patternsToSplitMask, TSymbolTable *symbolTable);
 
     bool visitUnary(Visit visit, TIntermUnary *node) override;
     bool visitBinary(Visit visit, TIntermBinary *node) override;
@@ -45,9 +43,8 @@ class SplitSequenceOperatorTraverser : public TLValueTrackingTraverser
 };
 
 SplitSequenceOperatorTraverser::SplitSequenceOperatorTraverser(unsigned int patternsToSplitMask,
-                                                               TSymbolTable *symbolTable,
-                                                               int shaderVersion)
-    : TLValueTrackingTraverser(true, false, true, symbolTable, shaderVersion),
+                                                               TSymbolTable *symbolTable)
+    : TLValueTrackingTraverser(true, false, true, symbolTable),
       mFoundExpressionToSplit(false),
       mInsideSequenceOperator(0),
       mPatternToSplitMatcher(patternsToSplitMask)
@@ -151,12 +148,9 @@ bool SplitSequenceOperatorTraverser::visitTernary(Visit visit, TIntermTernary *n
 
 }  // namespace
 
-void SplitSequenceOperator(TIntermNode *root,
-                           int patternsToSplitMask,
-                           TSymbolTable *symbolTable,
-                           int shaderVersion)
+void SplitSequenceOperator(TIntermNode *root, int patternsToSplitMask, TSymbolTable *symbolTable)
 {
-    SplitSequenceOperatorTraverser traverser(patternsToSplitMask, symbolTable, shaderVersion);
+    SplitSequenceOperatorTraverser traverser(patternsToSplitMask, symbolTable);
     // Separate one expression at a time, and reset the traverser between iterations.
     do
     {

src/compiler/translator/SplitSequenceOperator.h

@@ -18,10 +18,7 @@ namespace sh
 class TIntermNode;
 class TSymbolTable;
 
-void SplitSequenceOperator(TIntermNode *root,
-                           int patternsToSplitMask,
-                           TSymbolTable *symbolTable,
-                           int shaderVersion);
+void SplitSequenceOperator(TIntermNode *root, int patternsToSplitMask, TSymbolTable *symbolTable);
 
 }  // namespace sh
 

src/compiler/translator/Symbol.cpp

@@ -135,18 +135,13 @@ TFunction::TFunction(TSymbolTable *symbolTable,
     ASSERT(name != nullptr || symbolType == SymbolType::AngleInternal || tOp != EOpNull);
 }
 
-//
-// Functions have buried pointers to delete.
-//
 TFunction::~TFunction()
 {
-    clearParameters();
+    // Just here to discourage the compiler from inlining it.
 }
 
 void TFunction::clearParameters()
 {
-    for (TParamList::iterator i = parameters.begin(); i != parameters.end(); ++i)
-        delete (*i).type;
     parameters.clear();
     mangledName = nullptr;
 }

src/compiler/translator/SymbolTable.cpp

@@ -25,7 +25,6 @@ class TSymbolTable::TSymbolTableLevel
 {
   public:
     TSymbolTableLevel() : mGlobalInvariant(false) {}
-    ~TSymbolTableLevel();
 
     bool insert(TSymbol *symbol);
 
@@ -62,15 +61,6 @@ class TSymbolTable::TSymbolTableLevel
     std::set<const char *, CharArrayComparator> mUnmangledBuiltInNames;
 };
 
-//
-// Symbol table levels are a map of pointers to symbols that have to be deleted.
-//
-TSymbolTable::TSymbolTableLevel::~TSymbolTableLevel()
-{
-    for (tLevel::iterator it = level.begin(); it != level.end(); ++it)
-        delete (*it).second;
-}
-
 bool TSymbolTable::TSymbolTableLevel::insert(TSymbol *symbol)
 {
     // returning true means symbol was added to the table

src/compiler/translator/TranslatorESSL.cpp

@@ -53,7 +53,7 @@ void TranslatorESSL::translate(TIntermBlock *root,
 
     if (precisionEmulation)
     {
-        EmulatePrecision emulatePrecision(&getSymbolTable(), shaderVer);
+        EmulatePrecision emulatePrecision(&getSymbolTable());
         root->traverse(&emulatePrecision);
         emulatePrecision.updateTree();
         emulatePrecision.writeEmulationHelpers(sink, shaderVer, SH_ESSL_OUTPUT);

src/compiler/translator/TranslatorGLSL.cpp

@@ -109,7 +109,7 @@ void TranslatorGLSL::translate(TIntermBlock *root,
 
     if (precisionEmulation)
     {
-        EmulatePrecision emulatePrecision(&getSymbolTable(), getShaderVersion());
+        EmulatePrecision emulatePrecision(&getSymbolTable());
         root->traverse(&emulatePrecision);
         emulatePrecision.updateTree();
         emulatePrecision.writeEmulationHelpers(sink, getShaderVersion(), getOutputType());

src/compiler/translator/TranslatorHLSL.cpp

@@ -51,13 +51,13 @@ void TranslatorHLSL::translate(TIntermBlock *root,
                            IntermNodePatternMatcher::kExpressionReturningArray |
                                IntermNodePatternMatcher::kUnfoldedShortCircuitExpression |
                                IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
-                           &getSymbolTable(), getShaderVersion());
+                           &getSymbolTable());
 
     SplitSequenceOperator(root,
                           IntermNodePatternMatcher::kExpressionReturningArray |
                               IntermNodePatternMatcher::kUnfoldedShortCircuitExpression |
                               IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
-                          &getSymbolTable(), getShaderVersion());
+                          &getSymbolTable());
 
     // Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf.
     UnfoldShortCircuitToIf(root, &getSymbolTable());
@@ -76,7 +76,7 @@ void TranslatorHLSL::translate(TIntermBlock *root,
     if (!shouldRunLoopAndIndexingValidation(compileOptions))
     {
         // HLSL doesn't support dynamic indexing of vectors and matrices.
-        RemoveDynamicIndexing(root, &getSymbolTable(), getShaderVersion(), perfDiagnostics);
+        RemoveDynamicIndexing(root, &getSymbolTable(), perfDiagnostics);
     }
 
     // Work around D3D9 bug that would manifest in vertex shaders with selection blocks which
@@ -106,7 +106,7 @@ void TranslatorHLSL::translate(TIntermBlock *root,
 
     if (precisionEmulation)
     {
-        EmulatePrecision emulatePrecision(&getSymbolTable(), getShaderVersion());
+        EmulatePrecision emulatePrecision(&getSymbolTable());
         root->traverse(&emulatePrecision);
         emulatePrecision.updateTree();
         emulatePrecision.writeEmulationHelpers(getInfoSink().obj, getShaderVersion(),

src/compiler/translator/ValidateLimitations.cpp

@@ -72,7 +72,6 @@ class ValidateLimitationsTraverser : public TLValueTrackingTraverser
   public:
     ValidateLimitationsTraverser(sh::GLenum shaderType,
                                  TSymbolTable *symbolTable,
-                                 int shaderVersion,
                                  TDiagnostics *diagnostics);
 
     void visitSymbol(TIntermSymbol *node) override;
@@ -104,9 +103,8 @@ class ValidateLimitationsTraverser : public TLValueTrackingTraverser
 
 ValidateLimitationsTraverser::ValidateLimitationsTraverser(sh::GLenum shaderType,
                                                            TSymbolTable *symbolTable,
-                                                           int shaderVersion,
                                                            TDiagnostics *diagnostics)
-    : TLValueTrackingTraverser(true, false, false, symbolTable, shaderVersion),
+    : TLValueTrackingTraverser(true, false, false, symbolTable),
       mShaderType(shaderType),
       mDiagnostics(diagnostics)
 {
@@ -427,10 +425,9 @@ bool ValidateLimitationsTraverser::validateIndexing(TIntermBinary *node)
 bool ValidateLimitations(TIntermNode *root,
                          GLenum shaderType,
                          TSymbolTable *symbolTable,
-                         int shaderVersion,
                          TDiagnostics *diagnostics)
 {
-    ValidateLimitationsTraverser validate(shaderType, symbolTable, shaderVersion, diagnostics);
+    ValidateLimitationsTraverser validate(shaderType, symbolTable, diagnostics);
     root->traverse(&validate);
     return diagnostics->numErrors() == 0;
 }

src/compiler/translator/ValidateLimitations.h

@@ -19,7 +19,6 @@ class TDiagnostics;
 bool ValidateLimitations(TIntermNode *root,
                          GLenum shaderType,
                          TSymbolTable *symbolTable,
-                         int shaderVersion,
                          TDiagnostics *diagnostics);
 
 }  // namespace sh

src/tests/compiler_tests/HLSLOutput_test.cpp

@@ -115,3 +115,44 @@ TEST_F(HLSLOutputTest, ArrayOfArraysStatement)
         })";
     compile(shaderString);
 }
+
+// Test dynamic indexing of a vector. This makes sure that helper functions added for dynamic
+// indexing have correct data that subsequent traversal steps rely on.
+TEST_F(HLSLOutputTest, VectorDynamicIndexing)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision mediump float;
+        out vec4 outColor;
+        uniform int i;
+        void main()
+        {
+            vec4 foo = vec4(0.0, 0.0, 0.0, 1.0);
+            foo[i] = foo[i + 1];
+            outColor = foo;
+        })";
+    compile(shaderString);
+}
+
+// Test returning an array from a user-defined function. This makes sure that function symbols are
+// changed consistently when the user-defined function is changed to have an array out parameter.
+TEST_F(HLSLOutputTest, ArrayReturnValue)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision mediump float;
+        uniform float u;
+        out vec4 outColor;
+
+        float[2] getArray(float f)
+        {
+            return float[2](f, f + 1.0);
+        }
+
+        void main()
+        {
+            float[2] arr = getArray(u);
+            outColor = vec4(arr[0], arr[1], 0.0, 1.0);
+        })";
+    compile(shaderString);
+}

src/tests/compiler_tests/IntermNode_test.cpp

@@ -60,6 +60,16 @@ class IntermNodeTest : public testing::Test
         return createTestSymbol(type);
     }
 
+    TFunction *createTestBuiltInFunction(const TType &returnType, const TIntermSequence &args)
+    {
+        // We're using a dummy symbol table similarly as for creating symbol nodes.
+        TString *name = NewPoolTString("testFunc");
+        TSymbolTable symbolTable;
+        TFunction *func =
+            new TFunction(&symbolTable, name, new TType(returnType), SymbolType::BuiltIn, true);
+        return func;
+    }
+
     void checkTypeEqualWithQualifiers(const TType &original, const TType &copy)
     {
         ASSERT_EQ(original, copy);
@@ -200,8 +210,11 @@ TEST_F(IntermNodeTest, DeepCopyAggregateNode)
     originalSeq->push_back(createTestSymbol());
     originalSeq->push_back(createTestSymbol());
     originalSeq->push_back(createTestSymbol());
-    TIntermAggregate *original =
-        TIntermAggregate::Create(originalSeq->at(0)->getAsTyped()->getType(), EOpMix, originalSeq);
+
+    TFunction *mix =
+        createTestBuiltInFunction(originalSeq->back()->getAsTyped()->getType(), *originalSeq);
+
+    TIntermAggregate *original = TIntermAggregate::Create(*mix, EOpMix, originalSeq);
     original->setLine(getTestSourceLoc());
 
     TIntermTyped *copyTyped = original->deepCopy();