[PATCH vkd3d v2 1/2] build: Make the default symbol visibility "hidden".

Zebediah Figura zfigura at codeweavers.com
Mon Aug 9 01:11:49 CDT 2021


We tag far fewer symbols this way.

Signed-off-by: Zebediah Figura <zfigura at codeweavers.com>
---
v2: Move definitions to the header files.

 configure.ac                             |   1 +
 include/private/vkd3d_blob.h             |   2 +-
 include/private/vkd3d_common.h           |   2 +-
 include/private/vkd3d_debug.h            |  19 +-
 include/private/vkd3d_memory.h           |   3 +-
 include/private/vkd3d_utf8.h             |   2 +-
 include/vkd3d.h                          |  48 ++---
 include/vkd3d_shader.h                   |  41 +++--
 include/vkd3d_utils.h                    |  35 ++--
 include/vkd3d_windows.h                  |  17 +-
 libs/vkd3d-common/debug.c                |   2 +-
 libs/vkd3d-shader/hlsl.h                 | 111 ++++++------
 libs/vkd3d-shader/preproc.h              |  12 +-
 libs/vkd3d-shader/vkd3d_shader_private.h |  80 ++++-----
 libs/vkd3d/vkd3d_private.h               | 216 +++++++++++------------
 15 files changed, 286 insertions(+), 305 deletions(-)

diff --git a/configure.ac b/configure.ac
index 8a448e60..0ff159e3 100644
--- a/configure.ac
+++ b/configure.ac
@@ -54,6 +54,7 @@ AC_SUBST([VKD3D_CFLAGS])
 AS_IF([test "x${GCC}" = "xyes"],
       [VKD3D_CFLAGS="-Wall -pipe"
       VKD3D_CHECK_CFLAGS([-std=c99])
+      VKD3D_CHECK_CFLAGS([-fvisibility=hidden])
       VKD3D_CHECK_CFLAGS([-Wdeclaration-after-statement])
       VKD3D_CHECK_CFLAGS([-Wimplicit-fallthrough])
       VKD3D_CHECK_CFLAGS([-Winit-self])
diff --git a/include/private/vkd3d_blob.h b/include/private/vkd3d_blob.h
index e78d3916..0f48e876 100644
--- a/include/private/vkd3d_blob.h
+++ b/include/private/vkd3d_blob.h
@@ -22,6 +22,6 @@
 #include "vkd3d_windows.h"
 #include "vkd3d_d3dcommon.h"
 
-HRESULT vkd3d_blob_create(void *buffer, SIZE_T size, ID3D10Blob **blob) DECLSPEC_HIDDEN;
+HRESULT vkd3d_blob_create(void *buffer, SIZE_T size, ID3D10Blob **blob);
 
 #endif  /* __VKD3D_BLOB_H */
diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h
index 5aeca58e..57b0ad20 100644
--- a/include/private/vkd3d_common.h
+++ b/include/private/vkd3d_common.h
@@ -214,6 +214,6 @@ static inline void vkd3d_parse_version(const char *version, int *major, int *min
     *minor = atoi(version);
 }
 
-HRESULT hresult_from_vkd3d_result(int vkd3d_result) DECLSPEC_HIDDEN;
+HRESULT hresult_from_vkd3d_result(int vkd3d_result);
 
 #endif  /* __VKD3D_COMMON_H */
diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h
index c37c841a..a206a92b 100644
--- a/include/private/vkd3d_debug.h
+++ b/include/private/vkd3d_debug.h
@@ -44,15 +44,14 @@ enum vkd3d_dbg_level
     VKD3D_DBG_LEVEL_TRACE,
 };
 
-enum vkd3d_dbg_level vkd3d_dbg_get_level(void) DECLSPEC_HIDDEN;
+enum vkd3d_dbg_level vkd3d_dbg_get_level(void);
 
-void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function,
-        const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN;
+void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4);
 
-const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2) DECLSPEC_HIDDEN;
-const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args) DECLSPEC_HIDDEN;
-const char *debugstr_a(const char *str) DECLSPEC_HIDDEN;
-const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN;
+const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2);
+const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args);
+const char *debugstr_a(const char *str);
+const char *debugstr_w(const WCHAR *wstr, size_t wchar_size);
 
 #define VKD3D_DBG_LOG(level) \
         do { \
@@ -103,7 +102,7 @@ static inline const char *debugstr_guid(const GUID *guid)
             guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 }
 
-unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value) DECLSPEC_HIDDEN;
+unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value);
 
 struct vkd3d_debug_option
 {
@@ -111,8 +110,8 @@ struct vkd3d_debug_option
     uint64_t flag;
 };
 
-bool vkd3d_debug_list_has_member(const char *string, const char *member) DECLSPEC_HIDDEN;
+bool vkd3d_debug_list_has_member(const char *string, const char *member);
 uint64_t vkd3d_parse_debug_options(const char *string,
-        const struct vkd3d_debug_option *options, unsigned int option_count) DECLSPEC_HIDDEN;
+        const struct vkd3d_debug_option *options, unsigned int option_count);
 
 #endif  /* __VKD3D_DEBUG_H */
diff --git a/include/private/vkd3d_memory.h b/include/private/vkd3d_memory.h
index bd56d30a..f6846d66 100644
--- a/include/private/vkd3d_memory.h
+++ b/include/private/vkd3d_memory.h
@@ -65,7 +65,6 @@ static inline char *vkd3d_strdup(const char *string)
     return ptr;
 }
 
-bool vkd3d_array_reserve(void **elements, size_t *capacity,
-        size_t element_count, size_t element_size) DECLSPEC_HIDDEN;
+bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size);
 
 #endif  /* __VKD3D_MEMORY_H */
diff --git a/include/private/vkd3d_utf8.h b/include/private/vkd3d_utf8.h
index ab32884b..ccb9e17e 100644
--- a/include/private/vkd3d_utf8.h
+++ b/include/private/vkd3d_utf8.h
@@ -21,6 +21,6 @@
 
 #include "vkd3d_common.h"
 
-char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN;
+char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size);
 
 #endif /* __VKD3D_UTF8_H */
diff --git a/include/vkd3d.h b/include/vkd3d.h
index 0ef81053..1bb87b4a 100644
--- a/include/vkd3d.h
+++ b/include/vkd3d.h
@@ -153,44 +153,50 @@ struct vkd3d_image_resource_create_info
     D3D12_RESOURCE_STATES present_state;
 };
 
+#if defined(__GNUC__) && !defined(__MINGW32__)
+# define VKD3D_API __attribute__((visibility("default")))
+#else
+# define VKD3D_API
+#endif
+
 #ifndef VKD3D_NO_PROTOTYPES
 
-HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info,
+VKD3D_API HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info,
         struct vkd3d_instance **instance);
-ULONG vkd3d_instance_decref(struct vkd3d_instance *instance);
-VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance);
-ULONG vkd3d_instance_incref(struct vkd3d_instance *instance);
+VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance);
+VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance);
+VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance);
 
-HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info,
+VKD3D_API HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info,
         REFIID iid, void **device);
