Vulkan: Fix image layout barriers for tessellation shaders

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -121,14 +121,18 @@ GLenum DefaultGLErrorCode(VkResult result)
 
 constexpr gl::ShaderMap<vk::ImageLayout> kShaderReadOnlyImageLayouts = {
     {gl::ShaderType::Vertex, vk::ImageLayout::VertexShaderReadOnly},
+    {gl::ShaderType::TessControl, vk::ImageLayout::PreFragmentShadersReadOnly},
+    {gl::ShaderType::TessEvaluation, vk::ImageLayout::PreFragmentShadersReadOnly},
+    {gl::ShaderType::Geometry, vk::ImageLayout::PreFragmentShadersReadOnly},
     {gl::ShaderType::Fragment, vk::ImageLayout::FragmentShaderReadOnly},
-    {gl::ShaderType::Geometry, vk::ImageLayout::GeometryShaderReadOnly},
     {gl::ShaderType::Compute, vk::ImageLayout::ComputeShaderReadOnly}};
 
 constexpr gl::ShaderMap<vk::ImageLayout> kShaderWriteImageLayouts = {
     {gl::ShaderType::Vertex, vk::ImageLayout::VertexShaderWrite},
+    {gl::ShaderType::TessControl, vk::ImageLayout::PreFragmentShadersWrite},
+    {gl::ShaderType::TessEvaluation, vk::ImageLayout::PreFragmentShadersWrite},
+    {gl::ShaderType::Geometry, vk::ImageLayout::PreFragmentShadersWrite},
     {gl::ShaderType::Fragment, vk::ImageLayout::FragmentShaderWrite},
-    {gl::ShaderType::Geometry, vk::ImageLayout::GeometryShaderWrite},
     {gl::ShaderType::Compute, vk::ImageLayout::ComputeShaderWrite}};
 
 constexpr VkBufferUsageFlags kVertexBufferUsage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
@@ -1266,12 +1270,18 @@ ANGLE_INLINE angle::Result ContextVk::handleDirtyTexturesImpl(
                 executable->getSamplerShaderBitsForTextureUnitIndex(textureUnit);
             ASSERT(remainingShaderBits.any());
             gl::ShaderType firstShader = remainingShaderBits.first();
+            gl::ShaderType lastShader  = remainingShaderBits.last();
             remainingShaderBits.reset(firstShader);
-            // If we have multiple shader accessing it, we barrier against all shader stage read
-            // given that we only support vertex/frag shaders
-            if (remainingShaderBits.any())
+            remainingShaderBits.reset(lastShader);
+            // We barrier against either:
+            // - Vertex only
+            // - Fragment only
+            // - Pre-fragment only (vertex, geometry and tessellation together)
+            if (remainingShaderBits.any() || firstShader != lastShader)
             {
-                textureLayout = vk::ImageLayout::AllGraphicsShadersReadOnly;
+                textureLayout = lastShader == gl::ShaderType::Fragment
+                                    ? vk::ImageLayout::AllGraphicsShadersReadOnly
+                                    : vk::ImageLayout::PreFragmentShadersReadOnly;
             }
             else
             {
@@ -1279,8 +1289,7 @@ ANGLE_INLINE angle::Result ContextVk::handleDirtyTexturesImpl(
             }
         }
         // Ensure the image is in read-only layout
-        commandBufferHelper->imageRead(&mResourceUseList, image.getAspectFlags(), textureLayout,
-                                       &image);
+        commandBufferHelper->imageRead(this, image.getAspectFlags(), textureLayout, &image);
 
         textureVk->retainImageViews(&mResourceUseList);
     }
