ES31 program query: support AtomicCounterBuffer and UniformBlock

src/libANGLE/Program.cpp

@@ -1659,6 +1659,11 @@ GLuint Program::getActiveUniformBlockCount() const
     return static_cast<GLuint>(mState.mUniformBlocks.size());
 }
 
+GLuint Program::getActiveAtomicCounterBufferCount() const
+{
+    return static_cast<GLuint>(mState.mAtomicCounterBuffers.size());
+}
+
 GLuint Program::getActiveShaderStorageBlockCount() const
 {
     return static_cast<GLuint>(mState.mShaderStorageBlocks.size());
@@ -2006,6 +2011,7 @@ bool Program::linkAtomicCounterBuffers()
                 buffer.memberIndexes.push_back(index);
                 uniform.bufferIndex = bufferIndex;
                 found               = true;
+                buffer.unionReferencesWith(uniform);
                 break;
             }
         }
@@ -2014,6 +2020,7 @@ bool Program::linkAtomicCounterBuffers()
             AtomicCounterBuffer atomicCounterBuffer;
             atomicCounterBuffer.binding = uniform.binding;
             atomicCounterBuffer.memberIndexes.push_back(index);
+            atomicCounterBuffer.unionReferencesWith(uniform);
             mState.mAtomicCounterBuffers.push_back(atomicCounterBuffer);
             uniform.bufferIndex = static_cast<int>(mState.mAtomicCounterBuffers.size() - 1);
         }

src/libANGLE/Program.h

@@ -496,6 +496,7 @@ class Program final : angle::NonCopyable, public LabeledObject
 
     void getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const;
     GLuint getActiveUniformBlockCount() const;
+    GLuint getActiveAtomicCounterBufferCount() const;
     GLuint getActiveShaderStorageBlockCount() const;
     GLint getActiveUniformBlockMaxLength() const;
 

src/libANGLE/Uniform.cpp

@@ -46,7 +46,7 @@ void StaticallyUsed::setStaticUse(GLenum shaderType, bool used)
     }
 }
 