-IUnknown *vkd3d_get_device_parent(ID3D12Device *device);
-VkDevice vkd3d_get_vk_device(ID3D12Device *device);
-VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device);
-struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device);
+VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device);
+VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device);
+VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device);
+VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device);
 
-uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue);
-VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue);
-void vkd3d_release_vk_queue(ID3D12CommandQueue *queue);
+VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue);
+VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue);
+VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue);
 
-HRESULT vkd3d_create_image_resource(ID3D12Device *device,
+VKD3D_API HRESULT vkd3d_create_image_resource(ID3D12Device *device,
         const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource);
-ULONG vkd3d_resource_decref(ID3D12Resource *resource);
-ULONG vkd3d_resource_incref(ID3D12Resource *resource);
+VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource);
+VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource);
 
-HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
-HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
+VKD3D_API HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
-VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
+VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
 
 /* 1.1 */
-DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
+VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
 
 /* 1.2 */
-HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
         ID3DBlob **blob, ID3DBlob **error_blob);
-HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size,
+VKD3D_API HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
 #endif  /* VKD3D_NO_PROTOTYPES */
diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h
index b0412d30..24f99fb9 100644
--- a/include/vkd3d_shader.h
+++ b/include/vkd3d_shader.h
@@ -1340,6 +1340,12 @@ static inline uint32_t vkd3d_shader_create_swizzle(enum vkd3d_shader_swizzle_com
             | ((w & VKD3D_SHADER_SWIZZLE_MASK) << VKD3D_SHADER_SWIZZLE_SHIFT(3));
 }
 
+#if defined(__GNUC__) && !defined(__MINGW32__)
+# define VKD3D_SHADER_API __attribute__((visibility("default")))
+#else
+# define VKD3D_SHADER_API
+#endif
+
 #ifndef VKD3D_SHADER_NO_PROTOTYPES
 
 /**
@@ -1353,7 +1359,7 @@ static inline uint32_t vkd3d_shader_create_swizzle(enum vkd3d_shader_swizzle_com
  * string is null-terminated and UTF-8 encoded. This may be a pointer to static
  * data in libvkd3d-shader; it should not be freed.
  */
-const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor);
+VKD3D_SHADER_API const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor);
 /**
  * Returns the source types supported, with any target type, by
  * vkd3d_shader_compile().
@@ -1368,7 +1374,7 @@ const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor);
  * vkd3d-shader. This array may be a pointer to static data in libvkd3d-shader;
  * it should not be freed.
  */
-const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count);
+VKD3D_SHADER_API const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count);
 /**
  * Returns the target types supported, with the given source type, by
  * vkd3d_shader_compile().
@@ -1382,7 +1388,7 @@ const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(uns
  * vkd3d-shader. This array may be a pointer to static data in libvkd3d-shader;
  * it should not be freed.
  */
-const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
+VKD3D_SHADER_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
         enum vkd3d_shader_source_type source_type, unsigned int *count);
 
 /**
@@ -1428,7 +1434,7 @@ const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
+VKD3D_SHADER_API int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages);
 /**
  * Free shader messages allocated by another vkd3d-shader function, such as
@@ -1437,7 +1443,7 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
  * \param messages Messages to free. This pointer is optional and may be NULL,
  * in which case no action will be taken.
  */
-void vkd3d_shader_free_messages(char *messages);
+VKD3D_SHADER_API void vkd3d_shader_free_messages(char *messages);
 /**
  * Free shader code allocated by another vkd3d-shader function, such as
  * vkd3d_shader_compile().
@@ -1447,7 +1453,7 @@ void vkd3d_shader_free_messages(char *messages);
  *
  * \param code Code to free.
  */
-void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
+VKD3D_SHADER_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
 
 /**
  * Convert a byte code description of a shader root signature to a structural
@@ -1479,7 +1485,7 @@ void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
+VKD3D_SHADER_API int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
         struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages);
 /**
  * Free a structural representation of a shader root signature allocated by
@@ -1491,7 +1497,8 @@ int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
  *
  * \param root_signature Signature description to free.
  */
-void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *root_signature);
+VKD3D_SHADER_API void vkd3d_shader_free_root_signature(
+        struct vkd3d_shader_versioned_root_signature_desc *root_signature);
 
 /**
  * Convert a structural description of a shader root signature to a byte code
@@ -1516,7 +1523,8 @@ void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signatu
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
+VKD3D_SHADER_API int vkd3d_shader_serialize_root_signature(
+        const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
         struct vkd3d_shader_code *dxbc, char **messages);
 /**
  * Convert a structural representation of a root signature to a different
@@ -1538,7 +1546,7 @@ int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_ro
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst,
+VKD3D_SHADER_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst,
         enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src);
 
 /**
@@ -1565,7 +1573,7 @@ int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signa
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages);
+VKD3D_SHADER_API int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages);
 /**
  * Free members of struct vkd3d_shader_scan_descriptor_info() allocated by
  * vkd3d_shader_scan().
@@ -1575,7 +1583,8 @@ int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char
  *
  * \param scan_descriptor_info Descriptor information to free.
  */
-void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info);
+VKD3D_SHADER_API void vkd3d_shader_free_scan_descriptor_info(
+        struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info);
 
 /**
  * Read the input signature of a compiled shader, returning a structural
@@ -1601,7 +1610,7 @@ void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_
  *
  * \return A member of \ref vkd3d_result.
  */
-int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
+VKD3D_SHADER_API int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
         struct vkd3d_shader_signature *signature, char **messages);
 /**
  * Find a single element of a parsed input signature.
@@ -1622,7 +1631,7 @@ int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
  * NULL if no such element was found. If not NULL, the return value points into
  * the \a signature parameter and should not be explicitly freed.
  */
-struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
+VKD3D_SHADER_API struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
         const struct vkd3d_shader_signature *signature, const char *semantic_name,
         unsigned int semantic_index, unsigned int stream_index);
 /**
@@ -1634,7 +1643,7 @@ struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
  *
  * \param signature Signature description to free.
  */
-void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature);
+VKD3D_SHADER_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature);
 
 /* 1.3 */
 
@@ -1662,7 +1671,7 @@ void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature
  *
  * \since 1.3
  */
-int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
+VKD3D_SHADER_API int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages);
 
 #endif  /* VKD3D_SHADER_NO_PROTOTYPES */
diff --git a/include/vkd3d_utils.h b/include/vkd3d_utils.h
index a694de6c..ea310a0e 100644
--- a/include/vkd3d_utils.h
+++ b/include/vkd3d_utils.h
@@ -34,37 +34,44 @@ extern "C" {
 #define VKD3D_WAIT_FAILED (~0u)
 #define VKD3D_INFINITE (~0u)
 
+#if defined(__GNUC__) && !defined(__MINGW32__)
+# define VKD3D_UTILS_API __attribute__((visibility("default")))
+#else
+# define VKD3D_UTILS_API
+#endif
+
 /* 1.0 */
-HANDLE vkd3d_create_event(void);
-HRESULT vkd3d_signal_event(HANDLE event);
-unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds);
-void vkd3d_destroy_event(HANDLE event);
+VKD3D_UTILS_API HANDLE vkd3d_create_event(void);
+VKD3D_UTILS_API HRESULT vkd3d_signal_event(HANDLE event);
+VKD3D_UTILS_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds);
+VKD3D_UTILS_API void vkd3d_destroy_event(HANDLE event);
 
 #define D3D12CreateDevice(a, b, c, d) D3D12CreateDeviceVKD3D(a, b, c, d, VKD3D_UTILS_API_VERSION)
-HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
-HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug);
-HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc,
+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer(
+        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
+VKD3D_UTILS_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug);
+VKD3D_UTILS_API HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc,
         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
 
 /* 1.2 */
-HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level,
+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level,
         REFIID iid, void **device, enum vkd3d_api_version api_version);
-HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data,
+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data,
         SIZE_T data_size, REFIID iid, void **deserializer);
-HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+VKD3D_UTILS_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
         ID3DBlob **blob, ID3DBlob **error_blob);
 
 /* 1.3 */
-HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
+VKD3D_UTILS_API HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
         const char *target, UINT flags, UINT effect_flags, ID3DBlob **shader, ID3DBlob **error_messages);
-HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
+VKD3D_UTILS_API HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
         const char *target, UINT flags, UINT effect_flags, UINT secondary_flags,
         const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader,
         ID3DBlob **error_messages);
-HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3D10Blob **blob);
-HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
+VKD3D_UTILS_API HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3D10Blob **blob);
+VKD3D_UTILS_API HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
         const D3D_SHADER_MACRO *defines, ID3DInclude *include,
         ID3DBlob **shader, ID3DBlob **error_messages);
 
diff --git a/include/vkd3d_windows.h b/include/vkd3d_windows.h
index 7d8a8b19..24dad10d 100644
--- a/include/vkd3d_windows.h
+++ b/include/vkd3d_windows.h
@@ -132,18 +132,18 @@ typedef GUID IID;
 # ifdef INITGUID
 #  ifndef __cplusplus
 #   define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
-        const GUID name DECLSPEC_HIDDEN; \
+        const GUID name; \
         const GUID name = \
     { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 }}
 #  else
 #   define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
-        EXTERN_C const GUID name DECLSPEC_HIDDEN; \
+        EXTERN_C const GUID name; \
         EXTERN_C const GUID name = \
     { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 }}
 #  endif
 # else
 #  define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
-        EXTERN_C const GUID name DECLSPEC_HIDDEN;
+        EXTERN_C const GUID name;
 # endif /* INITGUID */
 
 /* __uuidof emulation */
@@ -251,17 +251,6 @@ typedef struct SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES;
 #endif  /* _WIN32 */
 
 
-/* Define DECLSPEC_HIDDEN */
-#ifndef DECLSPEC_HIDDEN
-# if defined(__MINGW32__)
-#  define DECLSPEC_HIDDEN
-# elif defined(__GNUC__)
-#  define DECLSPEC_HIDDEN __attribute__((visibility("hidden")))
-# else
-#  define DECLSPEC_HIDDEN
-# endif
-#endif  /* DECLSPEC_HIDDEN */
-
 /* Define min() & max() macros */
 #ifndef NOMINMAX
 # ifndef min
diff --git a/libs/vkd3d-common/debug.c b/libs/vkd3d-common/debug.c
index 5e49cf10..dcf53fa9 100644
--- a/libs/vkd3d-common/debug.c
+++ b/libs/vkd3d-common/debug.c
@@ -31,7 +31,7 @@
 #define VKD3D_DEBUG_BUFFER_COUNT 64
 #define VKD3D_DEBUG_BUFFER_SIZE 512
 
-extern const char *vkd3d_dbg_env_name DECLSPEC_HIDDEN;
+extern const char *vkd3d_dbg_env_name;
 
 static const char *debug_level_names[] =
 {
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 54273ac6..aede3a55 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -601,91 +601,84 @@ static inline void hlsl_release_string_buffer(struct hlsl_ctx *ctx, struct vkd3d
     vkd3d_string_buffer_release(&ctx->string_buffers, buffer);
 }
 
-const char *debug_hlsl_type(struct hlsl_ctx *ctx, const struct hlsl_type *type) DECLSPEC_HIDDEN;
-const char *debug_hlsl_writemask(unsigned int writemask) DECLSPEC_HIDDEN;
+const char *debug_hlsl_type(struct hlsl_ctx *ctx, const struct hlsl_type *type);
+const char *debug_hlsl_writemask(unsigned int writemask);
 
-struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const struct hlsl_type *type) DECLSPEC_HIDDEN;
-struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsigned int modifiers) DECLSPEC_HIDDEN;
-const char *hlsl_node_type_to_string(enum hlsl_ir_node_type type) DECLSPEC_HIDDEN;
+struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const struct hlsl_type *type);
+struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsigned int modifiers);
+const char *hlsl_node_type_to_string(enum hlsl_ir_node_type type);
 
-void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function_decl *decl,
-        bool intrinsic) DECLSPEC_HIDDEN;
-bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var) DECLSPEC_HIDDEN;
+void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function_decl *decl, bool intrinsic);
+bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var);
 
-void hlsl_dump_function(struct hlsl_ctx *ctx, const struct hlsl_ir_function_decl *func) DECLSPEC_HIDDEN;
+void hlsl_dump_function(struct hlsl_ctx *ctx, const struct hlsl_ir_function_decl *func);
 
-int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func,
-        struct vkd3d_shader_code *out) DECLSPEC_HIDDEN;
+int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, struct vkd3d_shader_code *out);
 
-void hlsl_free_instr(struct hlsl_ir_node *node) DECLSPEC_HIDDEN;
-void hlsl_free_instr_list(struct list *list) DECLSPEC_HIDDEN;
-void hlsl_free_type(struct hlsl_type *type) DECLSPEC_HIDDEN;
-void hlsl_free_var(struct hlsl_ir_var *decl) DECLSPEC_HIDDEN;
+void hlsl_free_instr(struct hlsl_ir_node *node);
+void hlsl_free_instr_list(struct list *list);
+void hlsl_free_type(struct hlsl_type *type);
+void hlsl_free_var(struct hlsl_ir_var *decl);
 
-bool hlsl_get_function(struct hlsl_ctx *ctx, const char *name) DECLSPEC_HIDDEN;
-struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const char *name) DECLSPEC_HIDDEN;
-struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool recursive) DECLSPEC_HIDDEN;
-struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name) DECLSPEC_HIDDEN;
+bool hlsl_get_function(struct hlsl_ctx *ctx, const char *name);
+struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const char *name);
+struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool recursive);
+struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name);
 
-struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type,
-        unsigned int array_size) DECLSPEC_HIDDEN;
+struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, unsigned int array_size);
 struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1,
