[PATCH v3 2/2] vkd3d-shader: Merge all shader fork and join phases into a single phase.

[Conor McCarthy]

From: Conor McCarthy

SPIR-V doesn't support parallelisation in patch constant functions.
Merging into one phase allows generation of a single patch constant
function and normalises to the shader model 6 pattern.
---
 libs/vkd3d-shader/spirv.c                | 556 +++++++++++++++--------
 libs/vkd3d-shader/vkd3d_shader_private.h |   5 +
 2 files changed, 368 insertions(+), 193 deletions(-)

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index 2c06ffe9..95ef0cda 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -2197,11 +2197,7 @@ struct vkd3d_push_constant_buffer_binding

struct vkd3d_shader_phase
 {
-    enum vkd3d_shader_opcode type;
-    unsigned int idx;
-    unsigned int instance_count;
     uint32_t function_id;
-    uint32_t instance_id;
     size_t function_location;
 };

@@ -2276,9 +2272,9 @@ struct spirv_compiler
     unsigned int output_control_point_count;
     bool use_vocp;

-    unsigned int shader_phase_count;
-    struct vkd3d_shader_phase *shader_phases;
-    size_t shader_phases_size;
+    enum vkd3d_shader_opcode phase;
+    struct vkd3d_shader_phase control_point_phase;
+    struct vkd3d_shader_phase patch_constant_phase;

uint32_t current_spec_constant_id;
     unsigned int spec_constant_count;
@@ -2289,9 +2285,19 @@ struct spirv_compiler
     struct vkd3d_string_buffer_cache string_buffers;
 };

-static bool is_control_point_phase(const struct vkd3d_shader_phase *phase)
+static bool is_in_default_phase(const struct spirv_compiler *compiler)
+{
+    return compiler->phase == VKD3DSIH_INVALID;
+}
+
+static bool is_in_control_point_phase(const struct spirv_compiler *compiler)
+{
+    return compiler->phase == VKD3DSIH_HS_CONTROL_POINT_PHASE;
+}
+
+static bool is_in_fork_or_join_phase(const struct spirv_compiler *compiler)
 {
-    return phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE;
+    return compiler->phase == VKD3DSIH_HS_FORK_PHASE || compiler->phase == VKD3DSIH_HS_JOIN_PHASE;
 }

