Release 1.7.

Since the introduction of instruction arrays, the parser location no
longer matches the location of the current instruction. Ultimately we'll
likely want to add some kind of explicit location information to struct
vkd3d_shader_instruction_array, because we might do transformations that
change the order of the original instructions.

ANNOUNCE

@@ -1,16 +1,17 @@
-The Wine team is proud to announce that release 1.6 of vkd3d, the Direct3D to
+The Wine team is proud to announce that release 1.7 of vkd3d, the Direct3D to
 Vulkan translation library, is now available.
 
 This release contains improvements that are listed in the release notes below.
 The main highlights are:
 
-  - Initial support for HLSL compute shaders.
+  - Support for many more HLSL features and intrinsics.
-  - More support for HLSL features and intrinsics.
+  - Much improved support for the Direct3D shader model 1/2/3 HLSL profiles.
+  - Public vkd3d-shader API for parsing and serialising DXBC blobs.
   - Miscellaneous bug fixes.
 
 The source is available from the following location:
 
-  https://dl.winehq.org/vkd3d/source/vkd3d-1.6.tar.xz
+  https://dl.winehq.org/vkd3d/source/vkd3d-1.7.tar.xz
 
 The current source can also be pulled directly from the git repository:
 
@@ -21,40 +22,49 @@ for the complete list.
 
 ----------------------------------------------------------------
 
-What's new in vkd3d 1.6
+What's new in vkd3d 1.7
 =======================
 
 
 *** libvkd3d-shader
 
 - New features for the HLSL source type:
-  - Initial support for compute shaders.
+  - Support for calling user-defined functions.
-  - Improved support for initialisation and assignment of compound objects
+  - Support for array parameters to user-defined functions.
-    like structures and arrays, including casts and implicit conversions.
+  - Much improved support for the Direct3D shader model 1/2/3 profiles.
-  - Support for loads and stores of texture resource unordered-access views.
+  - Support for the SV_DispatchThreadID, SV_GroupID, and SV_GroupThreadID
-  - Support for function attributes. In particular, the required "numthreads"
+    compute shader system-value semantics.
-    attribute for compute shader entry points is now supported.
+  - Support for the optional "offset" parameter of the texture object Load()
-  - Support for the asuint() intrinsic function.
+    method.
-  - Support for the length() intrinsic function.
+  - Support for the all() intrinsic function.
-  - Support for the normalize() intrinsic function.
+  - Support for the distance() intrinsic function.
-  - Support for integer division and modulus.
+  - Support for the exp() and exp2() intrinsic functions.
-  - Support for taking the absolute value of integers.
+  - Support for the frac() intrinsic function.
-  - Support for floating-point modulus.
+  - Support for the lit() intrinsic function.
+  - Support for the reflect() intrinsic function.
+  - Support for the sin() and cos() intrinsic functions.
+  - Support for the smoothstep() intrinsic function.
+  - Support for the sqrt() and rsqrt() intrinsic functions.
+  - Support for the step() intrinsic function.
+  - Support for the transpose() intrinsic function.
+  - Support for the case-insensitive variants of the "float" and "dword" data
+    types.
+  - Partial support for minimum precision data types like "min16float". These
+    are currently interpreted as their regular counterparts.
+  - Improved constant propagation support, in particular to constant
+    propagation through swizzles.
 
+- HLSL static variables are now properly zero-initialised.
+
+- The Direct3D shader model 4 and 5 disassembler outputs sample counts for
+  multi-sampled resource declarations.
 
 - New interfaces:
-  - The VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_ATOMICS descriptor info flag is
+  - vkd3d_shader_parse_dxbc() provides support for parsing DXBC blobs.
-    used to indicate that atomic operations are used on unordered-access view
+  - vkd3d_shader_serialize_dxbc() provides support for serialising DXBC blobs.
-    descriptors.
+  - vkd3d_shader_free_dxbc() is used to free vkd3d_shader_dxbc_desc
-
+    structures, as returned by vkd3d_shader_parse_dxbc().
-
+  - The VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE compile option
-*** libvkd3d-common
+    can be used to specify whether SPIR-V shaders targeting Vulkan
-
+    environments should write point sizes for geometry and tessellation
-- vkd3d debug output is prefixed with "vkd3d:" in order to make it easier to
+    shaders. If left unspecified, point sizes will be written.
-  distinguish from output produced by applications or other libraries.
-
-
-*** demos
-
-- The demos now use libvkd3d-shader to compile HLSL shaders at run-time.
-

AUTHORS

@@ -8,6 +8,7 @@ Chip Davis
 Conor McCarthy
 David Gow
 Derek Lesho
+Fabian Maurer
 Francisco Casas
 Francois Gouget
 Giovanni Mascellani

COPYING