-        struct hlsl_ir_node *arg2) DECLSPEC_HIDDEN;
+        struct hlsl_ir_node *arg2);
 struct hlsl_buffer *hlsl_new_buffer(struct hlsl_ctx *ctx, enum hlsl_buffer_type type, const char *name,
-        const struct hlsl_reg_reservation *reservation, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        const struct hlsl_reg_reservation *reservation, struct vkd3d_shader_location loc);
 struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
-        struct vkd3d_shader_location *loc) DECLSPEC_HIDDEN;
-struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_location *loc);
+struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node);
 struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hlsl_type *return_type,
-        struct list *parameters, const struct hlsl_semantic *semantic,
-        struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
-struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition,
-        struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
-struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type,
-        struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        struct list *parameters, const struct hlsl_semantic *semantic, struct vkd3d_shader_location loc);
+struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, struct vkd3d_shader_location loc);
+struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc);
 struct hlsl_ir_load *hlsl_new_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset,
-        struct hlsl_type *type, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
-struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
-struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *lhs,
-        struct hlsl_ir_node *rhs) DECLSPEC_HIDDEN;
+        struct hlsl_type *type, struct vkd3d_shader_location loc);
+struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc);
+struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs);
 struct hlsl_ir_store *hlsl_new_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset,
-        struct hlsl_ir_node *rhs, unsigned int writemask, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
-struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields) DECLSPEC_HIDDEN;
+        struct hlsl_ir_node *rhs, unsigned int writemask, struct vkd3d_shader_location loc);
+struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields);
 struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components,
-        struct hlsl_ir_node *val, struct vkd3d_shader_location *loc) DECLSPEC_HIDDEN;
+        struct hlsl_ir_node *val, struct vkd3d_shader_location *loc);
 struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type,
-        const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_location loc);
 struct hlsl_type *hlsl_new_type(struct hlsl_ctx *ctx, const char *name, enum hlsl_type_class type_class,
-        enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN;
+        enum hlsl_base_type base_type, unsigned dimx, unsigned dimy);
 struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n,
-        const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_location loc);
 struct hlsl_ir_node *hlsl_new_unary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg,
-        struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_location loc);
 struct hlsl_ir_var *hlsl_new_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type,
         const struct vkd3d_shader_location loc, const struct hlsl_semantic *semantic, unsigned int modifiers,
-        const struct hlsl_reg_reservation *reg_reservation) DECLSPEC_HIDDEN;
+        const struct hlsl_reg_reservation *reg_reservation);
 struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var,
-        const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_location loc);
 
-void hlsl_error(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_error error,
-        const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN;
-void hlsl_warning(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_error error,
-        const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN;
-void hlsl_note(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_log_level level,
-        const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN;
+void hlsl_error(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc,
+        enum vkd3d_shader_error error, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5);
+void hlsl_warning(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc,
+        enum vkd3d_shader_error error, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5);
+void hlsl_note(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc,
+        enum vkd3d_shader_log_level level, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5);
 
-void hlsl_push_scope(struct hlsl_ctx *ctx) DECLSPEC_HIDDEN;
-void hlsl_pop_scope(struct hlsl_ctx *ctx) DECLSPEC_HIDDEN;
+void hlsl_push_scope(struct hlsl_ctx *ctx);
+void hlsl_pop_scope(struct hlsl_ctx *ctx);
 
-bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type) DECLSPEC_HIDDEN;
+bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type);
 
 struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old,
-        unsigned int default_majority, unsigned int modifiers) DECLSPEC_HIDDEN;
-unsigned int hlsl_type_component_count(struct hlsl_type *type) DECLSPEC_HIDDEN;
-unsigned int hlsl_type_get_sm4_offset(const struct hlsl_type *type, unsigned int offset) DECLSPEC_HIDDEN;
-bool hlsl_type_is_void(const struct hlsl_type *type) DECLSPEC_HIDDEN;
-bool hlsl_types_are_equal(const struct hlsl_type *t1, const struct hlsl_type *t2) DECLSPEC_HIDDEN;
+        unsigned int default_majority, unsigned int modifiers);
+unsigned int hlsl_type_component_count(struct hlsl_type *type);
+unsigned int hlsl_type_get_sm4_offset(const struct hlsl_type *type, unsigned int offset);
+bool hlsl_type_is_void(const struct hlsl_type *type);
+bool hlsl_types_are_equal(const struct hlsl_type *t1, const struct hlsl_type *t2);
 
-int hlsl_lexer_compile(struct hlsl_ctx *ctx, const struct vkd3d_shader_code *hlsl) DECLSPEC_HIDDEN;
+int hlsl_lexer_compile(struct hlsl_ctx *ctx, const struct vkd3d_shader_code *hlsl);
 
 #endif
