[PATCH 0/2] MR2411: wined3d: Use vkd3d-shader to disassemble shaders.

List overview All Threads

newer

older

[PATCH v3 0/10] MR2421:...

[PATCH 0/3] MR2405: ddraw:...

Henri Verbeet (＠hverbeet)

15 Mar 2023 15 Mar '23

11:28 a.m.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/2411

Show replies by date

Henri Verbeet

15 Mar 15 Mar

11:28 a.m.

New subject: [PATCH 1/2] wined3d: Get rid of the wined3d_shader_byte_code_format enum.

From: Henri Verbeet hverbeet@codeweavers.com

It's been made redundant by the vkd3d_shader_source_type enum. --- dlls/wined3d/shader.c | 18 +++++++++--------- dlls/wined3d/shader_sm4.c | 10 +++++----- dlls/wined3d/shader_spirv.c | 2 -- dlls/wined3d/wined3d_private.h | 10 +++------- 4 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index a156d27e7ac..6c274fe2017 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -404,18 +404,18 @@ static void shader_signature_from_usage(struct wined3d_shader_signature_element e->mask = write_mask; }

-static const struct wined3d_shader_frontend *shader_select_frontend(enum wined3d_shader_byte_code_format format) +static const struct wined3d_shader_frontend *shader_select_frontend(enum vkd3d_shader_source_type source_type) { - switch (format) + switch (source_type) { - case WINED3D_SHADER_BYTE_CODE_FORMAT_SM1: + case VKD3D_SHADER_SOURCE_D3D_BYTECODE: return &sm1_shader_frontend;

- case WINED3D_SHADER_BYTE_CODE_FORMAT_SM4: + case VKD3D_SHADER_SOURCE_DXBC_TPF: return &sm4_shader_frontend;

default: - WARN("Invalid byte code format %#x specified.\n", format); + WARN("Invalid source type %#x specified.\n", source_type); return NULL; } } @@ -3628,7 +3628,7 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device const DWORD *ptr; void *fe_data;

- if (!(shader->frontend = shader_select_frontend(WINED3D_SHADER_BYTE_CODE_FORMAT_SM1))) + if (!(shader->frontend = shader_select_frontend(VKD3D_SHADER_SOURCE_D3D_BYTECODE))) { FIXME("Unable to find frontend for shader.\n"); hr = WINED3DERR_INVALIDCALL; @@ -3663,7 +3663,7 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device } else { - enum wined3d_shader_byte_code_format format; + enum vkd3d_shader_source_type source_type; unsigned int max_version;

if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) @@ -3675,10 +3675,10 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device shader->byte_code_size = desc->byte_code_size;

max_version = shader_max_version_from_feature_level(device->cs->c.state->feature_level); - if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) + if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &source_type))) goto fail;

- if (!(shader->frontend = shader_select_frontend(format))) + if (!(shader->frontend = shader_select_frontend(source_type))) { FIXME("Unable to find frontend for shader.\n"); hr = WINED3DERR_INVALIDCALL; diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index d5ca8ea9501..a55bc2df3f5 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -1845,7 +1845,7 @@ struct aon9_header struct shader_handler_context { struct wined3d_shader *shader; - enum wined3d_shader_byte_code_format *format; + enum vkd3d_shader_source_type *source_type; unsigned int max_version; };

@@ -2094,7 +2094,7 @@ static HRESULT shader_dxbc_chunk_handler(const char *data, unsigned int data_siz FIXME("Multiple shader code chunks.\n"); shader->function = (const DWORD *)data; shader->functionLength = data_size; - *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4; + *ctx->source_type = VKD3D_SHADER_SOURCE_DXBC_TPF; break;

case TAG_AON9: @@ -2123,7 +2123,7 @@ static HRESULT shader_dxbc_chunk_handler(const char *data, unsigned int data_siz FIXME("Multiple shader code chunks.\n"); shader->function = (const DWORD *)byte_code; shader->functionLength = data_size - header->byte_code_offset; - *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; + *ctx->source_type = VKD3D_SHADER_SOURCE_D3D_BYTECODE; TRACE("Feature level 9 shader version 0%08x, 0%08lx.\n", header->shader_version, *shader->function); } @@ -2142,13 +2142,13 @@ static HRESULT shader_dxbc_chunk_handler(const char *data, unsigned int data_siz }

HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, - unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format) + unsigned int max_shader_version, enum vkd3d_shader_source_type *source_type) { struct shader_handler_context ctx; HRESULT hr;

ctx.shader = shader; - ctx.format = format; + ctx.source_type = source_type; ctx.max_version = max_shader_version;

hr = parse_dxbc(shader->byte_code, shader->byte_code_size, shader_dxbc_chunk_handler, &ctx); diff --git a/dlls/wined3d/shader_spirv.c b/dlls/wined3d/shader_spirv.c index 1dff25cc6a6..b7205717760 100644 --- a/dlls/wined3d/shader_spirv.c +++ b/dlls/wined3d/shader_spirv.c @@ -18,8 +18,6 @@ */

#include "wined3d_private.h" -#define LIBVKD3D_SHADER_SOURCE -#include <vkd3d_shader.h>

WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);

diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 0c8cc03738a..2d420a60369 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -34,6 +34,8 @@ #include <math.h> #include <limits.h> #include <float.h> +#define LIBVKD3D_SHADER_SOURCE +#include <vkd3d_shader.h> #include "ntstatus.h" #define WIN32_NO_STATUS #define NONAMELESSUNION @@ -560,12 +562,6 @@ struct wined3d_settings

extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN;

-enum wined3d_shader_byte_code_format -{ - WINED3D_SHADER_BYTE_CODE_FORMAT_SM1, - WINED3D_SHADER_BYTE_CODE_FORMAT_SM4, -}; - enum wined3d_shader_resource_type { WINED3D_SHADER_RESOURCE_NONE, @@ -1470,7 +1466,7 @@ extern const struct wined3d_shader_frontend sm1_shader_frontend DECLSPEC_HIDDEN; extern const struct wined3d_shader_frontend sm4_shader_frontend DECLSPEC_HIDDEN;

HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, - unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format) DECLSPEC_HIDDEN; + unsigned int max_shader_version, enum vkd3d_shader_source_type *source_type) DECLSPEC_HIDDEN; BOOL shader_get_stream_output_register_info(const struct wined3d_shader *shader, const struct wined3d_stream_output_element *so_element, unsigned int *register_idx, unsigned int *component_idx) DECLSPEC_HIDDEN;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/2411

Henri Verbeet

11:28 a.m.

New subject: [PATCH 2/2] wined3d: Use vkd3d-shader to disassemble shaders.

From: Henri Verbeet hverbeet@codeweavers.com

--- dlls/wined3d/shader.c | 1627 ++++++----------------------------------- 1 file changed, 219 insertions(+), 1408 deletions(-)

diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 6c274fe2017..9924a2d806e 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -298,40 +298,6 @@ static const char * const semantic_names[] = /* WINED3D_DECL_USAGE_SAMPLE */ "SAMPLE", };

