Vulkan: Support mixed column/row-major buffer fields

src/compiler.gni

@@ -136,6 +136,8 @@ angle_translator_sources = [
   "src/compiler/translator/tree_ops/InitializeVariables.h",
   "src/compiler/translator/tree_ops/NameEmbeddedUniformStructs.cpp",
   "src/compiler/translator/tree_ops/NameEmbeddedUniformStructs.h",
+  "src/compiler/translator/tree_ops/NameNamelessUniformBuffers.cpp",
+  "src/compiler/translator/tree_ops/NameNamelessUniformBuffers.h",
   "src/compiler/translator/tree_ops/PruneEmptyCases.cpp",
   "src/compiler/translator/tree_ops/PruneEmptyCases.h",
   "src/compiler/translator/tree_ops/PruneNoOps.cpp",
@@ -168,6 +170,8 @@ angle_translator_sources = [
   "src/compiler/translator/tree_ops/RewriteStructSamplers.h",
   "src/compiler/translator/tree_ops/RewriteRepeatedAssignToSwizzled.cpp",
   "src/compiler/translator/tree_ops/RewriteRepeatedAssignToSwizzled.h",
+  "src/compiler/translator/tree_ops/RewriteRowMajorMatrices.cpp",
+  "src/compiler/translator/tree_ops/RewriteRowMajorMatrices.h",
   "src/compiler/translator/tree_ops/RewriteTexelFetchOffset.cpp",
   "src/compiler/translator/tree_ops/RewriteTexelFetchOffset.h",
   "src/compiler/translator/tree_ops/RewriteUnaryMinusOperatorFloat.cpp",

src/compiler/translator/Common.h

@@ -71,6 +71,10 @@ class TVector : public std::vector<T, pool_allocator<T>>
     TVector() : std::vector<T, pool_allocator<T>>() {}
     TVector(const pool_allocator<T> &a) : std::vector<T, pool_allocator<T>>(a) {}
     TVector(size_type i) : std::vector<T, pool_allocator<T>>(i) {}
+    TVector(size_type i, const T &value) : std::vector<T, pool_allocator<T>>(i, value) {}
+    template <typename InputIt>
+    TVector(InputIt first, InputIt last) : std::vector<T, pool_allocator<T>>(first, last)
+    {}
     TVector(std::initializer_list<T> init) : std::vector<T, pool_allocator<T>>(init) {}
 };
 

src/compiler/translator/IntermNode.h

@@ -915,7 +915,7 @@ enum class PreprocessorDirective
 class TIntermPreprocessorDirective : public TIntermNode
 {
   public:
-    // This could also take an ImmutbleString as an argument.
+    // This could also take an ImmutableString as an argument.
     TIntermPreprocessorDirective(PreprocessorDirective directive, ImmutableString command);
     ~TIntermPreprocessorDirective() final;
 

src/compiler/translator/OutputGLSLBase.cpp

@@ -293,6 +293,35 @@ void TOutputGLSLBase::writeLayoutQualifier(TIntermTyped *variable)
     out << ") ";
 }
 
+void TOutputGLSLBase::writeFieldLayoutQualifier(const TField *field)
+{
+    if (!field->type()->isMatrix() && !field->type()->isStructureContainingMatrices())
+    {
+        return;
+    }
+
+    TInfoSinkBase &out = objSink();
+
+    out << "layout(";
+    switch (field->type()->getLayoutQualifier().matrixPacking)
+    {
+        case EmpUnspecified:
+        case EmpColumnMajor:
+            // Default matrix packing is column major.
+            out << "column_major";
+            break;
+
+        case EmpRowMajor:
+            out << "row_major";
+            break;
+
+        default:
+            UNREACHABLE();
+            break;
+    }
+    out << ") ";
+}
+
 void TOutputGLSLBase::writeQualifier(TQualifier qualifier, const TType &type, const TSymbol *symbol)
 {
     const char *result = mapQualifierToString(qualifier);
@@ -1312,27 +1341,7 @@ void TOutputGLSLBase::declareInterfaceBlock(const TInterfaceBlock *interfaceBloc
     const TFieldList &fields = interfaceBlock->fields();
     for (const TField *field : fields)
     {
-        if (field->type()->isMatrix() || field->type()->isStructureContainingMatrices())
-        {
-            out << "layout(";
-            switch (field->type()->getLayoutQualifier().matrixPacking)
-            {
-                case EmpUnspecified:
-                case EmpColumnMajor:
-                    // Default matrix packing is column major.
-                    out << "column_major";
-                    break;
-
-                case EmpRowMajor:
-                    out << "row_major";
-                    break;
-
-                default:
-                    UNREACHABLE();
-                    break;
-            }
-            out << ") ";
-        }
+        writeFieldLayoutQualifier(field);
 
         if (writeVariablePrecision(field->type()->getPrecision()))
             out << " ";

src/compiler/translator/OutputGLSLBase.h

@@ -43,6 +43,7 @@ class TOutputGLSLBase : public TIntermTraverser
     std::string getCommonLayoutQualifiers(TIntermTyped *variable);
     std::string getMemoryQualifiers(const TType &type);
     virtual void writeLayoutQualifier(TIntermTyped *variable);
+    virtual void writeFieldLayoutQualifier(const TField *field);
     void writeInvariantQualifier(const TType &type);
     virtual void writeVariableType(const TType &type, const TSymbol *symbol);
     virtual bool writeVariablePrecision(TPrecision precision) = 0;

src/compiler/translator/OutputVulkanGLSL.cpp

@@ -54,7 +54,6 @@ void TOutputVulkanGLSL::writeLayoutQualifier(TIntermTyped *variable)
     }
 
     TInfoSinkBase &out                      = objSink();
-    const TLayoutQualifier &layoutQualifier = type.getLayoutQualifier();
 
     // This isn't super clean, but it gets the job done.
     // See corresponding code in GlslangWrapper.cpp.
@@ -88,12 +87,12 @@ void TOutputVulkanGLSL::writeLayoutQualifier(TIntermTyped *variable)
         {
             blockStorage = getBlockStorageString(storage);
         }
-    }
 
-    // Specify matrix packing if necessary.
-    if (layoutQualifier.matrixPacking != EmpUnspecified)
-    {
-        matrixPacking = getMatrixPackingString(layoutQualifier.matrixPacking);
+        // We expect all interface blocks to have been transformed to column major, so we don't
+        // specify the packing.  Any remaining interface block qualified with row_major shouldn't
+        // have any matrices inside.
+        ASSERT(type.getLayoutQualifier().matrixPacking != EmpRowMajor ||
+               !interfaceBlock->containsMatrices());
     }
 
     if (needsCustomLayout)
@@ -132,6 +131,14 @@ void TOutputVulkanGLSL::writeLayoutQualifier(TIntermTyped *variable)
     }
 }
 