diff --git a/libs/vkd3d-shader/preproc.h b/libs/vkd3d-shader/preproc.h
index 15d173a4..e1cb75e1 100644
--- a/libs/vkd3d-shader/preproc.h
+++ b/libs/vkd3d-shader/preproc.h
@@ -131,13 +131,13 @@ struct preproc_ctx
 };
 
 bool preproc_add_macro(struct preproc_ctx *ctx, const struct vkd3d_shader_location *loc, char *name, char **arg_names,
-        size_t arg_count, const struct vkd3d_shader_location *body_loc, struct vkd3d_string_buffer *body) DECLSPEC_HIDDEN;
-void preproc_close_include(struct preproc_ctx *ctx, const struct vkd3d_shader_code *code) DECLSPEC_HIDDEN;
-struct preproc_macro *preproc_find_macro(struct preproc_ctx *ctx, const char *name) DECLSPEC_HIDDEN;
-void preproc_free_macro(struct preproc_macro *macro) DECLSPEC_HIDDEN;
-bool preproc_push_include(struct preproc_ctx *ctx, char *filename, const struct vkd3d_shader_code *code) DECLSPEC_HIDDEN;
+        size_t arg_count, const struct vkd3d_shader_location *body_loc, struct vkd3d_string_buffer *body);
+void preproc_close_include(struct preproc_ctx *ctx, const struct vkd3d_shader_code *code);
+struct preproc_macro *preproc_find_macro(struct preproc_ctx *ctx, const char *name);
+void preproc_free_macro(struct preproc_macro *macro);
+bool preproc_push_include(struct preproc_ctx *ctx, char *filename, const struct vkd3d_shader_code *code);
 void preproc_warning(struct preproc_ctx *ctx, const struct vkd3d_shader_location *loc,
-        enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(4, 5);
 
 static inline struct preproc_file *preproc_get_top_file(struct preproc_ctx *ctx)
 {
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index 85859e84..cd3cd49d 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -858,20 +858,20 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg
     return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT;
 }
 
-void vkd3d_shader_trace(void *data) DECLSPEC_HIDDEN;
+void vkd3d_shader_trace(void *data);
 
-const char *shader_get_type_prefix(enum vkd3d_shader_type type) DECLSPEC_HIDDEN;
+const char *shader_get_type_prefix(enum vkd3d_shader_type type);
 
 struct vkd3d_shader_message_context;
 
 void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
-        const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN;
-void shader_sm4_free(void *data) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_signature *output_signature, struct vkd3d_shader_message_context *message_context);
+void shader_sm4_free(void *data);
 void shader_sm4_read_header(void *data, const DWORD **ptr,
-        struct vkd3d_shader_version *shader_version) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_version *shader_version);
 void shader_sm4_read_instruction(void *data, const DWORD **ptr,
-        struct vkd3d_shader_instruction *ins) DECLSPEC_HIDDEN;
-bool shader_sm4_is_end(void *data, const DWORD **ptr) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_instruction *ins);
+bool shader_sm4_is_end(void *data, const DWORD **ptr);
 
 struct vkd3d_string_buffer
 {
@@ -887,20 +887,18 @@ struct vkd3d_string_buffer_cache
 };
 
 enum vkd3d_result vkd3d_dxbc_binary_to_text(void *data,
-        const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out) DECLSPEC_HIDDEN;
-void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN;
-struct vkd3d_string_buffer *vkd3d_string_buffer_get(struct vkd3d_string_buffer_cache *list) DECLSPEC_HIDDEN;
-void vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN;
-void vkd3d_string_buffer_cache_cleanup(struct vkd3d_string_buffer_cache *list) DECLSPEC_HIDDEN;
-void vkd3d_string_buffer_cache_init(struct vkd3d_string_buffer_cache *list) DECLSPEC_HIDDEN;
-int vkd3d_string_buffer_printf(struct vkd3d_string_buffer *buffer,
-        const char *format, ...) VKD3D_PRINTF_FUNC(2, 3) DECLSPEC_HIDDEN;
-void vkd3d_string_buffer_release(struct vkd3d_string_buffer_cache *list,
-        struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out);
+void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer);
+struct vkd3d_string_buffer *vkd3d_string_buffer_get(struct vkd3d_string_buffer_cache *list);
+void vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer);
+void vkd3d_string_buffer_cache_cleanup(struct vkd3d_string_buffer_cache *list);
+void vkd3d_string_buffer_cache_init(struct vkd3d_string_buffer_cache *list);
+int vkd3d_string_buffer_printf(struct vkd3d_string_buffer *buffer, const char *format, ...) VKD3D_PRINTF_FUNC(2, 3);
+void vkd3d_string_buffer_release(struct vkd3d_string_buffer_cache *list, struct vkd3d_string_buffer *buffer);
 #define vkd3d_string_buffer_trace(buffer) \
         vkd3d_string_buffer_trace_(buffer, __FUNCTION__)
-void vkd3d_string_buffer_trace_(const struct vkd3d_string_buffer *buffer, const char *function) DECLSPEC_HIDDEN;
-int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args) DECLSPEC_HIDDEN;
+void vkd3d_string_buffer_trace_(const struct vkd3d_string_buffer *buffer, const char *function);
+int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args);
 
 struct vkd3d_bytecode_buffer
 {
@@ -909,8 +907,8 @@ struct vkd3d_bytecode_buffer
     int status;
 };
 
-size_t bytecode_put_bytes(struct vkd3d_bytecode_buffer *buffer, const void *bytes, size_t size) DECLSPEC_HIDDEN;
-void set_u32(struct vkd3d_bytecode_buffer *buffer, size_t offset, uint32_t value) DECLSPEC_HIDDEN;
+size_t bytecode_put_bytes(struct vkd3d_bytecode_buffer *buffer, const void *bytes, size_t size);
+void set_u32(struct vkd3d_bytecode_buffer *buffer, size_t offset, uint32_t value);
 
 static inline size_t put_u32(struct vkd3d_bytecode_buffer *buffer, uint32_t value)
 {
@@ -944,53 +942,51 @@ struct vkd3d_shader_message_context
     struct vkd3d_string_buffer messages;
 };
 
-void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context) DECLSPEC_HIDDEN;
-bool vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context,
-        char **out) DECLSPEC_HIDDEN;
+void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context);
+bool vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context, char **out);
 void vkd3d_shader_message_context_init(struct vkd3d_shader_message_context *context,
-        enum vkd3d_shader_log_level log_level) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_log_level log_level);
 void vkd3d_shader_message_context_trace_messages_(const struct vkd3d_shader_message_context *context,
-        const char *function) DECLSPEC_HIDDEN;
+        const char *function);
 #define vkd3d_shader_message_context_trace_messages(context) \
         vkd3d_shader_message_context_trace_messages_(context, __FUNCTION__)
 void vkd3d_shader_error(struct vkd3d_shader_message_context *context, const struct vkd3d_shader_location *location,
-        enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(4, 5);
 void vkd3d_shader_verror(struct vkd3d_shader_message_context *context, const struct vkd3d_shader_location *location,
-        enum vkd3d_shader_error error, const char *format, va_list args) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_error error, const char *format, va_list args);
 void vkd3d_shader_vnote(struct vkd3d_shader_message_context *context, const struct vkd3d_shader_location *location,
-        enum vkd3d_shader_log_level level, const char *format, va_list args) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_log_level level, const char *format, va_list args);
 void vkd3d_shader_vwarning(struct vkd3d_shader_message_context *context, const struct vkd3d_shader_location *location,
-        enum vkd3d_shader_error error, const char *format, va_list args) DECLSPEC_HIDDEN;
+        enum vkd3d_shader_error error, const char *format, va_list args);
 
-void vkd3d_shader_dump_shader(enum vkd3d_shader_type type, const struct vkd3d_shader_code *shader) DECLSPEC_HIDDEN;
+void vkd3d_shader_dump_shader(enum vkd3d_shader_type type, const struct vkd3d_shader_code *shader);
 
 int shader_extract_from_dxbc(const void *dxbc, size_t dxbc_length,
-        struct vkd3d_shader_message_context *message_context, const char *source_name,
-        struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN;
-void free_shader_desc(struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_message_context *message_context, const char *source_name, struct vkd3d_shader_desc *desc);
+void free_shader_desc(struct vkd3d_shader_desc *desc);
 
 int shader_parse_input_signature(const void *dxbc, size_t dxbc_length,
-        struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature);
 
 struct vkd3d_dxbc_compiler;
 
 struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version,
         const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info,
         const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info,
-        struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_message_context *message_context);
 int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler,
-        const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_instruction *instruction);
 int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
-        const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv) DECLSPEC_HIDDEN;
-void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler) DECLSPEC_HIDDEN;
+        const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv);
+void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler);
 
-void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]) DECLSPEC_HIDDEN;
+void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]);
 
 int preproc_lexer_parse(const struct vkd3d_shader_compile_info *compile_info,
-        struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context);
 
 int hlsl_compile_shader(const struct vkd3d_shader_code *hlsl, const struct vkd3d_shader_compile_info *compile_info,
-        struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context);
 
 static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_type(
         enum vkd3d_data_type data_type)
diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h
index deb8ee99..0fa51a2f 100644
--- a/libs/vkd3d/vkd3d_private.h
+++ b/libs/vkd3d/vkd3d_private.h
@@ -84,9 +84,9 @@ struct vkd3d_vk_device_procs
 };
 #undef DECLARE_VK_PFN
 