-static const struct -{ - enum wined3d_shader_input_sysval_semantic sysval_semantic; - const char *sysval_name; -} -shader_input_sysval_semantic_names[] = -{ - {WINED3D_SIV_POSITION, "position"}, - {WINED3D_SIV_CLIP_DISTANCE, "clip_distance"}, - {WINED3D_SIV_CULL_DISTANCE, "cull_distance"}, - {WINED3D_SIV_RENDER_TARGET_ARRAY_INDEX, "render_target_array_index"}, - {WINED3D_SIV_VIEWPORT_ARRAY_INDEX, "viewport_array_index"}, - {WINED3D_SIV_VERTEX_ID, "vertex_id"}, - {WINED3D_SIV_INSTANCE_ID, "instance_id"}, - {WINED3D_SIV_PRIMITIVE_ID, "primitive_id"}, - {WINED3D_SIV_IS_FRONT_FACE, "is_front_face"}, - {WINED3D_SIV_SAMPLE_INDEX, "sample_index"}, - {WINED3D_SIV_QUAD_U0_TESS_FACTOR, "finalQuadUeq0EdgeTessFactor"}, - {WINED3D_SIV_QUAD_V0_TESS_FACTOR, "finalQuadVeq0EdgeTessFactor"}, - {WINED3D_SIV_QUAD_U1_TESS_FACTOR, "finalQuadUeq1EdgeTessFactor"}, - {WINED3D_SIV_QUAD_V1_TESS_FACTOR, "finalQuadVeq1EdgeTessFactor"}, - {WINED3D_SIV_QUAD_U_INNER_TESS_FACTOR, "finalQuadUInsideTessFactor"}, - {WINED3D_SIV_QUAD_V_INNER_TESS_FACTOR, "finalQuadVInsideTessFactor"}, - {WINED3D_SIV_TRIANGLE_U_TESS_FACTOR, "finalTriUeq0EdgeTessFactor"}, - {WINED3D_SIV_TRIANGLE_V_TESS_FACTOR, "finalTriVeq0EdgeTessFactor"}, - {WINED3D_SIV_TRIANGLE_W_TESS_FACTOR, "finalTriWeq0EdgeTessFactor"}, - {WINED3D_SIV_TRIANGLE_INNER_TESS_FACTOR, "finalTriInsideTessFactor"}, - {WINED3D_SIV_LINE_DETAIL_TESS_FACTOR, "finalLineDetailTessFactor"}, - {WINED3D_SIV_LINE_DENSITY_TESS_FACTOR, "finalLineDensityTessFactor"}, -}; - -static void shader_dump_src_param(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version); - const char *debug_d3dshaderinstructionhandler(enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx) { if (handler_idx >= ARRAY_SIZE(shader_opcode_names)) @@ -565,22 +531,6 @@ void string_buffer_list_cleanup(struct wined3d_string_buffer_list *list) list_init(&list->list); }

-/* Convert floating point offset relative to a register file to an absolute - * offset for float constants. */ -static unsigned int shader_get_float_offset(enum wined3d_shader_register_type register_type, UINT register_idx) -{ - switch (register_type) - { - case WINED3DSPR_CONST: return register_idx; - case WINED3DSPR_CONST2: return 2048 + register_idx; - case WINED3DSPR_CONST3: return 4096 + register_idx; - case WINED3DSPR_CONST4: return 6144 + register_idx; - default: - FIXME("Unsupported register type: %u.\n", register_type); - return register_idx; - } -} - static void shader_delete_constant_list(struct list *clist) { struct wined3d_shader_lconst *constant, *constant_next; @@ -1883,1405 +1833,206 @@ unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_map return wined3d_log2i(map); }

-static void shader_dump_global_flags(struct wined3d_string_buffer *buffer, uint32_t global_flags) +/* Shared code in order to generate the bulk of the shader string. */ +HRESULT shader_generate_code(const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer, + const struct wined3d_shader_reg_maps *reg_maps, void *backend_ctx, + const DWORD *start, const DWORD *end) { - if (global_flags & WINED3DSGF_REFACTORING_ALLOWED) - { - shader_addline(buffer, "refactoringAllowed"); - global_flags &= ~WINED3DSGF_REFACTORING_ALLOWED; - if (global_flags) - shader_addline(buffer, " | "); - } + struct wined3d_device *device = shader->device; + const struct wined3d_shader_frontend *fe = shader->frontend; + void *fe_data = shader->frontend_data; + struct wined3d_shader_version shader_version; + struct wined3d_shader_parser_state state; + struct wined3d_shader_instruction ins; + struct wined3d_shader_tex_mx tex_mx; + struct wined3d_shader_context ctx; + const DWORD *ptr;

- if (global_flags & WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL) - { - shader_addline(buffer, "forceEarlyDepthStencil"); - global_flags &= ~WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL; - if (global_flags) - shader_addline(buffer, " | "); - } + /* Initialize current parsing state. */ + tex_mx.current_row = 0; + state.current_loop_depth = 0; + state.current_loop_reg = 0; + state.in_subroutine = FALSE;

- if (global_flags & WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS) - { - shader_addline(buffer, "enableRawAndStructuredBuffers"); - global_flags &= ~WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS; - } + ctx.shader = shader; + ctx.reg_maps = reg_maps; + ctx.buffer = buffer; + ctx.tex_mx = &tex_mx; + ctx.state = &state; + ctx.backend_data = backend_ctx; + ins.ctx = &ctx;

- if (global_flags) - shader_addline(buffer, "unknown_flags(%#x)", global_flags); -} + fe->shader_read_header(fe_data, &ptr, &shader_version); + if (start) + ptr = start;

-static void shader_dump_sync_flags(struct wined3d_string_buffer *buffer, uint32_t sync_flags) -{ - if (sync_flags & WINED3DSSF_GLOBAL_UAV) - { - shader_addline(buffer, "_uglobal"); - sync_flags &= ~WINED3DSSF_GLOBAL_UAV; - } - if (sync_flags & WINED3DSSF_GROUP_SHARED_MEMORY) - { - shader_addline(buffer, "_g"); - sync_flags &= ~WINED3DSSF_GROUP_SHARED_MEMORY; - } - if (sync_flags & WINED3DSSF_THREAD_GROUP) + while (!fe->shader_is_end(fe_data, &ptr) && ptr != end) { - shader_addline(buffer, "_t"); - sync_flags &= ~WINED3DSSF_THREAD_GROUP; - } - - if (sync_flags) - shader_addline(buffer, "_unknown_flags(%#x)", sync_flags); -} + /* Read opcode. */ + fe->shader_read_instruction(fe_data, &ptr, &ins);

-static void shader_dump_precise_flags(struct wined3d_string_buffer *buffer, uint32_t flags) -{ - if (!(flags & WINED3DSI_PRECISE_XYZW)) - return; + /* Unknown opcode and its parameters. */ + if (ins.handler_idx == WINED3DSIH_TABLE_SIZE) + { + WARN("Encountered unrecognised or invalid instruction.\n"); + return WINED3DERR_INVALIDCALL; + }

- shader_addline(buffer, " [precise"); - if (flags != WINED3DSI_PRECISE_XYZW) - { - shader_addline(buffer, "(%s%s%s%s)", - flags & WINED3DSI_PRECISE_X ? "x" : "", - flags & WINED3DSI_PRECISE_Y ? "y" : "", - flags & WINED3DSI_PRECISE_Z ? "z" : "", - flags & WINED3DSI_PRECISE_W ? "w" : ""); - } - shader_addline(buffer, "]"); -} + if (ins.predicate) + FIXME("Predicates not implemented.\n");

-static void shader_dump_uav_flags(struct wined3d_string_buffer *buffer, uint32_t uav_flags) -{ - if (uav_flags & WINED3DSUF_GLOBALLY_COHERENT) - { - shader_addline(buffer, "_glc"); - uav_flags &= ~WINED3DSUF_GLOBALLY_COHERENT; - } - if (uav_flags & WINED3DSUF_ORDER_PRESERVING_COUNTER) - { - shader_addline(buffer, "_opc"); - uav_flags &= ~WINED3DSUF_ORDER_PRESERVING_COUNTER; + /* Call appropriate function for output target */ + device->shader_backend->shader_handle_instruction(&ins); }

- if (uav_flags) - shader_addline(buffer, "_unknown_flags(%#x)", uav_flags); + return WINED3D_OK; }

-static void shader_dump_tessellator_domain(struct wined3d_string_buffer *buffer, - enum wined3d_tessellator_domain domain) +static void shader_cleanup(struct wined3d_shader *shader) { - switch (domain) + if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_HULL) { - case WINED3D_TESSELLATOR_DOMAIN_LINE: - shader_addline(buffer, "line"); - break; - case WINED3D_TESSELLATOR_DOMAIN_TRIANGLE: - shader_addline(buffer, "triangle"); - break; - case WINED3D_TESSELLATOR_DOMAIN_QUAD: - shader_addline(buffer, "quad"); - break; - default: - shader_addline(buffer, "unknown_tessellator_domain(%#x)", domain); - break; + heap_free(shader->u.hs.phases.control_point); + heap_free(shader->u.hs.phases.fork); + heap_free(shader->u.hs.phases.join); } -}

