[PATCH vkd3d 4/4] build: Make the default symbol visibility "hidden".

Zebediah Figura zfigura at codeweavers.com
Tue Aug 3 22:52:15 CDT 2021


We tag far fewer symbols this way.

Signed-off-by: Zebediah Figura <zfigura at codeweavers.com>
---
This is also going to conflict with what other people are doing; sorry about
that.

 configure.ac                             |   1 +
 include/private/vkd3d_blob.h             |   2 +-
 include/private/vkd3d_common.h           |   8 +-
 include/private/vkd3d_debug.h            |  19 +-
 include/private/vkd3d_memory.h           |   3 +-
 include/private/vkd3d_utf8.h             |   2 +-
 include/vkd3d_windows.h                  |  17 +-
 libs/vkd3d-common/debug.c                |   2 +-
 libs/vkd3d-shader/dxbc.c                 |   6 +-
 libs/vkd3d-shader/hlsl.h                 | 111 ++++++------
 libs/vkd3d-shader/preproc.h              |  12 +-
 libs/vkd3d-shader/vkd3d_shader_main.c    |  26 +--
 libs/vkd3d-shader/vkd3d_shader_private.h |  80 ++++-----
 libs/vkd3d-utils/vkd3d_utils_main.c      |  30 ++--
 libs/vkd3d/command.c                     |   6 +-
 libs/vkd3d/device.c                      |  16 +-
 libs/vkd3d/resource.c                    |   6 +-
 libs/vkd3d/utils.c                       |   4 +-
 libs/vkd3d/vkd3d_main.c                  |  10 +-
 libs/vkd3d/vkd3d_private.h               | 216 +++++++++++------------
 20 files changed, 271 insertions(+), 306 deletions(-)

diff --git a/configure.ac b/configure.ac
index 88d58e40..d296dfd4 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 e25ee909..80855ac0 100644
--- a/include/private/vkd3d_common.h
+++ b/include/private/vkd3d_common.h
@@ -54,6 +54,12 @@ static inline size_t align(size_t addr, size_t alignment)
 # define VKD3D_UNUSED
 #endif  /* __GNUC__ */
 
+#if defined(__GNUC__) && !defined(__MINGW32__)
+# define VKD3D_API __attribute__((visibility("default")))
+#else
+# define VKD3D_API
+#endif
+
 static inline unsigned int vkd3d_popcount(unsigned int v)
 {
 #ifdef _MSC_VER
@@ -209,6 +215,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_windows.h b/include/vkd3d_windows.h
index 8398d403..c1aa9f27 100644
--- a/include/vkd3d_windows.h
+++ b/include/vkd3d_windows.h
@@ -127,18 +127,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 */
@@ -239,17 +239,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/dxbc.c b/libs/vkd3d-shader/dxbc.c
index aba2d2cd..ae493391 100644
--- a/libs/vkd3d-shader/dxbc.c
+++ b/libs/vkd3d-shader/dxbc.c
@@ -2393,7 +2393,7 @@ static int rts0_handler(const char *data, DWORD data_size, DWORD tag, void *cont
     return shader_parse_root_signature(data, data_size, desc);
 }
 
-int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
+VKD3D_API int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
         struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages)
 {
     struct vkd3d_shader_message_context message_context;
@@ -2797,7 +2797,7 @@ static int validate_root_signature_desc(const struct vkd3d_shader_versioned_root
     return ret;
 }
 
-int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
+VKD3D_API int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
         struct vkd3d_shader_code *dxbc, char **messages)
 {
     struct root_signature_writer_context context;
@@ -3106,7 +3106,7 @@ fail:
     return ret;
 }
 
-int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst,
+VKD3D_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)
 {
     int ret;
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_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c
index 78312a14..884794c7 100644
--- a/libs/vkd3d-shader/vkd3d_shader_main.c
+++ b/libs/vkd3d-shader/vkd3d_shader_main.c
@@ -432,7 +432,7 @@ static int vkd3d_shader_validate_compile_info(const struct vkd3d_shader_compile_
     return VKD3D_OK;
 }
 
-void vkd3d_shader_free_messages(char *messages)
+VKD3D_API void vkd3d_shader_free_messages(char *messages)
 {
     TRACE("messages %p.\n", messages);
 
@@ -974,7 +974,7 @@ done:
     return ret;
 }
 
-int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages)
+VKD3D_API int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages)
 {
     struct vkd3d_shader_message_context message_context;
     int ret;
@@ -1080,7 +1080,7 @@ static int compile_hlsl(const struct vkd3d_shader_compile_info *compile_info,
     return ret;
 }
 
-int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
+VKD3D_API int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages)
 {
     struct vkd3d_shader_message_context message_context;
@@ -1117,14 +1117,14 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
     return ret;
 }
 