@@ -1,4 +1,4 @@
-Copyright 2016-2022 the Vkd3d project authors (see the file AUTHORS for a
+Copyright 2016-2023 the Vkd3d project authors (see the file AUTHORS for a
 complete list)
 
 Vkd3d is free software; you can redistribute it and/or modify it under

Makefile.am

@@ -43,15 +43,18 @@ vkd3d_cross_tests = \
 
 vkd3d_shader_tests = \
 	tests/abs.shader_test \
+	tests/all.shader_test \
 	tests/arithmetic-float.shader_test \
 	tests/arithmetic-float-uniform.shader_test \
 	tests/arithmetic-int.shader_test \
 	tests/arithmetic-int-uniform.shader_test \
 	tests/arithmetic-uint.shader_test \
+	tests/array-parameters.shader_test \
+	tests/asuint.shader_test \
 	tests/bitwise.shader_test \
 	tests/cast-broadcast.shader_test \
-	tests/cast-componentwise-equal.shader_test \
 	tests/cast-componentwise-compatible.shader_test \
+	tests/cast-componentwise-equal.shader_test \
 	tests/cast-to-float.shader_test \
 	tests/cast-to-half.shader_test \
 	tests/cast-to-int.shader_test \
@@ -59,7 +62,12 @@ vkd3d_shader_tests = \
 	tests/cbuffer.shader_test \
 	tests/compute.shader_test \
 	tests/conditional.shader_test \
+	tests/distance.shader_test \
+	tests/entry-point-semantics.shader_test \
+	tests/exp.shader_test \
 	tests/floor.shader_test \
+	tests/frac.shader_test \
+	tests/function-return.shader_test \
 	tests/hlsl-array-dimension.shader_test \
 	tests/hlsl-attributes.shader_test \
 	tests/hlsl-bool-cast.shader_test \
@@ -75,13 +83,13 @@ vkd3d_shader_tests = \
 	tests/hlsl-gather-offset.shader_test \
 	tests/hlsl-gather.shader_test \
 	tests/hlsl-initializer-flatten.shader_test \
-	tests/hlsl-initializer-invalid-arg-count.shader_test \
 	tests/hlsl-initializer-implicit-array.shader_test \
+	tests/hlsl-initializer-invalid-arg-count.shader_test \
 	tests/hlsl-initializer-local-array.shader_test \
-	tests/hlsl-initializer-objects.shader_test \
+	tests/hlsl-initializer-matrix.shader_test \
 	tests/hlsl-initializer-nested.shader_test \
 	tests/hlsl-initializer-numeric.shader_test \
-	tests/hlsl-initializer-matrix.shader_test \
+	tests/hlsl-initializer-objects.shader_test \
 	tests/hlsl-initializer-static-array.shader_test \
 	tests/hlsl-initializer-struct.shader_test \
 	tests/hlsl-intrinsic-override.shader_test \
@@ -99,21 +107,26 @@ vkd3d_shader_tests = \
 	tests/hlsl-numeric-types.shader_test \
 	tests/hlsl-numthreads.shader_test \
 	tests/hlsl-return-implicit-conversion.shader_test \
-	tests/hlsl-return-void.shader_test \
 	tests/hlsl-shape.shader_test \
 	tests/hlsl-single-numeric-initializer.shader_test \
+	tests/hlsl-smoothstep.shader_test \
 	tests/hlsl-state-block-syntax.shader_test \
 	tests/hlsl-static-initializer.shader_test \
 	tests/hlsl-storage-qualifiers.shader_test \
 	tests/hlsl-struct-array.shader_test \
 	tests/hlsl-struct-assignment.shader_test \
 	tests/hlsl-struct-semantics.shader_test \
+	tests/hlsl-transpose.shader_test \
+	tests/hlsl-type-names.shader_test \
 	tests/hlsl-vector-indexing.shader_test \
 	tests/hlsl-vector-indexing-uniform.shader_test \
+	tests/lit.shader_test \
 	tests/logic-operations.shader_test \
+	tests/majority-syntax.shader_test \
 	tests/math.shader_test \
 	tests/matrix-semantics.shader_test \
 	tests/max.shader_test \
+	tests/minimum-precision.shader_test \
 	tests/multiple-rt.shader_test \
 	tests/nointerpolation.shader_test \
 	tests/object-references.shader_test \
@@ -124,24 +137,25 @@ vkd3d_shader_tests = \
 	tests/preproc-invalid.shader_test \
 	tests/preproc-macro.shader_test \
 	tests/preproc-misc.shader_test \
+	tests/reflect.shader_test \
+	tests/register-reservations.shader_test \
+	tests/return.shader_test \
 	tests/round.shader_test \
 	tests/sampler.shader_test \
 	tests/sampler-offset.shader_test \
 	tests/saturate.shader_test \
 	tests/shader-interstage-interface.shader_test \
-	tests/swizzle-0.shader_test \
+	tests/sqrt.shader_test \
-	tests/swizzle-1.shader_test \
+	tests/step.shader_test \
-	tests/swizzle-2.shader_test \
+	tests/swizzle-constant-prop.shader_test \
-	tests/swizzle-3.shader_test \
+	tests/swizzles.shader_test \
-	tests/swizzle-4.shader_test \
-	tests/swizzle-5.shader_test \
-	tests/swizzle-6.shader_test \
-	tests/swizzle-7.shader_test \
 	tests/texture-load.shader_test \
+	tests/texture-load-offset.shader_test \
 	tests/texture-load-typed.shader_test \
 	tests/trigonometry.shader_test \
 	tests/uav.shader_test \
 	tests/uav-load.shader_test \
+	tests/uav-out-param.shader_test \
 	tests/writemask-assignop-0.shader_test \
 	tests/writemask-assignop-1.shader_test \
 	tests/writemask-assignop-2.shader_test \
@@ -245,7 +259,7 @@ libvkd3d_shader_la_SOURCES = \
 	libs/vkd3d-shader/vkd3d_shader_main.c \
 	libs/vkd3d-shader/vkd3d_shader_private.h
 libvkd3d_shader_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SHADER_SOURCE -I$(srcdir)/libs/vkd3d-shader @SPIRV_TOOLS_CFLAGS@
-libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 5:0:4
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 6:0:5
 libvkd3d_shader_la_LIBADD = libvkd3d-common.la @SPIRV_TOOLS_LIBS@ -lm
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_shader_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-shader/vkd3d_shader.map
@@ -279,7 +293,7 @@ libvkd3d_la_SOURCES = \
 	libs/vkd3d/vkd3d_shaders.h \
 	libs/vkd3d/vulkan_procs.h
 libvkd3d_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SOURCE
-libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:0:6
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 8:0:7
 libvkd3d_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la @DL_LIBS@ @PTHREAD_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d/vkd3d.map
@@ -291,7 +305,7 @@ libvkd3d_utils_la_SOURCES = \
 	libs/vkd3d-utils/vkd3d_utils_main.c \
 	libs/vkd3d-utils/vkd3d_utils_private.h
 libvkd3d_utils_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_UTILS_SOURCE
-libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 4:2:3
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 4:3:3
 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la libvkd3d.la @PTHREAD_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map
@@ -328,6 +342,8 @@ tests_hlsl_d3d12_LDADD = $(LDADD) @DL_LIBS@
 tests_shader_runner_LDADD = $(LDADD) @DL_LIBS@
 tests_shader_runner_SOURCES = \
 	tests/shader_runner.c \
+	tests/shader_runner_d3d9.c \
+	tests/shader_runner_d3d11.c \
 	tests/shader_runner_d3d12.c \
 	tests/shader_runner_vulkan.c
 tests_vkd3d_api_LDADD = libvkd3d.la @DL_LIBS@
@@ -409,7 +425,7 @@ dummy-vkd3d-version:
 ## Cross-compile tests
 cross_implibs = crosslibs/d3d12
 CROSS_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include
-CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS} -D__USE_MINGW_ANSI_STDIO=0
+CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS} -D__USE_MINGW_ANSI_STDIO=0 -DVKD3D_CROSSTEST=1
 EXTRA_DIST += $(cross_implibs:=.cross32.def) $(cross_implibs:=.cross64.def)
 EXTRA_DIST += tests/shader_runner_d3d11.c tests/shader_runner_d3d9.c
 

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.6])
+AC_INIT([vkd3d],[1.7])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
@@ -32,9 +32,11 @@ AS_IF([test "x$WIDL" = "xno"], [AC_MSG_WARN([widl is required to build header fi
 
 AC_CHECK_PROGS([FLEX], [flex], [none])
 AS_IF([test "$FLEX" = "none"], [AC_MSG_ERROR([no suitable flex found. Please install the 'flex' package.])])
+AC_ARG_VAR([LFLAGS], [extra flags for flex])
 
 AC_CHECK_PROGS([BISON], [bison], [none])
 AS_IF([test "$BISON" = "none"], [AC_MSG_ERROR([no suitable bison found. Please install the 'bison' package.])])
+AC_ARG_VAR([YFLAGS], [extra flags for bison])
 
 DX_PS_FEATURE([OFF])
 DX_INIT_DOXYGEN([vkd3d], [Doxyfile], [doc])

demos/demo_xcb.h

@@ -19,7 +19,7 @@
 
 #define VK_NO_PROTOTYPES
 #define VK_USE_PLATFORM_XCB_KHR
-#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_6
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_7
 #include "config.h"
 #include <vkd3d.h>
 #include <vkd3d_utils.h>

include/private/list.h

@@ -186,6 +186,30 @@ static inline void list_move_tail( struct list *dst, struct list *src )
     list_move_before( dst, src );
 }
 
+/* move the slice of elements from begin to end inclusive to the head of dst */
+static inline void list_move_slice_head( struct list *dst, struct list *begin, struct list *end )
+{
+    struct list *dst_next = dst->next;
+    begin->prev->next = end->next;
+    end->next->prev = begin->prev;
+    dst->next = begin;
+    dst_next->prev = end;
+    begin->prev = dst;
+    end->next = dst_next;
+}
+
+/* move the slice of elements from begin to end inclusive to the tail of dst */
+static inline void list_move_slice_tail( struct list *dst, struct list *begin, struct list *end )
+{
+    struct list *dst_prev = dst->prev;
+    begin->prev->next = end->next;
+    end->next->prev = begin->prev;
+    dst_prev->next = begin;
+    dst->prev = end;
+    begin->prev = dst_prev;
+    end->next = dst;
+}
+
 /* iterate through the list */
 #define LIST_FOR_EACH(cursor,list) \
     for ((cursor) = (list)->next; (cursor) != (list); (cursor) = (cursor)->next)

include/vkd3d.h

@@ -34,6 +34,18 @@
 extern "C" {
 #endif  /* __cplusplus */
 
+/**
+ * \file vkd3d.h
+ *
+ * This file contains definitions for the vkd3d library.
+ *
+ * The vkd3d library is a 3D graphics library built on top of
+ * Vulkan. It has an API very similar, but not identical, to
+ * Direct3D 12.
+ *
+ * \since 1.0
+ */
+
 enum vkd3d_structure_type
 {
     /* 1.0 */
@@ -63,6 +75,7 @@ enum vkd3d_api_version
     VKD3D_API_VERSION_1_4,
     VKD3D_API_VERSION_1_5,
     VKD3D_API_VERSION_1_6,
+    VKD3D_API_VERSION_1_7,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION),
 };

include/vkd3d_d3d12.idl

@@ -2263,6 +2263,7 @@ interface ID3D12CommandQueue : ID3D12Pageable
     void UpdateTileMappings(ID3D12Resource *resource, UINT region_count,
             const D3D12_TILED_RESOURCE_COORDINATE *region_start_coordinates,
             const D3D12_TILE_REGION_SIZE *region_sizes,
+            ID3D12Heap *heap,
             UINT range_count,
             const D3D12_TILE_RANGE_FLAGS *range_flags,
             UINT *heap_range_offsets,

include/vkd3d_shader.h

@@ -30,12 +30,12 @@ extern "C" {
 /**
  * \file vkd3d_shader.h
  *
- * \since 1.2
- *
  * This file contains definitions for the vkd3d-shader library.
  *
  * The vkd3d-shader library provides multiple utilities related to the
  * compilation, transformation, and reflection of GPU shaders.
+ *
+ * \since 1.2
  */
 
 /** \since 1.3 */
@@ -48,6 +48,7 @@ enum vkd3d_shader_api_version
     VKD3D_SHADER_API_VERSION_1_4,
     VKD3D_SHADER_API_VERSION_1_5,
     VKD3D_SHADER_API_VERSION_1_6,
+    VKD3D_SHADER_API_VERSION_1_7,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION),
 };
@@ -150,6 +151,18 @@ enum vkd3d_shader_compile_option_name
     VKD3D_SHADER_COMPILE_OPTION_API_VERSION = 0x00000004,
     /** \a value is a member of enum vkd3d_shader_compile_option_typed_uav. \since 1.5 */
     VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV   = 0x00000005,
+    /**
+     * If \a value is nonzero, write the point size for Vulkan tessellation and
+     * geometry shaders. This option should be enabled if and only if the
+     * shaderTessellationAndGeometryPointSize feature is enabled. The default
+     * value is nonzero, i.e. write the point size.
+     *
+     * This option is supported by vkd3d_shader_compile() for the SPIR-V target
+     * type and Vulkan targets; it should not be enabled otherwise.
+     *
+     * \since 1.7
+     */
+    VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE = 0x00000006,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_NAME),
 };
@@ -1460,6 +1473,46 @@ enum vkd3d_shader_swizzle_component
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SWIZZLE_COMPONENT),
 };
 