static void spirv_compiler_emit_initial_declarations(struct spirv_compiler *compiler);
@@ -2431,6 +2437,8 @@ struct spirv_compiler *spirv_compiler_create(const struct vkd3d_shader_version *

compiler->scan_descriptor_info = scan_descriptor_info;

+    compiler->phase = VKD3DSIH_INVALID;
+
     vkd3d_string_buffer_cache_init(&compiler->string_buffers);

spirv_compiler_emit_initial_declarations(compiler);
@@ -2881,12 +2889,6 @@ static bool spirv_compiler_get_register_name(char *buffer, unsigned int buffer_s
         case VKD3DSPR_DEPTHOUTLE:
             snprintf(buffer, buffer_size, "oDepth");
             break;
-        case VKD3DSPR_FORKINSTID:
-            snprintf(buffer, buffer_size, "vForkInstanceId");
-            break;
-        case VKD3DSPR_JOININSTID:
-            snprintf(buffer, buffer_size, "vJoinInstanceId");
-            break;
         case VKD3DSPR_GSINSTID:
             snprintf(buffer, buffer_size, "vGSInstanceID");
             break;
@@ -4296,7 +4298,7 @@ static uint32_t spirv_compiler_emit_load_invocation_id(struct spirv_compiler *co
 }

static void spirv_compiler_emit_shader_phase_name(struct spirv_compiler *compiler,
-        uint32_t id, const struct vkd3d_shader_phase *phase, const char *suffix)
+        uint32_t id, const char *suffix)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     const char *name;
@@ -4304,7 +4306,7 @@ static void spirv_compiler_emit_shader_phase_name(struct spirv_compiler *compile
     if (!suffix)
         suffix = "";

-    switch (phase->type)
+    switch (compiler->phase)
     {
         case VKD3DSIH_HS_CONTROL_POINT_PHASE:
             name = "control";
@@ -4316,58 +4318,19 @@ static void spirv_compiler_emit_shader_phase_name(struct spirv_compiler *compile
             name = "join";
             break;
         default:
-            ERR("Invalid phase type %#x.\n", phase->type);
+            ERR("Invalid phase type %#x.\n", compiler->phase);
             return;
     }
-    vkd3d_spirv_build_op_name(builder, id, "%s%u%s", name, phase->idx, suffix);
-}
-
-static void spirv_compiler_begin_shader_phase(struct spirv_compiler *compiler,
-        struct vkd3d_shader_phase *phase)
-{
-    struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    uint32_t void_id, function_type_id;
-    unsigned int param_count;
-    uint32_t param_type_id;
-
-    if (phase->instance_count)
-    {
-        param_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
-        param_count = 1;
-    }
-    else
-    {
-        param_count = 0;
-    }
-
-    phase->function_id = vkd3d_spirv_alloc_id(builder);
-
-    void_id = vkd3d_spirv_get_op_type_void(builder);
-    function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, &param_type_id, param_count);
-    vkd3d_spirv_build_op_function(builder, void_id, phase->function_id,
-            SpvFunctionControlMaskNone, function_type_id);
-
-    if (phase->instance_count)
-        phase->instance_id = vkd3d_spirv_build_op_function_parameter(builder, param_type_id);
-
-    vkd3d_spirv_build_op_label(builder, vkd3d_spirv_alloc_id(builder));
-    phase->function_location = vkd3d_spirv_stream_current_location(&builder->function_stream);
-
-    spirv_compiler_emit_shader_phase_name(compiler, phase->function_id, phase, NULL);
+    vkd3d_spirv_build_op_name(builder, id, "%s%s", name, suffix);
 }

static const struct vkd3d_shader_phase *spirv_compiler_get_current_shader_phase(
         struct spirv_compiler *compiler)
 {
-    struct vkd3d_shader_phase *phase;
-
-    if (!compiler->shader_phase_count)
+    if (is_in_default_phase(compiler))
         return NULL;

-    phase = &compiler->shader_phases[compiler->shader_phase_count - 1];
-    if (!phase->function_id)
-        spirv_compiler_begin_shader_phase(compiler, phase);
-    return phase;
+    return is_in_control_point_phase(compiler) ? &compiler->control_point_phase : &compiler->patch_constant_phase;
 }

static void spirv_compiler_decorate_xfb_output(struct spirv_compiler *compiler,
@@ -4764,12 +4727,9 @@ static void spirv_compiler_emit_input_register(struct spirv_compiler *compiler,
 }

static void spirv_compiler_emit_shader_phase_input(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_phase *phase, const struct vkd3d_shader_dst_param *dst)
+        const struct vkd3d_shader_dst_param *dst)
 {
-    struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     const struct vkd3d_shader_register *reg = &dst->reg;
-    struct vkd3d_symbol reg_symbol;
-    uint32_t val_id;

switch (reg->type)
     {
@@ -4781,10 +4741,6 @@ static void spirv_compiler_emit_shader_phase_input(struct spirv_compiler *compil
         case VKD3DSPR_PRIMID:
             spirv_compiler_emit_input_register(compiler, dst);
             return;
-        case VKD3DSPR_FORKINSTID:
-        case VKD3DSPR_JOININSTID:
-            val_id = phase->instance_id;
-            break;
         case VKD3DSPR_OUTPOINTID: /* Emitted in spirv_compiler_emit_initial_declarations(). */
         case VKD3DSPR_OUTCONTROLPOINT: /* See spirv_compiler_leave_shader_phase(). */
             return;
@@ -4792,13 +4748,6 @@ static void spirv_compiler_emit_shader_phase_input(struct spirv_compiler *compil
             FIXME("Unhandled shader phase input register %#x.\n", reg->type);
             return;
     }
-
-    vkd3d_symbol_make_register(&reg_symbol, reg);
-    vkd3d_symbol_set_register_info(&reg_symbol, val_id,
-            SpvStorageClassMax /* Intermediate value */,
-            VKD3D_SHADER_COMPONENT_UINT, VKD3DSP_WRITEMASK_0);
-    spirv_compiler_put_symbol(compiler, &reg_symbol);
-    spirv_compiler_emit_register_debug_name(builder, val_id, reg);
 }

static unsigned int spirv_compiler_get_output_variable_index(
@@ -4971,7 +4920,7 @@ static void spirv_compiler_emit_output_register(struct spirv_compiler *compiler,
 }

static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_phase *phase, const struct vkd3d_spirv_builtin *builtin)
+        const struct vkd3d_spirv_builtin *builtin)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     uint32_t *variable_id, id;
@@ -4987,7 +4936,7 @@ static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_c
         return *variable_id;

id = spirv_compiler_emit_builtin_variable(compiler, builtin, SpvStorageClassOutput, 0);
-    if (phase->type == VKD3DSIH_HS_FORK_PHASE || phase->type == VKD3DSIH_HS_JOIN_PHASE)
+    if (is_in_fork_or_join_phase(compiler))
         vkd3d_spirv_build_op_decorate(builder, id, SpvDecorationPatch, NULL, 0);

if (variable_id)
@@ -5005,7 +4954,6 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
     unsigned int component_idx, output_component_count;
     enum vkd3d_shader_component_type component_type;
     const struct vkd3d_spirv_builtin *builtin;
-    const struct vkd3d_shader_phase *phase;
     struct vkd3d_symbol *symbol = NULL;
     bool use_private_variable = false;
     struct vkd3d_symbol reg_symbol;
@@ -5017,12 +4965,11 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
     bool is_patch_constant;
     uint32_t id, var_id;

-    phase = spirv_compiler_get_current_shader_phase(compiler);
-    is_patch_constant = phase && (phase->type == VKD3DSIH_HS_FORK_PHASE || phase->type == VKD3DSIH_HS_JOIN_PHASE);
+    is_patch_constant = is_in_fork_or_join_phase(compiler);

shader_signature = is_patch_constant ? compiler->patch_constant_signature : compiler->output_signature;

-    array_size = is_control_point_phase(phase) ? compiler->output_control_point_count : 0;
+    array_size = is_in_control_point_phase(compiler) ? compiler->output_control_point_count : 0;

if (!(signature_element = vkd3d_find_signature_element_for_reg(shader_signature,
             &signature_idx, reg->idx[0].offset, dst->write_mask)))
@@ -5077,8 +5024,8 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
         }
         else if (builtin)
         {
-            if (phase)
-                id = spirv_compiler_emit_shader_phase_builtin_variable(compiler, phase, builtin);
+            if (spirv_compiler_get_current_shader_phase(compiler))
+                id = spirv_compiler_emit_shader_phase_builtin_variable(compiler, builtin);
             else
                 id = spirv_compiler_emit_builtin_variable(compiler, builtin, storage_class, array_size);

@@ -5137,7 +5084,7 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
                 use_private_variable ? VKD3D_SHADER_COMPONENT_FLOAT : component_type,
                 use_private_variable ? VKD3DSP_WRITEMASK_ALL : write_mask);
         reg_symbol.info.reg.is_aggregate = use_private_variable ? is_patch_constant : array_size;
-        if (!use_private_variable && is_control_point_phase(phase))
+        if (!use_private_variable && is_in_control_point_phase(compiler))
         {
             reg_symbol.info.reg.member_idx = spirv_compiler_get_invocation_id(compiler);
             reg_symbol.info.reg.is_dynamically_indexed = true;
@@ -5289,7 +5236,6 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler *
     uint32_t void_id, type_id, ptr_type_id, function_type_id, function_id;
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     const struct vkd3d_shader_signature *signature;
-    const struct vkd3d_shader_phase *phase;
     uint32_t output_index_id = 0;
     bool is_patch_constant;
     unsigned int i, count;
@@ -5300,8 +5246,7 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler *
     STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_array_idx));
     STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_write_mask));