@@ -4284,16 +4293,23 @@ angle::Result ContextVk::updateActiveImages(const gl::Context *context,
         alreadyProcessed.insert(image);
 
         vk::ImageLayout imageLayout;
-        gl::ShaderType shader = static_cast<gl::ShaderType>(gl::ScanForward(shaderStages.bits()));
-        shaderStages.reset(shader);
-        // This is accessed by multiple shaders
-        if (shaderStages.any())
+        gl::ShaderType firstShader = shaderStages.first();
+        gl::ShaderType lastShader  = shaderStages.last();
+        shaderStages.reset(firstShader);
+        shaderStages.reset(lastShader);
+        // We barrier against either:
+        // - Vertex only
+        // - Fragment only
+        // - Pre-fragment only (vertex, geometry and tessellation together)
+        if (shaderStages.any() || firstShader != lastShader)
         {
-            imageLayout = vk::ImageLayout::AllGraphicsShadersWrite;
+            imageLayout = lastShader == gl::ShaderType::Fragment
+                              ? vk::ImageLayout::AllGraphicsShadersWrite
+                              : vk::ImageLayout::PreFragmentShadersWrite;
         }
         else
         {
-            imageLayout = kShaderWriteImageLayouts[shader];
+            imageLayout = kShaderWriteImageLayouts[firstShader];
         }
 
         VkImageAspectFlags aspectFlags = image->getAspectFlags();
@@ -4307,8 +4323,8 @@ angle::Result ContextVk::updateActiveImages(const gl::Context *context,
         }
 
         commandBufferHelper->imageWrite(
-            &mResourceUseList, gl::LevelIndex(static_cast<uint32_t>(imageUnit.level)), layerStart,
-            layerCount, aspectFlags, imageLayout, vk::AliasingMode::Allowed, image);
+            this, gl::LevelIndex(static_cast<uint32_t>(imageUnit.level)), layerStart, layerCount,
+            aspectFlags, imageLayout, vk::AliasingMode::Allowed, image);
     }
 
     return angle::Result::Continue;
@@ -5073,7 +5089,7 @@ angle::Result ContextVk::onResourceAccess(const vk::CommandBufferAccess &access)
     {
         ASSERT(!IsRenderPassStartedAndUsesImage(*mRenderPassCommands, *imageAccess.image));
 
-        imageAccess.image->recordReadBarrier(imageAccess.aspectFlags, imageAccess.imageLayout,
+        imageAccess.image->recordReadBarrier(this, imageAccess.aspectFlags, imageAccess.imageLayout,
                                              &mOutsideRenderPassCommands->getCommandBuffer());
         imageAccess.image->retain(&mResourceUseList);
     }
@@ -5083,7 +5099,7 @@ angle::Result ContextVk::onResourceAccess(const vk::CommandBufferAccess &access)
         ASSERT(!IsRenderPassStartedAndUsesImage(*mRenderPassCommands, *imageWrite.access.image));
 
         imageWrite.access.image->recordWriteBarrier(
-            imageWrite.access.aspectFlags, imageWrite.access.imageLayout,
+            this, imageWrite.access.aspectFlags, imageWrite.access.imageLayout,
             &mOutsideRenderPassCommands->getCommandBuffer());
         imageWrite.access.image->retain(&mResourceUseList);
         imageWrite.access.image->onWrite(imageWrite.levelStart, imageWrite.levelCount,

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -447,7 +447,7 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
                                vk::ImageHelper *image)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->imageRead(&mResourceUseList, aspectFlags, imageLayout, image);
+        mRenderPassCommands->imageRead(this, aspectFlags, imageLayout, image);
     }
 
     void onImageRenderPassWrite(gl::LevelIndex level,
@@ -458,8 +458,8 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
                                 vk::ImageHelper *image)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->imageWrite(&mResourceUseList, level, layerStart, layerCount,
-                                        aspectFlags, imageLayout, vk::AliasingMode::Allowed, image);
+        mRenderPassCommands->imageWrite(this, level, layerStart, layerCount, aspectFlags,
+                                        imageLayout, vk::AliasingMode::Allowed, image);
     }
 
     void onDepthStencilDraw(gl::LevelIndex level,
@@ -477,7 +477,7 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
     {
         if (mRenderPassCommands->started())
         {
-            mRenderPassCommands->onImageHelperRelease(image);
+            mRenderPassCommands->onImageHelperRelease(this, image);
         }
     }
 

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -202,7 +202,7 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
     {
         vk::CommandBuffer *commandBuffer;
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer({}, &commandBuffer));
-        mImage->changeLayoutAndQueue(aspect, vk::ImageLayout::ColorAttachment,
+        mImage->changeLayoutAndQueue(contextVk, aspect, vk::ImageLayout::ColorAttachment,
                                      rendererQueueFamilyIndex, commandBuffer);
     }
 

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -625,7 +625,8 @@ RendererVk::RendererVk()
       mPipelineCacheDirty(false),
       mPipelineCacheInitialized(false),
       mCommandProcessor(this),
-      mGlslangInitialized(false)
+      mGlslangInitialized(false),
+      mSupportedVulkanPipelineStageMask(0)
 {
     VkFormatProperties invalid = {0, 0, kInvalidFormatFeatureFlags};
     mFormatProperties.fill(invalid);
@@ -1719,6 +1720,21 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         ANGLE_TRY(initPipelineCache(displayVk, &mPipelineCache, &success));
     }
 
+    // Track the set of supported pipeline stages.  This is used when issuing image layout
+    // transitions that cover many stages (such as AllGraphicsReadOnly) to mask out unsupported
+    // stages, which avoids enumerating every possible combination of stages in the layouts.
+    VkPipelineStageFlags unsupportedStages = 0;
+    if (!mPhysicalDeviceFeatures.tessellationShader)
+    {
+        unsupportedStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT |
+                             VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
+    }
+    if (!mPhysicalDeviceFeatures.geometryShader)
+    {
+        unsupportedStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+    }
+    mSupportedVulkanPipelineStageMask = ~unsupportedStages;
+
     return angle::Result::Continue;
 }
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -363,6 +363,11 @@ class RendererVk : angle::NonCopyable
     // Log cache stats for all caches
     void logCacheStats() const;
 