+/**
+ * A description of a DXBC section.
+ *
+ * \since 1.7
+ */
+struct vkd3d_shader_dxbc_section_desc
+{
+    /** The section tag. */
+    uint32_t tag;
+    /** The contents of the section. */
+    struct vkd3d_shader_code data;
+};
+
+/**
+ * A description of a DXBC blob, as returned by vkd3d_shader_parse_dxbc().
+ *
+ * \since 1.7
+ */
+struct vkd3d_shader_dxbc_desc
+{
+    /**
+     * The DXBC tag. This will always be "DXBC" in structures returned by
+     * this version of vkd3d-shader.
+     */
+    uint32_t tag;
+    /** A checksum of the DXBC contents. */
+    uint32_t checksum[4];
+    /**
+     * The DXBC version. This will always be 1 in structures returned by this
+     * version of vkd3d-shader.
+     */
+    unsigned int version;
+    /** The total size of the DXBC blob. */
+    size_t size;
+    /** The number of sections contained in the DXBC. */
+    size_t section_count;
+    /** Descriptions of the sections contained in the DXBC. */
+    struct vkd3d_shader_dxbc_section_desc *sections;
+};
+
 /**
  * A mask selecting one component from a vkd3d-shader swizzle. The component has
  * type \ref vkd3d_shader_swizzle_component.
@@ -1596,7 +1649,7 @@ VKD3D_SHADER_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported
  * vkd3d_shader_compile_info. Regardless of the requested level, if this
  * parameter is NULL, no compilation messages will be returned.
  * \n
- * If no compilation messages are produced by the compiler, this parameter may
+ * If no messages are produced by the compiler, this parameter may
  * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
@@ -1645,10 +1698,15 @@ VKD3D_SHADER_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *co
  * needed.
  *
  * \param messages Optional output location for error or informational messages
- * produced by the compiler.
+ * produced by the parser.
  * \n
- * This parameter behaves identically to the \a messages parameter of
+ * This string is null-terminated and UTF-8 encoded.
- * vkd3d_shader_compile().
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * If no messages are produced by the parser, this parameter may
+ * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
  */