-    phase = spirv_compiler_get_current_shader_phase(compiler);
-    is_patch_constant = phase && (phase->type == VKD3DSIH_HS_FORK_PHASE || phase->type == VKD3DSIH_HS_JOIN_PHASE);
+    is_patch_constant = is_in_fork_or_join_phase(compiler);

signature = is_patch_constant ? compiler->patch_constant_signature : compiler->output_signature;

@@ -5334,7 +5279,7 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler *
             param_id[i] = vkd3d_spirv_build_op_load(builder, type_id, param_id[i], SpvMemoryAccessMaskNone);
     }

-    if (is_control_point_phase(phase))
+    if (is_in_control_point_phase(compiler))
         output_index_id = spirv_compiler_emit_load_invocation_id(compiler);

for (i = 0; i < signature->element_count; ++i)
@@ -6179,10 +6124,9 @@ static void spirv_compiler_emit_dcl_input(struct spirv_compiler *compiler,
         const struct vkd3d_shader_instruction *instruction)
 {
     const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst;
-    const struct vkd3d_shader_phase *phase;

-    if ((phase = spirv_compiler_get_current_shader_phase(compiler)))
-        spirv_compiler_emit_shader_phase_input(compiler, phase, dst);
+    if (spirv_compiler_get_current_shader_phase(compiler))
+        spirv_compiler_emit_shader_phase_input(compiler, dst);
     else if (vkd3d_shader_register_is_input(&dst->reg) || dst->reg.type == VKD3DSPR_PATCHCONST)
         spirv_compiler_emit_input(compiler, dst, VKD3D_SIV_NONE, VKD3DSIM_NONE);
     else
@@ -6481,8 +6425,7 @@ static void spirv_compiler_emit_dcl_thread_group(struct spirv_compiler *compiler
             SpvExecutionModeLocalSize, local_size, ARRAY_SIZE(local_size));
 }