-void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info)
+VKD3D_API void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info)
 {
     TRACE("scan_descriptor_info %p.\n", scan_descriptor_info);
 
     vkd3d_free(scan_descriptor_info->descriptors);
 }
 
-void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code)
+VKD3D_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code)
 {
     TRACE("shader_code %p.\n", shader_code);
 
@@ -1165,7 +1165,7 @@ static void vkd3d_shader_free_root_signature_v_1_1(struct vkd3d_shader_root_sign
     memset(root_signature, 0, sizeof(*root_signature));
 }
 
-void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc)
+VKD3D_API void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc)
 {
     TRACE("desc %p.\n", desc);
 
@@ -1186,7 +1186,7 @@ void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signatu
     desc->version = 0;
 }
 
-int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
+VKD3D_API int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
         struct vkd3d_shader_signature *signature, char **messages)
 {
     struct vkd3d_shader_message_context message_context;
@@ -1208,7 +1208,7 @@ int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
     return ret;
 }
 
-struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
+VKD3D_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)
 {
@@ -1230,7 +1230,7 @@ struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
     return NULL;
 }
 
-void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature)
+VKD3D_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature)
 {
     TRACE("signature %p.\n", signature);
 
@@ -1238,7 +1238,7 @@ void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature
     signature->elements = NULL;
 }
 
-const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor)
+VKD3D_API const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor)
 {
     int x, y;
 
@@ -1256,7 +1256,7 @@ const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor)
     return "vkd3d-shader " PACKAGE_VERSION VKD3D_VCS_ID;
 }
 
-const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count)
+VKD3D_API const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count)
 {
     static const enum vkd3d_shader_source_type types[] =
     {
@@ -1270,7 +1270,7 @@ const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(uns
     return types;
 }
 
-const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
+VKD3D_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
         enum vkd3d_shader_source_type source_type, unsigned int *count)
 {
     static const enum vkd3d_shader_target_type dxbc_tpf_types[] =
@@ -1305,7 +1305,7 @@ const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
     }
 }
 
-int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
+VKD3D_API int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages)
 {
     struct vkd3d_shader_message_context message_context;
diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h
index bd142297..1e21d4dc 100644
--- a/libs/vkd3d-shader/vkd3d_shader_private.h
+++ b/libs/vkd3d-shader/vkd3d_shader_private.h
@@ -855,20 +855,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
 {
@@ -884,20 +884,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
 {
@@ -906,8 +904,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)
 {
@@ -941,53 +939,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-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c
index 9c968cc6..48d3aa2a 100644
--- a/libs/vkd3d-utils/vkd3d_utils_main.c
+++ b/libs/vkd3d-utils/vkd3d_utils_main.c
@@ -21,14 +21,14 @@
 
 VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG");
 
-HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug)
+VKD3D_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug)
 {
     FIXME("iid %s, debug %p stub!\n", debugstr_guid(iid), debug);
 
     return E_NOTIMPL;
 }
 
-HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level,
+VKD3D_API HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level,
         REFIID iid, void **device, enum vkd3d_api_version api_version)
 {
     struct vkd3d_optional_instance_extensions_info optional_extensions_info;
@@ -85,13 +85,13 @@ HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minim
     return vkd3d_create_device(&device_create_info, iid, device);
 }
 
-HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter,
+VKD3D_API HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter,
         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device)
 {
     return D3D12CreateDeviceVKD3D(adapter, minimum_feature_level, iid, device, VKD3D_API_VERSION_1_0);
 }
 
-HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size,
+VKD3D_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer)
 {
     TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n",
@@ -100,7 +100,7 @@ HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T dat
     return vkd3d_create_root_signature_deserializer(data, data_size, iid, deserializer);
 }
 
-HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size,
+VKD3D_API HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size,
         REFIID iid,void **deserializer)
 {
     TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n",
@@ -109,7 +109,7 @@ HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, S
     return vkd3d_create_versioned_root_signature_deserializer(data, data_size, iid, deserializer);
 }
 
-HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc,
         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob)
 {
     TRACE("desc %p, version %#x, blob %p, error_blob %p.\n", desc, version, blob, error_blob);
@@ -117,7 +117,7 @@ HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc
     return vkd3d_serialize_root_signature(desc, version, blob, error_blob);
 }
 
-HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
         ID3DBlob **blob, ID3DBlob **error_blob)
 {
     TRACE("desc %p, blob %p, error_blob %p.\n", desc, blob, error_blob);
@@ -150,7 +150,7 @@ static void close_include(const struct vkd3d_shader_code *code, void *context)
     ID3DInclude_Close(iface, code->code);
 }
 
-HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
+VKD3D_API HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *macros, ID3DInclude *include, const char *entry_point,
         const char *profile, UINT flags, UINT effect_flags, UINT secondary_flags,
         const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader_blob,
@@ -244,7 +244,7 @@ HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filen
     return hresult_from_vkd3d_result(ret);
 }
 
-HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
+VKD3D_API HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *macros, ID3DInclude *include, const char *entrypoint,
         const char *profile, UINT flags, UINT effect_flags, ID3DBlob **shader, ID3DBlob **error_messages)
 {
@@ -257,7 +257,7 @@ HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filena
             effect_flags, 0, NULL, 0, shader, error_messages);
 }
 
-HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
+VKD3D_API HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
         const D3D_SHADER_MACRO *macros, ID3DInclude *include,
         ID3DBlob **preprocessed_blob, ID3DBlob **messages_blob)
 {
@@ -327,7 +327,7 @@ HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename
 }
 
 /* Events */
-HANDLE vkd3d_create_event(void)
+VKD3D_API HANDLE vkd3d_create_event(void)
 {
     struct vkd3d_event *event;
     int rc;
@@ -358,7 +358,7 @@ HANDLE vkd3d_create_event(void)
     return event;
 }
 
-unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds)
+VKD3D_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds)
 {
     struct vkd3d_event *impl = event;
     int rc;
@@ -401,7 +401,7 @@ unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds)
     return VKD3D_WAIT_FAILED;
 }
 
-HRESULT vkd3d_signal_event(HANDLE event)
+VKD3D_API HRESULT vkd3d_signal_event(HANDLE event)
 {
     struct vkd3d_event *impl = event;
     int rc;
@@ -420,7 +420,7 @@ HRESULT vkd3d_signal_event(HANDLE event)
     return S_OK;
 }
 
-void vkd3d_destroy_event(HANDLE event)
+VKD3D_API void vkd3d_destroy_event(HANDLE event)
 {
     struct vkd3d_event *impl = event;
     int rc;
@@ -434,7 +434,7 @@ void vkd3d_destroy_event(HANDLE event)
     vkd3d_free(impl);
 }
 
-HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3D10Blob **blob)
+VKD3D_API HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3D10Blob **blob)
 {
     HRESULT hr;
     void *data;
diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c
index bf80a9d0..1eeaea16 100644
--- a/libs/vkd3d/command.c
+++ b/libs/vkd3d/command.c
@@ -6249,21 +6249,21 @@ HRESULT d3d12_command_queue_create(struct d3d12_device *device,
     return S_OK;
 }
 
-uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue)
+VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue)
 {
     struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue);
 
     return d3d12_queue->vkd3d_queue->vk_family_index;
 }
 
-VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue)
+VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue)
 {
     struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue);
 
     return vkd3d_queue_acquire(d3d12_queue->vkd3d_queue);
 }
 
-void vkd3d_release_vk_queue(ID3D12CommandQueue *queue)
+VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue)
 {
     struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue);
 
diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c
index 0fadb521..476de1d0 100644
--- a/libs/vkd3d/device.c
+++ b/libs/vkd3d/device.c
@@ -589,7 +589,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance,
     return S_OK;
 }
 
-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)
 {
     struct vkd3d_instance *object;
@@ -637,7 +637,7 @@ static void vkd3d_destroy_instance(struct vkd3d_instance *instance)
     vkd3d_free(instance);
 }
 
