Vulkan: SPIR-V Gen: Handle load/store access chain

src/compiler/translator/BaseTypes.h

@@ -1086,6 +1086,11 @@ inline bool IsShaderOut(TQualifier qualifier)
         case EvqSampleOut:
         case EvqPatchOut:
         case EvqFragmentInOut:
+        // Per-vertex built-ins when used without gl_in or gl_out are always output.
+        case EvqPosition:
+        case EvqPointSize:
+        case EvqClipDistance:
+        case EvqCullDistance:
             return true;
         default:
             return false;

src/compiler/translator/BuildSPIRV.cpp

@@ -293,7 +293,7 @@ SpirvTypeData SPIRVBuilder::declareType(const SpirvType &type, const char *block
     // unconditionally and having the SPIR-V transformer remove them, it's better to avoid
     // generating them in the first place.  This both simplifies the transformer and reduces SPIR-V
     // binary size that gets written to disk cache.  http://anglebug.com/4889
-    if (type.block != nullptr)
+    if (type.block != nullptr && type.arraySizes.empty())
     {
         spirv::WriteName(&mSpirvDebug, typeId, blockName);
 
@@ -912,6 +912,10 @@ uint32_t SPIRVBuilder::calculateBaseAlignmentAndSize(const SpirvType &type,
         // > laid out in order, according to rule (9).
         SpirvType baseType  = type;
         baseType.arraySizes = {};
+        if (baseType.arraySizes.empty() && baseType.block == nullptr)
+        {
+            baseType.blockStorage = EbsUnspecified;
+        }
 
         const SpirvTypeData &baseTypeData = getSpirvTypeData(baseType, "");
         uint32_t baseAlignment            = baseTypeData.baseAlignment;
@@ -1173,6 +1177,12 @@ spirv::Blob SPIRVBuilder::getSpirv()
     }
     result.insert(result.end(), mSpirvExecutionModes.begin(), mSpirvExecutionModes.end());
 
+    // - OpSource instruction.
+    //
+    // This is to support debuggers and capture/replay tools and isn't strictly necessary.
+    spirv::WriteSource(&result, spv::SourceLanguageGLSL, spirv::LiteralInteger(450), nullptr,
+                       nullptr);
+
     // Append the already generated sections in order
     result.insert(result.end(), mSpirvDebug.begin(), mSpirvDebug.end());
     result.insert(result.end(), mSpirvDecorations.begin(), mSpirvDecorations.end());

src/compiler/translator/BuildSPIRV.h

@@ -177,6 +177,8 @@ class SPIRVBuilder : angle::NonCopyable
     spirv::Blob *getSpirvExecutionModes() { return &mSpirvExecutionModes; }
     spirv::Blob *getSpirvDebug() { return &mSpirvDebug; }
     spirv::Blob *getSpirvDecorations() { return &mSpirvDecorations; }
+    spirv::Blob *getSpirvTypeAndConstantDecls() { return &mSpirvTypeAndConstantDecls; }
+    spirv::Blob *getSpirvTypePointerDecls() { return &mSpirvTypePointerDecls; }
     spirv::Blob *getSpirvVariableDecls() { return &mSpirvVariableDecls; }
     spirv::Blob *getSpirvFunctions() { return &mSpirvFunctions; }
 
@@ -190,6 +192,12 @@ class SPIRVBuilder : angle::NonCopyable
     uint32_t calculateBaseAlignmentAndSize(const SpirvType &type, uint32_t *sizeInStorageBlockOut);
     uint32_t calculateSizeAndWriteOffsetDecorations(const SpirvType &type, spirv::IdRef typeId);
 
+    spirv::IdRef getBoolConstant(bool value);
+    spirv::IdRef getUintConstant(uint32_t value);
+    spirv::IdRef getIntConstant(int32_t value);
+    spirv::IdRef getFloatConstant(float value);
+    spirv::IdRef getCompositeConstant(spirv::IdRef typeId, const spirv::IdRefList &values);
+
     // TODO: remove name hashing once translation through glslang is removed.  That is necessary to
     // avoid name collision between ANGLE's internal symbols and user-defined ones when compiling
     // the generated GLSL, but is irrelevant when generating SPIR-V directly.  Currently, the SPIR-V
@@ -215,14 +223,9 @@ class SPIRVBuilder : angle::NonCopyable
                                 spirv::LiteralInteger *sampledOut);
     spv::ImageFormat getImageFormat(TLayoutImageInternalFormat imageInternalFormat);
 
-    spirv::IdRef getBoolConstant(bool value);
     spirv::IdRef getBasicConstantHelper(uint32_t value,
                                         TBasicType type,
                                         angle::HashMap<uint32_t, spirv::IdRef> *constants);
-    spirv::IdRef getUintConstant(uint32_t value);
-    spirv::IdRef getIntConstant(int32_t value);
-    spirv::IdRef getFloatConstant(float value);
-    spirv::IdRef getCompositeConstant(spirv::IdRef typeId, const spirv::IdRefList &values);
 
     uint32_t nextUnusedBinding();
     uint32_t nextUnusedInputLocation(uint32_t consumedCount);

src/compiler/translator/TranslatorVulkan.cpp

@@ -1340,7 +1340,10 @@ bool TranslatorVulkan::translate(TIntermBlock *root,
     }
 
 #if defined(ANGLE_ENABLE_DIRECT_SPIRV_GENERATION)
-    if ((compileOptions & SH_GENERATE_SPIRV_DIRECTLY) != 0 && getShaderType() == GL_VERTEX_SHADER)
+    constexpr ShCompileOptions kUnsupportedTransformations =
+        SH_ADD_VULKAN_XFB_EMULATION_SUPPORT_CODE | SH_ADD_BRESENHAM_LINE_RASTER_EMULATION;
+    if ((compileOptions & SH_GENERATE_SPIRV_DIRECTLY) != 0 && getShaderType() == GL_VERTEX_SHADER &&
+        (compileOptions & kUnsupportedTransformations) == 0)
     {
         // Declare the implicitly defined gl_PerVertex I/O blocks if not already.  This will help
         // SPIR-V generation treat them mostly like usual I/O blocks.

src/tests/gl_tests/ColorMaskTest.cpp

@@ -73,6 +73,6 @@ TEST_P(ColorMaskTest, AMDZeroColorMaskBug)
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against. D3D11 Feature Level 9_3 uses different D3D formats for vertex
 // attribs compared to Feature Levels 10_0+, so we should test them separately.
-ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(ColorMaskTest);
+ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND(ColorMaskTest, WithDirectSPIRVGeneration(ES2_VULKAN()));
 
 }  // namespace angle

src/tests/gl_tests/GLSLTest.cpp

@@ -515,7 +515,7 @@ class GLSLTest_ES3 : public GLSLTest
 class GLSLTest_ES31 : public GLSLTest
 {};
 
-std::string BuillBigInitialStackShader(int length)
+std::string BuildBigInitialStackShader(int length)
 {
     std::string result;
     result += "void main() { \n";
@@ -1482,6 +1482,25 @@ TEST_P(GLSLTest_ES3, MissingReturnStructOfArrays)
     EXPECT_NE(0u, program);
 }
 
+// Verify that non-const index used on an array returned by a function compiles
+TEST_P(GLSLTest_ES3, ReturnArrayOfStructsThenNonConstIndex)
+{
+    constexpr char kVS[] = R"(#version 300 es
+in float v_varying;
+struct s { float a; int b; vec2 c; };
+s[2] f()
+{
+    return s[2](s(v_varying, 1, vec2(1.0, 1.0)), s(v_varying / 2.0, 1, vec2(1.0, 1.0)));
+}
+void main()
+{
+    gl_Position = vec4(f()[uint(v_varying)].a, 0, 0, 1);
+})";
+
+    GLuint program = CompileProgram(kVS, essl3_shaders::fs::Red());
+    EXPECT_NE(0u, program);
+}
+
 // Verify that using invariant(all) in both shaders fails in ESSL 3.00.
 TEST_P(GLSLTest_ES3, InvariantAllBoth)
 {
@@ -8178,7 +8197,7 @@ TEST_P(GLSLTest, MemoryExhaustedTest)
 {
     ANGLE_SKIP_TEST_IF(IsD3D11_FL93());
     GLuint program =
-        CompileProgram(essl1_shaders::vs::Simple(), BuillBigInitialStackShader(36).c_str());
+        CompileProgram(essl1_shaders::vs::Simple(), BuildBigInitialStackShader(36).c_str());
     EXPECT_NE(0u, program);
 }