-static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_phase *phase)
+static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler)
 {
     const struct vkd3d_shader_signature *signature = compiler->output_signature;
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -6501,11 +6444,11 @@ static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler,
      * point phase. Reinsert symbols for vocp registers while leaving the
      * control point phase.
      */
-    if (is_control_point_phase(phase))
+    if (is_in_control_point_phase(compiler))
     {
         if (compiler->epilogue_function_id)
         {
-            spirv_compiler_emit_shader_phase_name(compiler, compiler->epilogue_function_id, phase, "_epilogue");
+            spirv_compiler_emit_shader_phase_name(compiler, compiler->epilogue_function_id, "_epilogue");
             spirv_compiler_emit_shader_epilogue_function(compiler);
         }

@@ -6546,79 +6489,38 @@ static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler,
             }
         }
     }
-
-    if (phase->instance_count)
-    {
-        memset(&reg, 0, sizeof(reg));
-        reg.type = phase->type == VKD3DSIH_HS_FORK_PHASE ? VKD3DSPR_FORKINSTID : VKD3DSPR_JOININSTID;
-        reg.idx[0].offset = ~0u;
-        reg.idx[1].offset = ~0u;
-        vkd3d_symbol_make_register(&reg_symbol, &reg);
-        if ((entry = rb_get(&compiler->symbol_table, &reg_symbol)))
-        {
-            rb_remove(&compiler->symbol_table, entry);
-            vkd3d_symbol_free(entry, NULL);
-        }
-    }
 }

static void spirv_compiler_enter_shader_phase(struct spirv_compiler *compiler,
         const struct vkd3d_shader_instruction *instruction)
 {
-    const struct vkd3d_shader_phase *previous_phase;
+    struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
+    uint32_t function_id, void_id, function_type_id;
     struct vkd3d_shader_phase *phase;

-    if ((previous_phase = spirv_compiler_get_current_shader_phase(compiler)))
-        spirv_compiler_leave_shader_phase(compiler, previous_phase);
-
-    if (!vkd3d_array_reserve((void **)&compiler->shader_phases, &compiler->shader_phases_size,
-            compiler->shader_phase_count + 1, sizeof(*compiler->shader_phases)))
+    if (is_in_fork_or_join_phase(compiler) && (instruction->handler_idx == VKD3DSIH_HS_JOIN_PHASE
+            || instruction->handler_idx == VKD3DSIH_HS_FORK_PHASE))
         return;
-    phase = &compiler->shader_phases[compiler->shader_phase_count];

-    phase->type = instruction->handler_idx;
-    phase->idx = compiler->shader_phase_count;
-    phase->instance_count = 0;
-    phase->function_id = 0;
-    phase->instance_id = 0;
-    phase->function_location = 0;
+    if (compiler->phase != VKD3DSIH_INVALID)
+        spirv_compiler_leave_shader_phase(compiler);

-    ++compiler->shader_phase_count;
-}
-
-static int spirv_compiler_emit_shader_phase_instance_count(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_instruction *instruction)
-{
-    struct vkd3d_shader_phase *phase = &compiler->shader_phases[compiler->shader_phase_count - 1];
+    function_id = vkd3d_spirv_alloc_id(builder);

-    if (!compiler->shader_phase_count
-            || (phase->type != VKD3DSIH_HS_FORK_PHASE && phase->type != VKD3DSIH_HS_JOIN_PHASE)
-            || phase->function_id)
-    {
-        WARN("Unexpected dcl_hs_{fork,join}_phase_instance_count instruction.\n");
-        return VKD3D_ERROR_INVALID_SHADER;
-    }
-
-    phase->instance_count = instruction->declaration.count;
-
-    spirv_compiler_begin_shader_phase(compiler, phase);
-
-    return VKD3D_OK;
-}
-
-static const struct vkd3d_shader_phase *spirv_compiler_get_control_point_phase(
-        struct spirv_compiler *compiler)
-{
-    const struct vkd3d_shader_phase *phase;
+    void_id = vkd3d_spirv_get_op_type_void(builder);
+    function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, NULL, 0);
+    vkd3d_spirv_build_op_function(builder, void_id, function_id,
+            SpvFunctionControlMaskNone, function_type_id);

-    if (compiler->shader_phase_count < 1)
-        return NULL;
+    vkd3d_spirv_build_op_label(builder, vkd3d_spirv_alloc_id(builder));

-    phase = &compiler->shader_phases[0];
-    if (is_control_point_phase(phase))
-        return phase;
+    compiler->phase = instruction->handler_idx;
+    spirv_compiler_emit_shader_phase_name(compiler, function_id, NULL);

