[PATCH v2 0/4] MR263: vkd3d-shader/spirv: Refactor the type system.

[Conor McCarthy (＠cmccarthy)]

Shader Model 6 introduces a 16-bit float (half) type, and 16-bit and 64-bit integer types. Storing extra info in the type enum simplifies checking if a type is any integer, floating point or numeric type, and the declaration of SPIR-V types. The benefits depend on using enum vkd3d_data_type in the backend instead of vkd3d_shader_component_type.

Patch 2 is difficult to split because types typically flow through to vkd3d_spirv_get_type_id(), so partial changes would require new calls to conversion functions which would be deleted again later.

--
  v2: vkd3d-shader/spirv: Use a helper function to check if a data type is floating point.
      vkd3d-shader/spirv: Use vkd3d_spirv_get_op_constant() for 64-bit types.
      vkd3d-shader/spirv: Use enum vkd3d_data_type instead of vkd3d_shader_component_type.

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

[PATCH v2 1/4] vkd3d-shader: Encode type info in enum vkd3d_data_type values.

[Conor McCarthy]

From: Conor McCarthy

Shader Model 6 introduces a 16-bit float (half) type, and 16-bit and
64-bit integer types. Storing extra info in the type enum simplifies
checking if a type is any integer, floating point or numeric type, and
the declaration of SPIR-V types.
---
 libs/vkd3d-shader/d3d_asm.c              | 38 +++++++++-------
 libs/vkd3d-shader/vkd3d_shader_private.h | 57 ++++++++++++++++++------
 2 files changed, 67 insertions(+), 28 deletions(-)

diff --git a/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d-shader/d3d_asm.c
index d72402eb..dbd764f9 100644
--- a/libs/vkd3d-shader/d3d_asm.c
+++ b/libs/vkd3d-shader/d3d_asm.c
@@ -601,19 +601,13 @@ static void shader_dump_data_type(struct vkd3d_d3d_asm_compiler *compiler, const
 {
     static const char *const data_type_names[] =
     {
-        [VKD3D_DATA_FLOAT    ] = "float",
-        [VKD3D_DATA_INT      ] = "int",
-        [VKD3D_DATA_RESOURCE ] = "resource",
-        [VKD3D_DATA_SAMPLER  ] = "sampler",
-        [VKD3D_DATA_UAV      ] = "uav",
-        [VKD3D_DATA_UINT     ] = "uint",
-        [VKD3D_DATA_UNORM    ] = "unorm",
-        [VKD3D_DATA_SNORM    ] = "snorm",
-        [VKD3D_DATA_OPAQUE   ] = "opaque",
-        [VKD3D_DATA_MIXED    ] = "mixed",
-        [VKD3D_DATA_DOUBLE   ] = "double",
-        [VKD3D_DATA_CONTINUED] = "<continued>",
-        [VKD3D_DATA_UNUSED   ] = "<unused>",
+        [VKD3D_DATA_CLASS_RESOURCE ] = "resource",
+        [VKD3D_DATA_CLASS_SAMPLER  ] = "sampler",
+        [VKD3D_DATA_CLASS_UAV      ] = "uav",
+        [VKD3D_DATA_CLASS_OPAQUE   ] = "opaque",
+        [VKD3D_DATA_CLASS_MIXED    ] = "mixed",
+        [VKD3D_DATA_CLASS_CONTINUED] = "<continued>",
+        [VKD3D_DATA_CLASS_UNUSED   ] = "<unused>",
     };
     const char *name;
     int i;
@@ -622,8 +616,22 @@ static void shader_dump_data_type(struct vkd3d_d3d_asm_compiler *compiler, const

for (i = 0; i < 4; i++)
     {
-        if (type[i] < ARRAY_SIZE(data_type_names))
-            name = data_type_names[type[i]];
+        enum vkd3d_data_type_class class = data_type_get_class(type[i]);
+        if (data_type_class_is_numeric(class))
+        {
+            switch (type[i])
+            {
+                case VKD3D_DATA_FLOAT:  name = "float"; break;
+                case VKD3D_DATA_INT:    name = "int"; break;
+                case VKD3D_DATA_UINT:   name = "uint"; break;
+                case VKD3D_DATA_UNORM:  name = "unorm"; break;
+                case VKD3D_DATA_SNORM:  name = "snorm"; break;
+                case VKD3D_DATA_DOUBLE: name = "double"; break;
+                default: vkd3d_unreachable();
+            }
+        }
+        else if (class < ARRAY_SIZE(data_type_names))
+            name = data_type_names[class];
         else
             name = "unknown";
         vkd3d_string_buffer_printf(&compiler->buffer, "%s%s", i == 0 ? "" : ",", name);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 398139c3..247d00e1 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -514,23 +514,54 @@ enum vkd3d_shader_register_precision
     VKD3D_SHADER_REGISTER_PRECISION_INVALID = ~0u,
 };

+#define DATA_TYPE_WIDTH_MASK         0xffu
+#define DATA_TYPE_CLASS_SHIFT           8u
+#define DATA_TYPE_CLASS_MASK        (0x3fu << DATA_TYPE_CLASS_SHIFT)
+#define DATA_TYPE_NORM_SHIFT           14u
+#define DATA_TYPE_NORM_MASK            (1u << DATA_TYPE_NORM_SHIFT)
+#define DATA_TYPE_IS_SIGNED_SHIFT      15u
+#define DATA_TYPE_IS_SIGNED_MASK       (1u << DATA_TYPE_IS_SIGNED_SHIFT)
+
+enum vkd3d_data_type_class
+{
+    VKD3D_DATA_CLASS_FLOAT,
+    VKD3D_DATA_CLASS_INT,
+    VKD3D_DATA_CLASS_RESOURCE,
+    VKD3D_DATA_CLASS_SAMPLER,
+    VKD3D_DATA_CLASS_UAV,
+    VKD3D_DATA_CLASS_OPAQUE,
+    VKD3D_DATA_CLASS_MIXED,
+    VKD3D_DATA_CLASS_CONTINUED,
+    VKD3D_DATA_CLASS_UNUSED,
+};
+
 enum vkd3d_data_type
 {
-    VKD3D_DATA_FLOAT,
-    VKD3D_DATA_INT,
-    VKD3D_DATA_RESOURCE,
-    VKD3D_DATA_SAMPLER,
-    VKD3D_DATA_UAV,
-    VKD3D_DATA_UINT,
-    VKD3D_DATA_UNORM,
-    VKD3D_DATA_SNORM,
-    VKD3D_DATA_OPAQUE,
-    VKD3D_DATA_MIXED,
-    VKD3D_DATA_DOUBLE,
-    VKD3D_DATA_CONTINUED,
-    VKD3D_DATA_UNUSED,
+    VKD3D_DATA_FLOAT     = (VKD3D_DATA_CLASS_FLOAT     << DATA_TYPE_CLASS_SHIFT) | 32,
+    VKD3D_DATA_INT       = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_IS_SIGNED_MASK,
+    VKD3D_DATA_RESOURCE  =  VKD3D_DATA_CLASS_RESOURCE  << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_SAMPLER   =  VKD3D_DATA_CLASS_SAMPLER   << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_UAV       =  VKD3D_DATA_CLASS_UAV       << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_UINT      = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32,
+    VKD3D_DATA_UNORM     = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK,
+    VKD3D_DATA_SNORM     = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK | DATA_TYPE_IS_SIGNED_MASK,
+    VKD3D_DATA_OPAQUE    =  VKD3D_DATA_CLASS_OPAQUE    << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_MIXED     =  VKD3D_DATA_CLASS_MIXED     << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_DOUBLE    = (VKD3D_DATA_CLASS_FLOAT     << DATA_TYPE_CLASS_SHIFT) | 64,
+    VKD3D_DATA_CONTINUED =  VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_UNUSED    =  VKD3D_DATA_CLASS_UNUSED    << DATA_TYPE_CLASS_SHIFT,
 };

+static inline bool data_type_class_is_numeric(enum vkd3d_data_type_class class)
+{
+    return class <= VKD3D_DATA_CLASS_INT;
+}
+
+static inline enum vkd3d_data_type_class data_type_get_class(enum vkd3d_data_type type)
+{
+    return (type & DATA_TYPE_CLASS_MASK) >> DATA_TYPE_CLASS_SHIFT;
+}
+
 enum vkd3d_immconst_type
 {
     VKD3D_IMMCONST_SCALAR,

[PATCH v2 2/4] vkd3d-shader/spirv: Use enum vkd3d_data_type instead of vkd3d_shader_component_type.

[Conor McCarthy]

From: Conor McCarthy

Using two different type systems is a little messy, and enum
vkd3d_data_type now has the advantage of containing numeric type info,
which simplifies introduction of 16-bit and 64-bit integers.
---
 libs/vkd3d-shader/d3dbc.c                |   2 +-
 libs/vkd3d-shader/dxbc.c                 |   6 +-
 libs/vkd3d-shader/ir.c                   |   2 +-
 libs/vkd3d-shader/spirv.c                | 565 +++++++++++------------
 libs/vkd3d-shader/vkd3d_shader_main.c    |   2 +-
 libs/vkd3d-shader/vkd3d_shader_private.h |  29 +-
 6 files changed, 299 insertions(+), 307 deletions(-)

diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c
index d2a4666a..de187be2 100644
--- a/libs/vkd3d-shader/d3dbc.c
+++ b/libs/vkd3d-shader/d3dbc.c
@@ -550,7 +550,7 @@ static bool add_signature_element(struct vkd3d_shader_sm1_parser *sm1, bool outp
     element->semantic_index = index;
     element->stream_index = 0;
     element->sysval_semantic = sysval;
-    element->component_type = VKD3D_SHADER_COMPONENT_FLOAT;
+    element->data_type = VKD3D_DATA_FLOAT;
     element->register_index = register_index;
     element->register_count = 1;
     element->mask = mask;
diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
index 3c52e332..3191dcb1 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -328,6 +328,7 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
     const char *data = section->data.code;
     uint32_t count, header_size;
     struct signature_element *e;
+    uint32_t component_type;
     const char *ptr = data;
     unsigned int i;

@@ -389,7 +390,8 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
         }
         read_dword(&ptr, &e[i].semantic_index);
         read_dword(&ptr, &e[i].sysval_semantic);
-        read_dword(&ptr, &e[i].component_type);
+        read_dword(&ptr, &component_type);
+        e[i].data_type = vkd3d_data_type_from_component_type(component_type);
         read_dword(&ptr, &e[i].register_index);
         e[i].register_count = 1;
         read_dword(&ptr, &mask);
@@ -414,7 +416,7 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s
         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,
-                e[i].component_type, e[i].register_index, e[i].used_mask, e[i].mask, e[i].min_precision);
+                component_type, e[i].register_index, e[i].used_mask, e[i].mask, e[i].min_precision);
     }

s->elements = e;
diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c
index 9eefb82c..47838834 100644
--- a/libs/vkd3d-shader/ir.c
+++ b/libs/vkd3d-shader/ir.c
@@ -334,7 +334,7 @@ static void shader_dst_param_io_init(struct vkd3d_shader_dst_param *param, const
     param->write_mask = e->mask;
     param->modifiers = 0;
     param->shift = 0;
-    shader_register_init(&param->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count);
+    shader_register_init(&param->reg, reg_type, e->data_type, idx_count);
 }

static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_point_normaliser *normaliser,
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index 3542b5fa..2bd13360 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -1710,38 +1710,34 @@ static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp(struct vkd3d_spirv_build
 }

static uint32_t vkd3d_spirv_get_type_id(struct vkd3d_spirv_builder *builder,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count)
+        enum vkd3d_data_type data_type, unsigned int component_count)
 {
-    uint32_t scalar_id;
+    uint32_t scalar_id, width = data_type_get_width(data_type);

if (component_count == 1)
     {
-        switch (component_type)
+        switch (data_type_get_class(data_type))
         {
-            case VKD3D_SHADER_COMPONENT_VOID:
+            case VKD3D_DATA_CLASS_VOID:
                 return vkd3d_spirv_get_op_type_void(builder);
                 break;
-            case VKD3D_SHADER_COMPONENT_FLOAT:
-                return vkd3d_spirv_get_op_type_float(builder, 32);
+            case VKD3D_DATA_CLASS_FLOAT:
+                return vkd3d_spirv_get_op_type_float(builder, width);
                 break;
-            case VKD3D_SHADER_COMPONENT_INT:
-            case VKD3D_SHADER_COMPONENT_UINT:
-                return vkd3d_spirv_get_op_type_int(builder, 32, component_type == VKD3D_SHADER_COMPONENT_INT);
+            case VKD3D_DATA_CLASS_INT:
+                return vkd3d_spirv_get_op_type_int(builder, width, data_type_is_signed(data_type));
                 break;
-            case VKD3D_SHADER_COMPONENT_BOOL:
+            case VKD3D_DATA_CLASS_BOOL:
                 return vkd3d_spirv_get_op_type_bool(builder);
                 break;
-            case VKD3D_SHADER_COMPONENT_DOUBLE:
-                return vkd3d_spirv_get_op_type_float(builder, 64);
             default:
-                FIXME("Unhandled component type %#x.\n", component_type);
-                return 0;
+                vkd3d_unreachable();
         }
     }
     else
     {
-        assert(component_type != VKD3D_SHADER_COMPONENT_VOID);
-        scalar_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        assert(data_type != VKD3D_DATA_VOID);
+        scalar_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         return vkd3d_spirv_get_op_type_vector(builder, scalar_id, component_count);
     }
 }