@@ -1683,10 +1741,15 @@ VKD3D_SHADER_API void vkd3d_shader_free_root_signature(
  * vkd3d_shader_free_shader_code() when no longer needed.
  *
  * \param messages Optional output location for error or informational messages
- * produced by the compiler.
+ * produced by the serializer.
  * \n
- * This parameter behaves identically to the \a messages parameter of
+ * This string is null-terminated and UTF-8 encoded.
- * vkd3d_shader_compile().
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * If no messages are produced by the serializer, this parameter may
+ * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
  */
@@ -1733,10 +1796,19 @@ VKD3D_SHADER_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_ver
  * depending on their structure type.
  *
  * \param messages Optional output location for error or informational messages
- * produced by the compiler.
+ * produced by the parser.
  * \n
- * This parameter behaves identically to the \a messages parameter of
+ * This string is null-terminated and UTF-8 encoded.
- * vkd3d_shader_compile().
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * The messages returned can be regulated with the \a log_level member of struct
+ * vkd3d_shader_compile_info. Regardless of the requested level, if this
+ * parameter is NULL, no compilation messages will be returned.
+ * \n
+ * If no messages are produced by the parser, this parameter may
+ * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
  */
@@ -1768,12 +1840,20 @@ VKD3D_SHADER_API void vkd3d_shader_free_scan_descriptor_info(
  * Members of \a signature may be allocated by vkd3d-shader. The signature
  * should be freed with vkd3d_shader_free_shader_signature() when no longer
  * needed.
+ * \n
+ * The signature may contain pointers into the input shader, and should only be
+ * accessed while the input shader remains valid.
  *
  * \param messages Optional output location for error or informational messages
- * produced by the compiler.
+ * produced by the parser.
  * \n
- * This parameter behaves identically to the \a messages parameter of
+ * This string is null-terminated and UTF-8 encoded.
- * vkd3d_shader_compile().
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * If no messages are produced by the parser, this parameter may
+ * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
  */
@@ -1829,10 +1909,19 @@ VKD3D_SHADER_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_sig
  * vkd3d_shader_free_shader_code() when no longer needed.
  *
  * \param messages Optional output location for error or informational messages
- * produced by the compiler.
+ * produced by the preprocessor.
  * \n
- * This parameter behaves identically to the \a messages parameter of
+ * This string is null-terminated and UTF-8 encoded.
- * vkd3d_shader_compile().
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * The messages returned can be regulated with the \a log_level member of struct
+ * vkd3d_shader_compile_info. Regardless of the requested level, if this
+ * parameter is NULL, no compilation messages will be returned.
+ * \n
+ * If no messages are produced by the preprocessor, this parameter may
+ * receive NULL instead of a valid string pointer.
  *
  * \return A member of \ref vkd3d_result.
  *
@@ -1853,6 +1942,85 @@ VKD3D_SHADER_API int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_i
  */
 VKD3D_SHADER_API void vkd3d_shader_set_log_callback(PFN_vkd3d_log callback);
 
+/**
+ * Free the contents of a vkd3d_shader_dxbc_desc structure allocated by
+ * another vkd3d-shader function, such as vkd3d_shader_parse_dxbc().
+ *
+ * This function may free the \ref vkd3d_shader_dxbc_desc.sections member, but
+ * does not free the structure itself.
+ *
+ * \param dxbc The vkd3d_shader_dxbc_desc structure to free.
+ *
+ * \since 1.7
+ */
+VKD3D_SHADER_API void vkd3d_shader_free_dxbc(struct vkd3d_shader_dxbc_desc *dxbc);
+
+/**
+ * Parse a DXBC blob contained in a vkd3d_shader_code structure.
+ *
+ * \param dxbc A vkd3d_shader_code structure containing the DXBC blob to parse.
+ *
+ * \param flags A set of flags modifying the behaviour of the function. No
+ * flags are defined for this version of vkd3d-shader, and this parameter
+ * should be set to 0.
+ *
+ * \param desc A vkd3d_shader_dxbc_desc structure describing the contents of
+ * the DXBC blob. Its vkd3d_shader_dxbc_section_desc structures will contain
+ * pointers into the input blob; its contents are only valid while the input
+ * blob is valid. The contents of this structure should be freed with
+ * vkd3d_shader_free_dxbc() when no longer needed.
+ *
+ * \param messages Optional output location for error or informational messages
+ * produced by the parser.
+ * \n
+ * This string is null-terminated and UTF-8 encoded.
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * If no messages are produced by the parser, this parameter may
+ * receive NULL instead of a valid string pointer.
+ *
+ * \return A member of \ref vkd3d_result.
+ *
+ * \since 1.7
+ */
+VKD3D_SHADER_API int vkd3d_shader_parse_dxbc(const struct vkd3d_shader_code *dxbc,
+        uint32_t flags, struct vkd3d_shader_dxbc_desc *desc, char **messages);
+
+/**
+ * Serialize a DXBC description into a blob stored in a vkd3d_shader_code
+ * structure.
+ *
+ * \param section_count The number of DXBC sections to serialize.
+ *
+ * \param sections An array of vkd3d_shader_dxbc_section_desc structures
+ * to serialize.
+ *
+ * \param dxbc A pointer to a vkd3d_shader_code structure in which the
+ * serialized blob will be stored.
+ * \n
+ * The output blob is allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_shader_code() when no longer needed.
+ *
+ * \param messages Optional output location for error or informational messages
+ * produced by the serializer.
+ * \n
+ * This string is null-terminated and UTF-8 encoded.
+ * \n
+ * The messages are allocated by vkd3d-shader and should be freed with
+ * vkd3d_shader_free_messages() when no longer needed.
+ * \n
+ * If no messages are produced by the serializer, this parameter may
+ * receive NULL instead of a valid string pointer.
+ *
+ * \return A member of \ref vkd3d_result.
+ *
+ * \since 1.7
+ */
+VKD3D_SHADER_API int vkd3d_shader_serialize_dxbc(size_t section_count,
+        const struct vkd3d_shader_dxbc_section_desc *sections, struct vkd3d_shader_code *dxbc, char **messages);
+
 #endif  /* VKD3D_SHADER_NO_PROTOTYPES */
 
 /** Type of vkd3d_shader_get_version(). */
@@ -1909,6 +2077,15 @@ typedef void (*PFN_vkd3d_shader_preprocess)(struct vkd3d_shader_compile_info *co
 /** Type of vkd3d_shader_set_log_callback(). \since 1.4 */
 typedef void (*PFN_vkd3d_shader_set_log_callback)(PFN_vkd3d_log callback);
 
+/** Type of vkd3d_shader_free_dxbc(). \since 1.7 */
+typedef void (*PFN_vkd3d_shader_free_dxbc)(struct vkd3d_shader_dxbc_desc *dxbc);
+/** Type of vkd3d_shader_parse_dxbc(). \since 1.7 */
+typedef int (*PFN_vkd3d_shader_parse_dxbc)(const struct vkd3d_shader_code *dxbc,
+        uint32_t flags, struct vkd3d_shader_dxbc_desc *desc, char **messages);
+/** Type of vkd3d_shader_serialize_dxbc(). \since 1.7 */
+typedef int (*PFN_vkd3d_shader_serialize_dxbc)(size_t section_count,
+        const struct vkd3d_shader_dxbc_section_desc *sections, struct vkd3d_shader_code *dxbc, char **messages);
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

include/vkd3d_utils.h

@@ -29,6 +29,17 @@
 extern "C" {
 #endif  /* __cplusplus */
 
+/**
+ * \file vkd3d_utils.h
+ *
+ * This file contains definitions for the vkd3d-utils library.
+ *
+ * The vkd3d-utils library is a collections of routines to ease the
+ * porting of a Direct3D 12 application to vkd3d.
+ *
+ * \since 1.0
+ */
+
 #define VKD3D_WAIT_OBJECT_0 (0)
 #define VKD3D_WAIT_TIMEOUT (1)
 #define VKD3D_WAIT_FAILED (~0u)

libs/vkd3d-shader/d3dbc.c

@@ -210,13 +210,6 @@ struct vkd3d_shader_sm1_parser
     const uint32_t *start, *end;
     bool abort;
 
-    struct vkd3d_shader_src_param src_rel_addr[4];
-    struct vkd3d_shader_src_param pred_rel_addr;
-    struct vkd3d_shader_src_param dst_rel_addr;
-    struct vkd3d_shader_src_param src_param[4];
-    struct vkd3d_shader_src_param pred_param;
-    struct vkd3d_shader_dst_param dst_param;
-
     struct vkd3d_shader_parser p;
 };
 
@@ -556,33 +549,50 @@ static void shader_sm1_destroy(struct vkd3d_shader_parser *parser)
 {
     struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser);
 
+    shader_instruction_array_destroy(&parser->instructions);
     free_shader_desc(&sm1->p.shader_desc);
     vkd3d_free(sm1);
 }
 
 static void shader_sm1_read_src_param(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr,
-        struct vkd3d_shader_src_param *src_param, struct vkd3d_shader_src_param *src_rel_addr)
+        struct vkd3d_shader_src_param *src_param)
 {
+    struct vkd3d_shader_src_param *src_rel_addr = NULL;
     uint32_t token, addr_token;
 
     shader_sm1_read_param(sm1, ptr, &token, &addr_token);
     if (has_relative_address(token))
+    {
+        if (!(src_rel_addr = shader_parser_get_src_params(&sm1->p, 1)))
+        {
+            vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_OUT_OF_MEMORY,
+                    "Out of memory.");
+            sm1->abort = true;
+            return;
+        }
         shader_sm1_parse_src_param(addr_token, NULL, src_rel_addr);
-    else
+    }
-        src_rel_addr = NULL;
     shader_sm1_parse_src_param(token, src_rel_addr, src_param);
 }
 
 static void shader_sm1_read_dst_param(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr,
-        struct vkd3d_shader_dst_param *dst_param, struct vkd3d_shader_src_param *dst_rel_addr)
+        struct vkd3d_shader_dst_param *dst_param)
 {
+    struct vkd3d_shader_src_param *dst_rel_addr = NULL;
     uint32_t token, addr_token;
 
     shader_sm1_read_param(sm1, ptr, &token, &addr_token);
     if (has_relative_address(token))
+    {
+        if (!(dst_rel_addr = shader_parser_get_src_params(&sm1->p, 1)))
+        {
+            vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_OUT_OF_MEMORY,
+                    "Out of memory.");
+            sm1->abort = true;
+            return;
+        }
         shader_sm1_parse_src_param(addr_token, NULL, dst_rel_addr);
-    else
+    }
-        dst_rel_addr = NULL;
     shader_sm1_parse_dst_param(token, dst_rel_addr, dst_param);
 }
 