+    VkPipelineStageFlags getSupportedVulkanPipelineStageMask() const
+    {
+        return mSupportedVulkanPipelineStageMask;
+    }
+
   private:
     angle::Result initializeDevice(DisplayVk *displayVk, uint32_t queueFamilyIndex);
     void ensureCapsInitialized() const;
@@ -492,6 +497,17 @@ class RendererVk : angle::NonCopyable
     // Stats about all Vulkan object caches
     using VulkanCacheStats = angle::PackedEnumMap<VulkanCacheType, CacheStats>;
     VulkanCacheStats mVulkanCacheStats;
+
+    // A mask to filter out Vulkan pipeline stages that are not supported, applied in situations
+    // where multiple stages are prespecified (for example with image layout transitions):
+    //
+    // - Excludes GEOMETRY if geometry shaders are not supported.
+    // - Excludes TESSELLATION_CONTROL and TESSELLATION_EVALUATION if tessellation shaders are not
+    //   supported.
+    //
+    // Note that this mask can have bits set that don't correspond to valid stages, so it's strictly
+    // only useful for masking out unsupported stages in an otherwise valid set of stages.
+    VkPipelineStageFlags mSupportedVulkanPipelineStageMask;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -1336,7 +1336,7 @@ angle::Result WindowSurfaceVk::present(ContextVk *contextVk,
     }
 
     // This does nothing if it's already in the requested layout
-    image.image.recordReadBarrier(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::Present,
+    image.image.recordReadBarrier(contextVk, VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::Present,
                                   commandBuffer);
 
     // Knowing that the kSwapHistorySize'th submission ago has finished, we can know that the

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -1366,8 +1366,8 @@ angle::Result TextureVk::setEGLImageTarget(const gl::Context *context,
 
         vk::CommandBuffer *commandBuffer;
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer({}, &commandBuffer));
-        mImage->changeLayoutAndQueue(mImage->getAspectFlags(), newLayout, rendererQueueFamilyIndex,
-                                     commandBuffer);
+        mImage->changeLayoutAndQueue(contextVk, mImage->getAspectFlags(), newLayout,
+                                     rendererQueueFamilyIndex, commandBuffer);
     }
 
     return angle::Result::Continue;

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -101,8 +101,12 @@ struct ImageMemoryBarrierData
     PipelineStage barrierIndex;
 };
 
+constexpr VkPipelineStageFlags kPreFragmentStageFlags =
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT |
+    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+
 constexpr VkPipelineStageFlags kAllShadersPipelineStageFlags =
-    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+    kPreFragmentStageFlags | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 
 constexpr VkPipelineStageFlags kAllDepthStencilPipelineStageFlags =
