Defer global initializers when necessary

src/compiler.gypi

@@ -34,6 +34,8 @@
             'compiler/translator/Compiler.cpp',
             'compiler/translator/Compiler.h',
             'compiler/translator/ConstantUnion.h',
+            'compiler/translator/DeferGlobalInitializers.cpp',
+            'compiler/translator/DeferGlobalInitializers.h',
             'compiler/translator/Diagnostics.cpp',
             'compiler/translator/Diagnostics.h',
             'compiler/translator/DirectiveHandler.cpp',

src/compiler/translator/Compiler.cpp

@@ -7,6 +7,7 @@
 #include "compiler/translator/Cache.h"
 #include "compiler/translator/Compiler.h"
 #include "compiler/translator/CallDAG.h"
+#include "compiler/translator/DeferGlobalInitializers.h"
 #include "compiler/translator/ForLoopUnroll.h"
 #include "compiler/translator/Initialize.h"
 #include "compiler/translator/InitializeParseContext.h"
@@ -376,6 +377,11 @@ TIntermNode *TCompiler::compileTreeImpl(const char *const shaderStrings[],
             RegenerateStructNames gen(symbolTable, shaderVersion);
             root->traverse(&gen);
         }
+
+        if (success)
+        {
+            DeferGlobalInitializers(root);
+        }
     }
 
     SetGlobalParseContext(NULL);

src/compiler/translator/DeferGlobalInitializers.cpp