@@ -731,10 +741,13 @@ static void shader_sm1_validate_instruction(struct vkd3d_shader_sm1_parser *sm1,
 static void shader_sm1_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins)
 {
     struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser);
+    struct vkd3d_shader_src_param *src_params, *predicate;
     const struct vkd3d_sm1_opcode_info *opcode_info;
+    struct vkd3d_shader_dst_param *dst_param;
     const uint32_t **ptr = &parser->ptr;
     uint32_t opcode_token;
     const uint32_t *p;
+    bool predicated;
     unsigned int i;
 
     shader_sm1_read_comment(sm1);
@@ -761,11 +774,18 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_parser *parser, stru
     ins->coissue = opcode_token & VKD3D_SM1_COISSUE;
     ins->raw = false;
     ins->structured = false;
-    ins->predicate = opcode_token & VKD3D_SM1_INSTRUCTION_PREDICATED ? &sm1->pred_param : NULL;
+    predicated = !!(opcode_token & VKD3D_SM1_INSTRUCTION_PREDICATED);
+    ins->predicate = predicate = predicated ? shader_parser_get_src_params(parser, 1) : NULL;
     ins->dst_count = opcode_info->dst_count;
-    ins->dst = &sm1->dst_param;
+    ins->dst = dst_param = shader_parser_get_dst_params(parser, ins->dst_count);
     ins->src_count = opcode_info->src_count;
