From 11f82d985c4e2f32f0b8c2ccabe2aca51eada245 Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Thu, 30 Jul 2020 14:59:55 +0430 Subject: [PATCH] vkd3d-shader: Pass a vkd3d_shader_compile_info structure to vkd3d_shader_scan_dxbc(). In order to allow it to handle different source types. Signed-off-by: Henri Verbeet Signed-off-by: Alexandre Julliard --- include/vkd3d_shader.h | 18 ++--- libs/vkd3d-shader/spirv.c | 33 ++------ libs/vkd3d-shader/vkd3d_shader.map | 4 +- libs/vkd3d-shader/vkd3d_shader_main.c | 97 ++++++++++++++---------- libs/vkd3d-shader/vkd3d_shader_private.h | 23 +++++- libs/vkd3d/state.c | 41 +++++++--- tests/vkd3d_shader_api.c | 20 +++-- 7 files changed, 141 insertions(+), 95 deletions(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 69a98e0f..96d05453 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -32,7 +32,7 @@ enum vkd3d_shader_structure_type /* 1.2 */ VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO, VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO, - VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO, + VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO, VKD3D_SHADER_STRUCTURE_TYPE_SPIRV_DOMAIN_SHADER_TARGET_INFO, VKD3D_SHADER_STRUCTURE_TYPE_SPIRV_TARGET_INFO, VKD3D_SHADER_STRUCTURE_TYPE_TRANSFORM_FEEDBACK_INFO, @@ -653,10 +653,11 @@ struct vkd3d_shader_descriptor_info unsigned int count; }; -struct vkd3d_shader_scan_info +/* Extends vkd3d_shader_compile_info. */ +struct vkd3d_shader_scan_descriptor_info { enum vkd3d_shader_structure_type type; - void *next; + const void *next; struct vkd3d_shader_descriptor_info *descriptors; unsigned int descriptor_count; @@ -762,9 +763,8 @@ int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_ro int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst, enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src); -int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc, - struct vkd3d_shader_scan_info *scan_info, char **messages); -void vkd3d_shader_free_scan_info(struct vkd3d_shader_scan_info *scan_info); +int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages); +void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info); int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_signature *signature); @@ -793,9 +793,9 @@ typedef int (*PFN_vkd3d_shader_serialize_root_signature)( typedef int (*PFN_vkd3d_shader_convert_root_signature)(struct vkd3d_shader_versioned_root_signature_desc *dst, enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src); -typedef int (*PFN_vkd3d_shader_scan_dxbc)(const struct vkd3d_shader_code *dxbc, - struct vkd3d_shader_scan_info *scan_info, char **messages); -typedef void (*PFN_vkd3d_shader_free_scan_info)(struct vkd3d_shader_scan_info *scan_info); +typedef int (*PFN_vkd3d_shader_scan)(const struct vkd3d_shader_compile_info *compile_info, char **messages); +typedef void (*PFN_vkd3d_shader_free_scan_descriptor_info)( + struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info); typedef int (*PFN_vkd3d_shader_parse_input_signature)(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_signature *signature); diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 3ece0447..86ee2631 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -111,27 +111,6 @@ static void vkd3d_spirv_validate(const struct vkd3d_shader_code *spirv, #endif /* HAVE_SPIRV_TOOLS */ -struct vkd3d_struct -{ - enum vkd3d_shader_structure_type type; - const void *next; -}; - -#define vkd3d_find_struct(c, t) vkd3d_find_struct_(c, VKD3D_SHADER_STRUCTURE_TYPE_##t) -static const void *vkd3d_find_struct_(const struct vkd3d_struct *chain, - enum vkd3d_shader_structure_type type) -{ - while (chain) - { - if (chain->type == type) - return chain; - - chain = chain->next; - } - - return NULL; -} - static enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed(enum vkd3d_shader_sysval_semantic sysval, unsigned int index) { @@ -2103,7 +2082,7 @@ struct vkd3d_dxbc_compiler uint32_t binding_idx; - const struct vkd3d_shader_scan_info *scan_info; + const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info; unsigned int input_control_point_count; unsigned int output_control_point_count; bool use_vocp; @@ -2134,7 +2113,7 @@ static const char *vkd3d_dxbc_compiler_get_entry_point_name(const struct vkd3d_d struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info, - const struct vkd3d_shader_scan_info *scan_info) + const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) { const struct vkd3d_shader_signature *patch_constant_signature = &shader_desc->patch_constant_signature; const struct vkd3d_shader_signature *output_signature = &shader_desc->output_signature; @@ -2216,7 +2195,7 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader } } - compiler->scan_info = scan_info; + compiler->scan_descriptor_info = scan_descriptor_info; vkd3d_dxbc_compiler_emit_initial_declarations(compiler); @@ -5177,13 +5156,13 @@ static const struct vkd3d_shader_descriptor_info *vkd3d_dxbc_compiler_get_descri struct vkd3d_dxbc_compiler *compiler, enum vkd3d_shader_descriptor_type type, unsigned int register_space, unsigned int register_index) { - const struct vkd3d_shader_scan_info *scan_info = compiler->scan_info; + const struct vkd3d_shader_scan_descriptor_info *descriptor_info = compiler->scan_descriptor_info; const struct vkd3d_shader_descriptor_info *d; unsigned int i; - for (i = 0; i < scan_info->descriptor_count; ++i) + for (i = 0; i < descriptor_info->descriptor_count; ++i) { - d = &scan_info->descriptors[i]; + d = &descriptor_info->descriptors[i]; if (d->type == type && d->register_space == register_space && d->register_index == register_index) return d; } diff --git a/libs/vkd3d-shader/vkd3d_shader.map b/libs/vkd3d-shader/vkd3d_shader.map index 55b50ad4..9c9f0a51 100644 --- a/libs/vkd3d-shader/vkd3d_shader.map +++ b/libs/vkd3d-shader/vkd3d_shader.map @@ -6,12 +6,12 @@ global: vkd3d_shader_find_signature_element; vkd3d_shader_free_messages; vkd3d_shader_free_root_signature; - vkd3d_shader_free_scan_info; + vkd3d_shader_free_scan_descriptor_info; vkd3d_shader_free_shader_code; vkd3d_shader_free_shader_signature; vkd3d_shader_parse_input_signature; vkd3d_shader_parse_root_signature; - vkd3d_shader_scan_dxbc; + vkd3d_shader_scan; vkd3d_shader_serialize_root_signature; local: *; diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index cf8b2896..5d504875 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -285,10 +285,11 @@ void vkd3d_shader_free_messages(char *messages) int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, char **messages) { + struct vkd3d_shader_scan_descriptor_info scan_descriptor_info; struct vkd3d_shader_message_context message_context; struct vkd3d_shader_instruction instruction; + struct vkd3d_shader_compile_info scan_info; struct vkd3d_dxbc_compiler *spirv_compiler; - struct vkd3d_shader_scan_info scan_info; struct vkd3d_shader_parser parser; int ret; @@ -300,9 +301,12 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, if ((ret = vkd3d_shader_validate_compile_info(compile_info)) < 0) return ret; - scan_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO; - scan_info.next = NULL; - if ((ret = vkd3d_shader_scan_dxbc(&compile_info->source, &scan_info, messages)) < 0) + scan_info = *compile_info; + scan_descriptor_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO; + scan_descriptor_info.next = scan_info.next; + scan_info.next = &scan_descriptor_info; + + if ((ret = vkd3d_shader_scan(&scan_info, messages)) < 0) return ret; if (!vkd3d_shader_message_context_init(&message_context, compile_info->log_level, compile_info->source_name)) @@ -317,15 +321,19 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, } vkd3d_shader_message_context_cleanup(&message_context); if (ret < 0) + { + vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info); return ret; + } vkd3d_shader_dump_shader(parser.shader_version.type, &compile_info->source); if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser.shader_version, - &parser.shader_desc, compile_info, &scan_info))) + &parser.shader_desc, compile_info, &scan_descriptor_info))) { ERR("Failed to create DXBC compiler.\n"); vkd3d_shader_parser_destroy(&parser); + vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info); return VKD3D_ERROR; } @@ -336,9 +344,8 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, if (instruction.handler_idx == VKD3DSIH_INVALID) { WARN("Encountered unrecognized or invalid instruction.\n"); - vkd3d_dxbc_compiler_destroy(spirv_compiler); - vkd3d_shader_parser_destroy(&parser); - return VKD3D_ERROR_INVALID_ARGUMENT; + ret = VKD3D_ERROR_INVALID_SHADER; + break; } if ((ret = vkd3d_dxbc_compiler_handle_instruction(spirv_compiler, &instruction)) < 0) @@ -350,13 +357,13 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, vkd3d_dxbc_compiler_destroy(spirv_compiler); vkd3d_shader_parser_destroy(&parser); - vkd3d_shader_free_scan_info(&scan_info); + vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info); return ret; } struct vkd3d_shader_scan_context { - struct vkd3d_shader_scan_info *scan_info; + struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info; size_t descriptors_size; struct vkd3d_shader_message_context message_context; @@ -385,11 +392,12 @@ struct vkd3d_shader_scan_context }; static bool vkd3d_shader_scan_context_init(struct vkd3d_shader_scan_context *context, - struct vkd3d_shader_scan_info *scan_info) + struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info, + enum vkd3d_shader_log_level log_level, const char *source_name) { memset(context, 0, sizeof(*context)); - context->scan_info = scan_info; - return vkd3d_shader_message_context_init(&context->message_context, VKD3D_SHADER_LOG_INFO, NULL); + context->scan_descriptor_info = scan_descriptor_info; + return vkd3d_shader_message_context_init(&context->message_context, log_level, source_name); } static void vkd3d_shader_scan_context_cleanup(struct vkd3d_shader_scan_context *context) @@ -471,7 +479,7 @@ static struct vkd3d_shader_descriptor_info *vkd3d_shader_scan_get_uav_descriptor for (i = 0; i < context->uav_range_count; ++i) { if (context->uav_ranges[i].id == range_id) - return &context->scan_info->descriptors[context->uav_ranges[i].descriptor_idx]; + return &context->scan_descriptor_info->descriptors[context->uav_ranges[i].descriptor_idx]; } return NULL; @@ -492,7 +500,7 @@ static void vkd3d_shader_scan_record_uav_read(struct vkd3d_shader_scan_context * { struct vkd3d_shader_descriptor_info *d; - if (!context->scan_info) + if (!context->scan_descriptor_info) return; d = vkd3d_shader_scan_get_uav_descriptor_info(context, reg->idx[0].offset); @@ -511,7 +519,7 @@ static void vkd3d_shader_scan_record_uav_counter(struct vkd3d_shader_scan_contex { struct vkd3d_shader_descriptor_info *d; - if (!context->scan_info) + if (!context->scan_descriptor_info) return; d = vkd3d_shader_scan_get_uav_descriptor_info(context, reg->idx[0].offset); @@ -523,17 +531,17 @@ static bool vkd3d_shader_scan_add_descriptor(struct vkd3d_shader_scan_context *c enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_resource_data_type resource_data_type, unsigned int flags) { - struct vkd3d_shader_scan_info *scan_info = context->scan_info; + struct vkd3d_shader_scan_descriptor_info *info = context->scan_descriptor_info; struct vkd3d_shader_descriptor_info *d; - if (!vkd3d_array_reserve((void **)&scan_info->descriptors, &context->descriptors_size, - scan_info->descriptor_count + 1, sizeof(*scan_info->descriptors))) + if (!vkd3d_array_reserve((void **)&info->descriptors, &context->descriptors_size, + info->descriptor_count + 1, sizeof(*info->descriptors))) { ERR("Failed to allocate descriptor info.\n"); return false; } - d = &scan_info->descriptors[scan_info->descriptor_count]; + d = &info->descriptors[info->descriptor_count]; d->type = type; d->register_space = register_space; d->register_index = register_index; @@ -541,7 +549,7 @@ static bool vkd3d_shader_scan_add_descriptor(struct vkd3d_shader_scan_context *c d->resource_data_type = resource_data_type; d->flags = flags; d->count = 1; - ++scan_info->descriptor_count; + ++info->descriptor_count; return true; } @@ -568,7 +576,7 @@ static void vkd3d_shader_scan_constant_buffer_declaration(struct vkd3d_shader_sc { const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb; - if (!context->scan_info) + if (!context->scan_descriptor_info) return; vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV, cb->register_space, @@ -581,7 +589,7 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte const struct vkd3d_shader_sampler *sampler = &instruction->declaration.sampler; unsigned int flags; - if (!context->scan_info) + if (!context->scan_descriptor_info) return; if (instruction->flags & VKD3DSI_SAMPLER_COMPARISON_MODE) @@ -598,7 +606,7 @@ static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_cont { enum vkd3d_shader_descriptor_type type; - if (!context->scan_info) + if (!context->scan_descriptor_info) return; if (resource->reg.reg.type == VKD3DSPR_UAV) @@ -609,7 +617,7 @@ static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_cont resource->register_index, resource_type, resource_data_type, 0); if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) vkd3d_shader_scan_add_uav_range(context, resource->reg.reg.idx[0].offset, - context->scan_info->descriptor_count - 1); + context->scan_descriptor_info->descriptor_count - 1); } static void vkd3d_shader_scan_typed_resource_declaration(struct vkd3d_shader_scan_context *context, @@ -811,31 +819,44 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte return VKD3D_OK; } -int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc, - struct vkd3d_shader_scan_info *scan_info, char **messages) +int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages) { + struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info; struct vkd3d_shader_message_context *message_context; struct vkd3d_shader_instruction instruction; struct vkd3d_shader_scan_context context; struct vkd3d_shader_parser parser; int ret; - TRACE("dxbc {%p, %zu}, scan_info %p, messages %p.\n", dxbc->code, dxbc->size, scan_info, messages); + TRACE("compile_info %p, messages %p.\n", compile_info, messages); if (messages) *messages = NULL; - if (scan_info->type != VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO) + if (compile_info->type != VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO) { - WARN("Invalid structure type %#x.\n", scan_info->type); + WARN("Invalid structure type %#x.\n", compile_info->type); return VKD3D_ERROR_INVALID_ARGUMENT; } - if (!vkd3d_shader_scan_context_init(&context, scan_info)) + if (compile_info->source_type != VKD3D_SHADER_SOURCE_DXBC_TPF) + { + WARN("Unsupported source type %#x.\n", compile_info->source_type); + return VKD3D_ERROR_INVALID_ARGUMENT; + } + + if ((scan_descriptor_info = vkd3d_find_struct(compile_info->next, SCAN_DESCRIPTOR_INFO))) + { + scan_descriptor_info->descriptors = NULL; + scan_descriptor_info->descriptor_count = 0; + } + + if (!vkd3d_shader_scan_context_init(&context, scan_descriptor_info, + compile_info->log_level, compile_info->source_name)) return VKD3D_ERROR; message_context = &context.message_context; - if ((ret = vkd3d_shader_parser_init(&parser, dxbc, message_context)) < 0) + if ((ret = vkd3d_shader_parser_init(&parser, &compile_info->source, message_context)) < 0) { vkd3d_shader_message_context_trace_messages(message_context); if (messages && !(*messages = vkd3d_shader_message_context_copy_messages(message_context))) @@ -847,8 +868,6 @@ int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc, if (TRACE_ON()) vkd3d_shader_trace(parser.data); - memset(scan_info, 0, sizeof(*scan_info)); - message_context->line = 2; /* Line 1 is the version token. */ message_context->column = 1; while (!shader_sm4_is_end(parser.data, &parser.ptr)) @@ -858,14 +877,14 @@ int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc, if (instruction.handler_idx == VKD3DSIH_INVALID) { WARN("Encountered unrecognized or invalid instruction.\n"); - vkd3d_shader_free_scan_info(scan_info); + vkd3d_shader_free_scan_descriptor_info(scan_descriptor_info); ret = VKD3D_ERROR_INVALID_SHADER; goto done; } if ((ret = vkd3d_shader_scan_instruction(&context, &instruction)) < 0) { - vkd3d_shader_free_scan_info(scan_info); + vkd3d_shader_free_scan_descriptor_info(scan_descriptor_info); goto done; } ++message_context->line; @@ -882,12 +901,12 @@ done: return ret; } -void vkd3d_shader_free_scan_info(struct vkd3d_shader_scan_info *scan_info) +void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) { - if (!scan_info) + if (!scan_descriptor_info) return; - vkd3d_free(scan_info->descriptors); + vkd3d_free(scan_descriptor_info->descriptors); } void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code) diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 4fa17d64..ae2f6c2f 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -846,7 +846,7 @@ struct vkd3d_dxbc_compiler; struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info, - const struct vkd3d_shader_scan_info *scan_info) DECLSPEC_HIDDEN; + const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) DECLSPEC_HIDDEN; int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN; int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler, @@ -941,6 +941,27 @@ static inline unsigned int vkd3d_compact_swizzle(unsigned int swizzle, unsigned return compacted_swizzle; } +struct vkd3d_struct +{ + enum vkd3d_shader_structure_type type; + const void *next; +}; + +#define vkd3d_find_struct(c, t) vkd3d_find_struct_(c, VKD3D_SHADER_STRUCTURE_TYPE_##t) +static inline void *vkd3d_find_struct_(const struct vkd3d_struct *chain, + enum vkd3d_shader_structure_type type) +{ + while (chain) + { + if (chain->type == type) + return (void *)chain; + + chain = chain->next; + } + + return NULL; +} + #define VKD3D_DXBC_MAX_SOURCE_COUNT 6 #define VKD3D_DXBC_HEADER_SIZE (8 * sizeof(uint32_t)) diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 316132b0..93f22ce0 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -1376,6 +1376,25 @@ static HRESULT create_shader_stage(struct d3d12_device *device, return S_OK; } +static int vkd3d_scan_dxbc(const D3D12_SHADER_BYTECODE *code, + struct vkd3d_shader_scan_descriptor_info *descriptor_info) +{ + struct vkd3d_shader_compile_info compile_info; + + compile_info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; + compile_info.next = descriptor_info; + compile_info.source.code = code->pShaderBytecode; + compile_info.source.size = code->BytecodeLength; + compile_info.source_type = VKD3D_SHADER_SOURCE_DXBC_TPF; + compile_info.target_type = VKD3D_SHADER_TARGET_SPIRV_BINARY; + compile_info.options = NULL; + compile_info.option_count = 0; + compile_info.log_level = VKD3D_SHADER_LOG_NONE; + compile_info.source_name = NULL; + + return vkd3d_shader_scan(&compile_info, NULL); +} + static HRESULT vkd3d_create_compute_pipeline(struct d3d12_device *device, const D3D12_SHADER_BYTECODE *code, const struct vkd3d_shader_interface_info *shader_interface, VkPipelineLayout vk_pipeline_layout, VkPipeline *vk_pipeline) @@ -1409,7 +1428,7 @@ static HRESULT vkd3d_create_compute_pipeline(struct d3d12_device *device, static HRESULT d3d12_pipeline_state_init_compute_uav_counters(struct d3d12_pipeline_state *state, struct d3d12_device *device, const struct d3d12_root_signature *root_signature, - const struct vkd3d_shader_scan_info *shader_info) + const struct vkd3d_shader_scan_descriptor_info *shader_info) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct vkd3d_descriptor_set_context context; @@ -1503,11 +1522,10 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st struct d3d12_device *device, const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + struct vkd3d_shader_scan_descriptor_info shader_info; struct vkd3d_shader_interface_info shader_interface; const struct d3d12_root_signature *root_signature; - struct vkd3d_shader_scan_info shader_info; VkPipelineLayout vk_pipeline_layout; - struct vkd3d_shader_code dxbc; HRESULT hr; int ret; @@ -1525,11 +1543,9 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st return E_INVALIDARG; } - dxbc.code = desc->CS.pShaderBytecode; - dxbc.size = desc->CS.BytecodeLength; - shader_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO; + shader_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO; shader_info.next = NULL; - if ((ret = vkd3d_shader_scan_dxbc(&dxbc, &shader_info, NULL)) < 0) + if ((ret = vkd3d_scan_dxbc(&desc->CS, &shader_info)) < 0) { WARN("Failed to scan shader bytecode, vkd3d result %d.\n", ret); return hresult_from_vkd3d_result(ret); @@ -1541,7 +1557,7 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st WARN("Failed to create descriptor set layout for UAV counters, hr %#x.\n", hr); return hr; } - vkd3d_shader_free_scan_info(&shader_info); + vkd3d_shader_free_scan_descriptor_info(&shader_info); shader_interface.type = VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO; shader_interface.next = NULL; @@ -2266,14 +2282,17 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s for (i = 0; i < ARRAY_SIZE(shader_stages); ++i) { + struct vkd3d_shader_scan_descriptor_info shader_info = + { + .type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO, + }; const D3D12_SHADER_BYTECODE *b = (const void *)((uintptr_t)desc + shader_stages[i].offset); - struct vkd3d_shader_scan_info shader_info = {VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO}; const struct vkd3d_shader_code dxbc = {b->pShaderBytecode, b->BytecodeLength}; if (!b->pShaderBytecode) continue; - if ((ret = vkd3d_shader_scan_dxbc(&dxbc, &shader_info, NULL)) < 0) + if ((ret = vkd3d_scan_dxbc(b, &shader_info)) < 0) { WARN("Failed to scan shader bytecode, stage %#x, vkd3d result %d.\n", shader_stages[i].stage, ret); @@ -2291,7 +2310,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s break; } } - vkd3d_shader_free_scan_info(&shader_info); + vkd3d_shader_free_scan_descriptor_info(&shader_info); target_info = NULL; switch (shader_stages[i].stage) diff --git a/tests/vkd3d_shader_api.c b/tests/vkd3d_shader_api.c index 079559a5..be63b393 100644 --- a/tests/vkd3d_shader_api.c +++ b/tests/vkd3d_shader_api.c @@ -68,10 +68,14 @@ static void test_invalid_shaders(void) rc = vkd3d_shader_compile(&info, &spirv, NULL); ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); + + rc = vkd3d_shader_scan(&info, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); } static void test_vkd3d_shader_pfns(void) { + PFN_vkd3d_shader_free_scan_descriptor_info pfn_vkd3d_shader_free_scan_descriptor_info; PFN_vkd3d_shader_serialize_root_signature pfn_vkd3d_shader_serialize_root_signature; PFN_vkd3d_shader_find_signature_element pfn_vkd3d_shader_find_signature_element; PFN_vkd3d_shader_free_shader_signature pfn_vkd3d_shader_free_shader_signature; @@ -79,13 +83,13 @@ static void test_vkd3d_shader_pfns(void) PFN_vkd3d_shader_parse_root_signature pfn_vkd3d_shader_parse_root_signature; PFN_vkd3d_shader_free_root_signature pfn_vkd3d_shader_free_root_signature; PFN_vkd3d_shader_free_shader_code pfn_vkd3d_shader_free_shader_code; - PFN_vkd3d_shader_scan_dxbc pfn_vkd3d_shader_scan_dxbc; PFN_vkd3d_shader_compile pfn_vkd3d_shader_compile; + PFN_vkd3d_shader_scan pfn_vkd3d_shader_scan; struct vkd3d_shader_versioned_root_signature_desc root_signature_desc; + struct vkd3d_shader_scan_descriptor_info descriptor_info; struct vkd3d_shader_signature_element *element; struct vkd3d_shader_compile_info compile_info; - struct vkd3d_shader_scan_info scan_info; struct vkd3d_shader_signature signature; struct vkd3d_shader_code dxbc, spirv; int rc; @@ -112,6 +116,7 @@ static void test_vkd3d_shader_pfns(void) }; static const struct vkd3d_shader_code vs = {vs_code, sizeof(vs_code)}; + pfn_vkd3d_shader_free_scan_descriptor_info = vkd3d_shader_free_scan_descriptor_info; pfn_vkd3d_shader_serialize_root_signature = vkd3d_shader_serialize_root_signature; pfn_vkd3d_shader_find_signature_element = vkd3d_shader_find_signature_element; pfn_vkd3d_shader_free_shader_signature = vkd3d_shader_free_shader_signature; @@ -119,8 +124,8 @@ static void test_vkd3d_shader_pfns(void) pfn_vkd3d_shader_parse_root_signature = vkd3d_shader_parse_root_signature; pfn_vkd3d_shader_free_root_signature = vkd3d_shader_free_root_signature; pfn_vkd3d_shader_free_shader_code = vkd3d_shader_free_shader_code; - pfn_vkd3d_shader_scan_dxbc = vkd3d_shader_scan_dxbc; pfn_vkd3d_shader_compile = vkd3d_shader_compile; + pfn_vkd3d_shader_scan = vkd3d_shader_scan; rc = pfn_vkd3d_shader_serialize_root_signature(&empty_rs_desc, &dxbc); ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); @@ -149,10 +154,13 @@ static void test_vkd3d_shader_pfns(void) ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); pfn_vkd3d_shader_free_shader_code(&spirv); - memset(&scan_info, 0, sizeof(scan_info)); - scan_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO; - rc = pfn_vkd3d_shader_scan_dxbc(&vs, &scan_info, NULL); + memset(&descriptor_info, 0, sizeof(descriptor_info)); + descriptor_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO; + compile_info.next = &descriptor_info; + + rc = pfn_vkd3d_shader_scan(&compile_info, NULL); ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); + pfn_vkd3d_shader_free_scan_descriptor_info(&descriptor_info); } START_TEST(vkd3d_shader_api)