[PATCH v4 0/18] MR401: Draft: vkd3d-shader/dxil: Implement constant buffer loads.

[Conor McCarthy (＠cmccarthy)]

Goes atop MR 346, 400, 372, and 388. The last six commits belong to this MR.

--
  v4: vkd3d-shader/dxil: Implement the DXIL EXTRACTVAL instruction.
      vkd3d-shader/dxil: Implement DX instruction CBufferLoadLegacy.
      vkd3d-shader/dxil: Implement DX instruction CreateHandle.
      vkd3d-shader/dxil: Read CBV descriptors.
      vkd3d-shader/spirv: Align constant buffer sizes to 16 bytes.
      vkd3d-shader/spirv: Support scalar swizzle of vector SSA registers.
      vkd3d-shader/dxil: Read DXIL compute shader thread group dimensions.
      vkd3d-shader/dxil: Read DXIL global flags.
      vkd3d-shader: Define more global flags.
      vkd3d-shader/dxil: Handle multi-row signature elements.
      vkd3d-shader/dxil: Handle signature element additional tag/value pairs.
      vkd3d-shader/dxil: Read the DXIL input and output signatures.
      vkd3d-shader/dxil: Validate the entry point info.
      vkd3d-shader/dxil: Read DXIL metadata named nodes.
      vkd3d-shader/dxil: Read DXIL metadata kinds.
      vkd3d-shader/dxil: Read DXIL metadata values.
      vkd3d-shader/dxil: Read DXIL metadata nodes.
      vkd3d-shader/dxil: Read DXIL metadata strings.

https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/401

[PATCH v4 01/18] vkd3d-shader/dxil: Read DXIL metadata strings.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 134 ++++++++++++++++++++++-
 libs/vkd3d-shader/vkd3d_shader_private.h |   1 +
 2 files changed, 134 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index bfb34d248..19a9758ab 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -20,6 +20,8 @@

#define VKD3D_SM6_VERSION_MAJOR(version) (((version) >> 4) & 0xf)
 #define VKD3D_SM6_VERSION_MINOR(version) (((version) >> 0) & 0xf)
+/* Two seems to be the maximum but leave some extra room. */
+#define VKD3D_SM6_MAX_METADATA_TABLES 4

#define BITCODE_MAGIC VKD3D_MAKE_TAG('B', 'C', 0xc0, 0xde)
 #define DXIL_OP_MAX_OPERANDS 17
@@ -114,6 +116,19 @@ enum bitcode_function_code
     FUNC_CODE_INST_CMPXCHG     = 46,
 };

+enum bitcode_metadata_code
+{
+    METADATA_STRING             =  1,
+    METADATA_VALUE              =  2,
+    METADATA_NODE               =  3,
+    METADATA_NAME               =  4,
+    METADATA_DISTINCT_NODE      =  5,
+    METADATA_KIND               =  6,
+    METADATA_LOCATION           =  7,
+    METADATA_NAMED_NODE         = 10,
+    METADATA_ATTACHMENT         = 11,
+};
+
 enum bitcode_type_code
 {
     TYPE_CODE_NUMENTRY     =  1,
@@ -278,6 +293,26 @@ struct dxil_block
     size_t record_count;
 };

+enum sm6_metadata_type
+{
+    VKD3D_METADATA_STRING,
+};
+
+struct sm6_metadata_value
+{
+    enum sm6_metadata_type type;
+    union
+    {
+        char *string_value;
+    } u;
+};
+
+struct sm6_metadata_table
+{
+    struct sm6_metadata_value *values;
+    unsigned int count;
+};
+
 struct sm6_parser
 {
     const uint32_t *ptr, *start, *end;
@@ -292,6 +327,7 @@ struct sm6_parser

struct sm6_type *types;
     size_t type_count;
+    struct sm6_type *metadata_type;

struct sm6_symbol *global_symbols;
     size_t global_symbol_count;
@@ -302,6 +338,8 @@ struct sm6_parser
     struct sm6_function *functions;
     size_t function_count;

+    struct sm6_metadata_table metadata_tables[VKD3D_SM6_MAX_METADATA_TABLES];
+
     struct sm6_value *values;
     size_t value_count;
     size_t value_capacity;
@@ -1173,6 +1211,7 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6)

case TYPE_CODE_METADATA:
                 type->class = TYPE_CLASS_METADATA;
+                sm6->metadata_type = type;
                 break;

case TYPE_CODE_NUMENTRY:
@@ -2818,6 +2857,80 @@ static enum vkd3d_result sm6_parser_module_init(struct sm6_parser *sm6, const st
     return VKD3D_OK;
 }

+static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const struct dxil_block *block,
+        struct sm6_metadata_table *table)
+{
+    struct sm6_metadata_value *values, *m;
+    unsigned int i, count, table_idx;
+    const struct dxil_record *record;
+
+    for (i = 0, count = 0; i < block->record_count; ++i)
+        count += block->records[i]->code != METADATA_NAME;
+
+    if (!(values = vkd3d_calloc(count, sizeof(*values))))
+    {
+        ERR("Failed to allocate metadata tables.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
+                "Out of memory allocating metadata tables.");
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+    }
+    table->values = values;
+
+    for (i = 0; i < block->record_count; ++i)
+    {
+        record = block->records[i];
+
+        table_idx = table->count;
+        m = &values[table_idx];
+
+        switch (record->code)
+        {
+            case METADATA_STRING:
+                /* LLVM allows an empty string here. */
+                m->type = VKD3D_METADATA_STRING;
+                if (!(m->u.string_value = dxil_record_to_string(record, 0, sm6)))
+                {
+                    ERR("Failed to allocate string.\n");
+                    return VKD3D_ERROR_OUT_OF_MEMORY;
+                }
+                break;
+
+            default:
+                FIXME("Unhandled metadata type %u.\n", record->code);
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                        "Metadata type %u is unhandled.", record->code);
+                return VKD3D_ERROR_INVALID_SHADER;
+        }
+        ++table->count;
+    }
+
+    return VKD3D_OK;
+}
+
+static void sm6_metadata_value_destroy(struct sm6_metadata_value *m)
+{
+    switch (m->type)
+    {
+        case VKD3D_METADATA_STRING:
+            vkd3d_free(m->u.string_value);
+            break;
+        default:
+            break;
+    }
+}
+
+static void sm6_parser_metadata_cleanup(struct sm6_parser *sm6)
+{
+    unsigned int i, j;
+
+    for (i = 0; i < ARRAY_SIZE(sm6->metadata_tables); ++i)
+    {
+        for (j = 0; j < sm6->metadata_tables[i].count; ++j)
+            sm6_metadata_value_destroy(&sm6->metadata_tables[i].values[j]);
+        vkd3d_free(sm6->metadata_tables[i].values);
+    }
+}
+
 static void sm6_type_table_cleanup(struct sm6_type *types, size_t count)
 {
     size_t i;
@@ -2881,6 +2994,7 @@ static void sm6_parser_destroy(struct vkd3d_shader_parser *parser)
     sm6_type_table_cleanup(sm6->types, sm6->type_count);
     sm6_symtab_cleanup(sm6->global_symbols, sm6->global_symbol_count);
     sm6_functions_cleanup(sm6->functions, sm6->function_count);
+    sm6_parser_metadata_cleanup(sm6);
     vkd3d_free(sm6->values);
     free_shader_desc(&parser->shader_desc);
     vkd3d_free(sm6);
@@ -2904,7 +3018,7 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
     struct vkd3d_shader_version version;
     struct dxil_block *block;
     enum vkd3d_result ret;
-    unsigned int i;
+    unsigned int i, j;

count = byte_code_size / sizeof(*byte_code);
     if (count < 6)
@@ -3091,6 +3205,24 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
         return ret;
     }

+    for (i = 0, j = 0; i < sm6->root_block.child_block_count; ++i)
+    {
+        block = sm6->root_block.child_blocks[i];
+        if (block->id != METADATA_BLOCK)
+            continue;
+
+        if (j == ARRAY_SIZE(sm6->metadata_tables))
+        {
+            FIXME("Too many metadata tables.\n");
+            vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                    "A metadata table count greater than %zu is unsupported.", ARRAY_SIZE(sm6->metadata_tables));
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if ((ret = sm6_parser_metadata_init(sm6, block, &sm6->metadata_tables[j++])) < 0)
+            return ret;
+    }
+
     sm6_parser_init_output_signature(sm6, output_signature);
     sm6_parser_init_input_signature(sm6, input_signature);

diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 495bda146..f94a12df7 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -176,6 +176,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_INVALID_MODULE              = 8011,
     VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND             = 8012,
     VKD3D_SHADER_ERROR_DXIL_UNHANDLED_INTRINSIC         = 8013,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA            = 8014,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,

[PATCH v4 02/18] vkd3d-shader/dxil: Read DXIL metadata nodes.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c | 76 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 19a9758ab..d36224999 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -295,15 +295,25 @@ struct dxil_block

enum sm6_metadata_type
 {
+    VKD3D_METADATA_NODE,
     VKD3D_METADATA_STRING,
 };

+struct sm6_metadata_node
+{
+    bool is_distinct;
+    unsigned int operand_count;
+    struct sm6_metadata_value *operands[];
+};
+
 struct sm6_metadata_value
 {
     enum sm6_metadata_type type;
+    const struct sm6_type *value_type;
     union
     {
         char *string_value;
+        struct sm6_metadata_node *node;
     } u;
 };

@@ -2857,12 +2867,69 @@ static enum vkd3d_result sm6_parser_module_init(struct sm6_parser *sm6, const st
     return VKD3D_OK;
 }

+static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m, struct sm6_metadata_table *table,
+        unsigned int dst_idx, unsigned int end_count, const struct dxil_record *record, struct sm6_parser *sm6)
+{
+    struct sm6_metadata_node *node;
+    unsigned int i;
+
+    m->type = VKD3D_METADATA_NODE;
+    if (!(m->value_type = sm6->metadata_type))
+    {
+        WARN("Metadata type not found.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                "The type for metadata values was not found.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+    if (!(node = vkd3d_malloc(offsetof(struct sm6_metadata_node, operands[record->operand_count]))))
+    {
+        ERR("Failed to allocate metadata node with %u operands.\n", record->operand_count);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
+                "Out of memory allocating a metadata node with %u operands.", record->operand_count);
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+    }
+    m->u.node = node;
+
+    node->is_distinct = record->code == METADATA_DISTINCT_NODE;
+
+    for (i = 0; i < record->operand_count; ++i)
+    {
+        uint64_t ref;
+
+        ref = record->operands[i] - 1;
+        if (record->operands[i] >= 1 && ref >= end_count)
+        {
+            WARN("Invalid metadata index %"PRIu64".\n", ref);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                    "Metadata index %"PRIu64" is invalid.", ref);
+            vkd3d_free(node);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if (!node->is_distinct && ref == dst_idx)
+        {
+            WARN("Metadata self-reference at index %u.\n", dst_idx);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                    "Metadata index %u is self-referencing.", dst_idx);
+            vkd3d_free(node);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        node->operands[i] = (record->operands[i] >= 1) ? &table->values[ref] : NULL;
+    }
+
+    node->operand_count = record->operand_count;
+
+    return VKD3D_OK;
+}
+
 static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_metadata_table *table)
 {
     struct sm6_metadata_value *values, *m;
     unsigned int i, count, table_idx;
     const struct dxil_record *record;
+    enum vkd3d_result ret;

for (i = 0, count = 0; i < block->record_count; ++i)
         count += block->records[i]->code != METADATA_NAME;
@@ -2885,6 +2952,12 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const

switch (record->code)
         {
+            case METADATA_DISTINCT_NODE:
+            case METADATA_NODE:
+                if ((ret = metadata_value_create_node(m, table, table_idx, count, record, sm6)) < 0)
+                    return ret;
+                break;
+
             case METADATA_STRING:
                 /* LLVM allows an empty string here. */
                 m->type = VKD3D_METADATA_STRING;
@@ -2911,6 +2984,9 @@ static void sm6_metadata_value_destroy(struct sm6_metadata_value *m)
 {
     switch (m->type)
     {
+        case VKD3D_METADATA_NODE:
+            vkd3d_free(m->u.node);
+            break;
         case VKD3D_METADATA_STRING:
             vkd3d_free(m->u.string_value);
             break;

[PATCH v4 03/18] vkd3d-shader/dxil: Read DXIL metadata values.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 54 +++++++++++++++++++++++-
 libs/vkd3d-shader/vkd3d_shader_private.h |  1 +
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index d36224999..2c04f5d16 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -297,6 +297,7 @@ enum sm6_metadata_type
 {
     VKD3D_METADATA_NODE,
     VKD3D_METADATA_STRING,
+    VKD3D_METADATA_VALUE,
 };

struct sm6_metadata_node
@@ -313,6 +314,7 @@ struct sm6_metadata_value
     union
     {
         char *string_value;
+        const struct sm6_value *value;
         struct sm6_metadata_node *node;
     } u;
 };
@@ -1601,6 +1603,11 @@ static inline bool sm6_value_is_undef(const struct sm6_value *value)
     return sm6_value_is_register(value) && value->u.reg.type == VKD3DSPR_UNDEF;
 }

+static bool sm6_value_is_icb(const struct sm6_value *value)
+{
+    return sm6_value_is_register(value) && value->u.reg.type == VKD3DSPR_IMMCONSTBUFFER;
+}
+
 static inline unsigned int sm6_value_get_constant_uint(const struct sm6_value *value)
 {
     if (!sm6_value_is_constant(value))
@@ -1831,6 +1838,17 @@ static size_t sm6_parser_get_value_index(struct sm6_parser *sm6, uint64_t idx)
     return i;
 }

+static const struct sm6_value *sm6_parser_get_value_safe(struct sm6_parser *sm6, unsigned int idx)
+{
+    if (idx < sm6->value_count)
+        return &sm6->values[idx];
+
+    WARN("Invalid value index %u.\n", idx);
+    vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND,
+            "Invalid value index %u.", idx);
+    return NULL;
+}
+
 static size_t sm6_parser_get_value_idx_by_ref(struct sm6_parser *sm6, const struct dxil_record *record,
         const struct sm6_type *fwd_type, unsigned int *rec_idx)
 {
@@ -2926,9 +2944,10 @@ static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m
 static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_metadata_table *table)
 {
+    unsigned int i, count, table_idx, value_idx;
     struct sm6_metadata_value *values, *m;
-    unsigned int i, count, table_idx;
     const struct dxil_record *record;
+    const struct sm6_value *value;
     enum vkd3d_result ret;

for (i = 0, count = 0; i < block->record_count; ++i)
@@ -2968,6 +2987,39 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
                 }
                 break;

+            case METADATA_VALUE:
+                if (!dxil_record_validate_operand_count(record, 2, 2, sm6))
+                    return VKD3D_ERROR_INVALID_SHADER;
+
+                m->type = VKD3D_METADATA_VALUE;
+                if (!(m->value_type = sm6_parser_get_type(sm6, record->operands[0])))
+                    return VKD3D_ERROR_INVALID_SHADER;
+
+                if (record->operands[1] > UINT_MAX)
+                    WARN("Truncating value index %"PRIu64".\n", record->operands[1]);
+                value_idx = record->operands[1];
+                if (!(value = sm6_parser_get_value_safe(sm6, value_idx)))
+                    return VKD3D_ERROR_INVALID_SHADER;
+
+                if (!sm6_value_is_constant(value) && !sm6_value_is_undef(value) && !sm6_value_is_icb(value)
+                        && !sm6_value_is_function_dcl(value))
+                {
+                    WARN("Value at index %u is not a constant or a function declaration.\n", value_idx);
+                    vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                            "Metadata value at index %u is not a constant or a function declaration.", value_idx);
+                    return VKD3D_ERROR_INVALID_SHADER;
+                }
+                m->u.value = value;
+
+                if (value->type != m->value_type)
+                {
+                    WARN("Type mismatch.\n");
+                    vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH,
+                            "The type of a metadata value does not match its referenced value at index %u.", value_idx);
+                }
+
+                break;
+
             default:
                 FIXME("Unhandled metadata type %u.\n", record->code);
                 vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index f94a12df7..060647a68 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -183,6 +183,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_WARNING_DXIL_INVALID_BLOCK_LENGTH      = 8302,
     VKD3D_SHADER_WARNING_DXIL_INVALID_MODULE_LENGTH     = 8303,
     VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS         = 8304,