-    ins->src = sm1->src_param;
+    ins->src = src_params = shader_parser_get_src_params(parser, ins->src_count);
+    if ((!predicate && predicated) || (!src_params && ins->src_count) || (!dst_param && ins->dst_count))
+    {
+        vkd3d_shader_parser_error(parser, VKD3D_SHADER_ERROR_D3DBC_OUT_OF_MEMORY, "Out of memory.");
+        goto fail;
+    }
+
     ins->resource_type = VKD3D_SHADER_RESOURCE_NONE;
     ins->resource_stride = 0;
     ins->resource_data_type[0] = VKD3D_DATA_FLOAT;
@@ -790,32 +810,32 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_parser *parser, stru
     }
     else if (ins->handler_idx == VKD3DSIH_DEF)
     {
-        shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr);
+        shader_sm1_read_dst_param(sm1, &p, dst_param);
-        shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_FLOAT);
+        shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_FLOAT);
     }
     else if (ins->handler_idx == VKD3DSIH_DEFB)
     {
-        shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr);
+        shader_sm1_read_dst_param(sm1, &p, dst_param);
-        shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_SCALAR, VKD3D_DATA_UINT);
+        shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_SCALAR, VKD3D_DATA_UINT);
     }
     else if (ins->handler_idx == VKD3DSIH_DEFI)
     {
-        shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr);
+        shader_sm1_read_dst_param(sm1, &p, dst_param);
-        shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_INT);
+        shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_INT);
     }
     else
     {
         /* Destination token */
         if (ins->dst_count)
-            shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr);
+            shader_sm1_read_dst_param(sm1, &p, dst_param);
 
         /* Predication token */
         if (ins->predicate)