-ULONG vkd3d_instance_incref(struct vkd3d_instance *instance)
+VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance)
 {
     ULONG refcount = InterlockedIncrement(&instance->refcount);
 
@@ -646,7 +646,7 @@ ULONG vkd3d_instance_incref(struct vkd3d_instance *instance)
     return refcount;
 }
 
-ULONG vkd3d_instance_decref(struct vkd3d_instance *instance)
+VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance)
 {
     ULONG refcount = InterlockedDecrement(&instance->refcount);
 
@@ -658,7 +658,7 @@ ULONG vkd3d_instance_decref(struct vkd3d_instance *instance)
     return refcount;
 }
 
-VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance)
+VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance)
 {
     return instance->vk_instance;
 }
@@ -3840,28 +3840,28 @@ HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_ha
     return hr;
 }
 
-IUnknown *vkd3d_get_device_parent(ID3D12Device *device)
+VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device)
 {
     struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device);
 
     return d3d12_device->parent;
 }
 
-VkDevice vkd3d_get_vk_device(ID3D12Device *device)
+VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device)
 {
     struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device);
 
     return d3d12_device->vk_device;
 }
 
-VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device)
+VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device)
 {
     struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device);
 
     return d3d12_device->vk_physical_device;
 }
 
-struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device)
+VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device)
 {
     struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device);
 
diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c
index 1ca23a90..681bd878 100644
--- a/libs/vkd3d/resource.c
+++ b/libs/vkd3d/resource.c
@@ -1996,7 +1996,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device,
     return S_OK;
 }
 
-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)
 {
     struct d3d12_device *d3d12_device = unsafe_impl_from_ID3D12Device(device);
@@ -2048,13 +2048,13 @@ HRESULT vkd3d_create_image_resource(ID3D12Device *device,
     return S_OK;
 }
 
-ULONG vkd3d_resource_incref(ID3D12Resource *resource)
+VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource)
 {
     TRACE("resource %p.\n", resource);
     return d3d12_resource_incref(impl_from_ID3D12Resource(resource));
 }
 
-ULONG vkd3d_resource_decref(ID3D12Resource *resource)
+VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource)
 {
     TRACE("resource %p.\n", resource);
     return d3d12_resource_decref(impl_from_ID3D12Resource(resource));
diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c
index ec2b4b39..450afc14 100644
--- a/libs/vkd3d/utils.c
+++ b/libs/vkd3d/utils.c
@@ -506,7 +506,7 @@ void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *sr
     }
 }
 
-VkFormat vkd3d_get_vk_format(DXGI_FORMAT format)
+VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format)
 {
     const struct vkd3d_format *vkd3d_format;
 
@@ -516,7 +516,7 @@ VkFormat vkd3d_get_vk_format(DXGI_FORMAT format)
     return vkd3d_format->vk_format;
 }
 
-DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format)
+VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format)
 {
     DXGI_FORMAT dxgi_format;
     VkFormat vk_format;
diff --git a/libs/vkd3d/vkd3d_main.c b/libs/vkd3d/vkd3d_main.c
index 21d998bf..df32fd5f 100644
--- a/libs/vkd3d/vkd3d_main.c
+++ b/libs/vkd3d/vkd3d_main.c
@@ -20,7 +20,7 @@
 
 VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG");
 
-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)
 {
     struct vkd3d_instance *instance;
@@ -215,7 +215,7 @@ static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signatur
     return S_OK;
 }
 
-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)
 {
     struct vkd3d_shader_code dxbc = {data, data_size};
@@ -399,7 +399,7 @@ static HRESULT d3d12_versioned_root_signature_deserializer_init(struct d3d12_ver
     return S_OK;
 }
 
-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)
 {
     struct d3d12_versioned_root_signature_deserializer *object;
@@ -422,7 +422,7 @@ HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZ
             &IID_ID3D12VersionedRootSignatureDeserializer, iid, deserializer);
 }
 
-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)
 {
     struct vkd3d_shader_versioned_root_signature_desc vkd3d_desc;
@@ -470,7 +470,7 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
     return hr;
 }
 
-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)
 {
     const struct vkd3d_shader_versioned_root_signature_desc *vkd3d_desc;
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