+//
+// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// DeferGlobalInitializers is an AST traverser that moves global initializers into a function, and
+// adds a function call to that function in the beginning of main().
+// This enables initialization of globals with uniforms or non-constant globals, as allowed by
+// the WebGL spec. Some initializers referencing non-constants may need to be unfolded into if
+// statements in HLSL - this kind of steps should be done after DeferGlobalInitializers is run.
+//
+
+#include "compiler/translator/DeferGlobalInitializers.h"
+
+#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/SymbolTable.h"
+
+namespace
+{
+
+void SetInternalFunctionName(TIntermAggregate *functionNode, const char *name)
+{
+    TString nameStr(name);
+    nameStr = TFunction::mangleName(nameStr);
+    TName nameObj(nameStr);
+    nameObj.setInternal(true);
+    functionNode->setNameObj(nameObj);
+}
+
+TIntermAggregate *CreateFunctionPrototypeNode(const char *name)
+{
+    TIntermAggregate *functionNode = new TIntermAggregate(EOpPrototype);
+
+    SetInternalFunctionName(functionNode, name);
+    TType returnType(EbtVoid);
+    functionNode->setType(returnType);
+    return functionNode;
+}
+
+TIntermAggregate *CreateFunctionDefinitionNode(const char *name, TIntermAggregate *functionBody)
+{
+    TIntermAggregate *functionNode = new TIntermAggregate(EOpFunction);
+    TIntermAggregate *paramsNode = new TIntermAggregate(EOpParameters);
+    functionNode->getSequence()->push_back(paramsNode);
+    functionNode->getSequence()->push_back(functionBody);
+
+    SetInternalFunctionName(functionNode, name);
+    TType returnType(EbtVoid);
+    functionNode->setType(returnType);
+    return functionNode;
+}
+
+TIntermAggregate *CreateFunctionCallNode(const char *name)
+{
+    TIntermAggregate *functionNode = new TIntermAggregate(EOpFunctionCall);
+
+    SetInternalFunctionName(functionNode, name);
+    TType returnType(EbtVoid);
+    functionNode->setType(returnType);
+    return functionNode;
+}
+
+class DeferGlobalInitializersTraverser : public TIntermTraverser
+{
+  public:
+    DeferGlobalInitializersTraverser();
+
+    bool visitBinary(Visit visit, TIntermBinary *node) override;
+
+    void insertInitFunction(TIntermNode *root);
+
+  private:
+    TIntermSequence mDeferredInitializers;
+};
+
+DeferGlobalInitializersTraverser::DeferGlobalInitializersTraverser()
+    : TIntermTraverser(true, false, false)
+{
+}
+
+bool DeferGlobalInitializersTraverser::visitBinary(Visit visit, TIntermBinary *node)
+{
+    if (node->getOp() == EOpInitialize)
+    {
+        TIntermSymbol *symbolNode = node->getLeft()->getAsSymbolNode();
+        ASSERT(symbolNode);
+        TIntermTyped *expression = node->getRight();
+
+        if (symbolNode->getQualifier() == EvqGlobal &&
+            (expression->getQualifier() != EvqConst || expression->getAsConstantUnion() == nullptr))
+        {
+            // For variables which are not constant, defer their real initialization until
+            // after we initialize uniforms.
+            // Deferral is done also in any cases where the variable has not been constant folded,
+            // since otherwise there's a chance that HLSL output will generate extra statements
+            // from the initializer expression.
+            TIntermBinary *deferredInit = new TIntermBinary(EOpAssign);
+            deferredInit->setLeft(node->getLeft()->deepCopy());
+            deferredInit->setRight(node->getRight());
+            deferredInit->setType(node->getType());
+            mDeferredInitializers.push_back(deferredInit);
+
+            // Remove the initializer from the global scope and just declare the global instead.
+            mReplacements.push_back(NodeUpdateEntry(getParentNode(), node, node->getLeft(), false));
+        }
+    }
+    return false;
+}
+
+void DeferGlobalInitializersTraverser::insertInitFunction(TIntermNode *root)
+{
+    if (mDeferredInitializers.empty())
+    {
+        return;
+    }
+    TIntermAggregate *rootAgg = root->getAsAggregate();
+    ASSERT(rootAgg != nullptr && rootAgg->getOp() == EOpSequence);
+
+    const char *functionName = "initializeDeferredGlobals";
+
+    // Add function prototype to the beginning of the shader
+    TIntermAggregate *functionPrototypeNode = CreateFunctionPrototypeNode(functionName);
+    rootAgg->getSequence()->insert(rootAgg->getSequence()->begin(), functionPrototypeNode);
+
+    // Add function definition to the end of the shader
+    TIntermAggregate *functionBodyNode = new TIntermAggregate(EOpSequence);
+    TIntermSequence *functionBody = functionBodyNode->getSequence();
+    for (const auto &deferredInit : mDeferredInitializers)
+    {
+        functionBody->push_back(deferredInit);
+    }
+    TIntermAggregate *functionDefinition =
+        CreateFunctionDefinitionNode(functionName, functionBodyNode);
+    rootAgg->getSequence()->push_back(functionDefinition);
+
+    // Insert call into main function
+    for (TIntermNode *node : *rootAgg->getSequence())
+    {
+        TIntermAggregate *nodeAgg = node->getAsAggregate();
+        if (nodeAgg != nullptr && nodeAgg->getOp() == EOpFunction &&
+            TFunction::unmangleName(nodeAgg->getName()) == "main")
+        {
+            TIntermAggregate *functionCallNode = CreateFunctionCallNode(functionName);
+
+            TIntermNode *mainBody         = nodeAgg->getSequence()->back();
+            TIntermAggregate *mainBodyAgg = mainBody->getAsAggregate();
+            ASSERT(mainBodyAgg != nullptr && mainBodyAgg->getOp() == EOpSequence);
+            mainBodyAgg->getSequence()->insert(mainBodyAgg->getSequence()->begin(),
+                                               functionCallNode);
+        }
+    }
+}
+
+}  // namespace
+
+void DeferGlobalInitializers(TIntermNode *root)
+{
+    DeferGlobalInitializersTraverser traverser;
+    root->traverse(&traverser);
+
+    // Replace the initializers of the global variables.
+    traverser.updateTree();
+
+    // Add the function with initialization and the call to that.
+    traverser.insertInitFunction(root);
+}

src/compiler/translator/DeferGlobalInitializers.h