@@ -1960,7 +1956,7 @@ struct vkd3d_symbol_register_data
 {
     SpvStorageClass storage_class;
     uint32_t member_idx;
-    enum vkd3d_shader_component_type component_type;
+    enum vkd3d_data_type data_type;
     unsigned int write_mask;
     unsigned int structure_stride;
     unsigned int binding_base_idx;
@@ -1970,7 +1966,7 @@ struct vkd3d_symbol_register_data
 struct vkd3d_symbol_resource_data
 {
     struct vkd3d_shader_register_range range;
-    enum vkd3d_shader_component_type sampled_type;
+    enum vkd3d_data_type sampled_type;
     uint32_t type_id;
     const struct vkd3d_spirv_resource_type *resource_type_info;
     unsigned int structure_stride;
@@ -2069,13 +2065,13 @@ static void vkd3d_symbol_make_register(struct vkd3d_symbol *symbol,

static void vkd3d_symbol_set_register_info(struct vkd3d_symbol *symbol,
         uint32_t val_id, SpvStorageClass storage_class,
-        enum vkd3d_shader_component_type component_type, DWORD write_mask)
+        enum vkd3d_data_type data_type, DWORD write_mask)
 {
     symbol->id = val_id;
     symbol->descriptor_array = NULL;
     symbol->info.reg.storage_class = storage_class;
     symbol->info.reg.member_idx = 0;
-    symbol->info.reg.component_type = component_type;
+    symbol->info.reg.data_type = data_type;
     symbol->info.reg.write_mask = write_mask;
     symbol->info.reg.structure_stride = 0;
     symbol->info.reg.binding_base_idx = 0;
@@ -2253,7 +2249,7 @@ struct spirv_compiler
     struct vkd3d_shader_output_info
     {
         uint32_t id;
-        enum vkd3d_shader_component_type component_type;
+        enum vkd3d_data_type data_type;
         uint32_t array_element_mask;
     } *output_info;
     uint32_t private_output_variable[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */
@@ -2765,24 +2761,19 @@ static const struct vkd3d_symbol *spirv_compiler_put_symbol(struct spirv_compile
 }

static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint32_t *values)
+        enum vkd3d_data_type data_type, unsigned int component_count, const uint32_t *values)
 {
     uint32_t type_id, scalar_type_id, component_ids[VKD3D_VEC4_SIZE];
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     unsigned int i;

assert(0 < component_count && component_count <= VKD3D_VEC4_SIZE);
-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);

-    switch (component_type)
+    if (!data_type_is_numeric(data_type) || data_type_get_width(data_type) != 32)
     {
-        case VKD3D_SHADER_COMPONENT_UINT:
-        case VKD3D_SHADER_COMPONENT_INT:
-        case VKD3D_SHADER_COMPONENT_FLOAT:
-            break;
-        default:
-            FIXME("Unhandled component_type %#x.\n", component_type);
-            return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
+        FIXME("Unhandled data type %#x.\n", data_type);
+        return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
     }

if (component_count == 1)
@@ -2791,7 +2782,7 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler,
     }
     else
     {
-        scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         for (i = 0; i < component_count; ++i)
             component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, values[i]);
         return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
@@ -2799,18 +2790,18 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler,
 }

static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint64_t *values)
+        enum vkd3d_data_type data_type, unsigned int component_count, const uint64_t *values)
 {
     uint32_t type_id, scalar_type_id, component_ids[VKD3D_DVEC2_SIZE];
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     unsigned int i;

assert(0 < component_count && component_count <= VKD3D_DVEC2_SIZE);
-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);

-    if (component_type != VKD3D_SHADER_COMPONENT_DOUBLE)
+    if (data_type != VKD3D_DATA_DOUBLE)
     {
-        FIXME("Unhandled component_type %#x.\n", component_type);
+        FIXME("Unhandled data_type %#x.\n", data_type);
         return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
     }

@@ -2820,7 +2811,7 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler,
     }
     else
     {
-        scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         for (i = 0; i < component_count; ++i)
             component_ids[i] = vkd3d_spirv_get_op_constant64(builder, scalar_type_id, values[i]);
         return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
@@ -2830,41 +2821,40 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler,
 static uint32_t spirv_compiler_get_constant_uint(struct spirv_compiler *compiler,
         uint32_t value)
 {
-    return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_UINT, 1, &value);
+    return spirv_compiler_get_constant(compiler, VKD3D_DATA_UINT, 1, &value);
 }

static uint32_t spirv_compiler_get_constant_float(struct spirv_compiler *compiler,
         float value)
 {
-    return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_FLOAT, 1, (uint32_t *)&value);
+    return spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, 1, (uint32_t *)&value);
 }

static uint32_t spirv_compiler_get_constant_vector(struct spirv_compiler *compiler,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t value)
+        enum vkd3d_data_type data_type, unsigned int component_count, uint32_t value)
 {
     const uint32_t values[] = {value, value, value, value};
-    return spirv_compiler_get_constant(compiler, component_type, component_count, values);
+    return spirv_compiler_get_constant(compiler, data_type, component_count, values);
 }

static uint32_t spirv_compiler_get_constant_uint_vector(struct spirv_compiler *compiler,
         uint32_t value, unsigned int component_count)
 {
-    return spirv_compiler_get_constant_vector(compiler, VKD3D_SHADER_COMPONENT_UINT, component_count, value);
+    return spirv_compiler_get_constant_vector(compiler, VKD3D_DATA_UINT, component_count, value);
 }

static uint32_t spirv_compiler_get_constant_float_vector(struct spirv_compiler *compiler,
         float value, unsigned int component_count)
 {
     const float values[] = {value, value, value, value};
-    return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_FLOAT,
-            component_count, (const uint32_t *)values);
+    return spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, component_count, (const uint32_t *)values);
 }

static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler *compiler,
         double value, unsigned int component_count)
 {
     const double values[] = {value, value};
-    return spirv_compiler_get_constant64(compiler, VKD3D_SHADER_COMPONENT_DOUBLE,
+    return spirv_compiler_get_constant64(compiler, VKD3D_DATA_DOUBLE,
             component_count, (const uint64_t *)values);
 }

@@ -2873,9 +2863,7 @@ static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compil
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;

-    return vkd3d_spirv_get_type_id(builder,
-            vkd3d_component_type_from_data_type(reg->data_type),
-            vkd3d_write_mask_component_count(write_mask));
+    return vkd3d_spirv_get_type_id(builder, reg->data_type, vkd3d_write_mask_component_count(write_mask));
 }

static uint32_t spirv_compiler_get_type_id_for_dst(struct spirv_compiler *compiler,
@@ -2979,19 +2967,19 @@ static void spirv_compiler_emit_register_debug_name(struct vkd3d_spirv_builder *

static uint32_t spirv_compiler_emit_variable(struct spirv_compiler *compiler,
         struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count)
+        enum vkd3d_data_type data_type, unsigned int component_count)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     uint32_t type_id, ptr_type_id;

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
     ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
     return vkd3d_spirv_build_op_variable(builder, stream, ptr_type_id, storage_class, 0);
 }

static uint32_t spirv_compiler_emit_array_variable(struct spirv_compiler *compiler,
         struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count,
+        enum vkd3d_data_type data_type, unsigned int component_count,
         const unsigned int *array_lengths, unsigned int length_count)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -2999,10 +2987,9 @@ static uint32_t spirv_compiler_emit_array_variable(struct spirv_compiler *compil
     unsigned int i;

if (!length_count)
-        return spirv_compiler_emit_variable(compiler,
-                stream, storage_class, component_type, component_count);
+        return spirv_compiler_emit_variable(compiler, stream, storage_class, data_type, component_count);

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
     for (i = 0; i < length_count; ++i)
     {
         if (!array_lengths[i])
@@ -3086,7 +3073,7 @@ static uint32_t spirv_compiler_emit_spec_constant(struct spirv_compiler *compile
     info = get_spec_constant_info(name);
     default_value = info ? info->default_value : 0;

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     id = vkd3d_spirv_build_op_spec_constant(builder, type_id, default_value);
     vkd3d_spirv_build_op_decorate1(builder, id, SpvDecorationSpecId, spec_id);

@@ -3142,7 +3129,7 @@ default_parameter:
 }

static uint32_t spirv_compiler_emit_construct_vector(struct spirv_compiler *compiler,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count,
+        enum vkd3d_data_type data_type, unsigned int component_count,
         uint32_t val_id, unsigned int val_component_idx, unsigned int val_component_count)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -3152,7 +3139,7 @@ static uint32_t spirv_compiler_emit_construct_vector(struct spirv_compiler *comp

assert(val_component_idx < val_component_count);

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
     if (val_component_count == 1)
     {
         for (i = 0; i < component_count; ++i)
@@ -3185,7 +3172,7 @@ static uint32_t spirv_compiler_emit_register_addressing(struct spirv_compiler *c
     addr_id = spirv_compiler_emit_load_src(compiler, reg_index->rel_addr, VKD3DSP_WRITEMASK_0);
     if (reg_index->offset)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         addr_id = vkd3d_spirv_build_op_iadd(builder, type_id,
                 addr_id, spirv_compiler_get_constant_uint(compiler, reg_index->offset));
     }
@@ -3197,7 +3184,7 @@ struct vkd3d_shader_register_info
     uint32_t id;
     const struct vkd3d_symbol *descriptor_array;
     SpvStorageClass storage_class;
-    enum vkd3d_shader_component_type component_type;
+    enum vkd3d_data_type data_type;
     unsigned int write_mask;
     uint32_t member_idx;
     unsigned int structure_stride;
@@ -3220,7 +3207,7 @@ static bool spirv_compiler_get_register_info(const struct spirv_compiler *compil
         register_info->storage_class = SpvStorageClassFunction;
         register_info->descriptor_array = NULL;
         register_info->member_idx = 0;
-        register_info->component_type = VKD3D_SHADER_COMPONENT_FLOAT;
+        register_info->data_type = VKD3D_DATA_FLOAT;
         register_info->write_mask = VKD3DSP_WRITEMASK_ALL;
         register_info->structure_stride = 0;
         register_info->binding_base_idx = 0;
@@ -3241,7 +3228,7 @@ static bool spirv_compiler_get_register_info(const struct spirv_compiler *compil
     register_info->descriptor_array = symbol->descriptor_array;
     register_info->storage_class = symbol->info.reg.storage_class;
     register_info->member_idx = symbol->info.reg.member_idx;
-    register_info->component_type = symbol->info.reg.component_type;
+    register_info->data_type = symbol->info.reg.data_type;
     register_info->write_mask = symbol->info.reg.write_mask;
     register_info->structure_stride = symbol->info.reg.structure_stride;
     register_info->binding_base_idx = symbol->info.reg.binding_base_idx;
@@ -3330,7 +3317,7 @@ static uint32_t spirv_compiler_get_descriptor_index(struct spirv_compiler *compi
         struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
         uint32_t type_id, ptr_type_id, ptr_id, offset_id, index_ids[2];

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         if (!(offset_id = compiler->descriptor_offset_ids[push_constant_index]))
         {
             index_ids[0] = compiler->descriptor_offsets_member_id;
@@ -3397,7 +3384,7 @@ static void spirv_compiler_emit_dereference_register(struct spirv_compiler *comp
     if (index_count)
     {
         component_count = vkd3d_write_mask_component_count(register_info->write_mask);
-        type_id = vkd3d_spirv_get_type_id(builder, register_info->component_type, component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, register_info->data_type, component_count);
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, register_info->storage_class, type_id);
         register_info->id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id,
                 register_info->id, indexes, index_count);
@@ -3419,7 +3406,7 @@ static uint32_t spirv_compiler_get_register_id(struct spirv_compiler *compiler,
     }

return spirv_compiler_emit_variable(compiler, &builder->global_stream,
-            SpvStorageClassPrivate, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+            SpvStorageClassPrivate, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
 }

static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask,
@@ -3429,7 +3416,7 @@ static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask,
 }

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,
+        uint32_t val_id, unsigned int val_write_mask, enum vkd3d_data_type data_type,
         unsigned int swizzle, unsigned int write_mask)
 {
     unsigned int i, component_idx, component_count, val_component_count;
@@ -3443,7 +3430,7 @@ static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler,
             && (component_count == 1 || vkd3d_swizzle_is_equal(val_write_mask, swizzle, write_mask)))
         return val_id;

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);

if (component_count == 1)
     {
@@ -3477,7 +3464,7 @@ static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler,

static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compiler,
         uint32_t vector1_id, uint32_t vector2_id, unsigned int swizzle, unsigned int write_mask,
-        enum vkd3d_shader_component_type component_type, unsigned int component_count)
+        enum vkd3d_data_type data_type, unsigned int component_count)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     uint32_t components[VKD3D_VEC4_SIZE];
@@ -3494,7 +3481,7 @@ static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compil
             components[i] = VKD3D_VEC4_SIZE + vkd3d_swizzle_get_component(swizzle, i);
     }

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
     return vkd3d_spirv_build_op_vector_shuffle(builder,
             type_id, vector1_id, vector2_id, components, component_count);
 }
@@ -3522,8 +3509,7 @@ static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compile
         }
     }

-    return spirv_compiler_get_constant(compiler,
-            vkd3d_component_type_from_data_type(reg->data_type), component_count, values);
+    return spirv_compiler_get_constant(compiler, reg->data_type, component_count, values);
 }

static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compiler,
@@ -3549,8 +3535,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi
         }
     }

-    return spirv_compiler_get_constant64(compiler,
-            vkd3d_component_type_from_data_type(reg->data_type), component_count, values);
+    return spirv_compiler_get_constant64(compiler, reg->data_type, component_count, values);
 }

static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
@@ -3560,8 +3545,8 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     uint32_t type_id, ptr_type_id, index, reg_id, val_id;
     unsigned int component_idx, reg_component_count;
-    enum vkd3d_shader_component_type component_type;
     unsigned int skipped_component_mask;
+    enum vkd3d_data_type data_type;

assert(reg->type != VKD3DSPR_IMMCONST && reg->type != VKD3DSPR_IMMCONST64);
     assert(vkd3d_write_mask_component_count(write_mask) == 1);
@@ -3571,7 +3556,7 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
     skipped_component_mask = ~reg_info->write_mask & ((VKD3DSP_WRITEMASK_0 << component_idx) - 1);
     if (skipped_component_mask)
         component_idx -= vkd3d_write_mask_component_count(skipped_component_mask);
-    component_type = vkd3d_component_type_from_data_type(reg->data_type);
+    data_type = reg->data_type;

reg_component_count = vkd3d_write_mask_component_count(reg_info->write_mask);

@@ -3581,7 +3566,7 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
                 component_idx, reg->type, reg->idx[0].offset, reg_info->write_mask);
     }