+void TOutputVulkanGLSL::writeFieldLayoutQualifier(const TField *field)
+{
+    // We expect all interface blocks to have been transformed to column major, as Vulkan GLSL
+    // doesn't allow layout qualifiers on interface block fields.  Any remaining interface block
+    // qualified with row_major shouldn't have any matrices inside, so the qualifier can be
+    // dropped.
+}
+
 void TOutputVulkanGLSL::writeQualifier(TQualifier qualifier,
                                        const TType &type,
                                        const TSymbol *symbol)

src/compiler/translator/OutputVulkanGLSL.h

@@ -31,6 +31,7 @@ class TOutputVulkanGLSL : public TOutputGLSL
 
   protected:
     void writeLayoutQualifier(TIntermTyped *variable) override;
+    void writeFieldLayoutQualifier(const TField *field) override;
     void writeQualifier(TQualifier qualifier, const TType &type, const TSymbol *symbol) override;
     void writeVariableType(const TType &type, const TSymbol *symbol) override;
     void visitSymbol(TIntermSymbol *node) override;

src/compiler/translator/TranslatorVulkan.cpp

@@ -17,9 +17,11 @@
 #include "compiler/translator/OutputVulkanGLSL.h"
 #include "compiler/translator/StaticType.h"
 #include "compiler/translator/tree_ops/NameEmbeddedUniformStructs.h"
+#include "compiler/translator/tree_ops/NameNamelessUniformBuffers.h"
 #include "compiler/translator/tree_ops/RewriteAtomicCounters.h"
 #include "compiler/translator/tree_ops/RewriteCubeMapSamplersAs2DArray.h"
 #include "compiler/translator/tree_ops/RewriteDfdy.h"