-void StaticallyUsed::unionWith(const StaticallyUsed &other)
+void StaticallyUsed::unionReferencesWith(const StaticallyUsed &other)
 {
     vertexStaticUse |= other.vertexStaticUse;
     fragmentStaticUse |= other.fragmentStaticUse;

src/libANGLE/Uniform.h

@@ -29,7 +29,7 @@ struct StaticallyUsed
     StaticallyUsed &operator=(const StaticallyUsed &rhs);
 
     void setStaticUse(GLenum shaderType, bool used);
-    void unionWith(const StaticallyUsed &other);
+    void unionReferencesWith(const StaticallyUsed &other);
 
     bool vertexStaticUse;
     bool fragmentStaticUse;

src/libANGLE/queryutils.cpp

@@ -543,11 +543,13 @@ GLint QueryProgramInterfaceActiveResources(const Program *program, GLenum progra
         case GL_UNIFORM_BLOCK:
             return clampCast<GLint>(program->getState().getUniformBlocks().size());
 
+        case GL_ATOMIC_COUNTER_BUFFER:
+            return clampCast<GLint>(program->getState().getAtomicCounterBuffers().size());
+
         // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_TRANSFORM_FEEDBACK_VARYING:
         case GL_BUFFER_VARIABLE:
         case GL_SHADER_STORAGE_BLOCK:
-        case GL_ATOMIC_COUNTER_BUFFER:
             UNIMPLEMENTED();
             return 0;
 
@@ -613,10 +615,12 @@ GLint QueryProgramInterfaceMaxNumActiveVariables(const Program *program, GLenum
         case GL_UNIFORM_BLOCK:
             return FindMaxSize(program->getState().getUniformBlocks(),
                                &InterfaceBlock::memberIndexes);
+        case GL_ATOMIC_COUNTER_BUFFER:
+            return FindMaxSize(program->getState().getAtomicCounterBuffers(),
+                               &AtomicCounterBuffer::memberIndexes);
 
         // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_SHADER_STORAGE_BLOCK:
-        case GL_ATOMIC_COUNTER_BUFFER:
             UNIMPLEMENTED();
             return 0;
 
@@ -652,6 +656,117 @@ GLenum GetUniformPropertyEnum(GLenum prop)
     }
 }
 
+GLenum GetUniformBlockPropertyEnum(GLenum prop)
+{
+    switch (prop)
+    {
+        case GL_UNIFORM_BLOCK_BINDING:
+            return GL_BUFFER_BINDING;
+
+        case GL_UNIFORM_BLOCK_DATA_SIZE:
+            return GL_BUFFER_DATA_SIZE;
+
+        case GL_UNIFORM_BLOCK_NAME_LENGTH:
+            return GL_NAME_LENGTH;
+
+        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+            return GL_NUM_ACTIVE_VARIABLES;
+
+        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
+            return GL_ACTIVE_VARIABLES;
+
+        case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+            return GL_REFERENCED_BY_VERTEX_SHADER;
+
+        case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+            return GL_REFERENCED_BY_FRAGMENT_SHADER;
+
+        default:
+            return prop;
+    }
+}
+
+void GetShaderVariableBufferResourceProperty(const ShaderVariableBuffer &buffer,
+                                             GLenum pname,
+                                             GLint *params,
+                                             GLsizei bufSize,
+                                             GLsizei *outputPosition)
+
+{
+    switch (pname)
+    {
+        case GL_BUFFER_BINDING:
+            params[(*outputPosition)++] = buffer.binding;
+            break;
+        case GL_BUFFER_DATA_SIZE:
+            params[(*outputPosition)++] = clampCast<GLint>(buffer.dataSize);
+            break;
+        case GL_NUM_ACTIVE_VARIABLES:
+            params[(*outputPosition)++] = buffer.numActiveVariables();
+            break;
+        case GL_ACTIVE_VARIABLES:
+            for (size_t memberIndex = 0;
+                 memberIndex < buffer.memberIndexes.size() && *outputPosition < bufSize;
+                 ++memberIndex)
+            {
+                params[(*outputPosition)++] = clampCast<GLint>(buffer.memberIndexes[memberIndex]);
+            }
+            break;
+        case GL_REFERENCED_BY_VERTEX_SHADER:
+            params[(*outputPosition)++] = static_cast<GLint>(buffer.vertexStaticUse);
+            break;
+        case GL_REFERENCED_BY_FRAGMENT_SHADER:
+            params[(*outputPosition)++] = static_cast<GLint>(buffer.fragmentStaticUse);
+            break;
+        case GL_REFERENCED_BY_COMPUTE_SHADER:
+            params[(*outputPosition)++] = static_cast<GLint>(buffer.computeStaticUse);
+            break;
+        default:
+            UNREACHABLE();
+            break;
+    }
+}
+
+void GetInterfaceBlockResourceProperty(const InterfaceBlock &block,
+                                       GLenum pname,
+                                       GLint *params,
+                                       GLsizei bufSize,
+                                       GLsizei *outputPosition)
+{
+    if (pname == GL_NAME_LENGTH)
+    {
+        params[(*outputPosition)++] = clampCast<GLint>(block.nameWithArrayIndex().size() + 1);
+        return;
+    }
+    GetShaderVariableBufferResourceProperty(block, pname, params, bufSize, outputPosition);
+}
+
+void GetUniformBlockResourceProperty(const Program *program,
+                                     GLuint blockIndex,
+                                     GLenum pname,
+                                     GLint *params,
+                                     GLsizei bufSize,
+                                     GLsizei *outputPosition)
+
+{
+    ASSERT(*outputPosition < bufSize);
+    const auto &block = program->getUniformBlockByIndex(blockIndex);
+    GetInterfaceBlockResourceProperty(block, pname, params, bufSize, outputPosition);
+}
+
+void GetAtomicCounterBufferResourceProperty(const Program *program,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLint *params,
+                                            GLsizei bufSize,
+                                            GLsizei *outputPosition)
+
+{
+    ASSERT(*outputPosition < bufSize);
+    const auto &buffer = program->getState().getAtomicCounterBuffers()[index];
+    GetShaderVariableBufferResourceProperty(buffer, pname, params, bufSize, outputPosition);
+}
+
 }  // anonymous namespace
 
 void QueryFramebufferAttachmentParameteriv(const Framebuffer *framebuffer,
@@ -861,6 +976,9 @@ void QueryProgramiv(const Context *context, const Program *program, GLenum pname
             params[2]                          = localSize[2];
         }
         break;
+        case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
+            *params = program->getActiveAtomicCounterBufferCount();
+            break;
         default:
             UNREACHABLE();
             break;
@@ -1044,39 +1162,9 @@ void QueryActiveUniformBlockiv(const Program *program,
                                GLenum pname,
                                GLint *params)
 {
-    const InterfaceBlock &uniformBlock = program->getUniformBlockByIndex(uniformBlockIndex);
-    switch (pname)
-    {
-        case GL_UNIFORM_BLOCK_BINDING:
-            *params = clampCast<GLint>(program->getUniformBlockBinding(uniformBlockIndex));
-            break;
-        case GL_UNIFORM_BLOCK_DATA_SIZE:
-            *params = clampCast<GLint>(uniformBlock.dataSize);
-            break;
-        case GL_UNIFORM_BLOCK_NAME_LENGTH:
-            *params = clampCast<GLint>(uniformBlock.nameWithArrayIndex().size() + 1);
-            break;
-        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
-            *params = clampCast<GLint>(uniformBlock.memberIndexes.size());
-            break;
-        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
-            for (size_t blockMemberIndex = 0; blockMemberIndex < uniformBlock.memberIndexes.size();
-                 blockMemberIndex++)
-            {
-                params[blockMemberIndex] =
-                    clampCast<GLint>(uniformBlock.memberIndexes[blockMemberIndex]);
-            }
-            break;
-        case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
-            *params = static_cast<GLint>(uniformBlock.vertexStaticUse);
-            break;
-        case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
-            *params = static_cast<GLint>(uniformBlock.fragmentStaticUse);
-            break;
-        default:
-            UNREACHABLE();
-            break;
-    }
+    GLenum prop = GetUniformBlockPropertyEnum(pname);
+    QueryProgramResourceiv(program, GL_UNIFORM_BLOCK, uniformBlockIndex, 1, &prop,
+                           std::numeric_limits<GLsizei>::max(), nullptr, params);
 }
 
 void QueryInternalFormativ(const TextureCaps &format, GLenum pname, GLsizei bufSize, GLint *params)
@@ -1317,8 +1405,10 @@ GLuint QueryProgramResourceIndex(const Program *program,
         case GL_UNIFORM:
             return program->getState().getUniformIndexFromName(name);
 
-        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_UNIFORM_BLOCK:
+            return program->getUniformBlockIndex(name);
+
+        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_TRANSFORM_FEEDBACK_VARYING:
         case GL_BUFFER_VARIABLE:
         case GL_SHADER_STORAGE_BLOCK:
@@ -1352,8 +1442,11 @@ void QueryProgramResourceName(const Program *program,
             program->getUniformResourceName(index, bufSize, length, name);
             break;
 
-        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_UNIFORM_BLOCK:
+            program->getActiveUniformBlockName(index, bufSize, length, name);
+            break;
+
+        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_TRANSFORM_FEEDBACK_VARYING:
         case GL_BUFFER_VARIABLE:
         case GL_SHADER_STORAGE_BLOCK:
@@ -1380,14 +1473,6 @@ GLint QueryProgramResourceLocation(const Program *program,
         case GL_UNIFORM:
             return program->getState().getUniformLocation(name);
 
-        // TODO(jie.a.chen@intel.com): more interfaces.
-        case GL_UNIFORM_BLOCK:
-        case GL_TRANSFORM_FEEDBACK_VARYING:
-        case GL_BUFFER_VARIABLE:
-        case GL_SHADER_STORAGE_BLOCK:
-            UNIMPLEMENTED();
-            return -1;
-
         default:
             UNREACHABLE();
             return -1;
@@ -1412,34 +1497,37 @@ void QueryProgramResourceiv(const Program *program,
         return;
     }
 
-    GLsizei count = std::min(propCount, bufSize);
-    if (length != nullptr)
-    {
-        *length = count;
-    }
-
-    for (GLsizei i = 0; i < count; i++)
+    GLsizei pos = 0;
+    for (GLsizei i = 0; i < propCount; i++)
     {
         switch (programInterface)
         {
             case GL_PROGRAM_INPUT:
                 params[i] = GetInputResourceProperty(program, index, props[i]);
+                ++pos;
                 break;
 
             case GL_PROGRAM_OUTPUT:
                 params[i] = GetOutputResourceProperty(program, index, props[i]);
+                ++pos;
                 break;
 
             case GL_UNIFORM:
                 params[i] = GetUniformResourceProperty(program, index, props[i]);
+                ++pos;
+                break;
+            case GL_UNIFORM_BLOCK:
+                GetUniformBlockResourceProperty(program, index, props[i], params, bufSize, &pos);
                 break;
 
+            case GL_ATOMIC_COUNTER_BUFFER:
+                GetAtomicCounterBufferResourceProperty(program, index, props[i], params, bufSize,
+                                                       &pos);
+                break;
             // TODO(jie.a.chen@intel.com): more interfaces.
-            case GL_UNIFORM_BLOCK:
             case GL_TRANSFORM_FEEDBACK_VARYING:
             case GL_BUFFER_VARIABLE:
             case GL_SHADER_STORAGE_BLOCK:
-            case GL_ATOMIC_COUNTER_BUFFER:
                 UNIMPLEMENTED();
                 params[i] = GL_INVALID_VALUE;
                 break;
@@ -1448,6 +1536,17 @@ void QueryProgramResourceiv(const Program *program,
                 UNREACHABLE();
                 params[i] = GL_INVALID_VALUE;
         }
+        if (pos == bufSize)
+        {
+            // Most properties return one value, but GL_ACTIVE_VARIABLES returns an array of values.
+            // This checks not to break buffer bounds for such case.
+            break;
+        }
+    }
+
+    if (length != nullptr)
+    {
+        *length = pos;
     }
 }
 

src/libANGLE/validationES.cpp

@@ -4153,6 +4153,7 @@ bool ValidateGetProgramivBase(ValidationContext *context,
 
         case GL_PROGRAM_SEPARABLE:
         case GL_COMPUTE_WORK_GROUP_SIZE:
+        case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
             if (context->getClientVersion() < Version(3, 1))
             {
                 ANGLE_VALIDATION_ERR(context, InvalidEnum(), ES31Required);

src/libANGLE/validationES31.cpp

@@ -260,12 +260,16 @@ bool ValidateProgramResourceIndex(const Program *programObject,
         case GL_UNIFORM:
             return (index < static_cast<GLuint>(programObject->getActiveUniformCount()));
 
-        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_UNIFORM_BLOCK:
+            return (index < programObject->getActiveUniformBlockCount());
+
+        case GL_ATOMIC_COUNTER_BUFFER:
+            return (index < programObject->getActiveAtomicCounterBufferCount());
+
+        // TODO(jie.a.chen@intel.com): more interfaces.
         case GL_TRANSFORM_FEEDBACK_VARYING:
         case GL_BUFFER_VARIABLE:
         case GL_SHADER_STORAGE_BLOCK:
-        case GL_ATOMIC_COUNTER_BUFFER:
             UNIMPLEMENTED();
             return false;
 

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -28,6 +28,8 @@
 1659 NVIDIA OPENGL : dEQP-GLES31.functional.draw_indirect.random.10 = SKIP
 1659 NVIDIA OPENGL : dEQP-GLES31.functional.draw_indirect.random.15 = SKIP
 1659 NVIDIA OPENGL : dEQP-GLES31.functional.draw_indirect.random.18 = SKIP
+1920 NVIDIA OPENGL : dEQP-GLES31.functional.layout_binding.ubo.vertex_binding_array = SKIP
+1920 NVIDIA D3D11 : dEQP-GLES31.functional.layout_binding.ubo.vertex_binding_max = SKIP
 1442 OPENGL D3D11 : dEQP-GLES31.functional.program_interface_query.transform_feedback_varying.resource_list.vertex_fragment.builtin_gl_position = SKIP
 1442 OPENGL D3D11 : dEQP-GLES31.functional.program_interface_query.transform_feedback_varying.resource_list.vertex_fragment.default_block_struct_member = SKIP
 1442 OPENGL D3D11 : dEQP-GLES31.functional.program_interface_query.transform_feedback_varying.array_size.vertex_fragment.default_block_struct_member = SKIP
@@ -80,6 +82,8 @@
 1442 D3D11 : dEQP-GLES31.functional.debug.error_groups.case_3 = SKIP
 1442 D3D11 : dEQP-GLES31.functional.debug.error_groups.case_9 = SKIP
 1442 D3D11 : dEQP-GLES31.functional.debug.error_groups.case_10 = SKIP
+1442 D3D11 : dEQP-GLES31.functional.state_query.program.active_atomic_counter_buffers_get_programiv = FAIL
+1442 D3D11 : dEQP-GLES31.functional.layout_binding.ubo.* = FAIL
 
 // OPENGL Failing Tests
 1665 WIN NVIDIA OPENGL : dEQP-GLES31.functional.draw_indirect.negative.command_offset_not_in_buffer_unsigned32_wrap = FAIL
@@ -1254,7 +1258,6 @@
 1442 OPENGL D3D11 : dEQP-GLES31.functional.state_query.internal_format.partial_query.num_sample_counts = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.state_query.internal_format.partial_query.samples = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.state_query.program.program_separable_get_programiv = FAIL
-1442 OPENGL D3D11 : dEQP-GLES31.functional.state_query.program.active_atomic_counter_buffers_get_programiv = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.state_query.program_pipeline.* = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.synchronization.* = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.geometry_shading.query.geometry_linked_vertices_out = FAIL
@@ -1305,7 +1308,6 @@
 1442 OPENGL D3D11 : dEQP-GLES31.functional.debug.negative_coverage.get_error.shader_directive.tessellation_shader = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.debug.object_labels.program_pipeline = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.program_interface_query.* = FAIL
-1442 OPENGL D3D11 : dEQP-GLES31.functional.layout_binding.ubo.* = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.layout_binding.ssbo.* = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.layout_binding.image.image2d.* = FAIL
 1442 OPENGL D3D11 : dEQP-GLES31.functional.layout_binding.image.image3d.* = FAIL

src/tests/gl_tests/ProgramInterfaceTest.cpp

@@ -159,9 +159,9 @@ TEST_P(ProgramInterfaceTestES31, GetResourceLocation)
 
     ANGLE_GL_PROGRAM(program, vertexShaderSource, fragmentShaderSource);
 
-    std::array<GLenum, 5> invalidInterfaces = {{GL_UNIFORM_BLOCK, GL_TRANSFORM_FEEDBACK_VARYING,
+    GLenum invalidInterfaces[] = {GL_UNIFORM_BLOCK, GL_TRANSFORM_FEEDBACK_VARYING,
                                   GL_BUFFER_VARIABLE, GL_SHADER_STORAGE_BLOCK,
-                                                GL_ATOMIC_COUNTER_BUFFER}};
+                                  GL_ATOMIC_COUNTER_BUFFER};
     GLint location;
     for (auto &invalidInterface : invalidInterfaces)
     {
@@ -221,16 +221,21 @@ TEST_P(ProgramInterfaceTestES31, GetResource)
     EXPECT_GL_NO_ERROR();
     EXPECT_NE(GL_INVALID_INDEX, index);
 
-    constexpr int kPropCount = 7;
-    std::array<GLint, kPropCount> params;
+    GLenum props[]    = {GL_TYPE,
+                      GL_ARRAY_SIZE,
+                      GL_LOCATION,
+                      GL_NAME_LENGTH,
+                      GL_REFERENCED_BY_VERTEX_SHADER,
+                      GL_REFERENCED_BY_FRAGMENT_SHADER,
+                      GL_REFERENCED_BY_COMPUTE_SHADER};
+    GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
+    GLint params[ArraySize(props)];
     GLsizei length;
-    std::array<GLenum, kPropCount> props = {
-        {GL_TYPE, GL_ARRAY_SIZE, GL_LOCATION, GL_NAME_LENGTH, GL_REFERENCED_BY_VERTEX_SHADER,
-         GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_COMPUTE_SHADER}};
-    glGetProgramResourceiv(program, GL_PROGRAM_INPUT, index, kPropCount, props.data(), kPropCount,
-                           &length, params.data());
+
+    glGetProgramResourceiv(program, GL_PROGRAM_INPUT, index, propCount, props, propCount, &length,
+                           params);
     EXPECT_GL_NO_ERROR();
-    EXPECT_EQ(kPropCount, length);
+    EXPECT_EQ(propCount, length);
     EXPECT_EQ(GL_FLOAT_VEC4, params[0]);  // type
     EXPECT_EQ(1, params[1]);              // array_size
     EXPECT_EQ(3, params[2]);              // location
@@ -242,10 +247,11 @@ TEST_P(ProgramInterfaceTestES31, GetResource)
     index = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "oColor[0]");
     EXPECT_GL_NO_ERROR();
     EXPECT_NE(index, GL_INVALID_INDEX);
-    glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, kPropCount, props.data(),
-                           kPropCount - 1, &length, params.data());
+    // bufSize is smaller than propCount.
+    glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, propCount, props, propCount - 1,
+                           &length, params);
     EXPECT_GL_NO_ERROR();
-    EXPECT_EQ(kPropCount - 1, length);
+    EXPECT_EQ(propCount - 1, length);
     EXPECT_EQ(GL_FLOAT_VEC4, params[0]);  // type
     EXPECT_EQ(4, params[1]);              // array_size
     EXPECT_EQ(2, params[2]);              // location
@@ -255,7 +261,7 @@ TEST_P(ProgramInterfaceTestES31, GetResource)
 
     GLenum invalidOutputProp = GL_OFFSET;
     glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, 1, &invalidOutputProp, 1, &length,
-                           params.data());
+                           params);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }
 
@@ -374,17 +380,25 @@ TEST_P(ProgramInterfaceTestES31, GetUniformProperties)
     EXPECT_GL_NO_ERROR();
     EXPECT_EQ(12, location);
 
-    constexpr int kPropCount = 13;
-    std::array<GLint, kPropCount> params;
-    std::array<GLenum, kPropCount> props = {
-        {GL_TYPE, GL_ARRAY_SIZE, GL_LOCATION, GL_NAME_LENGTH, GL_REFERENCED_BY_VERTEX_SHADER,
-         GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_COMPUTE_SHADER, GL_ARRAY_STRIDE,
-         GL_BLOCK_INDEX, GL_IS_ROW_MAJOR, GL_MATRIX_STRIDE, GL_OFFSET,
-         GL_ATOMIC_COUNTER_BUFFER_INDEX}};
-    glGetProgramResourceiv(program, GL_UNIFORM, index, kPropCount, props.data(), kPropCount,
-                           &length, params.data());
-    EXPECT_GL_NO_ERROR();
-    EXPECT_EQ(kPropCount, length);
+    GLenum props[]    = {GL_TYPE,
+                      GL_ARRAY_SIZE,
+                      GL_LOCATION,
+                      GL_NAME_LENGTH,
+                      GL_REFERENCED_BY_VERTEX_SHADER,
+                      GL_REFERENCED_BY_FRAGMENT_SHADER,
+                      GL_REFERENCED_BY_COMPUTE_SHADER,
+                      GL_ARRAY_STRIDE,
+                      GL_BLOCK_INDEX,
+                      GL_IS_ROW_MAJOR,
+                      GL_MATRIX_STRIDE,
+                      GL_OFFSET,
+                      GL_ATOMIC_COUNTER_BUFFER_INDEX};
+    GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
+    GLint params[ArraySize(props)];
+    glGetProgramResourceiv(program, GL_UNIFORM, index, propCount, props, propCount, &length,
+                           params);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(propCount, length);
     EXPECT_EQ(GL_FLOAT_VEC4, params[0]);  // type
     EXPECT_EQ(1, params[1]);              // array_size
     EXPECT_EQ(12, params[2]);             // location
@@ -412,10 +426,10 @@ TEST_P(ProgramInterfaceTestES31, GetUniformProperties)
     EXPECT_GL_NO_ERROR();
     EXPECT_EQ(-1, location);
 
-    glGetProgramResourceiv(program, GL_UNIFORM, index, kPropCount, props.data(), kPropCount,
-                           &length, params.data());
+    glGetProgramResourceiv(program, GL_UNIFORM, index, propCount, props, propCount, &length,
+                           params);
     EXPECT_GL_NO_ERROR();
-    EXPECT_EQ(kPropCount, length);
+    EXPECT_EQ(propCount, length);
     EXPECT_EQ(GL_UNSIGNED_INT_ATOMIC_COUNTER, params[0]);  // type
     EXPECT_EQ(1, params[1]);                               // array_size
     EXPECT_EQ(-1, params[2]);                              // location
@@ -431,6 +445,141 @@ TEST_P(ProgramInterfaceTestES31, GetUniformProperties)
     EXPECT_NE(-1, params[12]);                             // atomic_counter_buffer_index
 }
 
+// Tests the resource property query for uniform block can be done correctly.
+TEST_P(ProgramInterfaceTestES31, GetUniformBlockProperties)
+{
+    const std::string &vertexShaderSource =
+        "#version 310 es\n"
+        "in vec2 position;\n"
+        "out vec2 v;\n"
+        "layout(binding = 2) uniform blockName {\n"
+        "  float f1;\n"
+        "  float f2;\n"
+        "} instanceName;\n"
+        "void main() {\n"
+        "  v = vec2(instanceName.f1, instanceName.f2);\n"
+        "  gl_Position = vec4(position, 0, 1);\n"
+        "}";
+
+    const std::string &fragmentShaderSource =
+        "#version 310 es\n"
+        "precision highp float;\n"
+        "in vec2 v;\n"
+        "out vec4 color;\n"
+        "void main() {\n"
+        "  color = vec4(v, 0, 1);\n"
+        "}";
+
+    ANGLE_GL_PROGRAM(program, vertexShaderSource, fragmentShaderSource);
+
+    GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, "blockName");
+    EXPECT_GL_NO_ERROR();
+    EXPECT_NE(GL_INVALID_INDEX, index);
+
+    GLchar name[64];
+    GLsizei length;
+    glGetProgramResourceName(program, GL_UNIFORM_BLOCK, index, sizeof(name), &length, name);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(9, length);
+    EXPECT_EQ("blockName", std::string(name));
+
+    GLenum props[]         = {GL_BUFFER_BINDING,
+                      GL_BUFFER_DATA_SIZE,
+                      GL_NAME_LENGTH,
+                      GL_NUM_ACTIVE_VARIABLES,
+                      GL_ACTIVE_VARIABLES,
+                      GL_REFERENCED_BY_VERTEX_SHADER,
+                      GL_REFERENCED_BY_FRAGMENT_SHADER,
+                      GL_REFERENCED_BY_COMPUTE_SHADER};
+    GLsizei propCount      = static_cast<GLsizei>(ArraySize(props));
+    constexpr int kBufSize = 256;
+    GLint params[kBufSize];
+    GLint magic = 0xBEEF;
+
+    // Tests bufSize is respected even some prop returns more than one value.
+    params[propCount] = magic;
+    glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, propCount, props, propCount, &length,
+                           params);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(propCount, length);
+    EXPECT_EQ(2, params[0]);   // buffer_binding
+    EXPECT_NE(0, params[1]);   // buffer_data_size
+    EXPECT_EQ(10, params[2]);  // name_length
+    EXPECT_EQ(2, params[3]);   // num_active_variables
+    EXPECT_LE(0, params[4]);   // index of 'f1' or 'f2'
+    EXPECT_LE(0, params[5]);   // index of 'f1' or 'f2'
+    EXPECT_EQ(1, params[6]);   // referenced_by_vertex_shader
+    EXPECT_EQ(0, params[7]);   // referenced_by_fragment_shader
+    EXPECT_EQ(magic, params[8]);
+
+    glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, propCount, props, kBufSize, &length,
+                           params);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(propCount + 1, length);
+    EXPECT_EQ(0, params[8]);  // referenced_by_compute_shader
+
+    // bufSize is reached in middle of outputting values for GL_ACTIVE_VARIABLES.
+    GLenum actvieVariablesProperty = GL_ACTIVE_VARIABLES;
+    params[1]                      = magic;
+    glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, 1, &actvieVariablesProperty, 1,
+                           &length, params);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(1, length);
+    EXPECT_LE(0, params[0]);  // index of 'f1' or 'f2'
+    EXPECT_EQ(magic, params[1]);
+}
+
+// Tests atomic counter buffer qeury works correctly.
+TEST_P(ProgramInterfaceTestES31, QueryAtomicCounteBuffer)
+{
+    const std::string &vertShader =
+        "#version 310 es\n"
+        "precision highp float;\n"
+        "layout(binding = 2, offset = 0) uniform atomic_uint vcounter;\n"
+        "in highp vec4 a_position;\n"
+        "void main()\n"
+        "{\n"
+        "    atomicCounterIncrement(vcounter);\n"
+        "    gl_Position = a_position;\n"
+        "}\n";
+
+    const std::string &fragShader =
+        "#version 310 es\n"
+        "precision highp float;\n"
+        "layout(binding = 2, offset = 4) uniform atomic_uint fcounter;\n"
+        "out highp vec4 my_color;\n"
+        "void main()\n"
+        "{\n"
+        "    atomicCounterDecrement(fcounter);\n"
+        "    my_color = vec4(0.0);\n"
+        "}\n";
+
+    ANGLE_GL_PROGRAM(program, vertShader, fragShader);
+    GLint num;
+    glGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &num);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(1, num);
+
+    glGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(2, num);
+
+    GLenum props[]    = {GL_BUFFER_BINDING, GL_NUM_ACTIVE_VARIABLES, GL_REFERENCED_BY_VERTEX_SHADER,
+                      GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_COMPUTE_SHADER};
+    GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
+    GLint params[ArraySize(props)];
+    GLsizei length = 0;
+    glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, 0, propCount, props, propCount,
+                           &length, params);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(propCount, length);
+    EXPECT_EQ(2, params[0]);  // buffer_binding
+    EXPECT_EQ(2, params[1]);  // num_active_variables
+    EXPECT_EQ(1, params[2]);  // referenced_by_vertex_shader
+    EXPECT_EQ(1, params[3]);  // referenced_by_fragment_shader
+    EXPECT_EQ(0, params[4]);  // referenced_by_compute_shader
+}
+
 ANGLE_INSTANTIATE_TEST(ProgramInterfaceTestES31, ES31_OPENGL(), ES31_OPENGLES());
 
 }  // anonymous namespace