-    type_id = vkd3d_spirv_get_type_id(builder, reg_info->component_type, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, reg_info->data_type, 1);
     reg_id = reg_info->id;
     if (reg_component_count != 1)
     {
@@ -3592,9 +3577,9 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,

val_id = vkd3d_spirv_build_op_load(builder, type_id, reg_id, SpvMemoryAccessMaskNone);

-    if (component_type != reg_info->component_type)
+    if (data_type != reg_info->data_type)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
     }

@@ -3605,8 +3590,8 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler,
         const struct vkd3d_shader_register *reg, DWORD swizzle, DWORD write_mask)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    enum vkd3d_shader_component_type component_type;
     struct vkd3d_shader_register_info reg_info;
+    enum vkd3d_data_type data_type;
     unsigned int component_count;
     unsigned int write_mask32;
     uint32_t type_id, val_id;
@@ -3617,13 +3602,13 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler,
         return spirv_compiler_emit_load_constant64(compiler, reg, swizzle, write_mask);

component_count = vkd3d_write_mask_component_count(write_mask);
-    component_type = vkd3d_component_type_from_data_type(reg->data_type);
+    data_type = reg->data_type;
     if (!spirv_compiler_get_register_info(compiler, reg, &reg_info))
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
         return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
     }
-    assert(reg_info.component_type != VKD3D_SHADER_COMPONENT_DOUBLE);
+    assert(reg_info.data_type != VKD3D_DATA_DOUBLE);
     spirv_compiler_emit_dereference_register(compiler, reg, &reg_info);

write_mask32 = (reg->data_type == VKD3D_DATA_DOUBLE) ? vkd3d_write_mask_32_from_64(write_mask) : write_mask;
@@ -3640,16 +3625,16 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler,
     else
     {
         type_id = vkd3d_spirv_get_type_id(builder,
-                reg_info.component_type, vkd3d_write_mask_component_count(reg_info.write_mask));
+                reg_info.data_type, vkd3d_write_mask_component_count(reg_info.write_mask));
         val_id = vkd3d_spirv_build_op_load(builder, type_id, reg_info.id, SpvMemoryAccessMaskNone);
     }

val_id = spirv_compiler_emit_swizzle(compiler,
-            val_id, reg_info.write_mask, reg_info.component_type, swizzle, write_mask32);
+            val_id, reg_info.write_mask, reg_info.data_type, swizzle, write_mask32);

-    if (component_type != reg_info.component_type)
+    if (data_type != reg_info.data_type)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
     }

@@ -3734,16 +3719,16 @@ static uint32_t spirv_compiler_emit_load_src(struct spirv_compiler *compiler,
 }

static uint32_t spirv_compiler_emit_load_src_with_type(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_src_param *src, DWORD write_mask, enum vkd3d_shader_component_type component_type)
+        const struct vkd3d_shader_src_param *src, DWORD write_mask, enum vkd3d_data_type data_type)
 {
     struct vkd3d_shader_src_param src_param = *src;

-    src_param.reg.data_type = vkd3d_data_type_from_component_type(component_type);
+    src_param.reg.data_type = data_type;
     return spirv_compiler_emit_load_src(compiler, &src_param, write_mask);
 }

static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler,
-        uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_shader_component_type component_type,
+        uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_data_type data_type,
         SpvStorageClass storage_class, unsigned int write_mask, uint32_t val_id)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -3752,7 +3737,7 @@ static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler,

if (vkd3d_write_mask_component_count(dst_write_mask) > 1)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
         component_idx = vkd3d_write_mask_get_component_idx(write_mask);
         component_idx -= vkd3d_write_mask_get_component_idx(dst_write_mask);
@@ -3764,7 +3749,7 @@ static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler,
 }

static void spirv_compiler_emit_store(struct spirv_compiler *compiler,
-        uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_shader_component_type component_type,
+        uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_data_type data_type,
         SpvStorageClass storage_class, unsigned int write_mask, uint32_t val_id)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -3780,7 +3765,7 @@ static void spirv_compiler_emit_store(struct spirv_compiler *compiler,

if (dst_component_count == 1 && component_count != 1)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
         val_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id,
                 vkd3d_write_mask_get_component_idx(dst_write_mask));
         write_mask &= dst_write_mask;
@@ -3790,12 +3775,12 @@ static void spirv_compiler_emit_store(struct spirv_compiler *compiler,
     if (component_count == 1)
     {
         return spirv_compiler_emit_store_scalar(compiler,
-                dst_id, dst_write_mask, component_type, storage_class, write_mask, val_id);
+                dst_id, dst_write_mask, data_type, storage_class, write_mask, val_id);
     }

if (dst_component_count != component_count)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, dst_component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, dst_component_count);
         dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);

assert(component_count <= ARRAY_SIZE(components));
@@ -3822,9 +3807,9 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler,
         const struct vkd3d_shader_register *reg, unsigned int write_mask, uint32_t val_id)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    enum vkd3d_shader_component_type component_type;
     struct vkd3d_shader_register_info reg_info;
     unsigned int src_write_mask = write_mask;
+    enum vkd3d_data_type data_type;
     uint32_t type_id;

assert(reg->type != VKD3DSPR_IMMCONST && reg->type != VKD3DSPR_IMMCONST64);
@@ -3833,19 +3818,19 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler,
         return;
     spirv_compiler_emit_dereference_register(compiler, reg, &reg_info);

-    component_type = vkd3d_component_type_from_data_type(reg->data_type);
-    if (component_type != reg_info.component_type)
+    data_type = reg->data_type;
+    if (data_type != reg_info.data_type)
     {
         if (reg->data_type == VKD3D_DATA_DOUBLE)
             src_write_mask = vkd3d_write_mask_32_from_64(write_mask);
-        type_id = vkd3d_spirv_get_type_id(builder, reg_info.component_type,
+        type_id = vkd3d_spirv_get_type_id(builder, reg_info.data_type,
                 vkd3d_write_mask_component_count(src_write_mask));
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
-        component_type = reg_info.component_type;
+        data_type = reg_info.data_type;
     }

spirv_compiler_emit_store(compiler,
-            reg_info.id, reg_info.write_mask, component_type, reg_info.storage_class, src_write_mask, val_id);
+            reg_info.id, reg_info.write_mask, data_type, reg_info.storage_class, src_write_mask, val_id);
 }

static uint32_t spirv_compiler_emit_sat(struct spirv_compiler *compiler,
@@ -3886,21 +3871,20 @@ static void spirv_compiler_emit_store_dst(struct spirv_compiler *compiler,

static void spirv_compiler_emit_store_dst_swizzled(struct spirv_compiler *compiler,
         const struct vkd3d_shader_dst_param *dst, uint32_t val_id,
-        enum vkd3d_shader_component_type component_type, DWORD swizzle)
+        enum vkd3d_data_type data_type, DWORD swizzle)
 {
     struct vkd3d_shader_dst_param typed_dst = *dst;
     val_id = spirv_compiler_emit_swizzle(compiler,
-            val_id, VKD3DSP_WRITEMASK_ALL, component_type, swizzle, dst->write_mask);
+            val_id, VKD3DSP_WRITEMASK_ALL, data_type, swizzle, dst->write_mask);
     /* XXX: The register data type could be fixed by the shader parser. For SM5
      * shaders the data types are stored in instructions modifiers.
      */
-    typed_dst.reg.data_type = vkd3d_data_type_from_component_type(component_type);
+    typed_dst.reg.data_type = data_type;
     spirv_compiler_emit_store_dst(compiler, &typed_dst, val_id);
 }

static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *compiler,
-        const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_component_type component_type,
-        uint32_t *component_ids)
+        const struct vkd3d_shader_dst_param *dst, enum vkd3d_data_type data_type, uint32_t *component_ids)
 {
     unsigned int component_count = vkd3d_write_mask_component_count(dst->write_mask);
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -3908,7 +3892,7 @@ static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *comp

if (component_count > 1)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
         val_id = vkd3d_spirv_build_op_composite_construct(builder,
                 type_id, component_ids, component_count);
     }
@@ -3921,7 +3905,7 @@ static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *comp

static void spirv_compiler_emit_store_dst_scalar(struct spirv_compiler *compiler,
         const struct vkd3d_shader_dst_param *dst, uint32_t val_id,
-        enum vkd3d_shader_component_type component_type, DWORD swizzle)
+        enum vkd3d_data_type data_type, DWORD swizzle)
 {
     unsigned int component_count = vkd3d_write_mask_component_count(dst->write_mask);
     uint32_t component_ids[VKD3D_VEC4_SIZE];
@@ -3935,7 +3919,7 @@ static void spirv_compiler_emit_store_dst_scalar(struct spirv_compiler *compiler

component_ids[i] = val_id;
     }
-    spirv_compiler_emit_store_dst_components(compiler, dst, component_type, component_ids);
+    spirv_compiler_emit_store_dst_components(compiler, dst, data_type, component_ids);
 }

static void spirv_compiler_decorate_builtin(struct spirv_compiler *compiler,
@@ -4013,7 +3997,7 @@ static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler,

assert(!(condition & ~(VKD3D_SHADER_CONDITIONAL_OP_NZ | VKD3D_SHADER_CONDITIONAL_OP_Z)));

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, component_count);
     op = condition & VKD3D_SHADER_CONDITIONAL_OP_Z ? SpvOpIEqual : SpvOpINotEqual;
     return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, val_id,
             spirv_compiler_get_constant_uint_vector(compiler, 0, component_count));
@@ -4027,7 +4011,7 @@ static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler,

true_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count);
     false_id = spirv_compiler_get_constant_uint_vector(compiler, 0, component_count);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, component_count);
     return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id);
 }

@@ -4043,11 +4027,11 @@ static uint32_t spirv_compiler_emit_draw_parameter_fixup(struct spirv_compiler *
     vkd3d_spirv_enable_capability(builder, SpvCapabilityDrawParameters);

base_var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream,
-            SpvStorageClassInput, VKD3D_SHADER_COMPONENT_INT, 1);
+            SpvStorageClassInput, VKD3D_DATA_INT, 1);
     vkd3d_spirv_add_iface_variable(builder, base_var_id);
     spirv_compiler_decorate_builtin(compiler, base_var_id, base);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, 1);
     base_id = vkd3d_spirv_build_op_load(builder,
             type_id, base_var_id, SpvMemoryAccessMaskNone);

@@ -4083,17 +4067,17 @@ static uint32_t frag_coord_fixup(struct spirv_compiler *compiler,
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     uint32_t type_id, w_id;

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 1);
     w_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, frag_coord_id, 3);
     w_id = vkd3d_spirv_build_op_fdiv(builder, type_id,
             spirv_compiler_get_constant_float(compiler, 1.0f), w_id);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     return vkd3d_spirv_build_op_composite_insert1(builder, type_id, w_id, frag_coord_id, 3);
 }

struct vkd3d_spirv_builtin
 {
-    enum vkd3d_shader_component_type component_type;
+    enum vkd3d_data_type data_type;
     unsigned int component_count;
     SpvBuiltIn spirv_builtin;
     vkd3d_spirv_builtin_fixup_pfn fixup_pfn;
@@ -4113,45 +4097,43 @@ static const struct
 }
 vkd3d_system_value_builtins[] =
 {
-    {VKD3D_SIV_VERTEX_ID,   {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexId},
-            VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5},
-    {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceId},
-            VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5},
+    {VKD3D_SIV_VERTEX_ID,   {VKD3D_DATA_INT, 1, SpvBuiltInVertexId},   VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5},
+    {VKD3D_SIV_INSTANCE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInInstanceId}, VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5},

-    {VKD3D_SIV_POSITION,    {VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInPosition}},
-    {VKD3D_SIV_VERTEX_ID,   {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}},
-    {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}},
+    {VKD3D_SIV_POSITION,    {VKD3D_DATA_FLOAT, 4, SpvBuiltInPosition}},
+    {VKD3D_SIV_VERTEX_ID,   {VKD3D_DATA_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}},
+    {VKD3D_SIV_INSTANCE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}},

-    {VKD3D_SIV_PRIMITIVE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}},
+    {VKD3D_SIV_PRIMITIVE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInPrimitiveId}},

-    {VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLayer}},
-    {VKD3D_SIV_VIEWPORT_ARRAY_INDEX,      {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInViewportIndex}},
+    {VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_DATA_INT, 1, SpvBuiltInLayer}},
+    {VKD3D_SIV_VIEWPORT_ARRAY_INDEX,      {VKD3D_DATA_INT, 1, SpvBuiltInViewportIndex}},

-    {VKD3D_SIV_IS_FRONT_FACE, {VKD3D_SHADER_COMPONENT_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}},
+    {VKD3D_SIV_IS_FRONT_FACE, {VKD3D_DATA_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}},

-    {VKD3D_SIV_SAMPLE_INDEX, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleId}},
+    {VKD3D_SIV_SAMPLE_INDEX, {VKD3D_DATA_UINT, 1, SpvBuiltInSampleId}},

-    {VKD3D_SIV_CLIP_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}},
-    {VKD3D_SIV_CULL_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}},
+    {VKD3D_SIV_CLIP_DISTANCE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}},
+    {VKD3D_SIV_CULL_DISTANCE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}},

