vulkan.h: Bug 14181 - Barriers need to be more precise

8 files changed, 96 insertions, 129 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 71b44fda..1ffaea14 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -444,9 +444,10 @@ static void demo_set_image_layout(
 
     VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
 
-    VkPipeEvent set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE };
+    VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
-    vkCmdPipelineBarrier(demo->cmd, VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
+    vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, false, 1, (const void **)&pmemory_barrier);
 }
 
 static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf)
diff --git a/demos/tri.c b/demos/tri.c
index 4dbf4f6c..9a3c5f5f 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -250,9 +250,10 @@ static void demo_set_image_layout(
 
     VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
 
-    VkPipeEvent set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE };
+    VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
-    vkCmdPipelineBarrier(demo->setup_cmd, VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
+    vkCmdPipelineBarrier(demo->setup_cmd, src_stages, dest_stages, false, 1, (const void **)&pmemory_barrier);
 }
 
 static void demo_draw_build_cmd(struct demo *demo)
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index c8382a00..7bb40203 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1078,16 +1078,16 @@ ICD_EXPORT void VKAPI vkCmdResetQueryPool(
 
 ICD_EXPORT void VKAPI vkCmdSetEvent(
     VkCmdBuffer                              cmdBuffer,
-    VkEvent                                   event_,
-    VkPipeEvent                              pipeEvent)
+    VkEvent                                  event_,
+    VkPipelineStageFlags                     stageMask)
 {
     NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void VKAPI vkCmdResetEvent(
     VkCmdBuffer                              cmdBuffer,
-    VkEvent                                   event_,
-    VkPipeEvent                              pipeEvent)
+    VkEvent                                  event_,
+    VkPipelineStageFlags                     stageMask)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1222,9 +1222,10 @@ ICD_EXPORT void VKAPI vkCmdDispatchIndirect(
 
 void VKAPI vkCmdWaitEvents(
     VkCmdBuffer                                 cmdBuffer,
-    VkWaitEvent                                 waitEvent,
     uint32_t                                    eventCount,
     const VkEvent*                              pEvents,
+    VkPipelineStageFlags                        sourceStageMask,
+    VkPipelineStageFlags                        destStageMask,
     uint32_t                                    memBarrierCount,
     const void**                                ppMemBarriers)
 {
@@ -1233,9 +1234,9 @@ void VKAPI vkCmdWaitEvents(
 
 void VKAPI vkCmdPipelineBarrier(
     VkCmdBuffer                                 cmdBuffer,
-    VkWaitEvent                                 waitEvent,
-    uint32_t                                    pipeEventCount,
-    const VkPipeEvent*                          pPipeEvents,
+    VkPipelineStageFlags                        sourceStageMask,
+    VkPipelineStageFlags                        destStageMask,
+    bool32_t                                    byRegion,
     uint32_t                                    memBarrierCount,
     const void**                                ppMemBarriers)
 {
diff --git a/include/vulkan.h b/include/vulkan.h
index 468876ad..bf721bda 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -151,28 +151,6 @@ typedef enum VkImageLayout_
     VK_ENUM_RANGE(IMAGE_LAYOUT, UNDEFINED, TRANSFER_DESTINATION_OPTIMAL)
 } VkImageLayout;
 
-typedef enum VkPipeEvent_
-{
-    VK_PIPE_EVENT_TOP_OF_PIPE                               = 0x00000001,   // Set event before the device starts processing subsequent command
-    VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE                = 0x00000002,   // Set event when all pending vertex processing is complete
-    VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE        = 0x00000003,   // Set event when all pending fragment shader executions are complete, within each fragment location
-    VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE              = 0x00000004,   // Set event when all pending fragment shader executions are complete
-    VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE                = 0x00000005,   // Set event when all pending graphics operations are complete
-    VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE                 = 0x00000006,   // Set event when all pending compute operations are complete
-    VK_PIPE_EVENT_TRANSFER_COMPLETE                         = 0x00000007,   // Set event when all pending transfer operations are complete
-    VK_PIPE_EVENT_COMMANDS_COMPLETE                         = 0x00000008,   // Set event when all pending work is complete
-
-    VK_ENUM_RANGE(PIPE_EVENT, TOP_OF_PIPE, COMMANDS_COMPLETE)
-} VkPipeEvent;
-
-typedef enum VkWaitEvent_
-{
-    VK_WAIT_EVENT_TOP_OF_PIPE                               = 0x00000001,   // Wait event before the device starts processing subsequent commands
-    VK_WAIT_EVENT_BEFORE_RASTERIZATION                      = 0x00000002,   // Wait event before rasterizing subsequent primitives
-
-    VK_ENUM_RANGE(WAIT_EVENT, TOP_OF_PIPE, BEFORE_RASTERIZATION)
-} VkWaitEvent;
-
 typedef enum VkAttachmentLoadOp_
 {
     VK_ATTACHMENT_LOAD_OP_LOAD                              = 0x00000000,
@@ -1055,6 +1033,28 @@ typedef enum VkFormatFeatureFlagBits_
     VK_FORMAT_FEATURE_CONVERSION_BIT                        = VK_BIT(10),   // Format can be used as the source or destination of format converting blits
 } VkFormatFeatureFlagBits;
 
+// Pipeline stage flags
+typedef enum {
+    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                       = VK_BIT(0),
+    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                     = VK_BIT(1),
+    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                      = VK_BIT(2),
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                     = VK_BIT(3),
+    VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT               = VK_BIT(4),
+    VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT            = VK_BIT(5),
+    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                   = VK_BIT(6),
+    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                   = VK_BIT(7),
+    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT              = VK_BIT(8),
+    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT               = VK_BIT(9),
+    VK_PIPELINE_STAGE_ATTACHMENT_OUTPUT_BIT                 = VK_BIT(10),
+    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                    = VK_BIT(11),
+    VK_PIPELINE_STAGE_TRANSFER_BIT                          = VK_BIT(12),
+    VK_PIPELINE_STAGE_HOST_BIT                              = VK_BIT(13),
+    VK_PIPELINE_STAGE_ALL_GRAPHICS                          = 0x000007FF,
+    VK_PIPELINE_STAGE_ALL_GPU_COMMANDS                      = 0x00001FFF,
+} VkPipelineStageFlagBits;
+
+typedef VkFlags VkPipelineStageFlags;
+
 // Query control flags
 typedef VkFlags VkQueryControlFlags;
 typedef enum VkQueryControlFlagBits_
@@ -2115,10 +2115,10 @@ typedef void     (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer de
 typedef void     (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColor* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 typedef void     (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 typedef void     (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-typedef void     (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
-typedef void     (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
-typedef void     (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
-typedef void     (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
+typedef void     (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void     (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void     (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers);
+typedef void     (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers);
 typedef void     (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
 typedef void     (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
 typedef void     (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
@@ -2720,26 +2720,27 @@ void VKAPI vkCmdResolveImage(
 void VKAPI vkCmdSetEvent(
     VkCmdBuffer                                 cmdBuffer,
     VkEvent                                     event,
-    VkPipeEvent                                 pipeEvent);
+    VkPipelineStageFlags                        stageMask);
 
 void VKAPI vkCmdResetEvent(
     VkCmdBuffer                                 cmdBuffer,
     VkEvent                                     event,
-    VkPipeEvent                                 pipeEvent);
+    VkPipelineStageFlags                        stageMask);
 
 void VKAPI vkCmdWaitEvents(
     VkCmdBuffer                                 cmdBuffer,
-    VkWaitEvent                                 waitEvent,
     uint32_t                                    eventCount,
     const VkEvent*                              pEvents,
+    VkPipelineStageFlags                        sourceStageMask,
+    VkPipelineStageFlags                        destStageMask,
     uint32_t                                    memBarrierCount,
     const void**                                ppMemBarriers);
 
 void VKAPI vkCmdPipelineBarrier(
     VkCmdBuffer                                 cmdBuffer,
-    VkWaitEvent                                 waitEvent,
-    uint32_t                                    pipeEventCount,
-    const VkPipeEvent*                          pPipeEvents,
+    VkPipelineStageFlags                        sourceStageMask,
+    VkPipelineStageFlags                        destStageMask,
+    bool32_t                                    byRegion,
     uint32_t                                    memBarrierCount,
     const void**                                ppMemBarriers);
 
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 146c6410..ee891d62 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2546,56 +2546,56 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
             addCmd(pCB, CMD_SETEVENT);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, pipeEvent);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
         } else {
             report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
         }
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
             addCmd(pCB, CMD_RESETEVENT);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, pipeEvent);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
         } else {
             report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
         }
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
             addCmd(pCB, CMD_WAITEVENTS);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
         } else {
             report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
         }
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(cmdBuffer);
             addCmd(pCB, CMD_PIPELINEBARRIER);
-            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
         } else {
             report_error_no_cb_begin(cmdBuffer, "vkCmdPipelineBarrier()");
         }
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 70ced01e..22ca3e08 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -8619,7 +8619,7 @@ void PreCmdSetEvent(
 void PostCmdSetEvent(
     VkCmdBuffer cmdBuffer,
     VkEvent event,
-    VkPipeEvent pipeEvent)
+    VkPipelineStageFlags stageMask)
 {
     if(cmdBuffer == nullptr)
     {
@@ -8635,24 +8635,17 @@ void PostCmdSetEvent(
         return;
     }
 
-    if(pipeEvent < VK_PIPE_EVENT_BEGIN_RANGE ||
-        pipeEvent > VK_PIPE_EVENT_END_RANGE)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdSetEvent parameter, VkPipeEvent pipeEvent, is unrecognized enumerator");
-        return;
-    }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(
     VkCmdBuffer cmdBuffer,
     VkEvent event,
-    VkPipeEvent pipeEvent)
+    VkPipelineStageFlags stageMask)
 {
     PreCmdSetEvent(cmdBuffer);
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, pipeEvent);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
 
-    PostCmdSetEvent(cmdBuffer, event, pipeEvent);
+    PostCmdSetEvent(cmdBuffer, event, stageMask);
 }
 
 void PreCmdResetEvent(
@@ -8669,7 +8662,7 @@ void PreCmdResetEvent(
 void PostCmdResetEvent(
     VkCmdBuffer cmdBuffer,
     VkEvent event,
-    VkPipeEvent pipeEvent)
+    VkPipelineStageFlags stageMask)
 {
     if(cmdBuffer == nullptr)
     {
@@ -8685,24 +8678,17 @@ void PostCmdResetEvent(
         return;
     }
 
-    if(pipeEvent < VK_PIPE_EVENT_BEGIN_RANGE ||
-        pipeEvent > VK_PIPE_EVENT_END_RANGE)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdResetEvent parameter, VkPipeEvent pipeEvent, is unrecognized enumerator");
-        return;
-    }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(
     VkCmdBuffer cmdBuffer,
     VkEvent event,
-    VkPipeEvent pipeEvent)
+    VkPipelineStageFlags stageMask)
 {
     PreCmdResetEvent(cmdBuffer);
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, pipeEvent);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
 
-    PostCmdResetEvent(cmdBuffer, event, pipeEvent);
+    PostCmdResetEvent(cmdBuffer, event, stageMask);
 }
 
 void PreCmdWaitEvents(
@@ -8740,8 +8726,9 @@ void PreCmdWaitEvents(
 
 void PostCmdWaitEvents(
     VkCmdBuffer cmdBuffer,
-    VkWaitEvent waitEvent,
     uint32_t eventCount,
+    VkPipelineStageFlags sourceStageMask,
+    VkPipelineStageFlags destStageMask,
     uint32_t memBarrierCount)
 {
     if(cmdBuffer == nullptr)
@@ -8751,34 +8738,28 @@ void PostCmdWaitEvents(
         return;
     }
 
-    if(waitEvent < VK_WAIT_EVENT_BEGIN_RANGE ||
-        waitEvent > VK_WAIT_EVENT_END_RANGE)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdWaitEvents parameter, VkWaitEvent waitEvent, is unrecognized enumerator");
-        return;
-    }
+
 
 
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(
     VkCmdBuffer cmdBuffer,
-    VkWaitEvent waitEvent,
     uint32_t eventCount,
     const VkEvent* pEvents,
+    VkPipelineStageFlags sourceStageMask,
+    VkPipelineStageFlags destStageMask,
     uint32_t memBarrierCount,
     const void** ppMemBarriers)
 {
     PreCmdWaitEvents(cmdBuffer, pEvents, ppMemBarriers);
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
 
-    PostCmdWaitEvents(cmdBuffer, waitEvent, eventCount, memBarrierCount);
+    PostCmdWaitEvents(cmdBuffer, eventCount, sourceStageMask, destStageMask, memBarrierCount);
 }
 
 void PreCmdPipelineBarrier(
     VkCmdBuffer cmdBuffer,
-    const VkPipeEvent* pPipeEvents,
     const void** ppMemBarriers)
 {
     if(cmdBuffer == nullptr)
@@ -8788,20 +8769,6 @@ void PreCmdPipelineBarrier(
         return;
     }
 
-    if(pPipeEvents == nullptr)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdPipelineBarrier parameter, const VkPipeEvent* pPipeEvents, is null pointer");
-        return;
-    }
-    if((*pPipeEvents) < VK_PIPE_EVENT_BEGIN_RANGE ||
-        (*pPipeEvents) > VK_PIPE_EVENT_END_RANGE)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdPipelineBarrier parameter, const VkPipeEvent* pPipeEvents, is unrecognized enumerator");
-        return;
-    }
-
     if(ppMemBarriers == nullptr)
     {
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
@@ -8812,8 +8779,9 @@ void PreCmdPipelineBarrier(
 
 void PostCmdPipelineBarrier(
     VkCmdBuffer cmdBuffer,
-    VkWaitEvent waitEvent,
-    uint32_t pipeEventCount,
+    VkPipelineStageFlags sourceStageMask,
+    VkPipelineStageFlags destStageMask,
+    bool32_t byRegion,
     uint32_t memBarrierCount)
 {
     if(cmdBuffer == nullptr)
@@ -8823,29 +8791,23 @@ void PostCmdPipelineBarrier(
         return;
     }
 
-    if(waitEvent < VK_WAIT_EVENT_BEGIN_RANGE ||
-        waitEvent > VK_WAIT_EVENT_END_RANGE)
-    {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdPipelineBarrier parameter, VkWaitEvent waitEvent, is unrecognized enumerator");
-        return;
-    }
+
 
 
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(
     VkCmdBuffer cmdBuffer,
-    VkWaitEvent waitEvent,
-    uint32_t pipeEventCount,
-    const VkPipeEvent* pPipeEvents,
+    VkPipelineStageFlags sourceStageMask,
+    VkPipelineStageFlags destStageMask,
+    bool32_t byRegion,
     uint32_t memBarrierCount,
     const void** ppMemBarriers)
 {
-    PreCmdPipelineBarrier(cmdBuffer, pPipeEvents, ppMemBarriers);
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+    PreCmdPipelineBarrier(cmdBuffer, ppMemBarriers);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
 
-    PostCmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, memBarrierCount);
+    PostCmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount);
 }
 
 void PreCmdBeginQuery(
diff --git a/loader/trampoline.c b/loader/trampoline.c
index d6a09ef9..3967fbfd 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -1044,40 +1044,40 @@ LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcIma
     disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdSetEvent(cmdBuffer, event, pipeEvent);
+    disp->CmdSetEvent(cmdBuffer, event, stageMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdResetEvent(cmdBuffer, event, pipeEvent);
+    disp->CmdResetEvent(cmdBuffer, event, stageMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+    disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
 }
 
-LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+    disp->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
diff --git a/vulkan.py b/vulkan.py
index 4b23a3aa..6d457fb6 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -754,26 +754,27 @@ core = Extension(
         Proto("void", "CmdSetEvent",
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkEvent", "event"),
-             Param("VkPipeEvent", "pipeEvent")]),
+             Param("VkPipelineStageFlags", "stageMask")]),
 
         Proto("void", "CmdResetEvent",
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkEvent", "event"),
-             Param("VkPipeEvent", "pipeEvent")]),
+             Param("VkPipelineStageFlags", "stageMask")]),
 
         Proto("void", "CmdWaitEvents",
             [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkWaitEvent", "waitEvent"),
              Param("uint32_t", "eventCount"),
              Param("const VkEvent*", "pEvents"),
+             Param("VkPipelineStageFlags", "sourceStageMask"),
+             Param("VkPipelineStageFlags", "destStageMask"),
              Param("uint32_t", "memBarrierCount"),
              Param("const void**", "ppMemBarriers")]),
 
         Proto("void", "CmdPipelineBarrier",
             [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkWaitEvent", "waitEvent"),
-             Param("uint32_t", "pipeEventCount"),
-             Param("const VkPipeEvent*", "pPipeEvents"),
+             Param("VkPipelineStageFlags", "sourceStageMask"),
+             Param("VkPipelineStageFlags", "destStageMask"),
+             Param("bool32_t", "byRegion"),
              Param("uint32_t", "memBarrierCount"),
              Param("const void**", "ppMemBarriers")]),