Vulkan: Correct the viewport before intersecting it with the scissor.

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -2472,13 +2472,8 @@ void ContextVk::updateSampleMask(const gl::State &glState)
     }
 }
 
-void ContextVk::updateViewport(FramebufferVk *framebufferVk,
-                               const gl::Rectangle &viewport,
-                               float nearPlane,
-                               float farPlane,
-                               bool invertViewport)
+gl::Rectangle ContextVk::getCorrectedViewport(const gl::Rectangle &viewport) const
 {
-    VkViewport vkViewport;
     const gl::Caps &caps                   = getCaps();
     const VkPhysicalDeviceLimits &limitsVk = mRenderer->getPhysicalDeviceProperties().limits;
     const int viewportBoundsRangeLow       = static_cast<int>(limitsVk.viewportBoundsRange[0]);
@@ -2494,10 +2489,11 @@ void ContextVk::updateViewport(FramebufferVk *framebufferVk,
     // VkPhysicalDeviceLimits::maxViewportDimensions[1]
     int correctedHeight = std::min<int>(viewport.height, caps.maxViewportHeight);
     correctedHeight     = std::max<int>(correctedHeight, 0);
-    // x and y must each be between viewportBoundsRange[0] and viewportBoundsRange[1], inclusive
-    int correctedX = std::min<int>(viewport.x, viewportBoundsRangeHigh);
+    // x and y must each be between viewportBoundsRange[0] and viewportBoundsRange[1], inclusive.
+    // Viewport size cannot be 0 so ensure there is always size for a 1x1 viewport
+    int correctedX = std::min<int>(viewport.x, viewportBoundsRangeHigh - 1);
     correctedX     = std::max<int>(correctedX, viewportBoundsRangeLow);
-    int correctedY = std::min<int>(viewport.y, viewportBoundsRangeHigh);
+    int correctedY = std::min<int>(viewport.y, viewportBoundsRangeHigh - 1);
     correctedY     = std::max<int>(correctedY, viewportBoundsRangeLow);
     // x + width must be less than or equal to viewportBoundsRange[1]
     if ((correctedX + correctedWidth) > viewportBoundsRangeHigh)
@@ -2510,12 +2506,23 @@ void ContextVk::updateViewport(FramebufferVk *framebufferVk,
         correctedHeight = viewportBoundsRangeHigh - correctedY;
     }
 
-    gl::Box fbDimensions = framebufferVk->getState().getDimensions();
-    gl::Rectangle correctedRect =
-        gl::Rectangle(correctedX, correctedY, correctedWidth, correctedHeight);
+    return gl::Rectangle(correctedX, correctedY, correctedWidth, correctedHeight);
+}
+
+void ContextVk::updateViewport(FramebufferVk *framebufferVk,
+                               const gl::Rectangle &viewport,
+                               float nearPlane,
+                               float farPlane,
+                               bool invertViewport)
+{
+
+    gl::Box fbDimensions        = framebufferVk->getState().getDimensions();
+    gl::Rectangle correctedRect = getCorrectedViewport(viewport);
     gl::Rectangle rotatedRect;
     RotateRectangle(getRotationDrawFramebuffer(), false, fbDimensions.width, fbDimensions.height,
                     correctedRect, &rotatedRect);
+
+    VkViewport vkViewport;
     gl_vk::GetViewport(rotatedRect, nearPlane, farPlane, invertViewport,
                        // If the surface is rotated 90/270 degrees, use the framebuffer's width
                        // instead of the height for calculating the final viewport.
@@ -2538,7 +2545,8 @@ angle::Result ContextVk::updateScissor(const gl::State &glState)
 
     // Clip the render area to the viewport.
     gl::Rectangle viewportClippedRenderArea;
-    gl::ClipRectangle(renderArea, glState.getViewport(), &viewportClippedRenderArea);
+    gl::ClipRectangle(renderArea, getCorrectedViewport(glState.getViewport()),
+                      &viewportClippedRenderArea);
 
     gl::Rectangle scissoredArea = ClipRectToScissor(getState(), viewportClippedRenderArea, false);
     gl::Rectangle rotatedScissoredArea;

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -669,6 +669,7 @@ class ContextVk : public ContextImpl, public vk::Context
                                     uint32_t *numIndicesOut);
     angle::Result setupDispatch(const gl::Context *context, vk::CommandBuffer **commandBufferOut);
 
+    gl::Rectangle getCorrectedViewport(const gl::Rectangle &viewport) const;
     void updateViewport(FramebufferVk *framebufferVk,
                         const gl::Rectangle &viewport,
                         float nearPlane,

src/tests/gl_tests/ViewportTest.cpp

@@ -322,6 +322,66 @@ TEST_P(ViewportTest, DrawLineWithLargeViewport)
     }
 }
 
+// Test very large viewport sizes so sanitizers can verify there is no undefined behaviour
+TEST_P(ViewportTest, Overflow)
+{
+    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Green());
+    glUseProgram(program);
+
+    std::vector<Vector3> vertices = {{-1.0f, -1.0f, 0.0f}, {1.0f, 1.0f, 0.0f}};
+
+    const GLint positionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
+    ASSERT_NE(-1, positionLocation);
+
+    GLBuffer vertexBuffer;
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
+                 GL_STATIC_DRAW);
+    glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+    glEnableVertexAttribArray(positionLocation);
+
+    constexpr int kMaxSize            = std::numeric_limits<int>::max();
+    const int kTestViewportSizes[][4] = {
+        {
+            kMaxSize,
+            kMaxSize,
+            1,
+            1,
+        },
+        {
+            0,
+            0,
+            kMaxSize,
+            kMaxSize,
+        },
+        {
+            1,
+            1,
+            kMaxSize,
+            kMaxSize,
+        },
+        {
+            kMaxSize,
+            kMaxSize,
+            kMaxSize,
+            kMaxSize,
+        },
+    };
+
+    for (const int *viewportSize : kTestViewportSizes)
+    {
+        // Set the viewport.
+        glViewport(viewportSize[0], viewportSize[1], viewportSize[2], viewportSize[3]);
+
+        glClear(GL_COLOR_BUFFER_BIT);
+        glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(vertices.size()));
+
+        glDisableVertexAttribArray(positionLocation);
+
+        ASSERT_GL_NO_ERROR();
+    }
+}
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against. D3D11 Feature Level 9 and D3D9 emulate large and negative viewports
 // in the vertex shader. We should test both of these as well as D3D11 Feature Level 10_0+.