compiler: Prune literal statements when outputting ESSL

src/compiler.gypi

@@ -81,6 +81,8 @@
             'compiler/translator/Pragma.h',
             'compiler/translator/PruneEmptyDeclarations.cpp',
             'compiler/translator/PruneEmptyDeclarations.h',
+            'compiler/translator/PrunePureLiteralStatements.cpp',
+            'compiler/translator/PrunePureLiteralStatements.h',
             'compiler/translator/QualifierTypes.h',
             'compiler/translator/QualifierTypes.cpp',
             'compiler/translator/RecordConstantPrecision.cpp',

src/compiler/translator/PrunePureLiteralStatements.cpp

+//
+// Copyright (c) 2017 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.
+//
+// PrunePureLiteralStatements.cpp: Removes statements that are literals and nothing else.
+
+#include "compiler/translator/PrunePureLiteralStatements.h"
+
+#include "compiler/translator/IntermNode.h"
+
+namespace sh
+{
+
+namespace
+{
+
+class PrunePureLiteralStatementsTraverser : public TIntermTraverser
+{
+  public:
+    PrunePureLiteralStatementsTraverser() : TIntermTraverser(true, false, false) {}
+
+    bool visitBlock(Visit visit, TIntermBlock *node) override
+    {
+        TIntermSequence *statements = node->getSequence();
+        if (statements == nullptr)
+        {
+            return false;
+        }
+
+        // Empty case statements at the end of a switch are invalid: if the last statements
+        // of a block was a pure literal, also delete all the case statements directly preceding it.
+        bool deleteCaseStatements = false;
+        for (int i = static_cast<int>(statements->size()); i-- > 0;)
+        {
+            TIntermNode *statement = (*statements)[i];
+
+            if (statement->getAsConstantUnion() != nullptr)
+            {
+                TIntermSequence emptyReplacement;
+                mMultiReplacements.push_back(
+                    NodeReplaceWithMultipleEntry(node, statement, emptyReplacement));
+
+                if (i == static_cast<int>(statements->size()) - 1)
+                {
+                    deleteCaseStatements = true;
+                }
+
+                continue;
+            }
+
+            if (deleteCaseStatements)
+            {
+                if (statement->getAsCaseNode() != nullptr)
+                {
+                    TIntermSequence emptyReplacement;
+                    mMultiReplacements.push_back(
+                        NodeReplaceWithMultipleEntry(node, statement, emptyReplacement));
+                }
+                else
+                {
+                    deleteCaseStatements = false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool visitLoop(Visit visit, TIntermLoop *loop) override
+    {
+        TIntermTyped *expr = loop->getExpression();
+        if (expr != nullptr && expr->getAsConstantUnion() != nullptr)
+        {
+            loop->setExpression(nullptr);
+        }
+
+        return true;
+    }
+};
+
+}  // namespace
+
+void PrunePureLiteralStatements(TIntermNode *root)
+{
+    PrunePureLiteralStatementsTraverser prune;
+    root->traverse(&prune);
+    prune.updateTree();
+}
+
+}  // namespace sh

src/compiler/translator/PrunePureLiteralStatements.h

+//
+// Copyright (c) 2017 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.
+//
+// PrunePureLiteralStatements.h: Removes statements that are literals and nothing else.
+
+#ifndef COMPILER_TRANSLATOR_PRUNEPURELITERALSTATEMENTS_H_
+#define COMPILER_TRANSLATOR_PRUNEPURELITERALSTATEMENTS_H_
+
+namespace sh
+{
+class TIntermNode;
+
+void PrunePureLiteralStatements(TIntermNode *root);
+}
+
+#endif  // COMPILER_TRANSLATOR_PRUNEPURELITERALSTATEMENTS_H_

src/compiler/translator/TranslatorESSL.cpp

@@ -8,6 +8,7 @@
 
 #include "compiler/translator/BuiltInFunctionEmulatorGLSL.h"
 #include "compiler/translator/EmulatePrecision.h"
+#include "compiler/translator/PrunePureLiteralStatements.h"
 #include "compiler/translator/RecordConstantPrecision.h"
 #include "compiler/translator/OutputESSL.h"
 #include "angle_gl.h"
@@ -31,6 +32,10 @@ void TranslatorESSL::initBuiltInFunctionEmulator(BuiltInFunctionEmulator *emu,
 
 void TranslatorESSL::translate(TIntermNode *root, ShCompileOptions compileOptions)
 {
+    // The ESSL output doesn't define a default precision for float, so float literal statements
+    // end up with no precision which is invalid ESSL.
+    PrunePureLiteralStatements(root);
+
     TInfoSinkBase &sink = getInfoSink().obj;
 
     int shaderVer = getShaderVersion();

src/tests/angle_unittests.gypi

@@ -65,6 +65,7 @@
             '<(angle_path)/src/tests/compiler_tests/NV_draw_buffers_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/Pack_Unpack_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/PruneEmptyDeclarations_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/PrunePureLiteralStatements_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/PruneUnusedFunctions_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/QualificationOrderESSL31_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/QualificationOrder_test.cpp',

src/tests/compiler_tests/PrunePureLiteralStatements_test.cpp

+//
+// Copyright (c) 2017 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.
+//
+// PrunePureLiteralStatements_test.cpp:
+//   Tests for pruning literal statements.
+//
+
+#include "angle_gl.h"
+#include "gtest/gtest.h"
+#include "tests/test_utils/compiler_test.h"
+
+using namespace sh;
+
+namespace
+{
+
+class PrunePureLiteralStatementsTest : public MatchOutputCodeTest
+{
+  public:
+    // The PrunePureLiteralStatements pass is used when outputting ESSL
+    PrunePureLiteralStatementsTest() : MatchOutputCodeTest(GL_FRAGMENT_SHADER, 0, SH_ESSL_OUTPUT) {}
+};
+
+// Most basic test for the pruning
+TEST_F(PrunePureLiteralStatementsTest, FloatLiteralStatement)
+{
+    const std::string shaderString =
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "   float f = 41.0;\n"
+        "   42.0;\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(foundInCode("41"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test the pruning works for constructed types too
+TEST_F(PrunePureLiteralStatementsTest, ConstructorLiteralStatement)
+{
+    const std::string shaderString =
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "   vec2 f = vec2(41.0, 41.0);\n"
+        "   vec2(42.0, 42.0);\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(foundInCode("41"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test the pruning works when the literal is a (non-trivial) expression
+TEST_F(PrunePureLiteralStatementsTest, ExpressionLiteralStatement)
+{
+    const std::string shaderString =
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "   vec2(21.0, 21.0) + vec2(21.0, 21.0);\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(notFoundInCode("21"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test that the pruning happens in the for-loop expression too
+TEST_F(PrunePureLiteralStatementsTest, ForLoopLiteralExpression)
+{
+    const std::string shaderString =
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "    for (;; vec2(42.0, 42.0)) {}\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test that the pruning correctly handles the pruning inside switch statements - for a switch with
+// one empty case.
+TEST_F(PrunePureLiteralStatementsTest, SwitchLiteralExpressionEmptyCase)
+{
+    const std::string shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "    switch(1)\n"
+        "    {\n"
+        "      default:\n"
+        "        42;\n"
+        "    }\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(notFoundInCode("default"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test that the pruning correctly handles the pruning inside switch statements - for a switch with
+// multiple cases.
+TEST_F(PrunePureLiteralStatementsTest, SwitchLiteralExpressionEmptyCases)
+{
+    const std::string shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "    switch(1)\n"
+        "    {\n"
+        "      case 1:\n"
+        "      case 2:\n"
+        "      default:\n"
+        "        42;\n"
+        "    }\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(notFoundInCode("default"));
+    ASSERT_TRUE(notFoundInCode("case"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test that the pruning correctly handles the pruning inside switch statements - only cases at the
+// end are deleted
+TEST_F(PrunePureLiteralStatementsTest, SwitchLiteralExpressionOnlyLastCase)
+{
+    const std::string shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "    switch(1)\n"
+        "    {\n"
+        "      case 1:\n"
+        "      default:\n"
+        "        42;\n"
+        "        break;\n"
+        "    }\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(foundInCode("default"));
+    ASSERT_TRUE(foundInCode("case"));
+    ASSERT_TRUE(notFoundInCode("42"));
+}
+
+// Test that the pruning correctly handles the pruning inside switch statements - pruning isn't stopped by literal statements
+TEST_F(PrunePureLiteralStatementsTest, SwitchLiteralExpressionLiteralDoesntStop)
+{
+    const std::string shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "void main()\n"
+        "{\n"
+        "    switch(1)\n"
+        "    {\n"
+        "      case 1:\n"
+        "        42;\n"
+        "      case 2:\n"
+        "        43;\n"
+        "    }\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(notFoundInCode("case"));
+    ASSERT_TRUE(notFoundInCode("42"));
+    ASSERT_TRUE(notFoundInCode("43"));
+}
+
+}  // namespace