-HRESULT hresult_from_errno(int rc) DECLSPEC_HIDDEN;
-HRESULT hresult_from_vk_result(VkResult vr) DECLSPEC_HIDDEN;
-HRESULT hresult_from_vkd3d_result(int vkd3d_result) DECLSPEC_HIDDEN;
+HRESULT hresult_from_errno(int rc);
+HRESULT hresult_from_vk_result(VkResult vr);
+HRESULT hresult_from_vkd3d_result(int vkd3d_result);
 
 struct vkd3d_vulkan_info
 {
@@ -163,8 +163,8 @@ union vkd3d_thread_handle
 };
 
 HRESULT vkd3d_create_thread(struct vkd3d_instance *instance,
-        PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN;
-HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN;
+        PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread);
+HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread);
 
 struct vkd3d_waiting_fence
 {
@@ -200,10 +200,8 @@ struct vkd3d_fence_worker
     struct d3d12_device *device;
 };
 
-HRESULT vkd3d_fence_worker_start(struct vkd3d_fence_worker *worker,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
-HRESULT vkd3d_fence_worker_stop(struct vkd3d_fence_worker *worker,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
+HRESULT vkd3d_fence_worker_start(struct vkd3d_fence_worker *worker, struct d3d12_device *device);
+HRESULT vkd3d_fence_worker_stop(struct vkd3d_fence_worker *worker, struct d3d12_device *device);
 
 struct vkd3d_gpu_va_allocation
 {
@@ -232,11 +230,9 @@ struct vkd3d_gpu_va_allocator
 };
 
 D3D12_GPU_VIRTUAL_ADDRESS vkd3d_gpu_va_allocator_allocate(struct vkd3d_gpu_va_allocator *allocator,
-        size_t alignment, size_t size, void *ptr) DECLSPEC_HIDDEN;
-void *vkd3d_gpu_va_allocator_dereference(struct vkd3d_gpu_va_allocator *allocator,
-        D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN;
-void vkd3d_gpu_va_allocator_free(struct vkd3d_gpu_va_allocator *allocator,
-        D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN;
+        size_t alignment, size_t size, void *ptr);
+void *vkd3d_gpu_va_allocator_dereference(struct vkd3d_gpu_va_allocator *allocator, D3D12_GPU_VIRTUAL_ADDRESS address);
+void vkd3d_gpu_va_allocator_free(struct vkd3d_gpu_va_allocator *allocator, D3D12_GPU_VIRTUAL_ADDRESS address);
 
 struct vkd3d_render_pass_key
 {
@@ -258,12 +254,10 @@ struct vkd3d_render_pass_cache
     size_t render_passes_size;
 };
 
-void vkd3d_render_pass_cache_cleanup(struct vkd3d_render_pass_cache *cache,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
-HRESULT vkd3d_render_pass_cache_find(struct vkd3d_render_pass_cache *cache,
-        struct d3d12_device *device, const struct vkd3d_render_pass_key *key,
-        VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN;
-void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache) DECLSPEC_HIDDEN;
+void vkd3d_render_pass_cache_cleanup(struct vkd3d_render_pass_cache *cache, struct d3d12_device *device);
+HRESULT vkd3d_render_pass_cache_find(struct vkd3d_render_pass_cache *cache, struct d3d12_device *device,
+        const struct vkd3d_render_pass_key *key, VkRenderPass *vk_render_pass);
+void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache);
 
 struct vkd3d_private_store
 {
@@ -318,12 +312,10 @@ static inline void vkd3d_private_store_destroy(struct vkd3d_private_store *store
     pthread_mutex_destroy(&store->mutex);
 }
 
-HRESULT vkd3d_get_private_data(struct vkd3d_private_store *store,
-        const GUID *tag, unsigned int *out_size, void *out) DECLSPEC_HIDDEN;
+HRESULT vkd3d_get_private_data(struct vkd3d_private_store *store, const GUID *tag, unsigned int *out_size, void *out);
 HRESULT vkd3d_set_private_data(struct vkd3d_private_store *store,
-        const GUID *tag, unsigned int data_size, const void *data) DECLSPEC_HIDDEN;
-HRESULT vkd3d_set_private_data_interface(struct vkd3d_private_store *store,
-        const GUID *tag, const IUnknown *object) DECLSPEC_HIDDEN;
+        const GUID *tag, unsigned int data_size, const void *data);
+HRESULT vkd3d_set_private_data_interface(struct vkd3d_private_store *store, const GUID *tag, const IUnknown *object);
 
 struct vkd3d_signaled_semaphore
 {
@@ -363,8 +355,8 @@ struct d3d12_fence
     struct vkd3d_private_store private_store;
 };
 
-HRESULT d3d12_fence_create(struct d3d12_device *device,
-        uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence) DECLSPEC_HIDDEN;
+HRESULT d3d12_fence_create(struct d3d12_device *device, uint64_t initial_value,
+        D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence);
 
 /* ID3D12Heap */
 struct d3d12_heap
@@ -388,8 +380,8 @@ struct d3d12_heap
 };
 
 HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc,
-        const struct d3d12_resource *resource, struct d3d12_heap **heap) DECLSPEC_HIDDEN;
-struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) DECLSPEC_HIDDEN;
+        const struct d3d12_resource *resource, struct d3d12_heap **heap);
+struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface);
 
 #define VKD3D_RESOURCE_PUBLIC_FLAGS \
         (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION)
@@ -437,29 +429,29 @@ static inline bool d3d12_resource_is_texture(const struct d3d12_resource *resour
     return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER;
 }
 
-bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource) DECLSPEC_HIDDEN;
-HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device) DECLSPEC_HIDDEN;
+bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource);
+HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device);
 
 HRESULT d3d12_committed_resource_create(struct d3d12_device *device,
         const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
         const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
-        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN;
+        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource);
 HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset,
         const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
-        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN;
+        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource);
 HRESULT d3d12_reserved_resource_create(struct d3d12_device *device,
         const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
-        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN;
-struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN;
+        const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource);
+struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface);
 
 HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer,
         const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
-        VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size) DECLSPEC_HIDDEN;
+        VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size);
 HRESULT vkd3d_create_buffer(struct d3d12_device *device,
         const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
-        const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN;
+        const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer);
 HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device,
-        const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) DECLSPEC_HIDDEN;
+        const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info);
 
 enum vkd3d_view_type
 {
@@ -497,8 +489,8 @@ struct vkd3d_view
     } info;
 };
 