@@ -314,33 +318,35 @@ constexpr angle::PackedEnumMap<ImageLayout, ImageMemoryBarrierData> kImageMemory
         },
     },
     {
-        ImageLayout::GeometryShaderReadOnly,
+        ImageLayout::PreFragmentShadersReadOnly,
         ImageMemoryBarrierData{
-            "GeometryShaderReadOnly",
+            "PreFragmentShadersReadOnly",
             VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-            VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
-            VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+            kPreFragmentStageFlags,
+            kPreFragmentStageFlags,
             // Transition to: all reads must happen after barrier.
             VK_ACCESS_SHADER_READ_BIT,
             // Transition from: RAR and WAR don't need memory barrier.
             0,
             ResourceAccess::ReadOnly,
-            PipelineStage::GeometryShader,
+            // In case of multiple destination stages, We barrier the earliest stage
+            PipelineStage::VertexShader,
         },
     },
     {
-        ImageLayout::GeometryShaderWrite,
+        ImageLayout::PreFragmentShadersWrite,
         ImageMemoryBarrierData{
-            "GeometryShaderWrite",
+            "PreFragmentShadersWrite",
             VK_IMAGE_LAYOUT_GENERAL,
-            VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
-            VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+            kPreFragmentStageFlags,
+            kPreFragmentStageFlags,
             // Transition to: all reads and writes must happen after barrier.
             VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
             // Transition from: all writes must finish before barrier.
             VK_ACCESS_SHADER_WRITE_BIT,
             ResourceAccess::Write,
-            PipelineStage::GeometryShader,
+            // In case of multiple destination stages, We barrier the earliest stage
+            PipelineStage::VertexShader,
         },
     },
     {
@@ -438,6 +444,18 @@ constexpr angle::PackedEnumMap<ImageLayout, ImageMemoryBarrierData> kImageMemory
 };
 // clang-format on
 
+VkPipelineStageFlags GetImageLayoutSrcStageMask(Context *context,
+                                                const ImageMemoryBarrierData &transition)
+{
+    return transition.srcStageMask & context->getRenderer()->getSupportedVulkanPipelineStageMask();
+}
+
+VkPipelineStageFlags GetImageLayoutDstStageMask(Context *context,
+                                                const ImageMemoryBarrierData &transition)
+{
+    return transition.dstStageMask & context->getRenderer()->getSupportedVulkanPipelineStageMask();
+}
+
 VkImageCreateFlags GetImageCreateFlags(gl::TextureType textureType)
 {
     switch (textureType)
@@ -846,19 +864,19 @@ void CommandBufferHelper::bufferWrite(ResourceUseList *resourceUseList,
     }
 }
 