-static void shader_dump_tessellator_output_primitive(struct wined3d_string_buffer *buffer, - enum wined3d_tessellator_output_primitive output_primitive) -{ - switch (output_primitive) - { - case WINED3D_TESSELLATOR_OUTPUT_POINT: - shader_addline(buffer, "point"); - break; - case WINED3D_TESSELLATOR_OUTPUT_LINE: - shader_addline(buffer, "line"); - break; - case WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CW: - shader_addline(buffer, "triangle_cw"); - break; - case WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW: - shader_addline(buffer, "triangle_ccw"); - break; - default: - shader_addline(buffer, "unknown_tessellator_output_primitive(%#x)", output_primitive); - break; - } -} + heap_free(shader->patch_constant_signature.elements); + heap_free(shader->output_signature.elements); + heap_free(shader->input_signature.elements); + shader->device->shader_backend->shader_destroy(shader); + shader_cleanup_reg_maps(&shader->reg_maps); + heap_free(shader->byte_code); + shader_delete_constant_list(&shader->constantsF); + shader_delete_constant_list(&shader->constantsB); + shader_delete_constant_list(&shader->constantsI); + list_remove(&shader->shader_list_entry);

-static void shader_dump_tessellator_partitioning(struct wined3d_string_buffer *buffer, - enum wined3d_tessellator_partitioning partitioning) -{ - switch (partitioning) - { - case WINED3D_TESSELLATOR_PARTITIONING_INTEGER: - shader_addline(buffer, "integer"); - break; - case WINED3D_TESSELLATOR_PARTITIONING_POW2: - shader_addline(buffer, "pow2"); - break; - case WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD: - shader_addline(buffer, "fractional_odd"); - break; - case WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN: - shader_addline(buffer, "fractional_even"); - break; - default: - shader_addline(buffer, "unknown_tessellator_partitioning(%#x)", partitioning); - break; - } + if (shader->frontend && shader->frontend_data) + shader->frontend->shader_free(shader->frontend_data); }

-static void shader_dump_shader_input_sysval_semantic(struct wined3d_string_buffer *buffer, - enum wined3d_shader_input_sysval_semantic semantic) +struct shader_none_priv { - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(shader_input_sysval_semantic_names); ++i) - { - if (shader_input_sysval_semantic_names[i].sysval_semantic == semantic) - { - shader_addline(buffer, "%s", shader_input_sysval_semantic_names[i].sysval_name); - return; - } - } + const struct wined3d_vertex_pipe_ops *vertex_pipe; + const struct wined3d_fragment_pipe_ops *fragment_pipe; + BOOL ffp_proj_control; +};

- shader_addline(buffer, "unknown_shader_input_sysval_semantic(%#x)", semantic); -} +static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {} +static void shader_none_precompile(void *shader_priv, struct wined3d_shader *shader) {} +static void shader_none_select_compute(void *shader_priv, struct wined3d_context *context, + const struct wined3d_state *state) {} +static void shader_none_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count) {} +static void shader_none_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count) {} +static void shader_none_load_constants(void *shader_priv, struct wined3d_context *context, + const struct wined3d_state *state) {} +static void shader_none_destroy(struct wined3d_shader *shader) {} +static void shader_none_free_context_data(struct wined3d_context *context) {} +static void shader_none_init_context_state(struct wined3d_context *context) {}

-static void shader_dump_resource_type(struct wined3d_string_buffer *buffer, enum wined3d_shader_resource_type type) +/* Context activation is done by the caller. */ +static void shader_none_select(void *shader_priv, struct wined3d_context *context, + const struct wined3d_state *state) { - static const char *const resource_type_names[] = - { - /* WINED3D_SHADER_RESOURCE_NONE */ "none", - /* WINED3D_SHADER_RESOURCE_BUFFER */ "buffer", - /* WINED3D_SHADER_RESOURCE_TEXTURE_1D */ "texture1d", - /* WINED3D_SHADER_RESOURCE_TEXTURE_2D */ "texture2d", - /* WINED3D_SHADER_RESOURCE_TEXTURE_2DMS */ "texture2dms", - /* WINED3D_SHADER_RESOURCE_TEXTURE_3D */ "texture3d", - /* WINED3D_SHADER_RESOURCE_TEXTURE_CUBE */ "texturecube", - /* WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY */ "texture1darray", - /* WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY */ "texture2darray", - /* WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY */ "texture2dmsarray", - /* WINED3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY */ "texturecubearray", - }; + struct shader_none_priv *priv = shader_priv;

- if (type < ARRAY_SIZE(resource_type_names)) - shader_addline(buffer, "%s", resource_type_names[type]); - else - shader_addline(buffer, "unknown"); + priv->vertex_pipe->vp_enable(context, !use_vs(state)); + priv->fragment_pipe->fp_enable(context, !use_ps(state)); }

-static void shader_dump_data_type(struct wined3d_string_buffer *buffer, enum wined3d_data_type type) +/* Context activation is done by the caller. */ +static void shader_none_disable(void *shader_priv, struct wined3d_context *context) { - static const char *const data_type_names[] = - { - /* WINED3D_DATA_FLOAT */ "(float)", - /* WINED3D_DATA_INT */ "(int)", - /* WINED3D_DATA_RESOURCE */ "(resource)", - /* WINED3D_DATA_SAMPLER */ "(sampler)", - /* WINED3D_DATA_UAV */ "(uav)", - /* WINED3D_DATA_UINT */ "(uint)", - /* WINED3D_DATA_UNORM */ "(unorm)", - /* WINED3D_DATA_SNORM */ "(snorm)", - /* WINED3D_DATA_OPAQUE */ "(opaque)", - }; + struct shader_none_priv *priv = shader_priv;

- if (type < ARRAY_SIZE(data_type_names)) - shader_addline(buffer, "%s", data_type_names[type]); - else - shader_addline(buffer, "(unknown)"); + priv->vertex_pipe->vp_enable(context, FALSE); + priv->fragment_pipe->fp_enable(context, FALSE); + + context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL) + | (1u << WINED3D_SHADER_TYPE_VERTEX) + | (1u << WINED3D_SHADER_TYPE_GEOMETRY) + | (1u << WINED3D_SHADER_TYPE_HULL) + | (1u << WINED3D_SHADER_TYPE_DOMAIN) + | (1u << WINED3D_SHADER_TYPE_COMPUTE); }

-static void shader_dump_decl_usage(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_semantic *semantic, unsigned int flags, - const struct wined3d_shader_version *shader_version) +static HRESULT shader_none_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe, + const struct wined3d_fragment_pipe_ops *fragment_pipe) { - shader_addline(buffer, "dcl"); - - if (semantic->reg.reg.type == WINED3DSPR_SAMPLER) - { - switch (semantic->resource_type) - { - case WINED3D_SHADER_RESOURCE_TEXTURE_2D: - shader_addline(buffer, "_2d"); - break; - - case WINED3D_SHADER_RESOURCE_TEXTURE_3D: - shader_addline(buffer, "_3d"); - break; + struct fragment_caps fragment_caps; + void *vertex_priv, *fragment_priv; + struct shader_none_priv *priv;

- case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE: - shader_addline(buffer, "_cube"); - break; + if (!(priv = heap_alloc(sizeof(*priv)))) + return E_OUTOFMEMORY;

- default: - shader_addline(buffer, "_unknown_resource_type(%#x)", semantic->resource_type); - break; - } - } - else if (semantic->reg.reg.type == WINED3DSPR_RESOURCE || semantic->reg.reg.type == WINED3DSPR_UAV) + if (!(vertex_priv = vertex_pipe->vp_alloc(&none_shader_backend, priv))) { - if (semantic->reg.reg.type == WINED3DSPR_RESOURCE) - shader_addline(buffer, "_resource_"); - else - shader_addline(buffer, "_uav_"); - shader_dump_resource_type(buffer, semantic->resource_type); - if (semantic->reg.reg.type == WINED3DSPR_UAV) - shader_dump_uav_flags(buffer, flags); - shader_dump_data_type(buffer, semantic->resource_data_type); + ERR("Failed to initialize vertex pipe.\n"); + heap_free(priv); + return E_FAIL; } - else - { - /* Pixel shaders 3.0 don't have usage semantics. */ - if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL) - return; - else - shader_addline(buffer, "_");

- switch (semantic->usage) - { - case WINED3D_DECL_USAGE_POSITION: - shader_addline(buffer, "position%u", semantic->usage_idx); - break; + if (!(fragment_priv = fragment_pipe->alloc_private(&none_shader_backend, priv))) + { + ERR("Failed to initialize fragment pipe.\n"); + vertex_pipe->vp_free(device, NULL); + heap_free(priv); + return E_FAIL; + }

- case WINED3D_DECL_USAGE_BLEND_INDICES: - shader_addline(buffer, "blend"); - break; + priv->vertex_pipe = vertex_pipe; + priv->fragment_pipe = fragment_pipe; + fragment_pipe->get_caps(device->adapter, &fragment_caps); + priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;

- case WINED3D_DECL_USAGE_BLEND_WEIGHT: - shader_addline(buffer, "weight"); - break; + device->vertex_priv = vertex_priv; + device->fragment_priv = fragment_priv; + device->shader_priv = priv;

- case WINED3D_DECL_USAGE_NORMAL: - shader_addline(buffer, "normal%u", semantic->usage_idx); - break; + return WINED3D_OK; +}

- case WINED3D_DECL_USAGE_PSIZE: - shader_addline(buffer, "psize"); - break; +static void shader_none_free(struct wined3d_device *device, struct wined3d_context *context) +{ + struct shader_none_priv *priv = device->shader_priv;

- case WINED3D_DECL_USAGE_COLOR: - if (!semantic->usage_idx) - shader_addline(buffer, "color"); - else - shader_addline(buffer, "specular%u", (semantic->usage_idx - 1)); - break; + priv->fragment_pipe->free_private(device, context); + priv->vertex_pipe->vp_free(device, context); + heap_free(priv); +}

- case WINED3D_DECL_USAGE_TEXCOORD: - shader_addline(buffer, "texture%u", semantic->usage_idx); - break; +static BOOL shader_none_allocate_context_data(struct wined3d_context *context) +{ + return TRUE; +}

- case WINED3D_DECL_USAGE_TANGENT: - shader_addline(buffer, "tangent"); - break; +static void shader_none_get_caps(const struct wined3d_adapter *adapter, struct shader_caps *caps) +{ + /* Set the shader caps to 0 for the none shader backend */ + memset(caps, 0, sizeof(*caps)); +}

- case WINED3D_DECL_USAGE_BINORMAL: - shader_addline(buffer, "binormal"); - break; +static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup) +{ + /* We "support" every possible fixup, since we don't support any shader + * model, and will never have to actually sample a texture. */ + return TRUE; +}