-            shader_sm1_read_src_param(sm1, &p, &sm1->pred_param, &sm1->pred_rel_addr);
+            shader_sm1_read_src_param(sm1, &p, predicate);
 
         /* Other source tokens */
         for (i = 0; i < ins->src_count; ++i)
-            shader_sm1_read_src_param(sm1, &p, &sm1->src_param[i], &sm1->src_rel_addr[i]);
+            shader_sm1_read_src_param(sm1, &p, &src_params[i]);
     }
 
     if (sm1->abort)
@@ -851,20 +871,9 @@ static bool shader_sm1_is_end(struct vkd3d_shader_parser *parser)
     return false;
 }
 
-static void shader_sm1_reset(struct vkd3d_shader_parser *parser)
-{
-    struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser);
-
-    parser->ptr = sm1->start;
-    parser->failed = false;
-}
-
 const struct vkd3d_shader_parser_ops shader_sm1_parser_ops =
 {
-    .parser_reset = shader_sm1_reset,
     .parser_destroy = shader_sm1_destroy,
-    .parser_read_instruction = shader_sm1_read_instruction,
-    .parser_is_end = shader_sm1_is_end,
 };
 
 static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1,
@@ -922,7 +931,10 @@ static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1,
     sm1->start = &code[1];
     sm1->end = &code[token_count];
 
-    vkd3d_shader_parser_init(&sm1->p, message_context, compile_info->source_name, &version, &shader_sm1_parser_ops);
+    /* Estimate instruction count to avoid reallocation in most shaders. */
+    if (!vkd3d_shader_parser_init(&sm1->p, message_context, compile_info->source_name, &version, &shader_sm1_parser_ops,
+            code_size != ~(size_t)0 ? token_count / 4u + 4 : 16))
+        return VKD3D_ERROR_OUT_OF_MEMORY;
     shader_desc = &sm1->p.shader_desc;
     shader_desc->byte_code = code;
     shader_desc->byte_code_size = code_size;
@@ -934,6 +946,8 @@ static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1,
 int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser)
 {
+    struct vkd3d_shader_instruction_array *instructions;
+    struct vkd3d_shader_instruction *ins;
     struct vkd3d_shader_sm1_parser *sm1;
     int ret;
 
@@ -950,6 +964,28 @@ int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compi
         return ret;
     }
 
+    instructions = &sm1->p.instructions;
+    while (!shader_sm1_is_end(&sm1->p))
+    {
+        if (!shader_instruction_array_reserve(instructions, instructions->count + 1))
+        {
+            ERR("Failed to allocate instructions.\n");
+            vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_OUT_OF_MEMORY, "Out of memory.");
+            shader_sm1_destroy(&sm1->p);
+            return VKD3D_ERROR_OUT_OF_MEMORY;
+        }
+        ins = &instructions->elements[instructions->count];
+        shader_sm1_read_instruction(&sm1->p, ins);
+
+        if (ins->handler_idx == VKD3DSIH_INVALID)
+        {
+            WARN("Encountered unrecognized or invalid instruction.\n");
+            shader_sm1_destroy(&sm1->p);
+            return VKD3D_ERROR_INVALID_SHADER;
+        }
+        ++instructions->count;
+    }
+
     *parser = &sm1->p;
 
     return VKD3D_OK;