-    {VKD3D_SIV_QUAD_U0_TESS_FACTOR,      {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
-    {VKD3D_SIV_QUAD_V0_TESS_FACTOR,      {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
-    {VKD3D_SIV_QUAD_U1_TESS_FACTOR,      {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}},
-    {VKD3D_SIV_QUAD_V1_TESS_FACTOR,      {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 3}},
-    {VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}},
-    {VKD3D_SIV_QUAD_V_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 1}},
+    {VKD3D_SIV_QUAD_U0_TESS_FACTOR,      {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
+    {VKD3D_SIV_QUAD_V0_TESS_FACTOR,      {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
+    {VKD3D_SIV_QUAD_U1_TESS_FACTOR,      {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}},
+    {VKD3D_SIV_QUAD_V1_TESS_FACTOR,      {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 3}},
+    {VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}},
+    {VKD3D_SIV_QUAD_V_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 1}},

-    {VKD3D_SIV_TRIANGLE_U_TESS_FACTOR,     {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
-    {VKD3D_SIV_TRIANGLE_V_TESS_FACTOR,     {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
-    {VKD3D_SIV_TRIANGLE_W_TESS_FACTOR,     {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}},
-    {VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}},
+    {VKD3D_SIV_TRIANGLE_U_TESS_FACTOR,     {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
+    {VKD3D_SIV_TRIANGLE_V_TESS_FACTOR,     {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
+    {VKD3D_SIV_TRIANGLE_W_TESS_FACTOR,     {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}},
+    {VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}},

-    {VKD3D_SIV_LINE_DENSITY_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
-    {VKD3D_SIV_LINE_DETAIL_TESS_FACTOR,  {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
+    {VKD3D_SIV_LINE_DENSITY_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}},
+    {VKD3D_SIV_LINE_DETAIL_TESS_FACTOR,  {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}},
 };
 static const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin =
 {
-    VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInFragCoord, frag_coord_fixup,
+    VKD3D_DATA_FLOAT, 4, SpvBuiltInFragCoord, frag_coord_fixup,
 };
 static const struct
 {
@@ -4160,26 +4142,26 @@ static const struct
 }
 vkd3d_register_builtins[] =
 {
-    {VKD3DSPR_THREADID,         {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInGlobalInvocationId}},
-    {VKD3DSPR_LOCALTHREADID,    {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInLocalInvocationId}},
-    {VKD3DSPR_LOCALTHREADINDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLocalInvocationIndex}},
-    {VKD3DSPR_THREADGROUPID,    {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInWorkgroupId}},
+    {VKD3DSPR_THREADID,         {VKD3D_DATA_INT, 3, SpvBuiltInGlobalInvocationId}},
+    {VKD3DSPR_LOCALTHREADID,    {VKD3D_DATA_INT, 3, SpvBuiltInLocalInvocationId}},
+    {VKD3DSPR_LOCALTHREADINDEX, {VKD3D_DATA_INT, 1, SpvBuiltInLocalInvocationIndex}},
+    {VKD3DSPR_THREADGROUPID,    {VKD3D_DATA_INT, 3, SpvBuiltInWorkgroupId}},

-    {VKD3DSPR_GSINSTID,         {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInvocationId}},
-    {VKD3DSPR_OUTPOINTID,       {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInvocationId}},
+    {VKD3DSPR_GSINSTID,         {VKD3D_DATA_INT, 1, SpvBuiltInInvocationId}},
+    {VKD3DSPR_OUTPOINTID,       {VKD3D_DATA_INT, 1, SpvBuiltInInvocationId}},

-    {VKD3DSPR_PRIMID,           {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}},
+    {VKD3DSPR_PRIMID,           {VKD3D_DATA_INT, 1, SpvBuiltInPrimitiveId}},

-    {VKD3DSPR_TESSCOORD,        {VKD3D_SHADER_COMPONENT_FLOAT, 3, SpvBuiltInTessCoord}},
+    {VKD3DSPR_TESSCOORD,        {VKD3D_DATA_FLOAT, 3, SpvBuiltInTessCoord}},

-    {VKD3DSPR_COVERAGE,         {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleMask, NULL, 1}},
-    {VKD3DSPR_SAMPLEMASK,       {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleMask, NULL, 1}},
+    {VKD3DSPR_COVERAGE,         {VKD3D_DATA_UINT, 1, SpvBuiltInSampleMask, NULL, 1}},
+    {VKD3DSPR_SAMPLEMASK,       {VKD3D_DATA_UINT, 1, SpvBuiltInSampleMask, NULL, 1}},

-    {VKD3DSPR_DEPTHOUT,         {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}},
-    {VKD3DSPR_DEPTHOUTGE,       {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}},
-    {VKD3DSPR_DEPTHOUTLE,       {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}},
+    {VKD3DSPR_DEPTHOUT,         {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}},
+    {VKD3DSPR_DEPTHOUTGE,       {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}},
+    {VKD3DSPR_DEPTHOUTLE,       {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}},

-    {VKD3DSPR_OUTSTENCILREF,    {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInFragStencilRefEXT}},
+    {VKD3DSPR_OUTSTENCILREF,    {VKD3D_DATA_UINT, 1, SpvBuiltInFragStencilRefEXT}},
 };

static void spirv_compiler_emit_register_execution_mode(struct spirv_compiler *compiler,
@@ -4287,7 +4269,7 @@ static uint32_t spirv_compiler_emit_load_invocation_id(struct spirv_compiler *co
     uint32_t type_id, id;

id = spirv_compiler_get_invocation_id(compiler);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, 1);
     return vkd3d_spirv_build_op_load(builder, type_id, id, SpvMemoryAccessMaskNone);
 }

@@ -4401,13 +4383,12 @@ static uint32_t spirv_compiler_emit_builtin_variable_v(struct spirv_compiler *co
     sizes[0] = max(sizes[0], builtin->spirv_array_size);

id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, storage_class,
-            builtin->component_type, builtin->component_count, array_sizes, size_count);
+            builtin->data_type, builtin->component_count, array_sizes, size_count);
     vkd3d_spirv_add_iface_variable(builder, id);
     spirv_compiler_decorate_builtin(compiler, id, builtin->spirv_builtin);

if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL && storage_class == SpvStorageClassInput
-            && builtin->component_type != VKD3D_SHADER_COMPONENT_FLOAT
-            && builtin->component_type != VKD3D_SHADER_COMPONENT_BOOL)
+            && builtin->data_type != VKD3D_DATA_FLOAT && builtin->data_type != VKD3D_DATA_BOOL)
         vkd3d_spirv_build_op_decorate(builder, id, SpvDecorationFlat, NULL, 0);

return id;
@@ -4463,13 +4444,13 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
     unsigned int component_idx, input_component_count;
     const struct signature_element *signature_element;
     const struct shader_signature *shader_signature;
-    enum vkd3d_shader_component_type component_type;
     uint32_t type_id, ptr_type_id, float_type_id;
     const struct vkd3d_spirv_builtin *builtin;
     unsigned int write_mask, reg_write_mask;
     struct vkd3d_symbol *symbol = NULL;
     uint32_t val_id, input_id, var_id;
     struct vkd3d_symbol reg_symbol;
+    enum vkd3d_data_type data_type;
     SpvStorageClass storage_class;
     struct rb_entry *entry = NULL;
     bool use_private_var = false;
@@ -4496,13 +4477,13 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,

if (builtin)
     {
-        component_type = builtin->component_type;
+        data_type = builtin->data_type;
         input_component_count = builtin->component_count;
         component_idx = 0;
     }
     else
     {
-        component_type = signature_element->component_type;
+        data_type = signature_element->data_type;
         input_component_count = vkd3d_write_mask_component_count(signature_element->mask);
         component_idx = vkd3d_write_mask_get_component_idx(signature_element->mask);
     }
@@ -4545,7 +4526,7 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
         unsigned int location = signature_element->register_index;

input_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
-                storage_class, component_type, input_component_count, array_sizes, 2);
+                storage_class, data_type, input_component_count, array_sizes, 2);
         vkd3d_spirv_add_iface_variable(builder, input_id);
         if (reg->type == VKD3DSPR_PATCHCONST)
         {
@@ -4564,11 +4545,11 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
     {
         storage_class = SpvStorageClassPrivate;
         var_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
-                storage_class, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, array_sizes, 2);
+                storage_class, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, array_sizes, 2);
     }

vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-            use_private_var ? VKD3D_SHADER_COMPONENT_FLOAT : component_type,
+            use_private_var ? VKD3D_DATA_FLOAT : data_type,
             use_private_var ? VKD3DSP_WRITEMASK_ALL : reg_write_mask);
     reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1];
     assert(!builtin || !builtin->spirv_array_size || use_private_var || array_sizes[0] || array_sizes[1]);
@@ -4578,7 +4559,7 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,

if (use_private_var)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, input_component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, input_component_count);
         for (i = 0; i < max(array_sizes[0], 1); ++i)
         {
             struct vkd3d_shader_register dst_reg = *reg;
@@ -4607,15 +4588,15 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
             if (builtin && builtin->fixup_pfn)
                 val_id = builtin->fixup_pfn(compiler, val_id);

-            if (component_type != VKD3D_SHADER_COMPONENT_FLOAT)
+            if (data_type != VKD3D_DATA_FLOAT)
             {
-                float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, input_component_count);
+                float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, input_component_count);
                 val_id = vkd3d_spirv_build_op_bitcast(builder, float_type_id, val_id);
             }

val_id = spirv_compiler_emit_swizzle(compiler, val_id,
                     vkd3d_write_mask_from_component_count(input_component_count),
-                    VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx);
+                    VKD3D_DATA_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx);

spirv_compiler_emit_store_reg(compiler, &dst_reg, dst->write_mask, val_id);
         }
@@ -4652,8 +4633,7 @@ static void spirv_compiler_emit_input_register(struct spirv_compiler *compiler,
     input_id = spirv_compiler_emit_builtin_variable(compiler, builtin, SpvStorageClassInput, 0);

write_mask = vkd3d_write_mask_from_component_count(builtin->component_count);
-    vkd3d_symbol_set_register_info(&reg_symbol, input_id,
-            SpvStorageClassInput, builtin->component_type, write_mask);
+    vkd3d_symbol_set_register_info(&reg_symbol, input_id, SpvStorageClassInput, builtin->data_type, write_mask);
     reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size;
     spirv_compiler_put_symbol(compiler, &reg_symbol);
     spirv_compiler_emit_register_debug_name(builder, input_id, reg);
@@ -4765,13 +4745,13 @@ static void spirv_compiler_emit_shader_signature_outputs(struct spirv_compiler *
         {
             case VKD3D_SHADER_SV_CLIP_DISTANCE:
                 compiler->output_info[i].id = clip_distance_id;
-                compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT;
+                compiler->output_info[i].data_type = VKD3D_DATA_FLOAT;
                 compiler->output_info[i].array_element_mask = clip_distance_mask;
                 break;

case VKD3D_SHADER_SV_CULL_DISTANCE:
                 compiler->output_info[i].id = cull_distance_id;
-                compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT;
+                compiler->output_info[i].data_type = VKD3D_DATA_FLOAT;
                 compiler->output_info[i].array_element_mask = cull_distance_mask;
                 break;

@@ -4804,8 +4784,7 @@ static void spirv_compiler_emit_output_register(struct spirv_compiler *compiler,

vkd3d_symbol_make_register(&reg_symbol, reg);
     write_mask = vkd3d_write_mask_from_component_count(builtin->component_count);
-    vkd3d_symbol_set_register_info(&reg_symbol, output_id,
-            SpvStorageClassOutput, builtin->component_type, write_mask);
+    vkd3d_symbol_set_register_info(&reg_symbol, output_id, SpvStorageClassOutput, builtin->data_type, write_mask);
     reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size;
     spirv_compiler_put_symbol(compiler, &reg_symbol);
     spirv_compiler_emit_register_execution_mode(compiler, reg);
@@ -4844,11 +4823,11 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
     const struct vkd3d_shader_register *reg = &dst->reg;
     unsigned int component_idx, output_component_count;
     const struct signature_element *signature_element;
-    enum vkd3d_shader_component_type component_type;
     const struct shader_signature *shader_signature;
     const struct vkd3d_spirv_builtin *builtin;
     unsigned int write_mask, reg_write_mask;
     bool use_private_variable = false;
+    enum vkd3d_data_type data_type;
     struct vkd3d_symbol reg_symbol;
     SpvStorageClass storage_class;
     unsigned int array_sizes[2];
@@ -4871,14 +4850,14 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
     output_component_count = vkd3d_write_mask_component_count(write_mask);
     if (builtin)
     {
-        component_type = builtin->component_type;
+        data_type = builtin->data_type;
         if (!builtin->spirv_array_size)
             output_component_count = builtin->component_count;
         component_idx = 0;
     }
     else
     {
-        component_type = signature_element->component_type;
+        data_type = signature_element->data_type;
     }

storage_class = SpvStorageClassOutput;
@@ -4926,7 +4905,7 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
             location += shader_signature_next_location(&compiler->output_signature);

id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
-                storage_class, component_type, output_component_count, array_sizes, 2);
+                storage_class, data_type, output_component_count, array_sizes, 2);
         vkd3d_spirv_add_iface_variable(builder, id);

if (is_dual_source_blending(compiler) && signature_element->register_index < 2)
@@ -4949,18 +4928,18 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler,
     spirv_compiler_decorate_xfb_output(compiler, id, output_component_count, signature_element);

compiler->output_info[element_idx].id = id;
-    compiler->output_info[element_idx].component_type = component_type;
+    compiler->output_info[element_idx].data_type = data_type;

var_id = id;
     if (use_private_variable)
     {
         storage_class = SpvStorageClassPrivate;
         var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream,
-                storage_class, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+                storage_class, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     }

vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-            use_private_variable ? VKD3D_SHADER_COMPONENT_FLOAT : component_type,
+            use_private_variable ? VKD3D_DATA_FLOAT : data_type,
             use_private_variable ? VKD3DSP_WRITEMASK_ALL : reg_write_mask);
     reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1];
     assert(!builtin || !builtin->spirv_array_size || use_private_variable || array_sizes[0] || array_sizes[1]);
@@ -5033,9 +5012,9 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi
     if (!write_mask)
         return;

-    if (output_info->component_type != VKD3D_SHADER_COMPONENT_FLOAT)
+    if (output_info->data_type != VKD3D_DATA_FLOAT)
     {
-        type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, VKD3D_VEC4_SIZE);
+        type_id = vkd3d_spirv_get_type_id(builder, output_info->data_type, VKD3D_VEC4_SIZE);
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
     }

@@ -5045,23 +5024,22 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi
     {
         /* Set values to 0 for not initialized shader output components. */
         write_mask |= uninit_mask;
-        zero_id = spirv_compiler_get_constant_vector(compiler,
-                output_info->component_type, VKD3D_VEC4_SIZE, 0);
+        zero_id = spirv_compiler_get_constant_vector(compiler, output_info->data_type, VKD3D_VEC4_SIZE, 0);
         val_id = spirv_compiler_emit_vector_shuffle(compiler,
-                zero_id, val_id, swizzle, uninit_mask, output_info->component_type,
+                zero_id, val_id, swizzle, uninit_mask, output_info->data_type,
                 vkd3d_write_mask_component_count(write_mask));
     }
     else
     {
         val_id = spirv_compiler_emit_swizzle(compiler,
-                val_id, VKD3DSP_WRITEMASK_ALL, output_info->component_type, swizzle, write_mask);
+                val_id, VKD3DSP_WRITEMASK_ALL, output_info->data_type, swizzle, write_mask);
     }