+    VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH             = 8305,

VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED             = 9000,
     VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER             = 9001,

[PATCH v4 04/18] vkd3d-shader/dxil: Read DXIL metadata kinds.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 2c04f5d16..2695b9f61 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -295,6 +295,7 @@ struct dxil_block

enum sm6_metadata_type
 {
+    VKD3D_METADATA_KIND,
     VKD3D_METADATA_NODE,
     VKD3D_METADATA_STRING,
     VKD3D_METADATA_VALUE,
@@ -307,6 +308,12 @@ struct sm6_metadata_node
     struct sm6_metadata_value *operands[];
 };

+struct sm6_metadata_kind
+{
+    uint64_t id;
+    char *name;
+};
+
 struct sm6_metadata_value
 {
     enum sm6_metadata_type type;
@@ -316,6 +323,7 @@ struct sm6_metadata_value
         char *string_value;
         const struct sm6_value *value;
         struct sm6_metadata_node *node;
+        struct sm6_metadata_kind kind;
     } u;
 };

@@ -2977,6 +2985,19 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
                     return ret;
                 break;

+            case METADATA_KIND:
+                if (!dxil_record_validate_operand_min_count(record, 2, sm6))
+                    return VKD3D_ERROR_INVALID_SHADER;
+
+                m->type = VKD3D_METADATA_KIND;
+                m->u.kind.id = record->operands[0];
+                if (!(m->u.kind.name = dxil_record_to_string(record, 1, sm6)))
+                {
+                    ERR("Failed to allocate name of a kind.\n");
+                    return VKD3D_ERROR_OUT_OF_MEMORY;
+                }
+                break;
+
             case METADATA_STRING:
                 /* LLVM allows an empty string here. */
                 m->type = VKD3D_METADATA_STRING;
@@ -3039,6 +3060,9 @@ static void sm6_metadata_value_destroy(struct sm6_metadata_value *m)
         case VKD3D_METADATA_NODE:
             vkd3d_free(m->u.node);
             break;
+        case VKD3D_METADATA_KIND:
+            vkd3d_free(m->u.kind.name);
+            break;
         case VKD3D_METADATA_STRING:
             vkd3d_free(m->u.string_value);
             break;

[PATCH v4 05/18] vkd3d-shader/dxil: Read DXIL metadata named nodes.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c | 104 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 99 insertions(+), 5 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 2695b9f61..9e591af25 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -333,6 +333,12 @@ struct sm6_metadata_table
     unsigned int count;
 };

+struct sm6_named_metadata
+{
+    char *name;
+    struct sm6_metadata_value value;
+};
+
 struct sm6_parser
 {
     const uint32_t *ptr, *start, *end;
@@ -359,6 +365,8 @@ struct sm6_parser
     size_t function_count;

struct sm6_metadata_table metadata_tables[VKD3D_SM6_MAX_METADATA_TABLES];
+    struct sm6_named_metadata *named_metadata;
+    unsigned int named_metadata_count;

struct sm6_value *values;
     size_t value_count;
@@ -2697,6 +2705,11 @@ static void sm6_parser_emit_ret(struct sm6_parser *sm6, const struct dxil_record
     ins->handler_idx = VKD3DSIH_NOP;
 }

+static bool sm6_metadata_value_is_node(const struct sm6_metadata_value *m)
+{
+    return m && m->type == VKD3D_METADATA_NODE;
+}
+
 static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_function *function)
 {
@@ -2893,11 +2906,31 @@ static enum vkd3d_result sm6_parser_module_init(struct sm6_parser *sm6, const st
     return VKD3D_OK;
 }

+static bool sm6_parser_allocate_named_metadata(struct sm6_parser *sm6)
+{
+    struct dxil_block *block;
+    unsigned int i, j, count;
+
+    for (i = 0, count = 0; i < sm6->root_block.child_block_count; ++i)
+    {
+        block = sm6->root_block.child_blocks[i];
+        if (block->id != METADATA_BLOCK)
+            continue;
+        for (j = 0; j < block->record_count; ++j)
+            count += block->records[j]->code == METADATA_NAMED_NODE;
+    }
+
+    if (!count)
+        return true;
+
+    return !!(sm6->named_metadata = vkd3d_calloc(count, sizeof(*sm6->named_metadata)));
+}
+
 static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m, struct sm6_metadata_table *table,
         unsigned int dst_idx, unsigned int end_count, const struct dxil_record *record, struct sm6_parser *sm6)
 {
     struct sm6_metadata_node *node;
-    unsigned int i;
+    unsigned int i, offset;

m->type = VKD3D_METADATA_NODE;
     if (!(m->value_type = sm6->metadata_type))
@@ -2918,12 +2951,14 @@ static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m

node->is_distinct = record->code == METADATA_DISTINCT_NODE;

+    offset = record->code != METADATA_NAMED_NODE;
+
     for (i = 0; i < record->operand_count; ++i)
     {
         uint64_t ref;

-        ref = record->operands[i] - 1;
-        if (record->operands[i] >= 1 && ref >= end_count)
+        ref = record->operands[i] - offset;
+        if (record->operands[i] >= offset && ref >= end_count)
         {
             WARN("Invalid metadata index %"PRIu64".\n", ref);
             vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
@@ -2941,7 +2976,15 @@ static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m
             return VKD3D_ERROR_INVALID_SHADER;
         }

-        node->operands[i] = (record->operands[i] >= 1) ? &table->values[ref] : NULL;
+        node->operands[i] = (record->operands[i] >= offset) ? &table->values[ref] : NULL;
+        if (record->code == METADATA_NAMED_NODE && !sm6_metadata_value_is_node(node->operands[i]))
+        {
+            WARN("Named node operand is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                    "The operand of a metadata named node is not a node.");
+            vkd3d_free(node);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
     }

node->operand_count = record->operand_count;
@@ -2957,6 +3000,7 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
     const struct dxil_record *record;
     const struct sm6_value *value;
     enum vkd3d_result ret;
+    char *name;

for (i = 0, count = 0; i < block->record_count; ++i)
         count += block->records[i]->code != METADATA_NAME;
@@ -2970,7 +3014,7 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
     }
     table->values = values;

-    for (i = 0; i < block->record_count; ++i)
+    for (i = 0, name = NULL; i < block->record_count; ++i)
     {
         record = block->records[i];

@@ -2979,6 +3023,27 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const

switch (record->code)
         {
+            case METADATA_NAMED_NODE:
+                if (!name)
+                {
+                    WARN("Named node has no name.\n");
+                    vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                            "A metadata named node has no name.");
+                    return VKD3D_ERROR_INVALID_SHADER;
+                }
+
+                /* When DXC emits metadata value array reference indices it assumes named nodes
+                 * are not included in the array. Store named nodes separately. */
+                m = &sm6->named_metadata[sm6->named_metadata_count].value;
+                sm6->named_metadata[sm6->named_metadata_count].name = name;
+                name = NULL;
+
+                if ((ret = metadata_value_create_node(m, table, UINT_MAX, count, record, sm6)) < 0)
+                    return ret;
+                ++sm6->named_metadata_count;
+                /* Skip incrementing the table count. */
+                continue;
+
             case METADATA_DISTINCT_NODE:
             case METADATA_NODE:
                 if ((ret = metadata_value_create_node(m, table, table_idx, count, record, sm6)) < 0)
@@ -2998,6 +3063,23 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
                 }
                 break;

+            case METADATA_NAME:
+                /* Check the next record to avoid freeing 'name' in all exit paths. */
+                if (i + 1 == block->record_count || block->records[i + 1]->code != METADATA_NAMED_NODE)
+                {
+                    WARN("Name is not followed by a named node.\n");
+                    vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA,
+                            "A metadata node name is not followed by a named node.");
+                    return VKD3D_ERROR_INVALID_SHADER;
+                }
+                /* LLVM allows an empty string here. */
+                if (!(name = dxil_record_to_string(record, 0, sm6)))
+                {
+                    ERR("Failed to allocate name.\n");
+                    return VKD3D_ERROR_OUT_OF_MEMORY;
+                }
+                continue;
+
             case METADATA_STRING:
                 /* LLVM allows an empty string here. */
                 m->type = VKD3D_METADATA_STRING;
@@ -3081,6 +3163,12 @@ static void sm6_parser_metadata_cleanup(struct sm6_parser *sm6)
             sm6_metadata_value_destroy(&sm6->metadata_tables[i].values[j]);
         vkd3d_free(sm6->metadata_tables[i].values);
     }
+    for (i = 0; i < sm6->named_metadata_count; ++i)
+    {
+        sm6_metadata_value_destroy(&sm6->named_metadata[i].value);
+        vkd3d_free(sm6->named_metadata[i].name);
+    }
+    vkd3d_free(sm6->named_metadata);
 }

static void sm6_type_table_cleanup(struct sm6_type *types, size_t count)
@@ -3357,6 +3445,12 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
         return ret;
     }

+    if (!sm6_parser_allocate_named_metadata(sm6))
+    {
+        ERR("Failed to allocate named metadata array.\n");
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+    }
+
     for (i = 0, j = 0; i < sm6->root_block.child_block_count; ++i)
     {
         block = sm6->root_block.child_blocks[i];

[PATCH v4 06/18] vkd3d-shader/dxil: Validate the entry point info.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 112 +++++++++++++++++++++--
 libs/vkd3d-shader/vkd3d_shader_private.h |   2 +
 2 files changed, 105 insertions(+), 9 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 9e591af25..fdcb84013 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -358,6 +358,8 @@ struct sm6_parser
     struct sm6_symbol *global_symbols;
     size_t global_symbol_count;

+    const char *entry_point;
+
     struct vkd3d_shader_dst_param *output_params;
     struct vkd3d_shader_dst_param *input_params;

@@ -2710,6 +2712,11 @@ static bool sm6_metadata_value_is_node(const struct sm6_metadata_value *m)
     return m && m->type == VKD3D_METADATA_NODE;
 }

+static bool sm6_metadata_value_is_string(const struct sm6_metadata_value *m)
+{
+    return m && m->type == VKD3D_METADATA_STRING;
+}
+
 static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_function *function)
 {
@@ -3135,6 +3142,77 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
     return VKD3D_OK;
 }

+static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm6_parser *sm6, const char *name)
+{
+    const struct sm6_metadata_node *node;
+    unsigned int i;
+
+    for (i = 0; i < sm6->named_metadata_count; ++i)
+    {
+        if (strcmp(sm6->named_metadata[i].name, name))
+            continue;
+
+        node = sm6->named_metadata[i].value.u.node;
+        if (!node->operand_count)
+            return NULL;
+        if (node->operand_count > 1)
+        {
+            FIXME("Ignoring %u extra operands for %s.\n", node->operand_count - 1, name);
+            vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                    "Ignoring %u extra operands for metadata node %s.", node->operand_count - 1, name);
+        }
+        return node->operands[0];
+    }
+
+    return NULL;
+}
+
+static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
+{
+    const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints");
+    const struct sm6_metadata_node *entry_node = m ? m->u.node : NULL;
+    const struct sm6_value *value;
+
+    if (!entry_node || entry_node->operand_count < 2 || !(m = entry_node->operands[0]))
+    {
+        WARN("No entry point definition found.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT,
+                "No entry point definition found in the metadata.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    if (m->type != VKD3D_METADATA_VALUE)
+    {
+        WARN("Entry point definition is not a value.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT,
+                "Entry point definition is not a metadata value.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    value = m->u.value;
+    if (!sm6_value_is_function_dcl(value))
+    {
+        WARN("Entry point value is not a function definition.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT,
+                "Entry point metadata value does not contain a function definition.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    sm6->entry_point = value->u.function.name;
+    if (!sm6_metadata_value_is_string(entry_node->operands[1])
+            || ascii_strcasecmp(sm6->entry_point, entry_node->operands[1]->u.string_value))
+    {
+        WARN("Entry point function name %s mismatch.\n", sm6->entry_point);
+        vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_ENTRY_POINT_MISMATCH,
+                "Entry point function name %s does not match the name in metadata.", sm6->entry_point);
+    }
+
+    sm6_parser_init_input_signature(sm6, &sm6->p.shader_desc.input_signature);
+    sm6_parser_init_output_signature(sm6, &sm6->p.shader_desc.output_signature);
+
+    return VKD3D_OK;
+}
+
 static void sm6_metadata_value_destroy(struct sm6_metadata_value *m)
 {
     switch (m->type)
@@ -3245,6 +3323,15 @@ static const struct vkd3d_shader_parser_ops sm6_parser_ops =
     .parser_destroy = sm6_parser_destroy,
 };

+static struct sm6_function *sm6_parser_get_function(const struct sm6_parser *sm6, const char *name)
+{
+    size_t i;
+    for (i = 0; i < sm6->function_count; ++i)
+        if (!ascii_strcasecmp(sm6->functions[i].declaration->u.function.name, name))
+            return &sm6->functions[i];
+    return NULL;
+}
+
 static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t *byte_code, size_t byte_code_size,
         const char *source_name, struct vkd3d_shader_message_context *message_context)
 {
@@ -3257,6 +3344,7 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
     enum bitcode_block_abbreviation abbr;
     struct vkd3d_shader_version version;
     struct dxil_block *block;
+    struct sm6_function *fn;
     enum vkd3d_result ret;
     unsigned int i, j;

@@ -3469,8 +3557,8 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
             return ret;
     }

-    sm6_parser_init_output_signature(sm6, output_signature);
-    sm6_parser_init_input_signature(sm6, input_signature);
+    if ((ret = sm6_parser_entry_point_init(sm6)) < 0)
+        return ret;

if ((ret = sm6_parser_module_init(sm6, &sm6->root_block, 0)) < 0)
     {
@@ -3494,14 +3582,20 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t

sm6->p.shader_desc.ssa_count = sm6->ssa_next_id;

-    for (i = 0; i < sm6->function_count; ++i)
+    if (!(fn = sm6_parser_get_function(sm6, sm6->entry_point)))
     {
-        if (!sm6_block_emit_instructions(sm6->functions[i].blocks[0], sm6))
-        {
-            vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
-                    "Out of memory emitting shader instructions.");
-            return VKD3D_ERROR_OUT_OF_MEMORY;
-        }
+        WARN("Failed to find entry point %s.\n", sm6->entry_point);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT,
+                "The definition of the entry point function '%s' was not found.", sm6->entry_point);
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    assert(sm6->function_count == 1);
+    if (!sm6_block_emit_instructions(fn->blocks[0], sm6))
+    {
+        vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
+                "Out of memory emitting shader instructions.");
+        return VKD3D_ERROR_OUT_OF_MEMORY;
     }

dxil_block_destroy(&sm6->root_block);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 060647a68..a0140c674 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -177,6 +177,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND             = 8012,
     VKD3D_SHADER_ERROR_DXIL_UNHANDLED_INTRINSIC         = 8013,
     VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA            = 8014,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT         = 8015,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,
@@ -184,6 +185,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_WARNING_DXIL_INVALID_MODULE_LENGTH     = 8303,
     VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS         = 8304,
     VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH             = 8305,
+    VKD3D_SHADER_WARNING_DXIL_ENTRY_POINT_MISMATCH      = 8306,

VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED             = 9000,
     VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER             = 9001,

[PATCH v4 07/18] vkd3d-shader/dxil: Read the DXIL input and output signatures.

[Conor McCarthy]

From: Conor McCarthy

These can differ from the DXBC signatures by having multiple rows, and
load/store instructions reference them by id instead of register index.
---
 libs/vkd3d-shader/dxbc.c                 |   2 +
 libs/vkd3d-shader/dxil.c                 | 358 ++++++++++++++++++++++-
 libs/vkd3d-shader/vkd3d_shader_private.h |   4 +
 3 files changed, 360 insertions(+), 4 deletions(-)

diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index dbbf8a5c4..a9a7aefe8 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -435,6 +435,8 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
         else
             e[i].min_precision = VKD3D_SHADER_MINIMUM_PRECISION_NONE;

+        e[i].interpolation_mode = VKD3DSIM_NONE;
+
         TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, "
                 "type %u, register idx: %u, use_mask %#x, input_mask %#x, precision %u.\n",
                 e[i].stream_index, debugstr_a(e[i].semantic_name), e[i].semantic_index, e[i].sysval_semantic,
diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index fdcb84013..48fbcaf13 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -154,6 +154,66 @@ enum bitcode_value_symtab_code
     VST_CODE_BBENTRY = 2,
 };

+enum dxil_component_type
+{
+    COMPONENT_TYPE_INVALID     =  0,
+    COMPONENT_TYPE_I1          =  1,
+    COMPONENT_TYPE_I16         =  2,
+    COMPONENT_TYPE_U16         =  3,
+    COMPONENT_TYPE_I32         =  4,
+    COMPONENT_TYPE_U32         =  5,
+    COMPONENT_TYPE_I64         =  6,
+    COMPONENT_TYPE_U64         =  7,
+    COMPONENT_TYPE_F16         =  8,
+    COMPONENT_TYPE_F32         =  9,
+    COMPONENT_TYPE_F64         = 10,
+    COMPONENT_TYPE_SNORMF16    = 11,
+    COMPONENT_TYPE_UNORMF16    = 12,
+    COMPONENT_TYPE_SNORMF32    = 13,
+    COMPONENT_TYPE_UNORMF32    = 14,
+    COMPONENT_TYPE_SNORMF64    = 15,
+    COMPONENT_TYPE_UNORMF64    = 16,
+    COMPONENT_TYPE_PACKEDS8X32 = 17,
+    COMPONENT_TYPE_PACKEDU8X32 = 18,
+};
+
+enum dxil_semantic_kind
+{
+    SEMANTIC_KIND_ARBITRARY            =  0,
+    SEMANTIC_KIND_VERTEXID             =  1,
+    SEMANTIC_KIND_INSTANCEID           =  2,
+    SEMANTIC_KIND_POSITION             =  3,
+    SEMANTIC_KIND_RTARRAYINDEX         =  4,
+    SEMANTIC_KIND_VIEWPORTARRAYINDEX   =  5,
+    SEMANTIC_KIND_CLIPDISTANCE         =  6,
+    SEMANTIC_KIND_CULLDISTANCE         =  7,
+    SEMANTIC_KIND_OUTPUTCONTROLPOINTID =  8,
+    SEMANTIC_KIND_DOMAINLOCATION       =  9,
+    SEMANTIC_KIND_PRIMITIVEID          = 10,
+    SEMANTIC_KIND_GSINSTANCEID         = 11,
+    SEMANTIC_KIND_SAMPLEINDEX          = 12,
+    SEMANTIC_KIND_ISFRONTFACE          = 13,
+    SEMANTIC_KIND_COVERAGE             = 14,
+    SEMANTIC_KIND_INNERCOVERAGE        = 15,
+    SEMANTIC_KIND_TARGET               = 16,
+    SEMANTIC_KIND_DEPTH                = 17,
+    SEMANTIC_KIND_DEPTHLESSEQUAL       = 18,
+    SEMANTIC_KIND_DEPTHGREATEREQUAL    = 19,
+    SEMANTIC_KIND_STENCILREF           = 20,
+    SEMANTIC_KIND_DISPATCHTHREADID     = 21,
+    SEMANTIC_KIND_GROUPID              = 22,
+    SEMANTIC_KIND_GROUPINDEX           = 23,
+    SEMANTIC_KIND_GROUPTHREADID        = 24,
+    SEMANTIC_KIND_TESSFACTOR           = 25,
+    SEMANTIC_KIND_INSIDETESSFACTOR     = 26,
+    SEMANTIC_KIND_VIEWID               = 27,
+    SEMANTIC_KIND_BARYCENTRICS         = 28,
+    SEMANTIC_KIND_SHADINGRATE          = 29,
+    SEMANTIC_KIND_CULLPRIMITIVE        = 30,
+    SEMANTIC_KIND_COUNT                = 31,
+    SEMANTIC_KIND_INVALID              = SEMANTIC_KIND_COUNT,
+};
+
 enum dx_intrinsic_opcode
 {
     DX_LOAD_INPUT                   =   4,
@@ -2357,8 +2417,7 @@ static void sm6_parser_emit_signature(struct sm6_parser *sm6, const struct shade
             param = &ins->declaration.dst;
         }

-        /* TODO: set the interpolation mode when signatures are loaded from DXIL metadata. */
-        ins->flags = (handler_idx == VKD3DSIH_DCL_INPUT_PS) ? VKD3DSIM_LINEAR_NOPERSPECTIVE : 0;
+        ins->flags = e->interpolation_mode;
         *param = params[i];
     }
 }
@@ -2717,6 +2776,25 @@ static bool sm6_metadata_value_is_string(const struct sm6_metadata_value *m)
     return m && m->type == VKD3D_METADATA_STRING;
 }