-void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device) DECLSPEC_HIDDEN;
-void vkd3d_view_incref(struct vkd3d_view *view) DECLSPEC_HIDDEN;
+void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device);
+void vkd3d_view_incref(struct vkd3d_view *view);
 
 struct vkd3d_texture_view_desc
 {
@@ -513,9 +505,9 @@ struct vkd3d_texture_view_desc
 };
 
 bool vkd3d_create_buffer_view(struct d3d12_device *device, VkBuffer vk_buffer, const struct vkd3d_format *format,
-        VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view) DECLSPEC_HIDDEN;
+        VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view);
 bool vkd3d_create_texture_view(struct d3d12_device *device, VkImage vk_image,
-        const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view) DECLSPEC_HIDDEN;
+        const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view);
 
 struct d3d12_desc
 {
@@ -538,25 +530,22 @@ static inline struct d3d12_desc *d3d12_desc_from_gpu_handle(D3D12_GPU_DESCRIPTOR
     return (struct d3d12_desc *)(intptr_t)gpu_handle.ptr;
 }
 
-void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
+void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src, struct d3d12_device *device);
 void d3d12_desc_create_cbv(struct d3d12_desc *descriptor,
-        struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc) DECLSPEC_HIDDEN;
+        struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc);
 void d3d12_desc_create_srv(struct d3d12_desc *descriptor,
         struct d3d12_device *device, struct d3d12_resource *resource,
-        const D3D12_SHADER_RESOURCE_VIEW_DESC *desc) DECLSPEC_HIDDEN;
+        const D3D12_SHADER_RESOURCE_VIEW_DESC *desc);
 void d3d12_desc_create_uav(struct d3d12_desc *descriptor, struct d3d12_device *device,
         struct d3d12_resource *resource, struct d3d12_resource *counter_resource,
-        const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc) DECLSPEC_HIDDEN;
-void d3d12_desc_create_sampler(struct d3d12_desc *sampler,
-        struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc) DECLSPEC_HIDDEN;
-void d3d12_desc_write_atomic(struct d3d12_desc *dst, const struct d3d12_desc *src,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
+        const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc);
+void d3d12_desc_create_sampler(struct d3d12_desc *sampler, struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc);
+void d3d12_desc_write_atomic(struct d3d12_desc *dst, const struct d3d12_desc *src, struct d3d12_device *device);
 
 bool vkd3d_create_raw_buffer_view(struct d3d12_device *device,
-        D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view) DECLSPEC_HIDDEN;
+        D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view);
 HRESULT vkd3d_create_static_sampler(struct d3d12_device *device,
-        const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler) DECLSPEC_HIDDEN;
+        const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler);
 
 struct d3d12_rtv_desc
 {
@@ -576,7 +565,7 @@ static inline struct d3d12_rtv_desc *d3d12_rtv_desc_from_cpu_handle(D3D12_CPU_DE
 }
 
 void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_device *device,
-        struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc) DECLSPEC_HIDDEN;
+        struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc);
 
 struct d3d12_dsv_desc
 {
@@ -596,7 +585,7 @@ static inline struct d3d12_dsv_desc *d3d12_dsv_desc_from_cpu_handle(D3D12_CPU_DE
 }
 
 void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_device *device,
-        struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc) DECLSPEC_HIDDEN;
+        struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc);
 
 /* ID3D12DescriptorHeap */
 struct d3d12_descriptor_heap
@@ -614,7 +603,7 @@ struct d3d12_descriptor_heap
 };
 
 HRESULT d3d12_descriptor_heap_create(struct d3d12_device *device,
-        const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap) DECLSPEC_HIDDEN;
+        const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap);
 
 /* ID3D12QueryHeap */
 struct d3d12_query_heap
@@ -631,9 +620,9 @@ struct d3d12_query_heap
     uint64_t availability_mask[];
 };
 
-HRESULT d3d12_query_heap_create(struct d3d12_device *device, const D3D12_QUERY_HEAP_DESC *desc,
-        struct d3d12_query_heap **heap) DECLSPEC_HIDDEN;
-struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface) DECLSPEC_HIDDEN;
+HRESULT d3d12_query_heap_create(struct d3d12_device *device,
+        const D3D12_QUERY_HEAP_DESC *desc, struct d3d12_query_heap **heap);
+struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface);
 
 /* A Vulkan query has to be issued at least one time before the result is
  * available. In D3D12 it is legal to get query reults for not issued queries.
@@ -734,11 +723,11 @@ struct d3d12_root_signature
 };
 
 HRESULT d3d12_root_signature_create(struct d3d12_device *device, const void *bytecode,
-        size_t bytecode_length, struct d3d12_root_signature **root_signature) DECLSPEC_HIDDEN;
-struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface) DECLSPEC_HIDDEN;
+        size_t bytecode_length, struct d3d12_root_signature **root_signature);
+struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface);
 
 int vkd3d_parse_root_signature_v_1_0(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_shader_versioned_root_signature_desc *desc) DECLSPEC_HIDDEN;
+        struct vkd3d_shader_versioned_root_signature_desc *desc);
 
 struct d3d12_graphics_pipeline_state
 {
@@ -837,13 +826,12 @@ static inline bool d3d12_pipeline_state_has_unknown_dsv_format(struct d3d12_pipe
 }
 
 HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device,
-        const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN;
+        const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state);
 HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device,
-        const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN;
+        const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state);
 VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_state *state,
-        D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format,
-        VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN;
-struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface) DECLSPEC_HIDDEN;
+        D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format, VkRenderPass *vk_render_pass);
+struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface);
 
 struct vkd3d_buffer
 {
@@ -903,7 +891,7 @@ struct d3d12_command_allocator
 };
 
 HRESULT d3d12_command_allocator_create(struct d3d12_device *device,
-        D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator) DECLSPEC_HIDDEN;
+        D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator);
 
 struct vkd3d_push_descriptor
 {
@@ -995,7 +983,7 @@ struct d3d12_command_list
 
 HRESULT d3d12_command_list_create(struct d3d12_device *device,
         UINT node_mask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator *allocator_iface,
-        ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list) DECLSPEC_HIDDEN;
+        ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list);
 
 struct vkd3d_queue
 {
@@ -1022,12 +1010,11 @@ struct vkd3d_queue
     VkSemaphore old_vk_semaphores[VKD3D_MAX_VK_SYNC_OBJECTS];
 };
 
-VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN;
-HRESULT vkd3d_queue_create(struct d3d12_device *device,
-        uint32_t family_index, const VkQueueFamilyProperties *properties,
-        struct vkd3d_queue **queue) DECLSPEC_HIDDEN;
-void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device) DECLSPEC_HIDDEN;
-void vkd3d_queue_release(struct vkd3d_queue *queue) DECLSPEC_HIDDEN;
+VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue);
+HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index,
+        const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue);
+void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device);
+void vkd3d_queue_release(struct vkd3d_queue *queue);
 
 /* ID3D12CommandQueue */
 struct d3d12_command_queue
@@ -1048,7 +1035,7 @@ struct d3d12_command_queue
 };
 
 HRESULT d3d12_command_queue_create(struct d3d12_device *device,
-        const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue) DECLSPEC_HIDDEN;
+        const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue);
 
 /* ID3D12CommandSignature */
 struct d3d12_command_signature
@@ -1063,9 +1050,9 @@ struct d3d12_command_signature
     struct vkd3d_private_store private_store;
 };
 