output_id = output_info->id;
     if (output_index_id)
     {
         type_id = vkd3d_spirv_get_type_id(builder,
-                output_info->component_type, vkd3d_write_mask_component_count(dst_write_mask));
+                output_info->data_type, vkd3d_write_mask_component_count(dst_write_mask));
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id);
         output_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, output_id, output_index_id);
     }
@@ -5069,11 +5047,11 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi
     if (!output_info->array_element_mask)
     {
         spirv_compiler_emit_store(compiler,
-                output_id, dst_write_mask, output_info->component_type, SpvStorageClassOutput, write_mask, val_id);
+                output_id, dst_write_mask, output_info->data_type, SpvStorageClassOutput, write_mask, val_id);
         return;
     }

-    type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, output_info->data_type, 1);
     ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id);
     mask = output_info->array_element_mask;
     array_idx = spirv_compiler_get_output_array_index(compiler, output);
@@ -5086,9 +5064,9 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi
         chain_id = vkd3d_spirv_build_op_access_chain1(builder,
                 ptr_type_id, output_id, spirv_compiler_get_constant_uint(compiler, index));
         object_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask,
-                output_info->component_type, VKD3D_SHADER_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i);
+                output_info->data_type, VKD3D_SHADER_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i);
         spirv_compiler_emit_store(compiler, chain_id, VKD3DSP_WRITEMASK_0,
-                output_info->component_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id);
+                output_info->data_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id);
         ++index;
     }
 }
@@ -5115,7 +5093,7 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler *
     function_id = compiler->epilogue_function_id;

void_id = vkd3d_spirv_get_op_type_void(builder);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 4);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 4);
     ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id);
     for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
     {
@@ -5274,7 +5252,7 @@ static void spirv_compiler_emit_dcl_temps(struct spirv_compiler *compiler,
     for (i = 0; i < compiler->temp_count; ++i)
     {
         id = spirv_compiler_emit_variable(compiler, &builder->function_stream,
-                SpvStorageClassFunction, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+                SpvStorageClassFunction, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
         if (!i)
             compiler->temp_id = id;
         assert(id == compiler->temp_id + i);
@@ -5308,7 +5286,7 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil
     vkd3d_spirv_begin_function_stream_insertion(builder, function_location);

id = spirv_compiler_emit_array_variable(compiler, &builder->function_stream,
-            SpvStorageClassFunction, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, &temp->register_size, 1);
+            SpvStorageClassFunction, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, &temp->register_size, 1);

spirv_compiler_emit_register_debug_name(builder, id, &reg);

@@ -5316,7 +5294,7 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil

vkd3d_symbol_make_register(&reg_symbol, &reg);
     vkd3d_symbol_set_register_info(&reg_symbol, id,
-            SpvStorageClassFunction, VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL);
+            SpvStorageClassFunction, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL);
     spirv_compiler_put_symbol(compiler, &reg_symbol);
 }

@@ -5343,7 +5321,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com
     if (!(member_ids = vkd3d_calloc(count, sizeof(*member_ids))))
         return;

-    vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+    vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);

for (i = 0, j = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
     {
@@ -5360,7 +5338,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com

if (compiler->offset_info.descriptor_table_count)
     {
-        uint32_t type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        uint32_t type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         length_id = spirv_compiler_get_constant_uint(compiler, compiler->offset_info.descriptor_table_count);
         member_ids[j] = vkd3d_spirv_build_op_type_array(builder, type_id, length_id);
         vkd3d_spirv_build_op_decorate1(builder, member_ids[j], SpvDecorationArrayStride, 4);
@@ -5392,7 +5370,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com

vkd3d_symbol_make_register(&reg_symbol, &cb->reg);
         vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-                VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL);
+                VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL);
         reg_symbol.info.reg.member_idx = j;
         spirv_compiler_put_symbol(compiler, &reg_symbol);

@@ -5503,7 +5481,7 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi
         return;
     }

-    vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+    vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     length_id = spirv_compiler_get_constant_uint(compiler, cb->size);
     array_type_id = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id);
     vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 16);
@@ -5517,8 +5495,7 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi
             reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, false, &var_info);

vkd3d_symbol_make_register(&reg_symbol, reg);
-    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-            VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL);
+    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL);
     reg_symbol.descriptor_array = var_info.array_symbol;
     reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx;
     spirv_compiler_put_symbol(compiler, &reg_symbol);
@@ -5537,9 +5514,8 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi
     if (!(elements = vkd3d_calloc(icb->vec4_count, sizeof(*elements))))
         return;
     for (i = 0; i < icb->vec4_count; ++i)
-        elements[i] = spirv_compiler_get_constant(compiler,
-                VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, &icb->data[4 * i]);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+        elements[i] = spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, &icb->data[4 * i]);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     length_id = spirv_compiler_get_constant_uint(compiler, icb->vec4_count);
     type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
     const_id = vkd3d_spirv_build_op_constant_composite(builder, type_id, elements, icb->vec4_count);
@@ -5553,7 +5529,7 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi
     reg.type = VKD3DSPR_IMMCONSTBUFFER;
     vkd3d_symbol_make_register(&reg_symbol, &reg);
     vkd3d_symbol_set_register_info(&reg_symbol, icb_id, SpvStorageClassPrivate,
-            VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL);
+            VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL);
     spirv_compiler_put_symbol(compiler, &reg_symbol);
 }

@@ -5580,8 +5556,7 @@ static void spirv_compiler_emit_dcl_sampler(struct spirv_compiler *compiler,
             &sampler->range, VKD3D_SHADER_RESOURCE_NONE, false, &var_info);

vkd3d_symbol_make_register(&reg_symbol, reg);
-    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-            VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL);
+    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL);
     reg_symbol.descriptor_array = var_info.array_symbol;
     reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx;
     spirv_compiler_put_symbol(compiler, &reg_symbol);
@@ -5604,7 +5579,7 @@ static const struct vkd3d_spirv_resource_type *spirv_compiler_enable_resource_ty
     return resource_type_info;
 }

-static SpvImageFormat image_format_for_image_read(enum vkd3d_shader_component_type data_type)
+static SpvImageFormat image_format_for_image_read(enum vkd3d_data_type data_type)
 {
     /* The following formats are supported by Direct3D 11 hardware for UAV
      * typed loads. A newer hardware may support more formats for UAV typed
@@ -5612,11 +5587,11 @@ static SpvImageFormat image_format_for_image_read(enum vkd3d_shader_component_ty
      */
     switch (data_type)
     {
-        case VKD3D_SHADER_COMPONENT_FLOAT:
+        case VKD3D_DATA_FLOAT:
             return SpvImageFormatR32f;
-        case VKD3D_SHADER_COMPONENT_INT:
+        case VKD3D_DATA_INT:
             return SpvImageFormatR32i;
-        case VKD3D_SHADER_COMPONENT_UINT:
+        case VKD3D_DATA_UINT:
             return SpvImageFormatR32ui;
         default:
             FIXME("Unhandled type %#x.\n", data_type);
@@ -5646,7 +5621,7 @@ static const struct vkd3d_shader_descriptor_info *spirv_compiler_get_descriptor_

static uint32_t spirv_compiler_get_image_type_id(struct spirv_compiler *compiler,
         const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range,
-        const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_shader_component_type data_type,
+        const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_data_type data_type,
         bool raw_structured, uint32_t depth)
 {
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -5676,7 +5651,7 @@ static uint32_t spirv_compiler_get_image_type_id(struct spirv_compiler *compiler

static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compiler *compiler,
         const struct vkd3d_shader_register *resource, const struct vkd3d_shader_register_range *resource_range,
-        enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_component_type sampled_type,
+        enum vkd3d_shader_resource_type resource_type, enum vkd3d_data_type sampled_type,
         unsigned int structure_stride, bool raw, const struct vkd3d_spirv_resource_type *resource_type_info)
 {
     const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
@@ -5762,7 +5737,7 @@ static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compi

static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *compiler,
         const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type,
-        enum vkd3d_data_type resource_data_type, unsigned int structure_stride, bool raw)
+        enum vkd3d_data_type sampled_type, unsigned int structure_stride, bool raw)
 {
     struct vkd3d_descriptor_variable_info var_info, counter_var_info = {0};
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@@ -5770,7 +5745,6 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp
     uint32_t counter_type_id, type_id, var_id, counter_var_id = 0;
     const struct vkd3d_shader_register *reg = &resource->reg.reg;
     const struct vkd3d_spirv_resource_type *resource_type_info;
-    enum vkd3d_shader_component_type sampled_type;
     struct vkd3d_symbol resource_symbol;
     bool is_uav;

@@ -5782,8 +5756,6 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp
         return;
     }

-    sampled_type = vkd3d_component_type_from_data_type(resource_data_type);
-
     if (spirv_compiler_has_combined_sampler(compiler, resource, NULL))
     {
         spirv_compiler_emit_combined_sampler_declarations(compiler, reg, &resource->range,
@@ -5830,7 +5802,7 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp
         {
             assert(structure_stride); /* counters are valid only for structured buffers */

-            counter_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+            counter_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
             if (spirv_compiler_is_opengl_target(compiler))
             {
                 vkd3d_spirv_enable_capability(builder, SpvCapabilityAtomicStorage);
@@ -5934,7 +5906,7 @@ static void spirv_compiler_emit_workgroup_memory(struct spirv_compiler *compiler
     const SpvStorageClass storage_class = SpvStorageClassWorkgroup;
     struct vkd3d_symbol reg_symbol;

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     length_id = spirv_compiler_get_constant_uint(compiler, size);
     array_type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);

@@ -5945,8 +5917,7 @@ static void spirv_compiler_emit_workgroup_memory(struct spirv_compiler *compiler
     spirv_compiler_emit_register_debug_name(builder, var_id, reg);

vkd3d_symbol_make_register(&reg_symbol, reg);
-    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
-            VKD3D_SHADER_COMPONENT_UINT, VKD3DSP_WRITEMASK_0);
+    vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, VKD3D_DATA_UINT, VKD3DSP_WRITEMASK_0);
     reg_symbol.info.reg.structure_stride = structure_stride;
     spirv_compiler_put_symbol(compiler, &reg_symbol);
 }
@@ -6078,7 +6049,7 @@ static void spirv_compiler_emit_dcl_input_primitive(struct spirv_compiler *compi

static void spirv_compiler_emit_point_size(struct spirv_compiler *compiler)
 {
-    static const struct vkd3d_spirv_builtin point_size = {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInPointSize};
+    static const struct vkd3d_spirv_builtin point_size = {VKD3D_DATA_FLOAT, 1, SpvBuiltInPointSize};

/* Set the point size. Point sprites are not supported in d3d10+, but
      * point primitives can still be used with e.g. stream output. Vulkan
@@ -6294,11 +6265,11 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile
     const struct shader_signature *output_signature = &compiler->output_signature;
     const struct shader_signature *input_signature = &compiler->input_signature;
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    enum vkd3d_shader_component_type component_type;
     struct vkd3d_shader_src_param invocation;
     struct vkd3d_shader_register input_reg;
     uint32_t type_id, output_ptr_type_id;
     uint32_t input_id, output_id, dst_id;
+    enum vkd3d_data_type data_type;
     unsigned int component_count;
     unsigned int array_sizes[2];
     uint32_t invocation_id;
@@ -6330,21 +6301,21 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile
         const struct signature_element *input = &input_signature->elements[i];

assert(input->mask == output->mask);
-        assert(input->component_type == output->component_type);
+        assert(input->data_type == output->data_type);

input_reg.idx[1].offset = i;
         input_id = spirv_compiler_get_register_id(compiler, &input_reg);

-        component_type = output->component_type;
+        data_type = output->data_type;
         component_count = vkd3d_write_mask_component_count(output->mask);
-        type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count);
+        type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
         if ((array_sizes[0] = (input->register_count > 1) ? input->register_count : 0))
             type_id = vkd3d_spirv_get_op_type_array(builder, type_id, spirv_compiler_get_constant_uint(compiler,
                     array_sizes[0]));

array_sizes[1] = compiler->output_control_point_count;
         output_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, SpvStorageClassOutput,
-                component_type, component_count, array_sizes, 2);
+                data_type, component_count, array_sizes, 2);
         vkd3d_spirv_add_iface_variable(builder, output_id);
         vkd3d_spirv_build_op_decorate1(builder, output_id, SpvDecorationLocation, output->register_index);
         vkd3d_spirv_build_op_name(builder, output_id, "vocp%u", output->register_index);
@@ -6394,7 +6365,7 @@ static void spirv_compiler_emit_shader_epilogue_invocation(struct spirv_compiler
     if ((function_id = compiler->epilogue_function_id))
     {
         void_id = vkd3d_spirv_get_op_type_void(builder);
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 4);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 4);
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id);
         for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
         {
@@ -6531,7 +6502,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler,
             || instruction->handler_idx == VKD3DSIH_USHR)
     {
         uint32_t mask_id = spirv_compiler_get_constant_vector(compiler,
-                VKD3D_SHADER_COMPONENT_UINT, vkd3d_write_mask_component_count(dst->write_mask), 0x1f);
+                VKD3D_DATA_UINT, vkd3d_write_mask_component_count(dst->write_mask), 0x1f);
         src_ids[1] = vkd3d_spirv_build_op_and(builder, type_id, src_ids[1], mask_id);
     }

@@ -6646,8 +6617,7 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler,
     spirv_compiler_get_register_info(compiler, &dst->reg, &dst_reg_info);
     spirv_compiler_get_register_info(compiler, &src->reg, &src_reg_info);

-    if (dst_reg_info.component_type != src_reg_info.component_type
-            || dst_reg_info.write_mask != src_reg_info.write_mask)
+    if (dst_reg_info.data_type != src_reg_info.data_type || dst_reg_info.write_mask != src_reg_info.write_mask)
         goto general_implementation;

if (vkd3d_swizzle_is_equal(dst_reg_info.write_mask, src->swizzle, src_reg_info.write_mask))
@@ -6666,7 +6636,7 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler,
         dst_id = spirv_compiler_get_register_id(compiler, &dst->reg);
         src_id = spirv_compiler_get_register_id(compiler, &src->reg);

-        type_id = vkd3d_spirv_get_type_id(builder, dst_reg_info.component_type, VKD3D_VEC4_SIZE);
+        type_id = vkd3d_spirv_get_type_id(builder, dst_reg_info.data_type, VKD3D_VEC4_SIZE);
         val_id = vkd3d_spirv_build_op_load(builder, type_id, src_id, SpvMemoryAccessMaskNone);
         dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);

@@ -6729,7 +6699,7 @@ static void spirv_compiler_emit_swapc(struct spirv_compiler *compiler,
     src2_id = spirv_compiler_emit_load_src(compiler, &src[2], dst->write_mask);

component_count = vkd3d_write_mask_component_count(dst->write_mask);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, component_count);

condition_id = spirv_compiler_emit_int_to_bool(compiler,
             VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id);
@@ -6746,13 +6716,13 @@ static void spirv_compiler_emit_dot(struct spirv_compiler *compiler,
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     const struct vkd3d_shader_dst_param *dst = instruction->dst;
     const struct vkd3d_shader_src_param *src = instruction->src;
-    enum vkd3d_shader_component_type component_type;
     uint32_t type_id, val_id, src_ids[2];
     unsigned int component_count, i;
+    enum vkd3d_data_type data_type;
     DWORD write_mask;

component_count = vkd3d_write_mask_component_count(dst->write_mask);
-    component_type = vkd3d_component_type_from_data_type(dst->reg.data_type);
+    data_type = dst->reg.data_type;

if (instruction->handler_idx == VKD3DSIH_DP4)
         write_mask = VKD3DSP_WRITEMASK_ALL;
@@ -6765,15 +6735,12 @@ static void spirv_compiler_emit_dot(struct spirv_compiler *compiler,
     for (i = 0; i < ARRAY_SIZE(src_ids); ++i)
         src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], write_mask);

-    type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);

val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
             SpvOpDot, type_id, src_ids[0], src_ids[1]);
     if (component_count > 1)
-    {
-        val_id = spirv_compiler_emit_construct_vector(compiler,
-                component_type, component_count, val_id, 0, 1);
-    }
+        val_id = spirv_compiler_emit_construct_vector(compiler, data_type, component_count, val_id, 0, 1);
     if (instruction->flags & VKD3DSI_PRECISE_XYZW)
         vkd3d_spirv_build_op_decorate(builder, val_id, SpvDecorationNoContraction, NULL, 0);

@@ -6870,7 +6837,7 @@ static void spirv_compiler_emit_imad(struct spirv_compiler *compiler,
     unsigned int i, component_count;

component_count = vkd3d_write_mask_component_count(dst->write_mask);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, component_count);

for (i = 0; i < ARRAY_SIZE(src_ids); ++i)
         src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], dst->write_mask);
@@ -6941,16 +6908,16 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
     const struct vkd3d_shader_dst_param *dst = instruction->dst;
     const struct vkd3d_shader_src_param *src = instruction->src;
-    enum vkd3d_shader_component_type component_type;
     unsigned int i, j, k, src_count;
+    enum vkd3d_data_type data_type;
     DWORD write_mask;
     SpvOp op;

src_count = instruction->src_count;
     assert(2 <= src_count && src_count <= ARRAY_SIZE(src_ids));

-    component_type = vkd3d_component_type_from_data_type(dst->reg.data_type);
-    type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+    data_type = dst->reg.data_type;
+    type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
     mask_id = spirv_compiler_get_constant_uint(compiler, 0x1f);

switch (instruction->handler_idx)
@@ -6972,7 +6939,7 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp
         for (j = 0; j < src_count; ++j)
         {
             src_ids[src_count - j - 1] = spirv_compiler_emit_load_src_with_type(compiler,
-                    &src[j], write_mask, component_type);
+                    &src[j], write_mask, data_type);
         }

/* In SPIR-V, the last two operands are Offset and Count. */
@@ -6985,7 +6952,7 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp
                 op, type_id, src_ids, src_count);
     }

-    spirv_compiler_emit_store_dst_components(compiler, dst, component_type, constituents);
+    spirv_compiler_emit_store_dst_components(compiler, dst, data_type, constituents);
 }

static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler,
@@ -7000,8 +6967,8 @@ static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler,
     DWORD write_mask;

instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2);
-    scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2);
+    scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 1);