+static bool sm6_metadata_get_uint_value(const struct sm6_parser *sm6,
+        const struct sm6_metadata_value *m, unsigned int *u)
+{
+    const struct sm6_value *value;
+
+    if (!m || m->type != VKD3D_METADATA_VALUE)
+        return false;
+
+    value = m->u.value;
+    if (!sm6_value_is_constant(value))
+        return false;
+    if (!sm6_type_is_integer(value->type))
+        return false;
+
+    *u = register_get_uint_value(&value->u.reg);
+
+    return true;
+}
+
 static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_function *function)
 {
@@ -3142,6 +3220,67 @@ static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const
     return VKD3D_OK;
 }

+static enum vkd3d_shader_component_type vkd3d_component_type_from_dxil_component_type(enum dxil_component_type type)
+{
+    switch (type)
+    {
+        case COMPONENT_TYPE_I1:
+            return VKD3D_SHADER_COMPONENT_BOOL;
+        case COMPONENT_TYPE_I16:
+        case COMPONENT_TYPE_I32:
+            return VKD3D_SHADER_COMPONENT_INT;
+        case COMPONENT_TYPE_U16:
+        case COMPONENT_TYPE_U32:
+            return VKD3D_SHADER_COMPONENT_UINT;
+        case COMPONENT_TYPE_F16:
+        case COMPONENT_TYPE_F32:
+        case COMPONENT_TYPE_SNORMF32:
+        case COMPONENT_TYPE_UNORMF32:
+            return VKD3D_SHADER_COMPONENT_FLOAT;
+        case COMPONENT_TYPE_F64:
+        case COMPONENT_TYPE_SNORMF64:
+        case COMPONENT_TYPE_UNORMF64:
+            return VKD3D_SHADER_COMPONENT_DOUBLE;
+        default:
+            FIXME("Unhandled component type %u.\n", type);
+            return VKD3D_SHADER_COMPONENT_UINT;
+    }
+}
+
+static enum vkd3d_shader_minimum_precision minimum_precision_from_dxil_component_type(enum dxil_component_type type)
+{
+    switch (type)
+    {
+        case COMPONENT_TYPE_F16:
+            return VKD3D_SHADER_MINIMUM_PRECISION_FLOAT_16;
+        case COMPONENT_TYPE_I16:
+            return VKD3D_SHADER_MINIMUM_PRECISION_INT_16;
+        case COMPONENT_TYPE_U16:
+            return VKD3D_SHADER_MINIMUM_PRECISION_UINT_16;
+        default:
+            return VKD3D_SHADER_MINIMUM_PRECISION_NONE;
+    }
+}
+
+static const enum vkd3d_shader_sysval_semantic sysval_semantic_table[] =
+{
+    [SEMANTIC_KIND_ARBITRARY]            = VKD3D_SHADER_SV_NONE,
+    [SEMANTIC_KIND_POSITION]             = VKD3D_SHADER_SV_POSITION,
+    [SEMANTIC_KIND_TARGET]               = VKD3D_SHADER_SV_NONE,
+};
+
+static enum vkd3d_shader_sysval_semantic sysval_semantic_from_dxil_semantic_kind(enum dxil_semantic_kind kind)
+{
+    if (kind < ARRAY_SIZE(sysval_semantic_table))
+    {
+        return sysval_semantic_table[kind];
+    }
+    else
+    {
+        return VKD3D_SHADER_SV_NONE;
+    }
+}
+
 static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm6_parser *sm6, const char *name)
 {
     const struct sm6_metadata_node *node;
@@ -3167,11 +3306,219 @@ static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm
     return NULL;
 }

