| // | |
| // Copyright 2026 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. | |
| // | |
| // BaseInstanceOverflowTest: Reproduces integer overflow in vertex buffer streaming path. | |
| #include "test_utils/ANGLETest.h" | |
| #include "test_utils/gl_raii.h" | |
| using namespace angle; | |
| class BaseInstanceOverflowTest : public ANGLETest<> | |
| { | |
| protected: | |
| BaseInstanceOverflowTest() | |
| { | |
| setWindowWidth(1); | |
| setWindowHeight(1); | |
| setConfigRedBits(8); | |
| setConfigGreenBits(8); | |
| setConfigBlueBits(8); | |
| setConfigAlphaBits(8); | |
| } | |
| }; | |
| class RobustBaseInstanceOverflowTest : public ANGLETest<> | |
| { | |
| protected: | |
| RobustBaseInstanceOverflowTest() | |
| { | |
| if (!IsMac() && !IsIOS()) | |
| { | |
| setRobustAccess(true); | |
| } | |
| } | |
| }; | |
| // Regression Test (crbug.com/489791424) | |
| // Reproduces integer overflow in vertex buffer streaming path. | |
| // The bug occurs when baseInstance is large, causing a wrap-around in reservation | |
| // while the copy path uses 64-bit math. | |
| TEST_P(RobustBaseInstanceOverflowTest, BaseInstanceOverflow) | |
| { | |
| // Note: this test does a large buffer overflow read from heap. | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_KHR_robust_buffer_access_behavior")); | |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_base_vertex_base_instance")); | |
| // We need a dynamic vertex attribute to trigger the streaming path. | |
| // In D3D11, using an unaligned offset forces the streaming path. | |
| GLBuffer buffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); | |
| std::vector<GLfloat> data(1000, 1.0f); | |
| glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(GLfloat), data.data(), GL_DYNAMIC_DRAW); | |
| GLProgram program; | |
| program.makeRaster(essl1_shaders::vs::Simple(), essl1_shaders::fs::Red()); | |
| glUseProgram(program); | |
| GLint posLoc = glGetAttribLocation(program, essl1_shaders::PositionAttrib()); | |
| glEnableVertexAttribArray(posLoc); | |
| // Unaligned offset (1 byte) forces streaming path in D3D11. | |
| glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 16, reinterpret_cast<void *>(1)); | |
| glVertexAttribDivisor(posLoc, 1); | |
| // Trigger overflow by using a large baseInstance. | |
| GLuint baseInstance = 0xFFFFFF00; | |
| GLsizei instanceCount = 300; | |
| // The call should fail due to validation of base instance + count overflow. | |
| glDrawArraysInstancedBaseInstanceANGLE(GL_TRIANGLES, 0, 3, instanceCount, baseInstance); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| } | |
| // Test that baseinstance + primcount overflow is properly validated for backends that cannot draw | |
| // large baseInstance + primcount. | |
| TEST_P(BaseInstanceOverflowTest, BaseInstanceOverflow2) | |
| { | |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_base_vertex_base_instance")); | |
| constexpr char kVS[] = R"( | |
| attribute vec4 a_position; | |
| attribute float a_instanceData; | |
| varying float v_data; | |
| void main() { | |
| gl_Position = a_position; | |
| v_data = a_instanceData; | |
| })"; | |
| constexpr char kFS[] = R"( | |
| precision mediump float; | |
| varying float v_data; | |
| void main() { | |
| gl_FragColor = vec4(0.0, v_data, 0.0, 1.0); | |
| })"; | |
| GLProgram program; | |
| program.makeRaster(kVS, kFS); | |
| ASSERT_TRUE(program.valid()); | |
| glUseProgram(program); | |
| GLint posLoc = glGetAttribLocation(program, "a_position"); | |
| GLint dataLoc = glGetAttribLocation(program, "a_instanceData"); | |
| ASSERT_NE(posLoc, -1); | |
| ASSERT_NE(dataLoc, -1); | |
| // Non-instanced position buffer: full-screen triangle. | |
| // clang-format off | |
| const GLfloat kQuadVerts[] = { | |
| -1.0f, -1.0f, | |
| 3.0f, -1.0f, | |
| -1.0f, 3.0f, | |
| }; | |
| // clang-format on | |
| GLBuffer posBuffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, posBuffer); | |
| glBufferData(GL_ARRAY_BUFFER, sizeof(kQuadVerts), kQuadVerts, GL_STATIC_DRAW); | |
| glEnableVertexAttribArray(posLoc); | |
| glVertexAttribPointer(posLoc, 2, GL_FLOAT, GL_FALSE, 0, nullptr); | |
| // Instanced attribute setup. | |
| // Use a large divisor so that all instances read the same element: | |
| // element index = baseInstance + floor(i / divisor) | |
| // With divisor >= primcount, floor(i / divisor) == 0 for all i in [0, primcount-1]. | |
| // So only element at index baseInstance is accessed. | |
| glEnableVertexAttribArray(dataLoc); | |
| struct Subcase | |
| { | |
| GLsizei primcount; | |
| GLuint baseInstance; | |
| }; | |
| // Three subcases: | |
| // small: 5 + 100 = 105, well within GLuint range -> should pass | |
| // medium: 0x7FFFFFFF + 1000 = 0x800003E7, within GLuint range -> should pass | |
| // large: 0xFFFFFF00 + 300 = overflow past GLuint max -> should fail | |
| Subcase subcases[] = { | |
| {100, 5}, | |
| {1000, 0x7FFFFFFFu}, | |
| {300, 0xFFFFFF00u}, | |
| }; | |
| for (const auto &subcase : subcases) | |
| { | |
| SCOPED_TRACE(testing::Message() << "primcount: " << subcase.primcount | |
| << " baseInstance: " << subcase.baseInstance); | |
| // Use divisor = primcount so only one element (at baseInstance) is accessed. | |
| const GLuint divisor = static_cast<GLuint>(subcase.primcount); | |
| glVertexAttribDivisor(dataLoc, divisor); | |
| // Allocate attribute buffer large enough for the one element at baseInstance. | |
| // Size needed: (baseInstance + 1) * sizeof(GLfloat). | |
| GLsizeiptr bufSize = (static_cast<GLsizeiptr>(subcase.baseInstance) + 1) * sizeof(GLfloat); | |
| GLBuffer instBuffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, instBuffer); | |
| glBufferData(GL_ARRAY_BUFFER, bufSize, nullptr, GL_DYNAMIC_DRAW); | |
| GLenum error = glGetError(); | |
| ANGLE_SKIP_TEST_IF(error == GL_OUT_OF_MEMORY); | |
| const bool largeBuffersMayBeInvalid = !isMetalRenderer(); | |
| if (largeBuffersMayBeInvalid) | |
| { | |
| continue; | |
| } | |
| EXPECT_EQ(error, static_cast<GLenum>(GL_NO_ERROR)); | |
| // Write 1.0f at element index baseInstance. | |
| GLfloat one = 1.0f; | |
| glBufferSubData(GL_ARRAY_BUFFER, subcase.baseInstance * sizeof(GLfloat), sizeof(GLfloat), | |
| &one); | |
| ASSERT_GL_NO_ERROR(); | |
| glVertexAttribPointer(dataLoc, 1, GL_FLOAT, GL_FALSE, sizeof(GLfloat), nullptr); | |
| glClearColor(0.0f, 0.0f, 0.0f, 1.0f); | |
| glClear(GL_COLOR_BUFFER_BIT); | |
| glDrawArraysInstancedBaseInstanceANGLE(GL_TRIANGLES, 0, 3, subcase.primcount, | |
| subcase.baseInstance); | |
| const bool expectOverflow = | |
| static_cast<uint64_t>(subcase.primcount - 1) + subcase.baseInstance > | |
| std::numeric_limits<GLuint>::max(); | |
| error = glGetError(); | |
| // The D3D backend may return OOM in emulation path | |
| ANGLE_SKIP_TEST_IF(error == GL_OUT_OF_MEMORY); | |
| if (error == GL_INVALID_OPERATION) | |
| { | |
| EXPECT_TRUE(expectOverflow); | |
| } | |
| else | |
| { | |
| EXPECT_EQ(error, static_cast<GLenum>(GL_NO_ERROR)); | |
| EXPECT_TRUE(!expectOverflow); | |
| // No overflow; the draw should succeed and produce green. | |
| ASSERT_GL_NO_ERROR(); | |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green); | |
| } | |
| } | |
| } | |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BaseInstanceOverflowTest); | |
| ANGLE_INSTANTIATE_TEST(BaseInstanceOverflowTest, | |
| ES3_D3D11().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_OPENGL().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_OPENGLES().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_VULKAN().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_METAL().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions)); | |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(RobustBaseInstanceOverflowTest); | |
| ANGLE_INSTANTIATE_TEST(RobustBaseInstanceOverflowTest, | |
| ES3_D3D11().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_OPENGL().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_OPENGLES().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_VULKAN().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions), | |
| ES3_METAL().enable(Feature::AlwaysEnableEmulatedMultidrawExtensions)); |