May 2020 - Wine-Devel - list.winehq.org

[PATCH 3/6] wined3d: Bind Vulkan vertex buffers.
by Henri Verbeet May 19, 2020

May 19, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_vk.c | 51 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index d13bb5d82e1..19351d4b953 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -1142,6 +1142,7 @@ void wined3d_context_vk_submit_command_buffer(struct wined3d_context_vk *context context_vk->c.update_compute_shader_resource_bindings = 1; context_vk->c.update_unordered_access_view_bindings = 1; context_vk->c.update_compute_unordered_access_view_bindings = 1; + context_invalidate_state(&context_vk->c, STATE_STREAMSRC); context_invalidate_state(&context_vk->c, STATE_INDEXBUFFER); VK_CALL(vkEndCommandBuffer(buffer->vk_command_buffer)); @@ -1618,6 +1619,42 @@ static bool wined3d_context_vk_begin_render_pass(struct wined3d_context_vk *cont return true; } +static void wined3d_context_vk_bind_vertex_buffers(struct wined3d_context_vk *context_vk, + VkCommandBuffer vk_command_buffer, const struct wined3d_state *state, const struct wined3d_vk_info *vk_info) +{ + VkDeviceSize offsets[ARRAY_SIZE(state->streams)] = {0}; + VkBuffer buffers[ARRAY_SIZE(state->streams)]; + const struct wined3d_stream_state *stream; + struct wined3d_buffer *buffer; + unsigned int i, first, count; + struct wined3d_bo_vk *bo; + + first = 0; + count = 0; + for (i = 0; i < ARRAY_SIZE(state->streams); ++i) + { + stream = &state->streams[i]; + + if ((buffer = stream->buffer)) + { + bo = &wined3d_buffer_vk(buffer)->bo; + wined3d_context_vk_reference_bo(context_vk, bo); + buffers[count] = bo->vk_buffer; + offsets[count] = bo->buffer_offset + stream->offset; + ++count; + continue; + } + + if (count) + VK_CALL(vkCmdBindVertexBuffers(vk_command_buffer, first, count, buffers, offsets)); + first = i + 1; + count = 0; + } + + if (count) + VK_CALL(vkCmdBindVertexBuffers(vk_command_buffer, first, count, buffers, offsets)); +} + static VkResult wined3d_context_vk_create_descriptor_pool(struct wined3d_device_vk *device_vk, const struct wined3d_vk_info *vk_info, VkDescriptorPool *vk_pool) { @@ -2190,6 +2227,7 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c struct wined3d_rendertarget_view *dsv; VkSampleCountFlagBits sample_count; VkCommandBuffer vk_command_buffer; + struct wined3d_buffer *buffer; unsigned int i; if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)) @@ -2261,6 +2299,16 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_GRAPHICS); + for (i = 0; i < ARRAY_SIZE(state->streams); ++i) + { + if (!(buffer = state->streams[i].buffer)) + continue; + + wined3d_buffer_load(buffer, &context_vk->c, state); + if (!wined3d_buffer_vk(buffer)->bo_user.valid) + context_invalidate_state(&context_vk->c, STATE_STREAMSRC); + } + if (indexed) { wined3d_buffer_load(state->index_buffer, &context_vk->c, state); @@ -2298,6 +2346,9 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); } + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STREAMSRC)) + wined3d_context_vk_bind_vertex_buffers(context_vk, vk_command_buffer, state, vk_info); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_INDEXBUFFER) && state->index_buffer) { struct wined3d_bo_vk *bo = &wined3d_buffer_vk(state->index_buffer)->bo; -- 2.20.1

1 0

[PATCH 2/6] wined3d: Create Vulkan pipeline objects.
by Henri Verbeet May 19, 2020

May 19, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 77 +++++++- dlls/wined3d/context_vk.c | 320 ++++++++++++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 31 ++++ 3 files changed, 418 insertions(+), 10 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 7d152d70b06..0249c4c7af1 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -398,12 +398,80 @@ static const struct wined3d_allocator_ops wined3d_allocator_vk_ops = .allocator_destroy_chunk = wined3d_allocator_vk_destroy_chunk, }; +static const struct +{ + const char *name; + unsigned int core_since_version; +} +vulkan_device_extensions[] = +{ + {VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_API_VERSION_1_1}, + {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_API_VERSION_1_1}, +}; + +static bool enable_vulkan_device_extensions(VkPhysicalDevice physical_device, uint32_t *extension_count, + const char *enabled_extensions[], const struct wined3d_vk_info *vk_info) +{ + VkExtensionProperties *extensions = NULL; + bool success = false, found; + unsigned int i, j, count; + VkResult vr; + + *extension_count = 0; + + if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL))) < 0) + { + ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr)); + goto done; + } + if (!(extensions = heap_calloc(count, sizeof(*extensions)))) + { + WARN("Out of memory.\n"); + goto done; + } + if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, extensions))) < 0) + { + ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr)); + goto done; + } + + for (i = 0; i < ARRAY_SIZE(vulkan_device_extensions); ++i) + { + if (vulkan_device_extensions[i].core_since_version <= vk_info->api_version) + continue; + + for (j = 0, found = false; j < count; ++j) + { + if (!strcmp(extensions[j].extensionName, vulkan_device_extensions[i].name)) + { + found = true; + break; + } + } + + if (!found) + { + WARN("Required extension '%s' is not available.\n", vulkan_device_extensions[i].name); + goto done; + } + + TRACE("Enabling instance extension '%s'.\n", vulkan_device_extensions[i].name); + enabled_extensions[(*extension_count)++] = vulkan_device_extensions[i].name; + } + success = true; + +done: + heap_free(extensions); + return success; +} + static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device) { const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter); + const char *enabled_device_extensions[ARRAY_SIZE(vulkan_device_extensions)]; const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info; static const float priorities[] = {1.0f}; struct wined3d_device_vk *device_vk; @@ -441,8 +509,13 @@ static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wi device_info.pQueueCreateInfos = &queue_info; device_info.enabledLayerCount = 0; device_info.ppEnabledLayerNames = NULL; - device_info.enabledExtensionCount = 0; - device_info.ppEnabledExtensionNames = NULL; + device_info.ppEnabledExtensionNames = enabled_device_extensions; + if (!enable_vulkan_device_extensions(physical_device, + &device_info.enabledExtensionCount, enabled_device_extensions, vk_info)) + { + hr = E_FAIL; + goto fail; + } device_info.pEnabledFeatures = &features; if ((vr = VK_CALL(vkCreateDevice(physical_device, &device_info, NULL, &vk_device))) < 0) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 08ce3db7ccc..d13bb5d82e1 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -772,6 +772,21 @@ static void wined3d_context_vk_destroy_bo_slab(struct wine_rb_entry *entry, void } } +static void wined3d_context_vk_destroy_graphics_pipeline(struct wine_rb_entry *entry, void *ctx) +{ + struct wined3d_graphics_pipeline_vk *pipeline_vk = WINE_RB_ENTRY_VALUE(entry, + struct wined3d_graphics_pipeline_vk, entry); + struct wined3d_context_vk *context_vk = ctx; + const struct wined3d_vk_info *vk_info; + struct wined3d_device_vk *device_vk; + + vk_info = context_vk->vk_info; + device_vk = wined3d_device_vk(context_vk->c.device); + + VK_CALL(vkDestroyPipeline(device_vk->vk_device, pipeline_vk->vk_pipeline, NULL)); + heap_free(pipeline_vk); +} + static void wined3d_context_vk_destroy_pipeline_layout(struct wine_rb_entry *entry, void *ctx) { struct wined3d_pipeline_layout_vk *layout = WINE_RB_ENTRY_VALUE(entry, @@ -1041,6 +1056,7 @@ void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) heap_free(context_vk->retired.objects); wined3d_shader_descriptor_writes_vk_cleanup(&context_vk->descriptor_writes); + wine_rb_destroy(&context_vk->graphics_pipelines, wined3d_context_vk_destroy_graphics_pipeline, context_vk); wine_rb_destroy(&context_vk->pipeline_layouts, wined3d_context_vk_destroy_pipeline_layout, context_vk); wine_rb_destroy(&context_vk->render_passes, wined3d_context_vk_destroy_render_pass, context_vk); @@ -1239,6 +1255,68 @@ static int wined3d_pipeline_layout_vk_compare(const void *key, const struct wine return memcmp(a->bindings, b->bindings, a->binding_count * sizeof(*a->bindings)); } +static int wined3d_graphics_pipeline_vk_compare(const void *key, const struct wine_rb_entry *entry) +{ + const struct wined3d_graphics_pipeline_key_vk *a = key; + const struct wined3d_graphics_pipeline_key_vk *b = &WINE_RB_ENTRY_VALUE(entry, + const struct wined3d_graphics_pipeline_vk, entry)->key; + unsigned int i; + int ret; + + if (a->pipeline_desc.stageCount != b->pipeline_desc.stageCount) + return a->pipeline_desc.stageCount - b->pipeline_desc.stageCount; + for (i = 0; i < a->pipeline_desc.stageCount; ++i) + { + if (a->stages[i].module != b->stages[i].module) + return a->stages[i].module - b->stages[i].module; + } + + if (a->input_desc.vertexAttributeDescriptionCount != b->input_desc.vertexAttributeDescriptionCount) + return a->input_desc.vertexAttributeDescriptionCount - b->input_desc.vertexAttributeDescriptionCount; + if ((ret = memcmp(a->attributes, b->attributes, + a->input_desc.vertexAttributeDescriptionCount * sizeof(*a->attributes)))) + return ret; + if (a->input_desc.vertexBindingDescriptionCount != b->input_desc.vertexBindingDescriptionCount) + return a->input_desc.vertexBindingDescriptionCount - b->input_desc.vertexBindingDescriptionCount; + if ((ret = memcmp(a->bindings, b->bindings, + a->input_desc.vertexBindingDescriptionCount * sizeof(*a->bindings)))) + return ret; + + if (a->ia_desc.topology != b->ia_desc.topology) + return a->ia_desc.topology - b->ia_desc.topology; + if (a->ia_desc.primitiveRestartEnable != b->ia_desc.primitiveRestartEnable) + return a->ia_desc.primitiveRestartEnable - b->ia_desc.primitiveRestartEnable; + + if ((ret = memcmp(&a->viewport, &b->viewport, sizeof(a->viewport)))) + return ret; + + if ((ret = memcmp(&a->scissor, &b->scissor, sizeof(a->scissor)))) + return ret; + + if ((ret = memcmp(&a->rs_desc, &b->rs_desc, sizeof(a->rs_desc)))) + return ret; + + if ((ret = memcmp(&a->ms_desc, &b->ms_desc, sizeof(a->ms_desc)))) + return ret; + + if ((ret = memcmp(&a->ds_desc, &b->ds_desc, sizeof(a->ds_desc)))) + return ret; + + if (a->blend_desc.attachmentCount != b->blend_desc.attachmentCount) + return a->blend_desc.attachmentCount - b->blend_desc.attachmentCount; + if ((ret = memcmp(a->blend_attachments, b->blend_attachments, + a->blend_desc.attachmentCount * sizeof(*a->blend_attachments)))) + return ret; + + if (a->pipeline_desc.layout != b->pipeline_desc.layout) + return a->pipeline_desc.layout - b->pipeline_desc.layout; + + if (a->pipeline_desc.renderPass != b->pipeline_desc.renderPass) + return a->pipeline_desc.renderPass - b->pipeline_desc.renderPass; + + return 0; +} + static int wined3d_bo_slab_vk_compare(const void *key, const struct wine_rb_entry *entry) { const struct wined3d_bo_slab_vk *slab = WINE_RB_ENTRY_VALUE(entry, const struct wined3d_bo_slab_vk, entry); @@ -1251,6 +1329,197 @@ static int wined3d_bo_slab_vk_compare(const void *key, const struct wine_rb_entr return k->size - slab->bo.size; } +static void wined3d_context_vk_init_graphics_pipeline_key(struct wined3d_context_vk *context_vk) +{ + struct wined3d_graphics_pipeline_key_vk *key; + VkPipelineShaderStageCreateInfo *stage; + unsigned int i; + + key = &context_vk->graphics.pipeline_key_vk; + memset(key, 0, sizeof(*key)); + + for (i = 0; i < ARRAY_SIZE(context_vk->graphics.vk_modules); ++i) + { + stage = &key->stages[i]; + stage->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stage->pName = "main"; + } + + key->input_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + key->input_desc.pVertexBindingDescriptions = key->bindings; + key->input_desc.pVertexAttributeDescriptions = key->attributes; + + key->ia_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + key->ia_desc.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + + key->vp_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + key->vp_desc.viewportCount = 1; + key->vp_desc.pViewports = &key->viewport; + key->vp_desc.scissorCount = 1; + key->vp_desc.pScissors = &key->scissor; + + key->rs_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + key->rs_desc.lineWidth = 1.0f; + + key->ms_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + + key->ds_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + key->ds_desc.maxDepthBounds = 1.0f; + + key->blend_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + key->blend_desc.logicOp = VK_LOGIC_OP_COPY; + key->blend_desc.pAttachments = key->blend_attachments; + key->blend_desc.blendConstants[0] = 1.0f; + key->blend_desc.blendConstants[1] = 1.0f; + key->blend_desc.blendConstants[2] = 1.0f; + key->blend_desc.blendConstants[3] = 1.0f; + + key->dynamic_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + + key->pipeline_desc.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + key->pipeline_desc.pStages = key->stages; + key->pipeline_desc.pVertexInputState = &key->input_desc; + key->pipeline_desc.pInputAssemblyState = &key->ia_desc; + key->pipeline_desc.pViewportState = &key->vp_desc; + key->pipeline_desc.pRasterizationState = &key->rs_desc; + key->pipeline_desc.pMultisampleState = &key->ms_desc; + key->pipeline_desc.pDepthStencilState = &key->ds_desc; + key->pipeline_desc.pColorBlendState = &key->blend_desc; + key->pipeline_desc.pDynamicState = &key->dynamic_desc; + key->pipeline_desc.basePipelineIndex = -1; +} + +static bool wined3d_context_vk_update_graphics_pipeline_key(struct wined3d_context_vk *context_vk, + const struct wined3d_state *state, VkPipelineLayout vk_pipeline_layout) +{ + const struct wined3d_d3d_info *d3d_info = context_vk->c.d3d_info; + unsigned int i, attribute_count, binding_count, stage_count; + struct wined3d_graphics_pipeline_key_vk *key; + VkPipelineShaderStageCreateInfo *stage; + struct wined3d_stream_info stream_info; + VkShaderModule module; + bool update = false; + uint32_t mask; + + key = &context_vk->graphics.pipeline_key_vk; + + if (context_vk->c.shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE)) + { + stage_count = 0; + for (i = 0; i < ARRAY_SIZE(context_vk->graphics.vk_modules); ++i) + { + if (!(module = context_vk->graphics.vk_modules[i])) + continue; + + stage = &key->stages[stage_count++]; + stage->stage = vk_shader_stage_from_wined3d(i); + stage->module = module; + } + + key->pipeline_desc.stageCount = stage_count; + + update = true; + } + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_VDECL) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STREAMSRC) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX))) + { + wined3d_stream_info_from_declaration(&stream_info, state, d3d_info); + for (i = 0, mask = 0, attribute_count = 0, binding_count = 0; i < ARRAY_SIZE(stream_info.elements); ++i) + { + struct wined3d_stream_info_element *e; + VkVertexInputAttributeDescription *a; + VkVertexInputBindingDescription *b; + uint32_t binding; + + if (!(stream_info.use_map & (1u << i))) + continue; + + a = &key->attributes[attribute_count++]; + e = &stream_info.elements[i]; + binding = e->stream_idx; + + a->location = i; + a->binding = binding; + a->format = wined3d_format_vk(e->format)->vk_format; + a->offset = (UINT_PTR)e->data.addr - state->streams[binding].offset; + + if (mask & (1u << binding)) + continue; + mask |= 1u << binding; + + b = &key->bindings[binding_count++]; + b->binding = binding; + b->stride = e->stride; + b->inputRate = e->divisor ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX; + } + + key->input_desc.vertexBindingDescriptionCount = binding_count; + key->input_desc.vertexAttributeDescriptionCount = attribute_count; + + update = true; + } + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_VIEWPORT)) + { + key->viewport.x = state->viewports[0].x; + key->viewport.y = state->viewports[0].y; + key->viewport.width = state->viewports[0].width; + key->viewport.height = state->viewports[0].height; + key->viewport.minDepth = state->viewports[0].min_z; + key->viewport.maxDepth = state->viewports[0].max_z; + + key->scissor.offset.x = key->viewport.x; + key->scissor.offset.y = key->viewport.y; + key->scissor.extent.width = key->viewport.width; + key->scissor.extent.height = key->viewport.height; + key->viewport.y += key->viewport.height; + key->viewport.height = -key->viewport.height; + + update = true; + } + + if (key->ms_desc.rasterizationSamples != context_vk->sample_count) + { + key->ms_desc.rasterizationSamples = context_vk->sample_count; + + update = true; + } + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)) + { + key->blend_desc.attachmentCount = context_vk->rt_count; + + memset(key->blend_attachments, 0, sizeof(key->blend_attachments)); + for (i = 0; i < context_vk->rt_count; ++i) + { + key->blend_attachments[i].colorWriteMask = VK_COLOR_COMPONENT_R_BIT + | VK_COLOR_COMPONENT_G_BIT + | VK_COLOR_COMPONENT_B_BIT + | VK_COLOR_COMPONENT_A_BIT; + } + + update = true; + } + + if (key->pipeline_desc.layout != vk_pipeline_layout) + { + key->pipeline_desc.layout = vk_pipeline_layout; + + update = true; + } + + if (key->pipeline_desc.renderPass != context_vk->vk_render_pass) + { + key->pipeline_desc.renderPass = context_vk->vk_render_pass; + + update = true; + } + + return update; +} + static bool wined3d_context_vk_begin_render_pass(struct wined3d_context_vk *context_vk, VkCommandBuffer vk_command_buffer, const struct wined3d_state *state, const struct wined3d_vk_info *vk_info) { @@ -1274,6 +1543,7 @@ static bool wined3d_context_vk_begin_render_pass(struct wined3d_context_vk *cont fb_layer_count = limits->maxFramebufferLayers; attachment_count = 0; + context_vk->rt_count = 0; for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i) { if (!(view = state->fb.render_targets[i]) || view->format->id == WINED3DFMT_NULL) @@ -1289,6 +1559,7 @@ static bool wined3d_context_vk_begin_render_pass(struct wined3d_context_vk *cont fb_height = view->height; if (view->layer_count < fb_layer_count) fb_layer_count = view->layer_count; + context_vk->rt_count = i + 1; ++attachment_count; } @@ -1766,9 +2037,33 @@ fail: static VkPipeline wined3d_context_vk_get_graphics_pipeline(struct wined3d_context_vk *context_vk) { - FIXME("Not implemented.\n"); + struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + struct wined3d_graphics_pipeline_vk *pipeline_vk; + struct wined3d_graphics_pipeline_key_vk *key; + struct wine_rb_entry *entry; + VkResult vr; + + key = &context_vk->graphics.pipeline_key_vk; + if ((entry = wine_rb_get(&context_vk->graphics_pipelines, key))) + return WINE_RB_ENTRY_VALUE(entry, struct wined3d_graphics_pipeline_vk, entry)->vk_pipeline; - return VK_NULL_HANDLE; + if (!(pipeline_vk = heap_alloc(sizeof(*pipeline_vk)))) + return VK_NULL_HANDLE; + pipeline_vk->key = *key; + + if ((vr = VK_CALL(vkCreateGraphicsPipelines(device_vk->vk_device, + VK_NULL_HANDLE, 1, &key->pipeline_desc, NULL, &pipeline_vk->vk_pipeline))) < 0) + { + WARN("Failed to create graphics pipeline, vr %s.\n", wined3d_debug_vkresult(vr)); + heap_free(pipeline_vk); + return VK_NULL_HANDLE; + } + + if (wine_rb_put(&context_vk->graphics_pipelines, &pipeline_vk->key, &pipeline_vk->entry) == -1) + ERR("Failed to insert pipeline.\n"); + + return pipeline_vk->vk_pipeline; } static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk *context_vk, @@ -1960,7 +2255,6 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c ERR("No pipeline layout set.\n"); return VK_NULL_HANDLE; } - context_vk->c.shader_update_mask &= 1u << WINED3D_SHADER_TYPE_COMPUTE; context_vk->c.update_shader_resource_bindings = 1; context_vk->c.update_unordered_access_view_bindings = 1; } @@ -1991,12 +2285,18 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c return VK_NULL_HANDLE; } - if (!(context_vk->graphics.vk_pipeline = wined3d_context_vk_get_graphics_pipeline(context_vk))) + if (wined3d_context_vk_update_graphics_pipeline_key(context_vk, state, context_vk->graphics.vk_pipeline_layout) + || !context_vk->graphics.vk_pipeline) { - ERR("Failed to get graphics pipeline.\n"); - return VK_NULL_HANDLE; + if (!(context_vk->graphics.vk_pipeline = wined3d_context_vk_get_graphics_pipeline(context_vk))) + { + ERR("Failed to get graphics pipeline.\n"); + return VK_NULL_HANDLE; + } + + VK_CALL(vkCmdBindPipeline(vk_command_buffer, + VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); } - VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_INDEXBUFFER) && state->index_buffer) { @@ -2039,6 +2339,7 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c } memset(context_vk->c.dirty_graphics_states, 0, sizeof(context_vk->c.dirty_graphics_states)); + context_vk->c.shader_update_mask &= 1u << WINED3D_SHADER_TYPE_COMPUTE; return vk_command_buffer; } @@ -2063,7 +2364,6 @@ VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk ERR("No compute pipeline set.\n"); return VK_NULL_HANDLE; } - context_vk->c.shader_update_mask &= ~(1u << WINED3D_SHADER_TYPE_COMPUTE); context_vk->c.update_compute_shader_resource_bindings = 1; context_vk->c.update_compute_unordered_access_view_bindings = 1; context_vk->update_compute_pipeline = 1; @@ -2107,6 +2407,7 @@ VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk } memset(context_vk->c.dirty_compute_states, 0, sizeof(context_vk->c.dirty_compute_states)); + context_vk->c.shader_update_mask &= ~(1u << WINED3D_SHADER_TYPE_COMPUTE); return vk_command_buffer; } @@ -2139,8 +2440,11 @@ HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wi } context_vk->current_command_buffer.id = 1; + wined3d_context_vk_init_graphics_pipeline_key(context_vk); + wine_rb_init(&context_vk->render_passes, wined3d_render_pass_vk_compare); wine_rb_init(&context_vk->pipeline_layouts, wined3d_pipeline_layout_vk_compare); + wine_rb_init(&context_vk->graphics_pipelines, wined3d_graphics_pipeline_vk_compare); wine_rb_init(&context_vk->bo_slab_available, wined3d_bo_slab_vk_compare); return WINED3D_OK; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index a56d1f59ecc..84391470657 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2320,6 +2320,34 @@ struct wined3d_pipeline_layout_vk VkDescriptorSetLayout vk_set_layout; }; +struct wined3d_graphics_pipeline_key_vk +{ + VkPipelineShaderStageCreateInfo stages[WINED3D_SHADER_TYPE_GRAPHICS_COUNT]; + VkVertexInputAttributeDescription attributes[MAX_ATTRIBS]; + VkVertexInputBindingDescription bindings[MAX_ATTRIBS]; + VkViewport viewport; + VkRect2D scissor; + VkPipelineColorBlendAttachmentState blend_attachments[WINED3D_MAX_RENDER_TARGETS]; + + VkPipelineVertexInputStateCreateInfo input_desc; + VkPipelineInputAssemblyStateCreateInfo ia_desc; + VkPipelineViewportStateCreateInfo vp_desc; + VkPipelineRasterizationStateCreateInfo rs_desc; + VkPipelineMultisampleStateCreateInfo ms_desc; + VkPipelineDepthStencilStateCreateInfo ds_desc; + VkPipelineColorBlendStateCreateInfo blend_desc; + VkPipelineDynamicStateCreateInfo dynamic_desc; + + VkGraphicsPipelineCreateInfo pipeline_desc; +}; + +struct wined3d_graphics_pipeline_vk +{ + struct wine_rb_entry entry; + struct wined3d_graphics_pipeline_key_vk key; + VkPipeline vk_pipeline; +}; + enum wined3d_shader_descriptor_type { WINED3D_SHADER_DESCRIPTOR_TYPE_CBV, @@ -2363,6 +2391,7 @@ struct wined3d_context_vk struct { VkShaderModule vk_modules[WINED3D_SHADER_TYPE_GRAPHICS_COUNT]; + struct wined3d_graphics_pipeline_key_vk pipeline_key_vk; VkPipeline vk_pipeline; VkPipelineLayout vk_pipeline_layout; VkDescriptorSetLayout vk_set_layout; @@ -2395,10 +2424,12 @@ struct wined3d_context_vk VkDescriptorPool vk_descriptor_pool; VkSampleCountFlagBits sample_count; + unsigned int rt_count; struct wined3d_retired_objects_vk retired; struct wine_rb_tree render_passes; struct wine_rb_tree pipeline_layouts; + struct wine_rb_tree graphics_pipelines; struct wine_rb_tree bo_slab_available; }; -- 2.20.1

1 0

[PATCH 1/6] wined3d: Implement shader_spirv_select().
by Henri Verbeet May 19, 2020

May 19, 2020

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_vk.c | 16 +++ dlls/wined3d/shader_spirv.c | 226 ++++++++++++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 237 insertions(+), 7 deletions(-) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index f5902bbd65a..08ce3db7ccc 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -1893,6 +1893,7 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); const struct wined3d_vk_info *vk_info = context_vk->vk_info; struct wined3d_rendertarget_view *dsv; + VkSampleCountFlagBits sample_count; VkCommandBuffer vk_command_buffer; unsigned int i; @@ -1908,6 +1909,7 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN))) context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_DOMAIN); + context_vk->sample_count = 0; for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i) { struct wined3d_rendertarget_view *rtv; @@ -1924,6 +1926,12 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c { wined3d_rendertarget_view_prepare_location(rtv, &context_vk->c, rtv->resource->draw_binding); } + + sample_count = max(1, wined3d_resource_get_sample_count(rtv->resource)); + if (!context_vk->sample_count) + context_vk->sample_count = sample_count; + else if (context_vk->sample_count != sample_count) + FIXME("Inconsistent sample counts (%u != %u).\n", context_vk->sample_count, sample_count); } if ((dsv = state->fb.depth_stencil)) @@ -1934,8 +1942,16 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c wined3d_rendertarget_view_prepare_location(dsv, &context_vk->c, dsv->resource->draw_binding); if (state->render_states[WINED3D_RS_ZWRITEENABLE]) wined3d_rendertarget_view_invalidate_location(dsv, ~dsv->resource->draw_binding); + + sample_count = max(1, wined3d_resource_get_sample_count(dsv->resource)); + if (!context_vk->sample_count) + context_vk->sample_count = sample_count; + else if (context_vk->sample_count != sample_count) + FIXME("Inconsistent sample counts (%u != %u).\n", context_vk->sample_count, sample_count); } + if (!context_vk->sample_count) + context_vk->sample_count = VK_SAMPLE_COUNT_1_BIT; if (context_vk->c.shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE)) { device_vk->d.shader_backend->shader_select(device_vk->d.shader_priv, &context_vk->c, state); diff --git a/dlls/wined3d/shader_spirv.c b/dlls/wined3d/shader_spirv.c index 2dc07b14f1d..07b9a5202bc 100644 --- a/dlls/wined3d/shader_spirv.c +++ b/dlls/wined3d/shader_spirv.c @@ -30,6 +30,8 @@ struct shader_spirv_resource_bindings { VkDescriptorSetLayoutBinding *vk_bindings; SIZE_T vk_bindings_size, vk_binding_count; + + size_t binding_base[WINED3D_SHADER_TYPE_COUNT]; }; struct shader_spirv_priv @@ -41,6 +43,38 @@ struct shader_spirv_priv struct shader_spirv_resource_bindings bindings; }; +struct shader_spirv_compile_arguments +{ + union + { + struct + { + uint32_t alpha_swizzle; + unsigned int sample_count; + } fs; + + struct + { + enum wined3d_tessellator_output_primitive output_primitive; + enum wined3d_tessellator_partitioning partitioning; + } tes; + } u; +}; + +struct shader_spirv_graphics_program_variant_vk +{ + struct shader_spirv_compile_arguments compile_args; + size_t binding_base; + + VkShaderModule vk_module; +}; + +struct shader_spirv_graphics_program_vk +{ + struct shader_spirv_graphics_program_variant_vk *variants; + SIZE_T variants_size, variant_count; +}; + struct shader_spirv_compute_program_vk { VkShaderModule vk_module; @@ -53,14 +87,95 @@ static void shader_spirv_handle_instruction(const struct wined3d_shader_instruct { } +static void shader_spirv_compile_arguments_init(struct shader_spirv_compile_arguments *args, + const struct wined3d_context *context, const struct wined3d_shader *shader, + const struct wined3d_state *state, unsigned int sample_count) +{ + const struct wined3d_shader *hull_shader; + struct wined3d_rendertarget_view *rtv; + unsigned int i; + + memset(args, 0, sizeof(*args)); + + switch (shader->reg_maps.shader_version.type) + { + case WINED3D_SHADER_TYPE_DOMAIN: + hull_shader = state->shader[WINED3D_SHADER_TYPE_HULL]; + args->u.tes.output_primitive = hull_shader->u.hs.tessellator_output_primitive; + if (args->u.tes.output_primitive == WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CW) + args->u.tes.output_primitive = WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW; + else if (args->u.tes.output_primitive == WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW) + args->u.tes.output_primitive = WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CW; + args->u.tes.partitioning = hull_shader->u.hs.tessellator_partitioning; + break; + + case WINED3D_SHADER_TYPE_PIXEL: + for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i) + { + if (!(rtv = state->fb.render_targets[i]) || rtv->format->id == WINED3DFMT_NULL) + continue; + if (rtv->format->id == WINED3DFMT_A8_UNORM && !is_identity_fixup(rtv->format->color_fixup)) + args->u.fs.alpha_swizzle |= 1u << i; + } + args->u.fs.sample_count = sample_count; + break; + + default: + break; + } +} + static VkShaderModule shader_spirv_compile(struct wined3d_context_vk *context_vk, - struct wined3d_shader *shader, const struct shader_spirv_resource_bindings *bindings) + struct wined3d_shader *shader, const struct shader_spirv_compile_arguments *args, + const struct shader_spirv_resource_bindings *bindings) { FIXME("Not implemented.\n"); return VK_NULL_HANDLE; } +static struct shader_spirv_graphics_program_variant_vk *shader_spirv_find_graphics_program_variant_vk( + struct shader_spirv_priv *priv, struct wined3d_context_vk *context_vk, struct wined3d_shader *shader, + const struct wined3d_state *state, const struct shader_spirv_resource_bindings *bindings) +{ + size_t binding_base = bindings->binding_base[shader->reg_maps.shader_version.type]; + struct shader_spirv_graphics_program_variant_vk *variant_vk; + struct shader_spirv_graphics_program_vk *program_vk; + struct shader_spirv_compile_arguments args; + size_t variant_count, i; + + shader_spirv_compile_arguments_init(&args, &context_vk->c, shader, state, context_vk->sample_count); + + if (!(program_vk = shader->backend_data)) + { + if (!(program_vk = heap_alloc_zero(sizeof(*program_vk)))) + return NULL; + shader->backend_data = program_vk; + } + + variant_count = program_vk->variant_count; + for (i = 0; i < variant_count; ++i) + { + variant_vk = &program_vk->variants[i]; + if (variant_vk->binding_base == binding_base + && !memcmp(&variant_vk->compile_args, &args, sizeof(args))) + return variant_vk; + } + + if (!wined3d_array_reserve((void **)&program_vk->variants, &program_vk->variants_size, + variant_count + 1, sizeof(*program_vk->variants))) + return NULL; + + variant_vk = &program_vk->variants[variant_count]; + variant_vk->compile_args = args; + variant_vk->binding_base = binding_base; + if (!(variant_vk->vk_module = shader_spirv_compile(context_vk, shader, &args, bindings))) + return NULL; + ++program_vk->variant_count; + + return variant_vk; +} + static struct shader_spirv_compute_program_vk *shader_spirv_find_compute_program_vk(struct shader_spirv_priv *priv, struct wined3d_context_vk *context_vk, struct wined3d_shader *shader, const struct shader_spirv_resource_bindings *bindings) @@ -78,7 +193,7 @@ static struct shader_spirv_compute_program_vk *shader_spirv_find_compute_program if (!(program = heap_alloc(sizeof(*program)))) return NULL; - if (!(program->vk_module = shader_spirv_compile(context_vk, shader, bindings))) + if (!(program->vk_module = shader_spirv_compile(context_vk, shader, NULL, bindings))) { heap_free(program); return NULL; @@ -191,6 +306,8 @@ static bool shader_spirv_resource_bindings_init(struct shader_spirv_resource_bin for (shader_type = 0; shader_type < WINED3D_SHADER_TYPE_COUNT; ++shader_type) { + bindings->binding_base[shader_type] = bindings->vk_binding_count; + if (!(shader_mask & (1u << shader_type)) || !(shader = state->shader[shader_type])) continue; @@ -295,10 +412,53 @@ static void shader_spirv_precompile(void *shader_priv, struct wined3d_shader *sh static void shader_spirv_select(void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state) { + struct wined3d_context_vk *context_vk = wined3d_context_vk(context); + struct shader_spirv_graphics_program_variant_vk *variant_vk; + struct shader_spirv_resource_bindings *bindings; + size_t binding_base[WINED3D_SHADER_TYPE_COUNT]; + struct wined3d_pipeline_layout_vk *layout_vk; struct shader_spirv_priv *priv = shader_priv; + enum wined3d_shader_type shader_type; + struct wined3d_shader *shader; priv->vertex_pipe->vp_enable(context, !use_vs(state)); priv->fragment_pipe->fp_enable(context, !use_ps(state)); + + bindings = &priv->bindings; + memcpy(binding_base, bindings->binding_base, sizeof(bindings)); + if (!shader_spirv_resource_bindings_init(bindings, &context_vk->graphics.bindings, + state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE))) + { + ERR("Failed to initialise shader resource bindings.\n"); + goto fail; + } + + layout_vk = wined3d_context_vk_get_pipeline_layout(context_vk, bindings->vk_bindings, bindings->vk_binding_count); + context_vk->graphics.vk_set_layout = layout_vk->vk_set_layout; + context_vk->graphics.vk_pipeline_layout = layout_vk->vk_pipeline_layout; + + for (shader_type = 0; shader_type < ARRAY_SIZE(context_vk->graphics.vk_modules); ++shader_type) + { + if (!(context->shader_update_mask & (1u << shader_type)) && (!context_vk->graphics.vk_modules[shader_type] + || binding_base[shader_type] == bindings->binding_base[shader_type])) + continue; + + if (!(shader = state->shader[shader_type])) + { + context_vk->graphics.vk_modules[shader_type] = VK_NULL_HANDLE; + continue; + } + + if (!(variant_vk = shader_spirv_find_graphics_program_variant_vk(priv, context_vk, shader, state, bindings))) + goto fail; + context_vk->graphics.vk_modules[shader_type] = variant_vk->vk_module; + } + + return; + +fail: + context_vk->graphics.vk_set_layout = VK_NULL_HANDLE; + context_vk->graphics.vk_pipeline_layout = VK_NULL_HANDLE; } static void shader_spirv_select_compute(void *shader_priv, @@ -386,14 +546,37 @@ static void shader_spirv_invalidate_contexts_compute_program(struct wined3d_devi } } -static void shader_spirv_destroy(struct wined3d_shader *shader) +static void shader_spirv_invalidate_graphics_program_variant(struct wined3d_context_vk *context_vk, + const struct shader_spirv_graphics_program_variant_vk *variant) +{ + enum wined3d_shader_type shader_type; + + for (shader_type = 0; shader_type < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++shader_type) + { + if (context_vk->graphics.vk_modules[shader_type] != variant->vk_module) + continue; + + context_vk->graphics.vk_modules[shader_type] = VK_NULL_HANDLE; + context_vk->c.shader_update_mask |= (1u << shader_type); + } +} + +static void shader_spirv_invalidate_contexts_graphics_program_variant(struct wined3d_device *device, + const struct shader_spirv_graphics_program_variant_vk *variant) +{ + unsigned int i; + + for (i = 0; i < device->context_count; ++i) + { + shader_spirv_invalidate_graphics_program_variant(wined3d_context_vk(device->contexts[i]), variant); + } +} + +static void shader_spirv_destroy_compute_vk(struct wined3d_shader *shader) { struct wined3d_device_vk *device_vk = wined3d_device_vk(shader->device); + struct shader_spirv_compute_program_vk *program = shader->backend_data; struct wined3d_vk_info *vk_info = &device_vk->vk_info; - struct shader_spirv_compute_program_vk *program; - - if (!(program = shader->backend_data)) - return; shader_spirv_invalidate_contexts_compute_program(&device_vk->d, program); VK_CALL(vkDestroyPipeline(device_vk->vk_device, program->vk_pipeline, NULL)); @@ -402,6 +585,35 @@ static void shader_spirv_destroy(struct wined3d_shader *shader) heap_free(program); } +static void shader_spirv_destroy(struct wined3d_shader *shader) +{ + struct wined3d_device_vk *device_vk = wined3d_device_vk(shader->device); + struct shader_spirv_graphics_program_variant_vk *variant_vk; + struct wined3d_vk_info *vk_info = &device_vk->vk_info; + struct shader_spirv_graphics_program_vk *program_vk; + size_t i; + + if (!shader->backend_data) + return; + + if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_COMPUTE) + { + shader_spirv_destroy_compute_vk(shader); + return; + } + + program_vk = shader->backend_data; + for (i = 0; i < program_vk->variant_count; ++i) + { + variant_vk = &program_vk->variants[i]; + shader_spirv_invalidate_contexts_graphics_program_variant(&device_vk->d, variant_vk); + VK_CALL(vkDestroyShaderModule(device_vk->vk_device, variant_vk->vk_module, NULL)); + } + + shader->backend_data = NULL; + heap_free(program_vk); +} + static HRESULT shader_spirv_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe, const struct wined3d_fragment_pipe_ops *fragment_pipe) { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index ef82fd7b0c1..a56d1f59ecc 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2394,6 +2394,8 @@ struct wined3d_context_vk VkRenderPass vk_render_pass; VkDescriptorPool vk_descriptor_pool; + VkSampleCountFlagBits sample_count; + struct wined3d_retired_objects_vk retired; struct wine_rb_tree render_passes; struct wine_rb_tree pipeline_layouts; -- 2.20.1

1 0

[PATCH vkd3d] vkd3d-shader: Increment the token pointer before reading the next one.
by Zebediah Figura May 19, 2020

May 19, 2020

From: Hans-Kristian Arntzen <post(a)arntzen-software.no> Signed-off-by: Hans-Kristian Arntzen <post(a)arntzen-software.no> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 98c51e4..5e504dc 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -873,7 +873,7 @@ static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction * shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &ins->declaration.structured_resource.reg); ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - ins->declaration.structured_resource.byte_stride = *tokens; + ins->declaration.structured_resource.byte_stride = *tokens++; if (ins->declaration.structured_resource.byte_stride % 4) FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride); shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space); @@ -908,7 +908,7 @@ static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruct const DWORD *end = &tokens[token_count]; shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &ins->declaration.structured_resource.reg); - ins->declaration.structured_resource.byte_stride = *tokens; + ins->declaration.structured_resource.byte_stride = *tokens++; if (ins->declaration.structured_resource.byte_stride % 4) FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride); shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space); -- 2.26.2