+static enum vkd3d_result sm6_parser_read_signature(struct sm6_parser *sm6, const struct sm6_metadata_value *m,
+        struct shader_signature *s)
+{
+    unsigned int i, j, column_count, operand_count, index;
+    const struct sm6_metadata_node *node, *element_node;
+    struct signature_element *elements, *e;
+    unsigned int values[10];
+
+    if (!m)
+        return VKD3D_OK;
+
+    if (!sm6_metadata_value_is_node(m))
+    {
+        WARN("Signature element list is not a node.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                "Signature element list is not a metadata node.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    node = m->u.node;
+    operand_count = node->operand_count;
+
+    if (!(elements = vkd3d_calloc(operand_count, sizeof(*elements))))
+    {
+        ERR("Failed to allocate %u signature elements.\n", operand_count);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
+                "Out of memory allocating %u signature elements.", operand_count);
+        return VKD3D_ERROR_OUT_OF_MEMORY;
+    }
+
+    for (i = 0; i < operand_count; ++i)
+    {
+        m = node->operands[i];
+
+        if (!sm6_metadata_value_is_node(m))
+        {
+            WARN("Signature element is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Signature element is not a metadata node.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        element_node = m->u.node;
+        if (element_node->operand_count < 10)
+        {
+            WARN("Invalid operand count %u.\n", element_node->operand_count);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Invalid signature element operand count %u.", element_node->operand_count);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        if (element_node->operand_count > 11)
+        {
+            WARN("Ignoring %u extra operands.\n", element_node->operand_count - 11);
+            vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                    "Ignoring %u extra operands for a signature element.", element_node->operand_count - 11);
+        }
+
+        for (j = 0; j < 10; ++j)
+        {
+            /* 1 is the semantic name, 4 is semantic index metadata. */
+            if (j == 1 || j == 4)
+                continue;
+            if (!sm6_metadata_get_uint_value(sm6, element_node->operands[j], &values[j]))
+            {
+                WARN("Failed to load uint value at index %u.\n", j);
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                        "Signature element value at index %u is not an integer.", j);
+                return VKD3D_ERROR_INVALID_SHADER;
+            }
+        }
+
+        e = &elements[i];
+
+        if (values[0] != i)
+        {
+            FIXME("Unsupported element id %u not equal to its index %u.\n", values[0], i);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "A non-sequential and non-zero-based element id is not supported.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if (!sm6_metadata_value_is_string(element_node->operands[1]))
+        {
+            WARN("Element name is not a string.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Signature element name is not a metadata string.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        e->semantic_name = element_node->operands[1]->u.string_value;
+
+        /* TODO: load from additional tag/value pairs. */
+        e->stream_index = 0;
+
+        e->component_type = vkd3d_component_type_from_dxil_component_type(values[2]);
+        e->min_precision = minimum_precision_from_dxil_component_type(values[2]);
+
+        j = values[3];
+        e->sysval_semantic = sysval_semantic_from_dxil_semantic_kind(j);
+        if (j != SEMANTIC_KIND_ARBITRARY && j != SEMANTIC_KIND_TARGET && e->sysval_semantic == VKD3D_SHADER_SV_NONE)
+        {
+            WARN("Unhandled semantic kind %u.\n", j);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "DXIL semantic kind %u is unhandled.", j);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if ((e->interpolation_mode = values[5]) >= VKD3DSIM_COUNT)
+        {
+            WARN("Unhandled interpolation mode %u.\n", e->interpolation_mode);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Interpolation mode %u is unhandled.", e->interpolation_mode);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        e->register_count = values[6];
+        column_count = values[7];
+        e->register_index = values[8];
+        e->target_location = e->register_index;
+        if (e->register_index > MAX_REG_OUTPUT || e->register_count > MAX_REG_OUTPUT - e->register_index)
+        {
+            WARN("Invalid row start %u with row count %u.\n", e->register_index, e->register_count);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "A signature element starting row of %u with count %u is invalid.",
+                    e->register_index, e->register_count);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        index = values[9];
+        if (index >= VKD3D_VEC4_SIZE || column_count > VKD3D_VEC4_SIZE - index)
+        {
+            WARN("Invalid column start %u with count %u.\n", index, column_count);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "A signature element starting column %u with count %u is invalid.", index, column_count);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        e->mask = vkd3d_write_mask_from_component_count(column_count) << index;
+        /* TODO: load from additional tag/value pairs. */
+        e->used_mask = e->mask;
+
+        m = element_node->operands[4];
+        if (!sm6_metadata_value_is_node(m))
+        {
+            WARN("Semantic index list is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Signature element semantic index list is not a metadata node.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        element_node = m->u.node;
+        for (j = 0; j < element_node->operand_count; ++j)
+        {
+            if (!sm6_metadata_get_uint_value(sm6, element_node->operands[j], &index))
+            {
+                WARN("Failed to get semantic index for row %u.\n", j);
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                        "Signature element semantic index for row %u is not an integer.", j);
+            }
+            else if (!j)
+            {
+                e->semantic_index = index;
+            }
+            else if (index != e->semantic_index + j)
+            {
+                WARN("Semantic index %u for row %u is not of an incrementing sequence.\n", index, j);
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                        "Signature element semantic index %u for row %u is not of an incrementing sequence.", index, j);
+            }
+        }
+    }
+
+    vkd3d_free(s->elements);
+    s->elements = elements;
+    s->element_count = operand_count;
+
+    return VKD3D_OK;
+}
+
+static enum vkd3d_result sm6_parser_signatures_init(struct sm6_parser *sm6, const struct sm6_metadata_value *m)
+{
+    enum vkd3d_result ret;
+
+    if (!sm6_metadata_value_is_node(m))
+    {
+        WARN("Signature table is not a node.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                "Signature table is not a metadata node.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    if (m->u.node->operand_count && (ret = sm6_parser_read_signature(sm6, m->u.node->operands[0],
+            &sm6->p.shader_desc.input_signature)) < 0)
+    {
+        return ret;
+    }
+    if (m->u.node->operand_count > 1 && (ret = sm6_parser_read_signature(sm6, m->u.node->operands[1],
+            &sm6->p.shader_desc.output_signature)) < 0)
+    {
+        return ret;
+    }
+    /* TODO: patch constant signature in operand 2. */
+
+    sm6_parser_init_input_signature(sm6, &sm6->p.shader_desc.input_signature);
+    sm6_parser_init_output_signature(sm6, &sm6->p.shader_desc.output_signature);
+
+    return VKD3D_OK;
+}
+
 static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
 {
     const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints");
     const struct sm6_metadata_node *entry_node = m ? m->u.node : NULL;
     const struct sm6_value *value;
+    enum vkd3d_result ret;

if (!entry_node || entry_node->operand_count < 2 || !(m = entry_node->operands[0]))
     {
@@ -3207,8 +3554,11 @@ static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
                 "Entry point function name %s does not match the name in metadata.", sm6->entry_point);
     }

-    sm6_parser_init_input_signature(sm6, &sm6->p.shader_desc.input_signature);
-    sm6_parser_init_output_signature(sm6, &sm6->p.shader_desc.output_signature);
+    if (entry_node->operand_count >= 3 && (m = entry_node->operands[2])
+            && (ret = sm6_parser_signatures_init(sm6, m)) < 0)
+    {
+        return ret;
+    }

return VKD3D_OK;
 }
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index a0140c674..b5171ba66 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -178,6 +178,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_UNHANDLED_INTRINSIC         = 8013,
     VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA            = 8014,
     VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT         = 8015,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE           = 8016,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,
@@ -627,6 +628,8 @@ enum vkd3d_shader_interpolation_mode
     VKD3DSIM_LINEAR_NOPERSPECTIVE_CENTROID = 5,
     VKD3DSIM_LINEAR_SAMPLE = 6,
     VKD3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE = 7,
+
+    VKD3DSIM_COUNT = 8,
 };

enum vkd3d_shader_global_flags
@@ -867,6 +870,7 @@ struct signature_element
     unsigned int mask;
     unsigned int used_mask;
     enum vkd3d_shader_minimum_precision min_precision;
+    enum vkd3d_shader_interpolation_mode interpolation_mode;
     /* Register index / location in the target shader.
      * If SIGNATURE_TARGET_LOCATION_UNUSED, this element should not be written. */
     unsigned int target_location;

[PATCH v4 08/18] vkd3d-shader/dxil: Handle signature element additional tag/value pairs.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 84 ++++++++++++++++++++++--
 libs/vkd3d-shader/vkd3d_shader_private.h |  1 +
 2 files changed, 81 insertions(+), 4 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 48fbcaf13..7e3a1257b 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -214,6 +214,14 @@ enum dxil_semantic_kind
     SEMANTIC_KIND_INVALID              = SEMANTIC_KIND_COUNT,
 };

+enum dxil_element_additional_tag
+{
+    ADDITIONAL_TAG_STREAM_INDEX  = 0,
+    ADDITIONAL_TAG_GLOBAL_SYMBOL = 1, /* not used */
+    ADDITIONAL_TAG_RELADDR_MASK  = 2,
+    ADDITIONAL_TAG_USED_MASK     = 3,
+};
+
 enum dx_intrinsic_opcode
 {
     DX_LOAD_INPUT                   =   4,
@@ -3306,6 +3314,76 @@ static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm
     return NULL;
 }

+static void signature_element_read_additional_element_values(struct signature_element *e,
+        const struct sm6_metadata_node *node, struct sm6_parser *sm6)
+{
+    unsigned int i, operand_count, value;
+    enum dxil_element_additional_tag tag;
+
+    if (node->operand_count < 11 || !node->operands[10])
+        return;
+
+    if (!sm6_metadata_value_is_node(node->operands[10]))
+    {
+        WARN("Additional values list is not a node.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                "Signature element additional values list is not a metadata node.");
+        return;
+    }
+
+    node = node->operands[10]->u.node;
+    if (node->operand_count & 1)
+    {
+        WARN("Operand count is not even.\n");
+        vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                "Operand count for signature element additional tag/value pairs is not even.");
+    }
+    operand_count = node->operand_count & ~1u;
+
+    for (i = 0; i < operand_count; i += 2)
+    {
+        if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &tag)
+                || !sm6_metadata_get_uint_value(sm6, node->operands[i + 1], &value))
+        {
+            WARN("Failed to extract tag/value pair.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE,
+                    "Signature element tag/value pair at index %u is not an integer pair.", i);
+            continue;
+        }
+
+        switch (tag)
+        {
+            case ADDITIONAL_TAG_STREAM_INDEX:
+                e->stream_index = value;
+                break;
+            case ADDITIONAL_TAG_RELADDR_MASK:
+                /* A mask of components accessed via relative addressing. Seems to replace TPF 'dcl_index_range'. */
+                if (value > VKD3DSP_WRITEMASK_ALL)
+                {
+                    WARN("Invalid relative addressed mask %#x.\n", value);
+                    vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_INVALID_MASK,
+                            "Mask %#x of relative-addressed components is invalid.", value);
+                }
+                break;
+            case ADDITIONAL_TAG_USED_MASK:
+                if (value > VKD3DSP_WRITEMASK_ALL)
+                {
+                    WARN("Invalid used mask %#x.\n", value);
+                    vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_INVALID_MASK,
+                            "Mask %#x of used components is invalid.", value);
+                    value &= VKD3DSP_WRITEMASK_ALL;
+                }
+                e->used_mask = value;
+                break;
+            default:
+                FIXME("Unhandled tag %u, value %u.\n", tag, value);
+                vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                        "Tag %#x for signature element additional value %#x is unhandled.", tag, value);
+                break;
+        }
+    }
+}
+
 static enum vkd3d_result sm6_parser_read_signature(struct sm6_parser *sm6, const struct sm6_metadata_value *m,
         struct shader_signature *s)
 {
@@ -3396,9 +3474,6 @@ static enum vkd3d_result sm6_parser_read_signature(struct sm6_parser *sm6, const
         }
         e->semantic_name = element_node->operands[1]->u.string_value;

-        /* TODO: load from additional tag/value pairs. */
-        e->stream_index = 0;
-
         e->component_type = vkd3d_component_type_from_dxil_component_type(values[2]);
         e->min_precision = minimum_precision_from_dxil_component_type(values[2]);

@@ -3442,9 +3517,10 @@ static enum vkd3d_result sm6_parser_read_signature(struct sm6_parser *sm6, const
         }

e->mask = vkd3d_write_mask_from_component_count(column_count) << index;
-        /* TODO: load from additional tag/value pairs. */
         e->used_mask = e->mask;

+        signature_element_read_additional_element_values(e, element_node, sm6);
+
         m = element_node->operands[4];
         if (!sm6_metadata_value_is_node(m))
         {
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index b5171ba66..2c84cb104 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -187,6 +187,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS         = 8304,
     VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH             = 8305,
     VKD3D_SHADER_WARNING_DXIL_ENTRY_POINT_MISMATCH      = 8306,
+    VKD3D_SHADER_WARNING_DXIL_INVALID_MASK              = 8307,

VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED             = 9000,
     VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER             = 9001,

[PATCH v4 09/18] vkd3d-shader/dxil: Handle multi-row signature elements.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                     | 15 ++++++++++++---
 tests/hlsl/entry-point-semantics.shader_test | 17 +++++++++++++----
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 7e3a1257b..47b261949 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -2384,7 +2384,7 @@ static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shade
 {
     struct vkd3d_shader_dst_param *param;
     const struct signature_element *e;
-    unsigned int i;
+    unsigned int i, count;

for (i = 0; i < s->element_count; ++i)
     {
@@ -2392,8 +2392,11 @@ static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shade

param = &params[i];
         dst_param_io_init(param, e, reg_type);
-        param->reg.idx[0].offset = i;
-        param->reg.idx_count = 1;
+        count = 0;
+        if (e->register_count > 1)
+            param->reg.idx[count++].offset = 0;
+        param->reg.idx[count++].offset = i;
+        param->reg.idx_count = count;
     }
 }

@@ -2427,6 +2430,12 @@ static void sm6_parser_emit_signature(struct sm6_parser *sm6, const struct shade

ins->flags = e->interpolation_mode;
         *param = params[i];
+
+        if (e->register_count > 1)
+        {
+            param->reg.idx[0].rel_addr = NULL;
+            param->reg.idx[0].offset = e->register_count;
+        }
     }
 }

diff --git a/tests/hlsl/entry-point-semantics.shader_test b/tests/hlsl/entry-point-semantics.shader_test
index 6d355ab5c..d177b0376 100644
--- a/tests/hlsl/entry-point-semantics.shader_test
+++ b/tests/hlsl/entry-point-semantics.shader_test
@@ -84,7 +84,7 @@ float4 main(in apple a) : sv_target

[test]
 draw quad
-todo(sm>=6) probe (0, 0) rgba (10.0, 20.0, 30.0, 40.0)
+probe (0, 0) rgba (10.0, 20.0, 30.0, 40.0)

% Arrays of matrices get successive indexes.
@@ -101,7 +101,12 @@ float4 main(in apple a) : sv_target

[test]
 draw quad
-todo(sm>=6) probe (0, 0) rgba (10.0, 11.0, 30.0, 31.0)
+probe (0, 0) rgba (10.0, 11.0, 30.0, 31.0)
+
+
+% dxcompiler emits correct array addressing.
+[require]
+shader model < 6.0

% Arrays (even multi-dimensional) of struct elements are allowed. The fields in the different struct
@@ -145,6 +150,10 @@ draw quad
 todo(sm>=6) probe (0, 0) rgba (10.0, 11.0, 20.0, 21.0)

+[require]
+% reset requirements
+
+
 [pixel shader fail]
 struct apple
 {
@@ -201,7 +210,7 @@ float4 main(in float4 tex0 : TEXCOORD0, in float4 tex1 : TEXCOORD1) : sv_target

[test]
 draw quad
-todo(sm>=6) probe (0, 0) rgba (1.0, 2.0, 10.0, 20.0)
+probe (0, 0) rgba (1.0, 2.0, 10.0, 20.0)

% Output semantics cannot be mapped to more than one value.
@@ -272,7 +281,7 @@ float4 main(in float4 a : TEXCOORD0, in float3 b : TEXCOORD1) : sv_target

[test]
 draw quad
-todo(sm>=6) probe (0, 0) rgba (10.0, 11.0, 20.0, 21.0)
+probe (0, 0) rgba (10.0, 11.0, 20.0, 21.0)

% In SM4, duplicated input semantics can only have different types if they have the same layout and

[PATCH v4 10/18] vkd3d-shader: Define more global flags.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/d3d_asm.c              |  9 ++++----
 libs/vkd3d-shader/spirv.c                |  6 +++---
 libs/vkd3d-shader/tpf.c                  |  2 +-
 libs/vkd3d-shader/vkd3d_shader_private.h | 27 ++++++++++++++++++++++++
 4 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d-shader/d3d_asm.c
index 566680be7..5a75cf25e 100644
--- a/libs/vkd3d-shader/d3d_asm.c
+++ b/libs/vkd3d-shader/d3d_asm.c
@@ -391,13 +391,14 @@ static unsigned int shader_get_float_offset(enum vkd3d_shader_register_type regi
     }
 }

-static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, uint32_t global_flags)
+static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler,
+        enum vkd3d_shader_global_flags global_flags)
 {
     unsigned int i;

static const struct
     {
-        unsigned int flag;
+        enum vkd3d_shader_global_flags flag;
         const char *name;
     }
     global_flag_info[] =
@@ -423,7 +424,7 @@ static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, ui
     }

if (global_flags)
-        vkd3d_string_buffer_printf(&compiler->buffer, "unknown_flags(%#x)", global_flags);
+        vkd3d_string_buffer_printf(&compiler->buffer, "unknown_flags(%#"PRIx64")", global_flags);
 }

static void shader_dump_sync_flags(struct vkd3d_d3d_asm_compiler *compiler, uint32_t sync_flags)
@@ -1637,7 +1638,7 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler,

case VKD3DSIH_DCL_GLOBAL_FLAGS:
             vkd3d_string_buffer_printf(buffer, " ");
-            shader_dump_global_flags(compiler, ins->flags);
+            shader_dump_global_flags(compiler, ins->declaration.global_flags);
             break;