+#include "compiler/translator/tree_ops/RewriteRowMajorMatrices.h"
 #include "compiler/translator/tree_ops/RewriteStructSamplers.h"
 #include "compiler/translator/tree_util/BuiltIn_autogen.h"
 #include "compiler/translator/tree_util/FindFunction.h"
@@ -728,6 +730,25 @@ bool TranslatorVulkan::translate(TIntermBlock *root,
         }
     }
 
+    if (getShaderVersion() >= 300)
+    {
+        // Make sure every uniform buffer variable has a name.  The following transformation relies
+        // on this.
+        if (!NameNamelessUniformBuffers(this, root, &getSymbolTable()))
+        {
+            return false;
+        }
+
+        // In GLES3+, matrices can be declared row- or column-major.  Transform all to column-major
+        // as interface block field layout qualifiers are not allowed.  This should be done after
+        // samplers are taken out of structs (as structs could be rewritten), but before uniforms
+        // are collected in a uniform buffer as they are handled especially.
+        if (!RewriteRowMajorMatrices(this, root, &getSymbolTable()))
+        {
+            return false;
+        }
+    }
+
     if (defaultUniformCount > 0)
     {
         sink << "\n@@ LAYOUT-defaultUniforms(std140) @@ uniform defaultUniforms\n{\n";

src/compiler/translator/tree_ops/NameNamelessUniformBuffers.cpp

+//
+// Copyright 2019 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.
+//
+// NameNamelessUniformBuffers: Gives nameless uniform buffer variables internal names.
+//
+
+#include "compiler/translator/tree_ops/NameNamelessUniformBuffers.h"
+
+#include "compiler/translator/SymbolTable.h"
+#include "compiler/translator/tree_util/IntermNode_util.h"
+#include "compiler/translator/tree_util/IntermTraverse.h"
+
+namespace sh
+{
+namespace
+{
+// Traverse uniform buffer declarations and give name to nameless declarations.  Keeps track of
+// the interface fields which will be used in the source without the interface block variable name
+// and replaces them with name.field.
+class NameUniformBufferVariablesTraverser : public TIntermTraverser
+{
+  public:
+    explicit NameUniformBufferVariablesTraverser(TSymbolTable *symbolTable)
+        : TIntermTraverser(true, false, false, symbolTable)
+    {}
+
+    bool visitDeclaration(Visit visit, TIntermDeclaration *decl) override
+    {
+        ASSERT(visit == PreVisit);
+
+        const TIntermSequence &sequence = *(decl->getSequence());
+
+        TIntermTyped *variableNode = sequence.front()->getAsTyped();
+        const TType &type          = variableNode->getType();
+
+        // If it's an interface block, it may have to be converted if it contains any row-major
+        // fields.
+        if (!type.isInterfaceBlock())
+        {
+            return true;
+        }
+
+        // Multi declaration statements are already separated, so there can only be one variable
+        // here.
+        ASSERT(sequence.size() == 1);
+        const TVariable *variable = &variableNode->getAsSymbolNode()->variable();
+        if (variable->symbolType() != SymbolType::Empty)
+        {
+            return false;
+        }
+
+        TIntermDeclaration *newDeclaration = new TIntermDeclaration;
+        TVariable *newVariable = new TVariable(mSymbolTable, kEmptyImmutableString, &type,
+                                               SymbolType::AngleInternal, variable->extension());
+        newDeclaration->appendDeclarator(new TIntermSymbol(newVariable));
+
+        queueReplacement(newDeclaration, OriginalNode::IS_DROPPED);
+
+        // It's safe to key the map with the interface block, as there couldn't have been multiple
+        // declarations with this interface block (as the variable is nameless), so for nameless
+        // uniform buffers, the interface block is unique.
+        mNamelessUniformBuffersMap[type.getInterfaceBlock()] = newVariable;
+
+        return false;
+    }
+
+    void visitSymbol(TIntermSymbol *symbol) override
+    {
+        const TType &type = symbol->getType();
+
+        // The symbols we are looking for have the interface block pointer set, but are not
+        // interface blocks.  These are references to fields of nameless uniform buffers.
+        if (type.isInterfaceBlock() || type.getInterfaceBlock() == nullptr)
+        {
+            return;
+        }
+
+        const TInterfaceBlock *block = type.getInterfaceBlock();
+
+        // If block variable is not nameless, there's nothing to do.
+        if (mNamelessUniformBuffersMap.count(block) == 0)
+        {
+            return;
+        }
+
+        const ImmutableString symbolName = symbol->getName();
+
+        // Find which field it is
+        const TVector<TField *> fields = block->fields();
+        for (size_t fieldIndex = 0; fieldIndex < fields.size(); ++fieldIndex)
+        {
+            const TField *field = fields[fieldIndex];
+            if (field->name() != symbolName)
+            {
+                continue;
+            }
+
+            // Replace this node with a binary node that indexes the named uniform buffer.
+            TIntermSymbol *namedUniformBuffer =
+                new TIntermSymbol(mNamelessUniformBuffersMap[block]);
+            TIntermBinary *replacement =
+                new TIntermBinary(EOpIndexDirectInterfaceBlock, namedUniformBuffer,
+                                  CreateIndexNode(static_cast<uint32_t>(fieldIndex)));
+
+            queueReplacement(replacement, OriginalNode::IS_DROPPED);
+
+            return;
+        }
+
+        UNREACHABLE();
+    }
+
+  private:
+    // A map from nameless uniform buffers to their named replacements.
+    std::unordered_map<const TInterfaceBlock *, const TVariable *> mNamelessUniformBuffersMap;
+};
+}  // anonymous namespace
+
+bool NameNamelessUniformBuffers(TCompiler *compiler, TIntermBlock *root, TSymbolTable *symbolTable)
+{
+    NameUniformBufferVariablesTraverser nameUniformBufferVariables(symbolTable);
+    root->traverse(&nameUniformBufferVariables);
+    return nameUniformBufferVariables.updateTree(compiler, root);
+}
+}  // namespace sh

src/compiler/translator/tree_ops/NameNamelessUniformBuffers.h

+//
+// Copyright 2019 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.
+//
+// NameNamelessUniformBuffers: Gives nameless uniform buffer variables internal names.
+//
+// For example:
+//   uniform UniformBuffer { int a; };
+//   x = a;
+// becomes:
+//   uniform UniformBuffer { int a; } s123;
+//   x = s123.a;
+//
+
+#ifndef COMPILER_TRANSLATOR_TREEOPS_NAMENAMELESSUNIFORMBUFFERS_H_
+#define COMPILER_TRANSLATOR_TREEOPS_NAMENAMELESSUNIFORMBUFFERS_H_
+
+#include "common/angleutils.h"
+
+namespace sh
+{
+class TCompiler;
+class TIntermBlock;
+class TSymbolTable;
+
+ANGLE_NO_DISCARD bool NameNamelessUniformBuffers(TCompiler *compiler,
+                                                 TIntermBlock *root,
+                                                 TSymbolTable *symbolTable);
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_TREEOPS_NAMENAMELESSUNIFORMBUFFERS_H_

src/compiler/translator/tree_ops/RewriteRowMajorMatrices.h

+//
+// Copyright 2019 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.
+//
+// RewriteRowMajorMatrices: Change row-major matrices to column-major in uniform and storage
+// buffers.
+
+#ifndef COMPILER_TRANSLATOR_TREEOPS_REWRITEROWMAJORMATRICES_H_
+#define COMPILER_TRANSLATOR_TREEOPS_REWRITEROWMAJORMATRICES_H_
+
+#include "common/angleutils.h"
+
+namespace sh
+{
+class TCompiler;
+class TIntermBlock;
+class TSymbolTable;
+
+ANGLE_NO_DISCARD bool RewriteRowMajorMatrices(TCompiler *compiler,
+                                              TIntermBlock *root,
+                                              TSymbolTable *symbolTable);
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_TREEOPS_REWRITEROWMAJORMATRICES_H_

src/compiler/translator/tree_util/IntermTraverse.h

@@ -133,10 +133,13 @@ class TIntermTraverser : angle::NonCopyable
     friend void TIntermConstantUnion::traverse(TIntermTraverser *);
     friend void TIntermFunctionPrototype::traverse(TIntermTraverser *);
 
-    TIntermNode *getParentNode() { return mPath.size() <= 1 ? nullptr : mPath[mPath.size() - 2u]; }
+    TIntermNode *getParentNode() const
+    {
+        return mPath.size() <= 1 ? nullptr : mPath[mPath.size() - 2u];
+    }
 
     // Return the nth ancestor of the node being traversed. getAncestorNode(0) == getParentNode()
-    TIntermNode *getAncestorNode(unsigned int n)
+    TIntermNode *getAncestorNode(unsigned int n) const
     {
         if (mPath.size() > n + 1u)
         {
@@ -147,6 +150,12 @@ class TIntermTraverser : angle::NonCopyable
 
     const TIntermBlock *getParentBlock() const;
 
+    TIntermNode *getRootNode() const
+    {
+        ASSERT(!mPath.empty());
+        return mPath.front();
+    }
+
     void pushParentBlock(TIntermBlock *node);
     void incrementParentBlockPos();
     void popParentBlock();

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -715,21 +715,6 @@
 3520 VULKAN : dEQP-GLES31.functional.state_query.texture_level.texture_2d.compressed_integer = SKIP
 3520 VULKAN : dEQP-GLES31.functional.state_query.texture_level.texture_2d.compressed_float = SKIP
 
-// column/row_major specified on struct member:
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.2 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.9 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.12 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.16 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.23 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.25 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.29 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_per_block_buffers.33 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_shared_buffer.3 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_shared_buffer.11 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_shared_buffer.25 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_shared_buffer.39 = FAIL
-3443 VULKAN : dEQP-GLES31.functional.ubo.random.all_shared_buffer.45 = FAIL
-
 // Inactive SSBOs with flexible array member (about 20% of these tests are affected):
 3714 VULKAN : dEQP-GLES31.functional.ssbo.layout.random.* = FAIL
 

src/tests/deqp_support/deqp_gles3_test_expectations.txt

@@ -560,29 +560,6 @@
 3219 VULKAN : dEQP-GLES3.functional.negative_api.shader.link_program = FAIL
 3219 VULKAN : dEQP-GLES3.functional.negative_api.shader.use_program = FAIL
 
-// column/row_major specified on struct member:
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_arrays.10 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_per_block_buffers.8 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_per_block_buffers.17 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_per_block_buffers.25 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_per_block_buffers.49 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_shared_buffer.11 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.all_shared_buffer.48 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_arrays.18 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_arrays.20 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_arrays.23 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_arrays.8 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.basic_instance_arrays.13 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs.12 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs.17 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs.5 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_arrays.2 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_arrays.3 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_arrays.4 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_instance_arrays.12 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_instance_arrays.18 = FAIL
-3443 VULKAN : dEQP-GLES3.functional.ubo.random.nested_structs_instance_arrays.24 = FAIL
-
 3221 VULKAN : dEQP-GLES3.functional.instanced.draw_elements_instanced.attribute_divisor.2*_instances = FAIL
 3221 VULKAN : dEQP-GLES3.functional.instanced.draw_elements_instanced.attribute_divisor.4_instances = FAIL
 3221 VULKAN : dEQP-GLES3.functional.instanced.draw_elements_instanced.mixed.2*_instances = FAIL

src/tests/deqp_support/deqp_khr_gles3_test_expectations.txt

@@ -115,17 +115,5 @@
 3818 VULKAN : KHR-GLES3.copy_tex_image_conversions.forbidden.renderbuffer_cubemap_posy = FAIL
 3818 VULKAN : KHR-GLES3.copy_tex_image_conversions.forbidden.renderbuffer_cubemap_posz = FAIL
 
-// column/row_major specified on struct member:
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.all_per_block_buffers.16 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.all_per_block_buffers.3 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.all_per_block_buffers.5 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.all_per_block_buffers.7 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.all_shared_buffer.0 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.basic_instance_arrays.0 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.basic_instance_arrays.4 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.basic_instance_arrays.5 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.nested_structs_arrays.7 = FAIL
-3443 VULKAN : KHR-GLES3.shaders.uniform_block.random.nested_structs_arrays_instance_arrays.3 = FAIL
-
 // Require 3D textures.
 3188 VULKAN : KHR-GLES3.packed_pixels.varied_rectangle.* = SKIP

src/tests/gl_tests/UniformBufferTest.cpp

@@ -1596,6 +1596,10 @@ TEST_P(UniformBufferTest, SizeOver65535)
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
 ANGLE_INSTANTIATE_TEST(UniformBufferTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES(), ES3_VULKAN());
-ANGLE_INSTANTIATE_TEST(UniformBufferTest31, ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES());
+ANGLE_INSTANTIATE_TEST(UniformBufferTest31,
+                       ES31_D3D11(),
+                       ES31_OPENGL(),
+                       ES31_OPENGLES(),
+                       ES31_VULKAN());
 
 }  // namespace