1 0

Absolute Junction Points/Symlinks
by Erich E. Hoover May 19, 2020

May 19, 2020

I've been trying to come up with a way to solve the problem of creating absolute symlinks inside a WINEPREFIX, since I believe this is now the last barrier for the Junction Point/Symlink patches*. The current staging patch includes the prefix path in the absolute symlink, which creates obvious problems if the prefix is ever moved to a new location. A proposal a while back was to use "/proc/self/cwd" as part of the symlink and force wine to always use the prefix folder as the "real" working directory. This has the downside that the symlinks will break outside of Wine, but got me thinking about other possible ways to make the absolute symlinks work outside of Wine. So, I put together a small tool that builds a chroot for the prefix and creates a special root folder "??" with bind mounts that allows symlinks to follow a semi-NT style (e.g. '/??/C:/windows/system32' instead of '\??\C:\windows\system32'). This technique wound up working remarkably well, with the obvious downside that it requires additional administrative privileges for the "launcher" app. This idea has a logical extension to drop the need for admin rights: use LD_PRELOAD and wrap essential path resolution functions. While conceptually straightforward, this is very challenging to do in practice. Fortunately, we are not actually trying to create a chroot - we just need to inject a fake "??" folder at the root mount point. After quite a bit of trial and error I've managed to put together a "wineprefix" tool that does this correctly for both Wine and bash, a couple interesting examples are attached (examples.txt). I'm curious what people think about this approach. You clearly need to run "wineprefix" for the symlinks to be valid, but once you've done that everything "just works". So, what do people think? Is this worth turning into a tool for Wine or is it completely insane? Best, Erich * sans some rebasing work that recently got introduced