/* FIXME: Consider a single UnpackHalf2x16 instruction per 2 components. */
     assert(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
@@ -7017,8 +6984,7 @@ static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler,
                 scalar_type_id, result_id, 0);
     }

-    spirv_compiler_emit_store_dst_components(compiler,
-            dst, vkd3d_component_type_from_data_type(dst->reg.data_type), components);
+    spirv_compiler_emit_store_dst_components(compiler, dst, dst->reg.data_type, components);
 }

static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler,
@@ -7033,8 +6999,8 @@ static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler,
     DWORD write_mask;

instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2);
-    scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2);
+    scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     zero_id = spirv_compiler_get_constant_float(compiler, 0.0f);

/* FIXME: Consider a single PackHalf2x16 instruction per 2 components. */
@@ -7053,8 +7019,7 @@ static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler,
                 instr_set_id, GLSLstd450PackHalf2x16, &src_id, 1);
     }

-    spirv_compiler_emit_store_dst_components(compiler,
-            dst, vkd3d_component_type_from_data_type(dst->reg.data_type), components);
+    spirv_compiler_emit_store_dst_components(compiler, dst, dst->reg.data_type, components);
 }

static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *compiler,
@@ -7093,7 +7058,7 @@ static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *co
     src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
     src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, component_count);
     result_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
             op, type_id, src0_id, src1_id);

@@ -7599,7 +7564,7 @@ struct vkd3d_shader_image
     uint32_t image_id;
     uint32_t sampled_image_id;

-    enum vkd3d_shader_component_type sampled_type;
+    enum vkd3d_data_type sampled_type;
     uint32_t image_type_id;
     const struct vkd3d_spirv_resource_type *resource_type_info;
     unsigned int structure_stride;
@@ -7769,8 +7734,7 @@ static uint32_t spirv_compiler_emit_texel_offset(struct spirv_compiler *compiler
     const struct vkd3d_shader_texel_offset *offset = &instruction->texel_offset;
     unsigned int component_count = resource_type_info->offset_component_count;
     int32_t data[4] = {offset->u, offset->v, offset->w, 0};
-    return spirv_compiler_get_constant(compiler,
-            VKD3D_SHADER_COMPONENT_INT, component_count, (const uint32_t *)data);
+    return spirv_compiler_get_constant(compiler, VKD3D_DATA_INT, component_count, (const uint32_t *)data);
 }

static void spirv_compiler_emit_ld(struct spirv_compiler *compiler,
@@ -7837,7 +7801,7 @@ static void spirv_compiler_emit_lod(struct spirv_compiler *compiler,
     spirv_compiler_prepare_image(compiler, &image,
             &resource->reg, &sampler->reg, VKD3D_IMAGE_FLAG_SAMPLED);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2);
     coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL);
     val_id = vkd3d_spirv_build_op_image_query_lod(builder,
             type_id, image.sampled_image_id, coordinate_id);
@@ -8021,8 +7985,7 @@ static void spirv_compiler_emit_gather4(struct spirv_compiler *compiler,
     {
         component_idx = vkd3d_swizzle_get_component(sampler->swizzle, 0);
         /* Nvidia driver requires signed integer type. */
-        component_id = spirv_compiler_get_constant(compiler,
-                VKD3D_SHADER_COMPONENT_INT, 1, &component_idx);
+        component_id = spirv_compiler_get_constant(compiler, VKD3D_DATA_INT, 1, &component_idx);
         val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id,
                 image.sampled_image_id, coordinate_id, component_id,
                 operands_mask, image_operands, image_operand_count);
@@ -8086,7 +8049,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler
         texel_type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, texel_type_id);

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
                 type_id, resource_symbol->info.resource.structure_stride,
                 &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
@@ -8118,7 +8081,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler

spirv_compiler_prepare_image(compiler, &image, &resource->reg, NULL, VKD3D_IMAGE_FLAG_NONE);

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
                 type_id, image.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);

@@ -8142,7 +8105,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler
         }
     }
     assert(dst->reg.data_type == VKD3D_DATA_UINT);
-    spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_SHADER_COMPONENT_UINT, constituents);
+    spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_DATA_UINT, constituents);
 }

static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler,
@@ -8162,7 +8125,7 @@ static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler,
     if (!spirv_compiler_get_register_info(compiler, &resource->reg, &reg_info))
         return;

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
     base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
             type_id, reg_info.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
@@ -8183,7 +8146,7 @@ static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler,
         constituents[j++] = vkd3d_spirv_build_op_load(builder, type_id, ptr_id, SpvMemoryAccessMaskNone);
     }
     assert(dst->reg.data_type == VKD3D_DATA_UINT);
-    spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_SHADER_COMPONENT_UINT, constituents);
+    spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_DATA_UINT, constituents);
 }

static void spirv_compiler_emit_ld_raw_structured(struct spirv_compiler *compiler,
@@ -8225,7 +8188,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler *
         type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, type_id);

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
                 type_id, resource_symbol->info.resource.structure_stride,
                 &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
@@ -8253,7 +8216,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler *
     }
     else
     {
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         spirv_compiler_prepare_image(compiler, &image, &dst->reg, NULL, VKD3D_IMAGE_FLAG_NONE);
         assert((instruction->handler_idx == VKD3DSIH_STORE_STRUCTURED) != !image.structure_stride);
         base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
@@ -8267,7 +8230,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler *
         for (component_idx = 0; component_idx < component_count; ++component_idx)
         {
             /* Mesa Vulkan drivers require the texel parameter to be a vector. */
-            data_id = spirv_compiler_emit_construct_vector(compiler, VKD3D_SHADER_COMPONENT_UINT,
+            data_id = spirv_compiler_emit_construct_vector(compiler, VKD3D_DATA_UINT,
                     VKD3D_VEC4_SIZE, val_id, component_idx, component_count);

coordinate_id = base_coordinate_id;
@@ -8297,7 +8260,7 @@ static void spirv_compiler_emit_store_tgsm(struct spirv_compiler *compiler,
     if (!spirv_compiler_get_register_info(compiler, &dst->reg, &reg_info))
         return;

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
     assert((instruction->handler_idx == VKD3DSIH_STORE_STRUCTURED) != !reg_info.structure_stride);
     base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
@@ -8444,7 +8407,7 @@ static void spirv_compiler_emit_uav_counter_instruction(struct spirv_compiler *c
     counter_id = resource_symbol->info.resource.uav_counter_id;
     assert(counter_id);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);

if (resource_symbol->info.resource.uav_counter_array)
     {
@@ -8552,11 +8515,11 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
     const struct vkd3d_shader_src_param *src = instruction->src;
     const struct vkd3d_symbol *resource_symbol = NULL;
     uint32_t ptr_type_id, type_id, val_id, result_id;
-    enum vkd3d_shader_component_type component_type;
     const struct vkd3d_shader_dst_param *resource;
     uint32_t coordinate_id, sample_id, pointer_id;
     struct vkd3d_shader_register_info reg_info;
     struct vkd3d_shader_image image;
+    enum vkd3d_data_type data_type;
     unsigned int structure_stride;
     DWORD coordinate_mask;
     uint32_t operands[6];
@@ -8603,7 +8566,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
         }
     }

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     if (structure_stride || raw)
     {
         assert(!raw != !structure_stride);
@@ -8619,7 +8582,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil

if (resource->reg.type == VKD3DSPR_GROUPSHAREDMEM)
     {
-        component_type = VKD3D_SHADER_COMPONENT_UINT;
+        data_type = VKD3D_DATA_UINT;
         ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
         pointer_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, reg_info.id, coordinate_id);
     }
@@ -8627,8 +8590,8 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
     {
         if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
         {
-            component_type = resource_symbol->info.resource.sampled_type;
-            type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
+            data_type = resource_symbol->info.resource.sampled_type;
+            type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
             ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, type_id);
             operands[0] = spirv_compiler_get_constant_uint(compiler, 0);
             operands[1] = coordinate_id;
@@ -8636,7 +8599,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
         }
         else
         {
-            component_type = image.sampled_type;
+            data_type = image.sampled_type;
             type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, 1);
             ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassImage, type_id);
             sample_id = spirv_compiler_get_constant_uint(compiler, 0);
@@ -8645,7 +8608,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
         }
     }

-    val_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1], VKD3DSP_WRITEMASK_0, component_type);
+    val_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1], VKD3DSP_WRITEMASK_0, data_type);

operands[i++] = pointer_id;
     operands[i++] = spirv_compiler_get_constant_uint(compiler, scope);
@@ -8653,7 +8616,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
     if (instruction->src_count >= 3)
     {
         operands[i++] = spirv_compiler_get_constant_uint(compiler, SpvMemorySemanticsMaskNone);
-        operands[i++] = spirv_compiler_emit_load_src_with_type(compiler, &src[2], VKD3DSP_WRITEMASK_0, component_type);
+        operands[i++] = spirv_compiler_emit_load_src_with_type(compiler, &src[2], VKD3DSP_WRITEMASK_0, data_type);
     }
     operands[i++] = val_id;
     result_id = vkd3d_spirv_build_op_trv(builder, &builder->function_stream,
@@ -8679,7 +8642,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler,
     {
         resource_symbol = spirv_compiler_find_resource(compiler, &src->reg);

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         val_id = vkd3d_spirv_build_op_array_length(builder, type_id, resource_symbol->id, 0);
         write_mask = VKD3DSP_WRITEMASK_0;
     }
@@ -8689,7 +8652,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler,

spirv_compiler_prepare_image(compiler, &image, &src->reg, NULL, VKD3D_IMAGE_FLAG_NONE);

-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         val_id = vkd3d_spirv_build_op_image_query_size(builder, type_id, image.image_id);
         write_mask = VKD3DSP_WRITEMASK_0;
     }