libs/vkd3d-shader/glsl.c

@@ -22,7 +22,7 @@ struct vkd3d_glsl_generator
 {
     struct vkd3d_shader_version version;
     struct vkd3d_string_buffer buffer;
-    const struct vkd3d_shader_location *location;
+    struct vkd3d_shader_location location;
     struct vkd3d_shader_message_context *message_context;
     bool failed;
 };
@@ -38,7 +38,7 @@ struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shad
     memset(generator, 0, sizeof(*generator));
     generator->version = *version;
     vkd3d_string_buffer_init(&generator->buffer);
-    generator->location = location;
+    generator->location = *location;
     generator->message_context = message_context;
     return generator;
 }
@@ -50,7 +50,7 @@ static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_glsl_compiler_error(
     va_list args;
 
     va_start(args, fmt);
-    vkd3d_shader_verror(generator->message_context, generator->location, error, fmt, args);
+    vkd3d_shader_verror(generator->message_context, &generator->location, error, fmt, args);
     va_end(args);
     generator->failed = true;
 }
@@ -93,28 +93,20 @@ static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *generator
 int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator,
         struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *out)
 {
+    unsigned int i;
     void *code;
-    struct vkd3d_shader_instruction ins;
 
     vkd3d_string_buffer_printf(&generator->buffer, "#version 440\n\n");
     vkd3d_string_buffer_printf(&generator->buffer, "void main()\n{\n");
 
-    while (!vkd3d_shader_parser_is_end(parser))
+    generator->location.column = 0;
+    for (i = 0; i < parser->instructions.count; ++i)
     {
-        vkd3d_shader_parser_read_instruction(parser, &ins);
+        generator->location.line = i + 1;
-
+        vkd3d_glsl_handle_instruction(generator, &parser->instructions.elements[i]);
-        if (ins.handler_idx == VKD3DSIH_INVALID)
-        {
-            vkd3d_glsl_compiler_error(generator,
-                    VKD3D_SHADER_ERROR_GLSL_INTERNAL,
-                    "Encountered unrecognized or invalid instruction.");
-            break;
-        }
-
-        vkd3d_glsl_handle_instruction(generator, &ins);
     }
 
-    if (parser->failed || generator->failed)
+    if (generator->failed)
         return VKD3D_ERROR_INVALID_SHADER;
 
     vkd3d_string_buffer_printf(&generator->buffer, "}\n");

libs/vkd3d-shader/hlsl.l

@@ -181,7 +181,7 @@ row_major               {return KW_ROW_MAJOR;           }
                             yylval->name = hlsl_strdup(ctx, yytext);
                             if (hlsl_get_var(ctx->cur_scope, yytext) || hlsl_get_function(ctx, yytext))
                                 return VAR_IDENTIFIER;
-                            else if (hlsl_get_type(ctx->cur_scope, yytext, true))
+                            else if (hlsl_get_type(ctx->cur_scope, yytext, true, true))
                                 return TYPE_IDENTIFIER;
                             else
                                 return NEW_IDENTIFIER;
@@ -233,14 +233,14 @@ row_major               {return KW_ROW_MAJOR;           }
                             struct hlsl_ctx *ctx = yyget_extra(yyscanner);
 
                             TRACE("#pragma setting row_major mode.\n");
-                            ctx->matrix_majority = HLSL_ROW_MAJOR;
+                            ctx->matrix_majority = HLSL_MODIFIER_ROW_MAJOR;
                             BEGIN(pp_ignore);
                         }
 <pp_pragma>pack_matrix{WS}*\({WS}*column_major{WS}*\) {
                             struct hlsl_ctx *ctx = yyget_extra(yyscanner);
 
                             TRACE("#pragma setting column_major mode.\n");
-                            ctx->matrix_majority = HLSL_COLUMN_MAJOR;
+                            ctx->matrix_majority = HLSL_MODIFIER_COLUMN_MAJOR;
                             BEGIN(pp_ignore);
                         }
 <pp_pragma>{NEWLINE}    {

libs/vkd3d-shader/hlsl_constant_ops.c

@@ -509,6 +509,8 @@ bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr,
     if (instr->type != HLSL_IR_EXPR)
         return false;
     expr = hlsl_ir_expr(instr);
+    if (!expr->operands[0].node)
+        return false;
 
     if (instr->data_type->type > HLSL_CLASS_VECTOR)
         return false;
@@ -601,7 +603,7 @@ bool hlsl_fold_constant_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *inst
 {
     struct hlsl_ir_constant *value, *res;
     struct hlsl_ir_swizzle *swizzle;
-    unsigned int i, swizzle_bits;
+    unsigned int i;
 
     if (instr->type != HLSL_IR_SWIZZLE)
         return false;
@@ -613,12 +615,8 @@ bool hlsl_fold_constant_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *inst
     if (!(res = hlsl_new_constant(ctx, instr->data_type, &instr->loc)))
         return false;
 
-    swizzle_bits = swizzle->swizzle;
     for (i = 0; i < swizzle->node.data_type->dimx; ++i)
-    {
+        res->value[i] = value->value[hlsl_swizzle_get_component(swizzle->swizzle, i)];
-        res->value[i] = value->value[swizzle_bits & 3];
-        swizzle_bits >>= 2;
-    }
 
     list_add_before(&swizzle->node.entry, &res->node.entry);
     hlsl_replace_node(&swizzle->node, &res->node);