+//
+// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// DeferGlobalInitializers is an AST traverser that moves global initializers into a function, and
+// adds a function call to that function in the beginning of main().
+// This enables initialization of globals with uniforms or non-constant globals, as allowed by
+// the WebGL spec. Some initializers referencing non-constants may need to be unfolded into if
+// statements in HLSL - this kind of steps should be done after DeferGlobalInitializers is run.
+//
+
+#ifndef COMPILER_TRANSLATOR_DEFERGLOBALINITIALIZERS_H_
+#define COMPILER_TRANSLATOR_DEFERGLOBALINITIALIZERS_H_
+
+class TIntermNode;
+
+void DeferGlobalInitializers(TIntermNode *root);
+
+#endif  // COMPILER_TRANSLATOR_DEFERGLOBALINITIALIZERS_H_

src/compiler/translator/OutputHLSL.cpp

@@ -259,10 +259,6 @@ void OutputHLSL::output(TIntermNode *treeRoot, TInfoSinkBase &objSink)
     mInfoSinkStack.pop();
 
     mInfoSinkStack.push(&mFooter);
-    if (!mDeferredGlobalInitializers.empty())
-    {
-        writeDeferredGlobalInitializers(mFooter);
-    }
     mInfoSinkStack.pop();
 
     mInfoSinkStack.push(&mHeader);
@@ -1784,20 +1780,11 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
             ASSERT(symbolNode);
             TIntermTyped *expression = node->getRight();
 
-            // TODO (jmadill): do a 'deep' scan to know if an expression is statically const
-            if (symbolNode->getQualifier() == EvqGlobal && expression->getQualifier() != EvqConst)
-            {
-                // For variables which are not constant, defer their real initialization until
-                // after we initialize uniforms.
-                TIntermBinary *deferredInit = new TIntermBinary(EOpAssign);
-                deferredInit->setLeft(node->getLeft());
-                deferredInit->setRight(node->getRight());
-                deferredInit->setType(node->getType());
-                mDeferredGlobalInitializers.push_back(deferredInit);
-                const TString &initString = initializer(node->getType());
-                node->setRight(new TIntermRaw(node->getType(), initString));
-            }
-            else if (writeSameSymbolInitializer(out, symbolNode, expression))
+            // Global initializers must be constant at this point.
+            ASSERT(symbolNode->getQualifier() != EvqGlobal ||
+                   (expression->getQualifier() == EvqConst &&
+                    expression->getAsConstantUnion() != nullptr));
+            if (writeSameSymbolInitializer(out, symbolNode, expression))
             {
                 // Skip initializing the rest of the expression
                 return false;
@@ -2994,13 +2981,7 @@ bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node)
     TInfoSinkBase &out = getInfoSink();
 
     ASSERT(!node->usesTernaryOperator());
-
-    if (!mInsideFunction)
-    {
-        // This is part of unfolded global initialization.
-        mDeferredGlobalInitializers.push_back(node);
-        return false;
-    }
+    ASSERT(mInsideFunction);
 
     // D3D errors when there is a gradient operation in a loop in an unflattened if.
     if (mShaderType == GL_FRAGMENT_SHADER && mCurrentFunctionMetadata->hasGradientLoop(node))
@@ -3731,47 +3712,6 @@ bool OutputHLSL::writeConstantInitialization(TInfoSinkBase &out,
     return false;
 }
 
