ES31: Add std430 support for OpenGL backend

include/GLSLANG/ShaderVars.h

@@ -37,6 +37,8 @@ bool InterpolationTypesMatch(InterpolationType a, InterpolationType b);
 enum BlockLayoutType
 {
     BLOCKLAYOUT_STANDARD,
+    BLOCKLAYOUT_STD140 = BLOCKLAYOUT_STANDARD,
+    BLOCKLAYOUT_STD430,  // Shader storage block layout qualifier
     BLOCKLAYOUT_PACKED,
     BLOCKLAYOUT_SHARED
 };

src/compiler/translator/BaseTypes.h

@@ -721,7 +721,8 @@ enum TLayoutBlockStorage
     EbsUnspecified,
     EbsShared,
     EbsPacked,
-    EbsStd140
+    EbsStd140,
+    EbsStd430
 };
 
 enum TYuvCscStandardEXT
@@ -970,6 +971,8 @@ inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
             return "packed";
         case EbsStd140:
             return "std140";
+        case EbsStd430:
+            return "std430";
         default:
             UNREACHABLE();
             return "unknown block storage";

src/compiler/translator/CollectVariables.cpp

@@ -29,7 +29,9 @@ BlockLayoutType GetBlockLayoutType(TLayoutBlockStorage blockStorage)
         case EbsShared:
             return BLOCKLAYOUT_SHARED;
         case EbsStd140:
-            return BLOCKLAYOUT_STANDARD;
+            return BLOCKLAYOUT_STD140;
+        case EbsStd430:
+            return BLOCKLAYOUT_STD430;
         default:
             UNREACHABLE();
             return BLOCKLAYOUT_SHARED;

src/compiler/translator/Compiler.cpp

@@ -1033,7 +1033,7 @@ void TCompiler::useAllMembersInUnusedStandardAndSharedBlocks(TIntermBlock *root)
     for (auto block : uniformBlocks)
     {
         if (!block.staticUse &&
-            (block.layout == sh::BLOCKLAYOUT_STANDARD || block.layout == sh::BLOCKLAYOUT_SHARED))
+            (block.layout == sh::BLOCKLAYOUT_STD140 || block.layout == sh::BLOCKLAYOUT_SHARED))
         {
             list.push_back(block);
         }

src/compiler/translator/OutputGLSLBase.cpp

@@ -1186,6 +1186,10 @@ void TOutputGLSLBase::declareInterfaceBlockLayout(const TInterfaceBlock *interfa
             out << "std140";
             break;
 
+        case EbsStd430:
+            out << "std430";
+            break;
+
         default:
             UNREACHABLE();
             break;

src/compiler/translator/ParseContext.cpp

@@ -908,6 +908,16 @@ void TParseContext::checkLocationIsNotSpecified(const TSourceLoc &location,
     }
 }
 
+void TParseContext::checkStd430IsForShaderStorageBlock(const TSourceLoc &location,
+                                                       const TLayoutBlockStorage &blockStorage,
+                                                       const TQualifier &qualifier)
+{
+    if (blockStorage == EbsStd430 && qualifier != EvqBuffer)
+    {
+        error(location, "The std430 layout is supported only for shader storage blocks.", "std430");
+    }
+}
+
 void TParseContext::checkOutParameterIsNotOpaqueType(const TSourceLoc &line,
                                                      TQualifier qualifier,
                                                      const TType &type)
@@ -2913,6 +2923,9 @@ void TParseContext::parseGlobalLayoutQualifier(const TTypeQualifierBuilder &type
 
     checkOffsetIsNotSpecified(typeQualifier.line, layoutQualifier.offset);
 
+    checkStd430IsForShaderStorageBlock(typeQualifier.line, layoutQualifier.blockStorage,
+                                       typeQualifier.qualifier);
+
     if (typeQualifier.qualifier == EvqComputeIn)
     {
         if (mComputeShaderLocalSizeDeclared &&
@@ -3577,6 +3590,8 @@ TIntermDeclaration *TParseContext::addInterfaceBlock(
 
     TLayoutQualifier blockLayoutQualifier = typeQualifier.layoutQualifier;
     checkLocationIsNotSpecified(typeQualifier.line, blockLayoutQualifier);
+    checkStd430IsForShaderStorageBlock(typeQualifier.line, blockLayoutQualifier.blockStorage,
+                                       typeQualifier.qualifier);
 
     if (blockLayoutQualifier.matrixPacking == EmpUnspecified)
     {
@@ -4120,6 +4135,11 @@ TLayoutQualifier TParseContext::parseLayoutQualifier(const TString &qualifierTyp
         }
         qualifier.blockStorage = EbsPacked;
     }
+    else if (qualifierType == "std430")
+    {
+        checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
+        qualifier.blockStorage = EbsStd430;
+    }
     else if (qualifierType == "std140")
     {
         qualifier.blockStorage = EbsStd140;

src/compiler/translator/ParseContext.h

@@ -135,6 +135,9 @@ class TParseContext : angle::NonCopyable
     void checkDeclaratorLocationIsNotSpecified(const TSourceLoc &line, const TPublicType &pType);
     void checkLocationIsNotSpecified(const TSourceLoc &location,
                                      const TLayoutQualifier &layoutQualifier);
+    void checkStd430IsForShaderStorageBlock(const TSourceLoc &location,
+                                            const TLayoutBlockStorage &blockStorage,
+                                            const TQualifier &qualifier);
     void checkIsParameterQualifierValid(const TSourceLoc &line,
                                         const TTypeQualifierBuilder &typeQualifierBuilder,
                                         TType *type);

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -2276,7 +2276,7 @@ size_t ProgramD3D::getUniformBlockInfo(const sh::InterfaceBlock &interfaceBlock)
     sh::HLSLBlockEncoder hlslEncoder(sh::HLSLBlockEncoder::ENCODE_PACKED, false);
     sh::BlockLayoutEncoder *encoder = nullptr;
 
-    if (interfaceBlock.layout == sh::BLOCKLAYOUT_STANDARD)
+    if (interfaceBlock.layout == sh::BLOCKLAYOUT_STD140)
     {
         encoder = &std140Encoder;
     }

src/tests/compiler_tests/BufferVariables_test.cpp

@@ -483,3 +483,39 @@ TEST_F(BufferVariablesTest, BufferQualifierOnFunctionParameter)
         FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
     }
 }
+
+// Test that std430 qualifier is supported for shader storage blocks.
+TEST_F(BufferVariablesTest, ShaderStorageBlockWithStd430)
+{
+    const std::string &source =
+        "#version 310 es\n"
+        "layout(std430) buffer buf {\n"
+        "    int b1;\n"
+        "    int b2;\n"
+        "};\n"
+        "void main()\n"
+        "{\n"
+        "}\n";
+    if (!compile(source))
+    {
+        FAIL() << "Shader compilation failed, expecting success:\n" << mInfoLog;
+    }
+}
+
+// Test that using std430 qualifier on a uniform block will fail to compile.
+TEST_F(BufferVariablesTest, UniformBlockWithStd430)
+{
+    const std::string &source =
+        "#version 310 es\n"
+        "layout(std430) uniform buf {\n"
+        "    int b1;\n"
+        "    int b2;\n"
+        "};\n"
+        "void main()\n"
+        "{\n"
+        "}\n";
+    if (compile(source))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}