case VKD3DSIH_DCL_HS_MAX_TESSFACTOR:
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index 55bc4ad42..c6731040b 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -5377,7 +5377,7 @@ static size_t spirv_compiler_get_current_function_location(struct spirv_compiler
 static void spirv_compiler_emit_dcl_global_flags(struct spirv_compiler *compiler,
         const struct vkd3d_shader_instruction *instruction)
 {
-    unsigned int flags = instruction->flags;
+    enum vkd3d_shader_global_flags flags = instruction->declaration.global_flags;

if (flags & VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL)
     {
@@ -5392,9 +5392,9 @@ static void spirv_compiler_emit_dcl_global_flags(struct spirv_compiler *compiler
     }

if (flags & ~(VKD3DSGF_REFACTORING_ALLOWED | VKD3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS))
-        FIXME("Unhandled global flags %#x.\n", flags);
+        FIXME("Unhandled global flags %#"PRIx64".\n", flags);
     else
-        WARN("Unhandled global flags %#x.\n", flags);
+        WARN("Unhandled global flags %#"PRIx64".\n", flags);
 }

static void spirv_compiler_emit_temps(struct spirv_compiler *compiler, uint32_t count)
diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c
index 596a0c499..b93c1233b 100644
--- a/libs/vkd3d-shader/tpf.c
+++ b/libs/vkd3d-shader/tpf.c
@@ -1092,7 +1092,7 @@ static void shader_sm4_read_dcl_indexable_temp(struct vkd3d_shader_instruction *
 static void shader_sm4_read_dcl_global_flags(struct vkd3d_shader_instruction *ins, uint32_t opcode,
         uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv)
 {
-    ins->flags = (opcode_token & VKD3D_SM4_GLOBAL_FLAGS_MASK) >> VKD3D_SM4_GLOBAL_FLAGS_SHIFT;
+    ins->declaration.global_flags = (opcode_token & VKD3D_SM4_GLOBAL_FLAGS_MASK) >> VKD3D_SM4_GLOBAL_FLAGS_SHIFT;
 }

static void shader_sm5_read_fcall(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token,
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 2c84cb104..ab148b3be 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -642,6 +642,32 @@ enum vkd3d_shader_global_flags
     VKD3DSGF_SKIP_OPTIMIZATION                 = 0x10,
     VKD3DSGF_ENABLE_MINIMUM_PRECISION          = 0x20,
     VKD3DSGF_ENABLE_11_1_DOUBLE_EXTENSIONS     = 0x40,
+    VKD3DSGF_ENABLE_SHADER_EXTENSIONS          = 0x80, /* never emitted? */
+    VKD3DSGF_BIND_FOR_DURATION                 =     0x100,
+    VKD3DSGF_ENABLE_VP_AND_RT_ARRAY_INDEX      =     0x200,
+    VKD3DSGF_ENABLE_INNER_COVERAGE             =     0x400,
+    VKD3DSGF_ENABLE_STENCIL_REF                =     0x800,
+    VKD3DSGF_ENABLE_TILED_RESOURCE_INTRINSICS  =    0x1000,
+    VKD3DSGF_ENABLE_RELAXED_TYPED_UAV_FORMATS  =    0x2000,
+    VKD3DSGF_ENABLE_LVL_9_COMPARISON_FILTERING =    0x4000,
+    VKD3DSGF_ENABLE_UP_TO_64_UAVS              =    0x8000,
+    VKD3DSGF_ENABLE_UAVS_AT_EVERY_STAGE        =   0x10000,
+    VKD3DSGF_ENABLE_CS4_RAW_STRUCTURED_BUFFERS =   0x20000,
+    VKD3DSGF_ENABLE_RASTERIZER_ORDERED_VIEWS   =   0x40000,
+    VKD3DSGF_ENABLE_WAVE_INTRINSICS            =   0x80000,
+    VKD3DSGF_ENABLE_INT64                      =  0x100000,
+    VKD3DSGF_ENABLE_VIEWID                     =  0x200000,
+    VKD3DSGF_ENABLE_BARYCENTRICS               =  0x400000,
+    VKD3DSGF_FORCE_NATIVE_LOW_PRECISION        =  0x800000,
+    VKD3DSGF_ENABLE_SHADINGRATE                = 0x1000000,
+    VKD3DSGF_ENABLE_RAYTRACING_TIER_1_1        = 0x2000000,
+    VKD3DSGF_ENABLE_SAMPLER_FEEDBACK           = 0x4000000,
+    VKD3DSGF_ENABLE_ATOMIC_INT64_ON_TYPED_RESOURCE                =   0x8000000,
+    VKD3DSGF_ENABLE_ATOMIC_INT64_ON_GROUP_SHARED                  =  0x10000000,
+    VKD3DSGF_ENABLE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS =  0x20000000,
+    VKD3DSGF_ENABLE_RESOURCE_DESCRIPTOR_HEAP_INDEXING             =  0x40000000,
+    VKD3DSGF_ENABLE_SAMPLER_DESCRIPTOR_HEAP_INDEXING              =  0x80000000,
+    VKD3DSGF_ENABLE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE      = 0x100000000ull,
 };

enum vkd3d_shader_sync_flags
@@ -1016,6 +1042,7 @@ struct vkd3d_shader_instruction
     const struct vkd3d_shader_src_param *predicate;
     union
     {
+        enum vkd3d_shader_global_flags global_flags;
         struct vkd3d_shader_semantic semantic;
         struct vkd3d_shader_register_semantic register_semantic;
         struct vkd3d_shader_primitive_type primitive_type;

[PATCH v4 11/18] vkd3d-shader/dxil: Read DXIL global flags.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 118 ++++++++++++++++++++++-
 libs/vkd3d-shader/vkd3d_shader_private.h |   5 +-
 2 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 47b261949..e24f01324 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -222,6 +222,23 @@ enum dxil_element_additional_tag
     ADDITIONAL_TAG_USED_MASK     = 3,
 };

+enum dxil_shader_properties_tag
+{
+    SHADER_PROPERTIES_FLAGS              =  0,
+    SHADER_PROPERTIES_GEOMETRY           =  1,
+    SHADER_PROPERTIES_DOMAIN             =  2,
+    SHADER_PROPERTIES_HULL               =  3,
+    SHADER_PROPERTIES_COMPUTE            =  4,
+    SHADER_PROPERTIES_AUTO_BINDING_SPACE =  5,
+    SHADER_PROPERTIES_RAY_PAYLOAD_SIZE   =  6,
+    SHADER_PROPERTIES_RAY_ATTRIB_SIZE    =  7,
+    SHADER_PROPERTIES_SHADER_KIND        =  8,
+    SHADER_PROPERTIES_MESH               =  9,
+    SHADER_PROPERTIES_AMPLIFICATION      = 10,
+    SHADER_PROPERTIES_WAVE_SIZE          = 11,
+    SHADER_PROPERTIES_ENTRY_ROOT_SIG     = 12,
+};
+
 enum dx_intrinsic_opcode
 {
     DX_LOAD_INPUT                   =   4,
@@ -1657,6 +1674,17 @@ static unsigned int register_get_uint_value(const struct vkd3d_shader_register *
     return reg->u.immconst_uint[0];
 }

+static uint64_t register_get_uint64_value(const struct vkd3d_shader_register *reg)
+{
+    if (!register_is_constant(reg) || !data_type_is_integer(reg->data_type))
+        return UINT64_MAX;
+
+    if (reg->dimension == VSIR_DIMENSION_VEC4)
+        WARN("Returning vec4.x.\n");
+
+    return (reg->type == VKD3DSPR_IMMCONST64) ? reg->u.immconst_uint64[0] : reg->u.immconst_uint[0];
+}
+
 static inline bool sm6_value_is_function_dcl(const struct sm6_value *value)
 {
     return value->value_type == VALUE_TYPE_FUNCTION;
@@ -1755,6 +1783,8 @@ static enum vkd3d_data_type vkd3d_data_type_from_sm6_type(const struct sm6_type
                 return VKD3D_DATA_UINT8;
             case 32:
                 return VKD3D_DATA_UINT;
+            case 64:
+                return VKD3D_DATA_UINT64;
             default:
                 FIXME("Unhandled width %u.\n", type->u.width);
                 return VKD3D_DATA_UINT;
@@ -2812,6 +2842,25 @@ static bool sm6_metadata_get_uint_value(const struct sm6_parser *sm6,
     return true;
 }

+static bool sm6_metadata_get_uint64_value(const struct sm6_parser *sm6,
+        const struct sm6_metadata_value *m, uint64_t *u)
+{
+    const struct sm6_value *value;
+
+    if (!m || m->type != VKD3D_METADATA_VALUE)
+        return false;
+
+    value = m->u.value;
+    if (!sm6_value_is_constant(value))
+        return false;
+    if (!sm6_type_is_integer(value->type))
+        return false;
+
+    *u = register_get_uint64_value(&value->u.reg);
+
+    return true;
+}
+
 static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block,
         struct sm6_function *function)
 {
@@ -3598,10 +3647,34 @@ static enum vkd3d_result sm6_parser_signatures_init(struct sm6_parser *sm6, cons
     return VKD3D_OK;
 }

+static void sm6_parser_emit_global_flags(struct sm6_parser *sm6, const struct sm6_metadata_value *m)
+{
+    enum vkd3d_shader_global_flags global_flags, mask, rotated_flags;
+    struct vkd3d_shader_instruction *ins;
+
+    if (!sm6_metadata_get_uint64_value(sm6, m, &global_flags))
+    {
+        WARN("Failed to load global flags.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                "Global flags metadata value is not an integer.");
+        return;
+    }
+    /* Rotate SKIP_OPTIMIZATION from bit 0 to bit 4 to match vkd3d_shader_global_flags.. */
+    mask = (VKD3DSGF_SKIP_OPTIMIZATION << 1) - 1;
+    rotated_flags = global_flags & mask;
+    rotated_flags = (rotated_flags >> 1) | ((rotated_flags & 1) << 4);
+    global_flags = (global_flags & ~mask) | rotated_flags;
+
+    ins = sm6_parser_add_instruction(sm6, VKD3DSIH_DCL_GLOBAL_FLAGS);
+    ins->declaration.global_flags = global_flags;
+}
+
 static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
 {
     const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints");
-    const struct sm6_metadata_node *entry_node = m ? m->u.node : NULL;
+    const struct sm6_metadata_node *node, *entry_node = m ? m->u.node : NULL;
+    enum dxil_shader_properties_tag tag;
+    unsigned int i, operand_count;
     const struct sm6_value *value;
     enum vkd3d_result ret;

@@ -3645,6 +3718,49 @@ static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
         return ret;
     }

+    if (entry_node->operand_count >= 5 && (m = entry_node->operands[4]))
+    {
+        if (!sm6_metadata_value_is_node(m))
+        {
+            WARN("Shader properties list is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                    "Shader properties tag/value list is not a metadata node.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        node = m->u.node;
+        if (node->operand_count & 1)
+        {
+            WARN("Operand count is not even.\n");
+            vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                    "Operand count for shader properties tag/value pairs is not even.");
+        }
+        operand_count = node->operand_count & ~1u;
+
+        for (i = 0; i < operand_count; i += 2)
+        {
+            if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &tag))
+            {
+                WARN("Tag is not an integer value.\n");
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                        "Shader properties tag at index %u is not an integer.", i);
+                return VKD3D_ERROR_INVALID_SHADER;
+            }
+
+            switch (tag)
+            {
+                case SHADER_PROPERTIES_FLAGS:
+                    sm6_parser_emit_global_flags(sm6, node->operands[i + 1]);
+                    break;
+                default:
+                    FIXME("Unhandled tag %#x.\n", tag);
+                    vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                            "Shader properties tag %#x is unhandled.", tag);
+                    break;
+            }
+        }
+    }
+
     return VKD3D_OK;
 }

diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index ab148b3be..85041f2a5 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -179,6 +179,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA            = 8014,
     VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT         = 8015,
     VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE           = 8016,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES          = 8017,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,
@@ -571,11 +572,13 @@ enum vkd3d_data_type
     VKD3D_DATA_CONTINUED,
     VKD3D_DATA_UNUSED,
     VKD3D_DATA_UINT8,
+    VKD3D_DATA_UINT64,
 };

static inline bool data_type_is_integer(enum vkd3d_data_type data_type)
 {
-    return data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT8 || data_type == VKD3D_DATA_UINT;
+    return data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT8 || data_type == VKD3D_DATA_UINT
+            || data_type == VKD3D_DATA_UINT64;
 }

enum vsir_dimension

[PATCH v4 12/18] vkd3d-shader/dxil: Read DXIL compute shader thread group dimensions.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c | 65 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index e24f01324..57e2885de 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -26,6 +26,8 @@
 #define BITCODE_MAGIC VKD3D_MAKE_TAG('B', 'C', 0xc0, 0xde)
 #define DXIL_OP_MAX_OPERANDS 17

+static const unsigned int dx_max_thread_group_size[3] = {1024, 1024, 64};
+
 enum bitcode_block_id
 {
     BLOCKINFO_BLOCK           =  0,
@@ -3669,6 +3671,65 @@ static void sm6_parser_emit_global_flags(struct sm6_parser *sm6, const struct sm
     ins->declaration.global_flags = global_flags;
 }

+static enum vkd3d_result sm6_parser_emit_thread_group(struct sm6_parser *sm6, const struct sm6_metadata_value *m)
+{
+    const struct sm6_metadata_node *node;
+    struct vkd3d_shader_instruction *ins;
+    unsigned int group_sizes[3];
+    unsigned int i;
+
+    if (sm6->p.shader_version.type != VKD3D_SHADER_TYPE_COMPUTE)
+    {
+        WARN("Shader of type %#x has thread group dimensions.\n", sm6->p.shader_version.type);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                "Shader has thread group dimensions but is not a compute shader.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    if (!m || !sm6_metadata_value_is_node(m))
+    {
+        WARN("Thread group dimension value is not a node.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                "Thread group dimension metadata value is not a node.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    node = m->u.node;
+    if (node->operand_count != 3)
+    {
+        WARN("Invalid operand count %u.\n", node->operand_count);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT,
+                "Thread group dimension operand count %u is invalid.", node->operand_count);
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    for (i = 0; i < 3; ++i)
+    {
+        if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &group_sizes[i]))
+        {
+            WARN("Thread group dimension is not an integer value.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                    "Thread group dimension metadata value is not an integer.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        if (!group_sizes[i] || group_sizes[i] > dx_max_thread_group_size[i])
+        {
+            char dim = "XYZ"[i];
+            WARN("Invalid thread group %c dimension %u.\n", dim, group_sizes[i]);
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,
+                    "Thread group %c dimension %u is invalid.", dim, group_sizes[i]);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+    }
+
+    ins = sm6_parser_add_instruction(sm6, VKD3DSIH_DCL_THREAD_GROUP);
+    ins->declaration.thread_group_size.x = group_sizes[0];
+    ins->declaration.thread_group_size.y = group_sizes[1];
+    ins->declaration.thread_group_size.z = group_sizes[2];
+
+    return VKD3D_OK;
+}
+
 static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
 {
     const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints");
@@ -3752,6 +3813,10 @@ static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6)
                 case SHADER_PROPERTIES_FLAGS:
                     sm6_parser_emit_global_flags(sm6, node->operands[i + 1]);
                     break;
+               case SHADER_PROPERTIES_COMPUTE:
+                    if ((ret = sm6_parser_emit_thread_group(sm6, node->operands[i + 1])) < 0)
+                        return ret;
+                    break;
                 default:
                     FIXME("Unhandled tag %#x.\n", tag);
                     vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES,

[PATCH v4 13/18] vkd3d-shader/spirv: Support scalar swizzle of vector SSA registers.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/spirv.c | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index c6731040b..e1d2f45c0 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -3522,6 +3522,11 @@ static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask,
     return vkd3d_compact_swizzle(VKD3D_SHADER_NO_SWIZZLE, dst_write_mask) == vkd3d_compact_swizzle(swizzle, write_mask);
 }

+static bool vkd3d_swizzle_is_scalar(unsigned int swizzle)
+{
+    return swizzle == (swizzle | (swizzle << VKD3D_SHADER_SWIZZLE_SHIFT(1)));
+}
+
 static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler,
         uint32_t val_id, unsigned int val_write_mask, enum vkd3d_shader_component_type component_type,
         unsigned int swizzle, unsigned int write_mask)
@@ -3724,6 +3729,26 @@ static void spirv_compiler_set_ssa_register_id(const struct spirv_compiler *comp
     compiler->ssa_register_ids[i] = val_id;
 }

+static uint32_t spirv_compiler_emit_load_ssa_reg(struct spirv_compiler *compiler,
+        const struct vkd3d_shader_register *reg, enum vkd3d_shader_component_type component_type,
+        unsigned int swizzle)
+{
+    struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
+    unsigned int component_idx;
+    uint32_t type_id, val_id;
+
+    val_id = spirv_compiler_get_ssa_register_id(compiler, reg);
+    assert(val_id);
+
+    if (reg->dimension == VSIR_DIMENSION_SCALAR)
+        return val_id;
+
+    type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+    assert(vkd3d_swizzle_is_scalar(swizzle));
+    component_idx = vkd3d_swizzle_get_component(swizzle, 0);
+    return vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx);
+}
+
 static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler,
         const struct vkd3d_shader_register *reg, DWORD swizzle, DWORD write_mask)
 {
@@ -3745,7 +3770,7 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler,
     component_type = vkd3d_component_type_from_data_type(reg->data_type);

if (reg->type == VKD3DSPR_SSA)
-        return spirv_compiler_get_ssa_register_id(compiler, reg);
+        return spirv_compiler_emit_load_ssa_reg(compiler, reg, component_type, swizzle);

if (!spirv_compiler_get_register_info(compiler, reg, &reg_info))
     {

[PATCH v4 14/18] vkd3d-shader/spirv: Align constant buffer sizes to 16 bytes.

[Conor McCarthy]

From: Conor McCarthy

DXIL constant buffer sizes can be 32-bit scalar aligned.
---
 libs/vkd3d-shader/spirv.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index e1d2f45c0..5542bc6c0 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -5663,7 +5663,8 @@ static void spirv_compiler_emit_cbv_declaration(struct spirv_compiler *compiler,
     reg.idx[1].offset = range->first;
     reg.idx[2].offset = range->last;

-    size = size_in_bytes / (VKD3D_VEC4_SIZE * sizeof(uint32_t));
+    size = align(size_in_bytes, VKD3D_VEC4_SIZE * sizeof(uint32_t));
+    size /= (VKD3D_VEC4_SIZE * sizeof(uint32_t));

if ((push_cb = spirv_compiler_find_push_constant_buffer(compiler, range)))
     {

[PATCH v4 15/18] vkd3d-shader/dxil: Read CBV descriptors.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxbc.c                 |   1 +
 libs/vkd3d-shader/dxil.c                 | 220 +++++++++++++++++++++++
 libs/vkd3d-shader/vkd3d_shader_main.c    |  18 ++
 libs/vkd3d-shader/vkd3d_shader_private.h |   4 +
 4 files changed, 243 insertions(+)

diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index a9a7aefe8..6f47560fc 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -550,6 +550,7 @@ void free_shader_desc(struct vkd3d_shader_desc *desc)
     shader_signature_cleanup(&desc->input_signature);
     shader_signature_cleanup(&desc->output_signature);
     shader_signature_cleanup(&desc->patch_constant_signature);
+    vkd3d_free(desc->descriptors);
 }

int shader_extract_from_dxbc(const struct vkd3d_shader_code *dxbc,
diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 57e2885de..4a1e1e108 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -25,6 +25,7 @@

#define BITCODE_MAGIC VKD3D_MAKE_TAG('B', 'C', 0xc0, 0xde)
 #define DXIL_OP_MAX_OPERANDS 17
+static const unsigned int SHADER_DESCRIPTOR_TYPE_COUNT = 4;

static const unsigned int dx_max_thread_group_size[3] = {1024, 1024, 64};

@@ -156,6 +157,29 @@ enum bitcode_value_symtab_code
     VST_CODE_BBENTRY = 2,
 };

+enum dxil_resource_kind
+{
+    RESOURCE_KIND_INVALID                 =  0,
+    RESOURCE_KIND_TEXTURE1D               =  1,
+    RESOURCE_KIND_TEXTURE2D               =  2,
+    RESOURCE_KIND_TEXTURE2DMS             =  3,
+    RESOURCE_KIND_TEXTURE3D               =  4,
+    RESOURCE_KIND_TEXTURECUBE             =  5,
+    RESOURCE_KIND_TEXTURE1DARRAY          =  6,
+    RESOURCE_KIND_TEXTURE2DARRAY          =  7,
+    RESOURCE_KIND_TEXTURE2DMSARRAY        =  8,
+    RESOURCE_KIND_TEXTURECUBEARRAY        =  9,
+    RESOURCE_KIND_TYPEDBUFFER             = 10,
+    RESOURCE_KIND_RAWBUFFER               = 11,
+    RESOURCE_KIND_STRUCTUREDBUFFER        = 12,
+    RESOURCE_KIND_CBUFFER                 = 13,
+    RESOURCE_KIND_SAMPLER                 = 14,
+    RESOURCE_KIND_TBUFFER                 = 15,
+    RESOURCE_KIND_RTACCELERATIONSTRUCTURE = 16,
+    RESOURCE_KIND_FEEDBACKTEXTURE2D       = 17,
+    RESOURCE_KIND_FEEDBACKTEXTURE2DARRAY  = 18,
+};
+
 enum dxil_component_type
 {
     COMPONENT_TYPE_INVALID     =  0,
@@ -2820,6 +2844,11 @@ static bool sm6_metadata_value_is_node(const struct sm6_metadata_value *m)
     return m && m->type == VKD3D_METADATA_NODE;
 }

+static bool sm6_metadata_value_is_value(const struct sm6_metadata_value *m)
+{
+    return m && m->type == VKD3D_METADATA_VALUE;
+}
+
 static bool sm6_metadata_value_is_string(const struct sm6_metadata_value *m)
 {
     return m && m->type == VKD3D_METADATA_STRING;
@@ -3374,6 +3403,194 @@ static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm
     return NULL;
 }

+static bool sm6_parser_resources_load_register_range(struct sm6_parser *sm6,
+        const struct sm6_metadata_node *node, struct vkd3d_shader_register_range *range)
+{
+    unsigned int size;
+
+    if (!sm6_metadata_value_is_value(node->operands[1]))
+    {
+        WARN("Resource data type is not a value.\n");
+        return false;
+    }
+    if (!sm6_type_is_pointer(node->operands[1]->value_type))
+    {
+        WARN("Resource type is not a pointer.\n");
+        vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH,
+                "Resource metadata value type is not a pointer.");
+    }
+
+    if (!sm6_metadata_get_uint_value(sm6, node->operands[3], &range->space))
+    {
+        WARN("Failed to load register space.\n");
+        return false;
+    }
+    if (!sm6_metadata_get_uint_value(sm6, node->operands[4], &range->first))
+    {
+        WARN("Failed to load register first.\n");
+        return false;
+    }
+    if (!sm6_metadata_get_uint_value(sm6, node->operands[5], &size))
+    {
+        WARN("Failed to load register range size.\n");
+        return false;
+    }
+    if (!size || (size != UINT_MAX && !vkd3d_bound_range(range->first, size, UINT_MAX)))
+    {
+        WARN("Invalid register range, first %u, size %u.\n", range->first, size);
+        return false;
+    }
+    range->last = (size == UINT_MAX) ? UINT_MAX : range->first + size - 1;
+
+    return true;
+}
+
+static enum vkd3d_result sm6_parser_resources_load_cbv(struct sm6_parser *sm6,
+        const struct sm6_metadata_node *node, struct vkd3d_shader_descriptor_info1 *d)
+{
+    if (node->operand_count < 7)
+    {
+        WARN("Invalid operand count %u.\n", node->operand_count);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT,
+                "Invalid operand count %u for a CBV descriptor.", node->operand_count);
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+    if (node->operand_count > 7 && node->operands[7])
+    {
+        WARN("Ignoring %u extra operands.\n", node->operand_count - 7);
+        vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS,
+                "Ignoring %u extra operands for a CBV descriptor.", node->operand_count - 7);
+    }
+
+    d->resource_type = VKD3D_SHADER_RESOURCE_BUFFER;
+    d->resource_data_type = VKD3D_SHADER_RESOURCE_DATA_UINT;
+
+    if (!sm6_metadata_get_uint_value(sm6, node->operands[6], &d->buffer_size))
+    {
+        WARN("Failed to load buffer size.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                "Constant buffer size metadata value is not an integer.");
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    return VKD3D_OK;
+}
+
+static enum vkd3d_result sm6_parser_descriptor_type_init(struct sm6_parser *sm6,
+        enum vkd3d_shader_descriptor_type type, const struct sm6_metadata_node *descriptor_node,
+        size_t *resource_capacity)
+{
+    struct vkd3d_shader_desc *desc = &sm6->p.shader_desc;
+    struct vkd3d_shader_register_range range;
+    struct vkd3d_shader_descriptor_info1 *d;
+    const struct sm6_metadata_node *node;
+    const struct sm6_metadata_value *m;
+    enum vkd3d_result ret;
+    unsigned int i;
+
+    for (i = 0; i < descriptor_node->operand_count; ++i)
+    {
+        m = descriptor_node->operands[i];
+        if (!sm6_metadata_value_is_node(m))
+        {
+            WARN("Resource descriptor is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                    "Resource descriptor is not a metadata node.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if (!vkd3d_array_reserve((void **)&desc->descriptors, resource_capacity,
+                desc->descriptor_count + 1, sizeof(*desc->descriptors)))
+        {
+            ERR("Failed to allocate resource array.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY,
+                    "Out of memory allocating the resource array.");
+            return VKD3D_ERROR_OUT_OF_MEMORY;
+        }
+
+        d = &desc->descriptors[desc->descriptor_count];
+        memset(d, 0, sizeof(*d));
+        d->type = type;
+
+        node = m->u.node;
+
+        switch (type)
+        {
+            case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV:
+                if ((ret = sm6_parser_resources_load_cbv(sm6, node, d)) < 0)
+                    return ret;
+                break;
+            default:
+                FIXME("Unsupported descriptor type %u.\n", type);
+                vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                        "Resource descriptor type %u is unsupported.", type);
+                return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if (!sm6_metadata_get_uint_value(sm6, node->operands[0], &d->register_id))
+        {
+            WARN("Failed to load resource id.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                    "Resource id metadata value is not an integer.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if (!sm6_parser_resources_load_register_range(sm6, node, &range))
+        {
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                    "Resource register range is invalid.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        d->register_space = range.space;
+        d->register_index = range.first;
+        d->count = (range.last == UINT_MAX) ? UINT_MAX : range.last - range.first + 1;
+
+        ++desc->descriptor_count;
+    }
+
+    return VKD3D_OK;
+}
+
+static enum vkd3d_result sm6_parser_resources_init(struct sm6_parser *sm6)
+{
+    const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.resources");
+    enum vkd3d_shader_descriptor_type type;
+    const struct sm6_metadata_node *node;
+    size_t resource_capacity = 0;
+    enum vkd3d_result ret;
+
+    if (!m)
+        return VKD3D_OK;
+
+    node = m->u.node;
+    if (node->operand_count != SHADER_DESCRIPTOR_TYPE_COUNT)
+    {
+        WARN("Unexpected descriptor type count %u.\n", node->operand_count);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                "Descriptor type count %u is invalid.", node->operand_count);
+        return VKD3D_ERROR_INVALID_SHADER;
+    }
+
+    for (type = 0; type < SHADER_DESCRIPTOR_TYPE_COUNT; ++type)
+    {
+        if (!(m = node->operands[type]))
+            continue;
+
+        if (!sm6_metadata_value_is_node(m))
+        {
+            WARN("Resource list is not a node.\n");
+            vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES,
+                    "Resource list is not a metadata node.");
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+
+        if ((ret = sm6_parser_descriptor_type_init(sm6, type, m->u.node, &resource_capacity)) < 0)
+            return ret;
+    }
+
+    return VKD3D_OK;
+}
+
 static void signature_element_read_additional_element_values(struct signature_element *e,
         const struct sm6_metadata_node *node, struct sm6_parser *sm6)
 {
@@ -4176,6 +4393,9 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t
     if ((ret = sm6_parser_entry_point_init(sm6)) < 0)
         return ret;

+    if ((ret = sm6_parser_resources_init(sm6)) < 0)
+        return ret;
+
     if ((ret = sm6_parser_module_init(sm6, &sm6->root_block, 0)) < 0)
     {
         if (ret == VKD3D_ERROR_OUT_OF_MEMORY)
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index 052edeb50..310932d9e 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -1150,6 +1150,22 @@ static enum vkd3d_result convert_descriptor_info(struct vkd3d_shader_scan_descri
     return VKD3D_OK;
 }

+static bool clone_descriptor_info1_safe(struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info,
+        struct vkd3d_shader_descriptor_info1 *descriptors, unsigned int descriptor_count)
+{
+    if (!scan_descriptor_info || !descriptor_count)
+        return true;
+
+    if (!(scan_descriptor_info->descriptors = vkd3d_calloc(descriptor_count,
+            sizeof(*scan_descriptor_info->descriptors))))
+        return false;
+    memcpy(scan_descriptor_info->descriptors, descriptors,
+            descriptor_count * sizeof(*scan_descriptor_info->descriptors));
+    scan_descriptor_info->descriptor_count = descriptor_count;
+
+    return true;
+}
+
 static void vkd3d_shader_free_scan_descriptor_info1(struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info)
 {
     TRACE("scan_descriptor_info %p.\n", scan_descriptor_info);
@@ -1179,6 +1195,8 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info
     {
         descriptor_info1 = &local_descriptor_info1;
     }
+    clone_descriptor_info1_safe(descriptor_info1, parser->shader_desc.descriptors, parser->shader_desc.descriptor_count);
+
     signature_info = vkd3d_find_struct(compile_info->next, SCAN_SIGNATURE_INFO);

vkd3d_shader_scan_context_init(&context, compile_info, descriptor_info1, message_context);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 85041f2a5..1305e4aff 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -180,6 +180,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT         = 8015,
     VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE           = 8016,
     VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES          = 8017,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES           = 8018,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,
@@ -931,6 +932,9 @@ struct vkd3d_shader_desc
     {
         uint32_t used, external;
     } flat_constant_count[3];
+
+    struct vkd3d_shader_descriptor_info1 *descriptors;
+    size_t descriptor_count;
 };

struct vkd3d_shader_register_semantic

[PATCH v4 16/18] vkd3d-shader/dxil: Implement DX instruction CreateHandle.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 83 ++++++++++++++++++++++++
 libs/vkd3d-shader/vkd3d_shader_private.h |  1 +
 2 files changed, 84 insertions(+)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 4a1e1e108..de76fbefd 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -269,6 +269,7 @@ enum dx_intrinsic_opcode
 {
     DX_LOAD_INPUT                   =   4,
     DX_STORE_OUTPUT                 =   5,
+    DX_CREATE_HANDLE                =  57,
 };

struct sm6_pointer_info
@@ -328,6 +329,7 @@ enum sm6_value_type
 {
     VALUE_TYPE_FUNCTION,
     VALUE_TYPE_REG,
+    VALUE_TYPE_HANDLE,
 };

struct sm6_function_data
@@ -337,6 +339,12 @@ struct sm6_function_data
     unsigned int attribs_id;
 };

+struct sm6_handle_data
+{
+    const struct vkd3d_shader_descriptor_info1 *d;
+    struct vkd3d_shader_register reg;
+};
+
 struct sm6_value
 {
     const struct sm6_type *type;
@@ -346,6 +354,7 @@ struct sm6_value
     {
         struct sm6_function_data function;
         struct vkd3d_shader_register reg;
+        struct sm6_handle_data handle;
     } u;
 };

@@ -465,6 +474,7 @@ struct sm6_parser
     struct sm6_type *types;
     size_t type_count;
     struct sm6_type *metadata_type;
+    struct sm6_type *handle_type;

struct sm6_symbol *global_symbols;
     size_t global_symbol_count;
@@ -1414,6 +1424,9 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6)
                     break;
                 }

+                if (!ascii_strcasecmp(struct_name, "dx.types.Handle"))
+                    sm6->handle_type = type;
+
                 type->u.struc->name = struct_name;
                 struct_name = NULL;
                 break;
@@ -1461,6 +1474,11 @@ static inline bool sm6_type_is_integer(const struct sm6_type *type)
     return type->class == TYPE_CLASS_INTEGER;
 }

+static bool sm6_type_is_bool(const struct sm6_type *type)
+{
+    return type->class == TYPE_CLASS_INTEGER && type->u.width == 1;
+}
+
 static inline bool sm6_type_is_i8(const struct sm6_type *type)
 {
     return type->class == TYPE_CLASS_INTEGER && type->u.width == 8;
@@ -1805,6 +1823,8 @@ static enum vkd3d_data_type vkd3d_data_type_from_sm6_type(const struct sm6_type
     {
         switch (type->u.width)
         {
+            case 1:
+                return VKD3D_DATA_BOOL;
             case 8:
                 return VKD3D_DATA_UINT8;
             case 32:
@@ -2542,6 +2562,62 @@ static struct sm6_block *sm6_block_create()
     return block;
 }

+static const struct vkd3d_shader_descriptor_info1 *parser_get_descriptor(struct vkd3d_shader_parser *parser,
+        enum vkd3d_shader_descriptor_type type, unsigned int id)
+{
+    const struct vkd3d_shader_descriptor_info1 *d;
+    size_t i;
+
+    for (i = 0; i < parser->shader_desc.descriptor_count; ++i)
+    {
+        d = &parser->shader_desc.descriptors[i];
+        if (d->type == type && d->register_id == id)
+            return d;
+    }
+
+    return NULL;
+}
+
+static void sm6_parser_emit_dx_create_handle(struct sm6_parser *sm6, struct sm6_block *code_block,
+        enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins)
+{
+    const struct vkd3d_shader_descriptor_info1 *d;
+    enum vkd3d_shader_descriptor_type type;
+    struct vkd3d_shader_register *reg;
+    struct sm6_value *dst;
+    unsigned int id;
+
+    type = sm6_value_get_constant_uint(operands[0]);
+    id = sm6_value_get_constant_uint(operands[1]);
+    if (!(d = parser_get_descriptor(&sm6->p, type, id)))
+    {
+        WARN("Failed to find resource type %#x, id %#x.\n", type, id);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND,
+                "Descriptor for resource type %#x, id %#x was not found.", type, id);
+        return;
+    }
+
+    /* NOP is used to flag no instruction emitted. */
+    ins->handler_idx = VKD3DSIH_NOP;
+
+    dst = sm6_parser_get_current_value(sm6);
+    dst->value_type = VALUE_TYPE_HANDLE;
+    dst->u.handle.d = d;
+
+    reg = &dst->u.handle.reg;
+    vsir_register_init(reg, VKD3DSPR_CONSTBUFFER, VKD3D_DATA_FLOAT, 2);
+    reg->idx[0].offset = id;
+    register_address_init(reg, operands[2], 1, sm6);
+    if (!sm6_value_is_constant(operands[3]))
+    {
+        WARN("Non-uniform attribute is not constant.\n");
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND,
+                "Resource handle non-uniform attribute is not a constant.");
+        return;
+    }
+    reg->non_uniform = !!sm6_value_get_constant_uint(operands[3]);
+}
+
 static void sm6_parser_emit_dx_load_input(struct sm6_parser *sm6, struct sm6_block *code_block,
         enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins)
 {
@@ -2636,8 +2712,10 @@ struct sm6_dx_opcode_info
 };

/*
+    1 -> int1
     8 -> int8
     i -> int32
+    H -> handle
     v -> void
     o -> overloaded
  */
@@ -2645,6 +2723,7 @@ static const struct sm6_dx_opcode_info sm6_dx_op_table[] =
 {
     [DX_LOAD_INPUT                    ] = {'o', "ii8i", sm6_parser_emit_dx_load_input},
     [DX_STORE_OUTPUT                  ] = {'v', "ii8o", sm6_parser_emit_dx_store_output},
+    [DX_CREATE_HANDLE                 ] = {'H', "8ii1", sm6_parser_emit_dx_create_handle},
 };

static bool sm6_parser_validate_operand_type(struct sm6_parser *sm6, const struct sm6_type *type, char info_type)
@@ -2654,10 +2733,14 @@ static bool sm6_parser_validate_operand_type(struct sm6_parser *sm6, const struc
         case 0:
             FIXME("Invalid operand count.\n");
             return false;
+        case '1':
+            return sm6_type_is_bool(type);
         case '8':
             return sm6_type_is_i8(type);
         case 'i':
             return sm6_type_is_i32(type);
+        case 'H':
+            return type == sm6->handle_type;
         case 'v':
             return !type;
         case 'o':
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 1305e4aff..71731b632 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -574,6 +574,7 @@ enum vkd3d_data_type
     VKD3D_DATA_UNUSED,
     VKD3D_DATA_UINT8,
     VKD3D_DATA_UINT64,
+    VKD3D_DATA_BOOL,
 };

static inline bool data_type_is_integer(enum vkd3d_data_type data_type)

[PATCH v4 17/18] vkd3d-shader/dxil: Implement DX instruction CBufferLoadLegacy.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                 | 99 +++++++++++++++++++++++-
 libs/vkd3d-shader/vkd3d_shader_private.h |  6 ++
 2 files changed, 101 insertions(+), 4 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index de76fbefd..2984c3ddd 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -270,6 +270,7 @@ enum dx_intrinsic_opcode
     DX_LOAD_INPUT                   =   4,
     DX_STORE_OUTPUT                 =   5,
     DX_CREATE_HANDLE                =  57,
+    DX_CBUFFER_LOAD_LEGACY          =  59,
 };

struct sm6_pointer_info
@@ -1598,6 +1599,11 @@ static const struct sm6_type *sm6_type_get_scalar_type(const struct sm6_type *ty
     }
 }

+static unsigned int sm6_type_max_vector_size(const struct sm6_type *type)
+{
+    return min((VKD3D_VEC4_SIZE * sizeof(uint32_t) * CHAR_BIT) / type->u.width, VKD3D_VEC4_SIZE);
+}
+
 static const struct sm6_type *sm6_parser_get_type(struct sm6_parser *sm6, uint64_t type_id)
 {
     if (type_id >= sm6->type_count)
@@ -1702,7 +1708,7 @@ static const char *sm6_parser_get_global_symbol_name(const struct sm6_parser *sm

static unsigned int register_get_uint_value(const struct vkd3d_shader_register *reg)
 {
-    if (!register_is_constant(reg) || !data_type_is_integer(reg->data_type))
+    if (!register_is_constant(reg) || (!data_type_is_integer(reg->data_type) && !data_type_is_bool(reg->data_type)))
         return UINT_MAX;

if (reg->dimension == VSIR_DIMENSION_VEC4)
@@ -1751,6 +1757,11 @@ static inline bool sm6_value_is_register(const struct sm6_value *value)
     return value->value_type == VALUE_TYPE_REG;
 }

+static bool sm6_value_is_handle(const struct sm6_value *value)
+{
+    return value->value_type == VALUE_TYPE_HANDLE;
+}
+
 static inline bool sm6_value_is_constant(const struct sm6_value *value)
 {
     return sm6_value_is_register(value) && register_is_constant(&value->u.reg);
@@ -1854,8 +1865,8 @@ static enum vkd3d_data_type vkd3d_data_type_from_sm6_type(const struct sm6_type
     return VKD3D_DATA_UINT;
 }

-static void register_init_ssa_scalar(struct vkd3d_shader_register *reg, const struct sm6_type *type,
-        struct sm6_parser *sm6)
+static void register_init_ssa_vector(struct vkd3d_shader_register *reg, const struct sm6_type *type,
+        unsigned int component_count, struct sm6_parser *sm6)
 {
     enum vkd3d_data_type data_type;
     unsigned int id;
@@ -1863,6 +1874,13 @@ static void register_init_ssa_scalar(struct vkd3d_shader_register *reg, const st
     id = sm6_parser_alloc_ssa_id(sm6);
     data_type = vkd3d_data_type_from_sm6_type(sm6_type_get_scalar_type(type, 0));
     register_init_with_id(reg, VKD3DSPR_SSA, data_type, id);
+    reg->dimension = component_count > 1 ? VSIR_DIMENSION_VEC4 : VSIR_DIMENSION_SCALAR;
+}
+
+static void register_init_ssa_scalar(struct vkd3d_shader_register *reg, const struct sm6_type *type,
+        struct sm6_parser *sm6)
+{
+    register_init_ssa_vector(reg, type, 1, sm6);
 }

static void dst_param_init(struct vkd3d_shader_dst_param *param)
@@ -1879,6 +1897,13 @@ static inline void dst_param_init_scalar(struct vkd3d_shader_dst_param *param, u
     param->shift = 0;
 }

+static void dst_param_init_vector(struct vkd3d_shader_dst_param *param, unsigned int component_count)
+{
+    param->write_mask = (1u << component_count) - 1;
+    param->modifiers = 0;
+    param->shift = 0;
+}
+
 static void dst_param_init_ssa_scalar(struct vkd3d_shader_dst_param *param, const struct sm6_type *type,
         struct sm6_parser *sm6)
 {
@@ -1904,6 +1929,14 @@ static void src_param_init_from_value(struct vkd3d_shader_src_param *param, cons
     param->reg = src->u.reg;
 }

+static void src_param_init_vector_from_reg(struct vkd3d_shader_src_param *param,
+        const struct vkd3d_shader_register *reg)
+{
+    param->swizzle = VKD3D_SHADER_NO_SWIZZLE;
+    param->modifiers = VKD3DSPSM_NONE;
+    param->reg = *reg;
+}
+
 static void register_address_init(struct vkd3d_shader_register *reg, const struct sm6_value *address,
         unsigned int idx, struct sm6_parser *sm6)
 {
@@ -1936,6 +1969,17 @@ static void instruction_dst_param_init_ssa_scalar(struct vkd3d_shader_instructio
     dst->u.reg = param->reg;
 }

+static void instruction_dst_param_init_ssa_vector(struct sm6_parser *sm6, struct vkd3d_shader_instruction *ins,
+        unsigned int component_count)
+{
+    struct vkd3d_shader_dst_param *param = instruction_dst_params_alloc(ins, 1, sm6);
+    struct sm6_value *dst = sm6_parser_get_current_value(sm6);
+
+    dst_param_init_vector(param, component_count);
+    register_init_ssa_vector(&param->reg, sm6_type_get_scalar_type(dst->type, 0), component_count, sm6);
+    dst->u.reg = param->reg;
+}
+
 /* Recurse through the block tree while maintaining a current value count. The current
  * count is the sum of the global count plus all declarations within the current function.
  * Store into value_capacity the highest count seen. */
@@ -2000,6 +2044,18 @@ static size_t sm6_parser_get_value_index(struct sm6_parser *sm6, uint64_t idx)
     return i;
 }

+static bool sm6_value_validate_is_handle(const struct sm6_value *value, struct sm6_parser *sm6)
+{
+    if (!sm6_value_is_handle(value))
+    {
+        WARN("Handle parameter of type %u is not a handle.\n", value->value_type);
+        vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCE_HANDLE,
+                "A handle parameter passed to a DX intrinsic function is not a handle.");
+        return false;
+    }
+    return true;
+}
+
 static const struct sm6_value *sm6_parser_get_value_safe(struct sm6_parser *sm6, unsigned int idx)
 {
     if (idx < sm6->value_count)
@@ -2578,6 +2634,39 @@ static const struct vkd3d_shader_descriptor_info1 *parser_get_descriptor(struct
     return NULL;
 }

+static void sm6_parser_emit_dx_cbuffer_load(struct sm6_parser *sm6, struct sm6_block *code_block,
+        enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins)
+{
+    struct sm6_value *dst = sm6_parser_get_current_value(sm6);
+    unsigned int component_count = VKD3D_VEC4_SIZE;
+    struct vkd3d_shader_src_param *src_param;
+    const struct sm6_value *buffer;
+    const struct sm6_type *type;
+
+    buffer = operands[0];
+    if (!sm6_value_validate_is_handle(buffer, sm6))
+        return;
+
+    vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV);
+
+    src_param = instruction_src_params_alloc(ins, 1, sm6);
+    src_param_init_vector_from_reg(src_param, &buffer->u.handle.reg);
+    type = sm6_type_get_scalar_type(dst->type, 0);
+    if (!type)
+    {
+        WARN("Failed to get result type.\n");
+    }
+    else
+    {
+        src_param->reg.data_type = vkd3d_data_type_from_sm6_type(type);
+        component_count = sm6_type_max_vector_size(type);
+    }
+    register_address_init(&src_param->reg, operands[1], 2, sm6);
+    src_param->reg.idx_count = 3;
+
+    instruction_dst_param_init_ssa_vector(sm6, ins, component_count);
+}
+
 static void sm6_parser_emit_dx_create_handle(struct sm6_parser *sm6, struct sm6_block *code_block,
         enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins)
 {
@@ -2723,6 +2812,7 @@ static const struct sm6_dx_opcode_info sm6_dx_op_table[] =
 {
     [DX_LOAD_INPUT                    ] = {'o', "ii8i", sm6_parser_emit_dx_load_input},
     [DX_STORE_OUTPUT                  ] = {'v', "ii8o", sm6_parser_emit_dx_store_output},
+    [DX_CBUFFER_LOAD_LEGACY           ] = {'o', "Hi",   sm6_parser_emit_dx_cbuffer_load},
     [DX_CREATE_HANDLE                 ] = {'H', "8ii1", sm6_parser_emit_dx_create_handle},
 };

@@ -2770,7 +2860,8 @@ static bool sm6_parser_validate_dx_op(struct sm6_parser *sm6, enum dx_intrinsic_
     for (i = 0; i < operand_count; ++i)
     {
         const struct sm6_value *value = operands[i];
-        if (!sm6_value_is_register(value) || !sm6_parser_validate_operand_type(sm6, value->type, info->operand_info[i]))
+        if ((!sm6_value_is_register(value) && !sm6_value_is_handle(value))
+                || !sm6_parser_validate_operand_type(sm6, value->type, info->operand_info[i]))
         {
             WARN("Failed to validate operand %u for dx intrinsic id %u, '%s'.\n", i + 1, op, name);
             vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND,
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 71731b632..b67c0190b 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -181,6 +181,7 @@ enum vkd3d_shader_error
     VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE           = 8016,
     VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES          = 8017,
     VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES           = 8018,
+    VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCE_HANDLE     = 8019,

VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER      = 8300,
     VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE       = 8301,
@@ -583,6 +584,11 @@ static inline bool data_type_is_integer(enum vkd3d_data_type data_type)
             || data_type == VKD3D_DATA_UINT64;
 }

+static inline bool data_type_is_bool(enum vkd3d_data_type data_type)
+{
+    return data_type == VKD3D_DATA_BOOL;
+}
+
 enum vsir_dimension
 {
     VSIR_DIMENSION_NONE,

[PATCH v4 18/18] vkd3d-shader/dxil: Implement the DXIL EXTRACTVAL instruction.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/dxil.c                    | 89 +++++++++++++++++++++
 tests/hlsl/asfloat.shader_test              |  2 +-
 tests/hlsl/cbuffer.shader_test              | 16 ++--
 tests/hlsl/expr-indexing.shader_test        |  4 +-
 tests/hlsl/majority-pragma.shader_test      | 26 +++---
 tests/hlsl/majority-syntax.shader_test      |  2 +-
 tests/hlsl/matrix-indexing.shader_test      |  8 +-
 tests/hlsl/nested-arrays.shader_test        |  2 +-
 tests/hlsl/object-field-offsets.shader_test |  4 +-
 tests/hlsl/storage-qualifiers.shader_test   |  2 +-
 tests/hlsl/struct-array.shader_test         |  2 +-
 tests/hlsl/swizzle-matrix.shader_test       | 14 ++--
 tests/hlsl/swizzles.shader_test             |  6 +-
 tests/hlsl/uniform-semantics.shader_test    |  4 +-
 tests/hlsl/vector-indexing.shader_test      |  2 +-
 15 files changed, 136 insertions(+), 47 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c
index 2984c3ddd..86d485cb8 100644
--- a/libs/vkd3d-shader/dxil.c
+++ b/libs/vkd3d-shader/dxil.c
@@ -1495,6 +1495,11 @@ static inline bool sm6_type_is_floating_point(const struct sm6_type *type)
     return type->class == TYPE_CLASS_FLOAT;
 }

+static bool sm6_type_is_scalar(const struct sm6_type *type)
+{
+    return type->class == TYPE_CLASS_INTEGER || type->class == TYPE_CLASS_FLOAT || type->class == TYPE_CLASS_POINTER;
+}
+
 static inline bool sm6_type_is_numeric(const struct sm6_type *type)
 {
     return type->class == TYPE_CLASS_INTEGER || type->class == TYPE_CLASS_FLOAT;
@@ -1505,6 +1510,11 @@ static inline bool sm6_type_is_pointer(const struct sm6_type *type)
     return type->class == TYPE_CLASS_POINTER;
 }

+static bool sm6_type_is_aggregate(const struct sm6_type *type)
+{
+    return type->class == TYPE_CLASS_STRUCT || type->class == TYPE_CLASS_VECTOR || type->class == TYPE_CLASS_ARRAY;
+}
+
 static bool sm6_type_is_numeric_aggregate(const struct sm6_type *type)
 {
     unsigned int i;
@@ -1575,6 +1585,29 @@ static const struct sm6_type *sm6_type_get_pointer_to_type(const struct sm6_type
     return NULL;
 }

+static const struct sm6_type *sm6_type_get_element_type_at_index(const struct sm6_type *type, unsigned int elem_idx)
+{
+    switch (type->class)
+    {
+        case TYPE_CLASS_ARRAY:
+        case TYPE_CLASS_VECTOR:
+            if (elem_idx != UINT_MAX && elem_idx >= type->u.array.count)
+                return NULL;
+            return type->u.array.elem_type;
+
+        case TYPE_CLASS_POINTER:
+            return type->u.pointer.type;
+
+        case TYPE_CLASS_STRUCT:
+            if (elem_idx >= type->u.struc->elem_count)
+                return NULL;
+            return type->u.struc->elem_types[elem_idx];
+
+        default:
+            return NULL;
+    }
+}
+
 /* Never returns null for elem_idx 0. */
 static const struct sm6_type *sm6_type_get_scalar_type(const struct sm6_type *type, unsigned int elem_idx)
 {
@@ -3001,6 +3034,59 @@ static void sm6_parser_emit_call(struct sm6_parser *sm6, const struct dxil_recor
             fn_value->u.function.name, &operands[1], operand_count - 1, ins, dst);
 }

+static void sm6_parser_emit_extractval(struct sm6_parser *sm6, const struct dxil_record *record,
+        struct vkd3d_shader_instruction *ins, struct sm6_value *dst)
+{
+    struct vkd3d_shader_src_param *src_param;
+    unsigned int elem_idx, i = 0;
+    const struct sm6_type *type;
+    const struct sm6_value *src;
+
+    if (!(src = sm6_parser_get_value_by_ref(sm6, record, NULL, &i)))
+        return;
+
+    if (!dxil_record_validate_operand_min_count(record, i + 1, sm6))
+        return;
+
+    if (record->operand_count > i + 1)
+    {
+        FIXME("Unhandled multiple indices.\n");
+        return;
+    }
+    if (record->operands[i] >= VKD3D_VEC4_SIZE)
+    {
+        FIXME("Unhandled element index %"PRIu64".\n", record->operands[i]);
+        return;
+    }
+    elem_idx = record->operands[i];
+
+    type = src->type;
+    if (!sm6_type_is_aggregate(type))
+    {
+        FIXME("Invalid extraction from non-aggregate.\n");
+        return;
+    }
+    if (!(type = sm6_type_get_element_type_at_index(type, elem_idx)))
+    {
+        FIXME("Invalid element index %u.\n", elem_idx);
+        return;
+    }
+    if (!sm6_type_is_scalar(type))
+    {
+        FIXME("Value is not of scalar type.\n");
+        return;
+    }
+    dst->type = type;
+
+    ins->handler_idx = VKD3DSIH_MOV;
+
+    src_param = instruction_src_params_alloc(ins, 1, sm6);
+    src_param_init_from_value(src_param, src);
+    src_param->swizzle = vkd3d_shader_create_swizzle(elem_idx, elem_idx, elem_idx, elem_idx);
+
+    instruction_dst_param_init_ssa_scalar(ins, sm6);
+}
+
 static void sm6_parser_emit_ret(struct sm6_parser *sm6, const struct dxil_record *record,
         struct sm6_block *code_block, struct vkd3d_shader_instruction *ins)
 {
@@ -3156,6 +3242,9 @@ static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const
             case FUNC_CODE_INST_CALL:
                 sm6_parser_emit_call(sm6, record, code_block, ins, dst);
                 break;
+            case FUNC_CODE_INST_EXTRACTVAL:
+                sm6_parser_emit_extractval(sm6, record, ins, dst);
+                break;
             case FUNC_CODE_INST_RET:
                 sm6_parser_emit_ret(sm6, record, code_block, ins);
                 is_terminator = true;
diff --git a/tests/hlsl/asfloat.shader_test b/tests/hlsl/asfloat.shader_test
index 00238164c..d460240b1 100644
--- a/tests/hlsl/asfloat.shader_test
+++ b/tests/hlsl/asfloat.shader_test
@@ -36,7 +36,7 @@ float4 main() : sv_target
 uniform 0 float4 11 12 0 0
 uniform 4 float4 13 14 0 0
 uniform 8 float4 20 21 22 23
-todo(sm>=6) draw quad
+draw quad
 probe (320,240) rgba (13.0, 21.0, 0.0, 0.0)

[pixel shader fail]
diff --git a/tests/hlsl/cbuffer.shader_test b/tests/hlsl/cbuffer.shader_test
index 59dda97a5..dbb49ea7e 100644
--- a/tests/hlsl/cbuffer.shader_test
+++ b/tests/hlsl/cbuffer.shader_test
@@ -13,7 +13,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 3.0, 4.0)

[pixel shader]
@@ -31,7 +31,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 3.0, 4.0)

% SM1 buffer offset allocation follows different rules than SM4.
@@ -72,7 +72,7 @@ uniform 0 float4 0.0 1.0 2.0 3.0
 uniform 4 float4 4.0 5.0 6.0 7.0
 uniform 8 float4 8.0 9.0 10.0 11.0
 uniform 12 float4 12.0 13.0 14.0 15.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.0, 2.0, 4.0, 8.0)

@@ -93,7 +93,7 @@ float4 main() : sv_target
 uniform 0 float4 0.0 1.0 2.0 3.0
 uniform 4 float4 4.0 5.0 6.0 7.0
 uniform 8 float4 8.0 9.0 10.0 11.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.0, 4.0, 8.0, 9.0)

@@ -119,7 +119,7 @@ uniform 0 float4 0.0 1.0 2.0 3.0
 uniform 4 float4 4.0 5.0 6.0 7.0
 uniform 8 float4 8.0 9.0 10.0 11.0
 uniform 12 float4 12.0 13.0 14.0 15.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.0, 4.0, 5.0, 6.0)

@@ -142,7 +142,7 @@ uniform 0 float4 1.0 0.0 0.0 0.0
 uniform 4 float4 2.0 0.0 0.0 0.0
 uniform 8 float4 3.0 0.0 0.0 0.0
 uniform 12 float4 4.0 0.0 0.0 0.0
-todo draw quad
+todo(sm<6) draw quad
 probe all rgba (1.0, 3.0, 3.0, 4.0)

@@ -221,7 +221,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (2.0, 3.0, 2.0, 3.0)

@@ -357,7 +357,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (3.0, 4.0, 3.0, 4.0)

diff --git a/tests/hlsl/expr-indexing.shader_test b/tests/hlsl/expr-indexing.shader_test
index 1816c6eb7..1c598816e 100644
--- a/tests/hlsl/expr-indexing.shader_test
+++ b/tests/hlsl/expr-indexing.shader_test
@@ -40,7 +40,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (3.0, 3.0, 3.0, 3.0)

@@ -78,7 +78,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (4.0, 4.0, 4.0, 4.0)

diff --git a/tests/hlsl/majority-pragma.shader_test b/tests/hlsl/majority-pragma.shader_test
index f7baa90b9..84dff63e0 100644
--- a/tests/hlsl/majority-pragma.shader_test
+++ b/tests/hlsl/majority-pragma.shader_test
@@ -40,7 +40,7 @@ float4 main() : sv_target
 [test]
 uniform  0 float4 0.1 0.2 0.0 0.0
 uniform  4 float4 0.3 0.4 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.2, 0.3, 0.4)

@@ -61,7 +61,7 @@ uniform  0 float4 0.0 0.0 0.0 0.0
 uniform  4 float4 0.0 0.0 0.0 0.0
 uniform  8 float4 0.5 0.6 0.0 0.0
 uniform 12 float4 0.7 0.8 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.5, 0.6, 0.7, 0.8)

@@ -111,7 +111,7 @@ float4 main() : sv_target
 [test]
 uniform  0 float4 0.1 0.2 0.0 0.0
 uniform  4 float4 0.3 0.4 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.2, 0.3, 0.4)

@@ -149,7 +149,7 @@ uniform  0 float4 0.3 0.4 0.0 0.0
 uniform  4 float4 0.0 0.0 0.0 0.0
 uniform  8 float4 0.0 0.0 0.0 0.0
 uniform 12 float4 0.5 0.6 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.3, 0.4, 0.5, 0.6)

@@ -173,7 +173,7 @@ float4 main() : sv_target
 [test]
 uniform  0 float4 0.1 0.2 0.0 0.0
 uniform  4 float4 0.3 0.4 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.2, 0.3, 0.4)

@@ -201,7 +201,7 @@ float4 main() : sv_target
 [test]
 uniform  0 float4 0.2 0.4 0.0 0.0
 uniform  4 float4 0.3 0.5 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.2, 0.3, 0.4, 0.5)

@@ -221,7 +221,7 @@ uniform  0 float4 0.3 0.0 0.0 0.0
 uniform  4 float4 0.4 0.0 0.0 0.0
 uniform  8 float4 0.0 0.5 0.0 0.0
 uniform 12 float4 0.0 0.6 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.3, 0.4, 0.5, 0.6)

% Compiler options
@@ -245,7 +245,7 @@ uniform  0 float4 0.1 0.5 0.9 1.3
 uniform  4 float4 0.2 0.6 1.0 1.4
 uniform  8 float4 0.3 0.7 1.1 1.5
 uniform 12 float4 0.4 0.8 1.2 1.6
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.2, 0.3, 0.6, 0.7) 1

[require]
@@ -267,7 +267,7 @@ uniform  0 float4 0.1 0.5 0.9 1.3
 uniform  4 float4 0.2 0.6 1.0 1.4
 uniform  8 float4 0.3 0.7 1.1 1.5
 uniform 12 float4 0.4 0.8 1.2 1.6
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.2, 0.3, 0.6, 0.7) 1

[require]
@@ -289,7 +289,7 @@ uniform  0 float4 0.1 0.5 0.9 1.3
 uniform  4 float4 0.2 0.6 1.0 1.4
 uniform  8 float4 0.3 0.7 1.1 1.5
 uniform 12 float4 0.4 0.8 1.2 1.6
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.5, 0.9, 0.6, 1.0) 1