-void CommandBufferHelper::imageRead(ResourceUseList *resourceUseList,
+void CommandBufferHelper::imageRead(ContextVk *contextVk,
                                     VkImageAspectFlags aspectFlags,
                                     ImageLayout imageLayout,
                                     ImageHelper *image)
 {
-    image->retain(resourceUseList);
+    image->retain(&contextVk->getResourceUseList());
 
     if (image->isReadBarrierNecessary(imageLayout))
     {
         PipelineStage barrierIndex = kImageMemoryBarrierData[imageLayout].barrierIndex;
         ASSERT(barrierIndex != PipelineStage::InvalidEnum);
         PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
-        if (image->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+        if (image->updateLayoutAndBarrier(contextVk, aspectFlags, imageLayout, barrier))
         {
             mPipelineBarrierMask.set(barrierIndex);
         }
@@ -875,7 +893,7 @@ void CommandBufferHelper::imageRead(ResourceUseList *resourceUseList,
     }
 }
 
-void CommandBufferHelper::imageWrite(ResourceUseList *resourceUseList,
+void CommandBufferHelper::imageWrite(ContextVk *contextVk,
                                      gl::LevelIndex level,
                                      uint32_t layerStart,
                                      uint32_t layerCount,
@@ -884,13 +902,13 @@ void CommandBufferHelper::imageWrite(ResourceUseList *resourceUseList,
                                      AliasingMode aliasingMode,
                                      ImageHelper *image)
 {
-    image->retain(resourceUseList);
+    image->retain(&contextVk->getResourceUseList());
     image->onWrite(level, 1, layerStart, layerCount, aspectFlags);
     // Write always requires a barrier
     PipelineStage barrierIndex = kImageMemoryBarrierData[imageLayout].barrierIndex;
     ASSERT(barrierIndex != PipelineStage::InvalidEnum);
     PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
-    if (image->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+    if (image->updateLayoutAndBarrier(contextVk, aspectFlags, imageLayout, barrier))
     {
         mPipelineBarrierMask.set(barrierIndex);
     }
@@ -1065,7 +1083,7 @@ void CommandBufferHelper::executeBarriers(const angle::FeaturesVk &features,
     mPipelineBarrierMask.reset();
 }
 
-void CommandBufferHelper::finalizeDepthStencilImageLayout()
+void CommandBufferHelper::finalizeDepthStencilImageLayout(Context *context)
 {
     ASSERT(mIsRenderPassCommandBuffer);
     ASSERT(mDepthStencilImage);
@@ -1098,7 +1116,7 @@ void CommandBufferHelper::finalizeDepthStencilImageLayout()
         ASSERT(barrierIndex != PipelineStage::InvalidEnum);
         PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
 
-        if (mDepthStencilImage->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+        if (mDepthStencilImage->updateLayoutAndBarrier(context, aspectFlags, imageLayout, barrier))
         {
             mPipelineBarrierMask.set(barrierIndex);
         }
@@ -1127,7 +1145,7 @@ void CommandBufferHelper::finalizeDepthStencilImageLayout()
     }
 }
 
-void CommandBufferHelper::finalizeDepthStencilResolveImageLayout()
+void CommandBufferHelper::finalizeDepthStencilResolveImageLayout(Context *context)
 {
     ASSERT(mIsRenderPassCommandBuffer);
     ASSERT(mDepthStencilImage);
@@ -1142,7 +1160,8 @@ void CommandBufferHelper::finalizeDepthStencilResolveImageLayout()
     ASSERT(barrierIndex != PipelineStage::InvalidEnum);
     PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
 
-    if (mDepthStencilResolveImage->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+    if (mDepthStencilResolveImage->updateLayoutAndBarrier(context, aspectFlags, imageLayout,
+                                                          barrier))
     {
         mPipelineBarrierMask.set(barrierIndex);
     }
@@ -1170,19 +1189,19 @@ void CommandBufferHelper::finalizeDepthStencilResolveImageLayout()
     }
 }
 
-void CommandBufferHelper::onImageHelperRelease(const ImageHelper *image)
+void CommandBufferHelper::onImageHelperRelease(Context *context, const ImageHelper *image)
 {
     ASSERT(mIsRenderPassCommandBuffer);
 
     if (mDepthStencilImage == image)
     {
-        finalizeDepthStencilImageLayout();
+        finalizeDepthStencilImageLayout(context);
         mDepthStencilImage = nullptr;
     }
 
     if (mDepthStencilResolveImage == image)
     {
-        finalizeDepthStencilResolveImageLayout();
+        finalizeDepthStencilResolveImageLayout(context);
         mDepthStencilResolveImage = nullptr;
     }
 }
@@ -1286,11 +1305,11 @@ void CommandBufferHelper::endRenderPass(ContextVk *contextVk)
     // Do depth stencil layout change.
     if (mDepthStencilImage)
     {
-        finalizeDepthStencilImageLayout();
+        finalizeDepthStencilImageLayout(contextVk);
     }
     if (mDepthStencilResolveImage)
     {
-        finalizeDepthStencilResolveImageLayout();
+        finalizeDepthStencilResolveImageLayout(contextVk);
     }
 }
 
@@ -3703,7 +3722,7 @@ angle::Result ImageHelper::initializeNonZeroMemory(Context *context, VkDeviceSiz
     ANGLE_TRY(renderer->getCommandBufferOneOff(context, &commandBuffer));
 
     // Queue a DMA copy.
-    barrierImpl(getAspectFlags(), ImageLayout::TransferDst, mCurrentQueueFamilyIndex,
+    barrierImpl(context, getAspectFlags(), ImageLayout::TransferDst, mCurrentQueueFamilyIndex,
                 &commandBuffer);
 
     StagingBuffer stagingBuffer;
@@ -4169,13 +4188,14 @@ bool ImageHelper::isReadBarrierNecessary(ImageLayout newLayout) const
     return layoutData.type == ResourceAccess::Write;
 }
 
-void ImageHelper::changeLayoutAndQueue(VkImageAspectFlags aspectMask,
+void ImageHelper::changeLayoutAndQueue(Context *context,
+                                       VkImageAspectFlags aspectMask,
                                        ImageLayout newLayout,
                                        uint32_t newQueueFamilyIndex,
                                        CommandBuffer *commandBuffer)
 {
     ASSERT(isQueueChangeNeccesary(newQueueFamilyIndex));
-    barrierImpl(aspectMask, newLayout, newQueueFamilyIndex, commandBuffer);
+    barrierImpl(context, aspectMask, newLayout, newQueueFamilyIndex, commandBuffer);
 }
 
 void ImageHelper::acquireFromExternal(ContextVk *contextVk,
@@ -4193,7 +4213,8 @@ void ImageHelper::acquireFromExternal(ContextVk *contextVk,
     mCurrentLayout           = currentLayout;
     mCurrentQueueFamilyIndex = externalQueueFamilyIndex;
 
-    changeLayoutAndQueue(getAspectFlags(), mCurrentLayout, rendererQueueFamilyIndex, commandBuffer);
+    changeLayoutAndQueue(contextVk, getAspectFlags(), mCurrentLayout, rendererQueueFamilyIndex,
+                         commandBuffer);
 
     // It is unknown how the external has modified the image, so assume every subresource has
     // defined content.  That is unless the layout is Undefined.
@@ -4215,7 +4236,8 @@ void ImageHelper::releaseToExternal(ContextVk *contextVk,
 {
     ASSERT(mCurrentQueueFamilyIndex == rendererQueueFamilyIndex);
 
-    changeLayoutAndQueue(getAspectFlags(), desiredLayout, externalQueueFamilyIndex, commandBuffer);
+    changeLayoutAndQueue(contextVk, getAspectFlags(), desiredLayout, externalQueueFamilyIndex,
+                         commandBuffer);
 }
 
 bool ImageHelper::isReleasedToExternal() const
@@ -4272,7 +4294,8 @@ ANGLE_INLINE void ImageHelper::initImageMemoryBarrierStruct(
 
 // Generalized to accept both "primary" and "secondary" command buffers.
 template <typename CommandBufferT>
-void ImageHelper::barrierImpl(VkImageAspectFlags aspectMask,
+void ImageHelper::barrierImpl(Context *context,
+                              VkImageAspectFlags aspectMask,
                               ImageLayout newLayout,
                               uint32_t newQueueFamilyIndex,
                               CommandBufferT *commandBuffer)
@@ -4284,26 +4307,29 @@ void ImageHelper::barrierImpl(VkImageAspectFlags aspectMask,
     initImageMemoryBarrierStruct(aspectMask, newLayout, newQueueFamilyIndex, &imageMemoryBarrier);
 
     // There might be other shaderRead operations there other than the current layout.
-    VkPipelineStageFlags srcStageMask = transitionFrom.srcStageMask;
+    VkPipelineStageFlags srcStageMask = GetImageLayoutSrcStageMask(context, transitionFrom);
     if (mCurrentShaderReadStageMask)
     {
         srcStageMask |= mCurrentShaderReadStageMask;
         mCurrentShaderReadStageMask  = 0;
         mLastNonShaderReadOnlyLayout = ImageLayout::Undefined;
     }
-    commandBuffer->imageBarrier(srcStageMask, transitionTo.dstStageMask, imageMemoryBarrier);
+    commandBuffer->imageBarrier(srcStageMask, GetImageLayoutDstStageMask(context, transitionTo),
+                                imageMemoryBarrier);
 
     mCurrentLayout           = newLayout;
     mCurrentQueueFamilyIndex = newQueueFamilyIndex;
 }
 
 template void ImageHelper::barrierImpl<priv::SecondaryCommandBuffer>(
+    Context *context,
     VkImageAspectFlags aspectMask,
     ImageLayout newLayout,
     uint32_t newQueueFamilyIndex,
     priv::SecondaryCommandBuffer *commandBuffer);
 
-bool ImageHelper::updateLayoutAndBarrier(VkImageAspectFlags aspectMask,
+bool ImageHelper::updateLayoutAndBarrier(Context *context,
+                                         VkImageAspectFlags aspectMask,
                                          ImageLayout newLayout,
                                          PipelineBarrier *barrier)
 {
@@ -4315,7 +4341,8 @@ bool ImageHelper::updateLayoutAndBarrier(VkImageAspectFlags aspectMask,
         // changed.  The following asserts that such a barrier is not attempted.
         ASSERT(layoutData.type == ResourceAccess::Write);
         // No layout change, only memory barrier is required
-        barrier->mergeMemoryBarrier(layoutData.srcStageMask, layoutData.dstStageMask,
+        barrier->mergeMemoryBarrier(GetImageLayoutSrcStageMask(context, layoutData),
+                                    GetImageLayoutDstStageMask(context, layoutData),
                                     layoutData.srcAccessMask, layoutData.dstAccessMask);
         barrierModified = true;
     }
@@ -4323,8 +4350,8 @@ bool ImageHelper::updateLayoutAndBarrier(VkImageAspectFlags aspectMask,
     {
         const ImageMemoryBarrierData &transitionFrom = kImageMemoryBarrierData[mCurrentLayout];
         const ImageMemoryBarrierData &transitionTo   = kImageMemoryBarrierData[newLayout];
-        VkPipelineStageFlags srcStageMask            = transitionFrom.srcStageMask;
-        VkPipelineStageFlags dstStageMask            = transitionTo.dstStageMask;
+        VkPipelineStageFlags srcStageMask = GetImageLayoutSrcStageMask(context, transitionFrom);
+        VkPipelineStageFlags dstStageMask = GetImageLayoutDstStageMask(context, transitionTo);
 
         if (IsShaderReadOnlyLayout(transitionTo) && IsShaderReadOnlyLayout(transitionFrom))
         {
@@ -4337,8 +4364,9 @@ bool ImageHelper::updateLayoutAndBarrier(VkImageAspectFlags aspectMask,
             {
                 const ImageMemoryBarrierData &layoutData =
                     kImageMemoryBarrierData[mLastNonShaderReadOnlyLayout];
-                barrier->mergeMemoryBarrier(layoutData.srcStageMask, dstStageMask,
-                                            layoutData.srcAccessMask, transitionTo.dstAccessMask);
+                barrier->mergeMemoryBarrier(GetImageLayoutSrcStageMask(context, layoutData),
+                                            dstStageMask, layoutData.srcAccessMask,
+                                            transitionTo.dstAccessMask);
                 barrierModified = true;
                 // Accumulate new read stage.
                 mCurrentShaderReadStageMask |= dstStageMask;
@@ -5663,7 +5691,7 @@ angle::Result ImageHelper::flushStagedUpdates(ContextVk *contextVk,
             if (updateLayerCount >= kMaxParallelSubresourceUpload)
             {
                 // If there are more subresources than bits we can track, always insert a barrier.
-                recordWriteBarrier(aspectFlags, ImageLayout::TransferDst, commandBuffer);
+                recordWriteBarrier(contextVk, aspectFlags, ImageLayout::TransferDst, commandBuffer);
                 subresourceUploadsInProgress = std::numeric_limits<uint64_t>::max();
             }
             else
@@ -5677,7 +5705,8 @@ angle::Result ImageHelper::flushStagedUpdates(ContextVk *contextVk,
                 if ((subresourceUploadsInProgress & subresourceHash) != 0)
                 {
                     // If there's overlap in subresource upload, issue a barrier.
-                    recordWriteBarrier(aspectFlags, ImageLayout::TransferDst, commandBuffer);
+                    recordWriteBarrier(contextVk, aspectFlags, ImageLayout::TransferDst,
+                                       commandBuffer);
                     subresourceUploadsInProgress = 0;
                 }
                 subresourceUploadsInProgress |= subresourceHash;

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -995,11 +995,11 @@ class CommandBufferHelper : angle::NonCopyable
                      AliasingMode aliasingMode,
                      BufferHelper *buffer);
 
-    void imageRead(ResourceUseList *resourceUseList,
+    void imageRead(ContextVk *contextVk,
                    VkImageAspectFlags aspectFlags,
                    ImageLayout imageLayout,
                    ImageHelper *image);
-    void imageWrite(ResourceUseList *resourceUseList,
+    void imageWrite(ContextVk *contextVk,
                     gl::LevelIndex level,
                     uint32_t layerStart,
                     uint32_t layerCount,
@@ -1053,7 +1053,7 @@ class CommandBufferHelper : angle::NonCopyable
         return mRenderPassStarted;
     }
 
-    void onImageHelperRelease(const ImageHelper *image);
+    void onImageHelperRelease(Context *context, const ImageHelper *image);
 
     void beginRenderPass(const Framebuffer &framebuffer,
                          const gl::Rectangle &renderArea,
@@ -1176,8 +1176,8 @@ class CommandBufferHelper : angle::NonCopyable
     void restoreDepthContent();
     void restoreStencilContent();
 
-    void finalizeDepthStencilImageLayout();
-    void finalizeDepthStencilResolveImageLayout();
+    void finalizeDepthStencilImageLayout(Context *context);
+    void finalizeDepthStencilResolveImageLayout(Context *context);
 
     // Allocator used by this class. Using a pool allocator per CBH to avoid threading issues
     //  that occur w/ shared allocator between multiple CBHs.
@@ -1286,8 +1286,9 @@ enum class ImageLayout
     TransferDst,
     VertexShaderReadOnly,
     VertexShaderWrite,
-    GeometryShaderReadOnly,
-    GeometryShaderWrite,
+    // PreFragment == Vertex, Tessellation and Geometry stages
+    PreFragmentShadersReadOnly,
+    PreFragmentShadersWrite,
     FragmentShaderReadOnly,
     FragmentShaderWrite,
     ComputeShaderReadOnly,
@@ -1621,17 +1622,19 @@ class ImageHelper final : public Resource, public angle::Subject
                                         uint32_t layerCount) const;
     bool hasStagedUpdatesInAllocatedLevels() const;
 
-    void recordWriteBarrier(VkImageAspectFlags aspectMask,
+    void recordWriteBarrier(Context *context,
+                            VkImageAspectFlags aspectMask,
                             ImageLayout newLayout,
                             CommandBuffer *commandBuffer)
     {
-        barrierImpl(aspectMask, newLayout, mCurrentQueueFamilyIndex, commandBuffer);
+        barrierImpl(context, aspectMask, newLayout, mCurrentQueueFamilyIndex, commandBuffer);
     }
 
     // This function can be used to prevent issuing redundant layout transition commands.
     bool isReadBarrierNecessary(ImageLayout newLayout) const;
 
-    void recordReadBarrier(VkImageAspectFlags aspectMask,
+    void recordReadBarrier(Context *context,
+                           VkImageAspectFlags aspectMask,
                            ImageLayout newLayout,
                            CommandBuffer *commandBuffer)
     {
@@ -1640,7 +1643,7 @@ class ImageHelper final : public Resource, public angle::Subject
             return;
         }
 
-        barrierImpl(aspectMask, newLayout, mCurrentQueueFamilyIndex, commandBuffer);
+        barrierImpl(context, aspectMask, newLayout, mCurrentQueueFamilyIndex, commandBuffer);
     }
 
     bool isQueueChangeNeccesary(uint32_t newQueueFamilyIndex) const
@@ -1648,13 +1651,15 @@ class ImageHelper final : public Resource, public angle::Subject
         return mCurrentQueueFamilyIndex != newQueueFamilyIndex;
     }
 
-    void changeLayoutAndQueue(VkImageAspectFlags aspectMask,
+    void changeLayoutAndQueue(Context *context,
+                              VkImageAspectFlags aspectMask,
                               ImageLayout newLayout,
                               uint32_t newQueueFamilyIndex,
                               CommandBuffer *commandBuffer);
 
     // Returns true if barrier has been generated
-    bool updateLayoutAndBarrier(VkImageAspectFlags aspectMask,
+    bool updateLayoutAndBarrier(Context *context,
+                                VkImageAspectFlags aspectMask,
                                 ImageLayout newLayout,
                                 PipelineBarrier *barrier);
 
@@ -1834,7 +1839,8 @@ class ImageHelper final : public Resource, public angle::Subject
 
     // Generalized to accept both "primary" and "secondary" command buffers.
     template <typename CommandBufferT>
-    void barrierImpl(VkImageAspectFlags aspectMask,
+    void barrierImpl(Context *context,
+                     VkImageAspectFlags aspectMask,
                      ImageLayout newLayout,
                      uint32_t newQueueFamilyIndex,
                      CommandBufferT *commandBuffer);