4 7

[PATCH] shlwapi: Fix SHRegDuplicateHKey declarations.
by Serge Gautherie May 19, 2020

May 19, 2020

Signed-off-by: Serge Gautherie <winehq-git_serge_180711(a)gautherie.fr> --- Follow-up to https://source.winehq.org/git/wine.git/commit/3e35bf3889031e86f0ad5a6ed5470… --- .../api-ms-win-downlevel-shlwapi-l2-1-0.spec | 2 +- dlls/shcore/main.c | 10 +++++++++- dlls/shcore/shcore.spec | 2 +- dlls/shlwapi/shlwapi.spec | 2 +- include/shlwapi.h | 2 +- 5 files changed, 13 insertions(+), 5 deletions(-) diff --git a/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec b/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec index 11c33f8..a2b2ce9 100644 --- a/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec +++ b/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec @@ -40,7 +40,7 @@ @ stdcall SHQueryInfoKeyW(long ptr ptr ptr ptr) shlwapi.SHQueryInfoKeyW @ stdcall SHQueryValueExA(long str ptr ptr ptr ptr) shlwapi.SHQueryValueExA @ stdcall SHQueryValueExW(long wstr ptr ptr ptr ptr) shlwapi.SHQueryValueExW -@ stdcall SHRegDuplicateHKey(long) shlwapi.SHRegDuplicateHKey +@ stdcall SHRegDuplicateHKey(ptr) shlwapi.SHRegDuplicateHKey @ stdcall SHRegGetPathA(long str str ptr long) shlwapi.SHRegGetPathA @ stdcall SHRegGetPathW(long wstr wstr ptr long) shlwapi.SHRegGetPathW @ stdcall SHRegGetValueA( long str str long ptr ptr ptr ) shlwapi.SHRegGetValueA diff --git a/dlls/shcore/main.c b/dlls/shcore/main.c index 3f95c1f..01b7747 100644 --- a/dlls/shcore/main.c +++ b/dlls/shcore/main.c @@ -1781,8 +1781,16 @@ DWORD WINAPI SHAnsiToUnicode(const char *src, WCHAR *dest, int dest_len) /************************************************************************* * SHRegDuplicateHKey [SHCORE.@] + * + * Create a duplicate of a registry handle. + * + * PARAMS + * hKey [I] key to duplicate. + * + * RETURNS + * A new handle pointing to the same key as hKey. */ -HKEY WINAPI SHRegDuplicateHKey(HKEY hKey) +HKEY WINAPI SHRegDuplicateHKey(IN HKEY hKey) { HKEY newKey = 0; diff --git a/dlls/shcore/shcore.spec b/dlls/shcore/shcore.spec index d5b7a34..db74017 100644 --- a/dlls/shcore/shcore.spec +++ b/dlls/shcore/shcore.spec @@ -61,7 +61,7 @@ @ stdcall SHQueryInfoKeyW(long ptr ptr ptr ptr) @ stdcall SHQueryValueExA(long str ptr ptr ptr ptr) @ stdcall SHQueryValueExW(long wstr ptr ptr ptr ptr) -@ stdcall SHRegDuplicateHKey(long) +@ stdcall SHRegDuplicateHKey(ptr) @ stdcall SHRegGetIntW(ptr wstr long) @ stdcall SHRegGetPathA(long str str ptr long) @ stdcall SHRegGetPathW(long wstr wstr ptr long) diff --git a/dlls/shlwapi/shlwapi.spec b/dlls/shlwapi/shlwapi.spec index b126a46..af61b8d 100644 --- a/dlls/shlwapi/shlwapi.spec +++ b/dlls/shlwapi/shlwapi.spec @@ -720,7 +720,7 @@ @ stdcall SHRegDeleteEmptyUSKeyW(long wstr long) @ stdcall SHRegDeleteUSValueA(long str long) @ stdcall SHRegDeleteUSValueW(long wstr long) -@ stdcall -import SHRegDuplicateHKey(long) +@ stdcall -import SHRegDuplicateHKey(ptr) @ stdcall SHRegEnumUSKeyA(long long str ptr long) @ stdcall SHRegEnumUSKeyW(long long wstr ptr long) @ stdcall SHRegEnumUSValueA(long long ptr ptr ptr ptr ptr long) diff --git a/include/shlwapi.h b/include/shlwapi.h index ca15bd2..d6943d0 100644 --- a/include/shlwapi.h +++ b/include/shlwapi.h @@ -91,7 +91,7 @@ DWORD WINAPI SHCopyKeyA(HKEY,LPCSTR,HKEY,DWORD); DWORD WINAPI SHCopyKeyW(HKEY,LPCWSTR,HKEY,DWORD); #define SHCopyKey WINELIB_NAME_AW(SHCopyKey) -HKEY WINAPI SHRegDuplicateHKey(HKEY); +HKEY WINAPI SHRegDuplicateHKey(IN HKEY hKey); /* SHRegGetValue flags */ typedef INT SRRF; -- 2.10.0.windows.1