[require]
@@ -317,7 +317,7 @@ uniform 16 float4 1.7 2.1 2.5 2.9
 uniform 20 float4 1.8 2.2 2.6 3.0
 uniform 24 float4 1.9 2.3 2.7 3.1
 uniform 28 float4 2.0 2.4 2.8 3.2
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.3, 0.4, 2.5, 2.9) 1

[require]
@@ -345,7 +345,7 @@ uniform 16 float4 1.7 2.1 2.5 2.9
 uniform 20 float4 1.8 2.2 2.6 3.0
 uniform 24 float4 1.9 2.3 2.7 3.1
 uniform 28 float4 2.0 2.4 2.8 3.2
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.2, 1.6, 3.1, 3.2) 1

[require]
@@ -365,5 +365,5 @@ float4 main() : sv_target
 [test]
 uniform  0 float4 0.1 0.2 0.0 0.0
 uniform  4 float4 0.3 0.4 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.3, 0.2, 0.4) 1
diff --git a/tests/hlsl/majority-syntax.shader_test b/tests/hlsl/majority-syntax.shader_test
index 63e5d2986..f1f5291ff 100644
--- a/tests/hlsl/majority-syntax.shader_test
+++ b/tests/hlsl/majority-syntax.shader_test
@@ -11,7 +11,7 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 0.1 0.3 0.0 0.0
 uniform 4 float4 0.2 0.4 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.3, 0.2, 0.4)

