Vulkan: Reuse GetBoundBufferAvailableSize in ProgramExecutableVk

src/libANGLE/angletypes.cpp

@@ -834,30 +834,29 @@ bool ValidateComponentTypeMasks(unsigned long outputTypes,
 GLsizeiptr GetBoundBufferAvailableSize(const OffsetBindingPointer<Buffer> &binding)
 {
     Buffer *buffer = binding.get();
-    if (buffer)
+    if (buffer == nullptr)
     {
-        if (binding.getSize() == 0)
-            return static_cast<GLsizeiptr>(buffer->getSize());
-        angle::CheckedNumeric<GLintptr> offset       = binding.getOffset();
-        angle::CheckedNumeric<GLsizeiptr> size       = binding.getSize();
-        angle::CheckedNumeric<GLsizeiptr> bufferSize = buffer->getSize();
-        auto end                                     = offset + size;
-        auto clampedSize                             = size;
-        auto difference                              = end - bufferSize;
-        if (!difference.IsValid())
-        {
-            return 0;
-        }
-        if (difference.ValueOrDie() > 0)
-        {
-            clampedSize = size - difference;
-        }
-        return clampedSize.ValueOrDefault(0);
+        return 0;
     }
-    else
+
+    const GLsizeiptr bufferSize = static_cast<GLsizeiptr>(buffer->getSize());
+
+    if (binding.getSize() == 0)
+    {
+        return bufferSize;
+    }
+
+    const GLintptr offset = binding.getOffset();
+    const GLsizeiptr size = binding.getSize();
+
+    ASSERT(offset >= 0 && bufferSize >= 0);
+
+    if (bufferSize <= offset)
     {
         return 0;
     }
+
+    return std::min(size, bufferSize - offset);
 }
 
 }  // namespace gl

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -30,21 +30,6 @@ constexpr gl::ShaderMap<vk::PipelineStage> kPipelineStageShaderMap = {
     {gl::ShaderType::Compute, vk::PipelineStage::ComputeShader},
 };
 
-VkDeviceSize GetShaderBufferBindingSize(const gl::OffsetBindingPointer<gl::Buffer> &bufferBinding)
-{
-    if (bufferBinding.getSize() != 0)
-    {
-        return bufferBinding.getSize();
-    }
-    // If size is 0, we can't always use VK_WHOLE_SIZE (or bufferHelper.getSize()), as the
-    // backing buffer may be larger than max*BufferRange.  In that case, we use the backing
-    // buffer size (what's left after offset).
-    const gl::Buffer *bufferGL = bufferBinding.get();
-    ASSERT(bufferGL);
-    ASSERT(bufferGL->getSize() >= bufferBinding.getOffset());
-    return bufferGL->getSize() - bufferBinding.getOffset();
-}
-
 bool ValidateTransformedSpirV(ContextVk *contextVk,
                               const gl::ShaderBitSet &linkedShaderStages,
                               ProgramExecutableVk *executableVk,
@@ -1029,7 +1014,7 @@ angle::Result ProgramExecutableVk::updateBuffersDescriptorSet(
         }
         else
         {
-            size = GetShaderBufferBindingSize(bufferBinding);
+            size = gl::GetBoundBufferAvailableSize(bufferBinding);
         }
 
         // Make sure there's no possible under/overflow with binding size.
@@ -1133,7 +1118,7 @@ angle::Result ProgramExecutableVk::updateAtomicCounterBuffersDescriptorSet(
             descriptorSet = mDescriptorSets[ToUnderlying(DescriptorSetIndex::ShaderResource)];
         }
         ASSERT(descriptorSet != VK_NULL_HANDLE);
-        VkDeviceSize size = GetShaderBufferBindingSize(bufferBinding);
+        VkDeviceSize size = gl::GetBoundBufferAvailableSize(bufferBinding);
         WriteBufferDescriptorSetBinding(bufferHelper, bufferBinding.getOffset(), size,
                                         descriptorSet, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                                         info.binding, binding, requiredOffsetAlignment, &bufferInfo,