- case WINED3D_DECL_USAGE_TESS_FACTOR: - shader_addline(buffer, "tessfactor"); - break; +static BOOL shader_none_has_ffp_proj_control(void *shader_priv) +{ + struct shader_none_priv *priv = shader_priv;

- case WINED3D_DECL_USAGE_POSITIONT: - shader_addline(buffer, "positionT%u", semantic->usage_idx); - break; + return priv->ffp_proj_control; +}

- case WINED3D_DECL_USAGE_FOG: - shader_addline(buffer, "fog"); - break; - - case WINED3D_DECL_USAGE_DEPTH: - shader_addline(buffer, "depth"); - break; - - case WINED3D_DECL_USAGE_SAMPLE: - shader_addline(buffer, "sample"); - break; - - default: - shader_addline(buffer, "<unknown_semantic(%#x)>", semantic->usage); - FIXME("Unrecognised semantic usage %#x.\n", semantic->usage); - } - } -} - -static void shader_dump_register(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version) -{ - static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"}; - static const char * const misctype_reg_names[] = {"vPos", "vFace"}; - UINT offset = reg->idx[0].offset; - - switch (reg->type) - { - case WINED3DSPR_TEMP: - shader_addline(buffer, "r"); - break; - - case WINED3DSPR_INPUT: - shader_addline(buffer, "v"); - break; - - case WINED3DSPR_CONST: - case WINED3DSPR_CONST2: - case WINED3DSPR_CONST3: - case WINED3DSPR_CONST4: - shader_addline(buffer, "c"); - offset = shader_get_float_offset(reg->type, offset); - break; - - case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */ - shader_addline(buffer, "%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a'); - break; - - case WINED3DSPR_RASTOUT: - shader_addline(buffer, "%s", rastout_reg_names[offset]); - break; - - case WINED3DSPR_COLOROUT: - shader_addline(buffer, "oC"); - break; - - case WINED3DSPR_DEPTHOUT: - shader_addline(buffer, "oDepth"); - break; - - case WINED3DSPR_DEPTHOUTGE: - shader_addline(buffer, "oDepthGE"); - break; - - case WINED3DSPR_DEPTHOUTLE: - shader_addline(buffer, "oDepthLE"); - break; - - case WINED3DSPR_ATTROUT: - shader_addline(buffer, "oD"); - break; - - case WINED3DSPR_TEXCRDOUT: - /* Vertex shaders >= 3.0 use general purpose output registers - * (WINED3DSPR_OUTPUT), which can include an address token. */ - if (shader_version->major >= 3) - shader_addline(buffer, "o"); - else - shader_addline(buffer, "oT"); - break; - - case WINED3DSPR_CONSTINT: - shader_addline(buffer, "i"); - break; - - case WINED3DSPR_CONSTBOOL: - shader_addline(buffer, "b"); - break; - - case WINED3DSPR_LABEL: - shader_addline(buffer, "l"); - break; - - case WINED3DSPR_LOOP: - shader_addline(buffer, "aL"); - break; - - case WINED3DSPR_SAMPLER: - shader_addline(buffer, "s"); - break; - - case WINED3DSPR_MISCTYPE: - if (offset > 1) - { - FIXME("Unhandled misctype register %u.\n", offset); - shader_addline(buffer, "<unhandled misctype %#x>", offset); - } - else - { - shader_addline(buffer, "%s", misctype_reg_names[offset]); - } - break; - - case WINED3DSPR_PREDICATE: - shader_addline(buffer, "p"); - break; - - case WINED3DSPR_IMMCONST: - shader_addline(buffer, "l"); - break; - - case WINED3DSPR_CONSTBUFFER: - shader_addline(buffer, "cb"); - break; - - case WINED3DSPR_IMMCONSTBUFFER: - shader_addline(buffer, "icb"); - break; - - case WINED3DSPR_PRIMID: - shader_addline(buffer, "primID"); - break; - - case WINED3DSPR_NULL: - shader_addline(buffer, "null"); - break; - - case WINED3DSPR_RASTERIZER: - shader_addline(buffer, "rasterizer"); - break; - - case WINED3DSPR_RESOURCE: - shader_addline(buffer, "t"); - break; - - case WINED3DSPR_UAV: - shader_addline(buffer, "u"); - break; - - case WINED3DSPR_OUTPOINTID: - shader_addline(buffer, "vOutputControlPointID"); - break; - - case WINED3DSPR_FORKINSTID: - shader_addline(buffer, "vForkInstanceId"); - break; - - case WINED3DSPR_JOININSTID: - shader_addline(buffer, "vJoinInstanceId"); - break; - - case WINED3DSPR_INCONTROLPOINT: - shader_addline(buffer, "vicp"); - break; - - case WINED3DSPR_OUTCONTROLPOINT: - shader_addline(buffer, "vocp"); - break; - - case WINED3DSPR_PATCHCONST: - shader_addline(buffer, "vpc"); - break; - - case WINED3DSPR_TESSCOORD: - shader_addline(buffer, "vDomainLocation"); - break; - - case WINED3DSPR_GROUPSHAREDMEM: - shader_addline(buffer, "g"); - break; - - case WINED3DSPR_THREADID: - shader_addline(buffer, "vThreadID"); - break; - - case WINED3DSPR_THREADGROUPID: - shader_addline(buffer, "vThreadGroupID"); - break; - - case WINED3DSPR_LOCALTHREADID: - shader_addline(buffer, "vThreadIDInGroup"); - break; - - case WINED3DSPR_LOCALTHREADINDEX: - shader_addline(buffer, "vThreadIDInGroupFlattened"); - break; - - case WINED3DSPR_IDXTEMP: - shader_addline(buffer, "x"); - break; - - case WINED3DSPR_STREAM: - shader_addline(buffer, "m"); - break; - - case WINED3DSPR_FUNCTIONBODY: - shader_addline(buffer, "fb"); - break; - - case WINED3DSPR_FUNCTIONPOINTER: - shader_addline(buffer, "fp"); - break; - - case WINED3DSPR_COVERAGE: - shader_addline(buffer, "vCoverage"); - break; - - case WINED3DSPR_SAMPLEMASK: - shader_addline(buffer, "oMask"); - break; - - case WINED3DSPR_GSINSTID: - shader_addline(buffer, "vGSInstanceID"); - break; - - default: - shader_addline(buffer, "<unhandled_rtype(%#x)>", reg->type); - break; - } - - if (reg->type == WINED3DSPR_IMMCONST) - { - shader_addline(buffer, "("); - switch (reg->immconst_type) - { - case WINED3D_IMMCONST_SCALAR: - switch (reg->data_type) - { - case WINED3D_DATA_FLOAT: - shader_addline(buffer, "%.8e", *(const float *)reg->u.immconst_data); - break; - case WINED3D_DATA_INT: - shader_addline(buffer, "%d", reg->u.immconst_data[0]); - break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: - case WINED3D_DATA_UINT: - shader_addline(buffer, "%u", reg->u.immconst_data[0]); - break; - default: - shader_addline(buffer, "<unhandled data type %#x>", reg->data_type); - break; - } - break; - - case WINED3D_IMMCONST_VEC4: - switch (reg->data_type) - { - case WINED3D_DATA_FLOAT: - shader_addline(buffer, "%.8e, %.8e, %.8e, %.8e", - *(const float *)&reg->u.immconst_data[0], *(const float *)&reg->u.immconst_data[1], - *(const float *)&reg->u.immconst_data[2], *(const float *)&reg->u.immconst_data[3]); - break; - case WINED3D_DATA_INT: - shader_addline(buffer, "%d, %d, %d, %d", - reg->u.immconst_data[0], reg->u.immconst_data[1], - reg->u.immconst_data[2], reg->u.immconst_data[3]); - break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: - case WINED3D_DATA_UINT: - shader_addline(buffer, "%u, %u, %u, %u", - reg->u.immconst_data[0], reg->u.immconst_data[1], - reg->u.immconst_data[2], reg->u.immconst_data[3]); - break; - default: - shader_addline(buffer, "<unhandled data type %#x>", reg->data_type); - break; - } - break; - - default: - shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type); - break; - } - shader_addline(buffer, ")"); - } - else if (reg->type != WINED3DSPR_RASTOUT - && reg->type != WINED3DSPR_MISCTYPE - && reg->type != WINED3DSPR_NULL) - { - if (offset != ~0u) - { - shader_addline(buffer, "["); - if (reg->idx[0].rel_addr) - { - shader_dump_src_param(buffer, reg->idx[0].rel_addr, shader_version); - shader_addline(buffer, " + "); - } - shader_addline(buffer, "%u]", offset); - - if (reg->idx[1].offset != ~0u) - { - shader_addline(buffer, "["); - if (reg->idx[1].rel_addr) - { - shader_dump_src_param(buffer, reg->idx[1].rel_addr, shader_version); - shader_addline(buffer, " + "); - } - shader_addline(buffer, "%u]", reg->idx[1].offset); - } - } - - if (reg->type == WINED3DSPR_FUNCTIONPOINTER) - shader_addline(buffer, "[%u]", reg->u.fp_body_idx); - } -} - -static void shader_dump_dst_param(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_dst_param *param, const struct wined3d_shader_version *shader_version) -{ - DWORD write_mask = param->write_mask; - - shader_dump_register(buffer, &param->reg, shader_version); - - if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL) - { - static const char write_mask_chars[] = "xyzw"; - - shader_addline(buffer, "."); - if (write_mask & WINED3DSP_WRITEMASK_0) - shader_addline(buffer, "%c", write_mask_chars[0]); - if (write_mask & WINED3DSP_WRITEMASK_1) - shader_addline(buffer, "%c", write_mask_chars[1]); - if (write_mask & WINED3DSP_WRITEMASK_2) - shader_addline(buffer, "%c", write_mask_chars[2]); - if (write_mask & WINED3DSP_WRITEMASK_3) - shader_addline(buffer, "%c", write_mask_chars[3]); - } -} - -static void shader_dump_src_param(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version) -{ - enum wined3d_shader_src_modifier src_modifier = param->modifiers; - DWORD swizzle = param->swizzle; - - if (src_modifier == WINED3DSPSM_NEG - || src_modifier == WINED3DSPSM_BIASNEG - || src_modifier == WINED3DSPSM_SIGNNEG - || src_modifier == WINED3DSPSM_X2NEG - || src_modifier == WINED3DSPSM_ABSNEG) - shader_addline(buffer, "-"); - else if (src_modifier == WINED3DSPSM_COMP) - shader_addline(buffer, "1-"); - else if (src_modifier == WINED3DSPSM_NOT) - shader_addline(buffer, "!"); - - if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG) - shader_addline(buffer, "abs("); - - shader_dump_register(buffer, &param->reg, shader_version); - - switch (src_modifier) - { - case WINED3DSPSM_NONE: break; - case WINED3DSPSM_NEG: break; - case WINED3DSPSM_NOT: break; - case WINED3DSPSM_BIAS: shader_addline(buffer, "_bias"); break; - case WINED3DSPSM_BIASNEG: shader_addline(buffer, "_bias"); break; - case WINED3DSPSM_SIGN: shader_addline(buffer, "_bx2"); break; - case WINED3DSPSM_SIGNNEG: shader_addline(buffer, "_bx2"); break; - case WINED3DSPSM_COMP: break; - case WINED3DSPSM_X2: shader_addline(buffer, "_x2"); break; - case WINED3DSPSM_X2NEG: shader_addline(buffer, "_x2"); break; - case WINED3DSPSM_DZ: shader_addline(buffer, "_dz"); break; - case WINED3DSPSM_DW: shader_addline(buffer, "_dw"); break; - case WINED3DSPSM_ABSNEG: shader_addline(buffer, ")"); break; - case WINED3DSPSM_ABS: shader_addline(buffer, ")"); break; - default: shader_addline(buffer, "_unknown_modifier(%#x)", src_modifier); - } - - if (swizzle != WINED3DSP_NOSWIZZLE) - { - static const char swizzle_chars[] = "xyzw"; - DWORD swizzle_x = swizzle & 0x03; - DWORD swizzle_y = (swizzle >> 2) & 0x03; - DWORD swizzle_z = (swizzle >> 4) & 0x03; - DWORD swizzle_w = (swizzle >> 6) & 0x03; - - if (swizzle_x == swizzle_y - && swizzle_x == swizzle_z - && swizzle_x == swizzle_w) - { - shader_addline(buffer, ".%c", swizzle_chars[swizzle_x]); - } - else - { - shader_addline(buffer, ".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y], - swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]); - } - } -} - -/* Shared code in order to generate the bulk of the shader string. */ -HRESULT shader_generate_code(const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer, - const struct wined3d_shader_reg_maps *reg_maps, void *backend_ctx, - const DWORD *start, const DWORD *end) -{ - struct wined3d_device *device = shader->device; - const struct wined3d_shader_frontend *fe = shader->frontend; - void *fe_data = shader->frontend_data; - struct wined3d_shader_version shader_version; - struct wined3d_shader_parser_state state; - struct wined3d_shader_instruction ins; - struct wined3d_shader_tex_mx tex_mx; - struct wined3d_shader_context ctx; - const DWORD *ptr; - - /* Initialize current parsing state. */ - tex_mx.current_row = 0; - state.current_loop_depth = 0; - state.current_loop_reg = 0; - state.in_subroutine = FALSE; - - ctx.shader = shader; - ctx.reg_maps = reg_maps; - ctx.buffer = buffer; - ctx.tex_mx = &tex_mx; - ctx.state = &state; - ctx.backend_data = backend_ctx; - ins.ctx = &ctx; - - fe->shader_read_header(fe_data, &ptr, &shader_version); - if (start) - ptr = start; - - while (!fe->shader_is_end(fe_data, &ptr) && ptr != end) - { - /* Read opcode. */ - fe->shader_read_instruction(fe_data, &ptr, &ins); - - /* Unknown opcode and its parameters. */ - if (ins.handler_idx == WINED3DSIH_TABLE_SIZE) - { - WARN("Encountered unrecognised or invalid instruction.\n"); - return WINED3DERR_INVALIDCALL; - } - - if (ins.predicate) - FIXME("Predicates not implemented.\n"); - - /* Call appropriate function for output target */ - device->shader_backend->shader_handle_instruction(&ins); - } - - return WINED3D_OK; -} - -static void shader_dump_ins_modifiers(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_dst_param *dst) -{ - uint32_t mmask = dst->modifiers; - - switch (dst->shift) - { - case 0: break; - case 13: shader_addline(buffer, "_d8"); break; - case 14: shader_addline(buffer, "_d4"); break; - case 15: shader_addline(buffer, "_d2"); break; - case 1: shader_addline(buffer, "_x2"); break; - case 2: shader_addline(buffer, "_x4"); break; - case 3: shader_addline(buffer, "_x8"); break; - default: shader_addline(buffer, "_unhandled_shift(%d)", dst->shift); break; - } - - if (mmask & WINED3DSPDM_SATURATE) shader_addline(buffer, "_sat"); - if (mmask & WINED3DSPDM_PARTIALPRECISION) shader_addline(buffer, "_pp"); - if (mmask & WINED3DSPDM_MSAMPCENTROID) shader_addline(buffer, "_centroid"); - - mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID); - if (mmask) FIXME("Unrecognised modifier %#x.\n", mmask); -} - -static void shader_dump_primitive_type(struct wined3d_string_buffer *buffer, - const struct wined3d_shader_primitive_type *primitive_type) -{ - switch (primitive_type->type) - { - case WINED3D_PT_UNDEFINED: - shader_addline(buffer, "undefined"); - break; - case WINED3D_PT_POINTLIST: - shader_addline(buffer, "pointlist"); - break; - case WINED3D_PT_LINELIST: - shader_addline(buffer, "linelist"); - break; - case WINED3D_PT_LINESTRIP: - shader_addline(buffer, "linestrip"); - break; - case WINED3D_PT_TRIANGLELIST: - shader_addline(buffer, "trianglelist"); - break; - case WINED3D_PT_TRIANGLESTRIP: - shader_addline(buffer, "trianglestrip"); - break; - case WINED3D_PT_TRIANGLEFAN: - shader_addline(buffer, "trianglefan"); - break; - case WINED3D_PT_LINELIST_ADJ: - shader_addline(buffer, "linelist_adj"); - break; - case WINED3D_PT_LINESTRIP_ADJ: - shader_addline(buffer, "linestrip_adj"); - break; - case WINED3D_PT_TRIANGLELIST_ADJ: - shader_addline(buffer, "trianglelist_adj"); - break; - case WINED3D_PT_TRIANGLESTRIP_ADJ: - shader_addline(buffer, "trianglestrip_adj"); - break; - case WINED3D_PT_PATCH: - shader_addline(buffer, "patch%u", primitive_type->patch_vertex_count); - break; - default: - shader_addline(buffer, "<unrecognized_primitive_type %#x>", primitive_type->type); - break; - } -} - -static void shader_dump_interpolation_mode(struct wined3d_string_buffer *buffer, - enum wined3d_shader_interpolation_mode interpolation_mode) -{ - switch (interpolation_mode) - { - case WINED3DSIM_CONSTANT: - shader_addline(buffer, "constant"); - break; - case WINED3DSIM_LINEAR: - shader_addline(buffer, "linear"); - break; - case WINED3DSIM_LINEAR_CENTROID: - shader_addline(buffer, "linear centroid"); - break; - case WINED3DSIM_LINEAR_NOPERSPECTIVE: - shader_addline(buffer, "linear noperspective"); - break; - case WINED3DSIM_LINEAR_SAMPLE: - shader_addline(buffer, "linear sample"); - break; - case WINED3DSIM_LINEAR_NOPERSPECTIVE_CENTROID: - shader_addline(buffer, "linear noperspective centroid"); - break; - case WINED3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE: - shader_addline(buffer, "linear noperspective sample"); - break; - default: - shader_addline(buffer, "<unrecognized_interpolation_mode %#x>", interpolation_mode); - break; - } -} - -static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data) -{ - struct wined3d_shader_version shader_version; - struct wined3d_string_buffer buffer; - const char *type_prefix; - const char *p, *q; - const DWORD *ptr; - DWORD i; - - if (!string_buffer_init(&buffer)) - { - ERR("Failed to initialize string buffer.\n"); - return; - } - - fe->shader_read_header(fe_data, &ptr, &shader_version); - - TRACE("Parsing %p.\n", ptr); - - switch (shader_version.type) - { - case WINED3D_SHADER_TYPE_VERTEX: - type_prefix = "vs"; - break; - - case WINED3D_SHADER_TYPE_HULL: - type_prefix = "hs"; - break; - - case WINED3D_SHADER_TYPE_DOMAIN: - type_prefix = "ds"; - break; - - case WINED3D_SHADER_TYPE_GEOMETRY: - type_prefix = "gs"; - break; - - case WINED3D_SHADER_TYPE_PIXEL: - type_prefix = "ps"; - break; - - case WINED3D_SHADER_TYPE_COMPUTE: - type_prefix = "cs"; - break; - - default: - FIXME("Unhandled shader type %#x.\n", shader_version.type); - type_prefix = "unknown"; - break; - } - - shader_addline(&buffer, "%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor); - - while (!fe->shader_is_end(fe_data, &ptr)) - { - struct wined3d_shader_instruction ins; - - fe->shader_read_instruction(fe_data, &ptr, &ins); - if (ins.handler_idx == WINED3DSIH_TABLE_SIZE) - { - WARN("Skipping unrecognized instruction.\n"); - shader_addline(&buffer, "<unrecognized instruction>\n"); - continue; - } - - if (ins.handler_idx == WINED3DSIH_DCL || ins.handler_idx == WINED3DSIH_DCL_UAV_TYPED) - { - shader_dump_decl_usage(&buffer, &ins.declaration.semantic, ins.flags, &shader_version); - shader_dump_ins_modifiers(&buffer, &ins.declaration.semantic.reg); - shader_addline(&buffer, " "); - shader_dump_dst_param(&buffer, &ins.declaration.semantic.reg, &shader_version); - } - else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_src_param(&buffer, &ins.declaration.src, &shader_version); - shader_addline(&buffer, ", %s", - ins.flags & WINED3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed"); - } - else if (ins.handler_idx == WINED3DSIH_DCL_FUNCTION_BODY) - { - shader_addline(&buffer, "%s fb%u", - shader_opcode_names[ins.handler_idx], ins.declaration.index); - } - else if (ins.handler_idx == WINED3DSIH_DCL_FUNCTION_TABLE) - { - shader_addline(&buffer, "%s ft%u = {...}", - shader_opcode_names[ins.handler_idx], ins.declaration.index); - } - else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_global_flags(&buffer, ins.flags); - } - else if (ins.handler_idx == WINED3DSIH_DCL_HS_MAX_TESSFACTOR) - { - shader_addline(&buffer, "%s %.8e", shader_opcode_names[ins.handler_idx], - ins.declaration.max_tessellation_factor); - } - else if (ins.handler_idx == WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER) - { - shader_addline(&buffer, "%s {\n", shader_opcode_names[ins.handler_idx]); - for (i = 0; i < ins.declaration.icb->vec4_count; ++i) - { - shader_addline(&buffer, " {0x%08x, 0x%08x, 0x%08x, 0x%08x},\n", - ins.declaration.icb->data[4 * i + 0], - ins.declaration.icb->data[4 * i + 1], - ins.declaration.icb->data[4 * i + 2], - ins.declaration.icb->data[4 * i + 3]); - } - shader_addline(&buffer, "}"); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INDEX_RANGE) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.index_range.first_register, &shader_version); - shader_addline(&buffer, " %u", ins.declaration.index_range.last_register); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INDEXABLE_TEMP) - { - shader_addline(&buffer, "%s x[%u][%u], %u", shader_opcode_names[ins.handler_idx], - ins.declaration.indexable_temp.register_idx, - ins.declaration.indexable_temp.register_size, - ins.declaration.indexable_temp.component_count); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_interpolation_mode(&buffer, ins.flags); - shader_addline(&buffer, " "); - shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SGV - || ins.handler_idx == WINED3DSIH_DCL_INPUT_SGV - || ins.handler_idx == WINED3DSIH_DCL_INPUT_SIV - || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_SIV) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version); - shader_addline(&buffer, ", "); - shader_dump_shader_input_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SIV) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_interpolation_mode(&buffer, ins.flags); - shader_addline(&buffer, " "); - shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version); - shader_addline(&buffer, ", "); - shader_dump_shader_input_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INPUT - || ins.handler_idx == WINED3DSIH_DCL_OUTPUT) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE - || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_primitive_type(&buffer, &ins.declaration.primitive_type); - } - else if (ins.handler_idx == WINED3DSIH_DCL_INTERFACE) - { - shader_addline(&buffer, "%s fp[%u][%u][%u] = {...}", - shader_opcode_names[ins.handler_idx], ins.declaration.fp.index, - ins.declaration.fp.array_size, ins.declaration.fp.body_count); - } - else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_RAW) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version); - } - else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.structured_resource.reg, &shader_version); - shader_addline(&buffer, ", %u", ins.declaration.structured_resource.byte_stride); - } - else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version); - if (ins.flags == WINED3DSI_SAMPLER_COMPARISON_MODE) - shader_addline(&buffer, ", comparisonMode"); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TEMPS - || ins.handler_idx == WINED3DSIH_DCL_GS_INSTANCES - || ins.handler_idx == WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT - || ins.handler_idx == WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT - || ins.handler_idx == WINED3DSIH_DCL_INPUT_CONTROL_POINT_COUNT - || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT - || ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT) - { - shader_addline(&buffer, "%s %u", shader_opcode_names[ins.handler_idx], ins.declaration.count); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_DOMAIN) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_tessellator_domain(&buffer, ins.declaration.tessellator_domain); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_tessellator_output_primitive(&buffer, ins.declaration.tessellator_output_primitive); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_PARTITIONING) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_tessellator_partitioning(&buffer, ins.declaration.tessellator_partitioning); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_RAW) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.tgsm_raw.reg, &shader_version); - shader_addline(&buffer, ", %u", ins.declaration.tgsm_raw.byte_count); - } - else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_STRUCTURED) - { - shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]); - shader_dump_dst_param(&buffer, &ins.declaration.tgsm_structured.reg, &shader_version); - shader_addline(&buffer, ", %u, %u", ins.declaration.tgsm_structured.byte_stride, - ins.declaration.tgsm_structured.structure_count); - } - else if (ins.handler_idx == WINED3DSIH_DCL_THREAD_GROUP) - { - shader_addline(&buffer, "%s %u, %u, %u", shader_opcode_names[ins.handler_idx], - ins.declaration.thread_group_size.x, - ins.declaration.thread_group_size.y, - ins.declaration.thread_group_size.z); - } - else if (ins.handler_idx == WINED3DSIH_DCL_UAV_RAW) - { - shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]); - shader_dump_uav_flags(&buffer, ins.flags); - shader_addline(&buffer, " "); - shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version); - } - else if (ins.handler_idx == WINED3DSIH_DCL_UAV_STRUCTURED) - { - shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]); - shader_dump_uav_flags(&buffer, ins.flags); - shader_addline(&buffer, " "); - shader_dump_dst_param(&buffer, &ins.declaration.structured_resource.reg, &shader_version); - shader_addline(&buffer, ", %u", ins.declaration.structured_resource.byte_stride); - } - else if (ins.handler_idx == WINED3DSIH_DEF) - { - shader_addline(&buffer, "def c%u = %.8e, %.8e, %.8e, %.8e", shader_get_float_offset(ins.dst[0].reg.type, - ins.dst[0].reg.idx[0].offset), - *(const float *)&ins.src[0].reg.u.immconst_data[0], - *(const float *)&ins.src[0].reg.u.immconst_data[1], - *(const float *)&ins.src[0].reg.u.immconst_data[2], - *(const float *)&ins.src[0].reg.u.immconst_data[3]); - } - else if (ins.handler_idx == WINED3DSIH_DEFI) - { - shader_addline(&buffer, "defi i%u = %d, %d, %d, %d", ins.dst[0].reg.idx[0].offset, - ins.src[0].reg.u.immconst_data[0], - ins.src[0].reg.u.immconst_data[1], - ins.src[0].reg.u.immconst_data[2], - ins.src[0].reg.u.immconst_data[3]); - } - else if (ins.handler_idx == WINED3DSIH_DEFB) - { - shader_addline(&buffer, "defb b%u = %s", - ins.dst[0].reg.idx[0].offset, ins.src[0].reg.u.immconst_data[0] ? "true" : "false"); - } - else - { - if (ins.predicate) - { - shader_addline(&buffer, "("); - shader_dump_src_param(&buffer, ins.predicate, &shader_version); - shader_addline(&buffer, ") "); - } - - /* PixWin marks instructions with the coissue flag with a '+' */ - if (ins.coissue) - shader_addline(&buffer, "+"); - - shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]); - - if (ins.handler_idx == WINED3DSIH_BREAKP - || ins.handler_idx == WINED3DSIH_CONTINUEP - || ins.handler_idx == WINED3DSIH_IF - || ins.handler_idx == WINED3DSIH_RETP - || ins.handler_idx == WINED3DSIH_TEXKILL) - { - switch (ins.flags) - { - case WINED3D_SHADER_CONDITIONAL_OP_NZ: shader_addline(&buffer, "_nz"); break; - case WINED3D_SHADER_CONDITIONAL_OP_Z: shader_addline(&buffer, "_z"); break; - default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags); break; - } - } - else if (ins.handler_idx == WINED3DSIH_IFC - || ins.handler_idx == WINED3DSIH_BREAKC) - { - switch (ins.flags) - { - case WINED3D_SHADER_REL_OP_GT: shader_addline(&buffer, "_gt"); break; - case WINED3D_SHADER_REL_OP_EQ: shader_addline(&buffer, "_eq"); break; - case WINED3D_SHADER_REL_OP_GE: shader_addline(&buffer, "_ge"); break; - case WINED3D_SHADER_REL_OP_LT: shader_addline(&buffer, "_lt"); break; - case WINED3D_SHADER_REL_OP_NE: shader_addline(&buffer, "_ne"); break; - case WINED3D_SHADER_REL_OP_LE: shader_addline(&buffer, "_le"); break; - default: shader_addline(&buffer, "_(%u)", ins.flags); - } - } - else if (ins.handler_idx == WINED3DSIH_TEX - && shader_version.major >= 2 - && (ins.flags & WINED3DSI_TEXLD_PROJECT)) - { - shader_addline(&buffer, "p"); - } - else if (ins.handler_idx == WINED3DSIH_RESINFO && ins.flags) - { - switch (ins.flags) - { - case WINED3DSI_RESINFO_RCP_FLOAT: shader_addline(&buffer, "_rcpFloat"); break; - case WINED3DSI_RESINFO_UINT: shader_addline(&buffer, "_uint"); break; - default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags); - } - } - else if (ins.handler_idx == WINED3DSIH_SAMPLE_INFO && ins.flags) - { - switch (ins.flags) - { - case WINED3DSI_SAMPLE_INFO_UINT: shader_addline(&buffer, "_uint"); break; - default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags); - } - } - else if (ins.handler_idx == WINED3DSIH_SYNC) - { - shader_dump_sync_flags(&buffer, ins.flags); - } - else - { - shader_dump_precise_flags(&buffer, ins.flags); - } - - if (wined3d_shader_instruction_has_texel_offset(&ins)) - shader_addline(&buffer, "(%d,%d,%d)", ins.texel_offset.u, ins.texel_offset.v, ins.texel_offset.w); - - if (ins.resource_type != WINED3D_SHADER_RESOURCE_NONE) - { - shader_addline(&buffer, "("); - shader_dump_resource_type(&buffer, ins.resource_type); - shader_addline(&buffer, ")"); - } - - if (ins.resource_data_type != WINED3D_DATA_FLOAT) - shader_dump_data_type(&buffer, ins.resource_data_type); - - for (i = 0; i < ins.dst_count; ++i) - { - shader_dump_ins_modifiers(&buffer, &ins.dst[i]); - shader_addline(&buffer, !i ? " " : ", "); - shader_dump_dst_param(&buffer, &ins.dst[i], &shader_version); - } - - /* Other source tokens */ - for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i) - { - shader_addline(&buffer, !i ? " " : ", "); - shader_dump_src_param(&buffer, &ins.src[i - ins.dst_count], &shader_version); - } - } - shader_addline(&buffer, "\n"); - } - - for (p = buffer.buffer; *p; p = q) - { - if (!(q = strstr(p, "\n"))) - q = p + strlen(p); - else - ++q; - TRACE(" %.*s", (int)(q - p), p); - } - - string_buffer_free(&buffer); -} - -static void shader_cleanup(struct wined3d_shader *shader) -{ - if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_HULL) - { - heap_free(shader->u.hs.phases.control_point); - heap_free(shader->u.hs.phases.fork); - heap_free(shader->u.hs.phases.join); - } - - heap_free(shader->patch_constant_signature.elements); - heap_free(shader->output_signature.elements); - heap_free(shader->input_signature.elements); - shader->device->shader_backend->shader_destroy(shader); - shader_cleanup_reg_maps(&shader->reg_maps); - heap_free(shader->byte_code); - shader_delete_constant_list(&shader->constantsF); - shader_delete_constant_list(&shader->constantsB); - shader_delete_constant_list(&shader->constantsI); - list_remove(&shader->shader_list_entry); - - if (shader->frontend && shader->frontend_data) - shader->frontend->shader_free(shader->frontend_data); -} - -struct shader_none_priv -{ - const struct wined3d_vertex_pipe_ops *vertex_pipe; - const struct wined3d_fragment_pipe_ops *fragment_pipe; - BOOL ffp_proj_control; -}; - -static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {} -static void shader_none_precompile(void *shader_priv, struct wined3d_shader *shader) {} -static void shader_none_select_compute(void *shader_priv, struct wined3d_context *context, - const struct wined3d_state *state) {} -static void shader_none_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count) {} -static void shader_none_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count) {} -static void shader_none_load_constants(void *shader_priv, struct wined3d_context *context, - const struct wined3d_state *state) {} -static void shader_none_destroy(struct wined3d_shader *shader) {} -static void shader_none_free_context_data(struct wined3d_context *context) {} -static void shader_none_init_context_state(struct wined3d_context *context) {} - -/* Context activation is done by the caller. */ -static void shader_none_select(void *shader_priv, struct wined3d_context *context, - const struct wined3d_state *state) -{ - struct shader_none_priv *priv = shader_priv; - - priv->vertex_pipe->vp_enable(context, !use_vs(state)); - priv->fragment_pipe->fp_enable(context, !use_ps(state)); -} - -/* Context activation is done by the caller. */ -static void shader_none_disable(void *shader_priv, struct wined3d_context *context) -{ - struct shader_none_priv *priv = shader_priv; - - priv->vertex_pipe->vp_enable(context, FALSE); - priv->fragment_pipe->fp_enable(context, FALSE); - - context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL) - | (1u << WINED3D_SHADER_TYPE_VERTEX) - | (1u << WINED3D_SHADER_TYPE_GEOMETRY) - | (1u << WINED3D_SHADER_TYPE_HULL) - | (1u << WINED3D_SHADER_TYPE_DOMAIN) - | (1u << WINED3D_SHADER_TYPE_COMPUTE); -} - -static HRESULT shader_none_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe, - const struct wined3d_fragment_pipe_ops *fragment_pipe) -{ - struct fragment_caps fragment_caps; - void *vertex_priv, *fragment_priv; - struct shader_none_priv *priv; - - if (!(priv = heap_alloc(sizeof(*priv)))) - return E_OUTOFMEMORY; - - if (!(vertex_priv = vertex_pipe->vp_alloc(&none_shader_backend, priv))) - { - ERR("Failed to initialize vertex pipe.\n"); - heap_free(priv); - return E_FAIL; - } - - if (!(fragment_priv = fragment_pipe->alloc_private(&none_shader_backend, priv))) - { - ERR("Failed to initialize fragment pipe.\n"); - vertex_pipe->vp_free(device, NULL); - heap_free(priv); - return E_FAIL; - } - - priv->vertex_pipe = vertex_pipe; - priv->fragment_pipe = fragment_pipe; - fragment_pipe->get_caps(device->adapter, &fragment_caps); - priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL; - - device->vertex_priv = vertex_priv; - device->fragment_priv = fragment_priv; - device->shader_priv = priv; - - return WINED3D_OK; -} - -static void shader_none_free(struct wined3d_device *device, struct wined3d_context *context) -{ - struct shader_none_priv *priv = device->shader_priv; - - priv->fragment_pipe->free_private(device, context); - priv->vertex_pipe->vp_free(device, context); - heap_free(priv); -} - -static BOOL shader_none_allocate_context_data(struct wined3d_context *context) -{ - return TRUE; -} - -static void shader_none_get_caps(const struct wined3d_adapter *adapter, struct shader_caps *caps) -{ - /* Set the shader caps to 0 for the none shader backend */ - memset(caps, 0, sizeof(*caps)); -} - -static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup) -{ - /* We "support" every possible fixup, since we don't support any shader - * model, and will never have to actually sample a texture. */ - return TRUE; -} - -static BOOL shader_none_has_ffp_proj_control(void *shader_priv) -{ - struct shader_none_priv *priv = shader_priv; - - return priv->ffp_proj_control; -} - -static uint64_t shader_none_shader_compile(struct wined3d_context *context, const struct wined3d_shader_desc *shader_desc, - enum wined3d_shader_type shader_type) -{ - return 0; -} +static uint64_t shader_none_shader_compile(struct wined3d_context *context, const struct wined3d_shader_desc *shader_desc, + enum wined3d_shader_type shader_type) +{ + return 0; +}