[pixel shader fail(sm<6)]
diff --git a/tests/hlsl/matrix-indexing.shader_test b/tests/hlsl/matrix-indexing.shader_test
index a61983eef..170036475 100644
--- a/tests/hlsl/matrix-indexing.shader_test
+++ b/tests/hlsl/matrix-indexing.shader_test
@@ -11,7 +11,7 @@ uniform 0 float4 1.0 2.0 3.0 4.0
 uniform 4 float4 5.0 6.0 7.0 8.0
 uniform 8 float4 9.0 10.0 11.0 12.0
 uniform 12 float4 13.0 14.0 15.0 16.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 10.0, 15.0)

[pixel shader]
@@ -27,7 +27,7 @@ uniform 0 float4 1.0 2.0 3.0 4.0
 uniform 4 float4 5.0 6.0 7.0 8.0
 uniform 8 float4 9.0 10.0 11.0 12.0
 uniform 12 float4 13.0 14.0 15.0 16.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 10.0, 15.0)

[pixel shader]
@@ -43,7 +43,7 @@ uniform 0 float4 1.0 2.0 3.0 4.0
 uniform 4 float4 5.0 6.0 7.0 8.0
 uniform 8 float4 9.0 10.0 11.0 12.0
 uniform 12 float4 13.0 14.0 15.0 16.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 5.0, 7.0, 12.0)