@@ -8699,7 +8662,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler,
         stride_id = spirv_compiler_get_constant_uint(compiler, image.structure_stride);
         constituents[0] = vkd3d_spirv_build_op_udiv(builder, type_id, val_id, stride_id);
         constituents[1] = stride_id;
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, ARRAY_SIZE(constituents));
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, ARRAY_SIZE(constituents));
         val_id = vkd3d_spirv_build_op_composite_construct(builder,
                 type_id, constituents, ARRAY_SIZE(constituents));
         write_mask |= VKD3DSP_WRITEMASK_1;
@@ -8711,7 +8674,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler,
     }

val_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask,
-            VKD3D_SHADER_COMPONENT_UINT, src->swizzle, dst->write_mask);
+            VKD3D_DATA_UINT, src->swizzle, dst->write_mask);
     spirv_compiler_emit_store_dst(compiler, dst, val_id);
 }

@@ -8733,14 +8696,14 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler,
     size_component_count = image.resource_type_info->coordinate_component_count;
     if (image.resource_type_info->dim == SpvDimCube)
         --size_component_count;
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, size_component_count);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, size_component_count);

supports_mipmaps = src[1].reg.type != VKD3DSPR_UAV && !image.resource_type_info->ms;
     if (supports_mipmaps)
     {
         lod_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
         val_id = vkd3d_spirv_build_op_image_query_size_lod(builder, type_id, image.image_id, lod_id);
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         miplevel_count_id = vkd3d_spirv_build_op_image_query_levels(builder, type_id, image.image_id);
     }
     else
@@ -8754,11 +8717,11 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler,
     for (i = 0; i < 3 - size_component_count; ++i)
         constituents[i + 1] = spirv_compiler_get_constant_uint(compiler, 0);
     constituents[i + 1] = miplevel_count_id;
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, VKD3D_VEC4_SIZE);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, VKD3D_VEC4_SIZE);
     val_id = vkd3d_spirv_build_op_composite_construct(builder,
             type_id, constituents, i + 2);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     if (instruction->flags == VKD3DSI_RESINFO_UINT)
     {
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
@@ -8770,7 +8733,7 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler,
         val_id = vkd3d_spirv_build_op_convert_utof(builder, type_id, val_id);
     }
     val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL,
-            VKD3D_SHADER_COMPONENT_FLOAT, src[1].swizzle, dst->write_mask);
+            VKD3D_DATA_FLOAT, src[1].swizzle, dst->write_mask);

spirv_compiler_emit_store_dst(compiler, dst, val_id);
 }
@@ -8792,7 +8755,7 @@ static uint32_t spirv_compiler_emit_query_sample_count(struct spirv_compiler *co
         vkd3d_spirv_enable_capability(builder, SpvCapabilityImageQuery);

spirv_compiler_prepare_image(compiler, &image, &src->reg, NULL, VKD3D_IMAGE_FLAG_NONE);
-        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+        type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
         val_id = vkd3d_spirv_build_op_image_query_samples(builder, type_id, image.image_id);
     }

@@ -8814,10 +8777,10 @@ static void spirv_compiler_emit_sample_info(struct spirv_compiler *compiler,
     constituents[0] = val_id;
     for (i = 1; i < VKD3D_VEC4_SIZE; ++i)
         constituents[i] = spirv_compiler_get_constant_uint(compiler, 0);
-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, VKD3D_VEC4_SIZE);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, VKD3D_VEC4_SIZE);
     val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, constituents, VKD3D_VEC4_SIZE);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
     if (instruction->flags == VKD3DSI_SAMPLE_INFO_UINT)
     {
         val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
@@ -8830,7 +8793,7 @@ static void spirv_compiler_emit_sample_info(struct spirv_compiler *compiler,
     }

val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL,
-            VKD3D_SHADER_COMPONENT_FLOAT, src->swizzle, dst->write_mask);
+            VKD3D_DATA_FLOAT, src->swizzle, dst->write_mask);

spirv_compiler_emit_store_dst(compiler, dst, val_id);
 }
@@ -8890,13 +8853,13 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler,
     sample_count_id = spirv_compiler_emit_query_sample_count(compiler, &instruction->src[0]);
     sample_index_id = spirv_compiler_emit_load_src(compiler, &instruction->src[1], VKD3DSP_WRITEMASK_0);

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
     index_id = vkd3d_spirv_build_op_iadd(builder, type_id, sample_count_id, sample_index_id);
     index_id = vkd3d_spirv_build_op_isub(builder,
             type_id, index_id, spirv_compiler_get_constant_uint(compiler, 1));

/* Validate sample index. */
-    bool_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, 1);
+    bool_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, 1);
     id = vkd3d_spirv_build_op_logical_and(builder, bool_id,
             vkd3d_spirv_build_op_uless_than(builder, bool_id, sample_index_id, sample_count_id),
             vkd3d_spirv_build_op_uless_than_equal(builder,
@@ -8904,7 +8867,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler,
     index_id = vkd3d_spirv_build_op_select(builder, type_id,
             id, index_id, spirv_compiler_get_constant_uint(compiler, 0));

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2);
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2);
     if (!(id = compiler->sample_positions_id))
     {
         length_id = spirv_compiler_get_constant_uint(compiler, ARRAY_SIZE(standard_sample_positions));
@@ -8913,7 +8876,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler,
         for (i = 0; i < ARRAY_SIZE(standard_sample_positions); ++ i)
         {
             constituents[i] = spirv_compiler_get_constant(compiler,
-                    VKD3D_SHADER_COMPONENT_FLOAT, 2, (const uint32_t *)standard_sample_positions[i]);
+                    VKD3D_DATA_FLOAT, 2, (const uint32_t *)standard_sample_positions[i]);
         }

id = vkd3d_spirv_build_op_constant_composite(builder, array_type_id, constituents, ARRAY_SIZE(constituents));
@@ -8928,7 +8891,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler,
     id = vkd3d_spirv_build_op_load(builder, type_id, id, SpvMemoryAccessMaskNone);

id = spirv_compiler_emit_swizzle(compiler, id, VKD3DSP_WRITEMASK_0 | VKD3DSP_WRITEMASK_1,
-            VKD3D_SHADER_COMPONENT_FLOAT, instruction->src[0].swizzle, dst->write_mask);
+            VKD3D_DATA_FLOAT, instruction->src[0].swizzle, dst->write_mask);
     spirv_compiler_emit_store_dst(compiler, dst, id);
 }

@@ -8968,14 +8931,14 @@ static void spirv_compiler_emit_eval_attrib(struct spirv_compiler *compiler,
         src_ids[src_count++] = spirv_compiler_emit_load_src(compiler, &src[1], VKD3DSP_WRITEMASK_0);
     }

-    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT,
+    type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT,
             vkd3d_write_mask_component_count(register_info.write_mask));

instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
     val_id = vkd3d_spirv_build_op_ext_inst(builder, type_id, instr_set_id, op, src_ids, src_count);

val_id = spirv_compiler_emit_swizzle(compiler, val_id, register_info.write_mask,
-            VKD3D_SHADER_COMPONENT_FLOAT, src[0].swizzle, dst->write_mask);
+            VKD3D_DATA_FLOAT, src[0].swizzle, dst->write_mask);

spirv_compiler_emit_store_dst(compiler, dst, val_id);
 }
diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index f26050bb..fa6c3220 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -565,7 +565,7 @@ static bool vkd3d_shader_signature_from_shader_signature(struct vkd3d_shader_sig
         d->semantic_index = e->semantic_index;
         d->stream_index = e->stream_index;
         d->sysval_semantic = e->sysval_semantic;
-        d->component_type = e->component_type;
+        d->component_type = vkd3d_component_type_from_data_type(e->data_type);
         d->register_index = e->register_index;
         if (e->register_count > 1)
             FIXME("Arrayed elements are not supported yet.\n");
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 247d00e1..ca4cea94 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -533,6 +533,8 @@ enum vkd3d_data_type_class
     VKD3D_DATA_CLASS_MIXED,
     VKD3D_DATA_CLASS_CONTINUED,
     VKD3D_DATA_CLASS_UNUSED,
+    VKD3D_DATA_CLASS_VOID,
+    VKD3D_DATA_CLASS_BOOL,
 };

enum vkd3d_data_type
@@ -550,6 +552,8 @@ enum vkd3d_data_type
     VKD3D_DATA_DOUBLE    = (VKD3D_DATA_CLASS_FLOAT     << DATA_TYPE_CLASS_SHIFT) | 64,
     VKD3D_DATA_CONTINUED =  VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT,
     VKD3D_DATA_UNUSED    =  VKD3D_DATA_CLASS_UNUSED    << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_VOID      =  VKD3D_DATA_CLASS_VOID      << DATA_TYPE_CLASS_SHIFT,
+    VKD3D_DATA_BOOL      =  VKD3D_DATA_CLASS_BOOL      << DATA_TYPE_CLASS_SHIFT,
 };

static inline bool data_type_class_is_numeric(enum vkd3d_data_type_class class)
@@ -562,6 +566,21 @@ static inline enum vkd3d_data_type_class data_type_get_class(enum vkd3d_data_typ
     return (type & DATA_TYPE_CLASS_MASK) >> DATA_TYPE_CLASS_SHIFT;
 }

+static inline bool data_type_is_numeric(enum vkd3d_data_type type)
+{
+    return data_type_class_is_numeric(data_type_get_class(type));
+}
+
+static inline unsigned int data_type_get_width(enum vkd3d_data_type type)
+{
+    return type & DATA_TYPE_WIDTH_MASK;
+}
+
+static inline bool data_type_is_signed(enum vkd3d_data_type type)
+{
+    return !!(type & DATA_TYPE_IS_SIGNED_MASK);
+}
+
 enum vkd3d_immconst_type
 {
     VKD3D_IMMCONST_SCALAR,
@@ -835,7 +854,7 @@ struct signature_element
     unsigned int semantic_index;
     unsigned int stream_index;
     enum vkd3d_shader_sysval_semantic sysval_semantic;
-    enum vkd3d_shader_component_type component_type;
+    enum vkd3d_data_type data_type;
     unsigned int register_index;
     unsigned int register_count;
     unsigned int mask;
@@ -1251,6 +1270,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty
 {
     switch (data_type)
     {
+        case VKD3D_DATA_VOID:
+            return VKD3D_SHADER_COMPONENT_VOID;
         case VKD3D_DATA_FLOAT:
         case VKD3D_DATA_UNORM:
         case VKD3D_DATA_SNORM:
@@ -1259,6 +1280,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty
             return VKD3D_SHADER_COMPONENT_UINT;
         case VKD3D_DATA_INT:
             return VKD3D_SHADER_COMPONENT_INT;
+        case VKD3D_DATA_BOOL:
+            return VKD3D_SHADER_COMPONENT_BOOL;
         case VKD3D_DATA_DOUBLE:
             return VKD3D_SHADER_COMPONENT_DOUBLE;
         default:
@@ -1274,12 +1297,16 @@ static inline enum vkd3d_data_type vkd3d_data_type_from_component_type(
 {
     switch (component_type)
     {
+        case VKD3D_SHADER_COMPONENT_VOID:
+            return VKD3D_DATA_VOID;
         case VKD3D_SHADER_COMPONENT_FLOAT:
             return VKD3D_DATA_FLOAT;
         case VKD3D_SHADER_COMPONENT_UINT:
             return VKD3D_DATA_UINT;
         case VKD3D_SHADER_COMPONENT_INT:
             return VKD3D_DATA_INT;
+        case VKD3D_SHADER_COMPONENT_BOOL:
+            return VKD3D_DATA_BOOL;
         case VKD3D_SHADER_COMPONENT_DOUBLE:
             return VKD3D_DATA_DOUBLE;
         default:

[PATCH v2 3/4] vkd3d-shader/spirv: Use vkd3d_spirv_get_op_constant() for 64-bit types.

[Conor McCarthy]

From: Conor McCarthy

Storing width info in enum vkd3d_data_type makes a separate code path
unnecessary.
---
 libs/vkd3d-shader/spirv.c | 69 ++++++++-------------------------------
 1 file changed, 13 insertions(+), 56 deletions(-)

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index 2bd13360..a9b845cd 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -1120,34 +1120,19 @@ static uint32_t vkd3d_spirv_get_op_type_pointer(struct vkd3d_spirv_builder *buil
             vkd3d_spirv_build_op_type_pointer);
 }

-/* Types larger than 32-bits are not supported. */
 static uint32_t vkd3d_spirv_build_op_constant(struct vkd3d_spirv_builder *builder,
-        uint32_t result_type, uint32_t value)
-{
-    return vkd3d_spirv_build_op_tr1(builder, &builder->global_stream,
-            SpvOpConstant, result_type, value);
-}
-
-static uint32_t vkd3d_spirv_get_op_constant(struct vkd3d_spirv_builder *builder,
-        uint32_t result_type, uint32_t value)
-{
-    return vkd3d_spirv_build_once2(builder, SpvOpConstant, result_type, value,
-            vkd3d_spirv_build_op_constant);
-}
-
-static uint32_t vkd3d_spirv_build_op_constant64(struct vkd3d_spirv_builder *builder,
         uint32_t result_type, const uint32_t *values, unsigned int value_count)
 {
-    assert(value_count == 2);
+    assert(0 < value_count && value_count <= 2);
     return vkd3d_spirv_build_op_trv(builder, &builder->global_stream,
             SpvOpConstant, result_type, values, value_count);
 }

-static uint32_t vkd3d_spirv_get_op_constant64(struct vkd3d_spirv_builder *builder,
-        uint32_t result_type, uint64_t value)
+static uint32_t vkd3d_spirv_get_op_constant(struct vkd3d_spirv_builder *builder,
+        uint32_t result_type, const uint32_t *values, unsigned int value_count)
 {
     return vkd3d_spirv_build_once1v(builder, SpvOpConstant, result_type,
-            (const uint32_t *)&value, 2, vkd3d_spirv_build_op_constant64);
+            values, value_count, vkd3d_spirv_build_op_constant);
 }

static uint32_t vkd3d_spirv_build_op_constant_composite(struct vkd3d_spirv_builder *builder,
@@ -2765,55 +2750,28 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler,
 {
     uint32_t type_id, scalar_type_id, component_ids[VKD3D_VEC4_SIZE];
     struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    unsigned int i;
+    unsigned int i, j, width, value_count;

assert(0 < component_count && component_count <= VKD3D_VEC4_SIZE);
     type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);

-    if (!data_type_is_numeric(data_type) || data_type_get_width(data_type) != 32)
+    if (!data_type_is_numeric(data_type))
     {
         FIXME("Unhandled data type %#x.\n", data_type);
         return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
     }

+    width = data_type_get_width(data_type);
+    value_count = max(width, 32u) / 32u;
     if (component_count == 1)
     {
-        return vkd3d_spirv_get_op_constant(builder, type_id, *values);
+        return vkd3d_spirv_get_op_constant(builder, type_id, values, value_count);
     }
     else
     {
         scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
-        for (i = 0; i < component_count; ++i)
-            component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, values[i]);
-        return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
-    }
-}
-
-static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler,
-        enum vkd3d_data_type data_type, unsigned int component_count, const uint64_t *values)
-{
-    uint32_t type_id, scalar_type_id, component_ids[VKD3D_DVEC2_SIZE];
-    struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
-    unsigned int i;
-
-    assert(0 < component_count && component_count <= VKD3D_DVEC2_SIZE);
-    type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
-
-    if (data_type != VKD3D_DATA_DOUBLE)
-    {
-        FIXME("Unhandled data_type %#x.\n", data_type);
-        return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id);
-    }
-
-    if (component_count == 1)
-    {
-        return vkd3d_spirv_get_op_constant64(builder, type_id, *values);
-    }
-    else
-    {
-        scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
-        for (i = 0; i < component_count; ++i)
-            component_ids[i] = vkd3d_spirv_get_op_constant64(builder, scalar_type_id, values[i]);
+        for (i = 0, j = 0; i < component_count; ++i, j += value_count)
+            component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, &values[j], value_count);
         return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
     }
 }