const struct wined3d_shader_backend_ops none_shader_backend = { @@ -3346,11 +2097,6 @@ static HRESULT shader_set_function(struct wined3d_shader *shader, struct wined3d return WINED3DERR_INVALIDCALL; }

- /* First pass: trace shader. */ - if (TRACE_ON(d3d_shader)) - shader_trace_init(fe, shader->frontend_data); - - /* Second pass: figure out which registers are used, what the semantics are, etc. */ if (FAILED(hr = shader_get_registers_used(shader, float_const_count))) return hr;

@@ -3597,9 +2343,65 @@ bool vshader_get_input(const struct wined3d_shader *shader, return false; }

+static void shader_trace(const void *code, size_t size, enum vkd3d_shader_source_type source_type) +{ + struct vkd3d_shader_compile_info info; + struct vkd3d_shader_code d3d_asm; + const char *ptr, *end, *line; + char *messages; + int ret; + + static const struct vkd3d_shader_compile_option compile_options[] = + { + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_6}, + }; + + info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; + info.next = NULL; + info.source.code = code; + info.source.size = size; + info.source_type = source_type; + info.target_type = VKD3D_SHADER_TARGET_D3D_ASM; + info.options = compile_options; + info.option_count = ARRAY_SIZE(compile_options); + info.log_level = VKD3D_SHADER_LOG_WARNING; + info.source_name = NULL; + + ret = vkd3d_shader_compile(&info, &d3d_asm, &messages); + if (messages && *messages && FIXME_ON(d3d_shader)) + { + FIXME("Shader log:\n"); + ptr = messages; + end = ptr + strlen(ptr); + while ((line = wined3d_get_line(&ptr, end))) + { + FIXME(" %.*s", (int)(ptr - line), line); + } + FIXME("\n"); + } + vkd3d_shader_free_messages(messages); + + if (ret < 0) + { + ERR("Failed to disassemble, ret %d.\n", ret); + return; + } + + ptr = d3d_asm.code; + end = ptr + d3d_asm.size; + while ((line = wined3d_get_line(&ptr, end))) + { + TRACE(" %.*s", (int)(ptr - line), line); + } + TRACE("\n"); + + vkd3d_shader_free_shader_code(&d3d_asm); +} + static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { + enum vkd3d_shader_source_type source_type; HRESULT hr;

TRACE("byte_code %p, byte_code_size %#lx.\n", desc->byte_code, (long)desc->byte_code_size); @@ -3628,7 +2430,8 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device const DWORD *ptr; void *fe_data;

- if (!(shader->frontend = shader_select_frontend(VKD3D_SHADER_SOURCE_D3D_BYTECODE))) + source_type = VKD3D_SHADER_SOURCE_D3D_BYTECODE; + if (!(shader->frontend = shader_select_frontend(source_type))) { FIXME("Unable to find frontend for shader.\n"); hr = WINED3DERR_INVALIDCALL; @@ -3663,7 +2466,6 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device } else { - enum vkd3d_shader_source_type source_type; unsigned int max_version;

if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) @@ -3686,6 +2488,15 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device } }

+ if (TRACE_ON(d3d_shader)) + { + if (source_type == VKD3D_SHADER_SOURCE_D3D_BYTECODE) + shader_trace(shader->function, shader->functionLength, source_type); + else + shader_trace(shader->byte_code, shader->byte_code_size, source_type); + } + + return WINED3D_OK;

fail:

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/2411