-HRESULT d3d12_command_signature_create(struct d3d12_device *device, const D3D12_COMMAND_SIGNATURE_DESC *desc,
-        struct d3d12_command_signature **signature) DECLSPEC_HIDDEN;
-struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface) DECLSPEC_HIDDEN;
+HRESULT d3d12_command_signature_create(struct d3d12_device *device,
+        const D3D12_COMMAND_SIGNATURE_DESC *desc, struct d3d12_command_signature **signature);
+struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface);
 
 /* NULL resources */
 struct vkd3d_null_resources
@@ -1083,10 +1070,8 @@ struct vkd3d_null_resources
     VkDeviceMemory vk_2d_storage_image_memory;
 };
 
-HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
-void vkd3d_destroy_null_resources(struct vkd3d_null_resources *null_resources,
-        struct d3d12_device *device) DECLSPEC_HIDDEN;
+HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, struct d3d12_device *device);
+void vkd3d_destroy_null_resources(struct vkd3d_null_resources *null_resources, struct d3d12_device *device);
 
 struct vkd3d_format_compatibility_list
 {
@@ -1124,8 +1109,8 @@ struct vkd3d_uav_clear_state
     struct vkd3d_uav_clear_pipelines pipelines_uint;
 };
 
-HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN;
-void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN;
+HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device);
+void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device);
 
 /* ID3D12Device */
 struct d3d12_device
@@ -1181,13 +1166,12 @@ struct d3d12_device
 };
 
 HRESULT d3d12_device_create(struct vkd3d_instance *instance,
-        const struct vkd3d_device_create_info *create_info, struct d3d12_device **device) DECLSPEC_HIDDEN;
-struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device,
-        D3D12_COMMAND_LIST_TYPE type) DECLSPEC_HIDDEN;
-bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent) DECLSPEC_HIDDEN;
+        const struct vkd3d_device_create_info *create_info, struct d3d12_device **device);
+struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, D3D12_COMMAND_LIST_TYPE type);
+bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent);
 void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason,
-        const char *message, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN;
-struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface) DECLSPEC_HIDDEN;
+        const char *message, ...) VKD3D_PRINTF_FUNC(3, 4);
+struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface);
 
 static inline HRESULT d3d12_device_query_interface(struct d3d12_device *device, REFIID iid, void **object)
 {
@@ -1262,15 +1246,14 @@ static inline bool vkd3d_format_is_compressed(const struct vkd3d_format *format)
 
 void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *src,
         unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch,
-        unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d) DECLSPEC_HIDDEN;
+        unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d);
 
 const struct vkd3d_format *vkd3d_get_format(const struct d3d12_device *device,
-        DXGI_FORMAT dxgi_format, bool depth_stencil) DECLSPEC_HIDDEN;
-const struct vkd3d_format *vkd3d_find_uint_format(const struct d3d12_device *device,
-        DXGI_FORMAT dxgi_format) DECLSPEC_HIDDEN;
+        DXGI_FORMAT dxgi_format, bool depth_stencil);
+const struct vkd3d_format *vkd3d_find_uint_format(const struct d3d12_device *device, DXGI_FORMAT dxgi_format);
 
-HRESULT vkd3d_init_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN;
-void vkd3d_cleanup_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN;
+HRESULT vkd3d_init_format_info(struct d3d12_device *device);
+void vkd3d_cleanup_format_info(struct d3d12_device *device);
 
 static inline const struct vkd3d_format *vkd3d_format_from_d3d12_resource_desc(
         const struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, DXGI_FORMAT view_format)
@@ -1318,24 +1301,23 @@ static inline unsigned int vkd3d_compute_workgroup_count(unsigned int thread_cou
     return (thread_count + workgroup_size - 1) / workgroup_size;
 }
 
-VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op) DECLSPEC_HIDDEN;
-VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc) DECLSPEC_HIDDEN;
-VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count) DECLSPEC_HIDDEN;
+VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op);
+VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc);
+VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count);
 
-bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level) DECLSPEC_HIDDEN;
+bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level);
 
-bool is_valid_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN;
-bool is_write_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN;
+bool is_valid_resource_state(D3D12_RESOURCE_STATES state);
+bool is_write_resource_state(D3D12_RESOURCE_STATES state);
 
-HRESULT return_interface(void *iface, REFIID iface_iid,
-        REFIID requested_iid, void **object) DECLSPEC_HIDDEN;
+HRESULT return_interface(void *iface, REFIID iface_iid, REFIID requested_iid, void **object);
 
-const char *debug_d3d12_box(const D3D12_BOX *box) DECLSPEC_HIDDEN;
-const char *debug_d3d12_shader_component_mapping(unsigned int mapping) DECLSPEC_HIDDEN;
-const char *debug_vk_extent_3d(VkExtent3D extent) DECLSPEC_HIDDEN;
-const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags) DECLSPEC_HIDDEN;
-const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags) DECLSPEC_HIDDEN;
-const char *debug_vk_queue_flags(VkQueueFlags flags) DECLSPEC_HIDDEN;
+const char *debug_d3d12_box(const D3D12_BOX *box);
+const char *debug_d3d12_shader_component_mapping(unsigned int mapping);
+const char *debug_vk_extent_3d(VkExtent3D extent);
+const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags);
+const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags);
+const char *debug_vk_queue_flags(VkQueueFlags flags);
 
 static inline void debug_ignored_node_mask(unsigned int mask)
 {
@@ -1344,15 +1326,15 @@ static inline void debug_ignored_node_mask(unsigned int mask)
 }
 
 HRESULT vkd3d_load_vk_global_procs(struct vkd3d_vk_global_procs *procs,
-        PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) DECLSPEC_HIDDEN;
+        PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr);
 HRESULT vkd3d_load_vk_instance_procs(struct vkd3d_vk_instance_procs *procs,
-        const struct vkd3d_vk_global_procs *global_procs, VkInstance instance) DECLSPEC_HIDDEN;
+        const struct vkd3d_vk_global_procs *global_procs, VkInstance instance);
 HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs,
-        const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device) DECLSPEC_HIDDEN;
+        const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device);
 
 extern const char vkd3d_build[];
 
-bool vkd3d_get_program_name(char program_name[PATH_MAX]) DECLSPEC_HIDDEN;
+bool vkd3d_get_program_name(char program_name[PATH_MAX]);
 
 static inline void vkd3d_set_thread_name(const char *name)
 {
@@ -1364,9 +1346,9 @@ static inline void vkd3d_set_thread_name(const char *name)
 }
 
 VkResult vkd3d_set_vk_object_name_utf8(struct d3d12_device *device, uint64_t vk_object,
-        VkDebugReportObjectTypeEXT vk_object_type, const char *name) DECLSPEC_HIDDEN;
+        VkDebugReportObjectTypeEXT vk_object_type, const char *name);
 HRESULT vkd3d_set_vk_object_name(struct d3d12_device *device, uint64_t vk_object,
-        VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name) DECLSPEC_HIDDEN;
+        VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name);
 
 static inline void vk_prepend_struct(void *header, void *structure)
 {
-- 
2.32.0




More information about the wine-devel mailing list