@@ -2854,8 +2812,7 @@ static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler
         double value, unsigned int component_count)
 {
     const double values[] = {value, value};
-    return spirv_compiler_get_constant64(compiler, VKD3D_DATA_DOUBLE,
-            component_count, (const uint64_t *)values);
+    return spirv_compiler_get_constant(compiler, VKD3D_DATA_DOUBLE, component_count, (const uint32_t *)values);
 }

static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compiler,
@@ -3535,7 +3492,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi
         }
     }

-    return spirv_compiler_get_constant64(compiler, reg->data_type, component_count, values);
+    return spirv_compiler_get_constant(compiler, reg->data_type, component_count, (const uint32_t *)values);
 }

static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,

[PATCH v2 4/4] vkd3d-shader/spirv: Use a helper function to check if a data type is floating point.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d-shader/spirv.c                | 6 +++---
 libs/vkd3d-shader/vkd3d_shader_private.h | 6 ++++++
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
index a9b845cd..4e1a47e7 100644
--- a/libs/vkd3d-shader/spirv.c
+++ b/libs/vkd3d-shader/spirv.c
@@ -3620,7 +3620,7 @@ static uint32_t spirv_compiler_emit_abs(struct spirv_compiler *compiler,
     uint32_t type_id;

type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
-    if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE)
+    if (data_type_is_floating_point(reg->data_type))
         return vkd3d_spirv_build_op_glsl_std450_fabs(builder, type_id, val_id);

FIXME("Unhandled data type %#x.\n", reg->data_type);
@@ -3634,7 +3634,7 @@ static uint32_t spirv_compiler_emit_neg(struct spirv_compiler *compiler,
     uint32_t type_id;

type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
-    if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE)
+    if (data_type_is_floating_point(reg->data_type))
         return vkd3d_spirv_build_op_fnegate(builder, type_id, val_id);
     else if (reg->data_type == VKD3D_DATA_INT)
         return vkd3d_spirv_build_op_snegate(builder, type_id, val_id);
@@ -3809,7 +3809,7 @@ static uint32_t spirv_compiler_emit_sat(struct spirv_compiler *compiler,
     }

type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
-    if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE)
+    if (data_type_is_floating_point(reg->data_type))
         return vkd3d_spirv_build_op_glsl_std450_nclamp(builder, type_id, val_id, zero_id, one_id);

FIXME("Unhandled data type %#x.\n", reg->data_type);
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index ca4cea94..4b2ccbce 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -581,6 +581,12 @@ static inline bool data_type_is_signed(enum vkd3d_data_type type)
     return !!(type & DATA_TYPE_IS_SIGNED_MASK);
 }

+static inline bool data_type_is_floating_point(enum vkd3d_data_type type)
+{
+    return type == VKD3D_DATA_FLOAT || type == VKD3D_DATA_DOUBLE;
+}
+
+
 enum vkd3d_immconst_type
 {
     VKD3D_IMMCONST_SCALAR,

[Conor McCarthy (＠cmccarthy)]

This series will clash with the current DXIL MR. It's probably neater to upstream this first but either order should be ok.

[Henri Verbeet (＠hverbeet)]

> +#define DATA_TYPE_WIDTH_MASK         0xffu
> +#define DATA_TYPE_CLASS_SHIFT           8u
> +#define DATA_TYPE_CLASS_MASK        (0x3fu << DATA_TYPE_CLASS_SHIFT)
> +#define DATA_TYPE_NORM_SHIFT           14u
> +#define DATA_TYPE_NORM_MASK            (1u << DATA_TYPE_NORM_SHIFT)
> +#define DATA_TYPE_IS_SIGNED_SHIFT      15u
> +#define DATA_TYPE_IS_SIGNED_MASK       (1u << DATA_TYPE_IS_SIGNED_SHIFT)
> +
> +enum vkd3d_data_type_class
> +{
> +    VKD3D_DATA_CLASS_FLOAT,
> +    VKD3D_DATA_CLASS_INT,
> +    VKD3D_DATA_CLASS_RESOURCE,
> +    VKD3D_DATA_CLASS_SAMPLER,
> +    VKD3D_DATA_CLASS_UAV,
> +    VKD3D_DATA_CLASS_OPAQUE,
> +    VKD3D_DATA_CLASS_MIXED,
> +    VKD3D_DATA_CLASS_CONTINUED,
> +    VKD3D_DATA_CLASS_UNUSED,
> +};
> +
>  enum vkd3d_data_type
>  {
> -    VKD3D_DATA_FLOAT,
> -    VKD3D_DATA_INT,
> -    VKD3D_DATA_RESOURCE,
> -    VKD3D_DATA_SAMPLER,
> -    VKD3D_DATA_UAV,
> -    VKD3D_DATA_UINT,
> -    VKD3D_DATA_UNORM,
> -    VKD3D_DATA_SNORM,
> -    VKD3D_DATA_OPAQUE,
> -    VKD3D_DATA_MIXED,
> -    VKD3D_DATA_DOUBLE,
> -    VKD3D_DATA_CONTINUED,
> -    VKD3D_DATA_UNUSED,
> +    VKD3D_DATA_FLOAT     = (VKD3D_DATA_CLASS_FLOAT     << DATA_TYPE_CLASS_SHIFT) | 32,
> +    VKD3D_DATA_INT       = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_IS_SIGNED_MASK,
> +    VKD3D_DATA_RESOURCE  =  VKD3D_DATA_CLASS_RESOURCE  << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_SAMPLER   =  VKD3D_DATA_CLASS_SAMPLER   << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_UAV       =  VKD3D_DATA_CLASS_UAV       << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_UINT      = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32,
> +    VKD3D_DATA_UNORM     = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK,
> +    VKD3D_DATA_SNORM     = (VKD3D_DATA_CLASS_INT       << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK | DATA_TYPE_IS_SIGNED_MASK,
> +    VKD3D_DATA_OPAQUE    =  VKD3D_DATA_CLASS_OPAQUE    << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_MIXED     =  VKD3D_DATA_CLASS_MIXED     << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_DOUBLE    = (VKD3D_DATA_CLASS_FLOAT     << DATA_TYPE_CLASS_SHIFT) | 64,
> +    VKD3D_DATA_CONTINUED =  VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT,
> +    VKD3D_DATA_UNUSED    =  VKD3D_DATA_CLASS_UNUSED    << DATA_TYPE_CLASS_SHIFT,
>  };

I'll wait for @giomasce, and possibly @etang-cw to take a look at this before looking more closely myself, but from just a quick look, do we really need the shifts and masks here? It would seem more straightforward to just store the required information in a structure, possibly using bitfields if we're particularly concerned about the size of that structure.

It's also not immediately clear to me from the commit messages what the benefit of using enum vkd3d_data_type instead of enum vkd3d_shader_component_type is. If it's just about supporting 16-bit and 64-bit components in struct signature_element, adding a "component_size" field or something similar would seem nicer.

[Conor McCarthy (＠cmccarthy)]

On Tue Jul 11 01:41:58 2023 +0000, Henri Verbeet wrote:
> > +#define DATA_TYPE_WIDTH_MASK         0xffu
> > +#define DATA_TYPE_CLASS_SHIFT           8u
> > +#define DATA_TYPE_CLASS_MASK        (0x3fu << DATA_TYPE_CLASS_SHIFT)
> > +#define DATA_TYPE_NORM_SHIFT           14u
> > +#define DATA_TYPE_NORM_MASK            (1u << DATA_TYPE_NORM_SHIFT)
> > +#define DATA_TYPE_IS_SIGNED_SHIFT      15u
> > +#define DATA_TYPE_IS_SIGNED_MASK       (1u << DATA_TYPE_IS_SIGNED_SHIFT)
> > +
> > +enum vkd3d_data_type_class
> > +{
> > +    VKD3D_DATA_CLASS_FLOAT,
> > +    VKD3D_DATA_CLASS_INT,
> > +    VKD3D_DATA_CLASS_RESOURCE,
> > +    VKD3D_DATA_CLASS_SAMPLER,
> > +    VKD3D_DATA_CLASS_UAV,
> > +    VKD3D_DATA_CLASS_OPAQUE,
> > +    VKD3D_DATA_CLASS_MIXED,
> > +    VKD3D_DATA_CLASS_CONTINUED,
> > +    VKD3D_DATA_CLASS_UNUSED,
> > +};
> > +
> >  enum vkd3d_data_type
> >  {
> > -    VKD3D_DATA_FLOAT,
> > -    VKD3D_DATA_INT,
> > -    VKD3D_DATA_RESOURCE,
> > -    VKD3D_DATA_SAMPLER,
> > -    VKD3D_DATA_UAV,
> > -    VKD3D_DATA_UINT,
> > -    VKD3D_DATA_UNORM,
> > -    VKD3D_DATA_SNORM,
> > -    VKD3D_DATA_OPAQUE,
> > -    VKD3D_DATA_MIXED,
> > -    VKD3D_DATA_DOUBLE,
> > -    VKD3D_DATA_CONTINUED,
> > -    VKD3D_DATA_UNUSED,
> > +    VKD3D_DATA_FLOAT     = (VKD3D_DATA_CLASS_FLOAT     <<
>
> DATA_TYPE_CLASS_SHIFT) | 32,
> > - VKD3D_DATA_INT       = (VKD3D_DATA_CLASS_INT       <<
>
> DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_IS_SIGNED_MASK,
> > - VKD3D_DATA_RESOURCE  =  VKD3D_DATA_CLASS_RESOURCE  << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_SAMPLER   =  VKD3D_DATA_CLASS_SAMPLER   << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_UAV       =  VKD3D_DATA_CLASS_UAV       << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_UINT      = (VKD3D_DATA_CLASS_INT       <<
>
> DATA_TYPE_CLASS_SHIFT) | 32,
> > - VKD3D_DATA_UNORM     = (VKD3D_DATA_CLASS_INT       <<
>
> DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK,
> > - VKD3D_DATA_SNORM     = (VKD3D_DATA_CLASS_INT       <<
>
> DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK | DATA_TYPE_IS_SIGNED_MASK,
> > - VKD3D_DATA_OPAQUE    =  VKD3D_DATA_CLASS_OPAQUE    << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_MIXED     =  VKD3D_DATA_CLASS_MIXED     << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_DOUBLE    = (VKD3D_DATA_CLASS_FLOAT     <<
>
> DATA_TYPE_CLASS_SHIFT) | 64,
> > - VKD3D_DATA_CONTINUED =  VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT,
> > - VKD3D_DATA_UNUSED    =  VKD3D_DATA_CLASS_UNUSED    << DATA_TYPE_CLASS_SHIFT,
> >
> > };
>
> I'll wait for @giomasce, and possibly @etang-cw to take a look at this
> before looking more closely myself, but from just a quick look, do we
> really need the shifts and masks here? It would seem more
> straightforward to just store the required information in a structure,
> possibly using bitfields if we're particularly concerned about the size
> of that structure.
> It's also not immediately clear to me from the commit messages what the
> benefit of using enum vkd3d_data_type instead of enum
> vkd3d_shader_component_type is. If it's just about supporting 16-bit and
> 64-bit components in struct signature_element, adding a "component_size"
> field or something similar would seem nicer.

My initial thought was to use bitfields. It would make it pretty ugly to use a single specific value to identify each type, and to initialise a type, but we can declare constant initialisers and types can be checked with helpers.

Signature elements are the only external source of `enum vkd3d_shader_component_type` values in the SPIR-V backend, while `enum vkd3d_data_type` is heavily used in registers. We already have numerous two-step conversions from data type to component type to SPIR-V type id, and in the SM 6 branch I added a `vkd3d_spirv_get_type_id_for_data_type()` function to avoid many more of these. Using an `enum vkd3d_data_type` in struct signature_element entirely removes the need for `enum vkd3d_shader_component_type` in the backend, which is the main reason for doing it.

The extra type sizes are making the code clunky in the SM 6 branch. For example, checking if a type is an integer is:
`data_type == VKD3D_DATA_UINT16 || data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT || data_type == VKD3D_DATA_UINT64`

These changes would make that check simple, and match the type + width pattern use both in DXIL and SPIR-V.