[pixel shader]
@@ -58,7 +58,7 @@ float4 main() : SV_TARGET
 [test]
 uniform 0 float4 1.0 2.0 3.0 0.0
 uniform 4 float4 5.0 6.0 7.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 3.0, 6.0, 7.0)

[pixel shader]
diff --git a/tests/hlsl/nested-arrays.shader_test b/tests/hlsl/nested-arrays.shader_test
index b7aeec442..c9ba186bd 100644
--- a/tests/hlsl/nested-arrays.shader_test
+++ b/tests/hlsl/nested-arrays.shader_test
@@ -21,5 +21,5 @@ uniform  8 float4 0.3 0.0 0.0 0.0
 uniform 12 float4 0.4 0.0 0.0 0.0
 uniform 16 float4 0.5 0.0 0.0 0.0
 uniform 20 float4 0.6 0.0 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.4, 0.1, 0.6, 0.3)
diff --git a/tests/hlsl/object-field-offsets.shader_test b/tests/hlsl/object-field-offsets.shader_test
index d1741c3e4..9cc4581ba 100644
--- a/tests/hlsl/object-field-offsets.shader_test
+++ b/tests/hlsl/object-field-offsets.shader_test
@@ -19,7 +19,7 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 1.0 2.0 3.0 4.0
 uniform 4 float4 5.0 6.0 7.0 8.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 3.0, 0.0)

@@ -66,5 +66,5 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 1.0 2.0 3.0 4.0
 uniform 4 float4 5.0 6.0 7.0 8.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 5.0, 0.0)
diff --git a/tests/hlsl/storage-qualifiers.shader_test b/tests/hlsl/storage-qualifiers.shader_test
index 09385e3e4..86cea4713 100644
--- a/tests/hlsl/storage-qualifiers.shader_test
+++ b/tests/hlsl/storage-qualifiers.shader_test
@@ -42,5 +42,5 @@ void main(out float4 o : sv_target)
 [test]
 uniform 0 float4 0.1 0.0 0.0 0.0
 uniform 4 float4 0.2 0.0 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.1, 0.2, 0.3, 0.4)
diff --git a/tests/hlsl/struct-array.shader_test b/tests/hlsl/struct-array.shader_test
index 4097f3835..aff0a677a 100644
--- a/tests/hlsl/struct-array.shader_test
+++ b/tests/hlsl/struct-array.shader_test
@@ -18,5 +18,5 @@ float4 main() : sv_target
 uniform 0 float4 0.1 0.2 0.0 0.0
 uniform 4 float4 0.3 0.4 0.0 0.0
 uniform 8 float4 0.5 0.6 0.0 0.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.2, 0.3, 0.6, 0.5)
diff --git a/tests/hlsl/swizzle-matrix.shader_test b/tests/hlsl/swizzle-matrix.shader_test
index 005522759..740d4d904 100644
--- a/tests/hlsl/swizzle-matrix.shader_test
+++ b/tests/hlsl/swizzle-matrix.shader_test
@@ -9,7 +9,7 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 11 21 31 -1
 uniform 4 float4 12 22 32 -1
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (21.0, 31.0, 11.0, 12.0)

@@ -24,7 +24,7 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 11 21 31 -1
 uniform 4 float4 12 22 32 -1
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (11.0, 31.0, 12.0, 32.0)

@@ -40,7 +40,7 @@ float4 main() : sv_target
 uniform 0 float4 11 12 -1 -1
 uniform 4 float4 21 22 -1 -1
 uniform 8 float4 31 32 -1 -1
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (11.0, 31.0, 12.0, 32.0)

@@ -169,8 +169,8 @@ float4 main() : sv_target

[test]
 uniform 0 float4 20 30 40 -1
-todo draw quad
-todo probe all rgba (10.0, 20.0, 30.0, 40.0)
+todo(sm<6) draw quad
+todo(sm<6) probe all rgba (10.0, 20.0, 30.0, 40.0)

[pixel shader todo]
@@ -187,8 +187,8 @@ float4 main() : sv_target

[test]
 uniform 0 float4 20 30 80 -1
-todo draw quad
-todo probe all rgba (80.0, 30.0, 20.0, 10.0)
+todo(sm<6) draw quad
+todo(sm<6) probe all rgba (80.0, 30.0, 20.0, 10.0)

% Cannot repeat components when assigning to a swizzle.
diff --git a/tests/hlsl/swizzles.shader_test b/tests/hlsl/swizzles.shader_test
index ddfc09fc9..c3d3343f3 100644
--- a/tests/hlsl/swizzles.shader_test
+++ b/tests/hlsl/swizzles.shader_test
@@ -11,7 +11,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 0.0303 0.08 0.07 0.0202
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (0.0101, 0.0303, 0.0202, 0.0404)

@@ -149,7 +149,7 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 3.0, 4.0)

@@ -166,5 +166,5 @@ float4 main() : sv_target

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 4.0, 2.0, 3.0)
diff --git a/tests/hlsl/uniform-semantics.shader_test b/tests/hlsl/uniform-semantics.shader_test
index 86e3b83f9..1125117fe 100644
--- a/tests/hlsl/uniform-semantics.shader_test
+++ b/tests/hlsl/uniform-semantics.shader_test
@@ -10,7 +10,7 @@ float4 main() : sv_target

[test]
 uniform 0 float 3.5
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (3.5, 3.5, 3.5, 3.5)

@@ -24,5 +24,5 @@ float4 main() : sv_target

[test]
 uniform 0 float4 4.0 5.0 6.0 7.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (4.0, 5.0, 4.0, 5.0)
diff --git a/tests/hlsl/vector-indexing.shader_test b/tests/hlsl/vector-indexing.shader_test
index 71a4ca26d..9f6f9a2ca 100644
--- a/tests/hlsl/vector-indexing.shader_test
+++ b/tests/hlsl/vector-indexing.shader_test
@@ -23,7 +23,7 @@ float4 main() : SV_TARGET

[test]
 uniform 0 float4 1.0 2.0 3.0 4.0
-todo(sm>=6) draw quad
+draw quad
 probe all rgba (1.0, 2.0, 2.0, 3.0)