2 4

[PATCH vkd3d 01/11] vkd3d: Implement support for D3D12_FEATURE_D3D12_OPTIONS1.
by Conor McCarthy May 19, 2020

May 19, 2020

Signed-off-by: Conor McCarthy <conor.mccarthy.444(a)gmail.com> --- include/vkd3d_d3d12.idl | 10 ++++++++++ libs/vkd3d/device.c | 28 ++++++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 1 + 3 files changed, 39 insertions(+) diff --git a/include/vkd3d_d3d12.idl b/include/vkd3d_d3d12.idl index ec8b83d..5cfb229 100644 --- a/include/vkd3d_d3d12.idl +++ b/include/vkd3d_d3d12.idl @@ -1608,6 +1608,16 @@ typedef struct D3D12_FEATURE_DATA_SHADER_MODEL D3D_SHADER_MODEL HighestShaderModel; } D3D12_FEATURE_DATA_SHADER_MODEL; +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 +{ + BOOL WaveOps; + UINT WaveLaneCountMin; + UINT WaveLaneCountMax; + UINT TotalLaneCount; + BOOL ExpandedComputeResourceStates; + BOOL Int64ShaderOps; +} D3D12_FEATURE_DATA_D3D12_OPTIONS1; + typedef enum D3D12_FEATURE { D3D12_FEATURE_D3D12_OPTIONS = 0, diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index fd593bc..90044ac 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1336,6 +1336,13 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, device->feature_options.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = FALSE; device->feature_options.ResourceHeapTier = D3D12_RESOURCE_HEAP_TIER_2; + device->feature_options1.WaveOps = FALSE; + device->feature_options1.WaveLaneCountMin = 0; + device->feature_options1.WaveLaneCountMax = 0; + device->feature_options1.TotalLaneCount = 0; + device->feature_options1.ExpandedComputeResourceStates = TRUE; + device->feature_options1.Int64ShaderOps = features->shaderInt64; + if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL))) < 0) { ERR("Failed to enumerate device extensions, vr %d.\n", vr); @@ -2668,6 +2675,27 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device * return S_OK; } + case D3D12_FEATURE_D3D12_OPTIONS1: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS1 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options1; + + TRACE("Wave ops %#x.\n", data->WaveOps); + TRACE("Min wave lane count %#x.\n", data->WaveLaneCountMin); + TRACE("Max wave lane count %#x.\n", data->WaveLaneCountMax); + TRACE("Total lane count %#x.\n", data->TotalLaneCount); + TRACE("Expanded compute resource states %#x.\n", data->ExpandedComputeResourceStates); + TRACE("Int64 shader ops %#x.\n", data->Int64ShaderOps); + return S_OK; + } + case D3D12_FEATURE_ROOT_SIGNATURE: { D3D12_FEATURE_DATA_ROOT_SIGNATURE *data = feature_data; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 28801ba..6c7ec4e 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -1131,6 +1131,7 @@ struct d3d12_device VkPhysicalDeviceMemoryProperties memory_properties; D3D12_FEATURE_DATA_D3D12_OPTIONS feature_options; + D3D12_FEATURE_DATA_D3D12_OPTIONS1 feature_options1; struct vkd3d_vulkan_info vk_info; -- 2.24.0

1 10

[PATCH v2] configure: Use cross compiler for EXCESS_PRECISION_CFLAGS check when available.
by Jacek Caban May 19, 2020

May 19, 2020

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- configure.ac | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)

