Revert "Remove IndexRange retrieving in validation"

src/libANGLE/renderer/d3d/VertexDataManager.cpp

@@ -410,7 +410,7 @@ gl::Error VertexDataManager::storeDynamicAttribs(
     for (auto attribIndex : dynamicAttribsMask)
     {
         const auto &dynamicAttrib = (*translatedAttribs)[attribIndex];
-        ANGLE_TRY(reserveSpaceForAttrib(dynamicAttrib, start, count, instances));
+        ANGLE_TRY(reserveSpaceForAttrib(dynamicAttrib, count, instances));
     }
 
     // Store dynamic attributes
@@ -445,7 +445,6 @@ void VertexDataManager::PromoteDynamicAttribs(
 }
 
 gl::Error VertexDataManager::reserveSpaceForAttrib(const TranslatedAttribute &translatedAttrib,
-                                                   GLint start,
                                                    GLsizei count,
                                                    GLsizei instances) const
 {
@@ -461,21 +460,9 @@ gl::Error VertexDataManager::reserveSpaceForAttrib(const TranslatedAttribute &tr
 
     size_t totalCount = gl::ComputeVertexBindingElementCount(
         binding.getDivisor(), static_cast<size_t>(count), static_cast<size_t>(instances));
-    if (bufferD3D)
-    {
-        // Vertices do not apply the 'start' offset when the divisor is non-zero even when doing
-        // a non-instanced draw call
-        GLint firstVertexIndex = binding.getDivisor() > 0 ? 0 : start;
-        int64_t maxVertexCount =
-            static_cast<int64_t>(firstVertexIndex) + static_cast<int64_t>(totalCount);
-        int elementsInBuffer =
-            ElementsInBuffer(attrib, binding, static_cast<unsigned int>(bufferD3D->getSize()));
-
-        if (maxVertexCount > elementsInBuffer)
-        {
-            return gl::InvalidOperation() << "Vertex buffer is not big enough for the draw call.";
-        }
-    }
+    ASSERT(!bufferD3D ||
+           ElementsInBuffer(attrib, binding, static_cast<unsigned int>(bufferD3D->getSize())) >=
+               static_cast<int>(totalCount));
 
     return mStreamingBuffer->reserveVertexSpace(attrib, binding, static_cast<GLsizei>(totalCount),
                                                 instances);

src/libANGLE/renderer/d3d/VertexDataManager.h

@@ -127,7 +127,6 @@ class VertexDataManager : angle::NonCopyable
     };
 
     gl::Error reserveSpaceForAttrib(const TranslatedAttribute &translatedAttrib,
-                                    GLint start,
                                     GLsizei count,
                                     GLsizei instances) const;
 

src/libANGLE/validationES.cpp

@@ -3171,13 +3171,34 @@ bool ValidateDrawElementsCommon(ValidationContext *context,
         }
     }
 
-    // Here we use maxVertex = 0 and vertexCount = 1 to avoid retrieving IndexRange.
-    if (!ValidateDrawAttribs(context, primcount, 0, 1))
+    // Use the parameter buffer to retrieve and cache the index range.
+    // TODO: offer fast path, with disabled index validation.
+    // TODO: also disable index checking on back-ends that are robust to out-of-range accesses.
+    const auto &params        = context->getParams<HasIndexRange>();
+    const auto &indexRangeOpt = params.getIndexRange();
+    if (!indexRangeOpt.valid())
     {
+        // Unexpected error.
         return false;
     }
 
-    return true;
+    // If we use an index greater than our maximum supported index range, return an error.
+    // The ES3 spec does not specify behaviour here, it is undefined, but ANGLE should always
+    // return an error if possible here.
+    if (static_cast<GLuint64>(indexRangeOpt.value().end) >= context->getCaps().maxElementIndex)
+    {
+        ANGLE_VALIDATION_ERR(context, InvalidOperation(), ExceedsMaxElement);
+        return false;
+    }
+
+    if (!ValidateDrawAttribs(context, primcount, static_cast<GLint>(indexRangeOpt.value().end),
+                             static_cast<GLint>(indexRangeOpt.value().vertexCount())))
+    {
+        return false;
+    }
+
+    // No op if there are no real indices in the index data (all are primitive restart).
+    return (indexRangeOpt.value().vertexIndexCount > 0);
 }
 
 bool ValidateDrawElementsInstancedCommon(ValidationContext *context,

src/tests/gl_tests/VertexAttributeTest.cpp

@@ -782,6 +782,21 @@ TEST_P(VertexAttributeTest, DrawArraysBufferTooSmall)
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }
 
+// Verify that index draw with an out-of-range offset generates INVALID_OPERATION.
+TEST_P(VertexAttributeTest, DrawElementsBufferTooSmall)
+{
+    std::array<GLfloat, kVertexCount> inputData;
+    std::array<GLfloat, kVertexCount> expectedData;
+    InitTestData(inputData, expectedData);
+
+    TestData data(GL_FLOAT, GL_FALSE, Source::BUFFER, inputData.data(), expectedData.data());
+    data.bufferOffset = (kVertexCount - 3) * TypeStride(GL_FLOAT);
+
+    setupTest(data, 1);
+    drawIndexedQuad(mProgram, "position", 0.5f);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
 // Verify that using a different start vertex doesn't mess up the draw.
 TEST_P(VertexAttributeTest, DrawArraysWithBufferOffset)
 {