-    return NULL;
+    phase = (instruction->handler_idx == VKD3DSIH_HS_CONTROL_POINT_PHASE)
+        ? &compiler->control_point_phase : &compiler->patch_constant_phase;
+    phase->function_id = function_id;
+    phase->function_location = vkd3d_spirv_stream_current_location(&builder->function_stream);
 }

static void spirv_compiler_emit_default_control_point_phase(struct spirv_compiler *compiler)
@@ -6840,9 +6742,6 @@ static void spirv_compiler_emit_shader_epilogue_invocation(struct spirv_compiler
 static void spirv_compiler_emit_hull_shader_main(struct spirv_compiler *compiler)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    const struct vkd3d_shader_phase *control_point_phase, *phase;
-    uint32_t phase_instance_id;
-    unsigned int i, j;
     uint32_t void_id;

vkd3d_spirv_builder_begin_main_function(builder);
@@ -6851,35 +6750,16 @@ static void spirv_compiler_emit_hull_shader_main(struct spirv_compiler *compiler

void_id = vkd3d_spirv_get_op_type_void(builder);

-    if ((control_point_phase = spirv_compiler_get_control_point_phase(compiler)))
-        vkd3d_spirv_build_op_function_call(builder, void_id, control_point_phase->function_id, NULL, 0);
+    if (compiler->control_point_phase.function_id)
+        vkd3d_spirv_build_op_function_call(builder, void_id, compiler->control_point_phase.function_id, NULL, 0);
     else
         spirv_compiler_emit_default_control_point_phase(compiler);

-    if (compiler->use_vocp)
-        spirv_compiler_emit_hull_shader_barrier(compiler);
-
-    for (i = 0; i < compiler->shader_phase_count; ++i)
-    {
-        phase = &compiler->shader_phases[i];
-        if (is_control_point_phase(phase))
-            continue;
-
-        if (phase->instance_count)
-        {
-            for (j = 0; j < phase->instance_count; ++j)
-            {
-                phase_instance_id = spirv_compiler_get_constant_uint(compiler, j);
-                vkd3d_spirv_build_op_function_call(builder,
-                        void_id, phase->function_id, &phase_instance_id, 1);
-            }
-        }
-        else
-        {
-            vkd3d_spirv_build_op_function_call(builder, void_id, phase->function_id, NULL, 0);
-        }
-    }
-
+    /* TODO: only call the patch constant function for invocation 0. The simplest way
+     * is to avoid use of private variables there, otherwise we would need a separate
+     * patch constant epilogue also only called from invocation 0. */
+    spirv_compiler_emit_hull_shader_barrier(compiler);
+    vkd3d_spirv_build_op_function_call(builder, void_id, compiler->patch_constant_phase.function_id, NULL, 0);
     spirv_compiler_emit_shader_epilogue_invocation(compiler);
     vkd3d_spirv_build_op_return(builder);
     vkd3d_spirv_build_op_function_end(builder);
@@ -7561,10 +7441,10 @@ static uint32_t spirv_compiler_emit_conditional_branch(struct spirv_compiler *co
 static void spirv_compiler_emit_return(struct spirv_compiler *compiler,
         const struct vkd3d_shader_instruction *instruction)
 {
-    const struct vkd3d_shader_phase *phase = spirv_compiler_get_current_shader_phase(compiler);
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;

-    if (compiler->shader_type != VKD3D_SHADER_TYPE_GEOMETRY && (!phase || is_control_point_phase(phase)))
+    if (compiler->shader_type != VKD3D_SHADER_TYPE_GEOMETRY && (is_in_default_phase(compiler)
+            || is_in_control_point_phase(compiler)))
         spirv_compiler_emit_shader_epilogue_invocation(compiler);

vkd3d_spirv_build_op_return(builder);
@@ -9685,10 +9565,6 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler,
         case VKD3DSIH_DCL_THREAD_GROUP:
             spirv_compiler_emit_dcl_thread_group(compiler, instruction);
             break;
-        case VKD3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
-        case VKD3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT:
-            ret = spirv_compiler_emit_shader_phase_instance_count(compiler, instruction);
-            break;
         case VKD3DSIH_HS_CONTROL_POINT_PHASE:
         case VKD3DSIH_HS_FORK_PHASE:
         case VKD3DSIH_HS_JOIN_PHASE:
@@ -9933,15 +9809,311 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler,
     return ret;
 }

+struct vkd3d_shader_normaliser
+{
+    struct vkd3d_shader_instruction_array instructions;
+
+    unsigned int max_temp_count;
+    unsigned int temp_dcl_idx;
+    uint64_t temp_is_instance_id;
+
+    unsigned int instance_count;
+    unsigned int phase_body_idx;
+    enum vkd3d_shader_opcode phase;
+};
+
+static inline bool shader_normaliser_reserve_instructions(struct vkd3d_shader_normaliser *normaliser, unsigned int extra)
+{
+    return shader_instruction_array_reserve(&normaliser->instructions, extra);
+}
+
+static void shader_normaliser_destroy(struct vkd3d_shader_normaliser *normaliser)
+{
+    shader_instruction_array_destroy(&normaliser->instructions, false);
+}
+
+static inline bool shader_src_param_is_phase_instance_id(const struct vkd3d_shader_src_param *param,
+        const struct vkd3d_shader_normaliser *normaliser)
+{
+    const struct vkd3d_shader_register *reg = &param->reg;
+    return vkd3d_shader_register_is_phase_instance_id(reg) || (reg->type == VKD3DSPR_TEMP
+            && !vkd3d_swizzle_get_component(param->swizzle, 0)
+            && (normaliser->temp_is_instance_id & (1ull << reg->idx[0].offset)));
+}
+
+static void shader_register_eliminate_phase_addressing(struct vkd3d_shader_register *reg,
+        unsigned int instance_id, const struct vkd3d_shader_normaliser *normaliser)
+{
+    unsigned int i;
+
+    for (i = 0; i < ARRAY_SIZE(reg->idx) && reg->idx[i].offset != ~0u; ++i)
+    {
+        if (reg->idx[i].rel_addr && shader_src_param_is_phase_instance_id(reg->idx[i].rel_addr, normaliser))
+        {
+            reg->idx[i].rel_addr = NULL;
+            reg->idx[i].offset += instance_id;
+        }
+    }
+}
+
+static void shader_instruction_eliminate_phase_instance_id(struct vkd3d_shader_instruction *ins,
+        unsigned int instance_id, const struct vkd3d_shader_normaliser *normaliser)
+{
+    struct vkd3d_shader_register *reg;
+    unsigned int i;
+
+    for (i = 0; i < ins->src_count; ++i)
+    {
+        reg = (struct vkd3d_shader_register *)&ins->src[i].reg;
+        if (shader_src_param_is_phase_instance_id(&ins->src[i], normaliser))
+        {
+            reg->type = VKD3DSPR_IMMCONST;
+            reg->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT;
+            reg->non_uniform = false;
+            reg->data_type = VKD3D_DATA_UINT;
+            reg->idx[0].offset = ~0u;
+            reg->idx[0].rel_addr = NULL;
+            reg->idx[1].offset = ~0u;
+            reg->idx[1].rel_addr = NULL;
+            reg->idx[2].offset = ~0u;
+            reg->idx[2].rel_addr = NULL;
+            reg->immconst_type = VKD3D_IMMCONST_SCALAR;
+            reg->u.immconst_uint[0] = instance_id;
+            continue;
+        }
+        shader_register_eliminate_phase_addressing(reg, instance_id, normaliser);
+    }
+
+    for (i = 0; i < ins->dst_count; ++i)
+        shader_register_eliminate_phase_addressing((struct vkd3d_shader_register *)&ins->dst[i].reg,
+                instance_id, normaliser);
+}
+
+static bool shader_register_clone_relative_addresses(struct vkd3d_shader_register *reg,
+        struct vkd3d_shader_instruction_array *instructions)
+{
+    struct vkd3d_shader_src_param *src;
+    unsigned int i;
+
+    for (i = 0; i < ARRAY_SIZE(reg->idx) && reg->idx[i].offset != ~0u; ++i)
+    {
+        if (!reg->idx[i].rel_addr)
+            continue;
+
+        if (!(src = shader_src_param_allocator_get(&instructions->src_params, 1)))
+            return false;
+
+        memcpy(src, reg->idx[i].rel_addr, sizeof(*src));
+        reg->idx[i].rel_addr = src;
+    }
+
+    return true;
+}
+
+static bool shader_instruction_array_clone_instruction(struct vkd3d_shader_instruction_array *instructions,
+        unsigned int dst, const struct vkd3d_shader_instruction *src)
+{
+    struct vkd3d_shader_instruction *ins = &instructions->elements[dst];
+    struct vkd3d_shader_dst_param *dst_params;
+    struct vkd3d_shader_src_param *src_params;
+    unsigned int i;
+
+    *ins = *src;
+
+    if (ins->dst_count && ins->dst)
+    {
+        if (!(dst_params = shader_dst_param_allocator_get(&instructions->dst_params, ins->dst_count)))
+            return false;
+
+        memcpy(dst_params, ins->dst, ins->dst_count * sizeof(*ins->dst));
+        ins->dst = dst_params;
+        for (i = 0; i < ins->dst_count; ++i)
+        {
+            if (!shader_register_clone_relative_addresses(&dst_params[i].reg, instructions))
+                return false;
+        }
+    }
+    if (ins->src_count)
+    {
+        if (!(src_params = shader_src_param_allocator_get(&instructions->src_params, ins->src_count)))
+            return false;
+
+        memcpy(src_params, ins->src, ins->src_count * sizeof(*ins->src));
+        ins->src = src_params;
+        for (i = 0; i < ins->src_count; ++i)
+        {
+            if (!shader_register_clone_relative_addresses(&src_params[i].reg, instructions))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static enum vkd3d_result shader_normaliser_eliminate_phase_instance_id(struct vkd3d_shader_normaliser *normaliser,
+        unsigned int *instruction_count)
+{
+    struct vkd3d_shader_instruction *ins = &normaliser->instructions.elements[normaliser->instructions.count];
+    unsigned int i, j, count;
+
+    if (ins->handler_idx == VKD3DSIH_HS_FORK_PHASE || ins->handler_idx == VKD3DSIH_HS_JOIN_PHASE)
+    {
+        /* Leave the first occurrence and delete the rest. */
+        *instruction_count = normaliser->phase != ins->handler_idx;
+        /* Reset the phase info. */
+        normaliser->phase_body_idx = ~0u;
+        normaliser->phase = ins->handler_idx;
+        normaliser->instance_count = 1;
+        normaliser->temp_is_instance_id = 0;
+        return VKD3D_OK;
+    }
+    else if (ins->handler_idx == VKD3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT
+            || ins->handler_idx == VKD3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT)
+    {
+        normaliser->instance_count = ins->declaration.count + !ins->declaration.count;
+        *instruction_count = 0;
+        return VKD3D_OK;
+    }
+    else if (ins->handler_idx == VKD3DSIH_DCL_INPUT && vkd3d_shader_register_is_phase_instance_id(
+            &ins->declaration.dst.reg))
+    {
+        *instruction_count = 0;
+        return VKD3D_OK;
+    }
+    else if (ins->handler_idx == VKD3DSIH_DCL_TEMPS && normaliser->phase != VKD3DSIH_INVALID)
+    {
+        /* Leave only the first temp declaration and set it to the max count later. */
+        if (!normaliser->max_temp_count)
+            normaliser->temp_dcl_idx = normaliser->instructions.count;
+        else
+            *instruction_count = 0;
+        normaliser->max_temp_count = max(normaliser->max_temp_count, ins->declaration.count);
+        return VKD3D_OK;
+    }
+
+    if (normaliser->phase == VKD3DSIH_INVALID || is_dcl_instruction(ins->handler_idx))
+        return VKD3D_OK;
+
+    if (ins->handler_idx == VKD3DSIH_MOV && vkd3d_shader_register_is_phase_instance_id(&ins->src->reg))
+    {
+        if (ins->dst->reg.type != VKD3DSPR_TEMP)
+        {
+            FIXME("Instance id not assigned to temp register.\n");
+            return VKD3D_OK;
+        }
+        /* Instance id always seems to be assigned to r{n}.x */
+        if (ins->dst->write_mask != VKD3DSP_WRITEMASK_0)
+            FIXME("Unsupported write mask %#x.\n", ins->dst->write_mask);
+        if (ins->dst->reg.idx[0].offset >= sizeof(normaliser->temp_is_instance_id) * CHAR_BIT)
+            FIXME("Unsupported temp idx %u.\n", ins->dst->reg.idx[0].offset);
+        else
+            normaliser->temp_is_instance_id |= 1ull << ins->dst->reg.idx[0].offset;
+        *instruction_count = 0;
+        return VKD3D_OK;
+    }
+
+    if (normaliser->phase_body_idx == ~0u)
+        normaliser->phase_body_idx = normaliser->instructions.count;
+
+    if (ins->handler_idx != VKD3DSIH_RET)
+        return VKD3D_OK;
+
+    count = normaliser->instructions.count - normaliser->phase_body_idx;
+
+    if (!shader_instruction_array_reserve(&normaliser->instructions, count * (normaliser->instance_count - 1)))
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+
+    /* Make a copy of the non-dcl instructions for each instance. */
+    ins = &normaliser->instructions.elements[normaliser->phase_body_idx];
+    for (i = 1; i < normaliser->instance_count; ++i)
+    {
+        for (j = 0; j < count; ++j)
+        {
+            if (!shader_instruction_array_clone_instruction(&normaliser->instructions,
+                    normaliser->phase_body_idx + count * i + j, &ins[j]))
+                return VKD3D_ERROR_OUT_OF_MEMORY;
+        }
+    }
+    /* Replace each reference to the instance id with a constant instance id. */
+    for (i = 0; i < normaliser->instance_count; ++i)
+    {
+        for (j = 0; j < count; ++j)
+            shader_instruction_eliminate_phase_instance_id(
+                    &normaliser->instructions.elements[normaliser->phase_body_idx + count * i + j], i, normaliser);
+    }
+
+    *instruction_count = count * (normaliser->instance_count - 1);
+    return VKD3D_OK;
+}
+
+static enum vkd3d_result shader_instruction_array_normalise(const struct vkd3d_shader_instruction_array *instructions,
+        struct vkd3d_shader_normaliser *normaliser)
+{
+    enum vkd3d_result result = VKD3D_OK;
+    unsigned int i, instruction_count;
+
+    memset(normaliser, 0, sizeof(*normaliser));
+    normaliser->phase = VKD3DSIH_INVALID;
+    if (!shader_instruction_array_init(&normaliser->instructions, instructions->count))
+    {
+        ERR("Failed to allocate instructions.\n");
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+    }
+
+    for (i = 0; i < instructions->count; ++i)
+    {
+        if (!shader_normaliser_reserve_instructions(normaliser, 1))
+        {
+            result = VKD3D_ERROR_OUT_OF_MEMORY;
+            break;
+        }
+
+        if (!shader_instruction_array_clone_instruction(&normaliser->instructions, normaliser->instructions.count,
+                &instructions->elements[i]))
+        {
+            result = VKD3D_ERROR_OUT_OF_MEMORY;
+            break;
+        }
+
+        instruction_count = 1;
+        if ((result = shader_normaliser_eliminate_phase_instance_id(normaliser, &instruction_count)) < 0)
+            break;
+
+        normaliser->instructions.count += instruction_count;
+    }
+
+    if (result >= 0 && normaliser->phase != VKD3DSIH_INVALID)
+    {
+        if (normaliser->temp_dcl_idx)
+            normaliser->instructions.elements[normaliser->temp_dcl_idx].declaration.count = normaliser->max_temp_count;
+        if (!shader_normaliser_reserve_instructions(normaliser, 1))
+            result = VKD3D_ERROR_OUT_OF_MEMORY;
+        else
+            normaliser->instructions.elements[normaliser->instructions.count++].handler_idx = VKD3DSIH_RET;
+    }
+
+    return result;
+}
+
 int spirv_compiler_handle_instructions(struct spirv_compiler *compiler,
         const struct vkd3d_shader_instruction_array *instructions)
 {
+    struct vkd3d_shader_normaliser normaliser;
     enum vkd3d_result result = VKD3D_OK;
     unsigned int i;

+    if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
+    {
+        result = shader_instruction_array_normalise(instructions, &normaliser);
+        instructions = &normaliser.instructions;
+    }
+
     for (i = 0; i < instructions->count && result >= 0; ++i)
         result = spirv_compiler_handle_instruction(compiler, &instructions->elements[i]);

+    if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
+        shader_normaliser_destroy(&normaliser);
+
     return result;
 }

@@ -9951,10 +10123,9 @@ int spirv_compiler_generate_spirv(struct spirv_compiler *compiler,
     const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info;
     const struct vkd3d_shader_spirv_domain_shader_target_info *ds_info;
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    const struct vkd3d_shader_phase *phase;

-    if ((phase = spirv_compiler_get_current_shader_phase(compiler)))
-        spirv_compiler_leave_shader_phase(compiler, phase);
+    if (!is_in_default_phase(compiler))
+        spirv_compiler_leave_shader_phase(compiler);
     else
         vkd3d_spirv_build_op_function_end(builder);

@@ -10022,7 +10193,6 @@ void spirv_compiler_destroy(struct spirv_compiler *compiler)

rb_destroy(&compiler->symbol_table, vkd3d_symbol_free, NULL);

-    vkd3d_free(compiler->shader_phases);
     vkd3d_free(compiler->spec_constants);

vkd3d_string_buffer_cache_cleanup(&compiler->string_buffers);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 6e5294ba..16be7e29 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -923,6 +923,11 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg
     return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT;
 }

+static inline bool vkd3d_shader_register_is_phase_instance_id(const struct vkd3d_shader_register *reg)
+{
+    return reg->type == VKD3DSPR_FORKINSTID || reg->type == VKD3DSPR_JOININSTID;
+}
+
 struct vkd3d_shader_location
 {
     const char *source_name;