1 0

[PATCH 1/2] ucrtbase: Add tests and fix more zero length __stdio_common_vs[w]printf cases
by Martin Storsjo May 19, 2020

May 19, 2020

Signed-off-by: Martin Storsjo <martin(a)martin.st> --- This is an old patch that I happened to have lying around; don't remember much of the details of it, but if it applies and still works, I guess it'd be worthwhile. --- dlls/msvcrt/wcs.c | 8 ++++++-- dlls/ucrtbase/tests/printf.c | 25 +++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/dlls/msvcrt/wcs.c b/dlls/msvcrt/wcs.c index 17d06eed3c..f751d658ef 100644 --- a/dlls/msvcrt/wcs.c +++ b/dlls/msvcrt/wcs.c @@ -744,7 +744,9 @@ int CDECL __stdio_common_vsprintf( unsigned __int64 options, char *str, MSVCRT_s return ret>len ? -1 : ret; if(ret>=len) { if(len) str[len-1] = 0; - return (options & UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR) ? ret : -2; + if(options & UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR) + return ret; + return len > 0 ? -2 : -1; } return ret; } @@ -1284,7 +1286,9 @@ int CDECL MSVCRT__stdio_common_vswprintf( unsigned __int64 options, return ret>len ? -1 : ret; if(ret>=len) { if(len) str[len-1] = 0; - return (options & UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR) ? ret : -2; + if(options & UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR) + return ret; + return len > 0 ? -2 : -1; } return ret; } diff --git a/dlls/ucrtbase/tests/printf.c b/dlls/ucrtbase/tests/printf.c index 8cacbbb79a..3b48e08b10 100644 --- a/dlls/ucrtbase/tests/printf.c +++ b/dlls/ucrtbase/tests/printf.c @@ -144,6 +144,18 @@ static void test_snprintf (void) "Failure to snprintf to NULL\n"); ok (vsprintf_wrapper (0, NULL, 0, "abcd") == 4, "Failure to snprintf to NULL\n"); + ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, "abcd") == 4, + "Failure to snprintf to zero length buffer\n"); + ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, "abcd") == -1, + "Failure to snprintf to zero length buffer\n"); + ok (vsprintf_wrapper (0, buffer, 0, "abcd") == -1, + "Failure to snprintf to zero length buffer\n"); + ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, "") == 0, + "Failure to snprintf a zero length string to a zero length buffer\n"); + ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, "") == 0, + "Failure to snprintf a zero length string to a zero length buffer\n"); + ok (vsprintf_wrapper (0, buffer, 0, "") == -1, + "Failure to snprintf a zero length string to a zero length buffer\n"); } static int WINAPIV vswprintf_wrapper(unsigned __int64 options, wchar_t *str, @@ -163,6 +175,7 @@ static void test_swprintf (void) const wchar_t str_justfit[] = {'j','u','s','t','f','i','t',0}; const wchar_t str_justfits[] = {'j','u','s','t','f','i','t','s',0}; const wchar_t str_muchlonger[] = {'m','u','c','h','l','o','n','g','e','r',0}; + const wchar_t str_empty[] = {0}; const wchar_t *tests[] = {str_short, str_justfit, str_justfits, str_muchlonger}; wchar_t buffer[8]; @@ -225,6 +238,18 @@ static void test_swprintf (void) "Failure to swprintf to NULL\n"); ok (vswprintf_wrapper (0, NULL, 0, str_short) == 5, "Failure to swprintf to NULL\n"); + ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, str_short) == 5, + "Failure to swprintf to a zero length buffer\n"); + ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, str_short) == -1, + "Failure to swprintf to a zero length buffer\n"); + ok (vswprintf_wrapper (0, buffer, 0, str_short) == -1, + "Failure to swprintf to a zero length buffer\n"); + ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, str_empty) == 0, + "Failure to swprintf a zero length string to a zero length buffer\n"); + ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, str_empty) == 0, + "Failure to swprintf a zero length string to a zero length buffer\n"); + ok (vswprintf_wrapper (0, buffer, 0, str_empty) == -1, + "Failure to swprintf a zero length string to a zero length buffer\n"); } static int WINAPIV vfprintf_wrapper(FILE *file, -- 2.17.1

3 3

[PATCH v2 3/3] api-ms-win-downlevel-shlwapi-l2-1-0: Is win32 only.
by Serge Gautherie May 19, 2020

May 19, 2020

Signed-off-by: Serge Gautherie <winehq-git_serge_180711(a)gautherie.fr> --- See https://testbot.winehq.org/JobDetails.pl?Key=71965 --- .../api-ms-win-downlevel-shlwapi-l2-1-0.spec | 112 ++++++++++----------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec b/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec index 11c33f8..c943132 100644 --- a/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec +++ b/dlls/api-ms-win-downlevel-shlwapi-l2-1-0/api-ms-win-downlevel-shlwapi-l2-1-0.spec @@ -1,56 +1,56 @@ -@ stub IStream_Copy -@ stdcall IStream_Read(ptr ptr long) shlwapi.IStream_Read -@ stub IStream_ReadStr -@ stdcall IStream_Reset(ptr) shlwapi.IStream_Reset -@ stdcall IStream_Size(ptr ptr) shlwapi.IStream_Size -@ stdcall IStream_Write(ptr ptr long) shlwapi.IStream_Write -@ stub IStream_WriteStr -@ stdcall IUnknown_AtomicRelease(ptr) shlwapi.IUnknown_AtomicRelease -@ stdcall IUnknown_GetSite(ptr ptr ptr) shlwapi.IUnknown_GetSite -@ stdcall IUnknown_QueryService(ptr ptr ptr ptr) shlwapi.IUnknown_QueryService -@ stdcall IUnknown_Set(ptr ptr) shlwapi.IUnknown_Set -@ stdcall IUnknown_SetSite(ptr ptr) shlwapi.IUnknown_SetSite -@ stdcall SHAnsiToAnsi(str ptr long) shlwapi.SHAnsiToAnsi -@ stdcall SHAnsiToUnicode(str ptr long) shlwapi.SHAnsiToUnicode -@ stdcall SHCopyKeyA(long str long long) shlwapi.SHCopyKeyA -@ stdcall SHCopyKeyW(long wstr long long) shlwapi.SHCopyKeyW -@ stdcall SHCreateMemStream(ptr long) shlwapi.SHCreateMemStream -@ stdcall SHCreateStreamOnFileA(str long ptr) shlwapi.SHCreateStreamOnFileA -@ stdcall SHCreateStreamOnFileEx(wstr long long long ptr ptr) shlwapi.SHCreateStreamOnFileEx -@ stdcall SHCreateStreamOnFileW(wstr long ptr) shlwapi.SHCreateStreamOnFileW -@ stdcall SHCreateThreadRef(ptr ptr) shlwapi.SHCreateThreadRef -@ stdcall SHDeleteEmptyKeyA(long str) shlwapi.SHDeleteEmptyKeyA -@ stdcall SHDeleteEmptyKeyW(long wstr) shlwapi.SHDeleteEmptyKeyW -@ stdcall SHDeleteKeyA(long str) shlwapi.SHDeleteKeyA -@ stdcall SHDeleteKeyW(long wstr) shlwapi.SHDeleteKeyW -@ stdcall SHDeleteValueA(long str str) shlwapi.SHDeleteValueA -@ stdcall SHDeleteValueW(long wstr wstr) shlwapi.SHDeleteValueW -@ stdcall SHEnumKeyExA(long long str ptr) shlwapi.SHEnumKeyExA -@ stdcall SHEnumKeyExW(long long wstr ptr) shlwapi.SHEnumKeyExW -@ stdcall SHEnumValueA(long long str ptr ptr ptr ptr) shlwapi.SHEnumValueA -@ stdcall SHEnumValueW(long long wstr ptr ptr ptr ptr) shlwapi.SHEnumValueW -@ stdcall SHGetThreadRef(ptr) shlwapi.SHGetThreadRef -@ stdcall SHGetValueA(long str str ptr ptr ptr) shlwapi.SHGetValueA -@ stdcall SHGetValueW(long wstr wstr ptr ptr ptr) shlwapi.SHGetValueW -@ stdcall SHOpenRegStream2A(long str str long) shlwapi.SHOpenRegStream2A -@ stdcall SHOpenRegStream2W(long wstr wstr long) shlwapi.SHOpenRegStream2W -@ stdcall SHOpenRegStreamA(long str str long) shlwapi.SHOpenRegStreamA -@ stdcall SHOpenRegStreamW(long wstr wstr long) shlwapi.SHOpenRegStreamW -@ stdcall SHQueryInfoKeyA(long ptr ptr ptr ptr) shlwapi.SHQueryInfoKeyA -@ stdcall SHQueryInfoKeyW(long ptr ptr ptr ptr) shlwapi.SHQueryInfoKeyW -@ stdcall SHQueryValueExA(long str ptr ptr ptr ptr) shlwapi.SHQueryValueExA -@ stdcall SHQueryValueExW(long wstr ptr ptr ptr ptr) shlwapi.SHQueryValueExW -@ stdcall SHRegDuplicateHKey(long) shlwapi.SHRegDuplicateHKey -@ stdcall SHRegGetPathA(long str str ptr long) shlwapi.SHRegGetPathA -@ stdcall SHRegGetPathW(long wstr wstr ptr long) shlwapi.SHRegGetPathW -@ stdcall SHRegGetValueA( long str str long ptr ptr ptr ) shlwapi.SHRegGetValueA -@ stdcall SHRegGetValueW( long wstr wstr long ptr ptr ptr ) shlwapi.SHRegGetValueW -@ stdcall SHRegSetPathA(long str str str long) shlwapi.SHRegSetPathA -@ stdcall SHRegSetPathW(long wstr wstr wstr long) shlwapi.SHRegSetPathW -@ stdcall SHReleaseThreadRef() shlwapi.SHReleaseThreadRef -@ stdcall SHSetThreadRef(ptr) shlwapi.SHSetThreadRef -@ stdcall SHSetValueA(long str str long ptr long) shlwapi.SHSetValueA -@ stdcall SHSetValueW(long wstr wstr long ptr long) shlwapi.SHSetValueW -@ stdcall SHStrDupW(wstr ptr) shlwapi.SHStrDupW -@ stdcall SHUnicodeToAnsi(wstr ptr ptr) shlwapi.SHUnicodeToAnsi -@ stdcall SHUnicodeToUnicode(wstr ptr long) shlwapi.SHUnicodeToUnicode +@ stub -arch=win32 IStream_Copy +@ stdcall -arch=win32 IStream_Read(ptr ptr long) shlwapi.IStream_Read +@ stub -arch=win32 IStream_ReadStr +@ stdcall -arch=win32 IStream_Reset(ptr) shlwapi.IStream_Reset +@ stdcall -arch=win32 IStream_Size(ptr ptr) shlwapi.IStream_Size +@ stdcall -arch=win32 IStream_Write(ptr ptr long) shlwapi.IStream_Write +@ stub -arch=win32 IStream_WriteStr +@ stdcall -arch=win32 IUnknown_AtomicRelease(ptr) shlwapi.IUnknown_AtomicRelease +@ stdcall -arch=win32 IUnknown_GetSite(ptr ptr ptr) shlwapi.IUnknown_GetSite +@ stdcall -arch=win32 IUnknown_QueryService(ptr ptr ptr ptr) shlwapi.IUnknown_QueryService +@ stdcall -arch=win32 IUnknown_Set(ptr ptr) shlwapi.IUnknown_Set +@ stdcall -arch=win32 IUnknown_SetSite(ptr ptr) shlwapi.IUnknown_SetSite +@ stdcall -arch=win32 SHAnsiToAnsi(str ptr long) shlwapi.SHAnsiToAnsi +@ stdcall -arch=win32 SHAnsiToUnicode(str ptr long) shlwapi.SHAnsiToUnicode +@ stdcall -arch=win32 SHCopyKeyA(long str long long) shlwapi.SHCopyKeyA +@ stdcall -arch=win32 SHCopyKeyW(long wstr long long) shlwapi.SHCopyKeyW +@ stdcall -arch=win32 SHCreateMemStream(ptr long) shlwapi.SHCreateMemStream +@ stdcall -arch=win32 SHCreateStreamOnFileA(str long ptr) shlwapi.SHCreateStreamOnFileA +@ stdcall -arch=win32 SHCreateStreamOnFileEx(wstr long long long ptr ptr) shlwapi.SHCreateStreamOnFileEx +@ stdcall -arch=win32 SHCreateStreamOnFileW(wstr long ptr) shlwapi.SHCreateStreamOnFileW +@ stdcall -arch=win32 SHCreateThreadRef(ptr ptr) shlwapi.SHCreateThreadRef +@ stdcall -arch=win32 SHDeleteEmptyKeyA(long str) shlwapi.SHDeleteEmptyKeyA +@ stdcall -arch=win32 SHDeleteEmptyKeyW(long wstr) shlwapi.SHDeleteEmptyKeyW +@ stdcall -arch=win32 SHDeleteKeyA(long str) shlwapi.SHDeleteKeyA +@ stdcall -arch=win32 SHDeleteKeyW(long wstr) shlwapi.SHDeleteKeyW +@ stdcall -arch=win32 SHDeleteValueA(long str str) shlwapi.SHDeleteValueA +@ stdcall -arch=win32 SHDeleteValueW(long wstr wstr) shlwapi.SHDeleteValueW +@ stdcall -arch=win32 SHEnumKeyExA(long long str ptr) shlwapi.SHEnumKeyExA +@ stdcall -arch=win32 SHEnumKeyExW(long long wstr ptr) shlwapi.SHEnumKeyExW +@ stdcall -arch=win32 SHEnumValueA(long long str ptr ptr ptr ptr) shlwapi.SHEnumValueA +@ stdcall -arch=win32 SHEnumValueW(long long wstr ptr ptr ptr ptr) shlwapi.SHEnumValueW +@ stdcall -arch=win32 SHGetThreadRef(ptr) shlwapi.SHGetThreadRef +@ stdcall -arch=win32 SHGetValueA(long str str ptr ptr ptr) shlwapi.SHGetValueA +@ stdcall -arch=win32 SHGetValueW(long wstr wstr ptr ptr ptr) shlwapi.SHGetValueW +@ stdcall -arch=win32 SHOpenRegStream2A(long str str long) shlwapi.SHOpenRegStream2A +@ stdcall -arch=win32 SHOpenRegStream2W(long wstr wstr long) shlwapi.SHOpenRegStream2W +@ stdcall -arch=win32 SHOpenRegStreamA(long str str long) shlwapi.SHOpenRegStreamA +@ stdcall -arch=win32 SHOpenRegStreamW(long wstr wstr long) shlwapi.SHOpenRegStreamW +@ stdcall -arch=win32 SHQueryInfoKeyA(long ptr ptr ptr ptr) shlwapi.SHQueryInfoKeyA +@ stdcall -arch=win32 SHQueryInfoKeyW(long ptr ptr ptr ptr) shlwapi.SHQueryInfoKeyW +@ stdcall -arch=win32 SHQueryValueExA(long str ptr ptr ptr ptr) shlwapi.SHQueryValueExA +@ stdcall -arch=win32 SHQueryValueExW(long wstr ptr ptr ptr ptr) shlwapi.SHQueryValueExW +@ stdcall -arch=win32 SHRegDuplicateHKey(long) shlwapi.SHRegDuplicateHKey +@ stdcall -arch=win32 SHRegGetPathA(long str str ptr long) shlwapi.SHRegGetPathA +@ stdcall -arch=win32 SHRegGetPathW(long wstr wstr ptr long) shlwapi.SHRegGetPathW +@ stdcall -arch=win32 SHRegGetValueA( long str str long ptr ptr ptr ) shlwapi.SHRegGetValueA +@ stdcall -arch=win32 SHRegGetValueW( long wstr wstr long ptr ptr ptr ) shlwapi.SHRegGetValueW +@ stdcall -arch=win32 SHRegSetPathA(long str str str long) shlwapi.SHRegSetPathA +@ stdcall -arch=win32 SHRegSetPathW(long wstr wstr wstr long) shlwapi.SHRegSetPathW +@ stdcall -arch=win32 SHReleaseThreadRef() shlwapi.SHReleaseThreadRef +@ stdcall -arch=win32 SHSetThreadRef(ptr) shlwapi.SHSetThreadRef +@ stdcall -arch=win32 SHSetValueA(long str str long ptr long) shlwapi.SHSetValueA +@ stdcall -arch=win32 SHSetValueW(long wstr wstr long ptr long) shlwapi.SHSetValueW +@ stdcall -arch=win32 SHStrDupW(wstr ptr) shlwapi.SHStrDupW +@ stdcall -arch=win32 SHUnicodeToAnsi(wstr ptr ptr) shlwapi.SHUnicodeToAnsi +@ stdcall -arch=win32 SHUnicodeToUnicode(wstr ptr long) shlwapi.SHUnicodeToUnicode -- 2.10.0.windows.1

1 0