-void OutputHLSL::writeDeferredGlobalInitializers(TInfoSinkBase &out)
-{
-    out << "#define ANGLE_USES_DEFERRED_INIT\n"
-        << "\n"
-        << "void initializeDeferredGlobals()\n"
-        << "{\n";
-
-    for (const auto &deferredGlobal : mDeferredGlobalInitializers)
-    {
-        TIntermBinary *binary = deferredGlobal->getAsBinaryNode();
-        TIntermSelection *selection = deferredGlobal->getAsSelectionNode();
-        if (binary != nullptr)
-        {
-            TIntermSymbol *symbol = binary->getLeft()->getAsSymbolNode();
-            TIntermTyped *expression = binary->getRight();
-            ASSERT(symbol);
-            ASSERT(symbol->getQualifier() == EvqGlobal && expression->getQualifier() != EvqConst);
-
-            out << "    " << Decorate(symbol->getSymbol()) << " = ";
-
-            if (!writeSameSymbolInitializer(out, symbol, expression))
-            {
-                ASSERT(mInfoSinkStack.top() == &out);
-                expression->traverse(this);
-            }
-            out << ";\n";
-        }
-        else if (selection != nullptr)
-        {
-            writeSelection(out, selection);
-        }
-        else
-        {
-            UNREACHABLE();
-        }
-    }
-
-    out << "}\n"
-        << "\n";
-}
-
 TString OutputHLSL::addStructEqualityFunction(const TStructure &structure)
 {
     const TFieldList &fields = structure.fields();

src/compiler/translator/OutputHLSL.h

@@ -203,11 +203,6 @@ class OutputHLSL : public TIntermTraverser
     std::map<TIntermTyped*, TString> mFlaggedStructMappedNames;
     std::map<TIntermTyped*, TString> mFlaggedStructOriginalNames;
 
-    // Some initializers may have been unfolded into if statements, thus we can't evaluate all initializers
-    // at global static scope in HLSL. Instead, we can initialize these static globals inside a helper function.
-    // This also enables initialization of globals with uniforms.
-    TIntermSequence mDeferredGlobalInitializers;
-
     struct HelperFunction
     {
         TString functionName;

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -412,7 +412,6 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
     ASSERT(pixelHLSL->empty() && vertexHLSL->empty());
 
     const gl::Shader *vertexShaderGL   = programData.getAttachedVertexShader();
-    const ShaderD3D *vertexShader      = GetImplAs<ShaderD3D>(vertexShaderGL);
     const gl::Shader *fragmentShaderGL = programData.getAttachedFragmentShader();
     const ShaderD3D *fragmentShader    = GetImplAs<ShaderD3D>(fragmentShaderGL);
     const int shaderModel              = mRenderer->getMajorShaderModel();
@@ -451,12 +450,6 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
                  << "{\n"
                  << "    initAttributes(input);\n";
 
-    if (vertexShader->usesDeferredInit())
-    {
-        vertexStream << "\n"
-                     << "    initializeDeferredGlobals();\n";
-    }
-
     vertexStream << "\n"
                  << "    gl_main();\n"
                  << "\n"
@@ -771,12 +764,6 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
         pixelStream << ";\n";
     }
 
-    if (fragmentShader->usesDeferredInit())
-    {
-        pixelStream << "\n"
-                    << "    initializeDeferredGlobals();\n";
-    }
-
     pixelStream << "\n"
                 << "    gl_main();\n"
                 << "\n"

src/libANGLE/renderer/d3d/ShaderD3D.cpp

@@ -72,7 +72,6 @@ void ShaderD3D::uncompile()
     mUsesFragDepth = false;
     mUsesDiscardRewriting = false;
     mUsesNestedBreak = false;
-    mUsesDeferredInit = false;
     mRequiresIEEEStrictCompiling = false;
 
     mDebugInfo.clear();
@@ -171,7 +170,6 @@ bool ShaderD3D::postTranslateCompile(gl::Compiler *compiler, std::string *infoLo
     mUsesDiscardRewriting =
         translatedSource.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos;
     mUsesNestedBreak  = translatedSource.find("ANGLE_USES_NESTED_BREAK") != std::string::npos;
-    mUsesDeferredInit = translatedSource.find("ANGLE_USES_DEFERRED_INIT") != std::string::npos;
     mRequiresIEEEStrictCompiling =
         translatedSource.find("ANGLE_REQUIRES_IEEE_STRICT_COMPILING") != std::string::npos;
 

src/libANGLE/renderer/d3d/ShaderD3D.h

@@ -55,7 +55,6 @@ class ShaderD3D : public ShaderImpl
     bool usesPointCoord() const { return mUsesPointCoord; }
     bool usesDepthRange() const { return mUsesDepthRange; }
     bool usesFragDepth() const { return mUsesFragDepth; }
-    bool usesDeferredInit() const { return mUsesDeferredInit; }
 
     ShShaderOutput getCompilerOutputType() const;
 
@@ -71,7 +70,6 @@ class ShaderD3D : public ShaderImpl
     bool mUsesFragDepth;
     bool mUsesDiscardRewriting;
     bool mUsesNestedBreak;
-    bool mUsesDeferredInit;
     bool mRequiresIEEEStrictCompiling;
 
     ShShaderOutput mCompilerOutputType;