Fix allowing non-constant ternary global initializer

src/compiler/translator/ParseContext.cpp

@@ -1933,7 +1933,7 @@ bool TParseContext::executeInitializer(const TSourceLoc &line,
 
     bool globalInitWarning = false;
     if (symbolTable.atGlobalLevel() &&
-        !ValidateGlobalInitializer(initializer, this, &globalInitWarning))
+        !ValidateGlobalInitializer(initializer, mShaderVersion, &globalInitWarning))
     {
         // Error message does not completely match behavior with ESSL 1.00, but
         // we want to steer developers towards only using constant expressions.

src/compiler/translator/ValidateGlobalInitializer.cpp

@@ -7,7 +7,6 @@
 #include "compiler/translator/ValidateGlobalInitializer.h"
 
 #include "compiler/translator/IntermTraverse.h"
-#include "compiler/translator/ParseContext.h"
 
 namespace sh
 {
@@ -18,9 +17,10 @@ namespace
 class ValidateGlobalInitializerTraverser : public TIntermTraverser
 {
   public:
-    ValidateGlobalInitializerTraverser(const TParseContext *context);
+    ValidateGlobalInitializerTraverser(int shaderVersion);
 
     void visitSymbol(TIntermSymbol *node) override;
+    void visitConstantUnion(TIntermConstantUnion *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *node) override;
     bool visitBinary(Visit visit, TIntermBinary *node) override;
     bool visitUnary(Visit visit, TIntermUnary *node) override;
@@ -29,42 +29,59 @@ class ValidateGlobalInitializerTraverser : public TIntermTraverser
     bool issueWarning() const { return mIssueWarning; }
 
   private:
-    const TParseContext *mContext;
+    int mShaderVersion;
     bool mIsValid;
     bool mIssueWarning;
 };
 
 void ValidateGlobalInitializerTraverser::visitSymbol(TIntermSymbol *node)
 {
-    const TSymbol *sym =
-        mContext->symbolTable.find(node->getSymbol(), mContext->getShaderVersion());
-    if (sym->isVariable())
+    // ESSL 1.00 section 4.3 (or ESSL 3.00 section 4.3):
+    // Global initializers must be constant expressions.
+    switch (node->getType().getQualifier())
     {
-        // ESSL 1.00 section 4.3 (or ESSL 3.00 section 4.3):
-        // Global initializers must be constant expressions.
-        const TVariable *var = static_cast<const TVariable *>(sym);
-        switch (var->getType().getQualifier())
-        {
-            case EvqConst:
-                break;
-            case EvqGlobal:
-            case EvqTemporary:
-            case EvqUniform:
-                // We allow these cases to be compatible with legacy ESSL 1.00 content.
-                // Implement stricter rules for ESSL 3.00 since there's no legacy content to deal
-                // with.
-                if (mContext->getShaderVersion() >= 300)
-                {
-                    mIsValid = false;
-                }
-                else
-                {
-                    mIssueWarning = true;
-                }
-                break;
-            default:
+        case EvqConst:
+            break;
+        case EvqGlobal:
+        case EvqTemporary:
+        case EvqUniform:
+            // We allow these cases to be compatible with legacy ESSL 1.00 content.
+            // Implement stricter rules for ESSL 3.00 since there's no legacy content to deal
+            // with.
+            if (mShaderVersion >= 300)
+            {
                 mIsValid = false;
-        }
+            }
+            else
+            {
+                mIssueWarning = true;
+            }
+            break;
+        default:
+            mIsValid = false;
+    }
+}
+
+void ValidateGlobalInitializerTraverser::visitConstantUnion(TIntermConstantUnion *node)
+{
+    // Constant unions that are not constant expressions may result from folding a ternary
+    // expression.
+    switch (node->getType().getQualifier())
+    {
+        case EvqConst:
+            break;
+        case EvqTemporary:
+            if (mShaderVersion >= 300)
+            {
+                mIsValid = false;
+            }
+            else
+            {
+                mIssueWarning = true;
+            }
+            break;
+        default:
+            UNREACHABLE();
     }
 }
 
@@ -99,18 +116,19 @@ bool ValidateGlobalInitializerTraverser::visitUnary(Visit visit, TIntermUnary *n
     return true;
 }
 
-ValidateGlobalInitializerTraverser::ValidateGlobalInitializerTraverser(const TParseContext *context)
-    : TIntermTraverser(true, false, false), mContext(context), mIsValid(true), mIssueWarning(false)
+ValidateGlobalInitializerTraverser::ValidateGlobalInitializerTraverser(int shaderVersion)
+    : TIntermTraverser(true, false, false),
+      mShaderVersion(shaderVersion),
+      mIsValid(true),
+      mIssueWarning(false)
 {
 }
 
 }  // namespace
 
-bool ValidateGlobalInitializer(TIntermTyped *initializer,
-                               const TParseContext *context,
-                               bool *warning)
+bool ValidateGlobalInitializer(TIntermTyped *initializer, int shaderVersion, bool *warning)
 {
-    ValidateGlobalInitializerTraverser validate(context);
+    ValidateGlobalInitializerTraverser validate(shaderVersion);
     initializer->traverse(&validate);
     ASSERT(warning != nullptr);
     *warning = validate.issueWarning();

src/compiler/translator/ValidateGlobalInitializer.h

@@ -11,12 +11,9 @@ namespace sh
 {
 
 class TIntermTyped;
-class TParseContext;
 
 // Returns true if the initializer is valid.
-bool ValidateGlobalInitializer(TIntermTyped *initializer,
-                               const TParseContext *context,
-                               bool *warning);
+bool ValidateGlobalInitializer(TIntermTyped *initializer, int shaderVersion, bool *warning);
 
 }  // namespace sh
 

src/tests/compiler_tests/ShaderValidation_test.cpp

@@ -5572,3 +5572,51 @@ TEST_F(FragmentShaderValidationTest, MatrixNegativeIndex)
         FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
     }
 }
+
+// Global variable initializers need to be constant expressions. Test with assigning a ternary
+// expression that ANGLE can fold.
+TEST_F(FragmentShaderValidationTest, AssignConstantFoldedFromNonConstantTernaryToGlobal)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision mediump float;
+
+        uniform float u;
+        float f = true ? 1.0 : u;
+
+        out vec4 my_FragColor;
+
+        void main()
+        {
+           my_FragColor = vec4(f);
+        })";
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Global variable initializers need to be constant expressions. Test with assigning a ternary
+// expression that ANGLE can fold.
+TEST_F(FragmentShaderValidationTest,
+       AssignConstantArrayVariableFoldedFromNonConstantTernaryToGlobal)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision mediump float;
+
+        uniform float u[2];
+        const float c[2] = float[2](1.0, 2.0);
+        float f[2] = true ? c : u;
+
+        out vec4 my_FragColor;
+
+        void main()
+        {
+           my_FragColor = vec4(f[0], f[1], 0.0, 1.0);
+        })";
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}