1 files changed, 41 insertions, 51 deletions

diff --git a/gfx/angle/src/compiler/translator/ArrayReturnValueToOutParameter.cpp b/gfx/angle/src/compiler/translator/ArrayReturnValueToOutParameter.cpp
index 766f700ee..af5bb9ce3 100755
--- a/gfx/angle/src/compiler/translator/ArrayReturnValueToOutParameter.cpp
+++ b/gfx/angle/src/compiler/translator/ArrayReturnValueToOutParameter.cpp
@@ -10,9 +10,6 @@
 
 #include "compiler/translator/IntermNode.h"
 
-namespace sh
-{
-
 namespace
 {
 
@@ -44,7 +41,8 @@ TIntermAggregate *CreateReplacementCall(TIntermAggregate *originalCall, TIntermT
     TIntermAggregate *replacementCall = new TIntermAggregate(EOpFunctionCall);
     replacementCall->setType(TType(EbtVoid));
     replacementCall->setUserDefined();
-    *replacementCall->getFunctionSymbolInfo() = *originalCall->getFunctionSymbolInfo();
+    replacementCall->setNameObj(originalCall->getNameObj());
+    replacementCall->setFunctionId(originalCall->getFunctionId());
     replacementCall->setLine(originalCall->getLine());
     TIntermSequence *replacementParameters = replacementCall->getSequence();
     TIntermSequence *originalParameters = originalCall->getSequence();
@@ -63,7 +61,6 @@ class ArrayReturnValueToOutParameterTraverser : private TIntermTraverser
   private:
     ArrayReturnValueToOutParameterTraverser();
 
-    bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *node) override;
     bool visitBranch(Visit visit, TIntermBranch *node) override;
     bool visitBinary(Visit visit, TIntermBinary *node) override;
@@ -85,47 +82,35 @@ ArrayReturnValueToOutParameterTraverser::ArrayReturnValueToOutParameterTraverser
 {
 }
 
-bool ArrayReturnValueToOutParameterTraverser::visitFunctionDefinition(
-    Visit visit,
-    TIntermFunctionDefinition *node)
+bool ArrayReturnValueToOutParameterTraverser::visitAggregate(Visit visit, TIntermAggregate *node)
 {
-    if (node->isArray() && visit == PreVisit)
+    if (visit == PreVisit)
     {
-        // Replace the parameters child node of the function definition with another node
-        // that has the out parameter added.
-        // Also set the function to return void.
-
-        TIntermAggregate *params = node->getFunctionParameters();
-        ASSERT(params != nullptr && params->getOp() == EOpParameters);
+        if (node->isArray())
+        {
+            if (node->getOp() == EOpFunction)
+            {
+                // Replace the parameters child node of the function definition with another node
+                // that has the out parameter added.
+                // Also set the function to return void.
 
-        TIntermAggregate *replacementParams = new TIntermAggregate;
-        replacementParams->setOp(EOpParameters);
-        CopyAggregateChildren(params, replacementParams);
-        replacementParams->getSequence()->push_back(CreateReturnValueOutSymbol(node->getType()));
-        replacementParams->setLine(params->getLine());
+                TIntermAggregate *params = node->getSequence()->front()->getAsAggregate();
+                ASSERT(params != nullptr && params->getOp() == EOpParameters);
 
-        queueReplacementWithParent(node, params, replacementParams, OriginalNode::IS_DROPPED);
+                TIntermAggregate *replacementParams = new TIntermAggregate;
+                replacementParams->setOp(EOpParameters);
+                CopyAggregateChildren(params, replacementParams);
+                replacementParams->getSequence()->push_back(CreateReturnValueOutSymbol(node->getType()));
+                replacementParams->setLine(params->getLine());
 
-        node->setType(TType(EbtVoid));
+                queueReplacementWithParent(node, params, replacementParams,
+                                           OriginalNode::IS_DROPPED);
 
-        mInFunctionWithArrayReturnValue = true;
-    }
-    if (visit == PostVisit)
-    {
-        // This isn't conditional on node->isArray() since the type has already been changed on
-        // PreVisit.
-        mInFunctionWithArrayReturnValue = false;
-    }
-    return true;
-}
+                node->setType(TType(EbtVoid));
 
-bool ArrayReturnValueToOutParameterTraverser::visitAggregate(Visit visit, TIntermAggregate *node)
-{
-    if (visit == PreVisit)
-    {
-        if (node->isArray())
-        {
-            if (node->getOp() == EOpPrototype)
+                mInFunctionWithArrayReturnValue = true;
+            }
+            else if (node->getOp() == EOpPrototype)
             {
                 // Replace the whole prototype node with another node that has the out parameter added.
                 TIntermAggregate *replacement = new TIntermAggregate;
@@ -133,7 +118,8 @@ bool ArrayReturnValueToOutParameterTraverser::visitAggregate(Visit visit, TInter
                 CopyAggregateChildren(node, replacement);
                 replacement->getSequence()->push_back(CreateReturnValueOutSymbol(node->getType()));
                 replacement->setUserDefined();
-                *replacement->getFunctionSymbolInfo() = *node->getFunctionSymbolInfo();
+                replacement->setNameObj(node->getNameObj());
+                replacement->setFunctionId(node->getFunctionId());
                 replacement->setLine(node->getLine());
                 replacement->setType(TType(EbtVoid));
 
@@ -150,21 +136,27 @@ bool ArrayReturnValueToOutParameterTraverser::visitAggregate(Visit visit, TInter
                 // Cases 2 to 4 are already converted to simpler cases by SeparateExpressionsReturningArrays, so we
                 // only need to worry about the case where a function call returning an array forms an expression by
                 // itself.
-                TIntermBlock *parentBlock = getParentNode()->getAsBlock();
-                if (parentBlock)
+                TIntermAggregate *parentAgg = getParentNode()->getAsAggregate();
+                if (parentAgg != nullptr && parentAgg->getOp() == EOpSequence)
                 {
                     nextTemporaryIndex();
                     TIntermSequence replacements;
                     replacements.push_back(createTempDeclaration(node->getType()));
                     TIntermSymbol *returnSymbol = createTempSymbol(node->getType());
                     replacements.push_back(CreateReplacementCall(node, returnSymbol));
-                    mMultiReplacements.push_back(
-                        NodeReplaceWithMultipleEntry(parentBlock, node, replacements));
+                    mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(parentAgg, node, replacements));
                 }
                 return false;
             }
         }
     }
+    else if (visit == PostVisit)
+    {
+        if (node->getOp() == EOpFunction)
+        {
+            mInFunctionWithArrayReturnValue = false;
+        }
+    }
     return true;
 }
 
@@ -175,11 +167,12 @@ bool ArrayReturnValueToOutParameterTraverser::visitBranch(Visit visit, TIntermBr
         // Instead of returning a value, assign to the out parameter and then return.
         TIntermSequence replacements;
 
+        TIntermBinary *replacementAssignment = new TIntermBinary(EOpAssign);
         TIntermTyped *expression = node->getExpression();
         ASSERT(expression != nullptr);
-        TIntermSymbol *returnValueSymbol = CreateReturnValueSymbol(expression->getType());
-        TIntermBinary *replacementAssignment =
-            new TIntermBinary(EOpAssign, returnValueSymbol, expression);
+        replacementAssignment->setLeft(CreateReturnValueSymbol(expression->getType()));
+        replacementAssignment->setRight(node->getExpression());
+        replacementAssignment->setType(expression->getType());
         replacementAssignment->setLine(expression->getLine());
         replacements.push_back(replacementAssignment);
 
@@ -187,8 +180,7 @@ bool ArrayReturnValueToOutParameterTraverser::visitBranch(Visit visit, TIntermBr
         replacementBranch->setLine(node->getLine());
         replacements.push_back(replacementBranch);
 
-        mMultiReplacements.push_back(
-            NodeReplaceWithMultipleEntry(getParentNode()->getAsBlock(), node, replacements));
+        mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(getParentNode()->getAsAggregate(), node, replacements));
     }
     return false;
 }
@@ -213,5 +205,3 @@ void ArrayReturnValueToOutParameter(TIntermNode *root, unsigned int *temporaryIn
 {
     ArrayReturnValueToOutParameterTraverser::apply(root, temporaryIndex);
 }
-
-}  // namespace sh