From 10db6d3f1f92efeb26ff0a30996fcbd04bc524ec Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Thu, 7 Dec 2023 14:54:04 +1100 Subject: [PATCH] Rebase against f0c08bd01e6d3b01bfc28961bb5922b94ecbb7bc. --- ...-f0a16d84ce939716defe41268340757da39.patch | 22406 ---------------- ...-6a4a9a4518689a7db5eff362cc5e0fff099.patch | 287 - staging/upstream-commit | 2 +- 3 files changed, 1 insertion(+), 22694 deletions(-) delete mode 100644 patches/vkd3d-latest/0001-Updated-vkd3d-to-f0a16d84ce939716defe41268340757da39.patch delete mode 100644 patches/vkd3d-latest/0002-Updated-vkd3d-to-6a4a9a4518689a7db5eff362cc5e0fff099.patch diff --git a/patches/vkd3d-latest/0001-Updated-vkd3d-to-f0a16d84ce939716defe41268340757da39.patch b/patches/vkd3d-latest/0001-Updated-vkd3d-to-f0a16d84ce939716defe41268340757da39.patch deleted file mode 100644 index 5adbb46a..00000000 --- a/patches/vkd3d-latest/0001-Updated-vkd3d-to-f0a16d84ce939716defe41268340757da39.patch +++ /dev/null @@ -1,22406 +0,0 @@ -From 61a0c9a6ffa003b3829afaa88117f2d152f76df1 Mon Sep 17 00:00:00 2001 -From: Alistair Leslie-Hughes -Date: Wed, 17 May 2023 08:35:40 +1000 -Subject: [PATCH] Updated vkd3d to f0a16d84ce939716defe41268340757da3900055. - ---- - libs/vkd3d/include/list.h | 270 ++ - libs/vkd3d/include/private/list.h | 270 ++ - libs/vkd3d/include/private/rbtree.h | 378 ++ - libs/vkd3d/include/private/vkd3d_common.h | 27 +- - libs/vkd3d/include/private/vkd3d_test.h | 432 +++ - libs/vkd3d/include/vkd3d_d3d9types.h | 237 ++ - libs/vkd3d/include/vkd3d_d3dcompiler.h | 92 + - libs/vkd3d/include/vkd3d_d3dcompiler_types.h | 45 + - libs/vkd3d/include/vkd3d_shader.h | 163 +- - libs/vkd3d/include/vkd3d_utils.h | 123 + - libs/vkd3d/include/vkd3d_windows.h | 289 ++ - libs/vkd3d/libs/vkd3d-common/blob.c | 2 + - libs/vkd3d/libs/vkd3d-shader/d3d_asm.c | 139 +- - libs/vkd3d/libs/vkd3d-shader/d3dbc.c | 142 +- - libs/vkd3d/libs/vkd3d-shader/dxbc.c | 162 +- - libs/vkd3d/libs/vkd3d-shader/dxil.c | 3269 +++++++++++++++-- - libs/vkd3d/libs/vkd3d-shader/hlsl.c | 353 +- - libs/vkd3d/libs/vkd3d-shader/hlsl.h | 111 +- - libs/vkd3d/libs/vkd3d-shader/hlsl.l | 56 +- - libs/vkd3d/libs/vkd3d-shader/hlsl.y | 698 +++- - libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c | 952 +++-- - .../libs/vkd3d-shader/hlsl_constant_ops.c | 417 ++- - libs/vkd3d/libs/vkd3d-shader/ir.c | 648 +++- - libs/vkd3d/libs/vkd3d-shader/preproc.h | 2 +- - libs/vkd3d/libs/vkd3d-shader/spirv.c | 923 +++-- - libs/vkd3d/libs/vkd3d-shader/tpf.c | 1715 +++++---- - .../libs/vkd3d-shader/vkd3d_shader_main.c | 296 +- - .../libs/vkd3d-shader/vkd3d_shader_private.h | 230 +- - libs/vkd3d/libs/vkd3d/command.c | 352 +- - libs/vkd3d/libs/vkd3d/device.c | 437 ++- - libs/vkd3d/libs/vkd3d/resource.c | 121 +- - libs/vkd3d/libs/vkd3d/state.c | 409 ++- - libs/vkd3d/libs/vkd3d/vkd3d_main.c | 4 +- - libs/vkd3d/libs/vkd3d/vkd3d_private.h | 67 +- - libs/vkd3d/libs/vkd3d/vkd3d_shaders.h | 568 +-- - 35 files changed, 11546 insertions(+), 2853 deletions(-) - create mode 100644 libs/vkd3d/include/list.h - create mode 100644 libs/vkd3d/include/private/list.h - create mode 100644 libs/vkd3d/include/private/rbtree.h - create mode 100644 libs/vkd3d/include/private/vkd3d_test.h - create mode 100644 libs/vkd3d/include/vkd3d_d3d9types.h - create mode 100644 libs/vkd3d/include/vkd3d_d3dcompiler.h - create mode 100644 libs/vkd3d/include/vkd3d_d3dcompiler_types.h - create mode 100644 libs/vkd3d/include/vkd3d_utils.h - create mode 100644 libs/vkd3d/include/vkd3d_windows.h - -diff --git a/libs/vkd3d/include/list.h b/libs/vkd3d/include/list.h -new file mode 100644 -index 00000000000..2e1d95f3fd4 ---- /dev/null -+++ b/libs/vkd3d/include/list.h -@@ -0,0 +1,270 @@ -+/* -+ * Linked lists support -+ * -+ * Copyright (C) 2002 Alexandre Julliard -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __WINE_SERVER_LIST_H -+#define __WINE_SERVER_LIST_H -+ -+#include -+ -+struct list -+{ -+ struct list *next; -+ struct list *prev; -+}; -+ -+/* Define a list like so: -+ * -+ * struct gadget -+ * { -+ * struct list entry; <-- doesn't have to be the first item in the struct -+ * int a, b; -+ * }; -+ * -+ * static struct list global_gadgets = LIST_INIT( global_gadgets ); -+ * -+ * or -+ * -+ * struct some_global_thing -+ * { -+ * struct list gadgets; -+ * }; -+ * -+ * list_init( &some_global_thing->gadgets ); -+ * -+ * Manipulate it like this: -+ * -+ * list_add_head( &global_gadgets, &new_gadget->entry ); -+ * list_remove( &new_gadget->entry ); -+ * list_add_after( &some_random_gadget->entry, &new_gadget->entry ); -+ * -+ * And to iterate over it: -+ * -+ * struct gadget *gadget; -+ * LIST_FOR_EACH_ENTRY( gadget, &global_gadgets, struct gadget, entry ) -+ * { -+ * ... -+ * } -+ * -+ */ -+ -+/* add an element after the specified one */ -+static inline void list_add_after( struct list *elem, struct list *to_add ) -+{ -+ to_add->next = elem->next; -+ to_add->prev = elem; -+ elem->next->prev = to_add; -+ elem->next = to_add; -+} -+ -+/* add an element before the specified one */ -+static inline void list_add_before( struct list *elem, struct list *to_add ) -+{ -+ to_add->next = elem; -+ to_add->prev = elem->prev; -+ elem->prev->next = to_add; -+ elem->prev = to_add; -+} -+ -+/* add element at the head of the list */ -+static inline void list_add_head( struct list *list, struct list *elem ) -+{ -+ list_add_after( list, elem ); -+} -+ -+/* add element at the tail of the list */ -+static inline void list_add_tail( struct list *list, struct list *elem ) -+{ -+ list_add_before( list, elem ); -+} -+ -+/* remove an element from its list */ -+static inline void list_remove( struct list *elem ) -+{ -+ elem->next->prev = elem->prev; -+ elem->prev->next = elem->next; -+} -+ -+/* get the next element */ -+static inline struct list *list_next( const struct list *list, const struct list *elem ) -+{ -+ struct list *ret = elem->next; -+ if (elem->next == list) ret = NULL; -+ return ret; -+} -+ -+/* get the previous element */ -+static inline struct list *list_prev( const struct list *list, const struct list *elem ) -+{ -+ struct list *ret = elem->prev; -+ if (elem->prev == list) ret = NULL; -+ return ret; -+} -+ -+/* get the first element */ -+static inline struct list *list_head( const struct list *list ) -+{ -+ return list_next( list, list ); -+} -+ -+/* get the last element */ -+static inline struct list *list_tail( const struct list *list ) -+{ -+ return list_prev( list, list ); -+} -+ -+/* check if a list is empty */ -+static inline int list_empty( const struct list *list ) -+{ -+ return list->next == list; -+} -+ -+/* initialize a list */ -+static inline void list_init( struct list *list ) -+{ -+ list->next = list->prev = list; -+} -+ -+/* count the elements of a list */ -+static inline unsigned int list_count( const struct list *list ) -+{ -+ unsigned count = 0; -+ const struct list *ptr; -+ for (ptr = list->next; ptr != list; ptr = ptr->next) count++; -+ return count; -+} -+ -+/* move all elements from src to before the specified element */ -+static inline void list_move_before( struct list *dst, struct list *src ) -+{ -+ if (list_empty(src)) return; -+ -+ dst->prev->next = src->next; -+ src->next->prev = dst->prev; -+ dst->prev = src->prev; -+ src->prev->next = dst; -+ list_init(src); -+} -+ -+/* move all elements from src to after the specified element */ -+static inline void list_move_after( struct list *dst, struct list *src ) -+{ -+ if (list_empty(src)) return; -+ -+ dst->next->prev = src->prev; -+ src->prev->next = dst->next; -+ dst->next = src->next; -+ src->next->prev = dst; -+ list_init(src); -+} -+ -+/* move all elements from src to the head of dst */ -+static inline void list_move_head( struct list *dst, struct list *src ) -+{ -+ list_move_after( dst, src ); -+} -+ -+/* move all elements from src to the tail of dst */ -+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) -+ -+/* iterate through the list, with safety against removal */ -+#define LIST_FOR_EACH_SAFE(cursor, cursor2, list) \ -+ for ((cursor) = (list)->next, (cursor2) = (cursor)->next; \ -+ (cursor) != (list); \ -+ (cursor) = (cursor2), (cursor2) = (cursor)->next) -+ -+/* iterate through the list using a list entry */ -+#define LIST_FOR_EACH_ENTRY(elem, list, type, field) \ -+ for ((elem) = LIST_ENTRY((list)->next, type, field); \ -+ &(elem)->field != (list); \ -+ (elem) = LIST_ENTRY((elem)->field.next, type, field)) -+ -+/* iterate through the list using a list entry, with safety against removal */ -+#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field) \ -+ for ((cursor) = LIST_ENTRY((list)->next, type, field), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.next, type, field); \ -+ &(cursor)->field != (list); \ -+ (cursor) = (cursor2), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.next, type, field)) -+ -+/* iterate through the list in reverse order */ -+#define LIST_FOR_EACH_REV(cursor,list) \ -+ for ((cursor) = (list)->prev; (cursor) != (list); (cursor) = (cursor)->prev) -+ -+/* iterate through the list in reverse order, with safety against removal */ -+#define LIST_FOR_EACH_SAFE_REV(cursor, cursor2, list) \ -+ for ((cursor) = (list)->prev, (cursor2) = (cursor)->prev; \ -+ (cursor) != (list); \ -+ (cursor) = (cursor2), (cursor2) = (cursor)->prev) -+ -+/* iterate through the list in reverse order using a list entry */ -+#define LIST_FOR_EACH_ENTRY_REV(elem, list, type, field) \ -+ for ((elem) = LIST_ENTRY((list)->prev, type, field); \ -+ &(elem)->field != (list); \ -+ (elem) = LIST_ENTRY((elem)->field.prev, type, field)) -+ -+/* iterate through the list in reverse order using a list entry, with safety against removal */ -+#define LIST_FOR_EACH_ENTRY_SAFE_REV(cursor, cursor2, list, type, field) \ -+ for ((cursor) = LIST_ENTRY((list)->prev, type, field), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field); \ -+ &(cursor)->field != (list); \ -+ (cursor) = (cursor2), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field)) -+ -+/* macros for statically initialized lists */ -+#undef LIST_INIT -+#define LIST_INIT(list) { &(list), &(list) } -+ -+/* get pointer to object containing list element */ -+#undef LIST_ENTRY -+#define LIST_ENTRY(elem, type, field) \ -+ ((type *)((char *)(elem) - offsetof(type, field))) -+ -+#endif /* __WINE_SERVER_LIST_H */ -diff --git a/libs/vkd3d/include/private/list.h b/libs/vkd3d/include/private/list.h -new file mode 100644 -index 00000000000..2e1d95f3fd4 ---- /dev/null -+++ b/libs/vkd3d/include/private/list.h -@@ -0,0 +1,270 @@ -+/* -+ * Linked lists support -+ * -+ * Copyright (C) 2002 Alexandre Julliard -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __WINE_SERVER_LIST_H -+#define __WINE_SERVER_LIST_H -+ -+#include -+ -+struct list -+{ -+ struct list *next; -+ struct list *prev; -+}; -+ -+/* Define a list like so: -+ * -+ * struct gadget -+ * { -+ * struct list entry; <-- doesn't have to be the first item in the struct -+ * int a, b; -+ * }; -+ * -+ * static struct list global_gadgets = LIST_INIT( global_gadgets ); -+ * -+ * or -+ * -+ * struct some_global_thing -+ * { -+ * struct list gadgets; -+ * }; -+ * -+ * list_init( &some_global_thing->gadgets ); -+ * -+ * Manipulate it like this: -+ * -+ * list_add_head( &global_gadgets, &new_gadget->entry ); -+ * list_remove( &new_gadget->entry ); -+ * list_add_after( &some_random_gadget->entry, &new_gadget->entry ); -+ * -+ * And to iterate over it: -+ * -+ * struct gadget *gadget; -+ * LIST_FOR_EACH_ENTRY( gadget, &global_gadgets, struct gadget, entry ) -+ * { -+ * ... -+ * } -+ * -+ */ -+ -+/* add an element after the specified one */ -+static inline void list_add_after( struct list *elem, struct list *to_add ) -+{ -+ to_add->next = elem->next; -+ to_add->prev = elem; -+ elem->next->prev = to_add; -+ elem->next = to_add; -+} -+ -+/* add an element before the specified one */ -+static inline void list_add_before( struct list *elem, struct list *to_add ) -+{ -+ to_add->next = elem; -+ to_add->prev = elem->prev; -+ elem->prev->next = to_add; -+ elem->prev = to_add; -+} -+ -+/* add element at the head of the list */ -+static inline void list_add_head( struct list *list, struct list *elem ) -+{ -+ list_add_after( list, elem ); -+} -+ -+/* add element at the tail of the list */ -+static inline void list_add_tail( struct list *list, struct list *elem ) -+{ -+ list_add_before( list, elem ); -+} -+ -+/* remove an element from its list */ -+static inline void list_remove( struct list *elem ) -+{ -+ elem->next->prev = elem->prev; -+ elem->prev->next = elem->next; -+} -+ -+/* get the next element */ -+static inline struct list *list_next( const struct list *list, const struct list *elem ) -+{ -+ struct list *ret = elem->next; -+ if (elem->next == list) ret = NULL; -+ return ret; -+} -+ -+/* get the previous element */ -+static inline struct list *list_prev( const struct list *list, const struct list *elem ) -+{ -+ struct list *ret = elem->prev; -+ if (elem->prev == list) ret = NULL; -+ return ret; -+} -+ -+/* get the first element */ -+static inline struct list *list_head( const struct list *list ) -+{ -+ return list_next( list, list ); -+} -+ -+/* get the last element */ -+static inline struct list *list_tail( const struct list *list ) -+{ -+ return list_prev( list, list ); -+} -+ -+/* check if a list is empty */ -+static inline int list_empty( const struct list *list ) -+{ -+ return list->next == list; -+} -+ -+/* initialize a list */ -+static inline void list_init( struct list *list ) -+{ -+ list->next = list->prev = list; -+} -+ -+/* count the elements of a list */ -+static inline unsigned int list_count( const struct list *list ) -+{ -+ unsigned count = 0; -+ const struct list *ptr; -+ for (ptr = list->next; ptr != list; ptr = ptr->next) count++; -+ return count; -+} -+ -+/* move all elements from src to before the specified element */ -+static inline void list_move_before( struct list *dst, struct list *src ) -+{ -+ if (list_empty(src)) return; -+ -+ dst->prev->next = src->next; -+ src->next->prev = dst->prev; -+ dst->prev = src->prev; -+ src->prev->next = dst; -+ list_init(src); -+} -+ -+/* move all elements from src to after the specified element */ -+static inline void list_move_after( struct list *dst, struct list *src ) -+{ -+ if (list_empty(src)) return; -+ -+ dst->next->prev = src->prev; -+ src->prev->next = dst->next; -+ dst->next = src->next; -+ src->next->prev = dst; -+ list_init(src); -+} -+ -+/* move all elements from src to the head of dst */ -+static inline void list_move_head( struct list *dst, struct list *src ) -+{ -+ list_move_after( dst, src ); -+} -+ -+/* move all elements from src to the tail of dst */ -+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) -+ -+/* iterate through the list, with safety against removal */ -+#define LIST_FOR_EACH_SAFE(cursor, cursor2, list) \ -+ for ((cursor) = (list)->next, (cursor2) = (cursor)->next; \ -+ (cursor) != (list); \ -+ (cursor) = (cursor2), (cursor2) = (cursor)->next) -+ -+/* iterate through the list using a list entry */ -+#define LIST_FOR_EACH_ENTRY(elem, list, type, field) \ -+ for ((elem) = LIST_ENTRY((list)->next, type, field); \ -+ &(elem)->field != (list); \ -+ (elem) = LIST_ENTRY((elem)->field.next, type, field)) -+ -+/* iterate through the list using a list entry, with safety against removal */ -+#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field) \ -+ for ((cursor) = LIST_ENTRY((list)->next, type, field), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.next, type, field); \ -+ &(cursor)->field != (list); \ -+ (cursor) = (cursor2), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.next, type, field)) -+ -+/* iterate through the list in reverse order */ -+#define LIST_FOR_EACH_REV(cursor,list) \ -+ for ((cursor) = (list)->prev; (cursor) != (list); (cursor) = (cursor)->prev) -+ -+/* iterate through the list in reverse order, with safety against removal */ -+#define LIST_FOR_EACH_SAFE_REV(cursor, cursor2, list) \ -+ for ((cursor) = (list)->prev, (cursor2) = (cursor)->prev; \ -+ (cursor) != (list); \ -+ (cursor) = (cursor2), (cursor2) = (cursor)->prev) -+ -+/* iterate through the list in reverse order using a list entry */ -+#define LIST_FOR_EACH_ENTRY_REV(elem, list, type, field) \ -+ for ((elem) = LIST_ENTRY((list)->prev, type, field); \ -+ &(elem)->field != (list); \ -+ (elem) = LIST_ENTRY((elem)->field.prev, type, field)) -+ -+/* iterate through the list in reverse order using a list entry, with safety against removal */ -+#define LIST_FOR_EACH_ENTRY_SAFE_REV(cursor, cursor2, list, type, field) \ -+ for ((cursor) = LIST_ENTRY((list)->prev, type, field), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field); \ -+ &(cursor)->field != (list); \ -+ (cursor) = (cursor2), \ -+ (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field)) -+ -+/* macros for statically initialized lists */ -+#undef LIST_INIT -+#define LIST_INIT(list) { &(list), &(list) } -+ -+/* get pointer to object containing list element */ -+#undef LIST_ENTRY -+#define LIST_ENTRY(elem, type, field) \ -+ ((type *)((char *)(elem) - offsetof(type, field))) -+ -+#endif /* __WINE_SERVER_LIST_H */ -diff --git a/libs/vkd3d/include/private/rbtree.h b/libs/vkd3d/include/private/rbtree.h -new file mode 100644 -index 00000000000..b5d38bca54c ---- /dev/null -+++ b/libs/vkd3d/include/private/rbtree.h -@@ -0,0 +1,378 @@ -+/* -+ * Red-black search tree support -+ * -+ * Copyright 2009 Henri Verbeet -+ * Copyright 2009 Andrew Riedi -+ * Copyright 2016 Jacek Caban for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __WINE_WINE_RBTREE_H -+#define __WINE_WINE_RBTREE_H -+ -+#define RB_ENTRY_VALUE(element, type, field) \ -+ ((type *)((char *)(element) - offsetof(type, field))) -+ -+struct rb_entry -+{ -+ struct rb_entry *parent; -+ struct rb_entry *left; -+ struct rb_entry *right; -+ unsigned int flags; -+}; -+ -+typedef int (*rb_compare_func)(const void *key, const struct rb_entry *entry); -+ -+struct rb_tree -+{ -+ rb_compare_func compare; -+ struct rb_entry *root; -+}; -+ -+typedef void (rb_traverse_func)(struct rb_entry *entry, void *context); -+ -+#define RB_FLAG_RED 0x1 -+ -+static inline int rb_is_red(struct rb_entry *entry) -+{ -+ return entry && (entry->flags & RB_FLAG_RED); -+} -+ -+static inline void rb_rotate_left(struct rb_tree *tree, struct rb_entry *e) -+{ -+ struct rb_entry *right = e->right; -+ -+ if (!e->parent) -+ tree->root = right; -+ else if (e->parent->left == e) -+ e->parent->left = right; -+ else -+ e->parent->right = right; -+ -+ e->right = right->left; -+ if (e->right) e->right->parent = e; -+ right->left = e; -+ right->parent = e->parent; -+ e->parent = right; -+} -+ -+static inline void rb_rotate_right(struct rb_tree *tree, struct rb_entry *e) -+{ -+ struct rb_entry *left = e->left; -+ -+ if (!e->parent) -+ tree->root = left; -+ else if (e->parent->left == e) -+ e->parent->left = left; -+ else -+ e->parent->right = left; -+ -+ e->left = left->right; -+ if (e->left) e->left->parent = e; -+ left->right = e; -+ left->parent = e->parent; -+ e->parent = left; -+} -+ -+static inline void rb_flip_color(struct rb_entry *entry) -+{ -+ entry->flags ^= RB_FLAG_RED; -+ entry->left->flags ^= RB_FLAG_RED; -+ entry->right->flags ^= RB_FLAG_RED; -+} -+ -+static inline struct rb_entry *rb_head(struct rb_entry *iter) -+{ -+ if (!iter) return NULL; -+ while (iter->left) iter = iter->left; -+ return iter; -+} -+ -+static inline struct rb_entry *rb_next(struct rb_entry *iter) -+{ -+ if (iter->right) return rb_head(iter->right); -+ while (iter->parent && iter->parent->right == iter) iter = iter->parent; -+ return iter->parent; -+} -+ -+static inline struct rb_entry *rb_postorder_head(struct rb_entry *iter) -+{ -+ if (!iter) return NULL; -+ -+ for (;;) { -+ while (iter->left) iter = iter->left; -+ if (!iter->right) return iter; -+ iter = iter->right; -+ } -+} -+ -+static inline struct rb_entry *rb_postorder_next(struct rb_entry *iter) -+{ -+ if (!iter->parent) return NULL; -+ if (iter == iter->parent->right || !iter->parent->right) return iter->parent; -+ return rb_postorder_head(iter->parent->right); -+} -+ -+/* iterate through the tree */ -+#define RB_FOR_EACH(cursor, tree) \ -+ for ((cursor) = rb_head((tree)->root); (cursor); (cursor) = rb_next(cursor)) -+ -+/* iterate through the tree using a tree entry */ -+#define RB_FOR_EACH_ENTRY(elem, tree, type, field) \ -+ for ((elem) = RB_ENTRY_VALUE(rb_head((tree)->root), type, field); \ -+ (elem) != RB_ENTRY_VALUE(0, type, field); \ -+ (elem) = RB_ENTRY_VALUE(rb_next(&elem->field), type, field)) -+ -+/* iterate through the tree using using postorder, making it safe to free the entry */ -+#define RB_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \ -+ for ((cursor) = rb_postorder_head((tree)->root); \ -+ (cursor) && (((cursor2) = rb_postorder_next(cursor)) || 1); \ -+ (cursor) = (cursor2)) -+ -+/* iterate through the tree using a tree entry and postorder, making it safe to free the entry */ -+#define RB_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field) \ -+ for ((elem) = RB_ENTRY_VALUE(rb_postorder_head((tree)->root), type, field); \ -+ (elem) != WINE_RB_ENTRY_VALUE(0, type, field) \ -+ && (((elem2) = RB_ENTRY_VALUE(rb_postorder_next(&(elem)->field), type, field)) || 1); \ -+ (elem) = (elem2)) -+ -+ -+static inline void rb_postorder(struct rb_tree *tree, rb_traverse_func *callback, void *context) -+{ -+ struct rb_entry *iter, *next; -+ RB_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context); -+} -+ -+static inline void rb_init(struct rb_tree *tree, rb_compare_func compare) -+{ -+ tree->compare = compare; -+ tree->root = NULL; -+} -+ -+static inline void rb_for_each_entry(struct rb_tree *tree, rb_traverse_func *callback, void *context) -+{ -+ struct rb_entry *iter; -+ RB_FOR_EACH(iter, tree) callback(iter, context); -+} -+ -+static inline void rb_clear(struct rb_tree *tree, rb_traverse_func *callback, void *context) -+{ -+ /* Note that we use postorder here because the callback will likely free the entry. */ -+ if (callback) rb_postorder(tree, callback, context); -+ tree->root = NULL; -+} -+ -+static inline void rb_destroy(struct rb_tree *tree, rb_traverse_func *callback, void *context) -+{ -+ rb_clear(tree, callback, context); -+} -+ -+static inline struct rb_entry *rb_get(const struct rb_tree *tree, const void *key) -+{ -+ struct rb_entry *entry = tree->root; -+ while (entry) -+ { -+ int c = tree->compare(key, entry); -+ if (!c) return entry; -+ entry = c < 0 ? entry->left : entry->right; -+ } -+ return NULL; -+} -+ -+static inline int rb_put(struct rb_tree *tree, const void *key, struct rb_entry *entry) -+{ -+ struct rb_entry **iter = &tree->root, *parent = tree->root; -+ -+ while (*iter) -+ { -+ int c; -+ -+ parent = *iter; -+ c = tree->compare(key, parent); -+ if (!c) return -1; -+ else if (c < 0) iter = &parent->left; -+ else iter = &parent->right; -+ } -+ -+ entry->flags = RB_FLAG_RED; -+ entry->parent = parent; -+ entry->left = NULL; -+ entry->right = NULL; -+ *iter = entry; -+ -+ while (rb_is_red(entry->parent)) -+ { -+ if (entry->parent == entry->parent->parent->left) -+ { -+ if (rb_is_red(entry->parent->parent->right)) -+ { -+ rb_flip_color(entry->parent->parent); -+ entry = entry->parent->parent; -+ } -+ else -+ { -+ if (entry == entry->parent->right) -+ { -+ entry = entry->parent; -+ rb_rotate_left(tree, entry); -+ } -+ entry->parent->flags &= ~RB_FLAG_RED; -+ entry->parent->parent->flags |= RB_FLAG_RED; -+ rb_rotate_right(tree, entry->parent->parent); -+ } -+ } -+ else -+ { -+ if (rb_is_red(entry->parent->parent->left)) -+ { -+ rb_flip_color(entry->parent->parent); -+ entry = entry->parent->parent; -+ } -+ else -+ { -+ if (entry == entry->parent->left) -+ { -+ entry = entry->parent; -+ rb_rotate_right(tree, entry); -+ } -+ entry->parent->flags &= ~RB_FLAG_RED; -+ entry->parent->parent->flags |= RB_FLAG_RED; -+ rb_rotate_left(tree, entry->parent->parent); -+ } -+ } -+ } -+ -+ tree->root->flags &= ~RB_FLAG_RED; -+ -+ return 0; -+} -+ -+static inline void rb_remove(struct rb_tree *tree, struct rb_entry *entry) -+{ -+ struct rb_entry *iter, *child, *parent, *w; -+ int need_fixup; -+ -+ if (entry->right && entry->left) -+ for(iter = entry->right; iter->left; iter = iter->left); -+ else -+ iter = entry; -+ -+ child = iter->left ? iter->left : iter->right; -+ -+ if (!iter->parent) -+ tree->root = child; -+ else if (iter == iter->parent->left) -+ iter->parent->left = child; -+ else -+ iter->parent->right = child; -+ -+ if (child) child->parent = iter->parent; -+ parent = iter->parent; -+ -+ need_fixup = !rb_is_red(iter); -+ -+ if (entry != iter) -+ { -+ *iter = *entry; -+ if (!iter->parent) -+ tree->root = iter; -+ else if (entry == iter->parent->left) -+ iter->parent->left = iter; -+ else -+ iter->parent->right = iter; -+ -+ if (iter->right) iter->right->parent = iter; -+ if (iter->left) iter->left->parent = iter; -+ if (parent == entry) parent = iter; -+ } -+ -+ if (need_fixup) -+ { -+ while (parent && !rb_is_red(child)) -+ { -+ if (child == parent->left) -+ { -+ w = parent->right; -+ if (rb_is_red(w)) -+ { -+ w->flags &= ~RB_FLAG_RED; -+ parent->flags |= RB_FLAG_RED; -+ rb_rotate_left(tree, parent); -+ w = parent->right; -+ } -+ if (rb_is_red(w->left) || rb_is_red(w->right)) -+ { -+ if (!rb_is_red(w->right)) -+ { -+ w->left->flags &= ~RB_FLAG_RED; -+ w->flags |= RB_FLAG_RED; -+ rb_rotate_right(tree, w); -+ w = parent->right; -+ } -+ w->flags = (w->flags & ~RB_FLAG_RED) | (parent->flags & RB_FLAG_RED); -+ parent->flags &= ~RB_FLAG_RED; -+ if (w->right) -+ w->right->flags &= ~RB_FLAG_RED; -+ rb_rotate_left(tree, parent); -+ child = NULL; -+ break; -+ } -+ } -+ else -+ { -+ w = parent->left; -+ if (rb_is_red(w)) -+ { -+ w->flags &= ~RB_FLAG_RED; -+ parent->flags |= RB_FLAG_RED; -+ rb_rotate_right(tree, parent); -+ w = parent->left; -+ } -+ if (rb_is_red(w->left) || rb_is_red(w->right)) -+ { -+ if (!rb_is_red(w->left)) -+ { -+ w->right->flags &= ~RB_FLAG_RED; -+ w->flags |= RB_FLAG_RED; -+ rb_rotate_left(tree, w); -+ w = parent->left; -+ } -+ w->flags = (w->flags & ~RB_FLAG_RED) | (parent->flags & RB_FLAG_RED); -+ parent->flags &= ~RB_FLAG_RED; -+ if (w->left) -+ w->left->flags &= ~RB_FLAG_RED; -+ rb_rotate_right(tree, parent); -+ child = NULL; -+ break; -+ } -+ } -+ w->flags |= RB_FLAG_RED; -+ child = parent; -+ parent = child->parent; -+ } -+ if (child) child->flags &= ~RB_FLAG_RED; -+ } -+ -+ if (tree->root) tree->root->flags &= ~RB_FLAG_RED; -+} -+ -+static inline void rb_remove_key(struct rb_tree *tree, const void *key) -+{ -+ struct rb_entry *entry = rb_get(tree, key); -+ if (entry) rb_remove(tree, entry); -+} -+ -+#endif /* __WINE_WINE_RBTREE_H */ -diff --git a/libs/vkd3d/include/private/vkd3d_common.h b/libs/vkd3d/include/private/vkd3d_common.h -index 6b5cdf8cf2c..e9bff2fbba3 100644 ---- a/libs/vkd3d/include/private/vkd3d_common.h -+++ b/libs/vkd3d/include/private/vkd3d_common.h -@@ -49,17 +49,38 @@ - ((uint32_t)(ch0) | ((uint32_t)(ch1) << 8) \ - | ((uint32_t)(ch2) << 16) | ((uint32_t)(ch3) << 24)) - -+#define TAG_AON9 VKD3D_MAKE_TAG('A', 'o', 'n', '9') -+#define TAG_DXBC VKD3D_MAKE_TAG('D', 'X', 'B', 'C') -+#define TAG_DXIL VKD3D_MAKE_TAG('D', 'X', 'I', 'L') -+#define TAG_ISG1 VKD3D_MAKE_TAG('I', 'S', 'G', '1') -+#define TAG_ISGN VKD3D_MAKE_TAG('I', 'S', 'G', 'N') -+#define TAG_OSG1 VKD3D_MAKE_TAG('O', 'S', 'G', '1') -+#define TAG_OSG5 VKD3D_MAKE_TAG('O', 'S', 'G', '5') -+#define TAG_OSGN VKD3D_MAKE_TAG('O', 'S', 'G', 'N') -+#define TAG_PCSG VKD3D_MAKE_TAG('P', 'C', 'S', 'G') -+#define TAG_PSG1 VKD3D_MAKE_TAG('P', 'S', 'G', '1') -+#define TAG_RD11 VKD3D_MAKE_TAG('R', 'D', '1', '1') -+#define TAG_RDEF VKD3D_MAKE_TAG('R', 'D', 'E', 'F') -+#define TAG_RTS0 VKD3D_MAKE_TAG('R', 'T', 'S', '0') -+#define TAG_SDBG VKD3D_MAKE_TAG('S', 'D', 'B', 'G') -+#define TAG_SHDR VKD3D_MAKE_TAG('S', 'H', 'D', 'R') -+#define TAG_SHEX VKD3D_MAKE_TAG('S', 'H', 'E', 'X') -+#define TAG_STAT VKD3D_MAKE_TAG('S', 'T', 'A', 'T') -+#define TAG_TEXT VKD3D_MAKE_TAG('T', 'E', 'X', 'T') -+#define TAG_XNAP VKD3D_MAKE_TAG('X', 'N', 'A', 'P') -+#define TAG_XNAS VKD3D_MAKE_TAG('X', 'N', 'A', 'S') -+ - static inline size_t align(size_t addr, size_t alignment) - { - return (addr + (alignment - 1)) & ~(alignment - 1); - } - --#ifdef __GNUC__ -+#if defined(__GNUC__) || defined(__clang__) - # define VKD3D_NORETURN __attribute__((noreturn)) - # ifdef __MINGW_PRINTF_FORMAT - # define VKD3D_PRINTF_FUNC(fmt, args) __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, args))) - # else --# define VKD3D_PRINTF_FUNC(fmt, args) /* __attribute__((format(printf, fmt, args))) */ -+# define VKD3D_PRINTF_FUNC(fmt, args) __attribute__((format(printf, fmt, args))) - # endif - # define VKD3D_UNUSED __attribute__((unused)) - # define VKD3D_UNREACHABLE __builtin_unreachable() -@@ -86,7 +107,7 @@ static inline unsigned int vkd3d_popcount(unsigned int v) - { - #ifdef _MSC_VER - return __popcnt(v); --#elif defined(__MINGW32__) -+#elif defined(HAVE_BUILTIN_POPCOUNT) - return __builtin_popcount(v); - #else - v -= (v >> 1) & 0x55555555; -diff --git a/libs/vkd3d/include/private/vkd3d_test.h b/libs/vkd3d/include/private/vkd3d_test.h -new file mode 100644 -index 00000000000..081443c4fa6 ---- /dev/null -+++ b/libs/vkd3d/include/private/vkd3d_test.h -@@ -0,0 +1,432 @@ -+/* -+ * Copyright 2016 Józef Kucia for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_TEST_H -+#define __VKD3D_TEST_H -+ -+#include "vkd3d_common.h" -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+extern const char *vkd3d_test_name; -+extern const char *vkd3d_test_platform; -+ -+static void vkd3d_test_start_todo(bool is_todo); -+static int vkd3d_test_loop_todo(void); -+static void vkd3d_test_end_todo(void); -+ -+#define START_TEST(name) \ -+ const char *vkd3d_test_name = #name; \ -+ static void vkd3d_test_main(int argc, char **argv) -+ -+/* -+ * Use assert_that() for conditions that should always be true. -+ * todo_if() and bug_if() do not influence assert_that(). -+ */ -+#define assert_that assert_that_(__LINE__) -+ -+#define ok ok_(__LINE__) -+ -+#define skip skip_(__LINE__) -+ -+#define trace trace_(__LINE__) -+ -+#define assert_that_(line) \ -+ do { \ -+ unsigned int vkd3d_line = line; \ -+ VKD3D_TEST_ASSERT_THAT -+ -+#define VKD3D_TEST_ASSERT_THAT(...) \ -+ vkd3d_test_assert_that(vkd3d_line, __VA_ARGS__); } while (0) -+ -+#define ok_(line) \ -+ do { \ -+ unsigned int vkd3d_line = line; \ -+ VKD3D_TEST_OK -+ -+#define VKD3D_TEST_OK(...) \ -+ vkd3d_test_ok(vkd3d_line, __VA_ARGS__); } while (0) -+ -+#define todo_(line) \ -+ do { \ -+ unsigned int vkd3d_line = line; \ -+ VKD3D_TEST_TODO -+ -+#define VKD3D_TEST_TODO(...) \ -+ vkd3d_test_todo(vkd3d_line, __VA_ARGS__); } while (0) -+ -+#define skip_(line) \ -+ do { \ -+ unsigned int vkd3d_line = line; \ -+ VKD3D_TEST_SKIP -+ -+#define VKD3D_TEST_SKIP(...) \ -+ vkd3d_test_skip(vkd3d_line, __VA_ARGS__); } while (0) -+ -+#define trace_(line) \ -+ do { \ -+ unsigned int vkd3d_line = line; \ -+ VKD3D_TEST_TRACE -+ -+#define VKD3D_TEST_TRACE(...) \ -+ vkd3d_test_trace(vkd3d_line, __VA_ARGS__); } while (0) -+ -+#define todo_if(is_todo) \ -+ for (vkd3d_test_start_todo(is_todo); vkd3d_test_loop_todo(); vkd3d_test_end_todo()) -+ -+#define bug_if(is_bug) \ -+ for (vkd3d_test_start_bug(is_bug); vkd3d_test_loop_bug(); vkd3d_test_end_bug()) -+ -+#define todo todo_if(true) -+ -+struct vkd3d_test_state -+{ -+ LONG success_count; -+ LONG failure_count; -+ LONG skip_count; -+ LONG todo_count; -+ LONG todo_success_count; -+ LONG bug_count; -+ -+ unsigned int debug_level; -+ -+ unsigned int todo_level; -+ bool todo_do_loop; -+ -+ unsigned int bug_level; -+ bool bug_do_loop; -+ bool bug_enabled; -+ -+ const char *test_name_filter; -+ char context[8][128]; -+ unsigned int context_count; -+}; -+extern struct vkd3d_test_state vkd3d_test_state; -+ -+static bool -+vkd3d_test_platform_is_windows(void) -+{ -+ return !strcmp(vkd3d_test_platform, "windows"); -+} -+ -+static inline bool -+broken(bool condition) -+{ -+ return condition && vkd3d_test_platform_is_windows(); -+} -+ -+static void vkd3d_test_printf(unsigned int line, const char *msg) -+{ -+ unsigned int i; -+ -+ printf("%s:%u: ", vkd3d_test_name, line); -+ for (i = 0; i < vkd3d_test_state.context_count; ++i) -+ printf("%s: ", vkd3d_test_state.context[i]); -+ printf("%s", msg); -+} -+ -+static void -+vkd3d_test_check_assert_that(unsigned int line, bool result, const char *fmt, va_list args) -+{ -+ if (result) -+ { -+ InterlockedIncrement(&vkd3d_test_state.success_count); -+ if (vkd3d_test_state.debug_level > 1) -+ vkd3d_test_printf(line, "Test succeeded.\n"); -+ } -+ else -+ { -+ InterlockedIncrement(&vkd3d_test_state.failure_count); -+ vkd3d_test_printf(line, "Test failed: "); -+ vprintf(fmt, args); -+ } -+} -+ -+static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED -+vkd3d_test_assert_that(unsigned int line, bool result, const char *fmt, ...) -+{ -+ va_list args; -+ -+ va_start(args, fmt); -+ vkd3d_test_check_assert_that(line, result, fmt, args); -+ va_end(args); -+} -+ -+static void -+vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list args) -+{ -+ bool is_todo = vkd3d_test_state.todo_level && !vkd3d_test_platform_is_windows(); -+ bool is_bug = vkd3d_test_state.bug_level && !vkd3d_test_platform_is_windows(); -+ -+ if (is_bug && vkd3d_test_state.bug_enabled) -+ { -+ InterlockedIncrement(&vkd3d_test_state.bug_count); -+ if (is_todo) -+ result = !result; -+ if (result) -+ vkd3d_test_printf(line, "Fixed bug: "); -+ else -+ vkd3d_test_printf(line, "Bug: "); -+ vprintf(fmt, args); -+ } -+ else if (is_todo) -+ { -+ if (result) -+ { -+ InterlockedIncrement(&vkd3d_test_state.todo_success_count); -+ vkd3d_test_printf(line, "Todo succeeded: "); -+ } -+ else -+ { -+ InterlockedIncrement(&vkd3d_test_state.todo_count); -+ vkd3d_test_printf(line, "Todo: "); -+ } -+ vprintf(fmt, args); -+ } -+ else -+ { -+ vkd3d_test_check_assert_that(line, result, fmt, args); -+ } -+} -+ -+static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED -+vkd3d_test_ok(unsigned int line, bool result, const char *fmt, ...) -+{ -+ va_list args; -+ -+ va_start(args, fmt); -+ vkd3d_test_check_ok(line, result, fmt, args); -+ va_end(args); -+} -+ -+static void VKD3D_PRINTF_FUNC(2, 3) VKD3D_UNUSED -+vkd3d_test_skip(unsigned int line, const char *fmt, ...) -+{ -+ va_list args; -+ va_start(args, fmt); -+ vkd3d_test_printf(line, "Test skipped: "); -+ vprintf(fmt, args); -+ va_end(args); -+ InterlockedIncrement(&vkd3d_test_state.skip_count); -+} -+ -+static void VKD3D_PRINTF_FUNC(2, 3) VKD3D_UNUSED -+vkd3d_test_trace(unsigned int line, const char *fmt, ...) -+{ -+ va_list args; -+ va_start(args, fmt); -+ vkd3d_test_printf(line, ""); -+ vprintf(fmt, args); -+ va_end(args); -+} -+ -+static void VKD3D_PRINTF_FUNC(1, 2) VKD3D_UNUSED -+vkd3d_test_debug(const char *fmt, ...) -+{ -+ char buffer[512]; -+ va_list args; -+ int size; -+ -+ size = snprintf(buffer, sizeof(buffer), "%s: ", vkd3d_test_name); -+ if (0 < size && size < sizeof(buffer)) -+ { -+ va_start(args, fmt); -+ vsnprintf(buffer + size, sizeof(buffer) - size, fmt, args); -+ va_end(args); -+ } -+ buffer[sizeof(buffer) - 1] = '\0'; -+ -+#ifdef _WIN32 -+ OutputDebugStringA(buffer); -+#endif -+ -+ if (vkd3d_test_state.debug_level > 0) -+ printf("%s\n", buffer); -+} -+ -+#ifndef VKD3D_TEST_NO_DEFS -+const char *vkd3d_test_platform = "other"; -+struct vkd3d_test_state vkd3d_test_state; -+ -+static void vkd3d_test_main(int argc, char **argv); -+ -+int main(int argc, char **argv) -+{ -+ const char *test_filter = getenv("VKD3D_TEST_FILTER"); -+ const char *debug_level = getenv("VKD3D_TEST_DEBUG"); -+ char *test_platform = getenv("VKD3D_TEST_PLATFORM"); -+ const char *bug = getenv("VKD3D_TEST_BUG"); -+ -+ memset(&vkd3d_test_state, 0, sizeof(vkd3d_test_state)); -+ vkd3d_test_state.debug_level = debug_level ? atoi(debug_level) : 0; -+ vkd3d_test_state.bug_enabled = bug ? atoi(bug) : true; -+ vkd3d_test_state.test_name_filter = test_filter; -+ -+ if (test_platform) -+ { -+ test_platform = strdup(test_platform); -+ vkd3d_test_platform = test_platform; -+ } -+ -+ if (vkd3d_test_state.debug_level > 1) -+ printf("Test platform: '%s'.\n", vkd3d_test_platform); -+ -+ vkd3d_test_main(argc, argv); -+ -+ printf("%s: %lu tests executed (%lu failures, %lu skipped, %lu todo, %lu bugs).\n", -+ vkd3d_test_name, -+ (unsigned long)(vkd3d_test_state.success_count -+ + vkd3d_test_state.failure_count + vkd3d_test_state.todo_count -+ + vkd3d_test_state.todo_success_count), -+ (unsigned long)(vkd3d_test_state.failure_count -+ + vkd3d_test_state.todo_success_count), -+ (unsigned long)vkd3d_test_state.skip_count, -+ (unsigned long)vkd3d_test_state.todo_count, -+ (unsigned long)vkd3d_test_state.bug_count); -+ -+ if (test_platform) -+ free(test_platform); -+ -+ return vkd3d_test_state.failure_count || vkd3d_test_state.todo_success_count; -+} -+ -+#ifdef _WIN32 -+static char *vkd3d_test_strdupWtoA(WCHAR *str) -+{ -+ char *out; -+ int len; -+ -+ if (!(len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL))) -+ return NULL; -+ if (!(out = malloc(len))) -+ return NULL; -+ WideCharToMultiByte(CP_ACP, 0, str, -1, out, len, NULL, NULL); -+ -+ return out; -+} -+ -+static bool running_under_wine(void) -+{ -+ HMODULE module = GetModuleHandleA("ntdll.dll"); -+ return module && GetProcAddress(module, "wine_server_call"); -+} -+ -+int wmain(int argc, WCHAR **wargv) -+{ -+ char **argv; -+ int i, ret; -+ -+ argv = malloc(argc * sizeof(*argv)); -+ assert(argv); -+ for (i = 0; i < argc; ++i) -+ { -+ if (!(argv[i] = vkd3d_test_strdupWtoA(wargv[i]))) -+ break; -+ } -+ assert(i == argc); -+ -+ vkd3d_test_platform = running_under_wine() ? "wine" : "windows"; -+ -+ ret = main(argc, argv); -+ -+ for (i = 0; i < argc; ++i) -+ free(argv[i]); -+ free(argv); -+ -+ return ret; -+} -+#endif /* _WIN32 */ -+#endif /* VKD3D_TEST_NO_DEFS */ -+ -+typedef void (*vkd3d_test_pfn)(void); -+ -+static inline void vkd3d_run_test(const char *name, vkd3d_test_pfn test_pfn) -+{ -+ if (vkd3d_test_state.test_name_filter && !strstr(name, vkd3d_test_state.test_name_filter)) -+ return; -+ -+ vkd3d_test_debug("%s", name); -+ test_pfn(); -+} -+ -+static inline void vkd3d_test_start_todo(bool is_todo) -+{ -+ vkd3d_test_state.todo_level = (vkd3d_test_state.todo_level << 1) | is_todo; -+ vkd3d_test_state.todo_do_loop = true; -+} -+ -+static inline int vkd3d_test_loop_todo(void) -+{ -+ bool do_loop = vkd3d_test_state.todo_do_loop; -+ vkd3d_test_state.todo_do_loop = false; -+ return do_loop; -+} -+ -+static inline void vkd3d_test_end_todo(void) -+{ -+ vkd3d_test_state.todo_level >>= 1; -+} -+ -+static inline void vkd3d_test_start_bug(bool is_bug) -+{ -+ vkd3d_test_state.bug_level = (vkd3d_test_state.bug_level << 1) | is_bug; -+ vkd3d_test_state.bug_do_loop = true; -+} -+ -+static inline int vkd3d_test_loop_bug(void) -+{ -+ bool do_loop = vkd3d_test_state.bug_do_loop; -+ vkd3d_test_state.bug_do_loop = false; -+ return do_loop; -+} -+ -+static inline void vkd3d_test_end_bug(void) -+{ -+ vkd3d_test_state.bug_level >>= 1; -+} -+ -+static inline void vkd3d_test_push_context(const char *fmt, ...) -+{ -+ va_list args; -+ -+ if (vkd3d_test_state.context_count < ARRAY_SIZE(vkd3d_test_state.context)) -+ { -+ va_start(args, fmt); -+ vsnprintf(vkd3d_test_state.context[vkd3d_test_state.context_count], -+ sizeof(vkd3d_test_state.context), fmt, args); -+ va_end(args); -+ vkd3d_test_state.context[vkd3d_test_state.context_count][sizeof(vkd3d_test_state.context[0]) - 1] = '\0'; -+ } -+ ++vkd3d_test_state.context_count; -+} -+ -+static inline void vkd3d_test_pop_context(void) -+{ -+ if (vkd3d_test_state.context_count) -+ --vkd3d_test_state.context_count; -+} -+ -+#define run_test(test_pfn) \ -+ vkd3d_run_test(#test_pfn, test_pfn) -+ -+#endif /* __VKD3D_TEST_H */ -diff --git a/libs/vkd3d/include/vkd3d_d3d9types.h b/libs/vkd3d/include/vkd3d_d3d9types.h -new file mode 100644 -index 00000000000..75d0461409d ---- /dev/null -+++ b/libs/vkd3d/include/vkd3d_d3d9types.h -@@ -0,0 +1,237 @@ -+/* -+ * Copyright 2002-2003 Jason Edmeades -+ * Copyright 2002-2003 Raphael Junqueira -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_D3D9TYPES_H -+#define __VKD3D_D3D9TYPES_H -+#ifndef _d3d9TYPES_H_ -+ -+#ifndef MAKEFOURCC -+#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ -+ ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ -+ ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) -+#endif -+ -+#define D3DSI_INSTLENGTH_SHIFT 24 -+ -+#define D3DSP_DCL_USAGE_SHIFT 0 -+#define D3DSP_DCL_USAGEINDEX_SHIFT 16 -+#define D3DSP_DSTMOD_SHIFT 20 -+ -+#define D3DSP_SRCMOD_SHIFT 24 -+ -+#define D3DSP_REGTYPE_SHIFT 28 -+#define D3DSP_REGTYPE_SHIFT2 8 -+#define D3DSP_REGTYPE_MASK (0x7 << D3DSP_REGTYPE_SHIFT) -+#define D3DSP_REGTYPE_MASK2 0x00001800 -+ -+#define D3DSP_WRITEMASK_0 0x00010000 -+#define D3DSP_WRITEMASK_1 0x00020000 -+#define D3DSP_WRITEMASK_2 0x00040000 -+#define D3DSP_WRITEMASK_3 0x00080000 -+#define D3DSP_WRITEMASK_ALL 0x000f0000 -+ -+#define D3DPS_VERSION(major, minor) (0xffff0000 | ((major) << 8) | (minor)) -+#define D3DVS_VERSION(major, minor) (0xfffe0000 | ((major) << 8) | (minor)) -+ -+typedef enum _D3DDECLUSAGE -+{ -+ D3DDECLUSAGE_POSITION = 0x0, -+ D3DDECLUSAGE_BLENDWEIGHT = 0x1, -+ D3DDECLUSAGE_BLENDINDICES = 0x2, -+ D3DDECLUSAGE_NORMAL = 0x3, -+ D3DDECLUSAGE_PSIZE = 0x4, -+ D3DDECLUSAGE_TEXCOORD = 0x5, -+ D3DDECLUSAGE_TANGENT = 0x6, -+ D3DDECLUSAGE_BINORMAL = 0x7, -+ D3DDECLUSAGE_TESSFACTOR = 0x8, -+ D3DDECLUSAGE_POSITIONT = 0x9, -+ D3DDECLUSAGE_COLOR = 0xa, -+ D3DDECLUSAGE_FOG = 0xb, -+ D3DDECLUSAGE_DEPTH = 0xc, -+ D3DDECLUSAGE_SAMPLE = 0xd, -+} D3DDECLUSAGE; -+ -+typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE -+{ -+ D3DSIO_NOP = 0x00, -+ D3DSIO_MOV = 0x01, -+ D3DSIO_ADD = 0x02, -+ D3DSIO_SUB = 0x03, -+ D3DSIO_MAD = 0x04, -+ D3DSIO_MUL = 0x05, -+ D3DSIO_RCP = 0x06, -+ D3DSIO_RSQ = 0x07, -+ D3DSIO_DP3 = 0x08, -+ D3DSIO_DP4 = 0x09, -+ D3DSIO_MIN = 0x0a, -+ D3DSIO_MAX = 0x0b, -+ D3DSIO_SLT = 0x0c, -+ D3DSIO_SGE = 0x0d, -+ D3DSIO_EXP = 0x0e, -+ D3DSIO_LOG = 0x0f, -+ D3DSIO_LIT = 0x10, -+ D3DSIO_DST = 0x11, -+ D3DSIO_LRP = 0x12, -+ D3DSIO_FRC = 0x13, -+ D3DSIO_M4x4 = 0x14, -+ D3DSIO_M4x3 = 0x15, -+ D3DSIO_M3x4 = 0x16, -+ D3DSIO_M3x3 = 0x17, -+ D3DSIO_M3x2 = 0x18, -+ D3DSIO_CALL = 0x19, -+ D3DSIO_CALLNZ = 0x1a, -+ D3DSIO_LOOP = 0x1b, -+ D3DSIO_RET = 0x1c, -+ D3DSIO_ENDLOOP = 0x1d, -+ D3DSIO_LABEL = 0x1e, -+ D3DSIO_DCL = 0x1f, -+ D3DSIO_POW = 0x20, -+ D3DSIO_CRS = 0x21, -+ D3DSIO_SGN = 0x22, -+ D3DSIO_ABS = 0x23, -+ D3DSIO_NRM = 0x24, -+ D3DSIO_SINCOS = 0x25, -+ D3DSIO_REP = 0x26, -+ D3DSIO_ENDREP = 0x27, -+ D3DSIO_IF = 0x28, -+ D3DSIO_IFC = 0x29, -+ D3DSIO_ELSE = 0x2a, -+ D3DSIO_ENDIF = 0x2b, -+ D3DSIO_BREAK = 0x2c, -+ D3DSIO_BREAKC = 0x2d, -+ D3DSIO_MOVA = 0x2e, -+ D3DSIO_DEFB = 0x2f, -+ D3DSIO_DEFI = 0x30, -+ -+ D3DSIO_TEXCOORD = 0x40, -+ D3DSIO_TEXKILL = 0x41, -+ D3DSIO_TEX = 0x42, -+ D3DSIO_TEXBEM = 0x43, -+ D3DSIO_TEXBEML = 0x44, -+ D3DSIO_TEXREG2AR = 0x45, -+ D3DSIO_TEXREG2GB = 0x46, -+ D3DSIO_TEXM3x2PAD = 0x47, -+ D3DSIO_TEXM3x2TEX = 0x48, -+ D3DSIO_TEXM3x3PAD = 0x49, -+ D3DSIO_TEXM3x3TEX = 0x4a, -+ D3DSIO_TEXM3x3DIFF = 0x4b, -+ D3DSIO_TEXM3x3SPEC = 0x4c, -+ D3DSIO_TEXM3x3VSPEC = 0x4d, -+ D3DSIO_EXPP = 0x4e, -+ D3DSIO_LOGP = 0x4f, -+ D3DSIO_CND = 0x50, -+ D3DSIO_DEF = 0x51, -+ D3DSIO_TEXREG2RGB = 0x52, -+ D3DSIO_TEXDP3TEX = 0x53, -+ D3DSIO_TEXM3x2DEPTH = 0x54, -+ D3DSIO_TEXDP3 = 0x55, -+ D3DSIO_TEXM3x3 = 0x56, -+ D3DSIO_TEXDEPTH = 0x57, -+ D3DSIO_CMP = 0x58, -+ D3DSIO_BEM = 0x59, -+ D3DSIO_DP2ADD = 0x5a, -+ D3DSIO_DSX = 0x5b, -+ D3DSIO_DSY = 0x5c, -+ D3DSIO_TEXLDD = 0x5d, -+ D3DSIO_SETP = 0x5e, -+ D3DSIO_TEXLDL = 0x5f, -+ D3DSIO_BREAKP = 0x60, -+ -+ D3DSIO_PHASE = 0xfffd, -+ D3DSIO_COMMENT = 0xfffe, -+ D3DSIO_END = 0xffff, -+ -+ D3DSIO_FORCE_DWORD = 0x7fffffff, -+} D3DSHADER_INSTRUCTION_OPCODE_TYPE; -+ -+typedef enum _D3DSHADER_PARAM_DSTMOD_TYPE -+{ -+ D3DSPDM_NONE = 0 << D3DSP_DSTMOD_SHIFT, -+ D3DSPDM_SATURATE = 1 << D3DSP_DSTMOD_SHIFT, -+ D3DSPDM_PARTIALPRECISION = 2 << D3DSP_DSTMOD_SHIFT, -+ D3DSPDM_MSAMPCENTROID = 4 << D3DSP_DSTMOD_SHIFT, -+ -+ D3DSPDM_FORCE_DWORD = 0x7fffffff, -+} D3DSHADER_PARAM_DSTMOD_TYPE; -+ -+typedef enum _D3DSHADER_PARAM_REGISTER_TYPE -+{ -+ D3DSPR_TEMP = 0x00, -+ D3DSPR_INPUT = 0x01, -+ D3DSPR_CONST = 0x02, -+ D3DSPR_ADDR = 0x03, -+ D3DSPR_TEXTURE = 0x03, -+ D3DSPR_RASTOUT = 0x04, -+ D3DSPR_ATTROUT = 0x05, -+ D3DSPR_TEXCRDOUT = 0x06, -+ D3DSPR_OUTPUT = 0x06, -+ D3DSPR_CONSTINT = 0x07, -+ D3DSPR_COLOROUT = 0x08, -+ D3DSPR_DEPTHOUT = 0x09, -+ D3DSPR_SAMPLER = 0x0a, -+ D3DSPR_CONST2 = 0x0b, -+ D3DSPR_CONST3 = 0x0c, -+ D3DSPR_CONST4 = 0x0d, -+ D3DSPR_CONSTBOOL = 0x0e, -+ D3DSPR_LOOP = 0x0f, -+ D3DSPR_TEMPFLOAT16 = 0x10, -+ D3DSPR_MISCTYPE = 0x11, -+ D3DSPR_LABEL = 0x12, -+ D3DSPR_PREDICATE = 0x13, -+ -+ D3DSPR_FORCE_DWORD = 0x7fffffff, -+} D3DSHADER_PARAM_REGISTER_TYPE; -+ -+typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE -+{ -+ D3DSPSM_NONE = 0x0 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_NEG = 0x1 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_BIAS = 0x2 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_BIASNEG = 0x3 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_SIGN = 0x4 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_SIGNNEG = 0x5 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_COMP = 0x6 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_X2 = 0x7 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_X2NEG = 0x8 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_DZ = 0x9 << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_DW = 0xa << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_ABS = 0xb << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_ABSNEG = 0xc << D3DSP_SRCMOD_SHIFT, -+ D3DSPSM_NOT = 0xd << D3DSP_SRCMOD_SHIFT, -+ -+ D3DSPSM_FORCE_DWORD = 0x7fffffff, -+} D3DSHADER_PARAM_SRCMOD_TYPE; -+ -+typedef enum _D3DSHADER_MISCTYPE_OFFSETS -+{ -+ D3DSMO_POSITION = 0x0, -+ D3DSMO_FACE = 0x1, -+} D3DSHADER_MISCTYPE_OFFSETS; -+ -+typedef enum _D3DVS_RASTOUT_OFFSETS -+{ -+ D3DSRO_POSITION = 0x0, -+ D3DSRO_FOG = 0x1, -+ D3DSRO_POINT_SIZE = 0x2, -+ -+ D3DSRO_FORCE_DWORD = 0x7fffffff, -+} D3DVS_RASTOUT_OFFSETS; -+ -+#endif /* _d3d9TYPES_H_ */ -+#endif /* __VKD3D_D3D9TYPES_H */ -diff --git a/libs/vkd3d/include/vkd3d_d3dcompiler.h b/libs/vkd3d/include/vkd3d_d3dcompiler.h -new file mode 100644 -index 00000000000..c78cf25b955 ---- /dev/null -+++ b/libs/vkd3d/include/vkd3d_d3dcompiler.h -@@ -0,0 +1,92 @@ -+/* -+ * Copyright 2010 Matteo Bruni for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_D3DCOMPILER_H -+#define __VKD3D_D3DCOMPILER_H -+#ifndef __D3DCOMPILER_H__ -+ -+#include -+ -+#define D3DCOMPILE_DEBUG 0x00000001 -+#define D3DCOMPILE_SKIP_VALIDATION 0x00000002 -+#define D3DCOMPILE_SKIP_OPTIMIZATION 0x00000004 -+#define D3DCOMPILE_PACK_MATRIX_ROW_MAJOR 0x00000008 -+#define D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR 0x00000010 -+#define D3DCOMPILE_PARTIAL_PRECISION 0x00000020 -+#define D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT 0x00000040 -+#define D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT 0x00000080 -+#define D3DCOMPILE_NO_PRESHADER 0x00000100 -+#define D3DCOMPILE_AVOID_FLOW_CONTROL 0x00000200 -+#define D3DCOMPILE_PREFER_FLOW_CONTROL 0x00000400 -+#define D3DCOMPILE_ENABLE_STRICTNESS 0x00000800 -+#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY 0x00001000 -+#define D3DCOMPILE_IEEE_STRICTNESS 0x00002000 -+#define D3DCOMPILE_OPTIMIZATION_LEVEL0 0x00004000 -+#define D3DCOMPILE_OPTIMIZATION_LEVEL1 0x00000000 -+#define D3DCOMPILE_OPTIMIZATION_LEVEL2 0x0000c000 -+#define D3DCOMPILE_OPTIMIZATION_LEVEL3 0x00008000 -+#define D3DCOMPILE_RESERVED16 0x00010000 -+#define D3DCOMPILE_RESERVED17 0x00020000 -+#define D3DCOMPILE_WARNINGS_ARE_ERRORS 0x00040000 -+#define D3DCOMPILE_RESOURCES_MAY_ALIAS 0x00080000 -+#define D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES 0x00100000 -+#define D3DCOMPILE_ALL_RESOURCES_BOUND 0x00200000 -+#define D3DCOMPILE_DEBUG_NAME_FOR_SOURCE 0x00400000 -+#define D3DCOMPILE_DEBUG_NAME_FOR_BINARY 0x00800000 -+ -+#define D3DCOMPILE_EFFECT_CHILD_EFFECT 0x00000001 -+#define D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS 0x00000002 -+ -+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST 0x00000000 -+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0 0x00000010 -+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1 0x00000020 -+ -+#define D3DCOMPILE_SECDATA_MERGE_UAV_SLOTS 0x00000001 -+#define D3DCOMPILE_SECDATA_PRESERVE_TEMPLATE_SLOTS 0x00000002 -+#define D3DCOMPILE_SECDATA_REQUIRE_TEMPLATE_MATCH 0x00000004 -+ -+typedef enum D3DCOMPILER_STRIP_FLAGS -+{ -+ D3DCOMPILER_STRIP_REFLECTION_DATA = 0x00000001, -+ D3DCOMPILER_STRIP_DEBUG_INFO = 0x00000002, -+ D3DCOMPILER_STRIP_TEST_BLOBS = 0x00000004, -+ D3DCOMPILER_STRIP_PRIVATE_DATA = 0x00000008, -+ D3DCOMPILER_STRIP_ROOT_SIGNATURE = 0x00000010, -+ D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff, -+} D3DCOMPILER_STRIP_FLAGS; -+ -+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); -+HRESULT WINAPI D3DCompile2(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, UINT secondary_flags, -+ const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, -+ ID3DBlob **error_messages); -+HRESULT WINAPI D3DCreateBlob(SIZE_T size, ID3DBlob **blob); -+HRESULT WINAPI D3DGetBlobPart(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob); -+HRESULT WINAPI D3DGetDebugInfo(const void *data, SIZE_T data_size, ID3DBlob **blob); -+HRESULT WINAPI D3DGetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+HRESULT WINAPI D3DGetInputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+HRESULT WINAPI D3DGetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename, const D3D_SHADER_MACRO *macros, -+ ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages); -+HRESULT WINAPI D3DStripShader(const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob); -+ -+#endif /* __D3DCOMPILER_H__ */ -+#endif /* __VKD3D_D3DCOMPILER_H */ -diff --git a/libs/vkd3d/include/vkd3d_d3dcompiler_types.h b/libs/vkd3d/include/vkd3d_d3dcompiler_types.h -new file mode 100644 -index 00000000000..b3a47cdd912 ---- /dev/null -+++ b/libs/vkd3d/include/vkd3d_d3dcompiler_types.h -@@ -0,0 +1,45 @@ -+/* -+ * Copyright 2010 Matteo Bruni for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_D3DCOMPILER_TYPES_H -+#define __VKD3D_D3DCOMPILER_TYPES_H -+#ifndef __D3DCOMPILER_H__ -+ -+typedef enum D3D_BLOB_PART -+{ -+ D3D_BLOB_INPUT_SIGNATURE_BLOB, -+ D3D_BLOB_OUTPUT_SIGNATURE_BLOB, -+ D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, -+ D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB, -+ D3D_BLOB_ALL_SIGNATURE_BLOB, -+ D3D_BLOB_DEBUG_INFO, -+ D3D_BLOB_LEGACY_SHADER, -+ D3D_BLOB_XNA_PREPASS_SHADER, -+ D3D_BLOB_XNA_SHADER, -+ D3D_BLOB_PDB, -+ D3D_BLOB_PRIVATE_DATA, -+ D3D_BLOB_ROOT_SIGNATURE, -+ D3D_BLOB_DEBUG_NAME, -+ D3D_BLOB_TEST_ALTERNATE_SHADER = 0x8000, -+ D3D_BLOB_TEST_COMPILE_DETAILS, -+ D3D_BLOB_TEST_COMPILE_PERF, -+ D3D_BLOB_TEST_COMPILE_REPORT -+} D3D_BLOB_PART; -+ -+#endif /* __D3DCOMPILER_H__ */ -+#endif /* __VKD3D_D3DCOMPILER_TYPES_H */ -diff --git a/libs/vkd3d/include/vkd3d_shader.h b/libs/vkd3d/include/vkd3d_shader.h -index 01356ce3931..66a7de9b571 100644 ---- a/libs/vkd3d/include/vkd3d_shader.h -+++ b/libs/vkd3d/include/vkd3d_shader.h -@@ -96,6 +96,11 @@ enum vkd3d_shader_structure_type - * \since 1.9 - */ - VKD3D_SHADER_STRUCTURE_TYPE_VARYING_MAP_INFO, -+ /** -+ * The structure is a vkd3d_shader_scan_combined_resource_sampler_info structure. -+ * \since 1.10 -+ */ -+ VKD3D_SHADER_STRUCTURE_TYPE_SCAN_COMBINED_RESOURCE_SAMPLER_INFO, - - VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_STRUCTURE_TYPE), - }; -@@ -154,6 +159,40 @@ enum vkd3d_shader_compile_option_pack_matrix_order - VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER), - }; - -+/** Individual options to enable various backward compatibility features. \since 1.10 */ -+enum vkd3d_shader_compile_option_backward_compatibility -+{ -+ /** -+ * Causes compiler to convert SM1-3 semantics to corresponding System Value semantics, -+ * when compiling HLSL sources for SM4+ targets. -+ * -+ * This option does the following conversions: -+ * -+ * - POSITION to SV_Position for vertex shader outputs, pixel shader inputs, -+ * and geometry shader inputs and outputs; -+ * - COLORN to SV_TargetN for pixel shader outputs; -+ * - DEPTH to SV_Depth for pixel shader outputs. -+ */ -+ VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES = 0x00000001, -+ -+ VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY), -+}; -+ -+/** -+ * Determines the origin of fragment coordinates. -+ * -+ * \since 1.10 -+ */ -+enum vkd3d_shader_compile_option_fragment_coordinate_origin -+{ -+ /** Fragment coordinates originate from the upper-left. This is the -+ * default; it's also the only value supported by Vulkan environments. */ -+ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, -+ /** Fragment coordinates originate from the lower-left. This matches the -+ * traditional behaviour of OpenGL environments. */ -+ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, -+}; -+ - enum vkd3d_shader_compile_option_name - { - /** -@@ -193,6 +232,24 @@ enum vkd3d_shader_compile_option_name - * \since 1.9 - */ - VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER = 0x00000007, -+ /** -+ * This option is used to enable various backward compatibility features. -+ * -+ * \a value is a mask of values from enum vkd3d_shader_compile_option_backward_compatibility. -+ * -+ * \since 1.10 -+ */ -+ VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY = 0x00000008, -+ /** -+ * This option specifies the origin of fragment coordinates for SPIR-V -+ * targets. -+ * -+ * \a value is a member of enum -+ * vkd3d_shader_compile_option_fragment_coordinate_origin. -+ * -+ * \since 1.10 -+ */ -+ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN = 0x00000009, - - VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_NAME), - }; -@@ -1383,19 +1440,33 @@ struct vkd3d_shader_descriptor_info - * - * This structure extends vkd3d_shader_compile_info. - * -- * When scanning a legacy Direct3D shader, vkd3d-shader enumerates each -- * constant register set used by the shader as a single constant buffer -- * descriptor, as follows: -- * - The \ref vkd3d_shader_descriptor_info.type field is set to -- * VKD3D_SHADER_DESCRIPTOR_TYPE_CBV. -- * - The \ref vkd3d_shader_descriptor_info.register_space field is set to zero. -- * - The \ref vkd3d_shader_descriptor_info.register_index field is set to a -- * member of enum vkd3d_shader_d3dbc_constant_register denoting which set -- * is used. -- * - The \ref vkd3d_shader_descriptor_info.count field is set to one. -- * -- * In summary, there may be up to three such descriptors, one for each register -- * set used by the shader: float, integer, and boolean. -+ * When scanning a legacy Direct3D shader, vkd3d-shader enumerates descriptors -+ * as follows: -+ * -+ * - Each constant register set used by the shader is scanned as a single -+ * constant buffer descriptor. -+ * There may therefore be up to three such descriptors, one for each register -+ * set used by the shader: float, integer, and boolean. -+ * The fields are set as follows: -+ * * The \ref vkd3d_shader_descriptor_info.type field is set to -+ * VKD3D_SHADER_DESCRIPTOR_TYPE_CBV. -+ * * The \ref vkd3d_shader_descriptor_info.register_space field is set to zero. -+ * * The \ref vkd3d_shader_descriptor_info.register_index field is set to a -+ * member of enum vkd3d_shader_d3dbc_constant_register denoting which set -+ * is used. -+ * * The \ref vkd3d_shader_descriptor_info.count field is set to one. -+ * - Each sampler used by the shader is scanned as two separate descriptors, -+ * one representing the texture, and one representing the sampler state. -+ * If desired, these may be mapped back into a single combined sampler using -+ * struct vkd3d_shader_combined_resource_sampler. -+ * The fields are set as follows: -+ * * The \ref vkd3d_shader_descriptor_info.type field is set to -+ * VKD3D_SHADER_DESCRIPTOR_TYPE_SRV and VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER -+ * respectively. -+ * * The \ref vkd3d_shader_descriptor_info.register_space field is set to zero. -+ * * The \ref vkd3d_shader_descriptor_info.register_index field is set to the -+ * binding index of the original sampler, for both descriptors. -+ * * The \ref vkd3d_shader_descriptor_info.count field is set to one. - */ - struct vkd3d_shader_scan_descriptor_info - { -@@ -1412,6 +1483,53 @@ struct vkd3d_shader_scan_descriptor_info - unsigned int descriptor_count; - }; - -+/** -+ * This structure describes a single resource-sampler pair. It is returned as -+ * part of struct vkd3d_shader_scan_combined_resource_sampler_info. -+ * -+ * \since 1.10 -+ */ -+struct vkd3d_shader_combined_resource_sampler_info -+{ -+ unsigned int resource_space; -+ unsigned int resource_index; -+ unsigned int sampler_space; -+ unsigned int sampler_index; -+}; -+ -+/** -+ * A chained structure describing the resource-sampler pairs used by a shader. -+ * -+ * This structure extends vkd3d_shader_compile_info. -+ * -+ * The information returned in this structure can be used to populate the -+ * \ref vkd3d_shader_interface_info.combined_samplers field. This is -+ * particularly useful when targeting environments without separate binding -+ * points for samplers and resources, like OpenGL. -+ * -+ * No resource-sampler pairs are returned for dynamic accesses to -+ * resource/sampler descriptor arrays, as can occur in Direct3D shader model -+ * 5.1 shaders. -+ * -+ * Members of this structure are allocated by vkd3d-shader and should be freed -+ * with vkd3d_shader_free_scan_combined_resource_sampler_info() when no longer -+ * needed. -+ * -+ * \since 1.10 -+ */ -+struct vkd3d_shader_scan_combined_resource_sampler_info -+{ -+ /** Must be set to VKD3D_SHADER_STRUCTURE_TYPE_SCAN_COMBINED_RESOURCE_SAMPLER_INFO. */ -+ enum vkd3d_shader_structure_type type; -+ /** Optional pointer to a structure containing further parameters. */ -+ const void *next; -+ -+ /** Pointer to an array of resource-sampler pairs. */ -+ struct vkd3d_shader_combined_resource_sampler_info *combined_samplers; -+ /** The number of resource-sampler pairs in \ref combined_samplers. */ -+ unsigned int combined_sampler_count; -+}; -+ - /** - * Data type of a shader varying, returned as part of struct - * vkd3d_shader_signature_element. -@@ -2313,6 +2431,21 @@ VKD3D_SHADER_API void vkd3d_shader_build_varying_map(const struct vkd3d_shader_s - const struct vkd3d_shader_signature *input_signature, - unsigned int *count, struct vkd3d_shader_varying_map *varyings); - -+/** -+ * Free members of struct vkd3d_shader_scan_combined_resource_sampler_info -+ * allocated by vkd3d_shader_scan(). -+ * -+ * This function may free members of -+ * vkd3d_shader_scan_combined_resource_sampler_info, but does not free the -+ * structure itself. -+ * -+ * \param info Combined resource-sampler information to free. -+ * -+ * \since 1.10 -+ */ -+VKD3D_SHADER_API void vkd3d_shader_free_scan_combined_resource_sampler_info( -+ struct vkd3d_shader_scan_combined_resource_sampler_info *info); -+ - #endif /* VKD3D_SHADER_NO_PROTOTYPES */ - - /** Type of vkd3d_shader_get_version(). */ -@@ -2385,6 +2518,10 @@ typedef void (*PFN_vkd3d_shader_build_varying_map)(const struct vkd3d_shader_sig - /** Type of vkd3d_shader_free_scan_signature_info(). \since 1.9 */ - typedef void (*PFN_vkd3d_shader_free_scan_signature_info)(struct vkd3d_shader_scan_signature_info *info); - -+/** Type of vkd3d_shader_free_scan_combined_resource_sampler_info(). \since 1.10 */ -+typedef void (*PFN_vkd3d_shader_free_scan_combined_resource_sampler_info)( -+ struct vkd3d_shader_scan_combined_resource_sampler_info *info); -+ - #ifdef __cplusplus - } - #endif /* __cplusplus */ -diff --git a/libs/vkd3d/include/vkd3d_utils.h b/libs/vkd3d/include/vkd3d_utils.h -new file mode 100644 -index 00000000000..686ddf386e7 ---- /dev/null -+++ b/libs/vkd3d/include/vkd3d_utils.h -@@ -0,0 +1,123 @@ -+/* -+ * Copyright 2016 Józef Kucia for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_UTILS_H -+#define __VKD3D_UTILS_H -+ -+#include -+#include -+ -+#ifndef VKD3D_UTILS_API_VERSION -+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_0 -+#endif -+ -+#ifdef __cplusplus -+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) -+#define VKD3D_INFINITE (~0u) -+ -+#ifdef LIBVKD3D_UTILS_SOURCE -+# define VKD3D_UTILS_API VKD3D_EXPORT -+#else -+# define VKD3D_UTILS_API VKD3D_IMPORT -+#endif -+ -+/* 1.0 */ -+VKD3D_UTILS_API HANDLE vkd3d_create_event(void); -+VKD3D_UTILS_API HRESULT vkd3d_signal_event(HANDLE event); -+VKD3D_UTILS_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds); -+VKD3D_UTILS_API void vkd3d_destroy_event(HANDLE event); -+ -+#define D3D12CreateDevice(a, b, c, d) D3D12CreateDeviceVKD3D(a, b, c, d, VKD3D_UTILS_API_VERSION) -+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer( -+ const void *data, SIZE_T data_size, REFIID iid, void **deserializer); -+VKD3D_UTILS_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug); -+VKD3D_UTILS_API HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, -+ D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob); -+ -+/* 1.2 */ -+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level, -+ REFIID iid, void **device, enum vkd3d_api_version api_version); -+VKD3D_UTILS_API HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, -+ SIZE_T data_size, REFIID iid, void **deserializer); -+VKD3D_UTILS_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, -+ ID3DBlob **blob, ID3DBlob **error_blob); -+ -+/* 1.3 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename, -+ const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, -+ const char *target, UINT flags, UINT effect_flags, ID3DBlob **shader, ID3DBlob **error_messages); -+VKD3D_UTILS_API HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename, -+ const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, -+ const char *target, UINT flags, UINT effect_flags, UINT secondary_flags, -+ const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, -+ ID3DBlob **error_messages); -+VKD3D_UTILS_API HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob); -+VKD3D_UTILS_API HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename, -+ const D3D_SHADER_MACRO *defines, ID3DInclude *include, -+ ID3DBlob **shader, ID3DBlob **error_messages); -+ -+/** -+ * Set a callback to be called when vkd3d-utils outputs debug logging. -+ * -+ * If NULL, or if this function has not been called, libvkd3d-utils will print -+ * all enabled log output to stderr. -+ * -+ * Calling this function will also set the log callback for libvkd3d and -+ * libvkd3d-shader. -+ * -+ * \param callback Callback function to set. -+ * -+ * \since 1.4 -+ */ -+VKD3D_UTILS_API void vkd3d_utils_set_log_callback(PFN_vkd3d_log callback); -+ -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DGetBlobPart(const void *data, -+ SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob); -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DGetDebugInfo(const void *data, SIZE_T data_size, ID3DBlob **blob); -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DGetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DGetInputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DGetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob); -+/** \since 1.10 */ -+VKD3D_UTILS_API HRESULT WINAPI D3DStripShader(const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob); -+ -+#ifdef __cplusplus -+} -+#endif /* __cplusplus */ -+ -+#endif /* __VKD3D_UTILS_H */ -diff --git a/libs/vkd3d/include/vkd3d_windows.h b/libs/vkd3d/include/vkd3d_windows.h -new file mode 100644 -index 00000000000..7b0e972d828 ---- /dev/null -+++ b/libs/vkd3d/include/vkd3d_windows.h -@@ -0,0 +1,289 @@ -+/* -+ * Copyright 2016 Józef Kucia for CodeWeavers -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2.1 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the Free Software -+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -+ */ -+ -+#ifndef __VKD3D_WINDOWS_H -+#define __VKD3D_WINDOWS_H -+#ifndef _INC_WINDOWS -+ -+/* Nameless unions */ -+#ifndef __C89_NAMELESS -+# ifdef NONAMELESSUNION -+# define __C89_NAMELESS -+# define __C89_NAMELESSUNIONNAME u -+# else -+# define __C89_NAMELESS -+# define __C89_NAMELESSUNIONNAME -+# endif /* NONAMELESSUNION */ -+#endif /* __C89_NAMELESS */ -+ -+#if !defined(_WIN32) || defined(__WIDL__) -+ -+# if !defined(__WIDL__) -+# if !defined(VKD3D_WIN32_WCHAR) -+# include -+# endif -+# include -+# endif -+ -+# ifdef __GNUC__ -+# define DECLSPEC_ALIGN(x) __attribute__((aligned(x))) -+# endif -+ -+/* HRESULT */ -+typedef int HRESULT; -+# define SUCCEEDED(hr) ((HRESULT)(hr) >= 0) -+# define FAILED(hr) ((HRESULT)(hr) < 0) -+ -+# define _HRESULT_TYPEDEF_(x) ((HRESULT)x) -+ -+# define S_OK _HRESULT_TYPEDEF_(0) -+# define S_FALSE _HRESULT_TYPEDEF_(1) -+ -+# define E_NOTIMPL _HRESULT_TYPEDEF_(0x80004001) -+# define E_NOINTERFACE _HRESULT_TYPEDEF_(0x80004002) -+# define E_POINTER _HRESULT_TYPEDEF_(0x80004003) -+# define E_ABORT _HRESULT_TYPEDEF_(0x80004004) -+# define E_FAIL _HRESULT_TYPEDEF_(0x80004005) -+# define E_OUTOFMEMORY _HRESULT_TYPEDEF_(0x8007000E) -+# define E_INVALIDARG _HRESULT_TYPEDEF_(0x80070057) -+ -+# define DXGI_ERROR_NOT_FOUND _HRESULT_TYPEDEF_(0x887a0002) -+# define DXGI_ERROR_MORE_DATA _HRESULT_TYPEDEF_(0x887a0003) -+# define DXGI_ERROR_UNSUPPORTED _HRESULT_TYPEDEF_(0x887a0004) -+ -+# define D3DERR_INVALIDCALL _HRESULT_TYPEDEF_(0x8876086c) -+ -+/* Basic types */ -+typedef unsigned char BYTE; -+typedef unsigned int DWORD; -+typedef int INT; -+typedef unsigned int UINT; -+typedef int LONG; -+typedef unsigned int ULONG; -+typedef float FLOAT; -+typedef LONG BOOL; -+ -+/* Assuming LP64 model */ -+typedef char INT8; -+typedef unsigned char UINT8; -+typedef short INT16; -+typedef unsigned short UINT16; -+typedef int INT32; -+typedef unsigned int UINT32; -+# if defined(__WIDL__) -+typedef __int64 INT64; -+typedef unsigned __int64 UINT64; -+# else -+typedef int64_t DECLSPEC_ALIGN(8) INT64; -+typedef uint64_t DECLSPEC_ALIGN(8) UINT64; -+# endif -+typedef INT64 LONG64; -+typedef long LONG_PTR; -+typedef unsigned long ULONG_PTR; -+ -+typedef ULONG_PTR SIZE_T; -+ -+# ifdef VKD3D_WIN32_WCHAR -+typedef unsigned short WCHAR; -+# else -+typedef wchar_t WCHAR; -+# endif /* VKD3D_WIN32_WCHAR */ -+typedef void *HANDLE; -+ -+/* GUID */ -+# ifdef __WIDL__ -+typedef struct -+{ -+ unsigned long Data1; -+ unsigned short Data2; -+ unsigned short Data3; -+ unsigned char Data4[8]; -+} GUID; -+# else -+typedef struct _GUID -+{ -+ unsigned int Data1; -+ unsigned short Data2; -+ unsigned short Data3; -+ unsigned char Data4[8]; -+} GUID; -+# endif -+ -+typedef GUID IID; -+typedef GUID CLSID; -+typedef GUID UUID; -+ -+# 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 = \ -+ { 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 = \ -+ { 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; -+# endif /* INITGUID */ -+ -+/* __uuidof emulation */ -+#if defined(__cplusplus) && !defined(_MSC_VER) -+ -+extern "C++" -+{ -+ template const GUID &__vkd3d_uuidof(); -+} -+ -+# define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ -+ extern "C++" \ -+ { \ -+ template<> inline const GUID &__vkd3d_uuidof() \ -+ { \ -+ static const IID __uuid_inst = {l, w1, w2, {b1, b2, b3, b4, b5, b6, b7, b8}}; \ -+ return __uuid_inst; \ -+ } \ -+ template<> inline const GUID &__vkd3d_uuidof() \ -+ { \ -+ return __vkd3d_uuidof(); \ -+ } \ -+ } -+ -+# define __uuidof(type) __vkd3d_uuidof() -+#else -+# define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) -+#endif /* defined(__cplusplus) && !defined(_MSC_VER) */ -+ -+typedef struct SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES; -+#endif /* !defined(_WIN32) || defined(__WIDL__) */ -+ -+ -+#ifndef _WIN32 -+# include -+# include -+# include -+ -+# define COM_NO_WINDOWS_H -+ -+# define FORCEINLINE inline -+ -+# define CONTAINING_RECORD(address, type, field) \ -+ ((type *)((char *)(address) - offsetof(type, field))) -+ -+# ifdef __x86_64__ -+# define __stdcall __attribute__((ms_abi)) -+# else -+# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2)) || defined(__APPLE__) -+# define __stdcall __attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__)) -+# else -+# define __stdcall __attribute__((__stdcall__)) -+# endif -+# endif -+ -+# define WINAPI __stdcall -+# define STDMETHODCALLTYPE __stdcall -+ -+# ifdef __GNUC__ -+# define DECLSPEC_SELECTANY __attribute__((weak)) -+# endif -+ -+/* Macros for COM interfaces */ -+# define interface struct -+# define BEGIN_INTERFACE -+# define END_INTERFACE -+# define MIDL_INTERFACE(x) struct -+ -+# ifdef __cplusplus -+# define EXTERN_C extern "C" -+# else -+# define EXTERN_C extern -+# endif -+ -+# define CONST_VTBL const -+ -+# define TRUE 1 -+# define FALSE 0 -+ -+# if defined(__cplusplus) && !defined(CINTERFACE) -+# define REFIID const IID & -+# define REFGUID const GUID & -+# define REFCLSID const CLSID & -+# else -+# define REFIID const IID * const -+# define REFGUID const GUID * const -+# define REFCLSID const CLSID * const -+# endif -+ -+#if defined(__cplusplus) && !defined(CINTERFACE) -+# define IsEqualGUID(guid1, guid2) (!memcmp(&(guid1), &(guid2), sizeof(GUID))) -+#else -+# define IsEqualGUID(guid1, guid2) (!memcmp(guid1, guid2, sizeof(GUID))) -+#endif -+ -+#elif !defined(__WIDL__) -+ -+# include -+ -+#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 -+# define min(a, b) (((a) <= (b)) ? (a) : (b)) -+# endif -+ -+# ifndef max -+# define max(a, b) (((a) >= (b)) ? (a) : (b)) -+# endif -+#endif /* NOMINMAX */ -+ -+#ifndef DEFINE_ENUM_FLAG_OPERATORS -+#ifdef __cplusplus -+# define DEFINE_ENUM_FLAG_OPERATORS(type) \ -+extern "C++" \ -+{ \ -+ inline type operator &(type x, type y) { return (type)((int)x & (int)y); } \ -+ inline type operator &=(type &x, type y) { return (type &)((int &)x &= (int)y); } \ -+ inline type operator ~(type x) { return (type)~(int)x; } \ -+ inline type operator |(type x, type y) { return (type)((int)x | (int)y); } \ -+ inline type operator |=(type &x, type y) { return (type &)((int &)x |= (int)y); } \ -+ inline type operator ^(type x, type y) { return (type)((int)x ^ (int)y); } \ -+ inline type operator ^=(type &x, type y) { return (type &)((int &)x ^= (int)y); } \ -+} -+#else -+# define DEFINE_ENUM_FLAG_OPERATORS(type) -+#endif -+#endif /* DEFINE_ENUM_FLAG_OPERATORS */ -+ -+#endif /* _INC_WINDOWS */ -+#endif /* __VKD3D_WINDOWS_H */ -diff --git a/libs/vkd3d/libs/vkd3d-common/blob.c b/libs/vkd3d/libs/vkd3d-common/blob.c -index 30205088b1b..fa2812619ac 100644 ---- a/libs/vkd3d/libs/vkd3d-common/blob.c -+++ b/libs/vkd3d/libs/vkd3d-common/blob.c -@@ -17,6 +17,8 @@ - */ - - #define COBJMACROS -+ -+#define CONST_VTABLE - #include "vkd3d.h" - #include "vkd3d_blob.h" - #include "vkd3d_debug.h" -diff --git a/libs/vkd3d/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d/libs/vkd3d-shader/d3d_asm.c -index f0c386f1b3a..82d1d71d9d3 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/d3d_asm.c -+++ b/libs/vkd3d/libs/vkd3d-shader/d3d_asm.c -@@ -106,9 +106,9 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_DEFAULT ] = "default", - [VKD3DSIH_DEFB ] = "defb", - [VKD3DSIH_DEFI ] = "defi", -- [VKD3DSIH_DEQ ] = "deq", -+ [VKD3DSIH_DEQO ] = "deq", - [VKD3DSIH_DFMA ] = "dfma", -- [VKD3DSIH_DGE ] = "dge", -+ [VKD3DSIH_DGEO ] = "dge", - [VKD3DSIH_DISCARD ] = "discard", - [VKD3DSIH_DIV ] = "div", - [VKD3DSIH_DLT ] = "dlt", -@@ -140,7 +140,8 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_ENDLOOP ] = "endloop", - [VKD3DSIH_ENDREP ] = "endrep", - [VKD3DSIH_ENDSWITCH ] = "endswitch", -- [VKD3DSIH_EQ ] = "eq", -+ [VKD3DSIH_EQO ] = "eq", -+ [VKD3DSIH_EQU ] = "eq_unord", - [VKD3DSIH_EVAL_CENTROID ] = "eval_centroid", - [VKD3DSIH_EVAL_SAMPLE_INDEX ] = "eval_sample_index", - [VKD3DSIH_EXP ] = "exp", -@@ -152,6 +153,7 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_FIRSTBIT_LO ] = "firstbit_lo", - [VKD3DSIH_FIRSTBIT_SHI ] = "firstbit_shi", - [VKD3DSIH_FRC ] = "frc", -+ [VKD3DSIH_FREM ] = "frem", - [VKD3DSIH_FTOD ] = "ftod", - [VKD3DSIH_FTOI ] = "ftoi", - [VKD3DSIH_FTOU ] = "ftou", -@@ -163,13 +165,15 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_GATHER4_PO_C_S ] = "gather4_po_c_s", - [VKD3DSIH_GATHER4_PO_S ] = "gather4_po_s", - [VKD3DSIH_GATHER4_S ] = "gather4_s", -- [VKD3DSIH_GE ] = "ge", -+ [VKD3DSIH_GEO ] = "ge", -+ [VKD3DSIH_GEU ] = "ge_unord", - [VKD3DSIH_HS_CONTROL_POINT_PHASE ] = "hs_control_point_phase", - [VKD3DSIH_HS_DECLS ] = "hs_decls", - [VKD3DSIH_HS_FORK_PHASE ] = "hs_fork_phase", - [VKD3DSIH_HS_JOIN_PHASE ] = "hs_join_phase", - [VKD3DSIH_IADD ] = "iadd", - [VKD3DSIH_IBFE ] = "ibfe", -+ [VKD3DSIH_IDIV ] = "idiv", - [VKD3DSIH_IEQ ] = "ieq", - [VKD3DSIH_IF ] = "if", - [VKD3DSIH_IFC ] = "ifc", -@@ -197,6 +201,7 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_ISHR ] = "ishr", - [VKD3DSIH_ITOD ] = "itod", - [VKD3DSIH_ITOF ] = "itof", -+ [VKD3DSIH_ITOI ] = "itoi", - [VKD3DSIH_LABEL ] = "label", - [VKD3DSIH_LD ] = "ld", - [VKD3DSIH_LD2DMS ] = "ld2dms", -@@ -214,7 +219,8 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_LOGP ] = "logp", - [VKD3DSIH_LOOP ] = "loop", - [VKD3DSIH_LRP ] = "lrp", -- [VKD3DSIH_LT ] = "lt", -+ [VKD3DSIH_LTO ] = "lt", -+ [VKD3DSIH_LTU ] = "lt_unord", - [VKD3DSIH_M3x2 ] = "m3x2", - [VKD3DSIH_M3x3 ] = "m3x3", - [VKD3DSIH_M3x4 ] = "m3x4", -@@ -228,7 +234,8 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_MOVC ] = "movc", - [VKD3DSIH_MSAD ] = "msad", - [VKD3DSIH_MUL ] = "mul", -- [VKD3DSIH_NE ] = "ne", -+ [VKD3DSIH_NEO ] = "ne_ord", -+ [VKD3DSIH_NEU ] = "ne", - [VKD3DSIH_NOP ] = "nop", - [VKD3DSIH_NOT ] = "not", - [VKD3DSIH_NRM ] = "nrm", -@@ -304,6 +311,7 @@ static const char * const shader_opcode_names[] = - [VKD3DSIH_USHR ] = "ushr", - [VKD3DSIH_UTOD ] = "utod", - [VKD3DSIH_UTOF ] = "utof", -+ [VKD3DSIH_UTOU ] = "utou", - [VKD3DSIH_XOR ] = "xor", - }; - -@@ -358,11 +366,6 @@ struct vkd3d_d3d_asm_compiler - struct vkd3d_d3d_asm_colours colours; - }; - --static int shader_ver_ge(const struct vkd3d_shader_version *v, int major, int minor) --{ -- return v->major > major || (v->major == major && v->minor >= minor); --} -- - static int VKD3D_PRINTF_FUNC(2, 3) shader_addline(struct vkd3d_string_buffer *buffer, const char *format, ...) - { - va_list args; -@@ -391,13 +394,14 @@ static unsigned int shader_get_float_offset(enum vkd3d_shader_register_type regi - } - } - --static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, uint32_t global_flags) -+static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, -+ enum vkd3d_shader_global_flags global_flags) - { - unsigned int i; - - static const struct - { -- unsigned int flag; -+ enum vkd3d_shader_global_flags flag; - const char *name; - } - global_flag_info[] = -@@ -423,7 +427,7 @@ static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, ui - } - - if (global_flags) -- vkd3d_string_buffer_printf(&compiler->buffer, "unknown_flags(%#x)", global_flags); -+ vkd3d_string_buffer_printf(&compiler->buffer, "unknown_flags(%#"PRIx64")", (uint64_t)global_flags); - } - - static void shader_dump_sync_flags(struct vkd3d_d3d_asm_compiler *compiler, uint32_t sync_flags) -@@ -477,6 +481,11 @@ static void shader_dump_uav_flags(struct vkd3d_d3d_asm_compiler *compiler, uint3 - vkd3d_string_buffer_printf(&compiler->buffer, "_opc"); - uav_flags &= ~VKD3DSUF_ORDER_PRESERVING_COUNTER; - } -+ if (uav_flags & VKD3DSUF_RASTERISER_ORDERED_VIEW) -+ { -+ vkd3d_string_buffer_printf(&compiler->buffer, "_rov"); -+ uav_flags &= ~VKD3DSUF_RASTERISER_ORDERED_VIEW; -+ } - - if (uav_flags) - vkd3d_string_buffer_printf(&compiler->buffer, "_unknown_flags(%#x)", uav_flags); -@@ -637,7 +646,7 @@ static void shader_dump_decl_usage(struct vkd3d_d3d_asm_compiler *compiler, - { - struct vkd3d_string_buffer *buffer = &compiler->buffer; - -- if (semantic->resource.reg.reg.type == VKD3DSPR_SAMPLER) -+ if (semantic->resource.reg.reg.type == VKD3DSPR_COMBINED_SAMPLER) - { - switch (semantic->resource_type) - { -@@ -678,7 +687,7 @@ static void shader_dump_decl_usage(struct vkd3d_d3d_asm_compiler *compiler, - else - { - /* Pixel shaders 3.0 don't have usage semantics. */ -- if (!shader_ver_ge(&compiler->shader_version, 3, 0) -+ if (!vkd3d_shader_ver_ge(&compiler->shader_version, 3, 0) - && compiler->shader_version.type == VKD3D_SHADER_TYPE_PIXEL) - return; - else -@@ -880,9 +889,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - break; - - case VKD3DSPR_COLOROUT: -- shader_addline(buffer, "o"); -- if (!shader_ver_ge(&compiler->shader_version, 4, 0)) -- shader_addline(buffer, "C"); -+ shader_addline(buffer, "oC"); - break; - - case VKD3DSPR_DEPTHOUT: -@@ -904,7 +911,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - case VKD3DSPR_TEXCRDOUT: - /* Vertex shaders >= 3.0 use general purpose output registers - * (VKD3DSPR_OUTPUT), which can include an address token. */ -- if (shader_ver_ge(&compiler->shader_version, 3, 0)) -+ if (vkd3d_shader_ver_ge(&compiler->shader_version, 3, 0)) - shader_addline(buffer, "o"); - else - shader_addline(buffer, "oT"); -@@ -926,6 +933,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - shader_addline(buffer, "aL"); - break; - -+ case VKD3DSPR_COMBINED_SAMPLER: - case VKD3DSPR_SAMPLER: - shader_addline(buffer, "s"); - is_descriptor = true; -@@ -1066,6 +1074,14 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - shader_addline(buffer, "oStencilRef"); - break; - -+ case VKD3DSPR_UNDEF: -+ shader_addline(buffer, "undef"); -+ break; -+ -+ case VKD3DSPR_SSA: -+ shader_addline(buffer, "sr"); -+ break; -+ - default: - shader_addline(buffer, "", reg->type); - break; -@@ -1074,9 +1090,9 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - if (reg->type == VKD3DSPR_IMMCONST) - { - shader_addline(buffer, "%s(", compiler->colours.reset); -- switch (reg->immconst_type) -+ switch (reg->dimension) - { -- case VKD3D_IMMCONST_SCALAR: -+ case VSIR_DIMENSION_SCALAR: - switch (reg->data_type) - { - case VKD3D_DATA_FLOAT: -@@ -1096,7 +1112,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - } - break; - -- case VKD3D_IMMCONST_VEC4: -+ case VSIR_DIMENSION_VEC4: - switch (reg->data_type) - { - case VKD3D_DATA_FLOAT: -@@ -1126,7 +1142,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - break; - - default: -- shader_addline(buffer, "", reg->immconst_type); -+ shader_addline(buffer, "", reg->dimension); - break; - } - shader_addline(buffer, ")"); -@@ -1134,13 +1150,13 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - else if (reg->type == VKD3DSPR_IMMCONST64) - { - shader_addline(buffer, "%s(", compiler->colours.reset); -- /* A double2 vector is treated as a float4 vector in enum vkd3d_immconst_type. */ -- if (reg->immconst_type == VKD3D_IMMCONST_SCALAR || reg->immconst_type == VKD3D_IMMCONST_VEC4) -+ /* A double2 vector is treated as a float4 vector in enum vsir_dimension. */ -+ if (reg->dimension == VSIR_DIMENSION_SCALAR || reg->dimension == VSIR_DIMENSION_VEC4) - { - if (reg->data_type == VKD3D_DATA_DOUBLE) - { - shader_print_double_literal(compiler, "", reg->u.immconst_double[0], ""); -- if (reg->immconst_type == VKD3D_IMMCONST_VEC4) -+ if (reg->dimension == VSIR_DIMENSION_VEC4) - shader_print_double_literal(compiler, ", ", reg->u.immconst_double[1], ""); - } - else -@@ -1150,17 +1166,18 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - } - else - { -- shader_addline(buffer, "", reg->immconst_type); -+ shader_addline(buffer, "", reg->dimension); - } - shader_addline(buffer, ")"); - } - else if (reg->type != VKD3DSPR_RASTOUT - && reg->type != VKD3DSPR_MISCTYPE -- && reg->type != VKD3DSPR_NULL) -+ && reg->type != VKD3DSPR_NULL -+ && reg->type != VKD3DSPR_DEPTHOUT) - { - if (offset != ~0u) - { -- bool is_sm_5_1 = shader_ver_ge(&compiler->shader_version, 5, 1); -+ bool is_sm_5_1 = vkd3d_shader_ver_ge(&compiler->shader_version, 5, 1); - - if (reg->idx[0].rel_addr || reg->type == VKD3DSPR_IMMCONSTBUFFER - || reg->type == VKD3DSPR_INCONTROLPOINT || (reg->type == VKD3DSPR_INPUT -@@ -1181,7 +1198,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const - { - shader_print_subscript_range(compiler, reg->idx[1].offset, reg->idx[2].offset); - } -- else -+ else if (reg->type != VKD3DSPR_SSA) - { - /* For descriptors in sm < 5.1 we move the reg->idx values up one slot - * to normalise with 5.1. -@@ -1256,7 +1273,7 @@ static void shader_dump_dst_param(struct vkd3d_d3d_asm_compiler *compiler, - - shader_dump_register(compiler, ¶m->reg, is_declaration); - -- if (write_mask) -+ if (write_mask && param->reg.dimension == VSIR_DIMENSION_VEC4) - { - static const char write_mask_chars[] = "xyzw"; - -@@ -1322,7 +1339,7 @@ static void shader_dump_src_param(struct vkd3d_d3d_asm_compiler *compiler, - } - - if (param->reg.type != VKD3DSPR_IMMCONST && param->reg.type != VKD3DSPR_IMMCONST64 -- && param->reg.type != VKD3DSPR_SAMPLER) -+ && param->reg.dimension == VSIR_DIMENSION_VEC4) - { - unsigned int swizzle_x = vkd3d_swizzle_get_component(swizzle, 0); - unsigned int swizzle_y = vkd3d_swizzle_get_component(swizzle, 1); -@@ -1374,7 +1391,7 @@ static void shader_dump_ins_modifiers(struct vkd3d_d3d_asm_compiler *compiler, - if (mmask & VKD3DSPDM_PARTIALPRECISION) shader_addline(buffer, "_pp"); - if (mmask & VKD3DSPDM_MSAMPCENTROID) shader_addline(buffer, "_centroid"); - -- mmask &= ~(VKD3DSPDM_SATURATE | VKD3DSPDM_PARTIALPRECISION | VKD3DSPDM_MSAMPCENTROID); -+ mmask &= ~VKD3DSPDM_MASK; - if (mmask) FIXME("Unrecognised modifier %#x.\n", mmask); - } - -@@ -1556,7 +1573,7 @@ static void shader_dump_instruction_flags(struct vkd3d_d3d_asm_compiler *compile - break; - - case VKD3DSIH_TEX: -- if (shader_ver_ge(&compiler->shader_version, 2, 0) && (ins->flags & VKD3DSI_TEXLD_PROJECT)) -+ if (vkd3d_shader_ver_ge(&compiler->shader_version, 2, 0) && (ins->flags & VKD3DSI_TEXLD_PROJECT)) - shader_addline(buffer, "p"); - break; - -@@ -1568,7 +1585,7 @@ static void shader_dump_instruction_flags(struct vkd3d_d3d_asm_compiler *compile - - static void shader_dump_register_space(struct vkd3d_d3d_asm_compiler *compiler, unsigned int register_space) - { -- if (shader_ver_ge(&compiler->shader_version, 5, 1)) -+ if (vkd3d_shader_ver_ge(&compiler->shader_version, 5, 1)) - shader_print_uint_literal(compiler, ", space=", register_space, ""); - } - -@@ -1578,6 +1595,36 @@ static void shader_print_opcode(struct vkd3d_d3d_asm_compiler *compiler, enum vk - shader_opcode_names[opcode], compiler->colours.reset); - } - -+static void shader_dump_icb(struct vkd3d_d3d_asm_compiler *compiler, -+ const struct vkd3d_shader_immediate_constant_buffer *icb) -+{ -+ struct vkd3d_string_buffer *buffer = &compiler->buffer; -+ unsigned int i, j; -+ -+ vkd3d_string_buffer_printf(buffer, " {\n"); -+ if (icb->component_count == 1) -+ { -+ for (i = 0; i < icb->element_count; ) -+ { -+ for (j = 0; i < icb->element_count && j < 4; ++i, ++j) -+ shader_print_hex_literal(compiler, !j ? " " : ", ", icb->data[i], ""); -+ vkd3d_string_buffer_printf(buffer, "\n"); -+ } -+ } -+ else -+ { -+ assert(icb->component_count == VKD3D_VEC4_SIZE); -+ for (i = 0; i < icb->element_count; ++i) -+ { -+ shader_print_hex_literal(compiler, " {", icb->data[4 * i + 0], ""); -+ shader_print_hex_literal(compiler, ", ", icb->data[4 * i + 1], ""); -+ shader_print_hex_literal(compiler, ", ", icb->data[4 * i + 2], ""); -+ shader_print_hex_literal(compiler, ", ", icb->data[4 * i + 3], "},\n"); -+ } -+ } -+ shader_addline(buffer, "}"); -+} -+ - static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, - const struct vkd3d_shader_instruction *ins) - { -@@ -1612,8 +1659,10 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, - case VKD3DSIH_DCL_CONSTANT_BUFFER: - vkd3d_string_buffer_printf(buffer, " "); - shader_dump_register(compiler, &ins->declaration.cb.src.reg, true); -- if (shader_ver_ge(&compiler->shader_version, 5, 1)) -+ if (vkd3d_shader_ver_ge(&compiler->shader_version, 6, 0)) - shader_print_subscript(compiler, ins->declaration.cb.size, NULL); -+ else if (vkd3d_shader_ver_ge(&compiler->shader_version, 5, 1)) -+ shader_print_subscript(compiler, ins->declaration.cb.size / VKD3D_VEC4_SIZE / sizeof(float), NULL); - shader_addline(buffer, ", %s", - ins->flags & VKD3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed"); - shader_dump_register_space(compiler, ins->declaration.cb.range.space); -@@ -1629,7 +1678,7 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, - - case VKD3DSIH_DCL_GLOBAL_FLAGS: - vkd3d_string_buffer_printf(buffer, " "); -- shader_dump_global_flags(compiler, ins->flags); -+ shader_dump_global_flags(compiler, ins->declaration.global_flags); - break; - - case VKD3DSIH_DCL_HS_MAX_TESSFACTOR: -@@ -1637,15 +1686,7 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, - break; - - case VKD3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER: -- vkd3d_string_buffer_printf(buffer, " {\n"); -- for (i = 0; i < ins->declaration.icb->vec4_count; ++i) -- { -- shader_print_hex_literal(compiler, " {", ins->declaration.icb->data[4 * i + 0], ""); -- shader_print_hex_literal(compiler, ", ", ins->declaration.icb->data[4 * i + 1], ""); -- shader_print_hex_literal(compiler, ", ", ins->declaration.icb->data[4 * i + 2], ""); -- shader_print_hex_literal(compiler, ", ", ins->declaration.icb->data[4 * i + 3], "},\n"); -- } -- shader_addline(buffer, "}"); -+ shader_dump_icb(compiler, ins->declaration.icb); - break; - - case VKD3DSIH_DCL_INDEX_RANGE: -@@ -1659,6 +1700,10 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, - ins->declaration.indexable_temp.register_idx, compiler->colours.reset); - shader_print_subscript(compiler, ins->declaration.indexable_temp.register_size, NULL); - shader_print_uint_literal(compiler, ", ", ins->declaration.indexable_temp.component_count, ""); -+ if (ins->declaration.indexable_temp.alignment) -+ shader_print_uint_literal(compiler, ", align ", ins->declaration.indexable_temp.alignment, ""); -+ if (ins->declaration.indexable_temp.initialiser) -+ shader_dump_icb(compiler, ins->declaration.indexable_temp.initialiser); - break; - - case VKD3DSIH_DCL_INPUT_PS: -diff --git a/libs/vkd3d/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d/libs/vkd3d-shader/d3dbc.c -index 1fd5ab2446d..3d139416b61 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/d3dbc.c -+++ b/libs/vkd3d/libs/vkd3d-shader/d3dbc.c -@@ -261,7 +261,7 @@ static const struct vkd3d_sm1_opcode_info vs_opcode_table[] = - {VKD3D_SM1_OP_M3x3, 1, 2, VKD3DSIH_M3x3}, - {VKD3D_SM1_OP_M3x2, 1, 2, VKD3DSIH_M3x2}, - /* Declarations */ -- {VKD3D_SM1_OP_DCL, 0, 2, VKD3DSIH_DCL}, -+ {VKD3D_SM1_OP_DCL, 0, 0, VKD3DSIH_DCL}, - /* Constant definitions */ - {VKD3D_SM1_OP_DEF, 1, 1, VKD3DSIH_DEF}, - {VKD3D_SM1_OP_DEFB, 1, 1, VKD3DSIH_DEFB}, -@@ -328,7 +328,7 @@ static const struct vkd3d_sm1_opcode_info ps_opcode_table[] = - {VKD3D_SM1_OP_M3x3, 1, 2, VKD3DSIH_M3x3}, - {VKD3D_SM1_OP_M3x2, 1, 2, VKD3DSIH_M3x2}, - /* Declarations */ -- {VKD3D_SM1_OP_DCL, 0, 2, VKD3DSIH_DCL}, -+ {VKD3D_SM1_OP_DCL, 0, 0, VKD3DSIH_DCL}, - /* Constant definitions */ - {VKD3D_SM1_OP_DEF, 1, 1, VKD3DSIH_DEF}, - {VKD3D_SM1_OP_DEFB, 1, 1, VKD3DSIH_DEFB}, -@@ -402,16 +402,6 @@ static uint32_t read_u32(const uint32_t **ptr) - return *(*ptr)++; - } - --static bool shader_ver_ge(const struct vkd3d_shader_version *v, unsigned int major, unsigned int minor) --{ -- return v->major > major || (v->major == major && v->minor >= minor); --} -- --static bool shader_ver_le(const struct vkd3d_shader_version *v, unsigned int major, unsigned int minor) --{ -- return v->major < major || (v->major == major && v->minor <= minor); --} -- - static bool has_relative_address(uint32_t param) - { - enum vkd3d_sm1_address_mode_type address_mode; -@@ -434,8 +424,8 @@ static const struct vkd3d_sm1_opcode_info *shader_sm1_get_opcode_info( - return NULL; - - if (opcode == info->sm1_opcode -- && shader_ver_ge(&sm1->p.shader_version, info->min_version.major, info->min_version.minor) -- && (shader_ver_le(&sm1->p.shader_version, info->max_version.major, info->max_version.minor) -+ && vkd3d_shader_ver_ge(&sm1->p.shader_version, info->min_version.major, info->min_version.minor) -+ && (vkd3d_shader_ver_le(&sm1->p.shader_version, info->max_version.major, info->max_version.minor) - || !info->max_version.major)) - return info; - } -@@ -457,18 +447,20 @@ static uint32_t swizzle_from_sm1(uint32_t swizzle) - static void shader_sm1_parse_src_param(uint32_t param, const struct vkd3d_shader_src_param *rel_addr, - struct vkd3d_shader_src_param *src) - { -- src->reg.type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) -+ enum vkd3d_shader_register_type reg_type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) - | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); -+ -+ vsir_register_init(&src->reg, reg_type, VKD3D_DATA_FLOAT, 1); - src->reg.precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; - src->reg.non_uniform = false; -- src->reg.data_type = VKD3D_DATA_FLOAT; - src->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; - src->reg.idx[0].rel_addr = rel_addr; -- src->reg.idx[1].offset = ~0u; -- src->reg.idx[1].rel_addr = NULL; -- src->reg.idx[2].offset = ~0u; -- src->reg.idx[2].rel_addr = NULL; -- src->reg.idx_count = 1; -+ if (src->reg.type == VKD3DSPR_SAMPLER) -+ src->reg.dimension = VSIR_DIMENSION_NONE; -+ else if (src->reg.type == VKD3DSPR_DEPTHOUT) -+ src->reg.dimension = VSIR_DIMENSION_SCALAR; -+ else -+ src->reg.dimension = VSIR_DIMENSION_VEC4; - src->swizzle = swizzle_from_sm1((param & VKD3D_SM1_SWIZZLE_MASK) >> VKD3D_SM1_SWIZZLE_SHIFT); - src->modifiers = (param & VKD3D_SM1_SRC_MODIFIER_MASK) >> VKD3D_SM1_SRC_MODIFIER_SHIFT; - } -@@ -476,18 +468,20 @@ static void shader_sm1_parse_src_param(uint32_t param, const struct vkd3d_shader - static void shader_sm1_parse_dst_param(uint32_t param, const struct vkd3d_shader_src_param *rel_addr, - struct vkd3d_shader_dst_param *dst) - { -- dst->reg.type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) -+ enum vkd3d_shader_register_type reg_type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) - | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); -+ -+ vsir_register_init(&dst->reg, reg_type, VKD3D_DATA_FLOAT, 1); - dst->reg.precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; - dst->reg.non_uniform = false; -- dst->reg.data_type = VKD3D_DATA_FLOAT; - dst->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; - dst->reg.idx[0].rel_addr = rel_addr; -- dst->reg.idx[1].offset = ~0u; -- dst->reg.idx[1].rel_addr = NULL; -- dst->reg.idx[2].offset = ~0u; -- dst->reg.idx[2].rel_addr = NULL; -- dst->reg.idx_count = 1; -+ if (dst->reg.type == VKD3DSPR_SAMPLER) -+ dst->reg.dimension = VSIR_DIMENSION_NONE; -+ else if (dst->reg.type == VKD3DSPR_DEPTHOUT) -+ dst->reg.dimension = VSIR_DIMENSION_SCALAR; -+ else -+ dst->reg.dimension = VSIR_DIMENSION_VEC4; - dst->write_mask = (param & VKD3D_SM1_WRITEMASK_MASK) >> VKD3D_SM1_WRITEMASK_SHIFT; - dst->modifiers = (param & VKD3D_SM1_DST_MODIFIER_MASK) >> VKD3D_SM1_DST_MODIFIER_SHIFT; - dst->shift = (param & VKD3D_SM1_DSTSHIFT_MASK) >> VKD3D_SM1_DSTSHIFT_SHIFT; -@@ -551,9 +545,9 @@ static bool add_signature_element(struct vkd3d_shader_sm1_parser *sm1, bool outp - return false; - element = &signature->elements[signature->element_count++]; - -+ memset(element, 0, sizeof(*element)); - element->semantic_name = name; - element->semantic_index = index; -- element->stream_index = 0; - element->sysval_semantic = sysval; - element->component_type = VKD3D_SHADER_COMPONENT_FLOAT; - element->register_index = register_index; -@@ -561,7 +555,8 @@ static bool add_signature_element(struct vkd3d_shader_sm1_parser *sm1, bool outp - element->register_count = 1; - element->mask = mask; - element->used_mask = is_dcl ? 0 : mask; -- element->min_precision = VKD3D_SHADER_MINIMUM_PRECISION_NONE; -+ if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL && !output) -+ element->interpolation_mode = VKD3DSIM_LINEAR; - - return true; - } -@@ -853,6 +848,22 @@ static void shader_sm1_skip_opcode(const struct vkd3d_shader_sm1_parser *sm1, co - return; - } - -+ /* DCL instructions do not have sources or destinations, but they -+ * read two tokens to a semantic. See -+ * shader_sm1_read_semantic(). */ -+ if (opcode_info->vkd3d_opcode == VKD3DSIH_DCL) -+ { -+ *ptr += 2; -+ } -+ /* Somewhat similarly, DEF and DEFI have a single source, but need to read -+ * four tokens for that source. See shader_sm1_read_immconst(). -+ * Technically shader model 1 doesn't have integer registers or DEFI; we -+ * handle it here anyway because it's easy. */ -+ else if (opcode_info->vkd3d_opcode == VKD3DSIH_DEF || opcode_info->vkd3d_opcode == VKD3DSIH_DEFI) -+ { -+ *ptr += 3; -+ } -+ - *ptr += (opcode_info->dst_count + opcode_info->src_count); - } - -@@ -951,9 +962,9 @@ static void shader_sm1_read_semantic(struct vkd3d_shader_sm1_parser *sm1, - } - - static void shader_sm1_read_immconst(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr, -- struct vkd3d_shader_src_param *src_param, enum vkd3d_immconst_type type, enum vkd3d_data_type data_type) -+ struct vkd3d_shader_src_param *src_param, enum vsir_dimension dimension, enum vkd3d_data_type data_type) - { -- unsigned int count = type == VKD3D_IMMCONST_VEC4 ? 4 : 1; -+ unsigned int count = dimension == VSIR_DIMENSION_VEC4 ? 4 : 1; - - if (*ptr >= sm1->end || sm1->end - *ptr < count) - { -@@ -975,7 +986,7 @@ static void shader_sm1_read_immconst(struct vkd3d_shader_sm1_parser *sm1, const - src_param->reg.idx[2].offset = ~0u; - src_param->reg.idx[2].rel_addr = NULL; - src_param->reg.idx_count = 0; -- src_param->reg.immconst_type = type; -+ src_param->reg.dimension = dimension; - memcpy(src_param->reg.u.immconst_uint, *ptr, count * sizeof(uint32_t)); - src_param->swizzle = VKD3D_SHADER_NO_SWIZZLE; - src_param->modifiers = 0; -@@ -1090,7 +1101,7 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_sm1_parser *sm1, str - goto fail; - } - -- ins->handler_idx = opcode_info->vkd3d_opcode; -+ vsir_instruction_init(ins, &sm1->p.location, opcode_info->vkd3d_opcode); - ins->flags = (opcode_token & VKD3D_SM1_INSTRUCTION_FLAGS_MASK) >> VKD3D_SM1_INSTRUCTION_FLAGS_SHIFT; - ins->coissue = opcode_token & VKD3D_SM1_COISSUE; - ins->raw = false; -@@ -1132,19 +1143,19 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_sm1_parser *sm1, str - else if (ins->handler_idx == VKD3DSIH_DEF) - { - shader_sm1_read_dst_param(sm1, &p, dst_param); -- shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_FLOAT); -+ shader_sm1_read_immconst(sm1, &p, &src_params[0], VSIR_DIMENSION_VEC4, VKD3D_DATA_FLOAT); - shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); - } - else if (ins->handler_idx == VKD3DSIH_DEFB) - { - shader_sm1_read_dst_param(sm1, &p, dst_param); -- shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_SCALAR, VKD3D_DATA_UINT); -+ shader_sm1_read_immconst(sm1, &p, &src_params[0], VSIR_DIMENSION_SCALAR, VKD3D_DATA_UINT); - shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); - } - else if (ins->handler_idx == VKD3DSIH_DEFI) - { - shader_sm1_read_dst_param(sm1, &p, dst_param); -- shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_INT); -+ shader_sm1_read_immconst(sm1, &p, &src_params[0], VSIR_DIMENSION_VEC4, VKD3D_DATA_INT); - shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); - } - else -@@ -1250,7 +1261,7 @@ static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1, - return VKD3D_ERROR_INVALID_SHADER; - } - -- if (!shader_ver_le(&version, 3, 0)) -+ if (!vkd3d_shader_ver_le(&version, 3, 0)) - { - vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_D3DBC_INVALID_VERSION_TOKEN, - "Invalid shader version %u.%u (token 0x%08x).", version.major, version.minor, code[0]); -@@ -1333,12 +1344,22 @@ int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compi - ++instructions->count; - } - -- *parser = &sm1->p; -- - for (i = 0; i < ARRAY_SIZE(sm1->p.shader_desc.flat_constant_count); ++i) - sm1->p.shader_desc.flat_constant_count[i].external = get_external_constant_count(sm1, i); - -- return sm1->p.failed ? VKD3D_ERROR_INVALID_SHADER : VKD3D_OK; -+ if (!sm1->p.failed) -+ vsir_validate(&sm1->p); -+ -+ if (sm1->p.failed) -+ { -+ WARN("Failed to parse shader.\n"); -+ shader_sm1_destroy(&sm1->p); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ *parser = &sm1->p; -+ -+ return VKD3D_OK; - } - - bool hlsl_sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, -@@ -1811,6 +1832,37 @@ static void write_sm1_dp2add(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer - write_sm1_instruction(ctx, buffer, &instr); - } - -+static void write_sm1_ternary_op(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, -+ D3DSHADER_INSTRUCTION_OPCODE_TYPE opcode, const struct hlsl_reg *dst, const struct hlsl_reg *src1, -+ const struct hlsl_reg *src2, const struct hlsl_reg *src3) -+{ -+ struct sm1_instruction instr = -+ { -+ .opcode = opcode, -+ -+ .dst.type = D3DSPR_TEMP, -+ .dst.writemask = dst->writemask, -+ .dst.reg = dst->id, -+ .has_dst = 1, -+ -+ .srcs[0].type = D3DSPR_TEMP, -+ .srcs[0].swizzle = hlsl_swizzle_from_writemask(src1->writemask), -+ .srcs[0].reg = src1->id, -+ .srcs[1].type = D3DSPR_TEMP, -+ .srcs[1].swizzle = hlsl_swizzle_from_writemask(src2->writemask), -+ .srcs[1].reg = src2->id, -+ .srcs[2].type = D3DSPR_TEMP, -+ .srcs[2].swizzle = hlsl_swizzle_from_writemask(src3->writemask), -+ .srcs[2].reg = src3->id, -+ .src_count = 3, -+ }; -+ -+ sm1_map_src_swizzle(&instr.srcs[0], instr.dst.writemask); -+ sm1_map_src_swizzle(&instr.srcs[1], instr.dst.writemask); -+ sm1_map_src_swizzle(&instr.srcs[2], instr.dst.writemask); -+ write_sm1_instruction(ctx, buffer, &instr); -+} -+ - static void write_sm1_binary_op(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, - D3DSHADER_INSTRUCTION_OPCODE_TYPE opcode, const struct hlsl_reg *dst, - const struct hlsl_reg *src1, const struct hlsl_reg *src2) -@@ -2177,6 +2229,10 @@ static void write_sm1_expr(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *b - } - break; - -+ case HLSL_OP3_CMP: -+ write_sm1_ternary_op(ctx, buffer, D3DSIO_CMP, &instr->reg, &arg1->reg, &arg2->reg, &arg3->reg); -+ break; -+ - case HLSL_OP3_DP2ADD: - write_sm1_dp2add(ctx, buffer, &instr->reg, &arg1->reg, &arg2->reg, &arg3->reg); - break; -@@ -2199,7 +2255,7 @@ static void write_sm1_jump(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *b - - struct sm1_instruction instr = - { -- .opcode = VKD3D_SM1_OP_TEXKILL, -+ .opcode = D3DSIO_TEXKILL, - - .dst.type = D3DSPR_TEMP, - .dst.reg = reg->id, -@@ -2289,6 +2345,8 @@ static void write_sm1_resource_load(struct hlsl_ctx *ctx, struct vkd3d_bytecode_ - - .src_count = 2, - }; -+ if (load->load_type == HLSL_RESOURCE_SAMPLE_PROJ) -+ sm1_instr.opcode |= VKD3DSI_TEXLD_PROJECT << VKD3D_SM1_INSTRUCTION_FLAGS_SHIFT; - - assert(instr->reg.allocated); - -diff --git a/libs/vkd3d/libs/vkd3d-shader/dxbc.c b/libs/vkd3d/libs/vkd3d-shader/dxbc.c -index 1cb00688c76..7834c1e1615 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/dxbc.c -+++ b/libs/vkd3d/libs/vkd3d-shader/dxbc.c -@@ -94,16 +94,24 @@ static bool require_space(size_t offset, size_t count, size_t size, size_t data_ - return !count || (data_size - offset) / count >= size; - } - --static void read_dword(const char **ptr, uint32_t *d) -+static uint32_t read_u32(const char **ptr) - { -- memcpy(d, *ptr, sizeof(*d)); -- *ptr += sizeof(*d); -+ unsigned int ret; -+ memcpy(&ret, *ptr, sizeof(ret)); -+ *ptr += sizeof(ret); -+ return ret; - } - --static void read_float(const char **ptr, float *f) -+static float read_float(const char **ptr) - { -+ union -+ { -+ uint32_t i; -+ float f; -+ } u; - STATIC_ASSERT(sizeof(float) == sizeof(uint32_t)); -- read_dword(ptr, (uint32_t *)f); -+ u.i = read_u32(ptr); -+ return u.f; - } - - static void skip_dword_unknown(const char **ptr, unsigned int count) -@@ -117,7 +125,7 @@ static void skip_dword_unknown(const char **ptr, unsigned int count) - WARN("Skipping %u unknown DWORDs:\n", count); - for (i = 0; i < count; ++i) - { -- read_dword(ptr, &d); -+ d = read_u32(ptr); - WARN("\t0x%08x\n", d); - } - } -@@ -164,7 +172,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &tag); -+ tag = read_u32(&ptr); - TRACE("tag: %#x.\n", tag); - - if (tag != TAG_DXBC) -@@ -174,10 +182,10 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &checksum[0]); -- read_dword(&ptr, &checksum[1]); -- read_dword(&ptr, &checksum[2]); -- read_dword(&ptr, &checksum[3]); -+ checksum[0] = read_u32(&ptr); -+ checksum[1] = read_u32(&ptr); -+ checksum[2] = read_u32(&ptr); -+ checksum[3] = read_u32(&ptr); - vkd3d_compute_dxbc_checksum(data, data_size, calculated_checksum); - if (memcmp(checksum, calculated_checksum, sizeof(checksum))) - { -@@ -191,7 +199,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &version); -+ version = read_u32(&ptr); - TRACE("version: %#x.\n", version); - if (version != 0x00000001) - { -@@ -201,10 +209,10 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &total_size); -+ total_size = read_u32(&ptr); - TRACE("total size: %#x\n", total_size); - -- read_dword(&ptr, &chunk_count); -+ chunk_count = read_u32(&ptr); - TRACE("chunk count: %#x\n", chunk_count); - - if (!(sections = vkd3d_calloc(chunk_count, sizeof(*sections)))) -@@ -219,7 +227,7 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - const char *chunk_ptr; - uint32_t chunk_offset; - -- read_dword(&ptr, &chunk_offset); -+ chunk_offset = read_u32(&ptr); - TRACE("chunk %u at offset %#x\n", i, chunk_offset); - - if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size)) -@@ -233,8 +241,8 @@ static int parse_dxbc(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_ - - chunk_ptr = data + chunk_offset; - -- read_dword(&chunk_ptr, &chunk_tag); -- read_dword(&chunk_ptr, &chunk_size); -+ chunk_tag = read_u32(&chunk_ptr); -+ chunk_size = read_u32(&chunk_ptr); - - if (!require_space(chunk_ptr - data, 1, chunk_size, data_size)) - { -@@ -359,10 +367,10 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &count); -+ count = read_u32(&ptr); - TRACE("%u elements.\n", count); - -- read_dword(&ptr, &header_size); -+ header_size = read_u32(&ptr); - i = header_size / sizeof(uint32_t); - if (align(header_size, sizeof(uint32_t)) != header_size || i < 2 - || !require_space(2, i - 2, sizeof(uint32_t), section->data.size)) -@@ -396,24 +404,24 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s - e[i].sort_index = i; - - if (has_stream_index) -- read_dword(&ptr, &e[i].stream_index); -+ e[i].stream_index = read_u32(&ptr); - else - e[i].stream_index = 0; - -- read_dword(&ptr, &name_offset); -+ name_offset = read_u32(&ptr); - if (!(e[i].semantic_name = shader_get_string(data, section->data.size, name_offset))) - { - WARN("Invalid name offset %#x (data size %#zx).\n", name_offset, section->data.size); - vkd3d_free(e); - return VKD3D_ERROR_INVALID_ARGUMENT; - } -- read_dword(&ptr, &e[i].semantic_index); -- read_dword(&ptr, &e[i].sysval_semantic); -- read_dword(&ptr, &e[i].component_type); -- read_dword(&ptr, &e[i].register_index); -+ e[i].semantic_index = read_u32(&ptr); -+ e[i].sysval_semantic = read_u32(&ptr); -+ e[i].component_type = read_u32(&ptr); -+ e[i].register_index = read_u32(&ptr); - e[i].target_location = e[i].register_index; - e[i].register_count = 1; -- read_dword(&ptr, &mask); -+ mask = read_u32(&ptr); - e[i].mask = mask & 0xff; - e[i].used_mask = (mask >> 8) & 0xff; - switch (section->tag) -@@ -431,10 +439,12 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s - } - - if (has_min_precision) -- read_dword(&ptr, &e[i].min_precision); -+ e[i].min_precision = read_u32(&ptr); - else - e[i].min_precision = VKD3D_SHADER_MINIMUM_PRECISION_NONE; - -+ e[i].interpolation_mode = VKD3DSIM_NONE; -+ - TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, " - "type %u, register idx: %u, use_mask %#x, input_mask %#x, precision %u.\n", - e[i].stream_index, debugstr_a(e[i].semantic_name), e[i].semantic_index, e[i].sysval_semantic, -@@ -452,7 +462,7 @@ static int isgn_handler(const struct vkd3d_shader_dxbc_section_desc *section, - { - struct shader_signature *is = ctx; - -- if (section->tag != TAG_ISGN) -+ if (section->tag != TAG_ISGN && section->tag != TAG_ISG1) - return VKD3D_OK; - - if (is->elements) -@@ -595,11 +605,11 @@ static int shader_parse_descriptor_ranges(struct root_signature_parser_context * - - for (i = 0; i < count; ++i) - { -- read_dword(&ptr, &ranges[i].range_type); -- read_dword(&ptr, &ranges[i].descriptor_count); -- read_dword(&ptr, &ranges[i].base_shader_register); -- read_dword(&ptr, &ranges[i].register_space); -- read_dword(&ptr, &ranges[i].descriptor_table_offset); -+ ranges[i].range_type = read_u32(&ptr); -+ ranges[i].descriptor_count = read_u32(&ptr); -+ ranges[i].base_shader_register = read_u32(&ptr); -+ ranges[i].register_space = read_u32(&ptr); -+ ranges[i].descriptor_table_offset = read_u32(&ptr); - - TRACE("Type %#x, descriptor count %u, base shader register %u, " - "register space %u, offset %u.\n", -@@ -638,12 +648,12 @@ static int shader_parse_descriptor_ranges1(struct root_signature_parser_context - - for (i = 0; i < count; ++i) - { -- read_dword(&ptr, &ranges[i].range_type); -- read_dword(&ptr, &ranges[i].descriptor_count); -- read_dword(&ptr, &ranges[i].base_shader_register); -- read_dword(&ptr, &ranges[i].register_space); -- read_dword(&ptr, &ranges[i].flags); -- read_dword(&ptr, &ranges[i].descriptor_table_offset); -+ ranges[i].range_type = read_u32(&ptr); -+ ranges[i].descriptor_count = read_u32(&ptr); -+ ranges[i].base_shader_register = read_u32(&ptr); -+ ranges[i].register_space = read_u32(&ptr); -+ ranges[i].flags = read_u32(&ptr); -+ ranges[i].descriptor_table_offset = read_u32(&ptr); - - TRACE("Type %#x, descriptor count %u, base shader register %u, " - "register space %u, flags %#x, offset %u.\n", -@@ -671,8 +681,8 @@ static int shader_parse_descriptor_table(struct root_signature_parser_context *c - } - ptr = &context->data[offset]; - -- read_dword(&ptr, &count); -- read_dword(&ptr, &offset); -+ count = read_u32(&ptr); -+ offset = read_u32(&ptr); - - TRACE("Descriptor range count %u.\n", count); - -@@ -698,8 +708,8 @@ static int shader_parse_descriptor_table1(struct root_signature_parser_context * - } - ptr = &context->data[offset]; - -- read_dword(&ptr, &count); -- read_dword(&ptr, &offset); -+ count = read_u32(&ptr); -+ offset = read_u32(&ptr); - - TRACE("Descriptor range count %u.\n", count); - -@@ -723,9 +733,9 @@ static int shader_parse_root_constants(struct root_signature_parser_context *con - } - ptr = &context->data[offset]; - -- read_dword(&ptr, &constants->shader_register); -- read_dword(&ptr, &constants->register_space); -- read_dword(&ptr, &constants->value_count); -+ constants->shader_register = read_u32(&ptr); -+ constants->register_space = read_u32(&ptr); -+ constants->value_count = read_u32(&ptr); - - TRACE("Shader register %u, register space %u, 32-bit value count %u.\n", - constants->shader_register, constants->register_space, constants->value_count); -@@ -745,8 +755,8 @@ static int shader_parse_root_descriptor(struct root_signature_parser_context *co - } - ptr = &context->data[offset]; - -- read_dword(&ptr, &descriptor->shader_register); -- read_dword(&ptr, &descriptor->register_space); -+ descriptor->shader_register = read_u32(&ptr); -+ descriptor->register_space = read_u32(&ptr); - - TRACE("Shader register %u, register space %u.\n", - descriptor->shader_register, descriptor->register_space); -@@ -777,9 +787,9 @@ static int shader_parse_root_descriptor1(struct root_signature_parser_context *c - } - ptr = &context->data[offset]; - -- read_dword(&ptr, &descriptor->shader_register); -- read_dword(&ptr, &descriptor->register_space); -- read_dword(&ptr, &descriptor->flags); -+ descriptor->shader_register = read_u32(&ptr); -+ descriptor->register_space = read_u32(&ptr); -+ descriptor->flags = read_u32(&ptr); - - TRACE("Shader register %u, register space %u, flags %#x.\n", - descriptor->shader_register, descriptor->register_space, descriptor->flags); -@@ -805,9 +815,9 @@ static int shader_parse_root_parameters(struct root_signature_parser_context *co - - for (i = 0; i < count; ++i) - { -- read_dword(&ptr, ¶meters[i].parameter_type); -- read_dword(&ptr, ¶meters[i].shader_visibility); -- read_dword(&ptr, &offset); -+ parameters[i].parameter_type = read_u32(&ptr); -+ parameters[i].shader_visibility = read_u32(&ptr); -+ offset = read_u32(&ptr); - - TRACE("Type %#x, shader visibility %#x.\n", - parameters[i].parameter_type, parameters[i].shader_visibility); -@@ -853,9 +863,9 @@ static int shader_parse_root_parameters1(struct root_signature_parser_context *c - - for (i = 0; i < count; ++i) - { -- read_dword(&ptr, ¶meters[i].parameter_type); -- read_dword(&ptr, ¶meters[i].shader_visibility); -- read_dword(&ptr, &offset); -+ parameters[i].parameter_type = read_u32(&ptr); -+ parameters[i].shader_visibility = read_u32(&ptr); -+ offset = read_u32(&ptr); - - TRACE("Type %#x, shader visibility %#x.\n", - parameters[i].parameter_type, parameters[i].shader_visibility); -@@ -900,19 +910,19 @@ static int shader_parse_static_samplers(struct root_signature_parser_context *co - - for (i = 0; i < count; ++i) - { -- read_dword(&ptr, &sampler_descs[i].filter); -- read_dword(&ptr, &sampler_descs[i].address_u); -- read_dword(&ptr, &sampler_descs[i].address_v); -- read_dword(&ptr, &sampler_descs[i].address_w); -- read_float(&ptr, &sampler_descs[i].mip_lod_bias); -- read_dword(&ptr, &sampler_descs[i].max_anisotropy); -- read_dword(&ptr, &sampler_descs[i].comparison_func); -- read_dword(&ptr, &sampler_descs[i].border_colour); -- read_float(&ptr, &sampler_descs[i].min_lod); -- read_float(&ptr, &sampler_descs[i].max_lod); -- read_dword(&ptr, &sampler_descs[i].shader_register); -- read_dword(&ptr, &sampler_descs[i].register_space); -- read_dword(&ptr, &sampler_descs[i].shader_visibility); -+ sampler_descs[i].filter = read_u32(&ptr); -+ sampler_descs[i].address_u = read_u32(&ptr); -+ sampler_descs[i].address_v = read_u32(&ptr); -+ sampler_descs[i].address_w = read_u32(&ptr); -+ sampler_descs[i].mip_lod_bias = read_float(&ptr); -+ sampler_descs[i].max_anisotropy = read_u32(&ptr); -+ sampler_descs[i].comparison_func = read_u32(&ptr); -+ sampler_descs[i].border_colour = read_u32(&ptr); -+ sampler_descs[i].min_lod = read_float(&ptr); -+ sampler_descs[i].max_lod = read_float(&ptr); -+ sampler_descs[i].shader_register = read_u32(&ptr); -+ sampler_descs[i].register_space = read_u32(&ptr); -+ sampler_descs[i].shader_visibility = read_u32(&ptr); - } - - return VKD3D_OK; -@@ -936,7 +946,7 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data, - return VKD3D_ERROR_INVALID_ARGUMENT; - } - -- read_dword(&ptr, &version); -+ version = read_u32(&ptr); - TRACE("Version %#x.\n", version); - if (version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0 && version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1) - { -@@ -945,8 +955,8 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data, - } - desc->version = version; - -- read_dword(&ptr, &count); -- read_dword(&ptr, &offset); -+ count = read_u32(&ptr); -+ offset = read_u32(&ptr); - TRACE("Parameter count %u, offset %u.\n", count, offset); - - if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0) -@@ -980,8 +990,8 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data, - } - } - -- read_dword(&ptr, &count); -- read_dword(&ptr, &offset); -+ count = read_u32(&ptr); -+ offset = read_u32(&ptr); - TRACE("Static sampler count %u, offset %u.\n", count, offset); - - v_1_0->static_sampler_count = count; -@@ -995,7 +1005,7 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data, - return ret; - } - -- read_dword(&ptr, &v_1_0->flags); -+ v_1_0->flags = read_u32(&ptr); - TRACE("Flags %#x.\n", v_1_0->flags); - - return VKD3D_OK; -diff --git a/libs/vkd3d/libs/vkd3d-shader/dxil.c b/libs/vkd3d/libs/vkd3d-shader/dxil.c -index b78c78d34a7..1709212fa99 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/dxil.c -+++ b/libs/vkd3d/libs/vkd3d-shader/dxil.c -@@ -20,9 +20,18 @@ - - #define VKD3D_SM6_VERSION_MAJOR(version) (((version) >> 4) & 0xf) - #define VKD3D_SM6_VERSION_MINOR(version) (((version) >> 0) & 0xf) -+/* Two seems to be the maximum but leave some extra room. */ -+#define VKD3D_SM6_MAX_METADATA_TABLES 4 - - #define BITCODE_MAGIC VKD3D_MAKE_TAG('B', 'C', 0xc0, 0xde) - #define DXIL_OP_MAX_OPERANDS 17 -+static const uint64_t MAX_ALIGNMENT_EXPONENT = 29; -+static const uint64_t GLOBALVAR_FLAG_IS_CONSTANT = 1; -+static const uint64_t GLOBALVAR_FLAG_EXPLICIT_TYPE = 2; -+static const unsigned int GLOBALVAR_ADDRESS_SPACE_SHIFT = 2; -+static const unsigned int SHADER_DESCRIPTOR_TYPE_COUNT = 4; -+ -+static const unsigned int dx_max_thread_group_size[3] = {1024, 1024, 64}; - - enum bitcode_block_id - { -@@ -114,6 +123,19 @@ enum bitcode_function_code - FUNC_CODE_INST_CMPXCHG = 46, - }; - -+enum bitcode_metadata_code -+{ -+ METADATA_STRING = 1, -+ METADATA_VALUE = 2, -+ METADATA_NODE = 3, -+ METADATA_NAME = 4, -+ METADATA_DISTINCT_NODE = 5, -+ METADATA_KIND = 6, -+ METADATA_LOCATION = 7, -+ METADATA_NAMED_NODE = 10, -+ METADATA_ATTACHMENT = 11, -+}; -+ - enum bitcode_type_code - { - TYPE_CODE_NUMENTRY = 1, -@@ -139,9 +161,190 @@ enum bitcode_value_symtab_code - VST_CODE_BBENTRY = 2, - }; - -+enum bitcode_linkage -+{ -+ LINKAGE_EXTERNAL = 0, -+ LINKAGE_APPENDING = 2, -+ LINKAGE_INTERNAL = 3, -+}; -+ -+enum dxil_component_type -+{ -+ COMPONENT_TYPE_INVALID = 0, -+ COMPONENT_TYPE_I1 = 1, -+ COMPONENT_TYPE_I16 = 2, -+ COMPONENT_TYPE_U16 = 3, -+ COMPONENT_TYPE_I32 = 4, -+ COMPONENT_TYPE_U32 = 5, -+ COMPONENT_TYPE_I64 = 6, -+ COMPONENT_TYPE_U64 = 7, -+ COMPONENT_TYPE_F16 = 8, -+ COMPONENT_TYPE_F32 = 9, -+ COMPONENT_TYPE_F64 = 10, -+ COMPONENT_TYPE_SNORMF16 = 11, -+ COMPONENT_TYPE_UNORMF16 = 12, -+ COMPONENT_TYPE_SNORMF32 = 13, -+ COMPONENT_TYPE_UNORMF32 = 14, -+ COMPONENT_TYPE_SNORMF64 = 15, -+ COMPONENT_TYPE_UNORMF64 = 16, -+ COMPONENT_TYPE_PACKEDS8X32 = 17, -+ COMPONENT_TYPE_PACKEDU8X32 = 18, -+}; -+ -+enum dxil_semantic_kind -+{ -+ SEMANTIC_KIND_ARBITRARY = 0, -+ SEMANTIC_KIND_VERTEXID = 1, -+ SEMANTIC_KIND_INSTANCEID = 2, -+ SEMANTIC_KIND_POSITION = 3, -+ SEMANTIC_KIND_RTARRAYINDEX = 4, -+ SEMANTIC_KIND_VIEWPORTARRAYINDEX = 5, -+ SEMANTIC_KIND_CLIPDISTANCE = 6, -+ SEMANTIC_KIND_CULLDISTANCE = 7, -+ SEMANTIC_KIND_OUTPUTCONTROLPOINTID = 8, -+ SEMANTIC_KIND_DOMAINLOCATION = 9, -+ SEMANTIC_KIND_PRIMITIVEID = 10, -+ SEMANTIC_KIND_GSINSTANCEID = 11, -+ SEMANTIC_KIND_SAMPLEINDEX = 12, -+ SEMANTIC_KIND_ISFRONTFACE = 13, -+ SEMANTIC_KIND_COVERAGE = 14, -+ SEMANTIC_KIND_INNERCOVERAGE = 15, -+ SEMANTIC_KIND_TARGET = 16, -+ SEMANTIC_KIND_DEPTH = 17, -+ SEMANTIC_KIND_DEPTHLESSEQUAL = 18, -+ SEMANTIC_KIND_DEPTHGREATEREQUAL = 19, -+ SEMANTIC_KIND_STENCILREF = 20, -+ SEMANTIC_KIND_DISPATCHTHREADID = 21, -+ SEMANTIC_KIND_GROUPID = 22, -+ SEMANTIC_KIND_GROUPINDEX = 23, -+ SEMANTIC_KIND_GROUPTHREADID = 24, -+ SEMANTIC_KIND_TESSFACTOR = 25, -+ SEMANTIC_KIND_INSIDETESSFACTOR = 26, -+ SEMANTIC_KIND_VIEWID = 27, -+ SEMANTIC_KIND_BARYCENTRICS = 28, -+ SEMANTIC_KIND_SHADINGRATE = 29, -+ SEMANTIC_KIND_CULLPRIMITIVE = 30, -+ SEMANTIC_KIND_COUNT = 31, -+ SEMANTIC_KIND_INVALID = SEMANTIC_KIND_COUNT, -+}; -+ -+enum dxil_element_additional_tag -+{ -+ ADDITIONAL_TAG_STREAM_INDEX = 0, -+ ADDITIONAL_TAG_GLOBAL_SYMBOL = 1, /* not used */ -+ ADDITIONAL_TAG_RELADDR_MASK = 2, -+ ADDITIONAL_TAG_USED_MASK = 3, -+}; -+ -+enum dxil_shader_properties_tag -+{ -+ SHADER_PROPERTIES_FLAGS = 0, -+ SHADER_PROPERTIES_GEOMETRY = 1, -+ SHADER_PROPERTIES_DOMAIN = 2, -+ SHADER_PROPERTIES_HULL = 3, -+ SHADER_PROPERTIES_COMPUTE = 4, -+ SHADER_PROPERTIES_AUTO_BINDING_SPACE = 5, -+ SHADER_PROPERTIES_RAY_PAYLOAD_SIZE = 6, -+ SHADER_PROPERTIES_RAY_ATTRIB_SIZE = 7, -+ SHADER_PROPERTIES_SHADER_KIND = 8, -+ SHADER_PROPERTIES_MESH = 9, -+ SHADER_PROPERTIES_AMPLIFICATION = 10, -+ SHADER_PROPERTIES_WAVE_SIZE = 11, -+ SHADER_PROPERTIES_ENTRY_ROOT_SIG = 12, -+}; -+ -+enum dxil_binop_code -+{ -+ BINOP_ADD = 0, -+ BINOP_SUB = 1, -+ BINOP_MUL = 2, -+ BINOP_UDIV = 3, -+ BINOP_SDIV = 4, -+ BINOP_UREM = 5, -+ BINOP_SREM = 6, -+ BINOP_SHL = 7, -+ BINOP_LSHR = 8, -+ BINOP_ASHR = 9, -+ BINOP_AND = 10, -+ BINOP_OR = 11, -+ BINOP_XOR = 12 -+}; -+ -+enum dxil_fast_fp_flags -+{ -+ FP_ALLOW_UNSAFE_ALGEBRA = 0x1, -+ FP_NO_NAN = 0x2, -+ FP_NO_INF = 0x4, -+ FP_NO_SIGNED_ZEROS = 0x8, -+ FP_ALLOW_RECIPROCAL = 0x10, -+}; -+ -+enum dxil_overflowing_binop_flags -+{ -+ /* Operation is known to never overflow. */ -+ OB_NO_UNSIGNED_WRAP = 0x1, -+ OB_NO_SIGNED_WRAP = 0x2, -+}; -+ -+enum dxil_possibly_exact_binop_flags -+{ -+ /* "A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed." */ -+ PEB_EXACT = 0x1, -+}; -+ - enum dx_intrinsic_opcode - { -+ DX_LOAD_INPUT = 4, - DX_STORE_OUTPUT = 5, -+ DX_CREATE_HANDLE = 57, -+ DX_CBUFFER_LOAD_LEGACY = 59, -+}; -+ -+enum dxil_cast_code -+{ -+ CAST_TRUNC = 0, -+ CAST_ZEXT = 1, -+ CAST_SEXT = 2, -+ CAST_FPTOUI = 3, -+ CAST_FPTOSI = 4, -+ CAST_UITOFP = 5, -+ CAST_SITOFP = 6, -+ CAST_FPTRUNC = 7, -+ CAST_FPEXT = 8, -+ CAST_PTRTOINT = 9, -+ CAST_INTTOPTR = 10, -+ CAST_BITCAST = 11, -+ CAST_ADDRSPACECAST = 12, -+}; -+ -+enum dxil_predicate -+{ -+ FCMP_FALSE = 0, -+ FCMP_OEQ = 1, -+ FCMP_OGT = 2, -+ FCMP_OGE = 3, -+ FCMP_OLT = 4, -+ FCMP_OLE = 5, -+ FCMP_ONE = 6, -+ FCMP_ORD = 7, -+ FCMP_UNO = 8, -+ FCMP_UEQ = 9, -+ FCMP_UGT = 10, -+ FCMP_UGE = 11, -+ FCMP_ULT = 12, -+ FCMP_ULE = 13, -+ FCMP_UNE = 14, -+ FCMP_TRUE = 15, -+ ICMP_EQ = 32, -+ ICMP_NE = 33, -+ ICMP_UGT = 34, -+ ICMP_UGE = 35, -+ ICMP_ULT = 36, -+ ICMP_ULE = 37, -+ ICMP_SGT = 38, -+ ICMP_SGE = 39, -+ ICMP_SLT = 40, -+ ICMP_SLE = 41, - }; - - struct sm6_pointer_info -@@ -201,6 +404,8 @@ enum sm6_value_type - { - VALUE_TYPE_FUNCTION, - VALUE_TYPE_REG, -+ VALUE_TYPE_ICB, -+ VALUE_TYPE_HANDLE, - }; - - struct sm6_function_data -@@ -210,6 +415,12 @@ struct sm6_function_data - unsigned int attribs_id; - }; - -+struct sm6_handle_data -+{ -+ const struct sm6_descriptor_info *d; -+ struct vkd3d_shader_register reg; -+}; -+ - struct sm6_value - { - const struct sm6_type *type; -@@ -219,6 +430,8 @@ struct sm6_value - { - struct sm6_function_data function; - struct vkd3d_shader_register reg; -+ const struct vkd3d_shader_immediate_constant_buffer *icb; -+ struct sm6_handle_data handle; - } u; - }; - -@@ -277,6 +490,59 @@ struct dxil_block - size_t record_count; - }; - -+enum sm6_metadata_type -+{ -+ VKD3D_METADATA_KIND, -+ VKD3D_METADATA_NODE, -+ VKD3D_METADATA_STRING, -+ VKD3D_METADATA_VALUE, -+}; -+ -+struct sm6_metadata_node -+{ -+ bool is_distinct; -+ unsigned int operand_count; -+ struct sm6_metadata_value *operands[]; -+}; -+ -+struct sm6_metadata_kind -+{ -+ uint64_t id; -+ char *name; -+}; -+ -+struct sm6_metadata_value -+{ -+ enum sm6_metadata_type type; -+ const struct sm6_type *value_type; -+ union -+ { -+ char *string_value; -+ const struct sm6_value *value; -+ struct sm6_metadata_node *node; -+ struct sm6_metadata_kind kind; -+ } u; -+}; -+ -+struct sm6_metadata_table -+{ -+ struct sm6_metadata_value *values; -+ unsigned int count; -+}; -+ -+struct sm6_named_metadata -+{ -+ char *name; -+ struct sm6_metadata_value value; -+}; -+ -+struct sm6_descriptor_info -+{ -+ enum vkd3d_shader_descriptor_type type; -+ unsigned int id; -+ struct vkd3d_shader_register_range range; -+}; -+ - struct sm6_parser - { - const uint32_t *ptr, *start, *end; -@@ -291,19 +557,36 @@ struct sm6_parser - - struct sm6_type *types; - size_t type_count; -+ struct sm6_type *bool_type; -+ struct sm6_type *metadata_type; -+ struct sm6_type *handle_type; - - struct sm6_symbol *global_symbols; - size_t global_symbol_count; - -+ const char *entry_point; -+ - struct vkd3d_shader_dst_param *output_params; -+ struct vkd3d_shader_dst_param *input_params; - - struct sm6_function *functions; - size_t function_count; - -+ struct sm6_metadata_table metadata_tables[VKD3D_SM6_MAX_METADATA_TABLES]; -+ struct sm6_named_metadata *named_metadata; -+ unsigned int named_metadata_count; -+ -+ struct sm6_descriptor_info *descriptors; -+ size_t descriptor_capacity; -+ size_t descriptor_count; -+ -+ unsigned int indexable_temp_count; -+ - struct sm6_value *values; - size_t value_count; - size_t value_capacity; - size_t cur_max_value; -+ unsigned int ssa_next_id; - - struct vkd3d_shader_parser p; - }; -@@ -970,14 +1253,18 @@ static const struct dxil_block *sm6_parser_get_level_one_block(const struct sm6_ - return found; - } - --static char *dxil_record_to_string(const struct dxil_record *record, unsigned int offset) -+static char *dxil_record_to_string(const struct dxil_record *record, unsigned int offset, struct sm6_parser *sm6) - { - unsigned int i; - char *str; - - assert(offset <= record->operand_count); - if (!(str = vkd3d_calloc(record->operand_count - offset + 1, 1))) -+ { -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating a string of length %u.", record->operand_count - offset); - return NULL; -+ } - - for (i = offset; i < record->operand_count; ++i) - str[i - offset] = record->operands[i]; -@@ -1147,6 +1434,8 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6) - switch ((width = record->operands[0])) - { - case 1: -+ sm6->bool_type = type; -+ break; - case 8: - case 16: - case 32: -@@ -1166,6 +1455,7 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6) - - case TYPE_CODE_METADATA: - type->class = TYPE_CLASS_METADATA; -+ sm6->metadata_type = type; - break; - - case TYPE_CODE_NUMENTRY: -@@ -1188,7 +1478,7 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6) - - case TYPE_CODE_STRUCT_ANON: - case TYPE_CODE_STRUCT_NAMED: -- if (!dxil_record_validate_operand_min_count(record, 2, sm6)) -+ if (!dxil_record_validate_operand_min_count(record, 1, sm6)) - return VKD3D_ERROR_INVALID_SHADER; - if (record->code == TYPE_CODE_STRUCT_NAMED && !struct_name) - { -@@ -1227,12 +1517,15 @@ static enum vkd3d_result sm6_parser_type_table_init(struct sm6_parser *sm6) - break; - } - -+ if (!ascii_strcasecmp(struct_name, "dx.types.Handle")) -+ sm6->handle_type = type; -+ - type->u.struc->name = struct_name; - struct_name = NULL; - break; - - case TYPE_CODE_STRUCT_NAME: -- if (!(struct_name = dxil_record_to_string(record, 0))) -+ if (!(struct_name = dxil_record_to_string(record, 0, sm6))) - { - ERR("Failed to allocate struct name.\n"); - return VKD3D_ERROR_OUT_OF_MEMORY; -@@ -1274,6 +1567,16 @@ static inline bool sm6_type_is_integer(const struct sm6_type *type) - return type->class == TYPE_CLASS_INTEGER; - } - -+static bool sm6_type_is_bool_i16_i32_i64(const struct sm6_type *type) -+{ -+ return type->class == TYPE_CLASS_INTEGER && (type->u.width == 1 || type->u.width >= 16); -+} -+ -+static bool sm6_type_is_bool(const struct sm6_type *type) -+{ -+ return type->class == TYPE_CLASS_INTEGER && type->u.width == 1; -+} -+ - static inline bool sm6_type_is_i8(const struct sm6_type *type) - { - return type->class == TYPE_CLASS_INTEGER && type->u.width == 8; -@@ -1289,6 +1592,11 @@ static inline bool sm6_type_is_floating_point(const struct sm6_type *type) - return type->class == TYPE_CLASS_FLOAT; - } - -+static bool sm6_type_is_scalar(const struct sm6_type *type) -+{ -+ return type->class == TYPE_CLASS_INTEGER || type->class == TYPE_CLASS_FLOAT || type->class == TYPE_CLASS_POINTER; -+} -+ - static inline bool sm6_type_is_numeric(const struct sm6_type *type) - { - return type->class == TYPE_CLASS_INTEGER || type->class == TYPE_CLASS_FLOAT; -@@ -1299,6 +1607,11 @@ static inline bool sm6_type_is_pointer(const struct sm6_type *type) - return type->class == TYPE_CLASS_POINTER; - } - -+static bool sm6_type_is_aggregate(const struct sm6_type *type) -+{ -+ return type->class == TYPE_CLASS_STRUCT || type->class == TYPE_CLASS_VECTOR || type->class == TYPE_CLASS_ARRAY; -+} -+ - static bool sm6_type_is_numeric_aggregate(const struct sm6_type *type) - { - unsigned int i; -@@ -1321,6 +1634,11 @@ static bool sm6_type_is_numeric_aggregate(const struct sm6_type *type) - } - } - -+static bool sm6_type_is_array(const struct sm6_type *type) -+{ -+ return type->class == TYPE_CLASS_ARRAY; -+} -+ - static inline bool sm6_type_is_struct(const struct sm6_type *type) - { - return type->class == TYPE_CLASS_STRUCT; -@@ -1364,6 +1682,27 @@ static const struct sm6_type *sm6_type_get_pointer_to_type(const struct sm6_type - return NULL; - } - -+/* Call for aggregate types only. */ -+static const struct sm6_type *sm6_type_get_element_type_at_index(const struct sm6_type *type, uint64_t elem_idx) -+{ -+ switch (type->class) -+ { -+ case TYPE_CLASS_ARRAY: -+ case TYPE_CLASS_VECTOR: -+ if (elem_idx >= type->u.array.count) -+ return NULL; -+ return type->u.array.elem_type; -+ -+ case TYPE_CLASS_STRUCT: -+ if (elem_idx >= type->u.struc->elem_count) -+ return NULL; -+ return type->u.struc->elem_types[elem_idx]; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+} -+ - /* Never returns null for elem_idx 0. */ - static const struct sm6_type *sm6_type_get_scalar_type(const struct sm6_type *type, unsigned int elem_idx) - { -@@ -1388,6 +1727,11 @@ static const struct sm6_type *sm6_type_get_scalar_type(const struct sm6_type *ty - } - } - -+static unsigned int sm6_type_max_vector_size(const struct sm6_type *type) -+{ -+ return min((VKD3D_VEC4_SIZE * sizeof(uint32_t) * CHAR_BIT) / type->u.width, VKD3D_VEC4_SIZE); -+} -+ - static const struct sm6_type *sm6_parser_get_type(struct sm6_parser *sm6, uint64_t type_id) - { - if (type_id >= sm6->type_count) -@@ -1451,7 +1795,7 @@ static enum vkd3d_result sm6_parser_symtab_init(struct sm6_parser *sm6) - - symbol = &sm6->global_symbols[sm6->global_symbol_count]; - symbol->id = record->operands[0]; -- if (!(symbol->name = dxil_record_to_string(record, 1))) -+ if (!(symbol->name = dxil_record_to_string(record, 1, sm6))) - { - ERR("Failed to allocate symbol name.\n"); - return VKD3D_ERROR_OUT_OF_MEMORY; -@@ -1492,10 +1836,10 @@ static const char *sm6_parser_get_global_symbol_name(const struct sm6_parser *sm - - static unsigned int register_get_uint_value(const struct vkd3d_shader_register *reg) - { -- if (!register_is_constant(reg) || !data_type_is_integer(reg->data_type)) -+ if (!register_is_constant(reg) || (!data_type_is_integer(reg->data_type) && !data_type_is_bool(reg->data_type))) - return UINT_MAX; - -- if (reg->immconst_type == VKD3D_IMMCONST_VEC4) -+ if (reg->dimension == VSIR_DIMENSION_VEC4) - WARN("Returning vec4.x.\n"); - - if (reg->type == VKD3DSPR_IMMCONST64) -@@ -1508,6 +1852,17 @@ static unsigned int register_get_uint_value(const struct vkd3d_shader_register * - return reg->u.immconst_uint[0]; - } - -+static uint64_t register_get_uint64_value(const struct vkd3d_shader_register *reg) -+{ -+ if (!register_is_constant(reg) || !data_type_is_integer(reg->data_type)) -+ return UINT64_MAX; -+ -+ if (reg->dimension == VSIR_DIMENSION_VEC4) -+ WARN("Returning vec4.x.\n"); -+ -+ return (reg->type == VKD3DSPR_IMMCONST64) ? reg->u.immconst_uint64[0] : reg->u.immconst_uint[0]; -+} -+ - static inline bool sm6_value_is_function_dcl(const struct sm6_value *value) - { - return value->value_type == VALUE_TYPE_FUNCTION; -@@ -1530,6 +1885,11 @@ static inline bool sm6_value_is_register(const struct sm6_value *value) - return value->value_type == VALUE_TYPE_REG; - } - -+static bool sm6_value_is_handle(const struct sm6_value *value) -+{ -+ return value->value_type == VALUE_TYPE_HANDLE; -+} -+ - static inline bool sm6_value_is_constant(const struct sm6_value *value) - { - return sm6_value_is_register(value) && register_is_constant(&value->u.reg); -@@ -1540,6 +1900,11 @@ static inline bool sm6_value_is_undef(const struct sm6_value *value) - return sm6_value_is_register(value) && value->u.reg.type == VKD3DSPR_UNDEF; - } - -+static bool sm6_value_is_icb(const struct sm6_value *value) -+{ -+ return value->value_type == VALUE_TYPE_ICB; -+} -+ - static inline unsigned int sm6_value_get_constant_uint(const struct sm6_value *value) - { - if (!sm6_value_is_constant(value)) -@@ -1547,6 +1912,11 @@ static inline unsigned int sm6_value_get_constant_uint(const struct sm6_value *v - return register_get_uint_value(&value->u.reg); - } - -+static unsigned int sm6_parser_alloc_ssa_id(struct sm6_parser *sm6) -+{ -+ return sm6->ssa_next_id++; -+} -+ - static struct vkd3d_shader_src_param *instruction_src_params_alloc(struct vkd3d_shader_instruction *ins, - unsigned int count, struct sm6_parser *sm6) - { -@@ -1555,7 +1925,7 @@ static struct vkd3d_shader_src_param *instruction_src_params_alloc(struct vkd3d_ - { - ERR("Failed to allocate src params.\n"); - vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -- "Out of memory allocating instruction src paramaters."); -+ "Out of memory allocating instruction src parameters."); - return NULL; - } - ins->src = params; -@@ -1571,7 +1941,7 @@ static struct vkd3d_shader_dst_param *instruction_dst_params_alloc(struct vkd3d_ - { - ERR("Failed to allocate dst params.\n"); - vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -- "Out of memory allocating instruction dst paramaters."); -+ "Out of memory allocating instruction dst parameters."); - return NULL; - } - ins->dst = params; -@@ -1579,16 +1949,27 @@ static struct vkd3d_shader_dst_param *instruction_dst_params_alloc(struct vkd3d_ - return params; - } - -+static void register_init_with_id(struct vkd3d_shader_register *reg, -+ enum vkd3d_shader_register_type reg_type, enum vkd3d_data_type data_type, unsigned int id) -+{ -+ vsir_register_init(reg, reg_type, data_type, 1); -+ reg->idx[0].offset = id; -+} -+ - static enum vkd3d_data_type vkd3d_data_type_from_sm6_type(const struct sm6_type *type) - { - if (type->class == TYPE_CLASS_INTEGER) - { - switch (type->u.width) - { -+ case 1: -+ return VKD3D_DATA_BOOL; - case 8: - return VKD3D_DATA_UINT8; - case 32: - return VKD3D_DATA_UINT; -+ case 64: -+ return VKD3D_DATA_UINT64; - default: - FIXME("Unhandled width %u.\n", type->u.width); - return VKD3D_DATA_UINT; -@@ -1612,6 +1993,31 @@ static enum vkd3d_data_type vkd3d_data_type_from_sm6_type(const struct sm6_type - return VKD3D_DATA_UINT; - } - -+static void register_init_ssa_vector(struct vkd3d_shader_register *reg, const struct sm6_type *type, -+ unsigned int component_count, struct sm6_parser *sm6) -+{ -+ enum vkd3d_data_type data_type; -+ unsigned int id; -+ -+ id = sm6_parser_alloc_ssa_id(sm6); -+ data_type = vkd3d_data_type_from_sm6_type(sm6_type_get_scalar_type(type, 0)); -+ register_init_with_id(reg, VKD3DSPR_SSA, data_type, id); -+ reg->dimension = component_count > 1 ? VSIR_DIMENSION_VEC4 : VSIR_DIMENSION_SCALAR; -+} -+ -+static void register_init_ssa_scalar(struct vkd3d_shader_register *reg, const struct sm6_type *type, -+ struct sm6_parser *sm6) -+{ -+ register_init_ssa_vector(reg, type, 1, sm6); -+} -+ -+static void dst_param_init(struct vkd3d_shader_dst_param *param) -+{ -+ param->write_mask = VKD3DSP_WRITEMASK_0; -+ param->modifiers = 0; -+ param->shift = 0; -+} -+ - static inline void dst_param_init_scalar(struct vkd3d_shader_dst_param *param, unsigned int component_idx) - { - param->write_mask = 1u << component_idx; -@@ -1619,40 +2025,88 @@ static inline void dst_param_init_scalar(struct vkd3d_shader_dst_param *param, u - param->shift = 0; - } - -+static void dst_param_init_vector(struct vkd3d_shader_dst_param *param, unsigned int component_count) -+{ -+ param->write_mask = (1u << component_count) - 1; -+ param->modifiers = 0; -+ param->shift = 0; -+} -+ -+static void dst_param_init_ssa_scalar(struct vkd3d_shader_dst_param *param, const struct sm6_type *type, -+ struct sm6_parser *sm6) -+{ -+ dst_param_init(param); -+ register_init_ssa_scalar(¶m->reg, type, sm6); -+} -+ - static inline void src_param_init(struct vkd3d_shader_src_param *param) - { - param->swizzle = VKD3D_SHADER_SWIZZLE(X, X, X, X); - param->modifiers = VKD3DSPSM_NONE; - } - -+static void src_param_init_scalar(struct vkd3d_shader_src_param *param, unsigned int component_idx) -+{ -+ param->swizzle = vkd3d_shader_create_swizzle(component_idx, component_idx, component_idx, component_idx); -+ param->modifiers = VKD3DSPSM_NONE; -+} -+ - static void src_param_init_from_value(struct vkd3d_shader_src_param *param, const struct sm6_value *src) - { - src_param_init(param); - param->reg = src->u.reg; - } - --static void register_address_init(struct vkd3d_shader_register *reg, const struct sm6_value *address, -- unsigned int idx, struct sm6_parser *sm6) -+static void src_param_init_vector_from_reg(struct vkd3d_shader_src_param *param, -+ const struct vkd3d_shader_register *reg) -+{ -+ param->swizzle = VKD3D_SHADER_NO_SWIZZLE; -+ param->modifiers = VKD3DSPSM_NONE; -+ param->reg = *reg; -+} -+ -+static void register_index_address_init(struct vkd3d_shader_register_index *idx, const struct sm6_value *address, -+ struct sm6_parser *sm6) - { -- assert(idx < ARRAY_SIZE(reg->idx)); - if (sm6_value_is_constant(address)) - { -- reg->idx[idx].offset = sm6_value_get_constant_uint(address); -+ idx->offset = sm6_value_get_constant_uint(address); - } - else if (sm6_value_is_undef(address)) - { -- reg->idx[idx].offset = 0; -+ idx->offset = 0; - } - else - { - struct vkd3d_shader_src_param *rel_addr = shader_parser_get_src_params(&sm6->p, 1); - if (rel_addr) - src_param_init_from_value(rel_addr, address); -- reg->idx[idx].offset = 0; -- reg->idx[idx].rel_addr = rel_addr; -+ idx->offset = 0; -+ idx->rel_addr = rel_addr; - } - } - -+static void instruction_dst_param_init_ssa_scalar(struct vkd3d_shader_instruction *ins, struct sm6_parser *sm6) -+{ -+ struct vkd3d_shader_dst_param *param = instruction_dst_params_alloc(ins, 1, sm6); -+ struct sm6_value *dst = sm6_parser_get_current_value(sm6); -+ -+ dst_param_init_ssa_scalar(param, dst->type, sm6); -+ param->write_mask = VKD3DSP_WRITEMASK_0; -+ dst->u.reg = param->reg; -+} -+ -+static void instruction_dst_param_init_ssa_vector(struct vkd3d_shader_instruction *ins, -+ unsigned int component_count, struct sm6_parser *sm6) -+{ -+ struct vkd3d_shader_dst_param *param = instruction_dst_params_alloc(ins, 1, sm6); -+ struct sm6_value *dst = sm6_parser_get_current_value(sm6); -+ -+ dst_param_init_vector(param, component_count); -+ register_init_ssa_vector(¶m->reg, sm6_type_get_scalar_type(dst->type, 0), component_count, sm6); -+ dst->u.reg = param->reg; -+} -+ - /* Recurse through the block tree while maintaining a current value count. The current - * count is the sum of the global count plus all declarations within the current function. - * Store into value_capacity the highest count seen. */ -@@ -1699,7 +2153,7 @@ static size_t sm6_parser_get_value_index(struct sm6_parser *sm6, uint64_t idx) - WARN("Ignoring upper 32 bits of relative index.\n"); - i = (uint32_t)sm6->value_count - (uint32_t)idx; - -- /* This may underflow to produce a forward reference, but it must not exceeed the final value count. */ -+ /* This may underflow to produce a forward reference, but it must not exceed the final value count. */ - if (i >= sm6->cur_max_value) - { - WARN("Invalid value index %"PRIx64" at %zu.\n", idx, sm6->value_count); -@@ -1717,6 +2171,78 @@ static size_t sm6_parser_get_value_index(struct sm6_parser *sm6, uint64_t idx) - return i; - } - -+static bool sm6_value_validate_is_register(const struct sm6_value *value, struct sm6_parser *sm6) -+{ -+ if (!sm6_value_is_register(value)) -+ { -+ WARN("Operand of type %u is not a register.\n", value->value_type); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A register operand passed to a DXIL instruction is not a register."); -+ return false; -+ } -+ return true; -+} -+ -+static bool sm6_value_validate_is_handle(const struct sm6_value *value, struct sm6_parser *sm6) -+{ -+ if (!sm6_value_is_handle(value)) -+ { -+ WARN("Handle parameter of type %u is not a handle.\n", value->value_type); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCE_HANDLE, -+ "A handle parameter passed to a DX intrinsic function is not a handle."); -+ return false; -+ } -+ return true; -+} -+ -+static bool sm6_value_validate_is_pointer(const struct sm6_value *value, struct sm6_parser *sm6) -+{ -+ if (!sm6_type_is_pointer(value->type)) -+ { -+ WARN("Operand result type class %u is not a pointer.\n", value->type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A pointer operand passed to a DXIL instruction is not a pointer."); -+ return false; -+ } -+ return true; -+} -+ -+static bool sm6_value_validate_is_numeric(const struct sm6_value *value, struct sm6_parser *sm6) -+{ -+ if (!sm6_type_is_numeric(value->type)) -+ { -+ WARN("Operand result type class %u is not numeric.\n", value->type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A numeric operand passed to a DXIL instruction is not numeric."); -+ return false; -+ } -+ return true; -+} -+ -+static bool sm6_value_validate_is_bool(const struct sm6_value *value, struct sm6_parser *sm6) -+{ -+ const struct sm6_type *type = value->type; -+ if (!sm6_type_is_bool(type)) -+ { -+ WARN("Operand of type class %u is not bool.\n", type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A bool operand of type class %u passed to a DXIL instruction is not a bool.", type->class); -+ return false; -+ } -+ return true; -+} -+ -+static const struct sm6_value *sm6_parser_get_value_safe(struct sm6_parser *sm6, unsigned int idx) -+{ -+ if (idx < sm6->value_count) -+ return &sm6->values[idx]; -+ -+ WARN("Invalid value index %u.\n", idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Invalid value index %u.", idx); -+ return NULL; -+} -+ - static size_t sm6_parser_get_value_idx_by_ref(struct sm6_parser *sm6, const struct dxil_record *record, - const struct sm6_type *fwd_type, unsigned int *rec_idx) - { -@@ -1860,12 +2386,80 @@ static inline double bitcast_uint64_to_double(uint64_t value) - return u.double_value; - } - -+static enum vkd3d_result value_allocate_constant_array(struct sm6_value *dst, const struct sm6_type *type, -+ const uint64_t *operands, struct sm6_parser *sm6) -+{ -+ struct vkd3d_shader_immediate_constant_buffer *icb; -+ const struct sm6_type *elem_type; -+ unsigned int i, size, count; -+ -+ elem_type = type->u.array.elem_type; -+ /* Multidimensional arrays are emitted in flattened form. */ -+ if (elem_type->class != TYPE_CLASS_INTEGER && elem_type->class != TYPE_CLASS_FLOAT) -+ { -+ FIXME("Unhandled element type %u for data array.\n", elem_type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "The element data type for an immediate constant buffer is not scalar integer or floating point."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ /* Arrays of bool are not used in DXIL. dxc will emit an array of int32 instead if necessary. */ -+ if (!(size = elem_type->u.width / CHAR_BIT)) -+ { -+ WARN("Invalid data type width %u.\n", elem_type->u.width); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "An immediate constant buffer is declared with boolean elements."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ size = max(size, sizeof(icb->data[0])); -+ count = type->u.array.count * size / sizeof(icb->data[0]); -+ -+ if (!(icb = vkd3d_malloc(offsetof(struct vkd3d_shader_immediate_constant_buffer, data[count])))) -+ { -+ ERR("Failed to allocate buffer, count %u.\n", count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating an immediate constant buffer of count %u.", count); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ if (!shader_instruction_array_add_icb(&sm6->p.instructions, icb)) -+ { -+ ERR("Failed to store icb object.\n"); -+ vkd3d_free(icb); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory storing an immediate constant buffer object."); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ -+ dst->value_type = VALUE_TYPE_ICB; -+ dst->u.icb = icb; -+ -+ icb->data_type = vkd3d_data_type_from_sm6_type(elem_type); -+ icb->element_count = type->u.array.count; -+ icb->component_count = 1; -+ -+ count = type->u.array.count; -+ if (size > sizeof(icb->data[0])) -+ { -+ uint64_t *data = (uint64_t *)icb->data; -+ for (i = 0; i < count; ++i) -+ data[i] = operands[i]; -+ } -+ else -+ { -+ for (i = 0; i < count; ++i) -+ icb->data[i] = operands[i]; -+ } -+ -+ return VKD3D_OK; -+} -+ - static enum vkd3d_result sm6_parser_constants_init(struct sm6_parser *sm6, const struct dxil_block *block) - { - enum vkd3d_shader_register_type reg_type = VKD3DSPR_INVALID; - const struct sm6_type *type, *elem_type; - enum vkd3d_data_type reg_data_type; - const struct dxil_record *record; -+ enum vkd3d_result ret; - struct sm6_value *dst; - size_t i, value_idx; - uint64_t value; -@@ -1911,14 +2505,19 @@ static enum vkd3d_result sm6_parser_constants_init(struct sm6_parser *sm6, const - dst = sm6_parser_get_current_value(sm6); - dst->type = type; - dst->value_type = VALUE_TYPE_REG; -- dst->u.reg.type = reg_type; -- dst->u.reg.immconst_type = VKD3D_IMMCONST_SCALAR; -- dst->u.reg.data_type = reg_data_type; -+ vsir_register_init(&dst->u.reg, reg_type, reg_data_type, 0); - - switch (record->code) - { - case CST_CODE_NULL: -- /* Register constant data is already zero-filled. */ -+ if (sm6_type_is_array(type)) -+ { -+ FIXME("Constant null arrays are not supported.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Constant null arrays are not supported."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ /* For non-aggregates, register constant data is already zero-filled. */ - break; - - case CST_CODE_INTEGER: -@@ -1961,7 +2560,19 @@ static enum vkd3d_result sm6_parser_constants_init(struct sm6_parser *sm6, const - break; - - case CST_CODE_DATA: -- WARN("Unhandled constant array.\n"); -+ if (!sm6_type_is_array(type)) -+ { -+ WARN("Invalid type %u for data constant idx %zu.\n", type->class, value_idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "The type of a constant array is not an array type."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (!dxil_record_validate_operand_count(record, type->u.array.count, type->u.array.count, sm6)) -+ return VKD3D_ERROR_INVALID_SHADER; -+ -+ if ((ret = value_allocate_constant_array(dst, type, record->operands, sm6)) < 0) -+ return ret; -+ - break; - - case CST_CODE_UNDEF: -@@ -1983,7 +2594,18 @@ static enum vkd3d_result sm6_parser_constants_init(struct sm6_parser *sm6, const - return VKD3D_OK; - } - --static struct vkd3d_shader_instruction *sm6_parser_require_space(struct sm6_parser *sm6, size_t extra) -+static bool bitcode_parse_alignment(uint64_t encoded_alignment, unsigned int *alignment) -+{ -+ if (encoded_alignment > MAX_ALIGNMENT_EXPONENT + 1) -+ { -+ *alignment = 0; -+ return false; -+ } -+ *alignment = (1u << encoded_alignment) >> 1; -+ return true; -+} -+ -+static struct vkd3d_shader_instruction *sm6_parser_require_space(struct sm6_parser *sm6, size_t extra) - { - if (!shader_instruction_array_reserve(&sm6->p.instructions, sm6->p.instructions.count + extra)) - { -@@ -1999,15 +2621,194 @@ static struct vkd3d_shader_instruction *sm6_parser_add_instruction(struct sm6_pa - { - struct vkd3d_shader_instruction *ins = sm6_parser_require_space(sm6, 1); - assert(ins); -- shader_instruction_init(ins, handler_idx); -+ vsir_instruction_init(ins, &sm6->p.location, handler_idx); - ++sm6->p.instructions.count; - return ins; - } - -+static void sm6_parser_declare_indexable_temp(struct sm6_parser *sm6, const struct sm6_type *elem_type, -+ unsigned int count, unsigned int alignment, unsigned int init, struct sm6_value *dst) -+{ -+ enum vkd3d_data_type data_type = vkd3d_data_type_from_sm6_type(elem_type); -+ struct vkd3d_shader_instruction *ins; -+ -+ ins = sm6_parser_add_instruction(sm6, VKD3DSIH_DCL_INDEXABLE_TEMP); -+ ins->declaration.indexable_temp.register_idx = sm6->indexable_temp_count++; -+ ins->declaration.indexable_temp.register_size = count; -+ ins->declaration.indexable_temp.alignment = alignment; -+ ins->declaration.indexable_temp.data_type = data_type; -+ ins->declaration.indexable_temp.component_count = 1; -+ /* The initialiser value index will be resolved later so forward references can be handled. */ -+ ins->declaration.indexable_temp.initialiser = (void *)(uintptr_t)init; -+ -+ register_init_with_id(&dst->u.reg, VKD3DSPR_IDXTEMP, data_type, ins->declaration.indexable_temp.register_idx); -+} -+ -+static bool sm6_parser_declare_global(struct sm6_parser *sm6, const struct dxil_record *record) -+{ -+ const struct sm6_type *type, *scalar_type; -+ unsigned int alignment, count; -+ uint64_t address_space, init; -+ struct sm6_value *dst; -+ bool is_constant; -+ -+ if (!dxil_record_validate_operand_min_count(record, 6, sm6)) -+ return false; -+ -+ if (!(type = sm6_parser_get_type(sm6, record->operands[0]))) -+ return false; -+ if (sm6_type_is_array(type)) -+ { -+ if (!sm6_type_is_scalar(type->u.array.elem_type)) -+ { -+ FIXME("Unsupported nested type class %u.\n", type->u.array.elem_type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Global array variables with nested type class %u are not supported.", -+ type->u.array.elem_type->class); -+ return false; -+ } -+ count = type->u.array.count; -+ scalar_type = type->u.array.elem_type; -+ } -+ else if (sm6_type_is_scalar(type)) -+ { -+ count = 1; -+ scalar_type = type; -+ } -+ else -+ { -+ FIXME("Unsupported type class %u.\n", type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Global variables of type class %u are not supported.", type->class); -+ return false; -+ } -+ -+ is_constant = record->operands[1] & GLOBALVAR_FLAG_IS_CONSTANT; -+ -+ if (record->operands[1] & GLOBALVAR_FLAG_EXPLICIT_TYPE) -+ { -+ address_space = record->operands[1] >> GLOBALVAR_ADDRESS_SPACE_SHIFT; -+ -+ if (!(type = sm6_type_get_pointer_to_type(type, address_space, sm6))) -+ { -+ WARN("Failed to get pointer type for type class %u, address space %"PRIu64".\n", -+ type->class, address_space); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_MODULE, -+ "Module does not define a pointer type for a global variable."); -+ return false; -+ } -+ } -+ else -+ { -+ if (!sm6_type_is_pointer(type)) -+ { -+ WARN("Type is not a pointer.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "The type of a global variable is not a pointer."); -+ return false; -+ } -+ address_space = type->u.pointer.addr_space; -+ } -+ -+ if ((init = record->operands[2])) -+ { -+ if (init - 1 >= sm6->value_capacity) -+ { -+ WARN("Invalid value index %"PRIu64" for initialiser.", init - 1); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Global variable initialiser value index %"PRIu64" is invalid.", init - 1); -+ return false; -+ } -+ } -+ -+ /* LINKAGE_EXTERNAL is common but not relevant here. */ -+ if (record->operands[3] != LINKAGE_EXTERNAL && record->operands[3] != LINKAGE_INTERNAL) -+ WARN("Ignoring linkage %"PRIu64".\n", record->operands[3]); -+ -+ if (!bitcode_parse_alignment(record->operands[4], &alignment)) -+ WARN("Invalid alignment %"PRIu64".\n", record->operands[4]); -+ -+ if (record->operands[5]) -+ WARN("Ignoring section code %"PRIu64".\n", record->operands[5]); -+ -+ if (!sm6_parser_get_global_symbol_name(sm6, sm6->value_count)) -+ WARN("Missing symbol name for global variable at index %zu.\n", sm6->value_count); -+ /* TODO: store global symbol names in struct vkd3d_shader_desc? */ -+ -+ if (record->operand_count > 6 && record->operands[6]) -+ WARN("Ignoring visibility %"PRIu64".\n", record->operands[6]); -+ if (record->operand_count > 7 && record->operands[7]) -+ WARN("Ignoring thread local mode %"PRIu64".\n", record->operands[7]); -+ /* record->operands[8] contains unnamed_addr, a flag indicating the address -+ * is not important, only the content is. This info is not relevant. */ -+ if (record->operand_count > 9 && record->operands[9]) -+ WARN("Ignoring external_init %"PRIu64".\n", record->operands[9]); -+ if (record->operand_count > 10 && record->operands[10]) -+ WARN("Ignoring dll storage class %"PRIu64".\n", record->operands[10]); -+ if (record->operand_count > 11 && record->operands[11]) -+ WARN("Ignoring comdat %"PRIu64".\n", record->operands[11]); -+ -+ dst = sm6_parser_get_current_value(sm6); -+ dst->type = type; -+ dst->value_type = VALUE_TYPE_REG; -+ -+ if (is_constant && !init) -+ { -+ WARN("Constant array has no initialiser.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A constant global variable has no initialiser."); -+ return false; -+ } -+ -+ if (address_space == ADDRESS_SPACE_DEFAULT) -+ { -+ sm6_parser_declare_indexable_temp(sm6, scalar_type, count, alignment, init, dst); -+ } -+ else if (address_space == ADDRESS_SPACE_GROUPSHARED) -+ { -+ FIXME("Unsupported TGSM.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "TGSM global variables are not supported."); -+ return false; -+ } -+ else -+ { -+ FIXME("Unhandled address space %"PRIu64".\n", address_space); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Global variables with address space %"PRIu64" are not supported.", address_space); -+ return false; -+ } -+ -+ ++sm6->value_count; -+ return true; -+} -+ -+static const struct vkd3d_shader_immediate_constant_buffer *resolve_forward_initialiser( -+ size_t index, struct sm6_parser *sm6) -+{ -+ const struct sm6_value *value; -+ -+ assert(index); -+ --index; -+ if (!(value = sm6_parser_get_value_safe(sm6, index)) || !sm6_value_is_icb(value)) -+ { -+ WARN("Invalid initialiser index %zu.\n", index); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Global variable initialiser value index %zu is invalid.", index); -+ return NULL; -+ } -+ else -+ { -+ return value->u.icb; -+ } -+} -+ - static enum vkd3d_result sm6_parser_globals_init(struct sm6_parser *sm6) - { - const struct dxil_block *block = &sm6->root_block; -+ struct vkd3d_shader_instruction *ins; - const struct dxil_record *record; -+ enum vkd3d_result ret; - uint64_t version; - size_t i; - -@@ -2030,7 +2831,8 @@ static enum vkd3d_result sm6_parser_globals_init(struct sm6_parser *sm6) - break; - - case MODULE_CODE_GLOBALVAR: -- FIXME("Global variables are not implemented yet.\n"); -+ if (!sm6_parser_declare_global(sm6, record)) -+ return VKD3D_ERROR_INVALID_SHADER; - break; - - case MODULE_CODE_VERSION: -@@ -2050,6 +2852,24 @@ static enum vkd3d_result sm6_parser_globals_init(struct sm6_parser *sm6) - } - } - -+ for (i = 0; i < block->child_block_count; ++i) -+ { -+ if (block->child_blocks[i]->id == CONSTANTS_BLOCK -+ && (ret = sm6_parser_constants_init(sm6, block->child_blocks[i])) < 0) -+ return ret; -+ } -+ -+ /* Resolve initialiser forward references. */ -+ for (i = 0; i < sm6->p.instructions.count; ++i) -+ { -+ ins = &sm6->p.instructions.elements[i]; -+ if (ins->handler_idx == VKD3DSIH_DCL_INDEXABLE_TEMP && ins->declaration.indexable_temp.initialiser) -+ { -+ ins->declaration.indexable_temp.initialiser = resolve_forward_initialiser( -+ (uintptr_t)ins->declaration.indexable_temp.initialiser, sm6); -+ } -+ } -+ - return VKD3D_OK; - } - -@@ -2063,7 +2883,7 @@ static void dst_param_io_init(struct vkd3d_shader_dst_param *param, - param->shift = 0; - /* DXIL types do not have signedness. Load signed elements as unsigned. */ - component_type = e->component_type == VKD3D_SHADER_COMPONENT_INT ? VKD3D_SHADER_COMPONENT_UINT : e->component_type; -- shader_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(component_type), 0); -+ vsir_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(component_type), 0); - } - - static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shader_signature *s, -@@ -2071,7 +2891,7 @@ static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shade - { - struct vkd3d_shader_dst_param *param; - const struct signature_element *e; -- unsigned int i; -+ unsigned int i, count; - - for (i = 0; i < s->element_count; ++i) - { -@@ -2079,8 +2899,11 @@ static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shade - - param = ¶ms[i]; - dst_param_io_init(param, e, reg_type); -- param->reg.idx[0].offset = i; -- param->reg.idx_count = 1; -+ count = 0; -+ if (e->register_count > 1) -+ param->reg.idx[count++].offset = 0; -+ param->reg.idx[count++].offset = i; -+ param->reg.idx_count = count; - } - } - -@@ -2112,15 +2935,25 @@ static void sm6_parser_emit_signature(struct sm6_parser *sm6, const struct shade - param = &ins->declaration.dst; - } - -+ ins->flags = e->interpolation_mode; - *param = params[i]; -+ -+ if (e->register_count > 1) -+ { -+ param->reg.idx[0].rel_addr = NULL; -+ param->reg.idx[0].offset = e->register_count; -+ } - } - } - - static void sm6_parser_init_output_signature(struct sm6_parser *sm6, const struct shader_signature *output_signature) - { -- sm6_parser_init_signature(sm6, output_signature, -- (sm6->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL) ? VKD3DSPR_COLOROUT : VKD3DSPR_OUTPUT, -- sm6->output_params); -+ sm6_parser_init_signature(sm6, output_signature, VKD3DSPR_OUTPUT, sm6->output_params); -+} -+ -+static void sm6_parser_init_input_signature(struct sm6_parser *sm6, const struct shader_signature *input_signature) -+{ -+ sm6_parser_init_signature(sm6, input_signature, VKD3DSPR_INPUT, sm6->input_params); - } - - static void sm6_parser_emit_output_signature(struct sm6_parser *sm6, const struct shader_signature *output_signature) -@@ -2128,6 +2961,14 @@ static void sm6_parser_emit_output_signature(struct sm6_parser *sm6, const struc - sm6_parser_emit_signature(sm6, output_signature, VKD3DSIH_DCL_OUTPUT, VKD3DSIH_DCL_OUTPUT_SIV, sm6->output_params); - } - -+static void sm6_parser_emit_input_signature(struct sm6_parser *sm6, const struct shader_signature *input_signature) -+{ -+ sm6_parser_emit_signature(sm6, input_signature, -+ (sm6->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL) ? VKD3DSIH_DCL_INPUT_PS : VKD3DSIH_DCL_INPUT, -+ (sm6->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL) ? VKD3DSIH_DCL_INPUT_PS_SIV : VKD3DSIH_DCL_INPUT_SIV, -+ sm6->input_params); -+} -+ - static const struct sm6_value *sm6_parser_next_function_definition(struct sm6_parser *sm6) - { - size_t i, count = sm6->function_count; -@@ -2150,6 +2991,303 @@ static struct sm6_block *sm6_block_create() - return block; - } - -+static enum vkd3d_shader_opcode map_binary_op(uint64_t code, const struct sm6_type *type_a, -+ const struct sm6_type *type_b, struct sm6_parser *sm6) -+{ -+ bool is_int = sm6_type_is_bool_i16_i32_i64(type_a); -+ bool is_bool = sm6_type_is_bool(type_a); -+ enum vkd3d_shader_opcode op; -+ bool is_valid; -+ -+ if (!is_int && !sm6_type_is_floating_point(type_a)) -+ { -+ WARN("Argument type %u is not bool, int16/32/64 or floating point.\n", type_a->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "An argument to a binary operation is not bool, int16/32/64 or floating point."); -+ return VKD3DSIH_INVALID; -+ } -+ if (type_a != type_b) -+ { -+ WARN("Type mismatch, type %u width %u vs type %u width %u.\n", type_a->class, -+ type_a->u.width, type_b->class, type_b->u.width); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "Type mismatch in binary operation arguments."); -+ } -+ -+ switch (code) -+ { -+ case BINOP_ADD: -+ case BINOP_SUB: -+ /* NEG is applied later for subtraction. */ -+ op = is_int ? VKD3DSIH_IADD : VKD3DSIH_ADD; -+ is_valid = !is_bool; -+ break; -+ case BINOP_AND: -+ op = VKD3DSIH_AND; -+ is_valid = is_int; -+ break; -+ case BINOP_ASHR: -+ op = VKD3DSIH_ISHR; -+ is_valid = is_int && !is_bool; -+ break; -+ case BINOP_LSHR: -+ op = VKD3DSIH_USHR; -+ is_valid = is_int && !is_bool; -+ break; -+ case BINOP_MUL: -+ op = is_int ? VKD3DSIH_UMUL : VKD3DSIH_MUL; -+ is_valid = !is_bool; -+ break; -+ case BINOP_OR: -+ op = VKD3DSIH_OR; -+ is_valid = is_int; -+ break; -+ case BINOP_SDIV: -+ op = is_int ? VKD3DSIH_IDIV : VKD3DSIH_DIV; -+ is_valid = !is_bool; -+ break; -+ case BINOP_SREM: -+ op = is_int ? VKD3DSIH_IDIV : VKD3DSIH_FREM; -+ is_valid = !is_bool; -+ break; -+ case BINOP_SHL: -+ op = VKD3DSIH_ISHL; -+ is_valid = is_int && !is_bool; -+ break; -+ case BINOP_UDIV: -+ case BINOP_UREM: -+ op = VKD3DSIH_UDIV; -+ is_valid = is_int && !is_bool; -+ break; -+ case BINOP_XOR: -+ op = VKD3DSIH_XOR; -+ is_valid = is_int; -+ break; -+ default: -+ FIXME("Unhandled binary op %#"PRIx64".\n", code); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Binary operation %#"PRIx64" is unhandled.", code); -+ return VKD3DSIH_INVALID; -+ } -+ -+ if (!is_valid) -+ { -+ WARN("Invalid operation %u for type %u, width %u.\n", op, type_a->class, type_a->u.width); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_INVALID_OPERATION, -+ "Binary operation %u is invalid on type class %u, width %u.", op, type_a->class, type_a->u.width); -+ } -+ -+ return op; -+} -+ -+static void sm6_parser_emit_binop(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ struct vkd3d_shader_src_param *src_params; -+ enum vkd3d_shader_opcode handler_idx; -+ const struct sm6_value *a, *b; -+ uint64_t code, flags; -+ bool silence_warning; -+ unsigned int i = 0; -+ -+ a = sm6_parser_get_value_by_ref(sm6, record, NULL, &i); -+ b = sm6_parser_get_value_by_ref(sm6, record, a->type, &i); -+ if (!a || !b) -+ return; -+ -+ if (!dxil_record_validate_operand_count(record, i + 1, i + 2, sm6)) -+ return; -+ -+ code = record->operands[i++]; -+ if ((handler_idx = map_binary_op(code, a->type, b->type, sm6)) == VKD3DSIH_INVALID) -+ return; -+ -+ vsir_instruction_init(ins, &sm6->p.location, handler_idx); -+ -+ flags = (record->operand_count > i) ? record->operands[i] : 0; -+ silence_warning = false; -+ -+ switch (handler_idx) -+ { -+ case VKD3DSIH_ADD: -+ case VKD3DSIH_MUL: -+ case VKD3DSIH_DIV: -+ case VKD3DSIH_FREM: -+ if (!(flags & FP_ALLOW_UNSAFE_ALGEBRA)) -+ ins->flags |= VKD3DSI_PRECISE_X; -+ flags &= ~FP_ALLOW_UNSAFE_ALGEBRA; -+ /* SPIR-V FPFastMathMode is only available in the Kernel executon model. */ -+ silence_warning = !(flags & ~(FP_NO_NAN | FP_NO_INF | FP_NO_SIGNED_ZEROS | FP_ALLOW_RECIPROCAL)); -+ break; -+ case VKD3DSIH_IADD: -+ case VKD3DSIH_UMUL: -+ case VKD3DSIH_ISHL: -+ silence_warning = !(flags & ~(OB_NO_UNSIGNED_WRAP | OB_NO_SIGNED_WRAP)); -+ break; -+ case VKD3DSIH_ISHR: -+ case VKD3DSIH_USHR: -+ case VKD3DSIH_IDIV: -+ case VKD3DSIH_UDIV: -+ silence_warning = !(flags & ~PEB_EXACT); -+ break; -+ default: -+ break; -+ } -+ /* The above flags are very common and cause warning spam. */ -+ if (flags && silence_warning) -+ { -+ TRACE("Ignoring flags %#"PRIx64".\n", flags); -+ } -+ else if (flags) -+ { -+ WARN("Ignoring flags %#"PRIx64".\n", flags); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Ignoring flags %#"PRIx64" for a binary operation.", flags); -+ } -+ -+ src_params = instruction_src_params_alloc(ins, 2, sm6); -+ src_param_init_from_value(&src_params[0], a); -+ src_param_init_from_value(&src_params[1], b); -+ if (code == BINOP_SUB) -+ src_params[1].modifiers = VKD3DSPSM_NEG; -+ -+ dst->type = a->type; -+ -+ if (handler_idx == VKD3DSIH_UMUL || handler_idx == VKD3DSIH_UDIV || handler_idx == VKD3DSIH_IDIV) -+ { -+ struct vkd3d_shader_dst_param *dst_params = instruction_dst_params_alloc(ins, 2, sm6); -+ unsigned int index = code != BINOP_UDIV && code != BINOP_SDIV; -+ -+ dst_param_init(&dst_params[0]); -+ dst_param_init(&dst_params[1]); -+ register_init_ssa_scalar(&dst_params[index].reg, a->type, sm6); -+ vsir_register_init(&dst_params[index ^ 1].reg, VKD3DSPR_NULL, VKD3D_DATA_UNUSED, 0); -+ dst->u.reg = dst_params[index].reg; -+ } -+ else -+ { -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+ } -+} -+ -+static void sm6_parser_emit_dx_cbuffer_load(struct sm6_parser *sm6, struct sm6_block *code_block, -+ enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins) -+{ -+ struct sm6_value *dst = sm6_parser_get_current_value(sm6); -+ struct vkd3d_shader_src_param *src_param; -+ const struct sm6_value *buffer; -+ const struct sm6_type *type; -+ -+ buffer = operands[0]; -+ if (!sm6_value_validate_is_handle(buffer, sm6)) -+ return; -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); -+ -+ src_param = instruction_src_params_alloc(ins, 1, sm6); -+ src_param_init_vector_from_reg(src_param, &buffer->u.handle.reg); -+ register_index_address_init(&src_param->reg.idx[2], operands[1], sm6); -+ assert(src_param->reg.idx_count == 3); -+ -+ type = sm6_type_get_scalar_type(dst->type, 0); -+ assert(type); -+ src_param->reg.data_type = vkd3d_data_type_from_sm6_type(type); -+ -+ instruction_dst_param_init_ssa_vector(ins, sm6_type_max_vector_size(type), sm6); -+} -+ -+static const struct sm6_descriptor_info *sm6_parser_get_descriptor(struct sm6_parser *sm6, -+ enum vkd3d_shader_descriptor_type type, unsigned int id, const struct sm6_value *address) -+{ -+ const struct sm6_descriptor_info *d; -+ unsigned int register_index; -+ size_t i; -+ -+ for (i = 0; i < sm6->descriptor_count; ++i) -+ { -+ d = &sm6->descriptors[i]; -+ -+ if (d->type != type || d->id != id) -+ continue; -+ -+ if (!sm6_value_is_constant(address)) -+ return d; -+ -+ register_index = sm6_value_get_constant_uint(address); -+ if (register_index >= d->range.first && register_index <= d->range.last) -+ return d; -+ } -+ -+ return NULL; -+} -+ -+static void sm6_parser_emit_dx_create_handle(struct sm6_parser *sm6, struct sm6_block *code_block, -+ enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins) -+{ -+ enum vkd3d_shader_descriptor_type type; -+ const struct sm6_descriptor_info *d; -+ struct vkd3d_shader_register *reg; -+ struct sm6_value *dst; -+ unsigned int id; -+ -+ type = sm6_value_get_constant_uint(operands[0]); -+ id = sm6_value_get_constant_uint(operands[1]); -+ if (!(d = sm6_parser_get_descriptor(sm6, type, id, operands[2]))) -+ { -+ WARN("Failed to find resource type %#x, id %#x.\n", type, id); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Descriptor for resource type %#x, id %#x was not found.", type, id); -+ return; -+ } -+ -+ dst = sm6_parser_get_current_value(sm6); -+ dst->value_type = VALUE_TYPE_HANDLE; -+ dst->u.handle.d = d; -+ -+ reg = &dst->u.handle.reg; -+ /* Set idx_count to 3 for use with load instructions. -+ * TODO: set register type from resource type when other types are supported. */ -+ vsir_register_init(reg, VKD3DSPR_CONSTBUFFER, VKD3D_DATA_FLOAT, 3); -+ reg->idx[0].offset = id; -+ register_index_address_init(®->idx[1], operands[2], sm6); -+ reg->non_uniform = !!sm6_value_get_constant_uint(operands[3]); -+ -+ /* NOP is used to flag no instruction emitted. */ -+ ins->handler_idx = VKD3DSIH_NOP; -+} -+ -+static void sm6_parser_emit_dx_load_input(struct sm6_parser *sm6, struct sm6_block *code_block, -+ enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins) -+{ -+ struct vkd3d_shader_src_param *src_param; -+ const struct shader_signature *signature; -+ unsigned int row_index, column_index; -+ const struct signature_element *e; -+ -+ row_index = sm6_value_get_constant_uint(operands[0]); -+ column_index = sm6_value_get_constant_uint(operands[2]); -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); -+ -+ signature = &sm6->p.shader_desc.input_signature; -+ if (row_index >= signature->element_count) -+ { -+ WARN("Invalid row index %u.\n", row_index); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Invalid input row index %u.", row_index); -+ return; -+ } -+ e = &signature->elements[row_index]; -+ -+ src_param = instruction_src_params_alloc(ins, 1, sm6); -+ src_param->reg = sm6->input_params[row_index].reg; -+ src_param_init_scalar(src_param, column_index); -+ if (e->register_count > 1) -+ register_index_address_init(&src_param->reg.idx[0], operands[1], sm6); -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+} -+ - static void sm6_parser_emit_dx_store_output(struct sm6_parser *sm6, struct sm6_block *code_block, - enum dx_intrinsic_opcode op, const struct sm6_value **operands, struct vkd3d_shader_instruction *ins) - { -@@ -2190,14 +3328,14 @@ static void sm6_parser_emit_dx_store_output(struct sm6_parser *sm6, struct sm6_b - return; - } - -- shader_instruction_init(ins, VKD3DSIH_MOV); -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); - - if (!(dst_param = instruction_dst_params_alloc(ins, 1, sm6))) - return; - dst_param_init_scalar(dst_param, column_index); - dst_param->reg = sm6->output_params[row_index].reg; - if (e->register_count > 1) -- register_address_init(&dst_param->reg, operands[1], 0, sm6); -+ register_index_address_init(&dst_param->reg.idx[0], operands[1], sm6); - - if ((src_param = instruction_src_params_alloc(ins, 1, sm6))) - src_param_init_from_value(src_param, value); -@@ -2213,17 +3351,29 @@ struct sm6_dx_opcode_info - - /* - 8 -> int8 -+ b -> constant int1 -+ c -> constant int8/16/32 - i -> int32 -+ H -> handle - v -> void - o -> overloaded - */ - static const struct sm6_dx_opcode_info sm6_dx_op_table[] = - { -+ [DX_CBUFFER_LOAD_LEGACY ] = {'o', "Hi", sm6_parser_emit_dx_cbuffer_load}, -+ [DX_CREATE_HANDLE ] = {'H', "ccib", sm6_parser_emit_dx_create_handle}, -+ [DX_LOAD_INPUT ] = {'o', "ii8i", sm6_parser_emit_dx_load_input}, - [DX_STORE_OUTPUT ] = {'v', "ii8o", sm6_parser_emit_dx_store_output}, - }; - --static bool sm6_parser_validate_operand_type(struct sm6_parser *sm6, const struct sm6_type *type, char info_type) -+static bool sm6_parser_validate_operand_type(struct sm6_parser *sm6, const struct sm6_value *value, char info_type, -+ bool is_return) - { -+ const struct sm6_type *type = value->type; -+ -+ if (info_type != 'H' && !sm6_value_is_register(value)) -+ return false; -+ - switch (info_type) - { - case 0: -@@ -2231,8 +3381,15 @@ static bool sm6_parser_validate_operand_type(struct sm6_parser *sm6, const struc - return false; - case '8': - return sm6_type_is_i8(type); -+ case 'b': -+ return sm6_value_is_constant(value) && sm6_type_is_bool(type); -+ case 'c': -+ return sm6_value_is_constant(value) && sm6_type_is_integer(type) && type->u.width >= 8 -+ && type->u.width <= 32; - case 'i': - return sm6_type_is_i32(type); -+ case 'H': -+ return (is_return || sm6_value_is_handle(value)) && type == sm6->handle_type; - case 'v': - return !type; - case 'o': -@@ -2252,7 +3409,7 @@ static bool sm6_parser_validate_dx_op(struct sm6_parser *sm6, enum dx_intrinsic_ - - info = &sm6_dx_op_table[op]; - -- if (!sm6_parser_validate_operand_type(sm6, dst->type, info->ret_type)) -+ if (!sm6_parser_validate_operand_type(sm6, dst, info->ret_type, true)) - { - WARN("Failed to validate return type for dx intrinsic id %u, '%s'.\n", op, name); - /* Return type validation failure is not so critical. We only need to set -@@ -2262,7 +3419,7 @@ static bool sm6_parser_validate_dx_op(struct sm6_parser *sm6, enum dx_intrinsic_ - for (i = 0; i < operand_count; ++i) - { - const struct sm6_value *value = operands[i]; -- if (!sm6_value_is_register(value) || !sm6_parser_validate_operand_type(sm6, value->type, info->operand_info[i])) -+ if (!sm6_parser_validate_operand_type(sm6, value, info->operand_info[i], false)) - { - WARN("Failed to validate operand %u for dx intrinsic id %u, '%s'.\n", i + 1, op, name); - vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -@@ -2292,7 +3449,7 @@ static void sm6_parser_emit_unhandled(struct sm6_parser *sm6, struct vkd3d_shade - return; - - type = sm6_type_get_scalar_type(dst->type, 0); -- shader_register_init(&dst->u.reg, VKD3DSPR_UNDEF, vkd3d_data_type_from_sm6_type(type), 0); -+ vsir_register_init(&dst->u.reg, VKD3DSPR_UNDEF, vkd3d_data_type_from_sm6_type(type), 0); - /* dst->is_undefined is not set here because it flags only explicitly undefined values. */ - } - -@@ -2303,7 +3460,7 @@ static void sm6_parser_decode_dx_op(struct sm6_parser *sm6, struct sm6_block *co - if (op >= ARRAY_SIZE(sm6_dx_op_table) || !sm6_dx_op_table[op].operand_info) - { - FIXME("Unhandled dx intrinsic function id %u, '%s'.\n", op, name); -- vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_UNHANDLED_INTRINSIC, -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_UNHANDLED_INTRINSIC, - "Call to intrinsic function %s is unhandled.", name); - sm6_parser_emit_unhandled(sm6, ins, dst); - return; -@@ -2372,238 +3529,1860 @@ static void sm6_parser_emit_call(struct sm6_parser *sm6, const struct dxil_recor - "Ignoring %u function call operands beyond the parameter list.", j); - } - -- if (!fn_value->u.function.is_prototype) -+ if (!fn_value->u.function.is_prototype) -+ { -+ FIXME("Unhandled call to local function.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Call to a local function is unsupported."); -+ return; -+ } -+ if (!sm6_value_is_dx_intrinsic_dcl(fn_value)) -+ WARN("External function is not a dx intrinsic.\n"); -+ -+ if (!operand_count) -+ { -+ WARN("Missing dx intrinsic function id.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT, -+ "The id for a dx intrinsic function is missing."); -+ return; -+ } -+ -+ op_value = operands[0]; -+ if (!sm6_value_is_constant(op_value) || !sm6_type_is_integer(op_value->type)) -+ { -+ WARN("dx intrinsic function id is not a constant int.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Expected a constant integer dx intrinsic function id."); -+ return; -+ } -+ sm6_parser_decode_dx_op(sm6, code_block, register_get_uint_value(&op_value->u.reg), -+ fn_value->u.function.name, &operands[1], operand_count - 1, ins, dst); -+} -+ -+static enum vkd3d_shader_opcode sm6_map_cast_op(uint64_t code, const struct sm6_type *from, -+ const struct sm6_type *to, struct sm6_parser *sm6) -+{ -+ enum vkd3d_shader_opcode op = VKD3DSIH_INVALID; -+ bool from_int, to_int, from_fp, to_fp; -+ bool is_valid = false; -+ -+ from_int = sm6_type_is_integer(from); -+ to_int = sm6_type_is_integer(to); -+ from_fp = sm6_type_is_floating_point(from); -+ to_fp = sm6_type_is_floating_point(to); -+ -+ /* NOTE: DXIL currently doesn't use vectors here. */ -+ if ((!from_int && !from_fp) || (!to_int && !to_fp)) -+ { -+ FIXME("Unhandled cast of type class %u to type class %u.\n", from->class, to->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Cast of type class %u to type class %u is not implemented.", from->class, to->class); -+ return VKD3DSIH_INVALID; -+ } -+ if (to->u.width == 8 || from->u.width == 8) -+ { -+ FIXME("Unhandled 8-bit value.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Cast to/from an 8-bit type is not implemented."); -+ return VKD3DSIH_INVALID; -+ } -+ -+ /* DXC emits minimum precision types as 16-bit. These must be emitted -+ * as 32-bit in VSIR, so all width extensions to 32 bits are no-ops. */ -+ switch (code) -+ { -+ case CAST_TRUNC: -+ /* nop or min precision. TODO: native 16-bit */ -+ if (to->u.width == from->u.width || (to->u.width == 16 && from->u.width == 32)) -+ op = VKD3DSIH_NOP; -+ else -+ op = VKD3DSIH_UTOU; -+ is_valid = from_int && to_int && to->u.width <= from->u.width; -+ break; -+ case CAST_ZEXT: -+ case CAST_SEXT: -+ /* nop or min precision. TODO: native 16-bit */ -+ if (to->u.width == from->u.width || (to->u.width == 32 && from->u.width == 16)) -+ { -+ op = VKD3DSIH_NOP; -+ is_valid = from_int && to_int; -+ } -+ else if (to->u.width > from->u.width) -+ { -+ op = (code == CAST_ZEXT) ? VKD3DSIH_UTOU : VKD3DSIH_ITOI; -+ assert(from->u.width == 1 || to->u.width == 64); -+ is_valid = from_int && to_int; -+ } -+ break; -+ case CAST_FPTOUI: -+ op = VKD3DSIH_FTOU; -+ is_valid = from_fp && to_int && to->u.width > 1; -+ break; -+ case CAST_FPTOSI: -+ op = VKD3DSIH_FTOI; -+ is_valid = from_fp && to_int && to->u.width > 1; -+ break; -+ case CAST_UITOFP: -+ op = VKD3DSIH_UTOF; -+ is_valid = from_int && to_fp; -+ break; -+ case CAST_SITOFP: -+ op = VKD3DSIH_ITOF; -+ is_valid = from_int && to_fp; -+ break; -+ case CAST_FPTRUNC: -+ /* TODO: native 16-bit */ -+ op = (from->u.width == 64) ? VKD3DSIH_DTOF : VKD3DSIH_NOP; -+ is_valid = from_fp && to_fp; -+ break; -+ case CAST_FPEXT: -+ /* TODO: native 16-bit */ -+ op = (to->u.width == 64) ? VKD3DSIH_FTOD : VKD3DSIH_NOP; -+ is_valid = from_fp && to_fp; -+ break; -+ case CAST_BITCAST: -+ op = VKD3DSIH_MOV; -+ is_valid = to->u.width == from->u.width; -+ break; -+ default: -+ FIXME("Unhandled cast op %"PRIu64".\n", code); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Cast operation %"PRIu64" is unhandled.\n", code); -+ return VKD3DSIH_INVALID; -+ } -+ -+ if (!is_valid) -+ { -+ FIXME("Invalid types %u and/or %u for op %"PRIu64".\n", from->class, to->class, code); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Cast operation %"PRIu64" from type class %u, width %u to type class %u, width %u is invalid.\n", -+ code, from->class, from->u.width, to->class, to->u.width); -+ return VKD3DSIH_INVALID; -+ } -+ -+ return op; -+} -+ -+static void sm6_parser_emit_cast(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ struct vkd3d_shader_src_param *src_param; -+ enum vkd3d_shader_opcode handler_idx; -+ const struct sm6_value *value; -+ const struct sm6_type *type; -+ unsigned int i = 0; -+ -+ if (!(value = sm6_parser_get_value_by_ref(sm6, record, NULL, &i))) -+ return; -+ -+ if (!dxil_record_validate_operand_count(record, i + 2, i + 2, sm6)) -+ return; -+ -+ if (!(type = sm6_parser_get_type(sm6, record->operands[i++]))) -+ return; -+ -+ dst->type = type; -+ -+ if (sm6_type_is_pointer(type)) -+ { -+ *dst = *value; -+ dst->type = type; -+ ins->handler_idx = VKD3DSIH_NOP; -+ return; -+ } -+ -+ if ((handler_idx = sm6_map_cast_op(record->operands[i], value->type, type, sm6)) == VKD3DSIH_INVALID) -+ return; -+ -+ vsir_instruction_init(ins, &sm6->p.location, handler_idx); -+ -+ if (handler_idx == VKD3DSIH_NOP) -+ { -+ dst->u.reg = value->u.reg; -+ return; -+ } -+ -+ src_param = instruction_src_params_alloc(ins, 1, sm6); -+ src_param_init_from_value(src_param, value); -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+ -+ /* bitcast */ -+ if (handler_idx == VKD3DSIH_MOV) -+ src_param->reg.data_type = dst->u.reg.data_type; -+} -+ -+struct sm6_cmp_info -+{ -+ enum vkd3d_shader_opcode handler_idx; -+ bool src_swap; -+}; -+ -+static const struct sm6_cmp_info *sm6_map_cmp2_op(uint64_t code) -+{ -+ static const struct sm6_cmp_info cmp_op_table[] = -+ { -+ [FCMP_FALSE] = {VKD3DSIH_INVALID}, -+ [FCMP_OEQ] = {VKD3DSIH_EQO}, -+ [FCMP_OGT] = {VKD3DSIH_LTO, true}, -+ [FCMP_OGE] = {VKD3DSIH_GEO}, -+ [FCMP_OLT] = {VKD3DSIH_LTO}, -+ [FCMP_OLE] = {VKD3DSIH_GEO, true}, -+ [FCMP_ONE] = {VKD3DSIH_NEO}, -+ [FCMP_ORD] = {VKD3DSIH_INVALID}, -+ [FCMP_UNO] = {VKD3DSIH_INVALID}, -+ [FCMP_UEQ] = {VKD3DSIH_EQU}, -+ [FCMP_UGT] = {VKD3DSIH_LTU, true}, -+ [FCMP_UGE] = {VKD3DSIH_GEU}, -+ [FCMP_ULT] = {VKD3DSIH_LTU}, -+ [FCMP_ULE] = {VKD3DSIH_GEU, true}, -+ [FCMP_UNE] = {VKD3DSIH_NEU}, -+ [FCMP_TRUE] = {VKD3DSIH_INVALID}, -+ -+ [ICMP_EQ] = {VKD3DSIH_IEQ}, -+ [ICMP_NE] = {VKD3DSIH_INE}, -+ [ICMP_UGT] = {VKD3DSIH_ULT, true}, -+ [ICMP_UGE] = {VKD3DSIH_UGE}, -+ [ICMP_ULT] = {VKD3DSIH_ULT}, -+ [ICMP_ULE] = {VKD3DSIH_UGE, true}, -+ [ICMP_SGT] = {VKD3DSIH_ILT, true}, -+ [ICMP_SGE] = {VKD3DSIH_IGE}, -+ [ICMP_SLT] = {VKD3DSIH_ILT}, -+ [ICMP_SLE] = {VKD3DSIH_IGE, true}, -+ }; -+ -+ return (code < ARRAY_SIZE(cmp_op_table)) ? &cmp_op_table[code] : NULL; -+} -+ -+static void sm6_parser_emit_cmp2(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ struct vkd3d_shader_src_param *src_params; -+ const struct sm6_type *type_a, *type_b; -+ bool is_int, is_fp, silence_warning; -+ const struct sm6_cmp_info *cmp; -+ const struct sm6_value *a, *b; -+ uint64_t code, flags; -+ unsigned int i = 0; -+ -+ if (!(dst->type = sm6->bool_type)) -+ { -+ WARN("Bool type not found.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_MODULE, -+ "Module does not define a boolean type for comparison results."); -+ return; -+ } -+ -+ a = sm6_parser_get_value_by_ref(sm6, record, NULL, &i); -+ b = sm6_parser_get_value_by_ref(sm6, record, a->type, &i); -+ if (!a || !b) -+ return; -+ -+ if (!dxil_record_validate_operand_count(record, i + 1, i + 2, sm6)) -+ return; -+ -+ type_a = a->type; -+ type_b = b->type; -+ is_int = sm6_type_is_bool_i16_i32_i64(type_a); -+ is_fp = sm6_type_is_floating_point(type_a); -+ -+ code = record->operands[i++]; -+ -+ if ((!is_int && !is_fp) || is_int != (code >= ICMP_EQ)) -+ { -+ FIXME("Invalid operation %"PRIu64" on type class %u.\n", code, type_a->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Comparison operation %"PRIu64" on type class %u is invalid.", code, type_a->class); -+ return; -+ } -+ -+ if (type_a != type_b) -+ { -+ WARN("Type mismatch, type %u width %u vs type %u width %u.\n", type_a->class, -+ type_a->u.width, type_b->class, type_b->u.width); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "Type mismatch in comparison operation arguments."); -+ } -+ -+ if (!(cmp = sm6_map_cmp2_op(code)) || !cmp->handler_idx || cmp->handler_idx == VKD3DSIH_INVALID) -+ { -+ FIXME("Unhandled operation %"PRIu64".\n", code); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Comparison operation %"PRIu64" is unhandled.", code); -+ return; -+ } -+ -+ vsir_instruction_init(ins, &sm6->p.location, cmp->handler_idx); -+ -+ flags = (record->operand_count > i) ? record->operands[i] : 0; -+ silence_warning = false; -+ -+ if (is_fp) -+ { -+ if (!(flags & FP_ALLOW_UNSAFE_ALGEBRA)) -+ ins->flags |= VKD3DSI_PRECISE_X; -+ flags &= ~FP_ALLOW_UNSAFE_ALGEBRA; -+ /* SPIR-V FPFastMathMode is only available in the Kernel execution model. */ -+ silence_warning = !(flags & ~(FP_NO_NAN | FP_NO_INF | FP_NO_SIGNED_ZEROS | FP_ALLOW_RECIPROCAL)); -+ } -+ if (flags && silence_warning) -+ { -+ TRACE("Ignoring fast FP modifier %#"PRIx64".\n", flags); -+ } -+ else if (flags) -+ { -+ WARN("Ignoring flags %#"PRIx64".\n", flags); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Ignoring flags %#"PRIx64" for a comparison operation.", flags); -+ } -+ -+ src_params = instruction_src_params_alloc(ins, 2, sm6); -+ src_param_init_from_value(&src_params[0 ^ cmp->src_swap], a); -+ src_param_init_from_value(&src_params[1 ^ cmp->src_swap], b); -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+} -+ -+static void sm6_parser_emit_extractval(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ struct vkd3d_shader_src_param *src_param; -+ const struct sm6_type *type; -+ const struct sm6_value *src; -+ unsigned int i = 0; -+ uint64_t elem_idx; -+ -+ if (!(src = sm6_parser_get_value_by_ref(sm6, record, NULL, &i))) -+ return; -+ -+ if (!dxil_record_validate_operand_min_count(record, i + 1, sm6)) -+ return; -+ -+ if (record->operand_count > i + 1) -+ { -+ FIXME("Unhandled multiple indices.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Multiple extractval indices are not supported."); -+ return; -+ } -+ -+ type = src->type; -+ if (!sm6_type_is_aggregate(type)) -+ { -+ WARN("Invalid extraction from non-aggregate.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Source type of an extractval instruction is not an aggregate."); -+ return; -+ } -+ -+ elem_idx = record->operands[i]; -+ if (!(type = sm6_type_get_element_type_at_index(type, elem_idx))) -+ { -+ WARN("Invalid element index %"PRIu64".\n", elem_idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Element index %"PRIu64" for an extractval instruction is out of bounds.", elem_idx); -+ return; -+ } -+ if (!sm6_type_is_scalar(type)) -+ { -+ FIXME("Nested extraction is not supported.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Extraction from nested aggregates is not supported."); -+ return; -+ } -+ dst->type = type; -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); -+ -+ src_param = instruction_src_params_alloc(ins, 1, sm6); -+ src_param_init_from_value(src_param, src); -+ src_param->swizzle = vkd3d_shader_create_swizzle(elem_idx, elem_idx, elem_idx, elem_idx); -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+} -+ -+static void sm6_parser_emit_gep(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ const struct sm6_type *type, *pointee_type; -+ unsigned int elem_idx, operand_idx = 2; -+ enum bitcode_address_space addr_space; -+ const struct sm6_value *elem_value; -+ struct vkd3d_shader_register *reg; -+ const struct sm6_value *src; -+ bool is_in_bounds; -+ -+ if (!dxil_record_validate_operand_min_count(record, 5, sm6) -+ || !(type = sm6_parser_get_type(sm6, record->operands[1])) -+ || !(src = sm6_parser_get_value_by_ref(sm6, record, NULL, &operand_idx)) -+ || !sm6_value_validate_is_register(src, sm6) -+ || !sm6_value_validate_is_pointer(src, sm6) -+ || !dxil_record_validate_operand_min_count(record, operand_idx + 2, sm6)) -+ { -+ return; -+ } -+ -+ if (src->u.reg.idx_count > 1) -+ { -+ WARN("Unsupported stacked GEP.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "A GEP instruction on the result of a previous GEP is unsupported."); -+ return; -+ } -+ -+ is_in_bounds = record->operands[0]; -+ -+ if ((pointee_type = src->type->u.pointer.type) != type) -+ { -+ WARN("Type mismatch, type %u width %u vs type %u width %u.\n", type->class, -+ type->u.width, pointee_type->class, pointee_type->u.width); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "Type mismatch in GEP operation arguments."); -+ } -+ addr_space = src->type->u.pointer.addr_space; -+ -+ if (!(elem_value = sm6_parser_get_value_by_ref(sm6, record, NULL, &operand_idx))) -+ return; -+ -+ /* The first index is always zero, to form a simple pointer dereference. */ -+ if (sm6_value_get_constant_uint(elem_value)) -+ { -+ WARN("Expected constant zero.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "The pointer dereference index for a GEP instruction is not constant zero."); -+ return; -+ } -+ -+ if (!sm6_type_is_array(pointee_type)) -+ { -+ WARN("Invalid GEP on type class %u.\n", pointee_type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Source type for index 1 of a GEP instruction is not an array."); -+ return; -+ } -+ -+ if (!(elem_value = sm6_parser_get_value_by_ref(sm6, record, NULL, &operand_idx))) -+ return; -+ -+ /* If indexing is dynamic, just get the type at offset zero. */ -+ elem_idx = sm6_value_is_constant(elem_value) ? sm6_value_get_constant_uint(elem_value) : 0; -+ type = sm6_type_get_element_type_at_index(pointee_type, elem_idx); -+ if (!type) -+ { -+ WARN("Invalid element index %u.\n", elem_idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Element index %u for a GEP instruction is out of bounds.", elem_idx); -+ return; -+ } -+ -+ if (operand_idx < record->operand_count) -+ { -+ FIXME("Multiple element indices are not implemented.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Multi-dimensional addressing in GEP instructions is not supported."); -+ return; -+ } -+ -+ if (!(dst->type = sm6_type_get_pointer_to_type(type, addr_space, sm6))) -+ { -+ WARN("Failed to get pointer type for type %u.\n", type->class); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_MODULE, -+ "Module does not define a pointer type for a GEP instruction."); -+ return; -+ } -+ -+ reg = &dst->u.reg; -+ *reg = src->u.reg; -+ reg->idx[1].offset = 0; -+ register_index_address_init(®->idx[1], elem_value, sm6); -+ reg->idx[1].is_in_bounds = is_in_bounds; -+ reg->idx_count = 2; -+ -+ ins->handler_idx = VKD3DSIH_NOP; -+} -+ -+static void sm6_parser_emit_load(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ const struct sm6_type *elem_type = NULL, *pointee_type; -+ struct vkd3d_shader_src_param *src_param; -+ unsigned int alignment, i = 0; -+ const struct sm6_value *ptr; -+ uint64_t alignment_code; -+ -+ if (!(ptr = sm6_parser_get_value_by_ref(sm6, record, NULL, &i))) -+ return; -+ if (!sm6_value_validate_is_register(ptr, sm6) -+ || !sm6_value_validate_is_pointer(ptr, sm6) -+ || !dxil_record_validate_operand_count(record, i + 2, i + 3, sm6)) -+ return; -+ -+ if (record->operand_count > i + 2 && !(elem_type = sm6_parser_get_type(sm6, record->operands[i++]))) -+ return; -+ -+ if (!elem_type) -+ { -+ elem_type = ptr->type->u.pointer.type; -+ } -+ else if (elem_type != (pointee_type = ptr->type->u.pointer.type)) -+ { -+ WARN("Type mismatch.\n"); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "Type mismatch in pointer load arguments."); -+ } -+ -+ dst->type = elem_type; -+ -+ if (!sm6_value_validate_is_numeric(dst, sm6)) -+ return; -+ -+ alignment_code = record->operands[i++]; -+ if (!bitcode_parse_alignment(alignment_code, &alignment)) -+ WARN("Invalid alignment %"PRIu64".\n", alignment_code); -+ -+ if (record->operands[i]) -+ WARN("Ignoring volatile modifier.\n"); -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); -+ -+ src_param = instruction_src_params_alloc(ins, 1, sm6); -+ src_param_init_from_value(&src_param[0], ptr); -+ src_param->reg.alignment = alignment; -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+} -+ -+static void sm6_parser_emit_ret(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct sm6_block *code_block, struct vkd3d_shader_instruction *ins) -+{ -+ if (!dxil_record_validate_operand_count(record, 0, 1, sm6)) -+ return; -+ -+ if (record->operand_count) -+ FIXME("Non-void return is not implemented.\n"); -+ -+ ins->handler_idx = VKD3DSIH_NOP; -+} -+ -+static void sm6_parser_emit_vselect(struct sm6_parser *sm6, const struct dxil_record *record, -+ struct vkd3d_shader_instruction *ins, struct sm6_value *dst) -+{ -+ struct vkd3d_shader_src_param *src_params; -+ const struct sm6_value *src[3]; -+ unsigned int i = 0; -+ -+ if (!(src[1] = sm6_parser_get_value_by_ref(sm6, record, NULL, &i)) -+ || !(src[2] = sm6_parser_get_value_by_ref(sm6, record, src[1]->type, &i)) -+ || !(src[0] = sm6_parser_get_value_by_ref(sm6, record, NULL, &i))) -+ { -+ return; -+ } -+ dxil_record_validate_operand_max_count(record, i, sm6); -+ -+ for (i = 0; i < 3; ++i) -+ { -+ if (!sm6_value_validate_is_register(src[i], sm6)) -+ return; -+ } -+ -+ dst->type = src[1]->type; -+ -+ if (!sm6_value_validate_is_bool(src[0], sm6)) -+ return; -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOVC); -+ -+ src_params = instruction_src_params_alloc(ins, 3, sm6); -+ for (i = 0; i < 3; ++i) -+ src_param_init_from_value(&src_params[i], src[i]); -+ -+ instruction_dst_param_init_ssa_scalar(ins, sm6); -+} -+ -+static bool sm6_metadata_value_is_node(const struct sm6_metadata_value *m) -+{ -+ return m && m->type == VKD3D_METADATA_NODE; -+} -+ -+static bool sm6_metadata_value_is_value(const struct sm6_metadata_value *m) -+{ -+ return m && m->type == VKD3D_METADATA_VALUE; -+} -+ -+static bool sm6_metadata_value_is_string(const struct sm6_metadata_value *m) -+{ -+ return m && m->type == VKD3D_METADATA_STRING; -+} -+ -+static bool sm6_metadata_get_uint_value(const struct sm6_parser *sm6, -+ const struct sm6_metadata_value *m, unsigned int *u) -+{ -+ const struct sm6_value *value; -+ -+ if (!m || m->type != VKD3D_METADATA_VALUE) -+ return false; -+ -+ value = m->u.value; -+ if (!sm6_value_is_constant(value)) -+ return false; -+ if (!sm6_type_is_integer(value->type)) -+ return false; -+ -+ *u = register_get_uint_value(&value->u.reg); -+ -+ return true; -+} -+ -+static bool sm6_metadata_get_uint64_value(const struct sm6_parser *sm6, -+ const struct sm6_metadata_value *m, uint64_t *u) -+{ -+ const struct sm6_value *value; -+ -+ if (!m || m->type != VKD3D_METADATA_VALUE) -+ return false; -+ -+ value = m->u.value; -+ if (!sm6_value_is_constant(value)) -+ return false; -+ if (!sm6_type_is_integer(value->type)) -+ return false; -+ -+ *u = register_get_uint64_value(&value->u.reg); -+ -+ return true; -+} -+ -+static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block, -+ struct sm6_function *function) -+{ -+ struct vkd3d_shader_instruction *ins; -+ size_t i, block_idx, block_count; -+ const struct dxil_record *record; -+ bool ret_found, is_terminator; -+ struct sm6_block *code_block; -+ struct sm6_value *dst; -+ -+ if (sm6->function_count) -+ { -+ FIXME("Multiple functions are not supported yet.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (!(function->declaration = sm6_parser_next_function_definition(sm6))) -+ { -+ WARN("Failed to find definition to match function body.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (block->record_count < 2) -+ { -+ /* It should contain at least a block count and a RET instruction. */ -+ WARN("Invalid function block record count %zu.\n", block->record_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (block->records[0]->code != FUNC_CODE_DECLAREBLOCKS || !block->records[0]->operand_count -+ || block->records[0]->operands[0] > UINT_MAX) -+ { -+ WARN("Block count declaration not found or invalid.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!(block_count = block->records[0]->operands[0])) -+ { -+ WARN("Function contains no blocks.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (block_count > 1) -+ { -+ FIXME("Branched shaders are not supported yet.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!(function->blocks[0] = sm6_block_create())) -+ { -+ ERR("Failed to allocate code block.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ function->block_count = block_count; -+ code_block = function->blocks[0]; -+ -+ sm6->cur_max_value = function->value_count; -+ -+ for (i = 1, block_idx = 0, ret_found = false; i < block->record_count; ++i) -+ { -+ sm6->p.location.column = i; -+ -+ if (!code_block) -+ { -+ WARN("Invalid block count %zu.\n", function->block_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -+ "Invalid block count %zu.", function->block_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ /* block->record_count - 1 is the instruction count, but some instructions -+ * can emit >1 IR instruction, so extra may be used. */ -+ if (!vkd3d_array_reserve((void **)&code_block->instructions, &code_block->instruction_capacity, -+ max(code_block->instruction_count + 1, block->record_count), sizeof(*code_block->instructions))) -+ { -+ ERR("Failed to allocate instructions.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ -+ ins = &code_block->instructions[code_block->instruction_count]; -+ ins->handler_idx = VKD3DSIH_INVALID; -+ -+ dst = sm6_parser_get_current_value(sm6); -+ dst->type = NULL; -+ dst->value_type = VALUE_TYPE_REG; -+ is_terminator = false; -+ -+ record = block->records[i]; -+ switch (record->code) -+ { -+ case FUNC_CODE_INST_BINOP: -+ sm6_parser_emit_binop(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_CALL: -+ sm6_parser_emit_call(sm6, record, code_block, ins, dst); -+ break; -+ case FUNC_CODE_INST_CAST: -+ sm6_parser_emit_cast(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_CMP2: -+ sm6_parser_emit_cmp2(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_EXTRACTVAL: -+ sm6_parser_emit_extractval(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_GEP: -+ sm6_parser_emit_gep(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_LOAD: -+ sm6_parser_emit_load(sm6, record, ins, dst); -+ break; -+ case FUNC_CODE_INST_RET: -+ sm6_parser_emit_ret(sm6, record, code_block, ins); -+ is_terminator = true; -+ ret_found = true; -+ break; -+ case FUNC_CODE_INST_VSELECT: -+ sm6_parser_emit_vselect(sm6, record, ins, dst); -+ break; -+ default: -+ FIXME("Unhandled dxil instruction %u.\n", record->code); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (sm6->p.failed) -+ return VKD3D_ERROR; -+ assert(ins->handler_idx != VKD3DSIH_INVALID); -+ -+ if (is_terminator) -+ { -+ ++block_idx; -+ code_block = (block_idx < function->block_count) ? function->blocks[block_idx] : NULL; -+ } -+ if (code_block) -+ code_block->instruction_count += ins->handler_idx != VKD3DSIH_NOP; -+ else -+ assert(ins->handler_idx == VKD3DSIH_NOP); -+ -+ sm6->value_count += !!dst->type; -+ } -+ -+ if (!ret_found) -+ { -+ WARN("Function contains no RET instruction.\n"); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ return VKD3D_OK; -+} -+ -+static bool sm6_block_emit_instructions(struct sm6_block *block, struct sm6_parser *sm6) -+{ -+ struct vkd3d_shader_instruction *ins = sm6_parser_require_space(sm6, block->instruction_count + 1); -+ -+ if (!ins) -+ return false; -+ -+ memcpy(ins, block->instructions, block->instruction_count * sizeof(*block->instructions)); -+ sm6->p.instructions.count += block->instruction_count; -+ -+ sm6_parser_add_instruction(sm6, VKD3DSIH_RET); -+ -+ return true; -+} -+ -+static enum vkd3d_result sm6_parser_module_init(struct sm6_parser *sm6, const struct dxil_block *block, -+ unsigned int level) -+{ -+ size_t i, old_value_count = sm6->value_count; -+ struct sm6_function *function; -+ enum vkd3d_result ret; -+ -+ for (i = 0; i < block->child_block_count; ++i) -+ { -+ if ((ret = sm6_parser_module_init(sm6, block->child_blocks[i], level + 1)) < 0) -+ return ret; -+ } -+ -+ sm6->p.location.line = block->id; -+ sm6->p.location.column = 0; -+ -+ switch (block->id) -+ { -+ case CONSTANTS_BLOCK: -+ /* Level 1 (global) constants are already done in sm6_parser_globals_init(). */ -+ if (level < 2) -+ break; -+ function = &sm6->functions[sm6->function_count]; -+ sm6->cur_max_value = function->value_count; -+ return sm6_parser_constants_init(sm6, block); -+ -+ case FUNCTION_BLOCK: -+ function = &sm6->functions[sm6->function_count]; -+ if ((ret = sm6_parser_function_init(sm6, block, function)) < 0) -+ return ret; -+ /* The value index returns to its previous value after handling a function. It's usually nonzero -+ * at the start because of global constants/variables/function declarations. Function constants -+ * occur in a child block, so value_count is already saved before they are emitted. */ -+ memset(&sm6->values[old_value_count], 0, (sm6->value_count - old_value_count) * sizeof(*sm6->values)); -+ sm6->value_count = old_value_count; -+ break; -+ -+ case BLOCKINFO_BLOCK: -+ case MODULE_BLOCK: -+ case PARAMATTR_BLOCK: -+ case PARAMATTR_GROUP_BLOCK: -+ case VALUE_SYMTAB_BLOCK: -+ case METADATA_BLOCK: -+ case METADATA_ATTACHMENT_BLOCK: -+ case TYPE_BLOCK: -+ break; -+ -+ default: -+ FIXME("Unhandled block id %u.\n", block->id); -+ break; -+ } -+ -+ return VKD3D_OK; -+} -+ -+static bool sm6_parser_allocate_named_metadata(struct sm6_parser *sm6) -+{ -+ struct dxil_block *block; -+ unsigned int i, j, count; -+ -+ for (i = 0, count = 0; i < sm6->root_block.child_block_count; ++i) -+ { -+ block = sm6->root_block.child_blocks[i]; -+ if (block->id != METADATA_BLOCK) -+ continue; -+ for (j = 0; j < block->record_count; ++j) -+ count += block->records[j]->code == METADATA_NAMED_NODE; -+ } -+ -+ if (!count) -+ return true; -+ -+ return !!(sm6->named_metadata = vkd3d_calloc(count, sizeof(*sm6->named_metadata))); -+} -+ -+static enum vkd3d_result metadata_value_create_node(struct sm6_metadata_value *m, struct sm6_metadata_table *table, -+ unsigned int dst_idx, unsigned int end_count, const struct dxil_record *record, struct sm6_parser *sm6) -+{ -+ struct sm6_metadata_node *node; -+ unsigned int i, offset; -+ -+ m->type = VKD3D_METADATA_NODE; -+ if (!(m->value_type = sm6->metadata_type)) -+ { -+ WARN("Metadata type not found.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "The type for metadata values was not found."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (!(node = vkd3d_malloc(offsetof(struct sm6_metadata_node, operands[record->operand_count])))) -+ { -+ ERR("Failed to allocate metadata node with %u operands.\n", record->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating a metadata node with %u operands.", record->operand_count); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ m->u.node = node; -+ -+ node->is_distinct = record->code == METADATA_DISTINCT_NODE; -+ -+ offset = record->code != METADATA_NAMED_NODE; -+ -+ for (i = 0; i < record->operand_count; ++i) -+ { -+ uint64_t ref; -+ -+ ref = record->operands[i] - offset; -+ if (record->operands[i] >= offset && ref >= end_count) -+ { -+ WARN("Invalid metadata index %"PRIu64".\n", ref); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "Metadata index %"PRIu64" is invalid.", ref); -+ vkd3d_free(node); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!node->is_distinct && ref == dst_idx) -+ { -+ WARN("Metadata self-reference at index %u.\n", dst_idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "Metadata index %u is self-referencing.", dst_idx); -+ vkd3d_free(node); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ node->operands[i] = (record->operands[i] >= offset) ? &table->values[ref] : NULL; -+ if (record->code == METADATA_NAMED_NODE && !sm6_metadata_value_is_node(node->operands[i])) -+ { -+ WARN("Named node operand is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "The operand of a metadata named node is not a node."); -+ vkd3d_free(node); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ } -+ -+ node->operand_count = record->operand_count; -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_result sm6_parser_metadata_init(struct sm6_parser *sm6, const struct dxil_block *block, -+ struct sm6_metadata_table *table) -+{ -+ unsigned int i, count, table_idx, value_idx; -+ struct sm6_metadata_value *values, *m; -+ const struct dxil_record *record; -+ const struct sm6_value *value; -+ enum vkd3d_result ret; -+ char *name; -+ -+ for (i = 0, count = 0; i < block->record_count; ++i) -+ count += block->records[i]->code != METADATA_NAME; -+ -+ if (!(values = vkd3d_calloc(count, sizeof(*values)))) -+ { -+ ERR("Failed to allocate metadata tables.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating metadata tables."); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ table->values = values; -+ -+ for (i = 0, name = NULL; i < block->record_count; ++i) -+ { -+ record = block->records[i]; -+ -+ table_idx = table->count; -+ m = &values[table_idx]; -+ -+ switch (record->code) -+ { -+ case METADATA_NAMED_NODE: -+ if (!name) -+ { -+ WARN("Named node has no name.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "A metadata named node has no name."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ /* When DXC emits metadata value array reference indices it assumes named nodes -+ * are not included in the array. Store named nodes separately. */ -+ m = &sm6->named_metadata[sm6->named_metadata_count].value; -+ sm6->named_metadata[sm6->named_metadata_count].name = name; -+ name = NULL; -+ -+ if ((ret = metadata_value_create_node(m, table, UINT_MAX, count, record, sm6)) < 0) -+ return ret; -+ ++sm6->named_metadata_count; -+ /* Skip incrementing the table count. */ -+ continue; -+ -+ case METADATA_DISTINCT_NODE: -+ case METADATA_NODE: -+ if ((ret = metadata_value_create_node(m, table, table_idx, count, record, sm6)) < 0) -+ return ret; -+ break; -+ -+ case METADATA_KIND: -+ if (!dxil_record_validate_operand_min_count(record, 2, sm6)) -+ return VKD3D_ERROR_INVALID_SHADER; -+ -+ m->type = VKD3D_METADATA_KIND; -+ m->u.kind.id = record->operands[0]; -+ if (!(m->u.kind.name = dxil_record_to_string(record, 1, sm6))) -+ { -+ ERR("Failed to allocate name of a kind.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ break; -+ -+ case METADATA_NAME: -+ /* Check the next record to avoid freeing 'name' in all exit paths. */ -+ if (i + 1 == block->record_count || block->records[i + 1]->code != METADATA_NAMED_NODE) -+ { -+ WARN("Name is not followed by a named node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "A metadata node name is not followed by a named node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ /* LLVM allows an empty string here. */ -+ if (!(name = dxil_record_to_string(record, 0, sm6))) -+ { -+ ERR("Failed to allocate name.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ continue; -+ -+ case METADATA_STRING: -+ /* LLVM allows an empty string here. */ -+ m->type = VKD3D_METADATA_STRING; -+ if (!(m->u.string_value = dxil_record_to_string(record, 0, sm6))) -+ { -+ ERR("Failed to allocate string.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ break; -+ -+ case METADATA_VALUE: -+ if (!dxil_record_validate_operand_count(record, 2, 2, sm6)) -+ return VKD3D_ERROR_INVALID_SHADER; -+ -+ m->type = VKD3D_METADATA_VALUE; -+ if (!(m->value_type = sm6_parser_get_type(sm6, record->operands[0]))) -+ return VKD3D_ERROR_INVALID_SHADER; -+ -+ if (record->operands[1] > UINT_MAX) -+ WARN("Truncating value index %"PRIu64".\n", record->operands[1]); -+ value_idx = record->operands[1]; -+ if (!(value = sm6_parser_get_value_safe(sm6, value_idx))) -+ return VKD3D_ERROR_INVALID_SHADER; -+ -+ if (!sm6_value_is_constant(value) && !sm6_value_is_undef(value) && !sm6_value_is_icb(value) -+ && !sm6_value_is_function_dcl(value)) -+ { -+ WARN("Value at index %u is not a constant or a function declaration.\n", value_idx); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "Metadata value at index %u is not a constant or a function declaration.", value_idx); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ m->u.value = value; -+ -+ if (value->type != m->value_type) -+ { -+ WARN("Type mismatch.\n"); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "The type of a metadata value does not match its referenced value at index %u.", value_idx); -+ } -+ -+ break; -+ -+ default: -+ FIXME("Unhandled metadata type %u.\n", record->code); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "Metadata type %u is unhandled.", record->code); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ ++table->count; -+ } -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_shader_component_type vkd3d_component_type_from_dxil_component_type(enum dxil_component_type type) -+{ -+ switch (type) -+ { -+ case COMPONENT_TYPE_I1: -+ return VKD3D_SHADER_COMPONENT_BOOL; -+ case COMPONENT_TYPE_I16: -+ case COMPONENT_TYPE_I32: -+ return VKD3D_SHADER_COMPONENT_INT; -+ case COMPONENT_TYPE_U16: -+ case COMPONENT_TYPE_U32: -+ return VKD3D_SHADER_COMPONENT_UINT; -+ case COMPONENT_TYPE_F16: -+ case COMPONENT_TYPE_F32: -+ case COMPONENT_TYPE_SNORMF32: -+ case COMPONENT_TYPE_UNORMF32: -+ return VKD3D_SHADER_COMPONENT_FLOAT; -+ case COMPONENT_TYPE_F64: -+ case COMPONENT_TYPE_SNORMF64: -+ case COMPONENT_TYPE_UNORMF64: -+ return VKD3D_SHADER_COMPONENT_DOUBLE; -+ default: -+ FIXME("Unhandled component type %u.\n", type); -+ return VKD3D_SHADER_COMPONENT_UINT; -+ } -+} -+ -+static enum vkd3d_shader_minimum_precision minimum_precision_from_dxil_component_type(enum dxil_component_type type) -+{ -+ switch (type) -+ { -+ case COMPONENT_TYPE_F16: -+ return VKD3D_SHADER_MINIMUM_PRECISION_FLOAT_16; -+ case COMPONENT_TYPE_I16: -+ return VKD3D_SHADER_MINIMUM_PRECISION_INT_16; -+ case COMPONENT_TYPE_U16: -+ return VKD3D_SHADER_MINIMUM_PRECISION_UINT_16; -+ default: -+ return VKD3D_SHADER_MINIMUM_PRECISION_NONE; -+ } -+} -+ -+static const enum vkd3d_shader_sysval_semantic sysval_semantic_table[] = -+{ -+ [SEMANTIC_KIND_ARBITRARY] = VKD3D_SHADER_SV_NONE, -+ [SEMANTIC_KIND_POSITION] = VKD3D_SHADER_SV_POSITION, -+ [SEMANTIC_KIND_TARGET] = VKD3D_SHADER_SV_NONE, -+}; -+ -+static enum vkd3d_shader_sysval_semantic sysval_semantic_from_dxil_semantic_kind(enum dxil_semantic_kind kind) -+{ -+ if (kind < ARRAY_SIZE(sysval_semantic_table)) -+ { -+ return sysval_semantic_table[kind]; -+ } -+ else -+ { -+ return VKD3D_SHADER_SV_NONE; -+ } -+} -+ -+static const struct sm6_metadata_value *sm6_parser_find_named_metadata(struct sm6_parser *sm6, const char *name) -+{ -+ const struct sm6_metadata_node *node; -+ unsigned int i; -+ -+ for (i = 0; i < sm6->named_metadata_count; ++i) -+ { -+ if (strcmp(sm6->named_metadata[i].name, name)) -+ continue; -+ -+ node = sm6->named_metadata[i].value.u.node; -+ if (!node->operand_count) -+ return NULL; -+ if (node->operand_count > 1) -+ { -+ FIXME("Ignoring %u extra operands for %s.\n", node->operand_count - 1, name); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Ignoring %u extra operands for metadata node %s.", node->operand_count - 1, name); -+ } -+ return node->operands[0]; -+ } -+ -+ return NULL; -+} -+ -+static bool sm6_parser_resources_load_register_range(struct sm6_parser *sm6, -+ const struct sm6_metadata_node *node, struct vkd3d_shader_register_range *range) -+{ -+ unsigned int size; -+ -+ if (!sm6_metadata_value_is_value(node->operands[1])) -+ { -+ WARN("Resource data type is not a value.\n"); -+ return false; -+ } -+ if (!sm6_type_is_pointer(node->operands[1]->value_type)) -+ { -+ WARN("Resource type is not a pointer.\n"); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH, -+ "Resource metadata value type is not a pointer."); -+ } -+ -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[3], &range->space)) -+ { -+ WARN("Failed to load register space.\n"); -+ return false; -+ } -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[4], &range->first)) -+ { -+ WARN("Failed to load register first.\n"); -+ return false; -+ } -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[5], &size)) -+ { -+ WARN("Failed to load register range size.\n"); -+ return false; -+ } -+ if (!size || (size != UINT_MAX && !vkd3d_bound_range(range->first, size, UINT_MAX))) -+ { -+ WARN("Invalid register range, first %u, size %u.\n", range->first, size); -+ return false; -+ } -+ range->last = (size == UINT_MAX) ? UINT_MAX : range->first + size - 1; -+ -+ return true; -+} -+ -+static enum vkd3d_result sm6_parser_resources_load_cbv(struct sm6_parser *sm6, -+ const struct sm6_metadata_node *node, struct sm6_descriptor_info *d, struct vkd3d_shader_instruction *ins) -+{ -+ struct vkd3d_shader_register *reg; -+ unsigned int buffer_size; -+ -+ if (node->operand_count < 7) -+ { -+ WARN("Invalid operand count %u.\n", node->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT, -+ "Invalid operand count %u for a CBV descriptor.", node->operand_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (node->operand_count > 7 && node->operands[7]) -+ { -+ WARN("Ignoring %u extra operands.\n", node->operand_count - 7); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Ignoring %u extra operands for a CBV descriptor.", node->operand_count - 7); -+ } -+ -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[6], &buffer_size)) -+ { -+ WARN("Failed to load buffer size.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Constant buffer size metadata value is not an integer."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_DCL_CONSTANT_BUFFER); -+ ins->resource_type = VKD3D_SHADER_RESOURCE_BUFFER; -+ ins->declaration.cb.size = buffer_size; -+ ins->declaration.cb.src.swizzle = VKD3D_SHADER_NO_SWIZZLE; -+ ins->declaration.cb.src.modifiers = VKD3DSPSM_NONE; -+ -+ reg = &ins->declaration.cb.src.reg; -+ vsir_register_init(reg, VKD3DSPR_CONSTBUFFER, VKD3D_DATA_FLOAT, 3); -+ reg->idx[0].offset = d->id; -+ reg->idx[1].offset = d->range.first; -+ reg->idx[2].offset = d->range.last; -+ -+ ins->declaration.cb.range = d->range; -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_result sm6_parser_descriptor_type_init(struct sm6_parser *sm6, -+ enum vkd3d_shader_descriptor_type type, const struct sm6_metadata_node *descriptor_node) -+{ -+ struct vkd3d_shader_instruction *ins; -+ const struct sm6_metadata_node *node; -+ const struct sm6_metadata_value *m; -+ struct sm6_descriptor_info *d; -+ enum vkd3d_result ret; -+ unsigned int i; -+ -+ for (i = 0; i < descriptor_node->operand_count; ++i) -+ { -+ m = descriptor_node->operands[i]; -+ if (!sm6_metadata_value_is_node(m)) -+ { -+ WARN("Resource descriptor is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Resource descriptor is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ node = m->u.node; -+ if (node->operand_count < 6) -+ { -+ WARN("Invalid operand count %u.\n", node->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT, -+ "Invalid operand count %u for a descriptor.", node->operand_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!vkd3d_array_reserve((void **)&sm6->descriptors, &sm6->descriptor_capacity, -+ sm6->descriptor_count + 1, sizeof(*sm6->descriptors))) -+ { -+ ERR("Failed to allocate descriptor array.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating the descriptor array."); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ d = &sm6->descriptors[sm6->descriptor_count]; -+ d->type = type; -+ -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[0], &d->id)) -+ { -+ WARN("Failed to load resource id.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Resource id metadata value is not an integer."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!sm6_parser_resources_load_register_range(sm6, node, &d->range)) -+ { -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Resource register range is invalid."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!(ins = sm6_parser_require_space(sm6, 1))) -+ { -+ ERR("Failed to allocate instruction.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ -+ switch (type) -+ { -+ case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV: -+ if ((ret = sm6_parser_resources_load_cbv(sm6, node, d, ins)) < 0) -+ return ret; -+ break; -+ default: -+ FIXME("Unsupported descriptor type %u.\n", type); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Resource descriptor type %u is unsupported.", type); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ ++sm6->descriptor_count; -+ ++sm6->p.instructions.count; -+ } -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_result sm6_parser_resources_init(struct sm6_parser *sm6) -+{ -+ const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.resources"); -+ enum vkd3d_shader_descriptor_type type; -+ const struct sm6_metadata_node *node; -+ enum vkd3d_result ret; -+ -+ if (!m) -+ return VKD3D_OK; -+ -+ node = m->u.node; -+ if (node->operand_count != SHADER_DESCRIPTOR_TYPE_COUNT) -+ { -+ WARN("Unexpected descriptor type count %u.\n", node->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Descriptor type count %u is invalid.", node->operand_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ for (type = 0; type < SHADER_DESCRIPTOR_TYPE_COUNT; ++type) -+ { -+ if (!(m = node->operands[type])) -+ continue; -+ -+ if (!sm6_metadata_value_is_node(m)) -+ { -+ WARN("Resource list is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES, -+ "Resource list is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if ((ret = sm6_parser_descriptor_type_init(sm6, type, m->u.node)) < 0) -+ return ret; -+ } -+ -+ return VKD3D_OK; -+} -+ -+static void signature_element_read_additional_element_values(struct signature_element *e, -+ const struct sm6_metadata_node *node, struct sm6_parser *sm6) -+{ -+ unsigned int i, operand_count, value; -+ enum dxil_element_additional_tag tag; -+ -+ if (node->operand_count < 11 || !node->operands[10]) -+ return; -+ -+ if (!sm6_metadata_value_is_node(node->operands[10])) -+ { -+ WARN("Additional values list is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element additional values list is not a metadata node."); -+ return; -+ } -+ -+ node = node->operands[10]->u.node; -+ if (node->operand_count & 1) -+ { -+ WARN("Operand count is not even.\n"); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Operand count for signature element additional tag/value pairs is not even."); -+ } -+ operand_count = node->operand_count & ~1u; -+ -+ for (i = 0; i < operand_count; i += 2) -+ { -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &tag) -+ || !sm6_metadata_get_uint_value(sm6, node->operands[i + 1], &value)) -+ { -+ WARN("Failed to extract tag/value pair.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element tag/value pair at index %u is not an integer pair.", i); -+ continue; -+ } -+ -+ switch (tag) -+ { -+ case ADDITIONAL_TAG_STREAM_INDEX: -+ e->stream_index = value; -+ break; -+ case ADDITIONAL_TAG_RELADDR_MASK: -+ /* A mask of components accessed via relative addressing. Seems to replace TPF 'dcl_index_range'. */ -+ if (value > VKD3DSP_WRITEMASK_ALL) -+ { -+ WARN("Invalid relative addressed mask %#x.\n", value); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_INVALID_MASK, -+ "Mask %#x of relative-addressed components is invalid.", value); -+ } -+ break; -+ case ADDITIONAL_TAG_USED_MASK: -+ if (value > VKD3DSP_WRITEMASK_ALL) -+ { -+ WARN("Invalid used mask %#x.\n", value); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_INVALID_MASK, -+ "Mask %#x of used components is invalid.", value); -+ value &= VKD3DSP_WRITEMASK_ALL; -+ } -+ e->used_mask = value; -+ break; -+ default: -+ FIXME("Unhandled tag %u, value %u.\n", tag, value); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Tag %#x for signature element additional value %#x is unhandled.", tag, value); -+ break; -+ } -+ } -+} -+ -+static enum vkd3d_result sm6_parser_read_signature(struct sm6_parser *sm6, const struct sm6_metadata_value *m, -+ struct shader_signature *s) -+{ -+ unsigned int i, j, column_count, operand_count, index; -+ const struct sm6_metadata_node *node, *element_node; -+ struct signature_element *elements, *e; -+ unsigned int values[10]; -+ -+ if (!m) -+ return VKD3D_OK; -+ -+ if (!sm6_metadata_value_is_node(m)) -+ { -+ WARN("Signature element list is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element list is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ node = m->u.node; -+ operand_count = node->operand_count; -+ -+ if (!(elements = vkd3d_calloc(operand_count, sizeof(*elements)))) -+ { -+ ERR("Failed to allocate %u signature elements.\n", operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory allocating %u signature elements.", operand_count); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ -+ for (i = 0; i < operand_count; ++i) -+ { -+ m = node->operands[i]; -+ -+ if (!sm6_metadata_value_is_node(m)) -+ { -+ WARN("Signature element is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ element_node = m->u.node; -+ if (element_node->operand_count < 10) -+ { -+ WARN("Invalid operand count %u.\n", element_node->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Invalid signature element operand count %u.", element_node->operand_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (element_node->operand_count > 11) -+ { -+ WARN("Ignoring %u extra operands.\n", element_node->operand_count - 11); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Ignoring %u extra operands for a signature element.", element_node->operand_count - 11); -+ } -+ -+ for (j = 0; j < 10; ++j) -+ { -+ /* 1 is the semantic name, 4 is semantic index metadata. */ -+ if (j == 1 || j == 4) -+ continue; -+ if (!sm6_metadata_get_uint_value(sm6, element_node->operands[j], &values[j])) -+ { -+ WARN("Failed to load uint value at index %u.\n", j); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element value at index %u is not an integer.", j); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ } -+ -+ e = &elements[i]; -+ -+ if (values[0] != i) -+ { -+ FIXME("Unsupported element id %u not equal to its index %u.\n", values[0], i); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "A non-sequential and non-zero-based element id is not supported."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if (!sm6_metadata_value_is_string(element_node->operands[1])) -+ { -+ WARN("Element name is not a string.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element name is not a metadata string."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ e->semantic_name = element_node->operands[1]->u.string_value; -+ -+ e->component_type = vkd3d_component_type_from_dxil_component_type(values[2]); -+ e->min_precision = minimum_precision_from_dxil_component_type(values[2]); -+ -+ j = values[3]; -+ e->sysval_semantic = sysval_semantic_from_dxil_semantic_kind(j); -+ if (j != SEMANTIC_KIND_ARBITRARY && j != SEMANTIC_KIND_TARGET && e->sysval_semantic == VKD3D_SHADER_SV_NONE) -+ { -+ WARN("Unhandled semantic kind %u.\n", j); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "DXIL semantic kind %u is unhandled.", j); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if ((e->interpolation_mode = values[5]) >= VKD3DSIM_COUNT) -+ { -+ WARN("Unhandled interpolation mode %u.\n", e->interpolation_mode); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Interpolation mode %u is unhandled.", e->interpolation_mode); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ e->register_count = values[6]; -+ column_count = values[7]; -+ e->register_index = values[8]; -+ e->target_location = e->register_index; -+ if (e->register_index > MAX_REG_OUTPUT || e->register_count > MAX_REG_OUTPUT - e->register_index) -+ { -+ WARN("Invalid row start %u with row count %u.\n", e->register_index, e->register_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "A signature element starting row of %u with count %u is invalid.", -+ e->register_index, e->register_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ index = values[9]; -+ if (index >= VKD3D_VEC4_SIZE || column_count > VKD3D_VEC4_SIZE - index) -+ { -+ WARN("Invalid column start %u with count %u.\n", index, column_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "A signature element starting column %u with count %u is invalid.", index, column_count); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ e->mask = vkd3d_write_mask_from_component_count(column_count); -+ e->used_mask = e->mask; -+ e->mask <<= index; -+ -+ signature_element_read_additional_element_values(e, element_node, sm6); -+ e->used_mask <<= index; -+ -+ m = element_node->operands[4]; -+ if (!sm6_metadata_value_is_node(m)) -+ { -+ WARN("Semantic index list is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element semantic index list is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ element_node = m->u.node; -+ for (j = 0; j < element_node->operand_count; ++j) -+ { -+ if (!sm6_metadata_get_uint_value(sm6, element_node->operands[j], &index)) -+ { -+ WARN("Failed to get semantic index for row %u.\n", j); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element semantic index for row %u is not an integer.", j); -+ } -+ else if (!j) -+ { -+ e->semantic_index = index; -+ } -+ else if (index != e->semantic_index + j) -+ { -+ WARN("Semantic index %u for row %u is not of an incrementing sequence.\n", index, j); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature element semantic index %u for row %u is not of an incrementing sequence.", index, j); -+ } -+ } -+ } -+ -+ vkd3d_free(s->elements); -+ s->elements = elements; -+ s->element_count = operand_count; -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_result sm6_parser_signatures_init(struct sm6_parser *sm6, const struct sm6_metadata_value *m) -+{ -+ enum vkd3d_result ret; -+ -+ if (!sm6_metadata_value_is_node(m)) - { -- FIXME("Unhandled call to local function.\n"); -- vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -- "Call to a local function is unsupported."); -- return; -+ WARN("Signature table is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE, -+ "Signature table is not a metadata node."); -+ return VKD3D_ERROR_INVALID_SHADER; - } -- if (!sm6_value_is_dx_intrinsic_dcl(fn_value)) -- WARN("External function is not a dx intrinsic.\n"); - -- if (!operand_count) -+ if (m->u.node->operand_count && (ret = sm6_parser_read_signature(sm6, m->u.node->operands[0], -+ &sm6->p.shader_desc.input_signature)) < 0) - { -- WARN("Missing dx intrinsic function id.\n"); -- vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT, -- "The id for a dx intrinsic function is missing."); -- return; -+ return ret; - } -- -- op_value = operands[0]; -- if (!sm6_value_is_constant(op_value) || !sm6_type_is_integer(op_value->type)) -+ if (m->u.node->operand_count > 1 && (ret = sm6_parser_read_signature(sm6, m->u.node->operands[1], -+ &sm6->p.shader_desc.output_signature)) < 0) - { -- WARN("dx intrinsic function id is not a constant int.\n"); -- vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -- "Expected a constant integer dx intrinsic function id."); -- return; -+ return ret; - } -- sm6_parser_decode_dx_op(sm6, code_block, register_get_uint_value(&op_value->u.reg), -- fn_value->u.function.name, &operands[1], operand_count - 1, ins, dst); -+ /* TODO: patch constant signature in operand 2. */ -+ -+ sm6_parser_init_input_signature(sm6, &sm6->p.shader_desc.input_signature); -+ sm6_parser_init_output_signature(sm6, &sm6->p.shader_desc.output_signature); -+ -+ return VKD3D_OK; - } - --static void sm6_parser_emit_ret(struct sm6_parser *sm6, const struct dxil_record *record, -- struct sm6_block *code_block, struct vkd3d_shader_instruction *ins) -+static void sm6_parser_emit_global_flags(struct sm6_parser *sm6, const struct sm6_metadata_value *m) - { -- if (!dxil_record_validate_operand_count(record, 0, 1, sm6)) -- return; -- -- if (record->operand_count) -- FIXME("Non-void return is not implemented.\n"); -+ enum vkd3d_shader_global_flags global_flags, mask, rotated_flags; -+ struct vkd3d_shader_instruction *ins; - -- ins->handler_idx = VKD3DSIH_NOP; -+ if (!sm6_metadata_get_uint64_value(sm6, m, (uint64_t*)&global_flags)) -+ { -+ WARN("Failed to load global flags.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Global flags metadata value is not an integer."); -+ return; -+ } -+ /* Rotate SKIP_OPTIMIZATION from bit 0 to bit 4 to match vkd3d_shader_global_flags. */ -+ mask = (VKD3DSGF_SKIP_OPTIMIZATION << 1) - 1; -+ rotated_flags = global_flags & mask; -+ rotated_flags = (rotated_flags >> 1) | ((rotated_flags & 1) << 4); -+ global_flags = (global_flags & ~mask) | rotated_flags; -+ -+ ins = sm6_parser_add_instruction(sm6, VKD3DSIH_DCL_GLOBAL_FLAGS); -+ ins->declaration.global_flags = global_flags; - } - --static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const struct dxil_block *block, -- struct sm6_function *function) -+static enum vkd3d_result sm6_parser_emit_thread_group(struct sm6_parser *sm6, const struct sm6_metadata_value *m) - { -+ const struct sm6_metadata_node *node; - struct vkd3d_shader_instruction *ins; -- const struct dxil_record *record; -- bool ret_found, is_terminator; -- struct sm6_block *code_block; -- struct sm6_value *dst; -- size_t i, block_idx; -+ unsigned int group_sizes[3]; -+ unsigned int i; - -- if (sm6->function_count) -+ if (sm6->p.shader_version.type != VKD3D_SHADER_TYPE_COMPUTE) - { -- FIXME("Multiple functions are not supported yet.\n"); -+ WARN("Shader of type %#x has thread group dimensions.\n", sm6->p.shader_version.type); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Shader has thread group dimensions but is not a compute shader."); - return VKD3D_ERROR_INVALID_SHADER; - } -- if (!(function->declaration = sm6_parser_next_function_definition(sm6))) -+ -+ if (!m || !sm6_metadata_value_is_node(m)) - { -- WARN("Failed to find definition to match function body.\n"); -+ WARN("Thread group dimension value is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Thread group dimension metadata value is not a node."); - return VKD3D_ERROR_INVALID_SHADER; - } - -- if (block->record_count < 2) -+ node = m->u.node; -+ if (node->operand_count != 3) - { -- /* It should contain at least a block count and a RET instruction. */ -- WARN("Invalid function block record count %zu.\n", block->record_count); -+ WARN("Invalid operand count %u.\n", node->operand_count); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND_COUNT, -+ "Thread group dimension operand count %u is invalid.", node->operand_count); - return VKD3D_ERROR_INVALID_SHADER; - } -- if (block->records[0]->code != FUNC_CODE_DECLAREBLOCKS || !block->records[0]->operand_count -- || block->records[0]->operands[0] > UINT_MAX) -+ -+ for (i = 0; i < 3; ++i) - { -- WARN("Block count declaration not found or invalid.\n"); -- return VKD3D_ERROR_INVALID_SHADER; -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &group_sizes[i])) -+ { -+ WARN("Thread group dimension is not an integer value.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Thread group dimension metadata value is not an integer."); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ if (!group_sizes[i] || group_sizes[i] > dx_max_thread_group_size[i]) -+ { -+ char dim = "XYZ"[i]; -+ WARN("Invalid thread group %c dimension %u.\n", dim, group_sizes[i]); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Thread group %c dimension %u is invalid.", dim, group_sizes[i]); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } - } - -- if (!(function->block_count = block->records[0]->operands[0])) -+ ins = sm6_parser_add_instruction(sm6, VKD3DSIH_DCL_THREAD_GROUP); -+ ins->declaration.thread_group_size.x = group_sizes[0]; -+ ins->declaration.thread_group_size.y = group_sizes[1]; -+ ins->declaration.thread_group_size.z = group_sizes[2]; -+ -+ return VKD3D_OK; -+} -+ -+static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6) -+{ -+ const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints"); -+ const struct sm6_metadata_node *node, *entry_node = m ? m->u.node : NULL; -+ enum dxil_shader_properties_tag tag; -+ unsigned int i, operand_count; -+ const struct sm6_value *value; -+ enum vkd3d_result ret; -+ -+ if (!entry_node || entry_node->operand_count < 2 || !(m = entry_node->operands[0])) - { -- WARN("Function contains no blocks.\n"); -+ WARN("No entry point definition found.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT, -+ "No entry point definition found in the metadata."); - return VKD3D_ERROR_INVALID_SHADER; - } -- if (function->block_count > 1) -+ -+ if (m->type != VKD3D_METADATA_VALUE) - { -- FIXME("Branched shaders are not supported yet.\n"); -+ WARN("Entry point definition is not a value.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT, -+ "Entry point definition is not a metadata value."); - return VKD3D_ERROR_INVALID_SHADER; - } - -- if (!(function->blocks[0] = sm6_block_create())) -+ value = m->u.value; -+ if (!sm6_value_is_function_dcl(value)) - { -- ERR("Failed to allocate code block.\n"); -- return VKD3D_ERROR_OUT_OF_MEMORY; -+ WARN("Entry point value is not a function definition.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT, -+ "Entry point metadata value does not contain a function definition."); -+ return VKD3D_ERROR_INVALID_SHADER; - } -- code_block = function->blocks[0]; - -- sm6->cur_max_value = function->value_count; -+ sm6->entry_point = value->u.function.name; -+ if (!sm6_metadata_value_is_string(entry_node->operands[1]) -+ || ascii_strcasecmp(sm6->entry_point, entry_node->operands[1]->u.string_value)) -+ { -+ WARN("Entry point function name %s mismatch.\n", sm6->entry_point); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_ENTRY_POINT_MISMATCH, -+ "Entry point function name %s does not match the name in metadata.", sm6->entry_point); -+ } - -- for (i = 1, block_idx = 0, ret_found = false; i < block->record_count; ++i) -+ if (entry_node->operand_count >= 3 && (m = entry_node->operands[2]) -+ && (ret = sm6_parser_signatures_init(sm6, m)) < 0) - { -- sm6->p.location.column = i; -+ return ret; -+ } - -- if (!code_block) -+ if (entry_node->operand_count >= 5 && (m = entry_node->operands[4])) -+ { -+ if (!sm6_metadata_value_is_node(m)) - { -- WARN("Invalid block count %zu.\n", function->block_count); -- vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, -- "Invalid block count %zu.", function->block_count); -+ WARN("Shader properties list is not a node.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Shader properties tag/value list is not a metadata node."); - return VKD3D_ERROR_INVALID_SHADER; - } - -- /* block->record_count - 1 is the instruction count, but some instructions -- * can emit >1 IR instruction, so extra may be used. */ -- if (!vkd3d_array_reserve((void **)&code_block->instructions, &code_block->instruction_capacity, -- max(code_block->instruction_count + 1, block->record_count), sizeof(*code_block->instructions))) -+ node = m->u.node; -+ if (node->operand_count & 1) - { -- ERR("Failed to allocate instructions.\n"); -- return VKD3D_ERROR_OUT_OF_MEMORY; -+ WARN("Operand count is not even.\n"); -+ vkd3d_shader_parser_warning(&sm6->p, VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS, -+ "Operand count for shader properties tag/value pairs is not even."); - } -+ operand_count = node->operand_count & ~1u; - -- ins = &code_block->instructions[code_block->instruction_count]; -- ins->handler_idx = VKD3DSIH_INVALID; -- -- dst = sm6_parser_get_current_value(sm6); -- dst->type = NULL; -- dst->value_type = VALUE_TYPE_REG; -- is_terminator = false; -- -- record = block->records[i]; -- switch (record->code) -+ for (i = 0; i < operand_count; i += 2) - { -- case FUNC_CODE_INST_CALL: -- sm6_parser_emit_call(sm6, record, code_block, ins, dst); -- break; -- case FUNC_CODE_INST_RET: -- sm6_parser_emit_ret(sm6, record, code_block, ins); -- is_terminator = true; -- ret_found = true; -- break; -- default: -- FIXME("Unhandled dxil instruction %u.\n", record->code); -+ if (!sm6_metadata_get_uint_value(sm6, node->operands[i], &tag)) -+ { -+ WARN("Tag is not an integer value.\n"); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Shader properties tag at index %u is not an integer.", i); - return VKD3D_ERROR_INVALID_SHADER; -- } -- -- if (sm6->p.failed) -- return VKD3D_ERROR; -- assert(ins->handler_idx != VKD3DSIH_INVALID); -+ } - -- if (is_terminator) -- { -- ++block_idx; -- code_block = (block_idx < function->block_count) ? function->blocks[block_idx] : NULL; -+ switch (tag) -+ { -+ case SHADER_PROPERTIES_FLAGS: -+ sm6_parser_emit_global_flags(sm6, node->operands[i + 1]); -+ break; -+ case SHADER_PROPERTIES_COMPUTE: -+ if ((ret = sm6_parser_emit_thread_group(sm6, node->operands[i + 1])) < 0) -+ return ret; -+ break; -+ default: -+ FIXME("Unhandled tag %#x.\n", tag); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, -+ "Shader properties tag %#x is unhandled.", tag); -+ break; -+ } - } -- if (code_block) -- code_block->instruction_count += ins->handler_idx != VKD3DSIH_NOP; -- else -- assert(ins->handler_idx == VKD3DSIH_NOP); -- -- sm6->value_count += !!dst->type; -- } -- -- if (!ret_found) -- { -- WARN("Function contains no RET instruction.\n"); -- return VKD3D_ERROR_INVALID_SHADER; - } - - return VKD3D_OK; - } - --static bool sm6_block_emit_instructions(struct sm6_block *block, struct sm6_parser *sm6) -+static void sm6_metadata_value_destroy(struct sm6_metadata_value *m) - { -- struct vkd3d_shader_instruction *ins = sm6_parser_require_space(sm6, block->instruction_count + 1); -- -- if (!ins) -- return false; -- -- memcpy(ins, block->instructions, block->instruction_count * sizeof(*block->instructions)); -- sm6->p.instructions.count += block->instruction_count; -- -- sm6_parser_add_instruction(sm6, VKD3DSIH_RET); -- -- return true; -+ switch (m->type) -+ { -+ case VKD3D_METADATA_NODE: -+ vkd3d_free(m->u.node); -+ break; -+ case VKD3D_METADATA_KIND: -+ vkd3d_free(m->u.kind.name); -+ break; -+ case VKD3D_METADATA_STRING: -+ vkd3d_free(m->u.string_value); -+ break; -+ default: -+ break; -+ } - } - --static enum vkd3d_result sm6_parser_module_init(struct sm6_parser *sm6, const struct dxil_block *block, -- unsigned int level) -+static void sm6_parser_metadata_cleanup(struct sm6_parser *sm6) - { -- size_t i, old_value_count = sm6->value_count; -- struct sm6_function *function; -- enum vkd3d_result ret; -+ unsigned int i, j; - -- for (i = 0; i < block->child_block_count; ++i) -+ for (i = 0; i < ARRAY_SIZE(sm6->metadata_tables); ++i) - { -- if ((ret = sm6_parser_module_init(sm6, block->child_blocks[i], level + 1)) < 0) -- return ret; -+ for (j = 0; j < sm6->metadata_tables[i].count; ++j) -+ sm6_metadata_value_destroy(&sm6->metadata_tables[i].values[j]); -+ vkd3d_free(sm6->metadata_tables[i].values); - } -- -- sm6->p.location.line = block->id; -- sm6->p.location.column = 0; -- -- switch (block->id) -+ for (i = 0; i < sm6->named_metadata_count; ++i) - { -- case CONSTANTS_BLOCK: -- function = &sm6->functions[sm6->function_count]; -- sm6->cur_max_value = function->value_count; -- return sm6_parser_constants_init(sm6, block); -- -- case FUNCTION_BLOCK: -- function = &sm6->functions[sm6->function_count]; -- if ((ret = sm6_parser_function_init(sm6, block, function)) < 0) -- return ret; -- /* The value index returns to its previous value after handling a function. It's usually nonzero -- * at the start because of global constants/variables/function declarations. Function constants -- * occur in a child block, so value_count is already saved before they are emitted. */ -- memset(&sm6->values[old_value_count], 0, (sm6->value_count - old_value_count) * sizeof(*sm6->values)); -- sm6->value_count = old_value_count; -- break; -- -- case BLOCKINFO_BLOCK: -- case MODULE_BLOCK: -- case PARAMATTR_BLOCK: -- case PARAMATTR_GROUP_BLOCK: -- case VALUE_SYMTAB_BLOCK: -- case METADATA_BLOCK: -- case METADATA_ATTACHMENT_BLOCK: -- case TYPE_BLOCK: -- break; -- -- default: -- FIXME("Unhandled block id %u.\n", block->id); -- break; -+ sm6_metadata_value_destroy(&sm6->named_metadata[i].value); -+ vkd3d_free(sm6->named_metadata[i].name); - } -- -- return VKD3D_OK; -+ vkd3d_free(sm6->named_metadata); - } - - static void sm6_type_table_cleanup(struct sm6_type *types, size_t count) -@@ -2669,6 +5448,8 @@ static void sm6_parser_destroy(struct vkd3d_shader_parser *parser) - sm6_type_table_cleanup(sm6->types, sm6->type_count); - sm6_symtab_cleanup(sm6->global_symbols, sm6->global_symbol_count); - sm6_functions_cleanup(sm6->functions, sm6->function_count); -+ sm6_parser_metadata_cleanup(sm6); -+ vkd3d_free(sm6->descriptors); - vkd3d_free(sm6->values); - free_shader_desc(&parser->shader_desc); - vkd3d_free(sm6); -@@ -2679,10 +5460,20 @@ static const struct vkd3d_shader_parser_ops sm6_parser_ops = - .parser_destroy = sm6_parser_destroy, - }; - -+static struct sm6_function *sm6_parser_get_function(const struct sm6_parser *sm6, const char *name) -+{ -+ size_t i; -+ for (i = 0; i < sm6->function_count; ++i) -+ if (!ascii_strcasecmp(sm6->functions[i].declaration->u.function.name, name)) -+ return &sm6->functions[i]; -+ return NULL; -+} -+ - static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t *byte_code, size_t byte_code_size, - const char *source_name, struct vkd3d_shader_message_context *message_context) - { - const struct shader_signature *output_signature = &sm6->p.shader_desc.output_signature; -+ const struct shader_signature *input_signature = &sm6->p.shader_desc.input_signature; - const struct vkd3d_shader_location location = {.source_name = source_name}; - uint32_t version_token, dxil_version, token_count, magic; - unsigned int chunk_offset, chunk_size; -@@ -2690,8 +5481,9 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t - enum bitcode_block_abbreviation abbr; - struct vkd3d_shader_version version; - struct dxil_block *block; -+ struct sm6_function *fn; - enum vkd3d_result ret; -- unsigned int i; -+ unsigned int i, j; - - count = byte_code_size / sizeof(*byte_code); - if (count < 6) -@@ -2838,11 +5630,12 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t - return ret; - } - -- if (!(sm6->output_params = shader_parser_get_dst_params(&sm6->p, output_signature->element_count))) -+ if (!(sm6->output_params = shader_parser_get_dst_params(&sm6->p, output_signature->element_count)) -+ || !(sm6->input_params = shader_parser_get_dst_params(&sm6->p, input_signature->element_count))) - { -- ERR("Failed to allocate output parameters.\n"); -+ ERR("Failed to allocate input/output parameters.\n"); - vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -- "Out of memory allocating output parameters."); -+ "Out of memory allocating input/output parameters."); - return VKD3D_ERROR_OUT_OF_MEMORY; - } - -@@ -2869,6 +5662,7 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t - "Out of memory allocating DXIL value array."); - return VKD3D_ERROR_OUT_OF_MEMORY; - } -+ sm6->ssa_next_id = 1; - - if ((ret = sm6_parser_globals_init(sm6)) < 0) - { -@@ -2876,7 +5670,35 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t - return ret; - } - -- sm6_parser_init_output_signature(sm6, output_signature); -+ if (!sm6_parser_allocate_named_metadata(sm6)) -+ { -+ ERR("Failed to allocate named metadata array.\n"); -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ } -+ -+ for (i = 0, j = 0; i < sm6->root_block.child_block_count; ++i) -+ { -+ block = sm6->root_block.child_blocks[i]; -+ if (block->id != METADATA_BLOCK) -+ continue; -+ -+ if (j == ARRAY_SIZE(sm6->metadata_tables)) -+ { -+ FIXME("Too many metadata tables.\n"); -+ vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA, -+ "A metadata table count greater than %zu is unsupported.", ARRAY_SIZE(sm6->metadata_tables)); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ if ((ret = sm6_parser_metadata_init(sm6, block, &sm6->metadata_tables[j++])) < 0) -+ return ret; -+ } -+ -+ if ((ret = sm6_parser_entry_point_init(sm6)) < 0) -+ return ret; -+ -+ if ((ret = sm6_parser_resources_init(sm6)) < 0) -+ return ret; - - if ((ret = sm6_parser_module_init(sm6, &sm6->root_block, 0)) < 0) - { -@@ -2889,22 +5711,31 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t - return ret; - } - -- if (!sm6_parser_require_space(sm6, output_signature->element_count)) -+ if (!sm6_parser_require_space(sm6, output_signature->element_count + input_signature->element_count)) - { - vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, - "Out of memory emitting shader signature declarations."); - return VKD3D_ERROR_OUT_OF_MEMORY; - } - sm6_parser_emit_output_signature(sm6, output_signature); -+ sm6_parser_emit_input_signature(sm6, input_signature); - -- for (i = 0; i < sm6->function_count; ++i) -+ sm6->p.shader_desc.ssa_count = sm6->ssa_next_id; -+ -+ if (!(fn = sm6_parser_get_function(sm6, sm6->entry_point))) - { -- if (!sm6_block_emit_instructions(sm6->functions[i].blocks[0], sm6)) -- { -- vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -- "Out of memory emitting shader instructions."); -- return VKD3D_ERROR_OUT_OF_MEMORY; -- } -+ WARN("Failed to find entry point %s.\n", sm6->entry_point); -+ vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT, -+ "The definition of the entry point function '%s' was not found.", sm6->entry_point); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ -+ assert(sm6->function_count == 1); -+ if (!sm6_block_emit_instructions(fn->blocks[0], sm6)) -+ { -+ vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXIL_OUT_OF_MEMORY, -+ "Out of memory emitting shader instructions."); -+ return VKD3D_ERROR_OUT_OF_MEMORY; - } - - dxil_block_destroy(&sm6->root_block); -@@ -2955,6 +5786,12 @@ int vkd3d_shader_sm6_parser_create(const struct vkd3d_shader_compile_info *compi - compile_info->source_name, message_context); - vkd3d_free(byte_code); - -+ if (!sm6->p.failed && ret >= 0) -+ vsir_validate(&sm6->p); -+ -+ if (sm6->p.failed && ret >= 0) -+ ret = VKD3D_ERROR_INVALID_SHADER; -+ - if (ret < 0) - { - WARN("Failed to initialise shader parser.\n"); -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.c b/libs/vkd3d/libs/vkd3d-shader/hlsl.c -index 5fe9047bf25..501bff8cfb8 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.c -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.c -@@ -216,13 +216,15 @@ bool hlsl_type_is_resource(const struct hlsl_type *type) - return false; - } - --enum hlsl_regset hlsl_type_get_regset(const struct hlsl_type *type) -+/* Only intended to be used for derefs (after copies have been lowered to components or vectors) or -+ * resources, since for both their data types span across a single regset. */ -+static enum hlsl_regset type_get_regset(const struct hlsl_type *type) - { -- if (type->class <= HLSL_CLASS_LAST_NUMERIC) -+ if (hlsl_is_numeric_type(type)) - return HLSL_REGSET_NUMERIC; - - if (type->class == HLSL_CLASS_ARRAY) -- return hlsl_type_get_regset(type->e.array.type); -+ return type_get_regset(type->e.array.type); - - if (type->class == HLSL_CLASS_OBJECT) - { -@@ -245,6 +247,11 @@ enum hlsl_regset hlsl_type_get_regset(const struct hlsl_type *type) - vkd3d_unreachable(); - } - -+enum hlsl_regset hlsl_deref_get_regset(struct hlsl_ctx *ctx, const struct hlsl_deref *deref) -+{ -+ return type_get_regset(hlsl_deref_get_type(ctx, deref)); -+} -+ - unsigned int hlsl_type_get_sm4_offset(const struct hlsl_type *type, unsigned int offset) - { - /* Align to the next vec4 boundary if: -@@ -324,7 +331,7 @@ static void hlsl_type_calculate_reg_size(struct hlsl_ctx *ctx, struct hlsl_type - { - if (hlsl_type_is_resource(type)) - { -- enum hlsl_regset regset = hlsl_type_get_regset(type); -+ enum hlsl_regset regset = type_get_regset(type); - - type->reg_size[regset] = 1; - } -@@ -452,11 +459,11 @@ struct hlsl_type *hlsl_type_get_component_type(struct hlsl_ctx *ctx, struct hlsl - } - - unsigned int hlsl_type_get_component_offset(struct hlsl_ctx *ctx, struct hlsl_type *type, -- enum hlsl_regset regset, unsigned int index) -+ unsigned int index, enum hlsl_regset *regset) - { -+ unsigned int offset[HLSL_REGSET_LAST + 1] = {0}; - struct hlsl_type *next_type; -- unsigned int offset = 0; -- unsigned int idx; -+ unsigned int idx, r; - - while (!type_is_single_component(type)) - { -@@ -468,19 +475,22 @@ unsigned int hlsl_type_get_component_offset(struct hlsl_ctx *ctx, struct hlsl_ty - case HLSL_CLASS_SCALAR: - case HLSL_CLASS_VECTOR: - case HLSL_CLASS_MATRIX: -- if (regset == HLSL_REGSET_NUMERIC) -- offset += idx; -+ offset[HLSL_REGSET_NUMERIC] += idx; - break; - - case HLSL_CLASS_STRUCT: -- offset += type->e.record.fields[idx].reg_offset[regset]; -+ for (r = 0; r <= HLSL_REGSET_LAST; ++r) -+ offset[r] += type->e.record.fields[idx].reg_offset[r]; - break; - - case HLSL_CLASS_ARRAY: -- if (regset == HLSL_REGSET_NUMERIC) -- offset += idx * align(type->e.array.type->reg_size[regset], 4); -- else -- offset += idx * type->e.array.type->reg_size[regset]; -+ for (r = 0; r <= HLSL_REGSET_LAST; ++r) -+ { -+ if (r == HLSL_REGSET_NUMERIC) -+ offset[r] += idx * align(type->e.array.type->reg_size[r], 4); -+ else -+ offset[r] += idx * type->e.array.type->reg_size[r]; -+ } - break; - - case HLSL_CLASS_OBJECT: -@@ -493,7 +503,8 @@ unsigned int hlsl_type_get_component_offset(struct hlsl_ctx *ctx, struct hlsl_ty - type = next_type; - } - -- return offset; -+ *regset = type_get_regset(type); -+ return offset[*regset]; - } - - static bool init_deref(struct hlsl_ctx *ctx, struct hlsl_deref *deref, struct hlsl_ir_var *var, -@@ -501,7 +512,9 @@ static bool init_deref(struct hlsl_ctx *ctx, struct hlsl_deref *deref, struct hl - { - deref->var = var; - deref->path_len = path_len; -- deref->offset.node = NULL; -+ deref->rel_offset.node = NULL; -+ deref->const_offset = 0; -+ deref->data_type = NULL; - - if (path_len == 0) - { -@@ -528,7 +541,8 @@ bool hlsl_init_deref_from_index_chain(struct hlsl_ctx *ctx, struct hlsl_deref *d - - deref->path = NULL; - deref->path_len = 0; -- deref->offset.node = NULL; -+ deref->rel_offset.node = NULL; -+ deref->const_offset = 0; - - assert(chain); - if (chain->type == HLSL_IR_INDEX) -@@ -591,7 +605,7 @@ struct hlsl_type *hlsl_deref_get_type(struct hlsl_ctx *ctx, const struct hlsl_de - - assert(deref); - -- if (deref->offset.node) -+ if (hlsl_deref_is_lowered(deref)) - return deref->data_type; - - type = deref->var->data_type; -@@ -745,7 +759,7 @@ struct hlsl_type *hlsl_new_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim - { - struct hlsl_type *type; - -- if (!(type = vkd3d_calloc(1, sizeof(*type)))) -+ if (!(type = hlsl_alloc(ctx, sizeof(*type)))) - return NULL; - type->class = HLSL_CLASS_OBJECT; - type->base_type = HLSL_TYPE_UAV; -@@ -811,17 +825,15 @@ struct hlsl_ir_function *hlsl_get_function(struct hlsl_ctx *ctx, const char *nam - return NULL; - } - --struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const char *name) -+struct hlsl_ir_function_decl *hlsl_get_first_func_decl(struct hlsl_ctx *ctx, const char *name) - { -- struct hlsl_ir_function_decl *decl; - struct hlsl_ir_function *func; - struct rb_entry *entry; - - if ((entry = rb_get(&ctx->functions, name))) - { - func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); -- RB_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) -- return decl; -+ return LIST_ENTRY(list_head(&func->overloads), struct hlsl_ir_function_decl, entry); - } - - return NULL; -@@ -1102,7 +1114,7 @@ bool hlsl_copy_deref(struct hlsl_ctx *ctx, struct hlsl_deref *deref, const struc - if (!other) - return true; - -- assert(!other->offset.node); -+ assert(!hlsl_deref_is_lowered(other)); - - if (!init_deref(ctx, deref, other->var, other->path_len)) - return false; -@@ -1124,7 +1136,8 @@ void hlsl_cleanup_deref(struct hlsl_deref *deref) - deref->path = NULL; - deref->path_len = 0; - -- hlsl_src_remove(&deref->offset); -+ hlsl_src_remove(&deref->rel_offset); -+ deref->const_offset = 0; - } - - /* Initializes a simple variable dereference, so that it can be passed to load/store functions. */ -@@ -1159,7 +1172,7 @@ struct hlsl_ir_node *hlsl_new_store_index(struct hlsl_ctx *ctx, const struct hls - unsigned int i; - - assert(lhs); -- assert(!lhs->offset.node); -+ assert(!hlsl_deref_is_lowered(lhs)); - - if (!(store = hlsl_alloc(ctx, sizeof(*store)))) - return NULL; -@@ -1325,6 +1338,40 @@ struct hlsl_ir_node *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *cond - return &iff->node; - } - -+struct hlsl_ir_switch_case *hlsl_new_switch_case(struct hlsl_ctx *ctx, unsigned int value, -+ bool is_default, struct hlsl_block *body, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_switch_case *c; -+ -+ if (!(c = hlsl_alloc(ctx, sizeof(*c)))) -+ return NULL; -+ -+ c->value = value; -+ c->is_default = is_default; -+ hlsl_block_init(&c->body); -+ if (body) -+ hlsl_block_add_block(&c->body, body); -+ c->loc = *loc; -+ -+ return c; -+} -+ -+struct hlsl_ir_node *hlsl_new_switch(struct hlsl_ctx *ctx, struct hlsl_ir_node *selector, -+ struct list *cases, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_switch *s; -+ -+ if (!(s = hlsl_alloc(ctx, sizeof(*s)))) -+ return NULL; -+ init_node(&s->node, HLSL_IR_SWITCH, NULL, loc); -+ hlsl_src_from_node(&s->selector, selector); -+ list_init(&s->cases); -+ if (cases) -+ list_move_head(&s->cases, cases); -+ -+ return &s->node; -+} -+ - struct hlsl_ir_load *hlsl_new_load_index(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, - struct hlsl_ir_node *idx, const struct vkd3d_shader_location *loc) - { -@@ -1332,7 +1379,7 @@ struct hlsl_ir_load *hlsl_new_load_index(struct hlsl_ctx *ctx, const struct hlsl - struct hlsl_type *type; - unsigned int i; - -- assert(!deref->offset.node); -+ assert(!hlsl_deref_is_lowered(deref)); - - type = hlsl_deref_get_type(ctx, deref); - if (idx) -@@ -1568,7 +1615,7 @@ static bool clone_block(struct hlsl_ctx *ctx, struct hlsl_block *dst_block, - - if (!list_empty(&src->uses)) - { -- if (!vkd3d_array_reserve((void **)&map->instrs, &map->capacity, map->count + 1, sizeof(*map->instrs))) -+ if (!hlsl_array_reserve(ctx, (void **)&map->instrs, &map->capacity, map->count + 1, sizeof(*map->instrs))) - { - hlsl_block_cleanup(dst_block); - return false; -@@ -1605,7 +1652,7 @@ static bool clone_deref(struct hlsl_ctx *ctx, struct clone_instr_map *map, - { - unsigned int i; - -- assert(!src->offset.node); -+ assert(!hlsl_deref_is_lowered(src)); - - if (!init_deref(ctx, dst, src->var, src->path_len)) - return false; -@@ -1787,6 +1834,58 @@ static struct hlsl_ir_node *clone_index(struct hlsl_ctx *ctx, struct clone_instr - return dst; - } - -+void hlsl_free_ir_switch_case(struct hlsl_ir_switch_case *c) -+{ -+ hlsl_block_cleanup(&c->body); -+ list_remove(&c->entry); -+ vkd3d_free(c); -+} -+ -+void hlsl_cleanup_ir_switch_cases(struct list *cases) -+{ -+ struct hlsl_ir_switch_case *c, *next; -+ -+ LIST_FOR_EACH_ENTRY_SAFE(c, next, cases, struct hlsl_ir_switch_case, entry) -+ { -+ hlsl_free_ir_switch_case(c); -+ } -+} -+ -+static struct hlsl_ir_node *clone_switch(struct hlsl_ctx *ctx, -+ struct clone_instr_map *map, struct hlsl_ir_switch *s) -+{ -+ struct hlsl_ir_switch_case *c, *d; -+ struct hlsl_ir_node *ret; -+ struct hlsl_block body; -+ struct list cases; -+ -+ list_init(&cases); -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ if (!(clone_block(ctx, &body, &c->body, map))) -+ { -+ hlsl_cleanup_ir_switch_cases(&cases); -+ return NULL; -+ } -+ -+ d = hlsl_new_switch_case(ctx, c->value, c->is_default, &body, &c->loc); -+ hlsl_block_cleanup(&body); -+ if (!d) -+ { -+ hlsl_cleanup_ir_switch_cases(&cases); -+ return NULL; -+ } -+ -+ list_add_tail(&cases, &d->entry); -+ } -+ -+ ret = hlsl_new_switch(ctx, map_instr(map, s->selector.node), &cases, &s->node.loc); -+ hlsl_cleanup_ir_switch_cases(&cases); -+ -+ return ret; -+} -+ - static struct hlsl_ir_node *clone_instr(struct hlsl_ctx *ctx, - struct clone_instr_map *map, const struct hlsl_ir_node *instr) - { -@@ -1825,6 +1924,9 @@ static struct hlsl_ir_node *clone_instr(struct hlsl_ctx *ctx, - case HLSL_IR_STORE: - return clone_store(ctx, map, hlsl_ir_store(instr)); - -+ case HLSL_IR_SWITCH: -+ return clone_switch(ctx, map, hlsl_ir_switch(instr)); -+ - case HLSL_IR_SWIZZLE: - return clone_swizzle(ctx, map, hlsl_ir_swizzle(instr)); - } -@@ -1946,76 +2048,38 @@ void hlsl_pop_scope(struct hlsl_ctx *ctx) - ctx->cur_scope = prev_scope; - } - --static int compare_param_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2) -+static bool func_decl_matches(const struct hlsl_ir_function_decl *decl, -+ const struct hlsl_func_parameters *parameters) - { -- int r; -- -- if ((r = vkd3d_u32_compare(t1->class, t2->class))) -- { -- if (!((t1->class == HLSL_CLASS_SCALAR && t2->class == HLSL_CLASS_VECTOR) -- || (t1->class == HLSL_CLASS_VECTOR && t2->class == HLSL_CLASS_SCALAR))) -- return r; -- } -- if ((r = vkd3d_u32_compare(t1->base_type, t2->base_type))) -- return r; -- if (t1->base_type == HLSL_TYPE_SAMPLER || t1->base_type == HLSL_TYPE_TEXTURE) -- { -- if ((r = vkd3d_u32_compare(t1->sampler_dim, t2->sampler_dim))) -- return r; -- if (t1->base_type == HLSL_TYPE_TEXTURE && t1->sampler_dim != HLSL_SAMPLER_DIM_GENERIC -- && (r = compare_param_hlsl_types(t1->e.resource_format, t2->e.resource_format))) -- return r; -- } -- if ((r = vkd3d_u32_compare(t1->dimx, t2->dimx))) -- return r; -- if ((r = vkd3d_u32_compare(t1->dimy, t2->dimy))) -- return r; -- if (t1->class == HLSL_CLASS_STRUCT) -- { -- size_t i; -- -- if (t1->e.record.field_count != t2->e.record.field_count) -- return t1->e.record.field_count - t2->e.record.field_count; -- -- for (i = 0; i < t1->e.record.field_count; ++i) -- { -- const struct hlsl_struct_field *field1 = &t1->e.record.fields[i]; -- const struct hlsl_struct_field *field2 = &t2->e.record.fields[i]; -+ size_t i; - -- if ((r = compare_param_hlsl_types(field1->type, field2->type))) -- return r; -+ if (parameters->count != decl->parameters.count) -+ return false; - -- if ((r = strcmp(field1->name, field2->name))) -- return r; -- } -- return 0; -- } -- if (t1->class == HLSL_CLASS_ARRAY) -+ for (i = 0; i < parameters->count; ++i) - { -- if ((r = vkd3d_u32_compare(t1->e.array.elements_count, t2->e.array.elements_count))) -- return r; -- return compare_param_hlsl_types(t1->e.array.type, t2->e.array.type); -+ if (!hlsl_types_are_equal(parameters->vars[i]->data_type, decl->parameters.vars[i]->data_type)) -+ return false; - } -- -- return 0; -+ return true; - } - --static int compare_function_decl_rb(const void *key, const struct rb_entry *entry) -+struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const char *name, -+ const struct hlsl_func_parameters *parameters) - { -- const struct hlsl_ir_function_decl *decl = RB_ENTRY_VALUE(entry, const struct hlsl_ir_function_decl, entry); -- const struct hlsl_func_parameters *parameters = key; -- size_t i; -- int r; -+ struct hlsl_ir_function_decl *decl; -+ struct hlsl_ir_function *func; - -- if ((r = vkd3d_u32_compare(parameters->count, decl->parameters.count))) -- return r; -+ if (!(func = hlsl_get_function(ctx, name))) -+ return NULL; - -- for (i = 0; i < parameters->count; ++i) -+ LIST_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) - { -- if ((r = compare_param_hlsl_types(parameters->vars[i]->data_type, decl->parameters.vars[i]->data_type))) -- return r; -+ if (func_decl_matches(decl, parameters)) -+ return decl; - } -- return 0; -+ -+ return NULL; - } - - struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const struct hlsl_type *type) -@@ -2193,6 +2257,10 @@ struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsig - vkd3d_string_buffer_printf(string, "extern "); - if (modifiers & HLSL_STORAGE_NOINTERPOLATION) - vkd3d_string_buffer_printf(string, "nointerpolation "); -+ if (modifiers & HLSL_STORAGE_CENTROID) -+ vkd3d_string_buffer_printf(string, "centroid "); -+ if (modifiers & HLSL_STORAGE_NOPERSPECTIVE) -+ vkd3d_string_buffer_printf(string, "noperspective "); - if (modifiers & HLSL_MODIFIER_PRECISE) - vkd3d_string_buffer_printf(string, "precise "); - if (modifiers & HLSL_STORAGE_SHARED) -@@ -2239,6 +2307,7 @@ const char *hlsl_node_type_to_string(enum hlsl_ir_node_type type) - [HLSL_IR_RESOURCE_LOAD ] = "HLSL_IR_RESOURCE_LOAD", - [HLSL_IR_RESOURCE_STORE] = "HLSL_IR_RESOURCE_STORE", - [HLSL_IR_STORE ] = "HLSL_IR_STORE", -+ [HLSL_IR_SWITCH ] = "HLSL_IR_SWITCH", - [HLSL_IR_SWIZZLE ] = "HLSL_IR_SWIZZLE", - }; - -@@ -2305,21 +2374,34 @@ static void dump_deref(struct vkd3d_string_buffer *buffer, const struct hlsl_der - if (deref->var) - { - vkd3d_string_buffer_printf(buffer, "%s", deref->var->name); -- if (deref->path_len) -+ if (!hlsl_deref_is_lowered(deref)) - { -- vkd3d_string_buffer_printf(buffer, "["); -- for (i = 0; i < deref->path_len; ++i) -+ if (deref->path_len) - { - vkd3d_string_buffer_printf(buffer, "["); -- dump_src(buffer, &deref->path[i]); -+ for (i = 0; i < deref->path_len; ++i) -+ { -+ vkd3d_string_buffer_printf(buffer, "["); -+ dump_src(buffer, &deref->path[i]); -+ vkd3d_string_buffer_printf(buffer, "]"); -+ } - vkd3d_string_buffer_printf(buffer, "]"); - } -- vkd3d_string_buffer_printf(buffer, "]"); - } -- else if (deref->offset.node) -+ else - { -+ bool show_rel, show_const; -+ -+ show_rel = deref->rel_offset.node; -+ show_const = deref->const_offset != 0 || !show_rel; -+ - vkd3d_string_buffer_printf(buffer, "["); -- dump_src(buffer, &deref->offset); -+ if (show_rel) -+ dump_src(buffer, &deref->rel_offset); -+ if (show_rel && show_const) -+ vkd3d_string_buffer_printf(buffer, " + "); -+ if (show_const) -+ vkd3d_string_buffer_printf(buffer, "%uc", deref->const_offset); - vkd3d_string_buffer_printf(buffer, "]"); - } - } -@@ -2440,6 +2522,7 @@ const char *debug_hlsl_expr_op(enum hlsl_ir_expr_op op) - [HLSL_OP1_ABS] = "abs", - [HLSL_OP1_BIT_NOT] = "~", - [HLSL_OP1_CAST] = "cast", -+ [HLSL_OP1_CEIL] = "ceil", - [HLSL_OP1_COS] = "cos", - [HLSL_OP1_COS_REDUCED] = "cos_reduced", - [HLSL_OP1_DSX] = "dsx", -@@ -2449,6 +2532,7 @@ const char *debug_hlsl_expr_op(enum hlsl_ir_expr_op op) - [HLSL_OP1_DSY_COARSE] = "dsy_coarse", - [HLSL_OP1_DSY_FINE] = "dsy_fine", - [HLSL_OP1_EXP2] = "exp2", -+ [HLSL_OP1_FLOOR] = "floor", - [HLSL_OP1_FRACT] = "fract", - [HLSL_OP1_LOG2] = "log2", - [HLSL_OP1_LOGIC_NOT] = "!", -@@ -2485,6 +2569,7 @@ const char *debug_hlsl_expr_op(enum hlsl_ir_expr_op op) - [HLSL_OP2_NEQUAL] = "!=", - [HLSL_OP2_RSHIFT] = ">>", - -+ [HLSL_OP3_CMP] = "cmp", - [HLSL_OP3_DP2ADD] = "dp2add", - [HLSL_OP3_MOVC] = "movc", - [HLSL_OP3_TERNARY] = "ternary", -@@ -2540,6 +2625,10 @@ static void dump_ir_jump(struct vkd3d_string_buffer *buffer, const struct hlsl_i - case HLSL_IR_JUMP_RETURN: - vkd3d_string_buffer_printf(buffer, "return"); - break; -+ -+ case HLSL_IR_JUMP_UNRESOLVED_CONTINUE: -+ vkd3d_string_buffer_printf(buffer, "unresolved_continue"); -+ break; - } - } - -@@ -2659,6 +2748,32 @@ static void dump_ir_index(struct vkd3d_string_buffer *buffer, const struct hlsl_ - vkd3d_string_buffer_printf(buffer, "]"); - } - -+static void dump_ir_switch(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer, const struct hlsl_ir_switch *s) -+{ -+ struct hlsl_ir_switch_case *c; -+ -+ vkd3d_string_buffer_printf(buffer, "switch ("); -+ dump_src(buffer, &s->selector); -+ vkd3d_string_buffer_printf(buffer, ") {\n"); -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ if (c->is_default) -+ { -+ vkd3d_string_buffer_printf(buffer, " %10s default: {\n", ""); -+ } -+ else -+ { -+ vkd3d_string_buffer_printf(buffer, " %10s case %u : {\n", "", c->value); -+ } -+ -+ dump_block(ctx, buffer, &c->body); -+ vkd3d_string_buffer_printf(buffer, " %10s }\n", ""); -+ } -+ -+ vkd3d_string_buffer_printf(buffer, " %10s }", ""); -+} -+ - static void dump_instr(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer, const struct hlsl_ir_node *instr) - { - if (instr->index) -@@ -2714,6 +2829,10 @@ static void dump_instr(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer, - dump_ir_store(buffer, hlsl_ir_store(instr)); - break; - -+ case HLSL_IR_SWITCH: -+ dump_ir_switch(ctx, buffer, hlsl_ir_switch(instr)); -+ break; -+ - case HLSL_IR_SWIZZLE: - dump_ir_swizzle(buffer, hlsl_ir_swizzle(instr)); - break; -@@ -2855,7 +2974,7 @@ static void free_ir_resource_load(struct hlsl_ir_resource_load *load) - - static void free_ir_resource_store(struct hlsl_ir_resource_store *store) - { -- hlsl_src_remove(&store->resource.offset); -+ hlsl_src_remove(&store->resource.rel_offset); - hlsl_src_remove(&store->coords); - hlsl_src_remove(&store->value); - vkd3d_free(store); -@@ -2874,6 +2993,14 @@ static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle) - vkd3d_free(swizzle); - } - -+static void free_ir_switch(struct hlsl_ir_switch *s) -+{ -+ hlsl_src_remove(&s->selector); -+ hlsl_cleanup_ir_switch_cases(&s->cases); -+ -+ vkd3d_free(s); -+} -+ - static void free_ir_index(struct hlsl_ir_index *index) - { - hlsl_src_remove(&index->val); -@@ -2934,6 +3061,10 @@ void hlsl_free_instr(struct hlsl_ir_node *node) - case HLSL_IR_SWIZZLE: - free_ir_swizzle(hlsl_ir_swizzle(node)); - break; -+ -+ case HLSL_IR_SWITCH: -+ free_ir_switch(hlsl_ir_switch(node)); -+ break; - } - } - -@@ -2967,14 +3098,12 @@ static void free_function_decl(struct hlsl_ir_function_decl *decl) - vkd3d_free(decl); - } - --static void free_function_decl_rb(struct rb_entry *entry, void *context) --{ -- free_function_decl(RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry)); --} -- - static void free_function(struct hlsl_ir_function *func) - { -- rb_destroy(&func->overloads, free_function_decl_rb, NULL); -+ struct hlsl_ir_function_decl *decl, *next; -+ -+ LIST_FOR_EACH_ENTRY_SAFE(decl, next, &func->overloads, struct hlsl_ir_function_decl, entry) -+ free_function_decl(decl); - vkd3d_free((void *)func->name); - vkd3d_free(func); - } -@@ -3004,17 +3133,15 @@ void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function - { - func = RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry); - decl->func = func; -- -- if (rb_put(&func->overloads, &decl->parameters, &decl->entry) == -1) -- ERR("Failed to insert function overload.\n"); -+ list_add_tail(&func->overloads, &decl->entry); - vkd3d_free(name); - return; - } - func = hlsl_alloc(ctx, sizeof(*func)); - func->name = name; -- rb_init(&func->overloads, compare_function_decl_rb); -+ list_init(&func->overloads); - decl->func = func; -- rb_put(&func->overloads, &decl->parameters, &decl->entry); -+ list_add_tail(&func->overloads, &decl->entry); - rb_put(&ctx->functions, func->name, &func->entry); - } - -@@ -3092,7 +3219,7 @@ unsigned int hlsl_combine_swizzles(unsigned int first, unsigned int second, unsi - return ret; - } - --static const struct hlsl_profile_info *get_target_info(const char *target) -+const struct hlsl_profile_info *hlsl_get_target_info(const char *target) - { - unsigned int i; - -@@ -3395,6 +3522,10 @@ static bool hlsl_ctx_init(struct hlsl_ctx *ctx, const struct vkd3d_shader_compil - else if (option->value == VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_COLUMN_MAJOR) - ctx->matrix_majority = HLSL_MODIFIER_COLUMN_MAJOR; - } -+ else if (option->name == VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY) -+ { -+ ctx->semantic_compat_mapping = option->value & VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES; -+ } - } - - return true; -@@ -3455,14 +3586,12 @@ int hlsl_compile_shader(const struct vkd3d_shader_code *hlsl, const struct vkd3d - } - entry_point = hlsl_source_info->entry_point ? hlsl_source_info->entry_point : "main"; - -- if (!(profile = get_target_info(hlsl_source_info->profile))) -+ if (!(profile = hlsl_get_target_info(hlsl_source_info->profile))) - { - FIXME("Unknown compilation target %s.\n", debugstr_a(hlsl_source_info->profile)); - return VKD3D_ERROR_NOT_IMPLEMENTED; - } - -- vkd3d_shader_dump_shader(compile_info->source_type, profile->type, &compile_info->source); -- - if (compile_info->target_type == VKD3D_SHADER_TARGET_D3D_BYTECODE && profile->major_version > 3) - { - vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_HLSL_INCOMPATIBLE_PROFILE, -@@ -3501,7 +3630,7 @@ int hlsl_compile_shader(const struct vkd3d_shader_code *hlsl, const struct vkd3d - - if ((func = hlsl_get_function(&ctx, entry_point))) - { -- RB_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) -+ LIST_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) - { - if (!decl->has_body) - continue; -@@ -3567,7 +3696,7 @@ struct hlsl_ir_function_decl *hlsl_compile_internal_function(struct hlsl_ctx *ct - hlsl_release_string_buffer(ctx, internal_name); - return NULL; - } -- func = hlsl_get_func_decl(ctx, internal_name->buffer); -+ func = hlsl_get_first_func_decl(ctx, internal_name->buffer); - hlsl_release_string_buffer(ctx, internal_name); - return func; - } -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.h b/libs/vkd3d/libs/vkd3d-shader/hlsl.h -index 743a746f2bf..a0065572539 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.h -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.h -@@ -21,13 +21,10 @@ - #define __VKD3D_SHADER_HLSL_H - - #include "vkd3d_shader_private.h" --#include "wine/rbtree.h" -+#include "rbtree.h" - #include "d3dcommon.h" - #include "d3dx9shader.h" - --enum vkd3d_sm4_register_type; --enum vkd3d_sm4_swizzle_type; -- - /* The general IR structure is inspired by Mesa GLSL hir, even though the code - * ends up being quite different in practice. Anyway, here comes the relevant - * licensing information. -@@ -284,6 +281,7 @@ enum hlsl_ir_node_type - HLSL_IR_RESOURCE_STORE, - HLSL_IR_STORE, - HLSL_IR_SWIZZLE, -+ HLSL_IR_SWITCH, - }; - - /* Common data for every type of IR instruction node. */ -@@ -357,11 +355,16 @@ struct hlsl_attribute - #define HLSL_STORAGE_IN 0x00000800 - #define HLSL_STORAGE_OUT 0x00001000 - #define HLSL_MODIFIER_INLINE 0x00002000 -+#define HLSL_STORAGE_CENTROID 0x00004000 -+#define HLSL_STORAGE_NOPERSPECTIVE 0x00008000 - - #define HLSL_TYPE_MODIFIERS_MASK (HLSL_MODIFIER_PRECISE | HLSL_MODIFIER_VOLATILE | \ - HLSL_MODIFIER_CONST | HLSL_MODIFIER_ROW_MAJOR | \ - HLSL_MODIFIER_COLUMN_MAJOR) - -+#define HLSL_INTERPOLATION_MODIFIERS_MASK (HLSL_STORAGE_NOINTERPOLATION | HLSL_STORAGE_CENTROID | \ -+ HLSL_STORAGE_NOPERSPECTIVE) -+ - #define HLSL_MODIFIERS_MAJORITY_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR) - - #define HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT 0 -@@ -369,7 +372,7 @@ struct hlsl_attribute - /* Reservation of a register and/or an offset for objects inside constant buffers, to be used as a - * starting point of their allocation. They are available through the register(·) and the - * packoffset(·) syntaxes, respectivelly. -- * The costant buffer offset is measured register components. */ -+ * The constant buffer offset is measured register components. */ - struct hlsl_reg_reservation - { - char reg_type; -@@ -422,6 +425,9 @@ struct hlsl_ir_var - * It may be less than the allocation size, e.g. for texture arrays. */ - unsigned int bind_count[HLSL_REGSET_LAST_OBJECT + 1]; - -+ /* Whether the shader performs dereferences with non-constant offsets in the variable. */ -+ bool indexable; -+ - uint32_t is_input_semantic : 1; - uint32_t is_output_semantic : 1; - uint32_t is_uniform : 1; -@@ -444,7 +450,7 @@ struct hlsl_ir_function - const char *name; - /* Tree containing function definitions, stored as hlsl_ir_function_decl structures, which would - * be more than one in case of function overloading. */ -- struct rb_tree overloads; -+ struct list overloads; - }; - - struct hlsl_ir_function_decl -@@ -454,8 +460,8 @@ struct hlsl_ir_function_decl - struct hlsl_ir_var *return_var; - - struct vkd3d_shader_location loc; -- /* Item entry in hlsl_ir_function.overloads. The parameters' types are used as key. */ -- struct rb_entry entry; -+ /* Item entry in hlsl_ir_function.overloads. */ -+ struct list entry; - - /* Function to which this declaration corresponds. */ - struct hlsl_ir_function *func; -@@ -497,6 +503,22 @@ struct hlsl_ir_loop - unsigned int next_index; /* liveness index of the end of the loop */ - }; - -+struct hlsl_ir_switch_case -+{ -+ unsigned int value; -+ bool is_default; -+ struct hlsl_block body; -+ struct list entry; -+ struct vkd3d_shader_location loc; -+}; -+ -+struct hlsl_ir_switch -+{ -+ struct hlsl_ir_node node; -+ struct hlsl_src selector; -+ struct list cases; -+}; -+ - enum hlsl_ir_expr_op - { - HLSL_OP0_VOID, -@@ -504,6 +526,7 @@ enum hlsl_ir_expr_op - HLSL_OP1_ABS, - HLSL_OP1_BIT_NOT, - HLSL_OP1_CAST, -+ HLSL_OP1_CEIL, - HLSL_OP1_COS, - HLSL_OP1_COS_REDUCED, /* Reduced range [-pi, pi] */ - HLSL_OP1_DSX, -@@ -556,7 +579,10 @@ enum hlsl_ir_expr_op - /* MOVC(a, b, c) returns c if a is bitwise zero and b otherwise. - * TERNARY(a, b, c) returns c if a == 0 and b otherwise. - * They differ for floating point numbers, because -- * -0.0 == 0.0, but it is not bitwise zero. */ -+ * -0.0 == 0.0, but it is not bitwise zero. CMP(a, b, c) returns b -+ if a >= 0, and c otherwise. It's used only for SM1-SM3 targets, while -+ SM4+ is using MOVC in such cases. */ -+ HLSL_OP3_CMP, - HLSL_OP3_MOVC, - HLSL_OP3_TERNARY, - }; -@@ -577,6 +603,10 @@ enum hlsl_ir_jump_type - HLSL_IR_JUMP_DISCARD_NEG, - HLSL_IR_JUMP_DISCARD_NZ, - HLSL_IR_JUMP_RETURN, -+ /* UNRESOLVED_CONTINUE type is used by the parser when 'continue' statement is found, -+ it never reaches code generation, and is resolved to CONTINUE type once iteration -+ and loop exit logic was properly applied. */ -+ HLSL_IR_JUMP_UNRESOLVED_CONTINUE, - }; - - struct hlsl_ir_jump -@@ -615,17 +645,25 @@ struct hlsl_deref - unsigned int path_len; - struct hlsl_src *path; - -- /* Single instruction node of data type uint used to represent the register offset (in register -- * components, within the pertaining regset), from the start of the variable, of the part -- * referenced. -- * The path is lowered to this single offset -- whose value may vary between SM1 and SM4 -- -- * before writing the bytecode. -+ /* Before writing the bytecode, deref paths are lowered into an offset (within the pertaining -+ * regset) from the start of the variable, to the part of the variable that is referenced. -+ * This offset is stored using two fields, one for a variable part and other for a constant -+ * part, which are added together: -+ * - rel_offset: An offset given by an instruction node, in whole registers. -+ * - const_offset: A constant number of register components. - * Since the type information cannot longer be retrieved from the offset alone, the type is -- * stored in the data_type field. */ -- struct hlsl_src offset; -+ * stored in the data_type field, which remains NULL if the deref hasn't been lowered yet. */ -+ struct hlsl_src rel_offset; -+ unsigned int const_offset; - struct hlsl_type *data_type; - }; - -+/* Whether the path has been lowered to an offset or not. */ -+static inline bool hlsl_deref_is_lowered(const struct hlsl_deref *deref) -+{ -+ return !!deref->data_type; -+} -+ - struct hlsl_ir_load - { - struct hlsl_ir_node node; -@@ -641,6 +679,7 @@ enum hlsl_resource_load_type - HLSL_RESOURCE_SAMPLE_LOD, - HLSL_RESOURCE_SAMPLE_LOD_BIAS, - HLSL_RESOURCE_SAMPLE_GRAD, -+ HLSL_RESOURCE_SAMPLE_PROJ, - HLSL_RESOURCE_GATHER_RED, - HLSL_RESOURCE_GATHER_GREEN, - HLSL_RESOURCE_GATHER_BLUE, -@@ -702,6 +741,10 @@ struct hlsl_scope - struct rb_tree types; - /* Scope containing this scope. This value is NULL for the global scope. */ - struct hlsl_scope *upper; -+ /* The scope was created for the loop statement. */ -+ bool loop; -+ /* The scope was created for the switch statement. */ -+ bool _switch; - }; - - struct hlsl_profile_info -@@ -854,13 +897,8 @@ struct hlsl_ctx - uint32_t in_state_block : 1; - /* Whether the numthreads() attribute has been provided in the entry-point function. */ - uint32_t found_numthreads : 1; --}; - --enum hlsl_error_level --{ -- HLSL_LEVEL_ERROR = 0, -- HLSL_LEVEL_WARNING, -- HLSL_LEVEL_NOTE, -+ bool semantic_compat_mapping; - }; - - struct hlsl_resource_load_params -@@ -944,6 +982,12 @@ static inline struct hlsl_ir_index *hlsl_ir_index(const struct hlsl_ir_node *nod - return CONTAINING_RECORD(node, struct hlsl_ir_index, node); - } - -+static inline struct hlsl_ir_switch *hlsl_ir_switch(const struct hlsl_ir_node *node) -+{ -+ assert(node->type == HLSL_IR_SWITCH); -+ return CONTAINING_RECORD(node, struct hlsl_ir_switch, node); -+} -+ - static inline void hlsl_block_init(struct hlsl_block *block) - { - list_init(&block->instrs); -@@ -1061,6 +1105,11 @@ static inline struct hlsl_type *hlsl_get_numeric_type(const struct hlsl_ctx *ctx - return hlsl_get_matrix_type(ctx, base_type, dimx, dimy); - } - -+static inline bool hlsl_is_numeric_type(const struct hlsl_type *type) -+{ -+ return type->class <= HLSL_CLASS_LAST_NUMERIC; -+} -+ - static inline unsigned int hlsl_sampler_dim_count(enum hlsl_sampler_dim dim) - { - switch (dim) -@@ -1117,6 +1166,9 @@ bool hlsl_copy_deref(struct hlsl_ctx *ctx, struct hlsl_deref *deref, const struc - void hlsl_cleanup_deref(struct hlsl_deref *deref); - void hlsl_cleanup_semantic(struct hlsl_semantic *semantic); - -+void hlsl_cleanup_ir_switch_cases(struct list *cases); -+void hlsl_free_ir_switch_case(struct hlsl_ir_switch_case *c); -+ - void hlsl_replace_node(struct hlsl_ir_node *old, struct hlsl_ir_node *new); - - void hlsl_free_attribute(struct hlsl_attribute *attr); -@@ -1126,7 +1178,10 @@ void hlsl_free_type(struct hlsl_type *type); - void hlsl_free_var(struct hlsl_ir_var *decl); - - struct hlsl_ir_function *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_ir_function_decl *hlsl_get_first_func_decl(struct hlsl_ctx *ctx, const char *name); -+struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const char *name, -+ const struct hlsl_func_parameters *parameters); -+const struct hlsl_profile_info *hlsl_get_target_info(const char *target); - struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool recursive, bool case_insensitive); - struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name); - -@@ -1210,6 +1265,10 @@ struct hlsl_ir_node *hlsl_new_unary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr - 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); -+struct hlsl_ir_switch_case *hlsl_new_switch_case(struct hlsl_ctx *ctx, unsigned int value, bool is_default, -+ struct hlsl_block *body, const struct vkd3d_shader_location *loc); -+struct hlsl_ir_node *hlsl_new_switch(struct hlsl_ctx *ctx, struct hlsl_ir_node *selector, -+ struct list *cases, 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); -@@ -1232,13 +1291,12 @@ unsigned int hlsl_type_get_array_element_reg_size(const struct hlsl_type *type, - struct hlsl_type *hlsl_type_get_component_type(struct hlsl_ctx *ctx, struct hlsl_type *type, - unsigned int index); - unsigned int hlsl_type_get_component_offset(struct hlsl_ctx *ctx, struct hlsl_type *type, -- enum hlsl_regset regset, unsigned int index); -+ unsigned int index, enum hlsl_regset *regset); - bool hlsl_type_is_row_major(const struct hlsl_type *type); - unsigned int hlsl_type_minor_size(const struct hlsl_type *type); - unsigned int hlsl_type_major_size(const struct hlsl_type *type); - unsigned int hlsl_type_element_count(const struct hlsl_type *type); - bool hlsl_type_is_resource(const struct hlsl_type *type); --enum hlsl_regset hlsl_type_get_regset(const struct hlsl_type *type); - unsigned int hlsl_type_get_sm4_offset(const struct hlsl_type *type, unsigned int offset); - bool hlsl_types_are_equal(const struct hlsl_type *t1, const struct hlsl_type *t2); - -@@ -1251,6 +1309,7 @@ unsigned int hlsl_map_swizzle(unsigned int swizzle, unsigned int writemask); - unsigned int hlsl_swizzle_from_writemask(unsigned int writemask); - - struct hlsl_type *hlsl_deref_get_type(struct hlsl_ctx *ctx, const struct hlsl_deref *deref); -+enum hlsl_regset hlsl_deref_get_regset(struct hlsl_ctx *ctx, const struct hlsl_deref *deref); - bool hlsl_component_index_range_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, - unsigned int *start, unsigned int *count); - bool hlsl_regset_index_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, -@@ -1273,7 +1332,7 @@ int hlsl_sm1_write(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun - bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, - const struct hlsl_semantic *semantic, bool output, D3D_NAME *usage); - bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, -- bool output, enum vkd3d_shader_register_type *type, enum vkd3d_sm4_swizzle_type *swizzle_type, bool *has_idx); -+ bool output, enum vkd3d_shader_register_type *type, bool *has_idx); - int hlsl_sm4_write(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, struct vkd3d_shader_code *out); - - struct hlsl_ir_function_decl *hlsl_compile_internal_function(struct hlsl_ctx *ctx, const char *name, const char *hlsl); -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.l b/libs/vkd3d/libs/vkd3d-shader/hlsl.l -index e9ae3ccf3d3..401fba60422 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.l -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.l -@@ -46,14 +46,13 @@ static void update_location(struct hlsl_ctx *ctx, YYLTYPE *loc); - - %x pp pp_line pp_pragma pp_ignore - --RESERVED1 auto|case|catch|char|class|const_cast|default|delete|dynamic_cast|enum -+RESERVED1 auto|catch|char|class|const_cast|delete|dynamic_cast|enum - RESERVED2 explicit|friend|goto|long|mutable|new|operator|private|protected|public - RESERVED3 reinterpret_cast|short|signed|sizeof|static_cast|template|this|throw|try - RESERVED4 typename|union|unsigned|using|virtual - - WS [ \t] - NEWLINE (\n)|(\r\n) --DOUBLESLASHCOMMENT "//"[^\n]* - STRING \"[^\"]*\" - IDENTIFIER [A-Za-z_][A-Za-z0-9_]* - -@@ -73,12 +72,16 @@ ANY (.) - BlendState {return KW_BLENDSTATE; } - break {return KW_BREAK; } - Buffer {return KW_BUFFER; } -+case {return KW_CASE; } - cbuffer {return KW_CBUFFER; } -+centroid {return KW_CENTROID; } -+column_major {return KW_COLUMN_MAJOR; } - compile {return KW_COMPILE; } - const {return KW_CONST; } - continue {return KW_CONTINUE; } - DepthStencilState {return KW_DEPTHSTENCILSTATE; } - DepthStencilView {return KW_DEPTHSTENCILVIEW; } -+default {return KW_DEFAULT; } - discard {return KW_DISCARD; } - do {return KW_DO; } - double {return KW_DOUBLE; } -@@ -95,28 +98,32 @@ inout {return KW_INOUT; } - matrix {return KW_MATRIX; } - namespace {return KW_NAMESPACE; } - nointerpolation {return KW_NOINTERPOLATION; } -+noperspective {return KW_NOPERSPECTIVE; } - out {return KW_OUT; } - packoffset {return KW_PACKOFFSET; } - pass {return KW_PASS; } - PixelShader {return KW_PIXELSHADER; } - precise {return KW_PRECISE; } - RasterizerState {return KW_RASTERIZERSTATE; } -+register {return KW_REGISTER; } - RenderTargetView {return KW_RENDERTARGETVIEW; } - return {return KW_RETURN; } --register {return KW_REGISTER; } -+row_major {return KW_ROW_MAJOR; } - RWBuffer {return KW_RWBUFFER; } - RWStructuredBuffer {return KW_RWSTRUCTUREDBUFFER; } - RWTexture1D {return KW_RWTEXTURE1D; } -+RWTexture1DArray {return KW_RWTEXTURE1DARRAY; } - RWTexture2D {return KW_RWTEXTURE2D; } -+RWTexture2DArray {return KW_RWTEXTURE2DARRAY; } - RWTexture3D {return KW_RWTEXTURE3D; } - sampler {return KW_SAMPLER; } - sampler1D {return KW_SAMPLER1D; } - sampler2D {return KW_SAMPLER2D; } - sampler3D {return KW_SAMPLER3D; } --samplerCUBE {return KW_SAMPLERCUBE; } --sampler_state {return KW_SAMPLER_STATE; } - SamplerComparisonState {return KW_SAMPLERCOMPARISONSTATE;} -+samplerCUBE {return KW_SAMPLERCUBE; } - SamplerState {return KW_SAMPLER; } -+sampler_state {return KW_SAMPLER_STATE; } - shared {return KW_SHARED; } - stateblock {return KW_STATEBLOCK; } - stateblock_state {return KW_STATEBLOCK_STATE; } -@@ -125,21 +132,22 @@ string {return KW_STRING; } - struct {return KW_STRUCT; } - switch {return KW_SWITCH; } - tbuffer {return KW_TBUFFER; } --technique {return KW_TECHNIQUE; } -+(?i:technique) {return KW_TECHNIQUE; } - technique10 {return KW_TECHNIQUE10; } -+technique11 {return KW_TECHNIQUE11; } - texture {return KW_TEXTURE; } --texture1D {return KW_TEXTURE1D; } - Texture1D {return KW_TEXTURE1D; } -+texture1D {return KW_TEXTURE1D; } - Texture1DArray {return KW_TEXTURE1DARRAY; } --texture2D {return KW_TEXTURE2D; } - Texture2D {return KW_TEXTURE2D; } -+texture2D {return KW_TEXTURE2D; } - Texture2DArray {return KW_TEXTURE2DARRAY; } - Texture2DMS {return KW_TEXTURE2DMS; } - Texture2DMSArray {return KW_TEXTURE2DMSARRAY; } --texture3D {return KW_TEXTURE3D; } - Texture3D {return KW_TEXTURE3D; } --textureCUBE {return KW_TEXTURECUBE; } -+texture3D {return KW_TEXTURE3D; } - TextureCube {return KW_TEXTURECUBE; } -+textureCUBE {return KW_TEXTURECUBE; } - TextureCubeArray {return KW_TEXTURECUBEARRAY; } - true {return KW_TRUE; } - typedef {return KW_TYPEDEF; } -@@ -159,7 +167,6 @@ while {return KW_WHILE; } - \<\<= {return OP_LEFTSHIFTASSIGN; } - \>\> {return OP_RIGHTSHIFT; } - \>\>= {return OP_RIGHTSHIFTASSIGN; } --\.\.\. {return OP_ELLIPSIS; } - \<= {return OP_LE; } - \>= {return OP_GE; } - != {return OP_NE; } -@@ -171,13 +178,6 @@ while {return KW_WHILE; } - &= {return OP_ANDASSIGN; } - \|= {return OP_ORASSIGN; } - ^= {return OP_XORASSIGN; } --## {return OP_UNKNOWN1; } --#@ {return OP_UNKNOWN2; } --:: {return OP_UNKNOWN3; } --\-\> {return OP_UNKNOWN4; } -- --column_major {return KW_COLUMN_MAJOR; } --row_major {return KW_ROW_MAJOR; } - - {IDENTIFIER} { - struct hlsl_ctx *ctx = yyget_extra(yyscanner); -@@ -203,20 +203,30 @@ row_major {return KW_ROW_MAJOR; } - yylval->floatval = atof(yytext); - return C_FLOAT; - } --0x[0-9a-fA-F]+ { -+0x[0-9a-fA-F]+[lL]? { - yylval->intval = vkd3d_parse_integer(yytext); - return C_INTEGER; - } --0[0-7]+ { -+0[0-7]+[lL]? { - yylval->intval = vkd3d_parse_integer(yytext); - return C_INTEGER; - } --[0-9]+ { -+[0-9]+[lL]? { - yylval->intval = vkd3d_parse_integer(yytext); - return C_INTEGER; - } -- --{DOUBLESLASHCOMMENT} {} -+0x[0-9a-fA-F]+([uU]|[uU][lL]|[lL][uU]) { -+ yylval->intval = vkd3d_parse_integer(yytext); -+ return C_UNSIGNED; -+ } -+0[0-7]+([uU]|[uU][lL]|[lL][uU]) { -+ yylval->intval = vkd3d_parse_integer(yytext); -+ return C_UNSIGNED; -+ } -+[0-9]+([uU]|[uU][lL]|[lL][uU]) { -+ yylval->intval = vkd3d_parse_integer(yytext); -+ return C_UNSIGNED; -+ } - - {WS}+ {} - {NEWLINE} { -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.y b/libs/vkd3d/libs/vkd3d-shader/hlsl.y -index fb6d485ea69..67b01293683 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.y -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.y -@@ -162,6 +162,12 @@ static void destroy_block(struct hlsl_block *block) - vkd3d_free(block); - } - -+static void destroy_switch_cases(struct list *cases) -+{ -+ hlsl_cleanup_ir_switch_cases(cases); -+ vkd3d_free(cases); -+} -+ - static bool hlsl_types_are_componentwise_compatible(struct hlsl_ctx *ctx, struct hlsl_type *src, - struct hlsl_type *dst) - { -@@ -205,7 +211,7 @@ static bool hlsl_types_are_componentwise_equal(struct hlsl_ctx *ctx, struct hlsl - return true; - } - --static bool type_contains_only_numerics(struct hlsl_type *type) -+static bool type_contains_only_numerics(const struct hlsl_type *type) - { - unsigned int i; - -@@ -220,12 +226,12 @@ static bool type_contains_only_numerics(struct hlsl_type *type) - } - return true; - } -- return type->class <= HLSL_CLASS_LAST_NUMERIC; -+ return hlsl_is_numeric_type(type); - } - - static bool explicit_compatible_data_types(struct hlsl_ctx *ctx, struct hlsl_type *src, struct hlsl_type *dst) - { -- if (src->class <= HLSL_CLASS_LAST_NUMERIC && src->dimx == 1 && src->dimy == 1 && type_contains_only_numerics(dst)) -+ if (hlsl_is_numeric_type(src) && src->dimx == 1 && src->dimy == 1 && type_contains_only_numerics(dst)) - return true; - - if (src->class == HLSL_CLASS_MATRIX && dst->class == HLSL_CLASS_MATRIX -@@ -245,10 +251,10 @@ static bool explicit_compatible_data_types(struct hlsl_ctx *ctx, struct hlsl_typ - - static bool implicit_compatible_data_types(struct hlsl_ctx *ctx, struct hlsl_type *src, struct hlsl_type *dst) - { -- if ((src->class <= HLSL_CLASS_LAST_NUMERIC) != (dst->class <= HLSL_CLASS_LAST_NUMERIC)) -+ if (hlsl_is_numeric_type(src) != hlsl_is_numeric_type(dst)) - return false; - -- if (src->class <= HLSL_CLASS_LAST_NUMERIC) -+ if (hlsl_is_numeric_type(src)) - { - /* Scalar vars can be converted to any other numeric data type */ - if (src->dimx == 1 && src->dimy == 1) -@@ -305,7 +311,7 @@ static struct hlsl_ir_node *add_cast(struct hlsl_ctx *ctx, struct hlsl_block *bl - struct hlsl_ir_var *var; - unsigned int dst_idx; - -- broadcast = src_type->class <= HLSL_CLASS_LAST_NUMERIC && src_type->dimx == 1 && src_type->dimy == 1; -+ broadcast = hlsl_is_numeric_type(src_type) && src_type->dimx == 1 && src_type->dimy == 1; - matrix_cast = !broadcast && dst_comp_count != src_comp_count - && src_type->class == HLSL_CLASS_MATRIX && dst_type->class == HLSL_CLASS_MATRIX; - assert(src_comp_count >= dst_comp_count || broadcast); -@@ -464,6 +470,72 @@ static bool attribute_list_has_duplicates(const struct parse_attribute_list *att - return false; - } - -+static void resolve_loop_continue(struct hlsl_ctx *ctx, struct hlsl_block *block, enum loop_type type, -+ struct hlsl_block *cond, struct hlsl_block *iter) -+{ -+ struct hlsl_ir_node *instr, *next; -+ -+ LIST_FOR_EACH_ENTRY_SAFE(instr, next, &block->instrs, struct hlsl_ir_node, entry) -+ { -+ if (instr->type == HLSL_IR_IF) -+ { -+ struct hlsl_ir_if *iff = hlsl_ir_if(instr); -+ -+ resolve_loop_continue(ctx, &iff->then_block, type, cond, iter); -+ resolve_loop_continue(ctx, &iff->else_block, type, cond, iter); -+ } -+ else if (instr->type == HLSL_IR_JUMP) -+ { -+ struct hlsl_ir_jump *jump = hlsl_ir_jump(instr); -+ struct hlsl_block block; -+ -+ if (jump->type != HLSL_IR_JUMP_UNRESOLVED_CONTINUE) -+ continue; -+ -+ if (type == LOOP_DO_WHILE) -+ { -+ if (!hlsl_clone_block(ctx, &block, cond)) -+ return; -+ if (!append_conditional_break(ctx, &block)) -+ { -+ hlsl_block_cleanup(&block); -+ return; -+ } -+ list_move_before(&instr->entry, &block.instrs); -+ } -+ else if (type == LOOP_FOR) -+ { -+ if (!hlsl_clone_block(ctx, &block, iter)) -+ return; -+ list_move_before(&instr->entry, &block.instrs); -+ } -+ jump->type = HLSL_IR_JUMP_CONTINUE; -+ } -+ } -+} -+ -+static void check_loop_attributes(struct hlsl_ctx *ctx, const struct parse_attribute_list *attributes, -+ const struct vkd3d_shader_location *loc) -+{ -+ bool has_unroll = false, has_loop = false, has_fastopt = false; -+ unsigned int i; -+ -+ for (i = 0; i < attributes->count; ++i) -+ { -+ const char *name = attributes->attrs[i]->name; -+ -+ has_loop |= !strcmp(name, "loop"); -+ has_unroll |= !strcmp(name, "unroll"); -+ has_fastopt |= !strcmp(name, "fastopt"); -+ } -+ -+ if (has_unroll && has_loop) -+ hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, "Unroll attribute can't be used with 'loop' attribute."); -+ -+ if (has_unroll && has_fastopt) -+ hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, "Unroll attribute can't be used with 'fastopt' attribute."); -+} -+ - static struct hlsl_block *create_loop(struct hlsl_ctx *ctx, enum loop_type type, - const struct parse_attribute_list *attributes, struct hlsl_block *init, struct hlsl_block *cond, - struct hlsl_block *iter, struct hlsl_block *body, const struct vkd3d_shader_location *loc) -@@ -474,6 +546,8 @@ static struct hlsl_block *create_loop(struct hlsl_ctx *ctx, enum loop_type type, - if (attribute_list_has_duplicates(attributes)) - hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, "Found duplicate attribute."); - -+ check_loop_attributes(ctx, attributes, loc); -+ - /* Ignore unroll(0) attribute, and any invalid attribute. */ - for (i = 0; i < attributes->count; ++i) - { -@@ -489,8 +563,11 @@ static struct hlsl_block *create_loop(struct hlsl_ctx *ctx, enum loop_type type, - hlsl_warning(ctx, loc, VKD3D_SHADER_ERROR_HLSL_NOT_IMPLEMENTED, "Loop unrolling is not implemented."); - } - } -- else if (!strcmp(attr->name, "loop") -- || !strcmp(attr->name, "fastopt") -+ else if (!strcmp(attr->name, "loop")) -+ { -+ /* TODO: this attribute will be used to disable unrolling, once it's implememented. */ -+ } -+ else if (!strcmp(attr->name, "fastopt") - || !strcmp(attr->name, "allow_uav_condition")) - { - hlsl_fixme(ctx, loc, "Unhandled attribute '%s'.", attr->name); -@@ -501,6 +578,8 @@ static struct hlsl_block *create_loop(struct hlsl_ctx *ctx, enum loop_type type, - } - } - -+ resolve_loop_continue(ctx, body, type, cond, iter); -+ - if (!init && !(init = make_empty_block(ctx))) - goto oom; - -@@ -1079,22 +1158,6 @@ static struct hlsl_reg_reservation parse_packoffset(struct hlsl_ctx *ctx, const - return reservation; - } - --static struct hlsl_ir_function_decl *get_func_decl(struct rb_tree *funcs, -- const char *name, const struct hlsl_func_parameters *parameters) --{ -- struct hlsl_ir_function *func; -- struct rb_entry *entry; -- -- if ((entry = rb_get(funcs, name))) -- { -- func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); -- -- if ((entry = rb_get(&func->overloads, parameters))) -- return RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry); -- } -- return NULL; --} -- - static struct hlsl_block *make_block(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr) - { - struct hlsl_block *block; -@@ -1134,6 +1197,7 @@ static unsigned int evaluate_static_expression_as_uint(struct hlsl_ctx *ctx, str - case HLSL_IR_RESOURCE_LOAD: - case HLSL_IR_RESOURCE_STORE: - case HLSL_IR_STORE: -+ case HLSL_IR_SWITCH: - hlsl_error(ctx, &node->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, - "Expected literal expression."); - } -@@ -1228,7 +1292,7 @@ static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hl - static bool expr_common_shape(struct hlsl_ctx *ctx, struct hlsl_type *t1, struct hlsl_type *t2, - const struct vkd3d_shader_location *loc, enum hlsl_type_class *type, unsigned int *dimx, unsigned int *dimy) - { -- if (t1->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type(t1)) - { - struct vkd3d_string_buffer *string; - -@@ -1239,7 +1303,7 @@ static bool expr_common_shape(struct hlsl_ctx *ctx, struct hlsl_type *t1, struct - return false; - } - -- if (t2->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type(t2)) - { - struct vkd3d_string_buffer *string; - -@@ -1711,7 +1775,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct hlsl_blo - return NULL; - } - -- if (lhs_type->class <= HLSL_CLASS_LAST_NUMERIC) -+ if (hlsl_is_numeric_type(lhs_type)) - writemask = (1 << lhs_type->dimx) - 1; - - if (!(rhs = add_implicit_conversion(ctx, block, rhs, lhs_type, &rhs->loc))) -@@ -1941,7 +2005,7 @@ static bool type_has_object_components(struct hlsl_type *type, bool must_be_in_s - - static bool type_has_numeric_components(struct hlsl_type *type) - { -- if (type->class <= HLSL_CLASS_LAST_NUMERIC) -+ if (hlsl_is_numeric_type(type)) - return true; - if (type->class == HLSL_CLASS_ARRAY) - return type_has_numeric_components(type->e.array.type); -@@ -2106,7 +2170,7 @@ static void declare_var(struct hlsl_ctx *ctx, struct parse_variable_def *v) - "Target profile doesn't support objects as struct members in uniform variables."); - } - -- if ((func = hlsl_get_func_decl(ctx, var->name))) -+ if ((func = hlsl_get_first_func_decl(ctx, var->name))) - { - hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED, - "'%s' is already defined as a function.", var->name); -@@ -2261,56 +2325,27 @@ static struct hlsl_block *initialize_vars(struct hlsl_ctx *ctx, struct list *var - return initializers; - } - --struct find_function_call_args --{ -- struct hlsl_ctx *ctx; -- const struct parse_initializer *params; -- struct hlsl_ir_function_decl *decl; -- unsigned int compatible_overloads_count; --}; -- --static void find_function_call_exact(struct rb_entry *entry, void *context) --{ -- struct hlsl_ir_function_decl *decl = RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry); -- struct find_function_call_args *args = context; -- unsigned int i; -- -- if (decl->parameters.count != args->params->args_count) -- return; -- -- for (i = 0; i < decl->parameters.count; ++i) -- { -- if (!hlsl_types_are_equal(decl->parameters.vars[i]->data_type, args->params->args[i]->data_type)) -- return; -- } -- args->decl = decl; --} -- --static void find_function_call_compatible(struct rb_entry *entry, void *context) -+static bool func_is_compatible_match(struct hlsl_ctx *ctx, -+ const struct hlsl_ir_function_decl *decl, const struct parse_initializer *args) - { -- struct hlsl_ir_function_decl *decl = RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry); -- struct find_function_call_args *args = context; - unsigned int i; - -- if (decl->parameters.count != args->params->args_count) -- return; -+ if (decl->parameters.count != args->args_count) -+ return false; - - for (i = 0; i < decl->parameters.count; ++i) - { -- if (!implicit_compatible_data_types(args->ctx, args->params->args[i]->data_type, -- decl->parameters.vars[i]->data_type)) -- return; -+ if (!implicit_compatible_data_types(ctx, args->args[i]->data_type, decl->parameters.vars[i]->data_type)) -+ return false; - } -- -- args->compatible_overloads_count++; -- args->decl = decl; -+ return true; - } - - static struct hlsl_ir_function_decl *find_function_call(struct hlsl_ctx *ctx, -- const char *name, const struct parse_initializer *params, -+ const char *name, const struct parse_initializer *args, - const struct vkd3d_shader_location *loc) - { -- struct find_function_call_args args = {.ctx = ctx, .params = params}; -+ struct hlsl_ir_function_decl *decl, *compatible_match = NULL; - struct hlsl_ir_function *func; - struct rb_entry *entry; - -@@ -2318,16 +2353,20 @@ static struct hlsl_ir_function_decl *find_function_call(struct hlsl_ctx *ctx, - return NULL; - func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); - -- rb_for_each_entry(&func->overloads, find_function_call_exact, &args); -- if (!args.decl) -+ LIST_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) - { -- rb_for_each_entry(&func->overloads, find_function_call_compatible, &args); -- if (args.compatible_overloads_count > 1) -+ if (func_is_compatible_match(ctx, decl, args)) - { -- hlsl_fixme(ctx, loc, "Prioritize between multiple compatible function overloads."); -+ if (compatible_match) -+ { -+ hlsl_fixme(ctx, loc, "Prioritize between multiple compatible function overloads."); -+ break; -+ } -+ compatible_match = decl; - } - } -- return args.decl; -+ -+ return compatible_match; - } - - static struct hlsl_ir_node *hlsl_new_void_expr(struct hlsl_ctx *ctx, const struct vkd3d_shader_location *loc) -@@ -2669,6 +2708,17 @@ static bool intrinsic_asuint(struct hlsl_ctx *ctx, - return add_expr(ctx, params->instrs, HLSL_OP1_REINTERPRET, operands, data_type, loc); - } - -+static bool intrinsic_ceil(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_node *arg; -+ -+ if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc))) -+ return false; -+ -+ return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_CEIL, arg, loc); -+} -+ - static bool intrinsic_clamp(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { -@@ -2828,6 +2878,22 @@ static bool intrinsic_ddy_coarse(struct hlsl_ctx *ctx, - return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_DSY_COARSE, arg, loc); - } - -+static bool intrinsic_degrees(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_node *arg, *deg; -+ -+ if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc))) -+ return false; -+ -+ /* 1 rad = 180/pi degree = 57.2957795 degree */ -+ if (!(deg = hlsl_new_float_constant(ctx, 57.2957795f, loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, deg); -+ -+ return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg, deg, loc); -+} -+ - static bool intrinsic_ddy_fine(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { -@@ -2961,6 +3027,33 @@ static bool intrinsic_frac(struct hlsl_ctx *ctx, - return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_FRACT, arg, loc); - } - -+static bool intrinsic_fwidth(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_function_decl *func; -+ struct hlsl_type *type; -+ char *body; -+ -+ static const char template[] = -+ "%s fwidth(%s x)\n" -+ "{\n" -+ " return abs(ddx(x)) + abs(ddy(x));\n" -+ "}"; -+ -+ if (!elementwise_intrinsic_float_convert_args(ctx, params, loc)) -+ return false; -+ type = params->args[0]->data_type; -+ -+ if (!(body = hlsl_sprintf_alloc(ctx, template, type->name, type->name))) -+ return false; -+ func = hlsl_compile_internal_function(ctx, "fwidth", body); -+ vkd3d_free(body); -+ if (!func) -+ return false; -+ -+ return add_user_call(ctx, func, params, loc); -+} -+ - static bool intrinsic_ldexp(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { -@@ -3078,6 +3171,7 @@ static bool intrinsic_log(struct hlsl_ctx *ctx, - /* ln(2) */ - if (!(coeff = hlsl_new_float_constant(ctx, 0.69314718055f, loc))) - return false; -+ hlsl_block_add_instr(params->instrs, coeff); - - return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, coeff, loc); - } -@@ -3096,6 +3190,7 @@ static bool intrinsic_log10(struct hlsl_ctx *ctx, - /* 1 / log2(10) */ - if (!(coeff = hlsl_new_float_constant(ctx, 0.301029996f, loc))) - return false; -+ hlsl_block_add_instr(params->instrs, coeff); - - return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, log, coeff, loc); - } -@@ -3264,6 +3359,22 @@ static bool intrinsic_pow(struct hlsl_ctx *ctx, - return !!add_pow_expr(ctx, params->instrs, params->args[0], params->args[1], loc); - } - -+static bool intrinsic_radians(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_node *arg, *rad; -+ -+ if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc))) -+ return false; -+ -+ /* 1 degree = pi/180 rad = 0.0174532925f rad */ -+ if (!(rad = hlsl_new_float_constant(ctx, 0.0174532925f, loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, rad); -+ -+ return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_MUL, arg, rad, loc); -+} -+ - static bool intrinsic_reflect(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { -@@ -3423,10 +3534,24 @@ static bool intrinsic_step(struct hlsl_ctx *ctx, - return !!add_implicit_conversion(ctx, params->instrs, ge, type, loc); - } - -+static bool intrinsic_tan(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ struct hlsl_ir_node *arg = params->args[0], *sin, *cos; -+ -+ if (!(sin = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_SIN, arg, loc))) -+ return false; -+ -+ if (!(cos = add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_COS, arg, loc))) -+ return false; -+ -+ return !!add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, sin, cos, loc); -+} -+ - static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer *params, - const struct vkd3d_shader_location *loc, const char *name, enum hlsl_sampler_dim dim) - { -- struct hlsl_resource_load_params load_params = {.type = HLSL_RESOURCE_SAMPLE}; -+ struct hlsl_resource_load_params load_params = { 0 }; - const struct hlsl_type *sampler_type; - struct hlsl_ir_node *coords, *load; - -@@ -3455,10 +3580,74 @@ static bool intrinsic_tex(struct hlsl_ctx *ctx, const struct parse_initializer * - hlsl_release_string_buffer(ctx, string); - } - -- if (!(coords = add_implicit_conversion(ctx, params->instrs, params->args[1], -- hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, hlsl_sampler_dim_count(dim)), loc))) -+ if (!strcmp(name, "tex2Dlod")) - { -- return false; -+ struct hlsl_ir_node *lod, *c; -+ -+ load_params.type = HLSL_RESOURCE_SAMPLE_LOD; -+ -+ if (!(c = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, Y, Z, W), hlsl_sampler_dim_count(dim), params->args[1], loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, c); -+ -+ if (!(coords = add_implicit_conversion(ctx, params->instrs, c, hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, -+ hlsl_sampler_dim_count(dim)), loc))) -+ { -+ return false; -+ } -+ -+ if (!(lod = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(W, W, W, W), 1, params->args[1], loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, lod); -+ -+ if (!(load_params.lod = add_implicit_conversion(ctx, params->instrs, lod, -+ hlsl_get_scalar_type(ctx, HLSL_TYPE_FLOAT), loc))) -+ { -+ return false; -+ } -+ } -+ else if (!strcmp(name, "tex2Dproj") -+ || !strcmp(name, "tex3Dproj") -+ || !strcmp(name, "texCUBEproj")) -+ { -+ if (!(coords = add_implicit_conversion(ctx, params->instrs, params->args[1], -+ hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, 4), loc))) -+ { -+ return false; -+ } -+ -+ if (shader_profile_version_ge(ctx, 4, 0)) -+ { -+ unsigned int count = hlsl_sampler_dim_count(dim); -+ struct hlsl_ir_node *divisor; -+ -+ if (!(divisor = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(W, W, W, W), count, coords, loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, divisor); -+ -+ if (!(coords = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, Y, Z, W), count, coords, loc))) -+ return false; -+ hlsl_block_add_instr(params->instrs, coords); -+ -+ if (!(coords = add_binary_arithmetic_expr(ctx, params->instrs, HLSL_OP2_DIV, coords, divisor, loc))) -+ return false; -+ -+ load_params.type = HLSL_RESOURCE_SAMPLE; -+ } -+ else -+ { -+ load_params.type = HLSL_RESOURCE_SAMPLE_PROJ; -+ } -+ } -+ else -+ { -+ load_params.type = HLSL_RESOURCE_SAMPLE; -+ -+ if (!(coords = add_implicit_conversion(ctx, params->instrs, params->args[1], -+ hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, hlsl_sampler_dim_count(dim)), loc))) -+ { -+ return false; -+ } - } - - /* tex1D() functions never produce 1D resource declarations. For newer profiles half offset -@@ -3517,18 +3706,42 @@ static bool intrinsic_tex2D(struct hlsl_ctx *ctx, - return intrinsic_tex(ctx, params, loc, "tex2D", HLSL_SAMPLER_DIM_2D); - } - -+static bool intrinsic_tex2Dlod(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ return intrinsic_tex(ctx, params, loc, "tex2Dlod", HLSL_SAMPLER_DIM_2D); -+} -+ -+static bool intrinsic_tex2Dproj(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ return intrinsic_tex(ctx, params, loc, "tex2Dproj", HLSL_SAMPLER_DIM_2D); -+} -+ - static bool intrinsic_tex3D(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { - return intrinsic_tex(ctx, params, loc, "tex3D", HLSL_SAMPLER_DIM_3D); - } - -+static bool intrinsic_tex3Dproj(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ return intrinsic_tex(ctx, params, loc, "tex3Dproj", HLSL_SAMPLER_DIM_3D); -+} -+ - static bool intrinsic_texCUBE(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { - return intrinsic_tex(ctx, params, loc, "texCUBE", HLSL_SAMPLER_DIM_CUBE); - } - -+static bool intrinsic_texCUBEproj(struct hlsl_ctx *ctx, -+ const struct parse_initializer *params, const struct vkd3d_shader_location *loc) -+{ -+ return intrinsic_tex(ctx, params, loc, "texCUBEproj", HLSL_SAMPLER_DIM_CUBE); -+} -+ - static bool intrinsic_transpose(struct hlsl_ctx *ctx, - const struct parse_initializer *params, const struct vkd3d_shader_location *loc) - { -@@ -3659,6 +3872,7 @@ intrinsic_functions[] = - {"any", 1, true, intrinsic_any}, - {"asfloat", 1, true, intrinsic_asfloat}, - {"asuint", -1, true, intrinsic_asuint}, -+ {"ceil", 1, true, intrinsic_ceil}, - {"clamp", 3, true, intrinsic_clamp}, - {"clip", 1, true, intrinsic_clip}, - {"cos", 1, true, intrinsic_cos}, -@@ -3669,6 +3883,7 @@ intrinsic_functions[] = - {"ddy", 1, true, intrinsic_ddy}, - {"ddy_coarse", 1, true, intrinsic_ddy_coarse}, - {"ddy_fine", 1, true, intrinsic_ddy_fine}, -+ {"degrees", 1, true, intrinsic_degrees}, - {"distance", 2, true, intrinsic_distance}, - {"dot", 2, true, intrinsic_dot}, - {"exp", 1, true, intrinsic_exp}, -@@ -3676,6 +3891,7 @@ intrinsic_functions[] = - {"floor", 1, true, intrinsic_floor}, - {"fmod", 2, true, intrinsic_fmod}, - {"frac", 1, true, intrinsic_frac}, -+ {"fwidth", 1, true, intrinsic_fwidth}, - {"ldexp", 2, true, intrinsic_ldexp}, - {"length", 1, true, intrinsic_length}, - {"lerp", 3, true, intrinsic_lerp}, -@@ -3688,6 +3904,7 @@ intrinsic_functions[] = - {"mul", 2, true, intrinsic_mul}, - {"normalize", 1, true, intrinsic_normalize}, - {"pow", 2, true, intrinsic_pow}, -+ {"radians", 1, true, intrinsic_radians}, - {"reflect", 2, true, intrinsic_reflect}, - {"round", 1, true, intrinsic_round}, - {"rsqrt", 1, true, intrinsic_rsqrt}, -@@ -3697,10 +3914,15 @@ intrinsic_functions[] = - {"smoothstep", 3, true, intrinsic_smoothstep}, - {"sqrt", 1, true, intrinsic_sqrt}, - {"step", 2, true, intrinsic_step}, -+ {"tan", 1, true, intrinsic_tan}, - {"tex1D", -1, false, intrinsic_tex1D}, - {"tex2D", -1, false, intrinsic_tex2D}, -+ {"tex2Dlod", 2, false, intrinsic_tex2Dlod}, -+ {"tex2Dproj", 2, false, intrinsic_tex2Dproj}, - {"tex3D", -1, false, intrinsic_tex3D}, -+ {"tex3Dproj", 2, false, intrinsic_tex3Dproj}, - {"texCUBE", -1, false, intrinsic_texCUBE}, -+ {"texCUBEproj", 2, false, intrinsic_texCUBEproj}, - {"transpose", 1, true, intrinsic_transpose}, - {"trunc", 1, true, intrinsic_trunc}, - }; -@@ -3740,7 +3962,7 @@ static struct hlsl_block *add_call(struct hlsl_ctx *ctx, const char *name, - - for (i = 0; i < args->args_count; ++i) - { -- if (args->args[i]->data_type->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type(args->args[i]->data_type)) - { - struct vkd3d_string_buffer *string; - -@@ -4544,6 +4766,66 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - } - } - -+static bool check_continue(struct hlsl_ctx *ctx, const struct hlsl_scope *scope, const struct vkd3d_shader_location *loc) -+{ -+ if (scope->_switch) -+ { -+ hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "The 'continue' statement is not allowed in 'switch' statements."); -+ return false; -+ } -+ -+ if (scope->loop) -+ return true; -+ -+ if (scope->upper) -+ return check_continue(ctx, scope->upper, loc); -+ -+ hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, "The 'continue' statement is only allowed in loops."); -+ return false; -+} -+ -+static bool is_break_allowed(const struct hlsl_scope *scope) -+{ -+ if (scope->loop || scope->_switch) -+ return true; -+ -+ return scope->upper ? is_break_allowed(scope->upper) : false; -+} -+ -+static void check_duplicated_switch_cases(struct hlsl_ctx *ctx, const struct hlsl_ir_switch_case *check, struct list *cases) -+{ -+ struct hlsl_ir_switch_case *c; -+ bool found_duplicate = false; -+ -+ LIST_FOR_EACH_ENTRY(c, cases, struct hlsl_ir_switch_case, entry) -+ { -+ if (check->is_default) -+ { -+ if ((found_duplicate = c->is_default)) -+ { -+ hlsl_error(ctx, &check->loc, VKD3D_SHADER_ERROR_HLSL_DUPLICATE_SWITCH_CASE, -+ "Found multiple 'default' statements."); -+ hlsl_note(ctx, &c->loc, VKD3D_SHADER_LOG_ERROR, "The 'default' statement was previously found here."); -+ } -+ } -+ else -+ { -+ if (c->is_default) continue; -+ if ((found_duplicate = (c->value == check->value))) -+ { -+ hlsl_error(ctx, &check->loc, VKD3D_SHADER_ERROR_HLSL_DUPLICATE_SWITCH_CASE, -+ "Found duplicate 'case' statement."); -+ hlsl_note(ctx, &c->loc, VKD3D_SHADER_LOG_ERROR, "The same 'case %d' statement was previously found here.", -+ c->value); -+ } -+ } -+ -+ if (found_duplicate) -+ break; -+ } -+} -+ - } - - %locations -@@ -4582,16 +4864,20 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - enum hlsl_sampler_dim sampler_dim; - struct hlsl_attribute *attr; - struct parse_attribute_list attr_list; -+ struct hlsl_ir_switch_case *switch_case; - } - - %token KW_BLENDSTATE - %token KW_BREAK - %token KW_BUFFER -+%token KW_CASE - %token KW_CBUFFER -+%token KW_CENTROID - %token KW_COLUMN_MAJOR - %token KW_COMPILE - %token KW_CONST - %token KW_CONTINUE -+%token KW_DEFAULT - %token KW_DEPTHSTENCILSTATE - %token KW_DEPTHSTENCILVIEW - %token KW_DISCARD -@@ -4610,6 +4896,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %token KW_MATRIX - %token KW_NAMESPACE - %token KW_NOINTERPOLATION -+%token KW_NOPERSPECTIVE - %token KW_OUT - %token KW_PACKOFFSET - %token KW_PASS -@@ -4623,7 +4910,9 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %token KW_RWBUFFER - %token KW_RWSTRUCTUREDBUFFER - %token KW_RWTEXTURE1D -+%token KW_RWTEXTURE1DARRAY - %token KW_RWTEXTURE2D -+%token KW_RWTEXTURE2DARRAY - %token KW_RWTEXTURE3D - %token KW_SAMPLER - %token KW_SAMPLER1D -@@ -4642,6 +4931,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %token KW_TBUFFER - %token KW_TECHNIQUE - %token KW_TECHNIQUE10 -+%token KW_TECHNIQUE11 - %token KW_TEXTURE - %token KW_TEXTURE1D - %token KW_TEXTURE1DARRAY -@@ -4670,7 +4960,6 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %token OP_LEFTSHIFTASSIGN - %token OP_RIGHTSHIFT - %token OP_RIGHTSHIFTASSIGN --%token OP_ELLIPSIS - %token OP_LE - %token OP_GE - %token OP_NE -@@ -4682,19 +4971,17 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %token OP_ANDASSIGN - %token OP_ORASSIGN - %token OP_XORASSIGN --%token OP_UNKNOWN1 --%token OP_UNKNOWN2 --%token OP_UNKNOWN3 --%token OP_UNKNOWN4 - - %token C_FLOAT - - %token C_INTEGER -+%token C_UNSIGNED - %token PRE_LINE - - %type type_specs - %type variables_def - %type variables_def_typed -+%type switch_cases - - %token VAR_IDENTIFIER - %token NEW_IDENTIFIER -@@ -4737,6 +5024,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - %type statement - %type statement_list - %type struct_declaration_without_vars -+%type switch_statement - %type unary_expr - - %type boolean -@@ -4762,6 +5050,7 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - - %type any_identifier - %type var_identifier -+%type technique_name - - %type parameter - -@@ -4775,6 +5064,8 @@ static void validate_texture_format_type(struct hlsl_ctx *ctx, struct hlsl_type - - %type semantic - -+%type switch_case -+ - %type field_type - %type named_struct_spec - %type unnamed_struct_spec -@@ -4801,8 +5092,50 @@ hlsl_prog: - destroy_block($2); - } - | hlsl_prog preproc_directive -+ | hlsl_prog technique - | hlsl_prog ';' - -+technique_name: -+ %empty -+ { -+ $$ = NULL; -+ } -+ | any_identifier -+ -+pass_list: -+ %empty -+ -+technique9: -+ KW_TECHNIQUE technique_name '{' pass_list '}' -+ { -+ hlsl_fixme(ctx, &@$, "Unsupported \'technique\' declaration."); -+ } -+ -+technique10: -+ KW_TECHNIQUE10 technique_name '{' pass_list '}' -+ { -+ if (ctx->profile->type == VKD3D_SHADER_TYPE_EFFECT && ctx->profile->major_version == 2) -+ hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "The 'technique10' keyword is invalid for this profile."); -+ -+ hlsl_fixme(ctx, &@$, "Unsupported \'technique10\' declaration."); -+ } -+ -+technique11: -+ KW_TECHNIQUE11 technique_name '{' pass_list '}' -+ { -+ if (ctx->profile->type == VKD3D_SHADER_TYPE_EFFECT && ctx->profile->major_version == 2) -+ hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "The 'technique11' keyword is invalid for this profile."); -+ -+ hlsl_fixme(ctx, &@$, "Unsupported \'technique11\' declaration."); -+ } -+ -+technique: -+ technique9 -+ | technique10 -+ | technique11 -+ - buffer_declaration: - buffer_type any_identifier colon_attribute - { -@@ -4952,7 +5285,7 @@ field: - - if (!(type = apply_type_modifiers(ctx, $2, &modifiers, true, &@1))) - YYABORT; -- if (modifiers & ~HLSL_STORAGE_NOINTERPOLATION) -+ if (modifiers & ~HLSL_INTERPOLATION_MODIFIERS_MASK) - { - struct vkd3d_string_buffer *string; - -@@ -5132,7 +5465,7 @@ func_prototype_no_attrs: - hlsl_error(ctx, &@5, VKD3D_SHADER_ERROR_HLSL_INVALID_RESERVATION, - "packoffset() is not allowed on functions."); - -- if (($$.decl = get_func_decl(&ctx->functions, $3, &$5))) -+ if (($$.decl = hlsl_get_func_decl(ctx, $3, &$5))) - { - const struct hlsl_func_parameters *params = &$$.decl->parameters; - size_t i; -@@ -5249,6 +5582,20 @@ scope_start: - hlsl_push_scope(ctx); - } - -+loop_scope_start: -+ %empty -+ { -+ hlsl_push_scope(ctx); -+ ctx->cur_scope->loop = true; -+ } -+ -+switch_scope_start: -+ %empty -+ { -+ hlsl_push_scope(ctx); -+ ctx->cur_scope->_switch = true; -+ } -+ - var_identifier: - VAR_IDENTIFIER - | NEW_IDENTIFIER -@@ -5441,10 +5788,18 @@ uav_type: - { - $$ = HLSL_SAMPLER_DIM_1D; - } -+ | KW_RWTEXTURE1DARRAY -+ { -+ $$ = HLSL_SAMPLER_DIM_1DARRAY; -+ } - | KW_RWTEXTURE2D - { - $$ = HLSL_SAMPLER_DIM_2D; - } -+ | KW_RWTEXTURE2DARRAY -+ { -+ $$ = HLSL_SAMPLER_DIM_2DARRAY; -+ } - | KW_RWTEXTURE3D - { - $$ = HLSL_SAMPLER_DIM_3D; -@@ -5591,7 +5946,9 @@ type_no_void: - { - case HLSL_SAMPLER_DIM_BUFFER: - case HLSL_SAMPLER_DIM_1D: -+ case HLSL_SAMPLER_DIM_1DARRAY: - case HLSL_SAMPLER_DIM_2D: -+ case HLSL_SAMPLER_DIM_2DARRAY: - case HLSL_SAMPLER_DIM_3D: - if ($3->class == HLSL_CLASS_ARRAY) - { -@@ -5901,6 +6258,14 @@ var_modifiers: - { - $$ = add_modifiers(ctx, $2, HLSL_STORAGE_NOINTERPOLATION, &@1); - } -+ | KW_CENTROID var_modifiers -+ { -+ $$ = add_modifiers(ctx, $2, HLSL_STORAGE_CENTROID, &@1); -+ } -+ | KW_NOPERSPECTIVE var_modifiers -+ { -+ $$ = add_modifiers(ctx, $2, HLSL_STORAGE_NOPERSPECTIVE, &@1); -+ } - | KW_PRECISE var_modifiers - { - $$ = add_modifiers(ctx, $2, HLSL_MODIFIER_PRECISE, &@1); -@@ -6059,9 +6424,39 @@ statement: - | jump_statement - | selection_statement - | loop_statement -+ | switch_statement - - jump_statement: -- KW_RETURN expr ';' -+ KW_BREAK ';' -+ { -+ struct hlsl_ir_node *jump; -+ -+ if (!is_break_allowed(ctx->cur_scope)) -+ { -+ hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "The 'break' statement must be used inside of a loop or a switch."); -+ } -+ -+ if (!($$ = make_empty_block(ctx))) -+ YYABORT; -+ if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, NULL, &@1))) -+ YYABORT; -+ hlsl_block_add_instr($$, jump); -+ } -+ | KW_CONTINUE ';' -+ { -+ struct hlsl_ir_node *jump; -+ -+ check_continue(ctx, ctx->cur_scope, &@1); -+ -+ if (!($$ = make_empty_block(ctx))) -+ YYABORT; -+ -+ if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_UNRESOLVED_CONTINUE, NULL, &@1))) -+ YYABORT; -+ hlsl_block_add_instr($$, jump); -+ } -+ | KW_RETURN expr ';' - { - $$ = $2; - if (!add_return(ctx, $$, node_from_block($$), &@1)) -@@ -6150,25 +6545,127 @@ if_body: - } - - loop_statement: -- attribute_list_optional KW_WHILE '(' expr ')' statement -+ attribute_list_optional loop_scope_start KW_WHILE '(' expr ')' statement - { -- $$ = create_loop(ctx, LOOP_WHILE, &$1, NULL, $4, NULL, $6, &@2); -+ $$ = create_loop(ctx, LOOP_WHILE, &$1, NULL, $5, NULL, $7, &@3); -+ hlsl_pop_scope(ctx); - } -- | attribute_list_optional KW_DO statement KW_WHILE '(' expr ')' ';' -+ | attribute_list_optional loop_scope_start KW_DO statement KW_WHILE '(' expr ')' ';' - { -- $$ = create_loop(ctx, LOOP_DO_WHILE, &$1, NULL, $6, NULL, $3, &@2); -+ $$ = create_loop(ctx, LOOP_DO_WHILE, &$1, NULL, $7, NULL, $4, &@3); -+ hlsl_pop_scope(ctx); - } -- | attribute_list_optional KW_FOR '(' scope_start expr_statement expr_statement expr_optional ')' statement -+ | attribute_list_optional loop_scope_start KW_FOR '(' expr_statement expr_statement expr_optional ')' statement - { -- $$ = create_loop(ctx, LOOP_FOR, &$1, $5, $6, $7, $9, &@2); -+ $$ = create_loop(ctx, LOOP_FOR, &$1, $5, $6, $7, $9, &@3); - hlsl_pop_scope(ctx); - } -- | attribute_list_optional KW_FOR '(' scope_start declaration expr_statement expr_optional ')' statement -+ | attribute_list_optional loop_scope_start KW_FOR '(' declaration expr_statement expr_optional ')' statement - { -- $$ = create_loop(ctx, LOOP_FOR, &$1, $5, $6, $7, $9, &@2); -+ $$ = create_loop(ctx, LOOP_FOR, &$1, $5, $6, $7, $9, &@3); -+ hlsl_pop_scope(ctx); -+ } -+ -+switch_statement: -+ attribute_list_optional switch_scope_start KW_SWITCH '(' expr ')' '{' switch_cases '}' -+ { -+ struct hlsl_ir_node *selector = node_from_block($5); -+ struct hlsl_ir_node *s; -+ -+ if (!(selector = add_implicit_conversion(ctx, $5, selector, hlsl_get_scalar_type(ctx, HLSL_TYPE_UINT), &@5))) -+ { -+ destroy_switch_cases($8); -+ destroy_block($5); -+ YYABORT; -+ } -+ -+ s = hlsl_new_switch(ctx, selector, $8, &@3); -+ -+ destroy_switch_cases($8); -+ -+ if (!s) -+ { -+ destroy_block($5); -+ YYABORT; -+ } -+ -+ $$ = $5; -+ hlsl_block_add_instr($$, s); -+ - hlsl_pop_scope(ctx); - } - -+switch_case: -+ KW_CASE expr ':' statement_list -+ { -+ struct hlsl_ir_switch_case *c; -+ unsigned int value; -+ -+ value = evaluate_static_expression_as_uint(ctx, $2, &@2); -+ -+ c = hlsl_new_switch_case(ctx, value, false, $4, &@2); -+ -+ destroy_block($2); -+ destroy_block($4); -+ -+ if (!c) -+ YYABORT; -+ $$ = c; -+ } -+ | KW_CASE expr ':' -+ { -+ struct hlsl_ir_switch_case *c; -+ unsigned int value; -+ -+ value = evaluate_static_expression_as_uint(ctx, $2, &@2); -+ -+ c = hlsl_new_switch_case(ctx, value, false, NULL, &@2); -+ -+ destroy_block($2); -+ -+ if (!c) -+ YYABORT; -+ $$ = c; -+ } -+ | KW_DEFAULT ':' statement_list -+ { -+ struct hlsl_ir_switch_case *c; -+ -+ c = hlsl_new_switch_case(ctx, 0, true, $3, &@1); -+ -+ destroy_block($3); -+ -+ if (!c) -+ YYABORT; -+ $$ = c; -+ } -+ | KW_DEFAULT ':' -+ { -+ struct hlsl_ir_switch_case *c; -+ -+ if (!(c = hlsl_new_switch_case(ctx, 0, true, NULL, &@1))) -+ YYABORT; -+ $$ = c; -+ } -+ -+switch_cases: -+ switch_case -+ { -+ struct hlsl_ir_switch_case *c = LIST_ENTRY($1, struct hlsl_ir_switch_case, entry); -+ if (!($$ = make_empty_list(ctx))) -+ { -+ hlsl_free_ir_switch_case(c); -+ YYABORT; -+ } -+ list_add_head($$, &$1->entry); -+ } -+ | switch_cases switch_case -+ { -+ $$ = $1; -+ check_duplicated_switch_cases(ctx, $2, $$); -+ list_add_tail($$, &$2->entry); -+ } -+ - expr_optional: - %empty - { -@@ -6213,6 +6710,15 @@ primary_expr: - if (!($$ = make_block(ctx, c))) - YYABORT; - } -+ | C_UNSIGNED -+ { -+ struct hlsl_ir_node *c; -+ -+ if (!(c = hlsl_new_uint_constant(ctx, $1, &@1))) -+ YYABORT; -+ if (!($$ = make_block(ctx, c))) -+ YYABORT; -+ } - | boolean - { - struct hlsl_ir_node *c; -@@ -6316,7 +6822,7 @@ postfix_expr: - YYABORT; - $$ = $1; - } -- else if (node->data_type->class <= HLSL_CLASS_LAST_NUMERIC) -+ else if (hlsl_is_numeric_type(node->data_type)) - { - struct hlsl_ir_node *swizzle; - -@@ -6359,7 +6865,7 @@ postfix_expr: - free_parse_initializer(&$4); - YYABORT; - } -- if ($2->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type($2)) - { - struct vkd3d_string_buffer *string; - -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -index be024842164..5a70878bca7 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -@@ -23,30 +23,21 @@ - - /* TODO: remove when no longer needed, only used for new_offset_instr_from_deref() */ - static struct hlsl_ir_node *new_offset_from_path_index(struct hlsl_ctx *ctx, struct hlsl_block *block, -- struct hlsl_type *type, struct hlsl_ir_node *offset, struct hlsl_ir_node *idx, -- enum hlsl_regset regset, const struct vkd3d_shader_location *loc) -+ struct hlsl_type *type, struct hlsl_ir_node *base_offset, struct hlsl_ir_node *idx, -+ enum hlsl_regset regset, unsigned int *offset_component, const struct vkd3d_shader_location *loc) - { - struct hlsl_ir_node *idx_offset = NULL; - struct hlsl_ir_node *c; - -- hlsl_block_init(block); -- - switch (type->class) - { - case HLSL_CLASS_VECTOR: -- idx_offset = idx; -+ *offset_component += hlsl_ir_constant(idx)->value.u[0].u; - break; - - case HLSL_CLASS_MATRIX: - { -- if (!(c = hlsl_new_uint_constant(ctx, 4, loc))) -- return NULL; -- hlsl_block_add_instr(block, c); -- -- if (!(idx_offset = hlsl_new_binary_expr(ctx, HLSL_OP2_MUL, c, idx))) -- return NULL; -- hlsl_block_add_instr(block, idx_offset); -- -+ idx_offset = idx; - break; - } - -@@ -54,6 +45,12 @@ static struct hlsl_ir_node *new_offset_from_path_index(struct hlsl_ctx *ctx, str - { - unsigned int size = hlsl_type_get_array_element_reg_size(type->e.array.type, regset); - -+ if (regset == HLSL_REGSET_NUMERIC) -+ { -+ assert(size % 4 == 0); -+ size /= 4; -+ } -+ - if (!(c = hlsl_new_uint_constant(ctx, size, loc))) - return NULL; - hlsl_block_add_instr(block, c); -@@ -69,8 +66,16 @@ static struct hlsl_ir_node *new_offset_from_path_index(struct hlsl_ctx *ctx, str - { - unsigned int field_idx = hlsl_ir_constant(idx)->value.u[0].u; - struct hlsl_struct_field *field = &type->e.record.fields[field_idx]; -+ unsigned int field_offset = field->reg_offset[regset]; -+ -+ if (regset == HLSL_REGSET_NUMERIC) -+ { -+ assert(*offset_component == 0); -+ *offset_component = field_offset % 4; -+ field_offset /= 4; -+ } - -- if (!(c = hlsl_new_uint_constant(ctx, field->reg_offset[regset], loc))) -+ if (!(c = hlsl_new_uint_constant(ctx, field_offset, loc))) - return NULL; - hlsl_block_add_instr(block, c); - -@@ -83,27 +88,33 @@ static struct hlsl_ir_node *new_offset_from_path_index(struct hlsl_ctx *ctx, str - vkd3d_unreachable(); - } - -- if (offset) -+ if (idx_offset) - { -- if (!(idx_offset = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, offset, idx_offset))) -+ if (!(base_offset = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, base_offset, idx_offset))) - return NULL; -- hlsl_block_add_instr(block, idx_offset); -+ hlsl_block_add_instr(block, base_offset); - } - -- return idx_offset; -+ return base_offset; - } - - /* TODO: remove when no longer needed, only used for replace_deref_path_with_offset() */ - static struct hlsl_ir_node *new_offset_instr_from_deref(struct hlsl_ctx *ctx, struct hlsl_block *block, -- const struct hlsl_deref *deref, const struct vkd3d_shader_location *loc) -+ const struct hlsl_deref *deref, unsigned int *offset_component, const struct vkd3d_shader_location *loc) - { -- enum hlsl_regset regset = hlsl_type_get_regset(deref->data_type); -- struct hlsl_ir_node *offset = NULL; -+ enum hlsl_regset regset = hlsl_deref_get_regset(ctx, deref); -+ struct hlsl_ir_node *offset; - struct hlsl_type *type; - unsigned int i; - -+ *offset_component = 0; -+ - hlsl_block_init(block); - -+ if (!(offset = hlsl_new_uint_constant(ctx, 0, loc))) -+ return NULL; -+ hlsl_block_add_instr(block, offset); -+ - assert(deref->var); - type = deref->var->data_type; - -@@ -111,9 +122,14 @@ static struct hlsl_ir_node *new_offset_instr_from_deref(struct hlsl_ctx *ctx, st - { - struct hlsl_block idx_block; - -+ hlsl_block_init(&idx_block); -+ - if (!(offset = new_offset_from_path_index(ctx, &idx_block, type, offset, deref->path[i].node, -- regset, loc))) -+ regset, offset_component, loc))) -+ { -+ hlsl_block_cleanup(&idx_block); - return NULL; -+ } - - hlsl_block_add_block(block, &idx_block); - -@@ -127,14 +143,13 @@ static struct hlsl_ir_node *new_offset_instr_from_deref(struct hlsl_ctx *ctx, st - static bool replace_deref_path_with_offset(struct hlsl_ctx *ctx, struct hlsl_deref *deref, - struct hlsl_ir_node *instr) - { -- struct hlsl_type *type; -+ unsigned int offset_component; - struct hlsl_ir_node *offset; - struct hlsl_block block; -+ struct hlsl_type *type; - - assert(deref->var); -- -- /* register offsets shouldn't be used before this point is reached. */ -- assert(!deref->offset.node); -+ assert(!hlsl_deref_is_lowered(deref)); - - type = hlsl_deref_get_type(ctx, deref); - -@@ -148,16 +163,35 @@ static bool replace_deref_path_with_offset(struct hlsl_ctx *ctx, struct hlsl_der - - deref->data_type = type; - -- if (!(offset = new_offset_instr_from_deref(ctx, &block, deref, &instr->loc))) -+ if (!(offset = new_offset_instr_from_deref(ctx, &block, deref, &offset_component, &instr->loc))) - return false; - list_move_before(&instr->entry, &block.instrs); - - hlsl_cleanup_deref(deref); -- hlsl_src_from_node(&deref->offset, offset); -+ hlsl_src_from_node(&deref->rel_offset, offset); -+ deref->const_offset = offset_component; - - return true; - } - -+static bool clean_constant_deref_offset_srcs(struct hlsl_ctx *ctx, struct hlsl_deref *deref, -+ struct hlsl_ir_node *instr) -+{ -+ if (deref->rel_offset.node && deref->rel_offset.node->type == HLSL_IR_CONSTANT) -+ { -+ enum hlsl_regset regset = hlsl_deref_get_regset(ctx, deref); -+ -+ if (regset == HLSL_REGSET_NUMERIC) -+ deref->const_offset += 4 * hlsl_ir_constant(deref->rel_offset.node)->value.u[0].u; -+ else -+ deref->const_offset += hlsl_ir_constant(deref->rel_offset.node)->value.u[0].u; -+ hlsl_src_remove(&deref->rel_offset); -+ return true; -+ } -+ return false; -+} -+ -+ - /* Split uniforms into two variables representing the constant and temp - * registers, and copy the former to the latter, so that writes to uniforms - * work. */ -@@ -195,7 +229,7 @@ static void prepend_uniform_copy(struct hlsl_ctx *ctx, struct hlsl_block *block, - - static void validate_field_semantic(struct hlsl_ctx *ctx, struct hlsl_struct_field *field) - { -- if (!field->semantic.name && hlsl_get_multiarray_element_type(field->type)->class <= HLSL_CLASS_LAST_NUMERIC -+ if (!field->semantic.name && hlsl_is_numeric_type(hlsl_get_multiarray_element_type(field->type)) - && !field->semantic.reported_missing) - { - hlsl_error(ctx, &field->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_SEMANTIC, -@@ -249,7 +283,7 @@ static struct hlsl_ir_var *add_semantic_var(struct hlsl_ctx *ctx, struct hlsl_ir - { - hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC, - "Output semantic \"%s%u\" is used multiple times.", semantic->name, index); -- hlsl_note(ctx, &ext_var->loc, HLSL_LEVEL_ERROR, -+ hlsl_note(ctx, &ext_var->loc, VKD3D_SHADER_LOG_ERROR, - "First use of \"%s%u\" is here.", semantic->name, index); - semantic->reported_duplicated_output_next_index = index + 1; - } -@@ -262,7 +296,7 @@ static struct hlsl_ir_var *add_semantic_var(struct hlsl_ctx *ctx, struct hlsl_ir - hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC, - "Input semantic \"%s%u\" is used multiple times with incompatible types.", - semantic->name, index); -- hlsl_note(ctx, &ext_var->loc, HLSL_LEVEL_ERROR, -+ hlsl_note(ctx, &ext_var->loc, VKD3D_SHADER_LOG_ERROR, - "First declaration of \"%s%u\" is here.", semantic->name, index); - semantic->reported_duplicated_input_incompatible_next_index = index + 1; - } -@@ -305,7 +339,7 @@ static void prepend_input_copy(struct hlsl_ctx *ctx, struct hlsl_block *block, s - struct hlsl_ir_node *c; - unsigned int i; - -- if (type->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type(type)) - { - struct vkd3d_string_buffer *string; - if (!(string = hlsl_type_to_string(ctx, type))) -@@ -377,6 +411,8 @@ static void prepend_input_copy_recurse(struct hlsl_ctx *ctx, struct hlsl_block * - - for (i = 0; i < hlsl_type_element_count(type); ++i) - { -+ unsigned int element_modifiers = modifiers; -+ - if (type->class == HLSL_CLASS_ARRAY) - { - elem_semantic_index = semantic_index -@@ -391,6 +427,17 @@ static void prepend_input_copy_recurse(struct hlsl_ctx *ctx, struct hlsl_block * - semantic = &field->semantic; - elem_semantic_index = semantic->index; - loc = &field->loc; -+ element_modifiers |= field->storage_modifiers; -+ -+ /* TODO: 'sample' modifier is not supported yet */ -+ -+ /* 'nointerpolation' always takes precedence, next the same is done for 'sample', -+ remaining modifiers are combined. */ -+ if (element_modifiers & HLSL_STORAGE_NOINTERPOLATION) -+ { -+ element_modifiers &= ~HLSL_INTERPOLATION_MODIFIERS_MASK; -+ element_modifiers |= HLSL_STORAGE_NOINTERPOLATION; -+ } - } - - if (!(c = hlsl_new_uint_constant(ctx, i, &var->loc))) -@@ -402,7 +449,7 @@ static void prepend_input_copy_recurse(struct hlsl_ctx *ctx, struct hlsl_block * - return; - list_add_after(&c->entry, &element_load->node.entry); - -- prepend_input_copy_recurse(ctx, block, element_load, modifiers, semantic, elem_semantic_index); -+ prepend_input_copy_recurse(ctx, block, element_load, element_modifiers, semantic, elem_semantic_index); - } - } - else -@@ -434,7 +481,7 @@ static void append_output_copy(struct hlsl_ctx *ctx, struct hlsl_block *block, s - struct hlsl_ir_node *c; - unsigned int i; - -- if (type->class > HLSL_CLASS_LAST_NUMERIC) -+ if (!hlsl_is_numeric_type(type)) - { - struct vkd3d_string_buffer *string; - if (!(string = hlsl_type_to_string(ctx, type))) -@@ -562,7 +609,19 @@ bool hlsl_transform_ir(struct hlsl_ctx *ctx, bool (*func)(struct hlsl_ctx *ctx, - progress |= hlsl_transform_ir(ctx, func, &iff->else_block, context); - } - else if (instr->type == HLSL_IR_LOOP) -+ { - progress |= hlsl_transform_ir(ctx, func, &hlsl_ir_loop(instr)->body, context); -+ } -+ else if (instr->type == HLSL_IR_SWITCH) -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ progress |= hlsl_transform_ir(ctx, func, &c->body, context); -+ } -+ } - - progress |= func(ctx, instr, context); - } -@@ -822,6 +881,30 @@ static bool lower_return(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *fun - } - } - } -+ else if (instr->type == HLSL_IR_SWITCH) -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ has_early_return |= lower_return(ctx, func, &c->body, true); -+ } -+ -+ if (has_early_return) -+ { -+ if (in_loop) -+ { -+ /* For a 'switch' nested in a loop append a break after the 'switch'. */ -+ insert_early_return_break(ctx, func, instr); -+ } -+ else -+ { -+ cf_instr = instr; -+ break; -+ } -+ } -+ } - } - - if (return_instr) -@@ -989,7 +1072,7 @@ static bool lower_matrix_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *ins - * For the latter case, this pass takes care of lowering hlsl_ir_indexes into individual - * hlsl_ir_loads, or individual hlsl_ir_resource_loads, in case the indexing is a - * resource access. */ --static bool lower_index_loads(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_index_loads(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *val, *store; - struct hlsl_deref var_deref; -@@ -1023,8 +1106,7 @@ static bool lower_index_loads(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - - if (!(load = hlsl_new_resource_load(ctx, ¶ms, &instr->loc))) - return false; -- list_add_before(&instr->entry, &load->entry); -- hlsl_replace_node(instr, load); -+ hlsl_block_add_instr(block, load); - return true; - } - -@@ -1034,7 +1116,7 @@ static bool lower_index_loads(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - - if (!(store = hlsl_new_simple_store(ctx, var, val))) - return false; -- list_add_before(&instr->entry, &store->entry); -+ hlsl_block_add_instr(block, store); - - if (hlsl_index_is_noncontiguous(index)) - { -@@ -1054,38 +1136,36 @@ static bool lower_index_loads(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - - if (!(c = hlsl_new_uint_constant(ctx, i, &instr->loc))) - return false; -- list_add_before(&instr->entry, &c->entry); -+ hlsl_block_add_instr(block, c); - - if (!(load = hlsl_new_load_index(ctx, &var_deref, c, &instr->loc))) - return false; -- list_add_before(&instr->entry, &load->node.entry); -+ hlsl_block_add_instr(block, &load->node); - - if (!(load = hlsl_new_load_index(ctx, &load->src, index->idx.node, &instr->loc))) - return false; -- list_add_before(&instr->entry, &load->node.entry); -+ hlsl_block_add_instr(block, &load->node); - - if (!(store = hlsl_new_store_index(ctx, &row_deref, c, &load->node, 0, &instr->loc))) - return false; -- list_add_before(&instr->entry, &store->entry); -+ hlsl_block_add_instr(block, store); - } - - if (!(load = hlsl_new_var_load(ctx, var, &instr->loc))) - return false; -- list_add_before(&instr->entry, &load->node.entry); -- hlsl_replace_node(instr, &load->node); -+ hlsl_block_add_instr(block, &load->node); - } - else - { - if (!(load = hlsl_new_load_index(ctx, &var_deref, index->idx.node, &instr->loc))) - return false; -- list_add_before(&instr->entry, &load->node.entry); -- hlsl_replace_node(instr, &load->node); -+ hlsl_block_add_instr(block, &load->node); - } - return true; - } - - /* Lower casts from vec1 to vecN to swizzles. */ --static bool lower_broadcasts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_broadcasts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - const struct hlsl_type *src_type, *dst_type; - struct hlsl_type *dst_scalar_type; -@@ -1101,25 +1181,22 @@ static bool lower_broadcasts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, v - - if (src_type->class <= HLSL_CLASS_VECTOR && dst_type->class <= HLSL_CLASS_VECTOR && src_type->dimx == 1) - { -- struct hlsl_ir_node *replacement, *new_cast, *swizzle; -+ struct hlsl_ir_node *new_cast, *swizzle; - - dst_scalar_type = hlsl_get_scalar_type(ctx, dst_type->base_type); - /* We need to preserve the cast since it might be doing more than just - * turning the scalar into a vector. */ - if (!(new_cast = hlsl_new_cast(ctx, cast->operands[0].node, dst_scalar_type, &cast->node.loc))) - return false; -- list_add_after(&cast->node.entry, &new_cast->entry); -- replacement = new_cast; -+ hlsl_block_add_instr(block, new_cast); - - if (dst_type->dimx != 1) - { -- if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, X, X, X), dst_type->dimx, replacement, &cast->node.loc))) -+ if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, X, X, X), dst_type->dimx, new_cast, &cast->node.loc))) - return false; -- list_add_after(&new_cast->entry, &swizzle->entry); -- replacement = swizzle; -+ hlsl_block_add_instr(block, swizzle); - } - -- hlsl_replace_node(&cast->node, replacement); - return true; - } - -@@ -1632,6 +1709,19 @@ static void copy_propagation_invalidate_from_block(struct hlsl_ctx *ctx, struct - break; - } - -+ case HLSL_IR_SWITCH: -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ copy_propagation_invalidate_from_block(ctx, state, &c->body); -+ } -+ -+ break; -+ } -+ - default: - break; - } -@@ -1680,6 +1770,28 @@ static bool copy_propagation_process_loop(struct hlsl_ctx *ctx, struct hlsl_ir_l - return progress; - } - -+static bool copy_propagation_process_switch(struct hlsl_ctx *ctx, struct hlsl_ir_switch *s, -+ struct copy_propagation_state *state) -+{ -+ struct copy_propagation_state inner_state; -+ struct hlsl_ir_switch_case *c; -+ bool progress = false; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ copy_propagation_state_init(ctx, &inner_state, state); -+ progress |= copy_propagation_transform_block(ctx, &c->body, &inner_state); -+ copy_propagation_state_destroy(&inner_state); -+ } -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ copy_propagation_invalidate_from_block(ctx, state, &c->body); -+ } -+ -+ return progress; -+} -+ - static bool copy_propagation_transform_block(struct hlsl_ctx *ctx, struct hlsl_block *block, - struct copy_propagation_state *state) - { -@@ -1718,6 +1830,10 @@ static bool copy_propagation_transform_block(struct hlsl_ctx *ctx, struct hlsl_b - progress |= copy_propagation_process_loop(ctx, hlsl_ir_loop(instr), state); - break; - -+ case HLSL_IR_SWITCH: -+ progress |= copy_propagation_process_switch(ctx, hlsl_ir_switch(instr), state); -+ break; -+ - default: - break; - } -@@ -1981,7 +2097,7 @@ static bool split_matrix_copies(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr - return true; - } - --static bool lower_narrowing_casts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_narrowing_casts(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - const struct hlsl_type *src_type, *dst_type; - struct hlsl_type *dst_vector_type; -@@ -2004,12 +2120,12 @@ static bool lower_narrowing_casts(struct hlsl_ctx *ctx, struct hlsl_ir_node *ins - * narrowing the vector. */ - if (!(new_cast = hlsl_new_cast(ctx, cast->operands[0].node, dst_vector_type, &cast->node.loc))) - return false; -- list_add_after(&cast->node.entry, &new_cast->entry); -+ hlsl_block_add_instr(block, new_cast); -+ - if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, Y, Z, W), dst_type->dimx, new_cast, &cast->node.loc))) - return false; -- list_add_after(&new_cast->entry, &swizzle->entry); -+ hlsl_block_add_instr(block, swizzle); - -- hlsl_replace_node(&cast->node, swizzle); - return true; - } - -@@ -2068,7 +2184,138 @@ static bool remove_trivial_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *i - return true; - } - --static bool lower_nonconstant_vector_derefs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool remove_trivial_conditional_branches(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+{ -+ struct hlsl_ir_constant *condition; -+ struct hlsl_ir_if *iff; -+ -+ if (instr->type != HLSL_IR_IF) -+ return false; -+ iff = hlsl_ir_if(instr); -+ if (iff->condition.node->type != HLSL_IR_CONSTANT) -+ return false; -+ condition = hlsl_ir_constant(iff->condition.node); -+ -+ list_move_before(&instr->entry, condition->value.u[0].u ? &iff->then_block.instrs : &iff->else_block.instrs); -+ list_remove(&instr->entry); -+ hlsl_free_instr(instr); -+ -+ return true; -+} -+ -+static bool normalize_switch_cases(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+{ -+ struct hlsl_ir_switch_case *c, *def = NULL; -+ bool missing_terminal_break = false; -+ struct hlsl_ir_node *node; -+ struct hlsl_ir_jump *jump; -+ struct hlsl_ir_switch *s; -+ -+ if (instr->type != HLSL_IR_SWITCH) -+ return false; -+ s = hlsl_ir_switch(instr); -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ bool terminal_break = false; -+ -+ if (list_empty(&c->body.instrs)) -+ { -+ terminal_break = !!list_next(&s->cases, &c->entry); -+ } -+ else -+ { -+ node = LIST_ENTRY(list_tail(&c->body.instrs), struct hlsl_ir_node, entry); -+ if (node->type == HLSL_IR_JUMP) -+ { -+ jump = hlsl_ir_jump(node); -+ terminal_break = jump->type == HLSL_IR_JUMP_BREAK; -+ } -+ } -+ -+ missing_terminal_break |= !terminal_break; -+ -+ if (!terminal_break) -+ { -+ if (c->is_default) -+ { -+ hlsl_error(ctx, &c->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "The 'default' case block is not terminated with 'break' or 'return'."); -+ } -+ else -+ { -+ hlsl_error(ctx, &c->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, -+ "Switch case block '%u' is not terminated with 'break' or 'return'.", c->value); -+ } -+ } -+ } -+ -+ if (missing_terminal_break) -+ return true; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ if (c->is_default) -+ { -+ def = c; -+ -+ /* Remove preceding empty cases. */ -+ while (list_prev(&s->cases, &def->entry)) -+ { -+ c = LIST_ENTRY(list_prev(&s->cases, &def->entry), struct hlsl_ir_switch_case, entry); -+ if (!list_empty(&c->body.instrs)) -+ break; -+ hlsl_free_ir_switch_case(c); -+ } -+ -+ if (list_empty(&def->body.instrs)) -+ { -+ /* Remove following empty cases. */ -+ while (list_next(&s->cases, &def->entry)) -+ { -+ c = LIST_ENTRY(list_next(&s->cases, &def->entry), struct hlsl_ir_switch_case, entry); -+ if (!list_empty(&c->body.instrs)) -+ break; -+ hlsl_free_ir_switch_case(c); -+ } -+ -+ /* Merge with the next case. */ -+ if (list_next(&s->cases, &def->entry)) -+ { -+ c = LIST_ENTRY(list_next(&s->cases, &def->entry), struct hlsl_ir_switch_case, entry); -+ c->is_default = true; -+ hlsl_free_ir_switch_case(def); -+ def = c; -+ } -+ } -+ -+ break; -+ } -+ } -+ -+ if (def) -+ { -+ list_remove(&def->entry); -+ } -+ else -+ { -+ struct hlsl_ir_node *jump; -+ -+ if (!(def = hlsl_new_switch_case(ctx, 0, true, NULL, &s->node.loc))) -+ return true; -+ if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, NULL, &s->node.loc))) -+ { -+ hlsl_free_ir_switch_case(def); -+ return true; -+ } -+ hlsl_block_add_instr(&def->body, jump); -+ } -+ list_add_tail(&s->cases, &def->entry); -+ -+ return true; -+} -+ -+static bool lower_nonconstant_vector_derefs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *idx; - struct hlsl_deref *deref; -@@ -2099,11 +2346,11 @@ static bool lower_nonconstant_vector_derefs(struct hlsl_ctx *ctx, struct hlsl_ir - - if (!(vector_load = hlsl_new_load_parent(ctx, deref, &instr->loc))) - return false; -- list_add_before(&instr->entry, &vector_load->node.entry); -+ hlsl_block_add_instr(block, &vector_load->node); - - if (!(swizzle = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, X, X, X), type->dimx, idx, &instr->loc))) - return false; -- list_add_before(&instr->entry, &swizzle->entry); -+ hlsl_block_add_instr(block, swizzle); - - value.u[0].u = 0; - value.u[1].u = 1; -@@ -2111,18 +2358,18 @@ static bool lower_nonconstant_vector_derefs(struct hlsl_ctx *ctx, struct hlsl_ir - value.u[3].u = 3; - if (!(c = hlsl_new_constant(ctx, hlsl_get_vector_type(ctx, HLSL_TYPE_UINT, type->dimx), &value, &instr->loc))) - return false; -- list_add_before(&instr->entry, &c->entry); -+ hlsl_block_add_instr(block, c); - - operands[0] = swizzle; - operands[1] = c; - if (!(eq = hlsl_new_expr(ctx, HLSL_OP2_EQUAL, operands, - hlsl_get_vector_type(ctx, HLSL_TYPE_BOOL, type->dimx), &instr->loc))) - return false; -- list_add_before(&instr->entry, &eq->entry); -+ hlsl_block_add_instr(block, eq); - - if (!(eq = hlsl_new_cast(ctx, eq, type, &instr->loc))) - return false; -- list_add_before(&instr->entry, &eq->entry); -+ hlsl_block_add_instr(block, eq); - - op = HLSL_OP2_DOT; - if (type->dimx == 1) -@@ -2134,8 +2381,7 @@ static bool lower_nonconstant_vector_derefs(struct hlsl_ctx *ctx, struct hlsl_ir - operands[1] = eq; - if (!(dot = hlsl_new_expr(ctx, op, operands, instr->data_type, &instr->loc))) - return false; -- list_add_before(&instr->entry, &dot->entry); -- hlsl_replace_node(instr, dot); -+ hlsl_block_add_instr(block, dot); - - return true; - } -@@ -2173,6 +2419,7 @@ static bool lower_combined_samples(struct hlsl_ctx *ctx, struct hlsl_ir_node *in - case HLSL_RESOURCE_SAMPLE: - case HLSL_RESOURCE_SAMPLE_LOD: - case HLSL_RESOURCE_SAMPLE_LOD_BIAS: -+ case HLSL_RESOURCE_SAMPLE_PROJ: - break; - } - if (load->sampler.var) -@@ -2184,7 +2431,7 @@ static bool lower_combined_samples(struct hlsl_ctx *ctx, struct hlsl_ir_node *in - return false; - } - -- assert(hlsl_type_get_regset(load->resource.var->data_type) == HLSL_REGSET_SAMPLERS); -+ assert(hlsl_deref_get_regset(ctx, &load->resource) == HLSL_REGSET_SAMPLERS); - - if (!(name = hlsl_get_string_buffer(ctx))) - return false; -@@ -2275,10 +2522,10 @@ static bool sort_synthetic_separated_samplers_first(struct hlsl_ctx *ctx) - } - - /* Lower DIV to RCP + MUL. */ --static bool lower_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { -+ struct hlsl_ir_node *rcp, *mul; - struct hlsl_ir_expr *expr; -- struct hlsl_ir_node *rcp; - - if (instr->type != HLSL_IR_EXPR) - return false; -@@ -2288,18 +2535,20 @@ static bool lower_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi - - if (!(rcp = hlsl_new_unary_expr(ctx, HLSL_OP1_RCP, expr->operands[1].node, &instr->loc))) - return false; -- list_add_before(&expr->node.entry, &rcp->entry); -- expr->op = HLSL_OP2_MUL; -- hlsl_src_remove(&expr->operands[1]); -- hlsl_src_from_node(&expr->operands[1], rcp); -+ hlsl_block_add_instr(block, rcp); -+ -+ if (!(mul = hlsl_new_binary_expr(ctx, HLSL_OP2_MUL, expr->operands[0].node, rcp))) -+ return false; -+ hlsl_block_add_instr(block, mul); -+ - return true; - } - - /* Lower SQRT to RSQ + RCP. */ --static bool lower_sqrt(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_sqrt(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { -+ struct hlsl_ir_node *rsq, *rcp; - struct hlsl_ir_expr *expr; -- struct hlsl_ir_node *rsq; - - if (instr->type != HLSL_IR_EXPR) - return false; -@@ -2309,15 +2558,16 @@ static bool lower_sqrt(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *c - - if (!(rsq = hlsl_new_unary_expr(ctx, HLSL_OP1_RSQ, expr->operands[0].node, &instr->loc))) - return false; -- list_add_before(&expr->node.entry, &rsq->entry); -- expr->op = HLSL_OP1_RCP; -- hlsl_src_remove(&expr->operands[0]); -- hlsl_src_from_node(&expr->operands[0], rsq); -+ hlsl_block_add_instr(block, rsq); -+ -+ if (!(rcp = hlsl_new_unary_expr(ctx, HLSL_OP1_RCP, rsq, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, rcp); - return true; - } - - /* Lower DP2 to MUL + ADD */ --static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *arg1, *arg2, *mul, *replacement, *zero, *add_x, *add_y; - struct hlsl_ir_expr *expr; -@@ -2338,7 +2588,7 @@ static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *co - - if (!(zero = hlsl_new_float_constant(ctx, 0.0f, &expr->node.loc))) - return false; -- list_add_before(&instr->entry, &zero->entry); -+ hlsl_block_add_instr(block, zero); - - operands[0] = arg1; - operands[1] = arg2; -@@ -2351,27 +2601,26 @@ static bool lower_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *co - { - if (!(mul = hlsl_new_binary_expr(ctx, HLSL_OP2_MUL, expr->operands[0].node, expr->operands[1].node))) - return false; -- list_add_before(&instr->entry, &mul->entry); -+ hlsl_block_add_instr(block, mul); - - if (!(add_x = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(X, X, X, X), instr->data_type->dimx, mul, &expr->node.loc))) - return false; -- list_add_before(&instr->entry, &add_x->entry); -+ hlsl_block_add_instr(block, add_x); - - if (!(add_y = hlsl_new_swizzle(ctx, HLSL_SWIZZLE(Y, Y, Y, Y), instr->data_type->dimx, mul, &expr->node.loc))) - return false; -- list_add_before(&instr->entry, &add_y->entry); -+ hlsl_block_add_instr(block, add_y); - - if (!(replacement = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, add_x, add_y))) - return false; - } -- list_add_before(&instr->entry, &replacement->entry); -+ hlsl_block_add_instr(block, replacement); - -- hlsl_replace_node(instr, replacement); - return true; - } - - /* Lower ABS to MAX */ --static bool lower_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *arg, *neg, *replacement; - struct hlsl_ir_expr *expr; -@@ -2385,18 +2634,17 @@ static bool lower_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *co - - if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, arg, &instr->loc))) - return false; -- list_add_before(&instr->entry, &neg->entry); -+ hlsl_block_add_instr(block, neg); - - if (!(replacement = hlsl_new_binary_expr(ctx, HLSL_OP2_MAX, neg, arg))) - return false; -- list_add_before(&instr->entry, &replacement->entry); -+ hlsl_block_add_instr(block, replacement); - -- hlsl_replace_node(instr, replacement); - return true; - } - - /* Lower ROUND using FRC, ROUND(x) -> ((x + 0.5) - FRC(x + 0.5)). */ --static bool lower_round(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_round(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *arg, *neg, *sum, *frc, *half, *replacement; - struct hlsl_type *type = instr->data_type; -@@ -2417,33 +2665,89 @@ static bool lower_round(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void * - half_value.u[i].f = 0.5f; - if (!(half = hlsl_new_constant(ctx, type, &half_value, &expr->node.loc))) - return false; -- -- list_add_before(&instr->entry, &half->entry); -+ hlsl_block_add_instr(block, half); - - if (!(sum = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, arg, half))) - return false; -- list_add_before(&instr->entry, &sum->entry); -+ hlsl_block_add_instr(block, sum); - - if (!(frc = hlsl_new_unary_expr(ctx, HLSL_OP1_FRACT, sum, &instr->loc))) - return false; -- list_add_before(&instr->entry, &frc->entry); -+ hlsl_block_add_instr(block, frc); - - if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, frc, &instr->loc))) - return false; -- list_add_before(&instr->entry, &neg->entry); -+ hlsl_block_add_instr(block, neg); - - if (!(replacement = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, sum, neg))) - return false; -- list_add_before(&instr->entry, &replacement->entry); -+ hlsl_block_add_instr(block, replacement); -+ -+ return true; -+} -+ -+/* Lower CEIL to FRC */ -+static bool lower_ceil(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) -+{ -+ struct hlsl_ir_node *arg, *neg, *sum, *frc; -+ struct hlsl_ir_expr *expr; -+ -+ if (instr->type != HLSL_IR_EXPR) -+ return false; -+ -+ expr = hlsl_ir_expr(instr); -+ arg = expr->operands[0].node; -+ if (expr->op != HLSL_OP1_CEIL) -+ return false; -+ -+ if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, arg, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, neg); -+ -+ if (!(frc = hlsl_new_unary_expr(ctx, HLSL_OP1_FRACT, neg, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, frc); -+ -+ if (!(sum = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, frc, arg))) -+ return false; -+ hlsl_block_add_instr(block, sum); -+ -+ return true; -+} -+ -+/* Lower FLOOR to FRC */ -+static bool lower_floor(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) -+{ -+ struct hlsl_ir_node *arg, *neg, *sum, *frc; -+ struct hlsl_ir_expr *expr; -+ -+ if (instr->type != HLSL_IR_EXPR) -+ return false; -+ -+ expr = hlsl_ir_expr(instr); -+ arg = expr->operands[0].node; -+ if (expr->op != HLSL_OP1_FLOOR) -+ return false; -+ -+ if (!(frc = hlsl_new_unary_expr(ctx, HLSL_OP1_FRACT, arg, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, frc); -+ -+ if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, frc, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, neg); -+ -+ if (!(sum = hlsl_new_binary_expr(ctx, HLSL_OP2_ADD, neg, arg))) -+ return false; -+ hlsl_block_add_instr(block, sum); - -- hlsl_replace_node(instr, replacement); - return true; - } - - /* Use 'movc' for the ternary operator. */ --static bool lower_ternary(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_ternary(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { -- struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS], *replacement; -+ struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS] = { 0 }, *replacement; - struct hlsl_ir_node *zero, *cond, *first, *second; - struct hlsl_constant_value zero_value = { 0 }; - struct hlsl_ir_expr *expr; -@@ -2460,39 +2764,63 @@ static bool lower_ternary(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void - first = expr->operands[1].node; - second = expr->operands[2].node; - -- if (cond->data_type->base_type == HLSL_TYPE_FLOAT) -+ if (ctx->profile->major_version < 4 && ctx->profile->type == VKD3D_SHADER_TYPE_PIXEL) - { -- if (!(zero = hlsl_new_constant(ctx, cond->data_type, &zero_value, &instr->loc))) -+ struct hlsl_ir_node *abs, *neg; -+ -+ if (!(abs = hlsl_new_unary_expr(ctx, HLSL_OP1_ABS, cond, &instr->loc))) - return false; -- list_add_tail(&instr->entry, &zero->entry); -+ hlsl_block_add_instr(block, abs); - -- memset(operands, 0, sizeof(operands)); -- operands[0] = zero; -- operands[1] = cond; -- type = cond->data_type; -- type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_BOOL, type->dimx, type->dimy); -- if (!(cond = hlsl_new_expr(ctx, HLSL_OP2_NEQUAL, operands, type, &instr->loc))) -+ if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, abs, &instr->loc))) - return false; -- list_add_before(&instr->entry, &cond->entry); -- } -+ hlsl_block_add_instr(block, neg); - -- memset(operands, 0, sizeof(operands)); -- operands[0] = cond; -- operands[1] = first; -- operands[2] = second; -- if (!(replacement = hlsl_new_expr(ctx, HLSL_OP3_MOVC, operands, first->data_type, &instr->loc))) -+ operands[0] = neg; -+ operands[1] = second; -+ operands[2] = first; -+ if (!(replacement = hlsl_new_expr(ctx, HLSL_OP3_CMP, operands, first->data_type, &instr->loc))) -+ return false; -+ } -+ else if (ctx->profile->major_version < 4 && ctx->profile->type == VKD3D_SHADER_TYPE_VERTEX) -+ { -+ hlsl_fixme(ctx, &instr->loc, "Ternary operator is not implemented for %s profile.", ctx->profile->name); - return false; -- list_add_before(&instr->entry, &replacement->entry); -+ } -+ else -+ { -+ if (cond->data_type->base_type == HLSL_TYPE_FLOAT) -+ { -+ if (!(zero = hlsl_new_constant(ctx, cond->data_type, &zero_value, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, zero); -+ -+ operands[0] = zero; -+ operands[1] = cond; -+ type = cond->data_type; -+ type = hlsl_get_numeric_type(ctx, type->class, HLSL_TYPE_BOOL, type->dimx, type->dimy); -+ if (!(cond = hlsl_new_expr(ctx, HLSL_OP2_NEQUAL, operands, type, &instr->loc))) -+ return false; -+ hlsl_block_add_instr(block, cond); -+ } -+ -+ memset(operands, 0, sizeof(operands)); -+ operands[0] = cond; -+ operands[1] = first; -+ operands[2] = second; -+ if (!(replacement = hlsl_new_expr(ctx, HLSL_OP3_MOVC, operands, first->data_type, &instr->loc))) -+ return false; -+ } - -- hlsl_replace_node(instr, replacement); -+ hlsl_block_add_instr(block, replacement); - return true; - } - --static bool lower_casts_to_bool(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_casts_to_bool(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_type *type = instr->data_type, *arg_type; - static const struct hlsl_constant_value zero_value; -- struct hlsl_ir_node *zero; -+ struct hlsl_ir_node *zero, *neq; - struct hlsl_ir_expr *expr; - - if (instr->type != HLSL_IR_EXPR) -@@ -2512,10 +2840,12 @@ static bool lower_casts_to_bool(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr - zero = hlsl_new_constant(ctx, arg_type, &zero_value, &instr->loc); - if (!zero) - return false; -- list_add_before(&instr->entry, &zero->entry); -+ hlsl_block_add_instr(block, zero); - -- expr->op = HLSL_OP2_NEQUAL; -- hlsl_src_from_node(&expr->operands[1], zero); -+ if (!(neq = hlsl_new_binary_expr(ctx, HLSL_OP2_NEQUAL, expr->operands[0].node, zero))) -+ return false; -+ neq->data_type = expr->node.data_type; -+ hlsl_block_add_instr(block, neq); - - return true; - } -@@ -2523,36 +2853,19 @@ static bool lower_casts_to_bool(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr - struct hlsl_ir_node *hlsl_add_conditional(struct hlsl_ctx *ctx, struct hlsl_block *instrs, - struct hlsl_ir_node *condition, struct hlsl_ir_node *if_true, struct hlsl_ir_node *if_false) - { -- struct hlsl_block then_block, else_block; -- struct hlsl_ir_node *iff, *store; -- struct hlsl_ir_load *load; -- struct hlsl_ir_var *var; -+ struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS]; -+ struct hlsl_ir_node *cond; - - assert(hlsl_types_are_equal(if_true->data_type, if_false->data_type)); - -- if (!(var = hlsl_new_synthetic_var(ctx, "conditional", if_true->data_type, &condition->loc))) -- return NULL; -- -- hlsl_block_init(&then_block); -- hlsl_block_init(&else_block); -- -- if (!(store = hlsl_new_simple_store(ctx, var, if_true))) -- return NULL; -- hlsl_block_add_instr(&then_block, store); -- -- if (!(store = hlsl_new_simple_store(ctx, var, if_false))) -- return NULL; -- hlsl_block_add_instr(&else_block, store); -- -- if (!(iff = hlsl_new_if(ctx, condition, &then_block, &else_block, &condition->loc))) -- return NULL; -- hlsl_block_add_instr(instrs, iff); -- -- if (!(load = hlsl_new_var_load(ctx, var, &condition->loc))) -- return NULL; -- hlsl_block_add_instr(instrs, &load->node); -+ operands[0] = condition; -+ operands[1] = if_true; -+ operands[2] = if_false; -+ if (!(cond = hlsl_new_expr(ctx, HLSL_OP3_TERNARY, operands, if_true->data_type, &condition->loc))) -+ return false; -+ hlsl_block_add_instr(instrs, cond); - -- return &load->node; -+ return cond; - } - - static bool lower_int_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) -@@ -2683,10 +2996,10 @@ static bool lower_int_modulus(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - return hlsl_add_conditional(ctx, block, and, neg, cast3); - } - --static bool lower_int_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_int_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_type *type = instr->data_type; -- struct hlsl_ir_node *arg, *neg; -+ struct hlsl_ir_node *arg, *neg, *max; - struct hlsl_ir_expr *expr; - - if (instr->type != HLSL_IR_EXPR) -@@ -2704,15 +3017,16 @@ static bool lower_int_abs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void - - if (!(neg = hlsl_new_unary_expr(ctx, HLSL_OP1_NEG, arg, &instr->loc))) - return false; -- list_add_before(&instr->entry, &neg->entry); -+ hlsl_block_add_instr(block, neg); - -- expr->op = HLSL_OP2_MAX; -- hlsl_src_from_node(&expr->operands[1], neg); -+ if (!(max = hlsl_new_binary_expr(ctx, HLSL_OP2_MAX, arg, neg))) -+ return false; -+ hlsl_block_add_instr(block, max); - - return true; - } - --static bool lower_int_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -+static bool lower_int_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, struct hlsl_block *block) - { - struct hlsl_ir_node *arg1, *arg2, *mult, *comps[4] = {0}, *res; - struct hlsl_type *type = instr->data_type; -@@ -2738,7 +3052,7 @@ static bool lower_int_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void - - if (!(mult = hlsl_new_binary_expr(ctx, is_bool ? HLSL_OP2_LOGIC_AND : HLSL_OP2_MUL, arg1, arg2))) - return false; -- list_add_before(&instr->entry, &mult->entry); -+ hlsl_block_add_instr(block, mult); - - for (i = 0; i < dimx; ++i) - { -@@ -2746,7 +3060,7 @@ static bool lower_int_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void - - if (!(comps[i] = hlsl_new_swizzle(ctx, s, 1, mult, &instr->loc))) - return false; -- list_add_before(&instr->entry, &comps[i]->entry); -+ hlsl_block_add_instr(block, comps[i]); - } - - res = comps[0]; -@@ -2754,10 +3068,9 @@ static bool lower_int_dot(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void - { - if (!(res = hlsl_new_binary_expr(ctx, is_bool ? HLSL_OP2_LOGIC_OR : HLSL_OP2_ADD, res, comps[i]))) - return false; -- list_add_before(&instr->entry, &res->entry); -+ hlsl_block_add_instr(block, res); - } - -- hlsl_replace_node(instr, res); - return true; - } - -@@ -2922,6 +3235,7 @@ static bool dce(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) - case HLSL_IR_JUMP: - case HLSL_IR_LOOP: - case HLSL_IR_RESOURCE_STORE: -+ case HLSL_IR_SWITCH: - break; - } - -@@ -2949,26 +3263,45 @@ static unsigned int index_instructions(struct hlsl_block *block, unsigned int in - index = index_instructions(&hlsl_ir_loop(instr)->body, index); - hlsl_ir_loop(instr)->next_index = index; - } -+ else if (instr->type == HLSL_IR_SWITCH) -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ index = index_instructions(&c->body, index); -+ } -+ } - } - - return index; - } - --static void dump_function_decl(struct rb_entry *entry, void *context) -+static void dump_function(struct rb_entry *entry, void *context) - { -- struct hlsl_ir_function_decl *func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry); -+ struct hlsl_ir_function *func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); -+ struct hlsl_ir_function_decl *decl; - struct hlsl_ctx *ctx = context; - -- if (func->has_body) -- hlsl_dump_function(ctx, func); -+ LIST_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) -+ { -+ if (decl->has_body) -+ hlsl_dump_function(ctx, decl); -+ } - } - --static void dump_function(struct rb_entry *entry, void *context) -+static bool mark_indexable_vars(struct hlsl_ctx *ctx, struct hlsl_deref *deref, -+ struct hlsl_ir_node *instr) - { -- struct hlsl_ir_function *func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); -- struct hlsl_ctx *ctx = context; -+ if (!deref->rel_offset.node) -+ return false; -+ -+ assert(deref->var); -+ assert(deref->rel_offset.node->type != HLSL_IR_CONSTANT); -+ deref->var->indexable = true; - -- rb_for_each_entry(&func->overloads, dump_function_decl, ctx); -+ return true; - } - - static char get_regset_name(enum hlsl_regset regset) -@@ -2993,31 +3326,39 @@ static void allocate_register_reservations(struct hlsl_ctx *ctx) - - LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) - { -- enum hlsl_regset regset; -+ unsigned int r; - - if (!hlsl_type_is_resource(var->data_type)) - continue; -- regset = hlsl_type_get_regset(var->data_type); - -- if (var->reg_reservation.reg_type && var->regs[regset].allocation_size) -+ if (var->reg_reservation.reg_type) - { -- if (var->reg_reservation.reg_type != get_regset_name(regset)) -- { -- struct vkd3d_string_buffer *type_string; -- -- type_string = hlsl_type_to_string(ctx, var->data_type); -- hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_RESERVATION, -- "Object of type '%s' must be bound to register type '%c'.", -- type_string->buffer, get_regset_name(regset)); -- hlsl_release_string_buffer(ctx, type_string); -- } -- else -+ for (r = 0; r <= HLSL_REGSET_LAST_OBJECT; ++r) - { -- var->regs[regset].allocated = true; -- var->regs[regset].id = var->reg_reservation.reg_index; -- TRACE("Allocated reserved %s to %c%u-%c%u.\n", var->name, var->reg_reservation.reg_type, -- var->reg_reservation.reg_index, var->reg_reservation.reg_type, -- var->reg_reservation.reg_index + var->regs[regset].allocation_size); -+ if (var->regs[r].allocation_size > 0) -+ { -+ if (var->reg_reservation.reg_type != get_regset_name(r)) -+ { -+ struct vkd3d_string_buffer *type_string; -+ -+ /* We can throw this error because resources can only span across a single -+ * regset, but we have to check for multiple regsets if we support register -+ * reservations for structs for SM5. */ -+ type_string = hlsl_type_to_string(ctx, var->data_type); -+ hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_RESERVATION, -+ "Object of type '%s' must be bound to register type '%c'.", -+ type_string->buffer, get_regset_name(r)); -+ hlsl_release_string_buffer(ctx, type_string); -+ } -+ else -+ { -+ var->regs[r].allocated = true; -+ var->regs[r].id = var->reg_reservation.reg_index; -+ TRACE("Allocated reserved %s to %c%u-%c%u.\n", var->name, var->reg_reservation.reg_type, -+ var->reg_reservation.reg_index, var->reg_reservation.reg_type, -+ var->reg_reservation.reg_index + var->regs[r].allocation_size); -+ } -+ } - } - } - } -@@ -3051,8 +3392,8 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop - if (!var->first_write) - var->first_write = loop_first ? min(instr->index, loop_first) : instr->index; - store->rhs.node->last_read = last_read; -- if (store->lhs.offset.node) -- store->lhs.offset.node->last_read = last_read; -+ if (store->lhs.rel_offset.node) -+ store->lhs.rel_offset.node->last_read = last_read; - break; - } - case HLSL_IR_EXPR: -@@ -3079,8 +3420,8 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop - - var = load->src.var; - var->last_read = max(var->last_read, last_read); -- if (load->src.offset.node) -- load->src.offset.node->last_read = last_read; -+ if (load->src.rel_offset.node) -+ load->src.rel_offset.node->last_read = last_read; - break; - } - case HLSL_IR_LOOP: -@@ -3097,14 +3438,14 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop - - var = load->resource.var; - var->last_read = max(var->last_read, last_read); -- if (load->resource.offset.node) -- load->resource.offset.node->last_read = last_read; -+ if (load->resource.rel_offset.node) -+ load->resource.rel_offset.node->last_read = last_read; - - if ((var = load->sampler.var)) - { - var->last_read = max(var->last_read, last_read); -- if (load->sampler.offset.node) -- load->sampler.offset.node->last_read = last_read; -+ if (load->sampler.rel_offset.node) -+ load->sampler.rel_offset.node->last_read = last_read; - } - - if (load->coords.node) -@@ -3129,8 +3470,8 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop - - var = store->resource.var; - var->last_read = max(var->last_read, last_read); -- if (store->resource.offset.node) -- store->resource.offset.node->last_read = last_read; -+ if (store->resource.rel_offset.node) -+ store->resource.rel_offset.node->last_read = last_read; - store->coords.node->last_read = last_read; - store->value.node->last_read = last_read; - break; -@@ -3158,6 +3499,16 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop - jump->condition.node->last_read = last_read; - break; - } -+ case HLSL_IR_SWITCH: -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ compute_liveness_recurse(&c->body, loop_first, loop_last); -+ s->selector.node->last_read = last_read; -+ break; -+ } - case HLSL_IR_CONSTANT: - break; - } -@@ -3191,18 +3542,20 @@ static void compute_liveness(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl - - struct register_allocator - { -- size_t count, capacity; -- -- /* Highest register index that has been allocated. -- * Used to declare sm4 temp count. */ -- uint32_t max_reg; -- - struct allocation - { - uint32_t reg; - unsigned int writemask; - unsigned int first_write, last_read; - } *allocations; -+ size_t count, capacity; -+ -+ /* Indexable temps are allocated separately and always keep their index regardless of their -+ * lifetime. */ -+ size_t indexable_count; -+ -+ /* Total number of registers allocated so far. Used to declare sm4 temp count. */ -+ uint32_t reg_count; - }; - - static unsigned int get_available_writemask(const struct register_allocator *allocator, -@@ -3245,7 +3598,7 @@ static void record_allocation(struct hlsl_ctx *ctx, struct register_allocator *a - allocation->first_write = first_write; - allocation->last_read = last_read; - -- allocator->max_reg = max(allocator->max_reg, reg_idx); -+ allocator->reg_count = max(allocator->reg_count, reg_idx + 1); - } - - /* reg_size is the number of register components to be reserved, while component_count is the number -@@ -3284,13 +3637,19 @@ static struct hlsl_reg allocate_register(struct hlsl_ctx *ctx, struct register_a - static bool is_range_available(const struct register_allocator *allocator, - unsigned int first_write, unsigned int last_read, uint32_t reg_idx, unsigned int reg_size) - { -+ unsigned int last_reg_mask = (1u << (reg_size % 4)) - 1; -+ unsigned int writemask; - uint32_t i; - - for (i = 0; i < (reg_size / 4); ++i) - { -- if (get_available_writemask(allocator, first_write, last_read, reg_idx + i) != VKD3DSP_WRITEMASK_ALL) -+ writemask = get_available_writemask(allocator, first_write, last_read, reg_idx + i); -+ if (writemask != VKD3DSP_WRITEMASK_ALL) - return false; - } -+ writemask = get_available_writemask(allocator, first_write, last_read, reg_idx + (reg_size / 4)); -+ if ((writemask & last_reg_mask) != last_reg_mask) -+ return false; - return true; - } - -@@ -3309,6 +3668,8 @@ static struct hlsl_reg allocate_range(struct hlsl_ctx *ctx, struct register_allo - - for (i = 0; i < reg_size / 4; ++i) - record_allocation(ctx, allocator, reg_idx + i, VKD3DSP_WRITEMASK_ALL, first_write, last_read); -+ if (reg_size % 4) -+ record_allocation(ctx, allocator, reg_idx + (reg_size / 4), (1u << (reg_size % 4)) - 1, first_write, last_read); - - ret.id = reg_idx; - ret.allocation_size = align(reg_size, 4) / 4; -@@ -3356,7 +3717,7 @@ static bool track_object_components_sampler_dim(struct hlsl_ctx *ctx, struct hls - load = hlsl_ir_resource_load(instr); - var = load->resource.var; - -- regset = hlsl_type_get_regset(hlsl_deref_get_type(ctx, &load->resource)); -+ regset = hlsl_deref_get_regset(ctx, &load->resource); - if (!hlsl_regset_index_from_deref(ctx, &load->resource, regset, &index)) - return false; - -@@ -3401,7 +3762,8 @@ static bool track_object_components_usage(struct hlsl_ctx *ctx, struct hlsl_ir_n - load = hlsl_ir_resource_load(instr); - var = load->resource.var; - -- regset = hlsl_type_get_regset(hlsl_deref_get_type(ctx, &load->resource)); -+ regset = hlsl_deref_get_regset(ctx, &load->resource); -+ - if (!hlsl_regset_index_from_deref(ctx, &load->resource, regset, &index)) - return false; - -@@ -3448,11 +3810,23 @@ static void allocate_variable_temp_register(struct hlsl_ctx *ctx, - - if (!var->regs[HLSL_REGSET_NUMERIC].allocated && var->last_read) - { -- var->regs[HLSL_REGSET_NUMERIC] = allocate_numeric_registers_for_type(ctx, allocator, -- var->first_write, var->last_read, var->data_type); -+ if (var->indexable) -+ { -+ var->regs[HLSL_REGSET_NUMERIC].id = allocator->indexable_count++; -+ var->regs[HLSL_REGSET_NUMERIC].allocation_size = 1; -+ var->regs[HLSL_REGSET_NUMERIC].writemask = 0; -+ var->regs[HLSL_REGSET_NUMERIC].allocated = true; -+ -+ TRACE("Allocated %s to x%u[].\n", var->name, var->regs[HLSL_REGSET_NUMERIC].id); -+ } -+ else -+ { -+ var->regs[HLSL_REGSET_NUMERIC] = allocate_numeric_registers_for_type(ctx, allocator, -+ var->first_write, var->last_read, var->data_type); - -- TRACE("Allocated %s to %s (liveness %u-%u).\n", var->name, debug_register('r', -- var->regs[HLSL_REGSET_NUMERIC], var->data_type), var->first_write, var->last_read); -+ TRACE("Allocated %s to %s (liveness %u-%u).\n", var->name, debug_register('r', -+ var->regs[HLSL_REGSET_NUMERIC], var->data_type), var->first_write, var->last_read); -+ } - } - } - -@@ -3508,6 +3882,18 @@ static void allocate_temp_registers_recurse(struct hlsl_ctx *ctx, - break; - } - -+ case HLSL_IR_SWITCH: -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ allocate_temp_registers_recurse(ctx, &c->body, allocator); -+ } -+ break; -+ } -+ - default: - break; - } -@@ -3556,7 +3942,7 @@ static void allocate_const_registers_recurse(struct hlsl_ctx *ctx, - constant->reg = allocate_numeric_registers_for_type(ctx, allocator, 1, UINT_MAX, type); - TRACE("Allocated constant @%u to %s.\n", instr->index, debug_register('c', constant->reg, type)); - -- assert(type->class <= HLSL_CLASS_LAST_NUMERIC); -+ assert(hlsl_is_numeric_type(type)); - assert(type->dimy == 1); - assert(constant->reg.writemask); - -@@ -3617,6 +4003,18 @@ static void allocate_const_registers_recurse(struct hlsl_ctx *ctx, - break; - } - -+ case HLSL_IR_SWITCH: -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ allocate_const_registers_recurse(ctx, &c->body, allocator); -+ } -+ break; -+ } -+ - default: - break; - } -@@ -3675,7 +4073,7 @@ static void allocate_temp_registers(struct hlsl_ctx *ctx, struct hlsl_ir_functio - } - - allocate_temp_registers_recurse(ctx, &entry_func->body, &allocator); -- ctx->temp_count = allocator.max_reg + 1; -+ ctx->temp_count = allocator.reg_count; - vkd3d_free(allocator.allocations); - } - -@@ -3728,7 +4126,7 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var - "Invalid semantic '%s'.", var->semantic.name); - return; - } -- if ((builtin = hlsl_sm4_register_from_semantic(ctx, &var->semantic, output, &type, NULL, &has_idx))) -+ if ((builtin = hlsl_sm4_register_from_semantic(ctx, &var->semantic, output, &type, &has_idx))) - reg = has_idx ? var->semantic.index : 0; - } - -@@ -4190,30 +4588,25 @@ bool hlsl_regset_index_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref - - bool hlsl_offset_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, unsigned int *offset) - { -- struct hlsl_ir_node *offset_node = deref->offset.node; -- enum hlsl_regset regset; -+ enum hlsl_regset regset = hlsl_deref_get_regset(ctx, deref); -+ struct hlsl_ir_node *offset_node = deref->rel_offset.node; - unsigned int size; - -- if (!offset_node) -- { -- *offset = 0; -- return true; -- } -+ *offset = deref->const_offset; - -- /* We should always have generated a cast to UINT. */ -- assert(offset_node->data_type->class == HLSL_CLASS_SCALAR -- && offset_node->data_type->base_type == HLSL_TYPE_UINT); -- -- if (offset_node->type != HLSL_IR_CONSTANT) -+ if (offset_node) -+ { -+ /* We should always have generated a cast to UINT. */ -+ assert(offset_node->data_type->class == HLSL_CLASS_SCALAR -+ && offset_node->data_type->base_type == HLSL_TYPE_UINT); -+ assert(offset_node->type != HLSL_IR_CONSTANT); - return false; -- -- *offset = hlsl_ir_constant(offset_node)->value.u[0].u; -- regset = hlsl_type_get_regset(deref->data_type); -+ } - - size = deref->var->data_type->reg_size[regset]; - if (*offset >= size) - { -- hlsl_error(ctx, &deref->offset.node->loc, VKD3D_SHADER_ERROR_HLSL_OFFSET_OUT_OF_BOUNDS, -+ hlsl_error(ctx, &offset_node->loc, VKD3D_SHADER_ERROR_HLSL_OFFSET_OUT_OF_BOUNDS, - "Dereference is out of bounds. %u/%u", *offset, size); - return false; - } -@@ -4228,8 +4621,8 @@ unsigned int hlsl_offset_from_deref_safe(struct hlsl_ctx *ctx, const struct hlsl - if (hlsl_offset_from_deref(ctx, deref, &offset)) - return offset; - -- hlsl_fixme(ctx, &deref->offset.node->loc, "Dereference with non-constant offset of type %s.", -- hlsl_node_type_to_string(deref->offset.node->type)); -+ hlsl_fixme(ctx, &deref->rel_offset.node->loc, "Dereference with non-constant offset of type %s.", -+ hlsl_node_type_to_string(deref->rel_offset.node->type)); - - return 0; - } -@@ -4241,7 +4634,7 @@ struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_dere - unsigned int offset = hlsl_offset_from_deref_safe(ctx, deref); - - assert(deref->data_type); -- assert(deref->data_type->class <= HLSL_CLASS_LAST_NUMERIC); -+ assert(hlsl_is_numeric_type(deref->data_type)); - - ret.id += offset / 4; - -@@ -4319,6 +4712,62 @@ static bool type_has_object_components(struct hlsl_type *type) - return false; - } - -+static void remove_unreachable_code(struct hlsl_ctx *ctx, struct hlsl_block *body) -+{ -+ struct hlsl_ir_node *instr, *next; -+ struct hlsl_block block; -+ struct list *start; -+ -+ LIST_FOR_EACH_ENTRY_SAFE(instr, next, &body->instrs, struct hlsl_ir_node, entry) -+ { -+ if (instr->type == HLSL_IR_IF) -+ { -+ struct hlsl_ir_if *iff = hlsl_ir_if(instr); -+ -+ remove_unreachable_code(ctx, &iff->then_block); -+ remove_unreachable_code(ctx, &iff->else_block); -+ } -+ else if (instr->type == HLSL_IR_LOOP) -+ { -+ struct hlsl_ir_loop *loop = hlsl_ir_loop(instr); -+ -+ remove_unreachable_code(ctx, &loop->body); -+ } -+ else if (instr->type == HLSL_IR_SWITCH) -+ { -+ struct hlsl_ir_switch *s = hlsl_ir_switch(instr); -+ struct hlsl_ir_switch_case *c; -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ remove_unreachable_code(ctx, &c->body); -+ } -+ } -+ } -+ -+ /* Remove instructions past unconditional jumps. */ -+ LIST_FOR_EACH_ENTRY(instr, &body->instrs, struct hlsl_ir_node, entry) -+ { -+ struct hlsl_ir_jump *jump; -+ -+ if (instr->type != HLSL_IR_JUMP) -+ continue; -+ -+ jump = hlsl_ir_jump(instr); -+ if (jump->type != HLSL_IR_JUMP_BREAK && jump->type != HLSL_IR_JUMP_CONTINUE) -+ continue; -+ -+ if (!(start = list_next(&body->instrs, &instr->entry))) -+ break; -+ -+ hlsl_block_init(&block); -+ list_move_slice_tail(&block.instrs, start, list_tail(&body->instrs)); -+ hlsl_block_cleanup(&block); -+ -+ break; -+ } -+} -+ - int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, - enum vkd3d_shader_target_type target_type, struct vkd3d_shader_code *out) - { -@@ -4345,7 +4794,7 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - while (hlsl_transform_ir(ctx, lower_calls, body, NULL)); - - lower_ir(ctx, lower_matrix_swizzles, body); -- hlsl_transform_ir(ctx, lower_index_loads, body, NULL); -+ lower_ir(ctx, lower_index_loads, body); - - LIST_FOR_EACH_ENTRY(var, &ctx->globals->vars, struct hlsl_ir_var, scope_entry) - { -@@ -4408,7 +4857,7 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - { - hlsl_transform_ir(ctx, lower_discard_neg, body, NULL); - } -- hlsl_transform_ir(ctx, lower_broadcasts, body, NULL); -+ lower_ir(ctx, lower_broadcasts, body); - while (hlsl_transform_ir(ctx, fold_redundant_casts, body, NULL)); - do - { -@@ -4418,12 +4867,12 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - while (progress); - hlsl_transform_ir(ctx, split_matrix_copies, body, NULL); - -- hlsl_transform_ir(ctx, lower_narrowing_casts, body, NULL); -- hlsl_transform_ir(ctx, lower_casts_to_bool, body, NULL); -- hlsl_transform_ir(ctx, lower_int_dot, body, NULL); -+ lower_ir(ctx, lower_narrowing_casts, body); -+ lower_ir(ctx, lower_casts_to_bool, body); -+ lower_ir(ctx, lower_int_dot, body); - lower_ir(ctx, lower_int_division, body); - lower_ir(ctx, lower_int_modulus, body); -- hlsl_transform_ir(ctx, lower_int_abs, body, NULL); -+ lower_ir(ctx, lower_int_abs, body); - lower_ir(ctx, lower_float_modulus, body); - hlsl_transform_ir(ctx, fold_redundant_casts, body, NULL); - do -@@ -4433,12 +4882,15 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - progress |= hlsl_copy_propagation_execute(ctx, body); - progress |= hlsl_transform_ir(ctx, fold_swizzle_chains, body, NULL); - progress |= hlsl_transform_ir(ctx, remove_trivial_swizzles, body, NULL); -+ progress |= hlsl_transform_ir(ctx, remove_trivial_conditional_branches, body, NULL); - } - while (progress); -+ remove_unreachable_code(ctx, body); -+ hlsl_transform_ir(ctx, normalize_switch_cases, body, NULL); - -- hlsl_transform_ir(ctx, lower_nonconstant_vector_derefs, body, NULL); -- hlsl_transform_ir(ctx, lower_casts_to_bool, body, NULL); -- hlsl_transform_ir(ctx, lower_int_dot, body, NULL); -+ lower_ir(ctx, lower_nonconstant_vector_derefs, body); -+ lower_ir(ctx, lower_casts_to_bool, body); -+ lower_ir(ctx, lower_int_dot, body); - - hlsl_transform_ir(ctx, validate_static_object_references, body, NULL); - hlsl_transform_ir(ctx, track_object_components_sampler_dim, body, NULL); -@@ -4447,24 +4899,26 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - hlsl_transform_ir(ctx, track_object_components_usage, body, NULL); - sort_synthetic_separated_samplers_first(ctx); - -- if (profile->major_version >= 4) -- hlsl_transform_ir(ctx, lower_ternary, body, NULL); -+ lower_ir(ctx, lower_ternary, body); - if (profile->major_version < 4) - { -- hlsl_transform_ir(ctx, lower_division, body, NULL); -- hlsl_transform_ir(ctx, lower_sqrt, body, NULL); -- hlsl_transform_ir(ctx, lower_dot, body, NULL); -- hlsl_transform_ir(ctx, lower_round, body, NULL); -+ lower_ir(ctx, lower_division, body); -+ lower_ir(ctx, lower_sqrt, body); -+ lower_ir(ctx, lower_dot, body); -+ lower_ir(ctx, lower_round, body); -+ lower_ir(ctx, lower_ceil, body); -+ lower_ir(ctx, lower_floor, body); - } - - if (profile->major_version < 2) - { -- hlsl_transform_ir(ctx, lower_abs, body, NULL); -+ lower_ir(ctx, lower_abs, body); - } - - /* TODO: move forward, remove when no longer needed */ - transform_derefs(ctx, replace_deref_path_with_offset, body); - while (hlsl_transform_ir(ctx, hlsl_fold_constant_exprs, body, NULL)); -+ transform_derefs(ctx, clean_constant_deref_offset_srcs, body); - - do - compute_liveness(ctx, entry_func); -@@ -4475,6 +4929,8 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry - if (TRACE_ON()) - rb_for_each_entry(&ctx->functions, dump_function, ctx); - -+ transform_derefs(ctx, mark_indexable_vars, body); -+ - calculate_resource_register_counts(ctx); - - allocate_register_reservations(ctx); -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl_constant_ops.c b/libs/vkd3d/libs/vkd3d-shader/hlsl_constant_ops.c -index 41a72ab6c0d..b76b1fce507 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl_constant_ops.c -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl_constant_ops.c -@@ -63,6 +63,82 @@ static bool fold_abs(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, - return true; - } - -+static uint32_t float_to_uint(float x) -+{ -+ if (isnan(x) || x <= 0) -+ return 0; -+ -+ if (x >= 4294967296.0f) -+ return UINT32_MAX; -+ -+ return x; -+} -+ -+static int32_t float_to_int(float x) -+{ -+ if (isnan(x)) -+ return 0; -+ -+ if (x <= -2147483648.0f) -+ return INT32_MIN; -+ -+ if (x >= 2147483648.0f) -+ return INT32_MAX; -+ -+ return x; -+} -+ -+static uint32_t double_to_uint(double x) -+{ -+ if (isnan(x) || x <= 0) -+ return 0; -+ -+ if (x >= 4294967296.0) -+ return UINT32_MAX; -+ -+ return x; -+} -+ -+static int32_t double_to_int(double x) -+{ -+ if (isnan(x)) -+ return 0; -+ -+ if (x <= -2147483648.0) -+ return INT32_MIN; -+ -+ if (x >= 2147483648.0) -+ return INT32_MAX; -+ -+ return x; -+} -+ -+static bool fold_bit_not(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_INT: -+ case HLSL_TYPE_UINT: -+ case HLSL_TYPE_BOOL: -+ dst->u[k].u = ~src->value.u[k].u; -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+ } -+ -+ return true; -+} -+ - static bool fold_cast(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, - const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) - { -@@ -86,15 +162,15 @@ static bool fold_cast(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, - { - case HLSL_TYPE_FLOAT: - case HLSL_TYPE_HALF: -- u = src->value.u[k].f; -- i = src->value.u[k].f; -+ u = float_to_uint(src->value.u[k].f); -+ i = float_to_int(src->value.u[k].f); - f = src->value.u[k].f; - d = src->value.u[k].f; - break; - - case HLSL_TYPE_DOUBLE: -- u = src->value.u[k].d; -- i = src->value.u[k].d; -+ u = double_to_uint(src->value.u[k].d); -+ i = double_to_int(src->value.u[k].d); - f = src->value.u[k].d; - d = src->value.u[k].d; - break; -@@ -152,6 +228,111 @@ static bool fold_cast(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, - return true; - } - -+static bool fold_ceil(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k].f = ceilf(src->value.u[k].f); -+ break; -+ -+ default: -+ FIXME("Fold 'ceil' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ -+static bool fold_exp2(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k].f = exp2f(src->value.u[k].f); -+ break; -+ -+ default: -+ FIXME("Fold 'exp2' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ -+static bool fold_floor(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k].f = floorf(src->value.u[k].f); -+ break; -+ -+ default: -+ FIXME("Fold 'floor' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ -+static bool fold_fract(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ float i; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k].f = modff(src->value.u[k].f, &i); -+ break; -+ -+ default: -+ FIXME("Fold 'fract' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ - static bool fold_log2(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, - const struct hlsl_ir_constant *src, const struct vkd3d_shader_location *loc) - { -@@ -231,6 +412,30 @@ static bool fold_neg(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, - return true; - } - -+static bool fold_not(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, -+ const struct hlsl_type *dst_type, const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_BOOL: -+ dst->u[k].u = ~src->value.u[k].u; -+ break; -+ -+ default: -+ FIXME("Fold logic 'not' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ return true; -+} -+ - static bool fold_rcp(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, - const struct hlsl_ir_constant *src, const struct vkd3d_shader_location *loc) - { -@@ -276,6 +481,72 @@ static bool fold_rcp(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, cons - return true; - } - -+static bool fold_rsq(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, -+ const struct hlsl_ir_constant *src, const struct vkd3d_shader_location *loc) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ if (ctx->profile->major_version >= 4) -+ { -+ if (src->value.u[k].f < 0.0f) -+ hlsl_warning(ctx, loc, VKD3D_SHADER_WARNING_HLSL_IMAGINARY_NUMERIC_RESULT, -+ "Imaginary square root result."); -+ else if (src->value.u[k].f == 0.0f) -+ hlsl_warning(ctx, loc, VKD3D_SHADER_WARNING_HLSL_IMAGINARY_NUMERIC_RESULT, -+ "Floating point division by zero."); -+ } -+ dst->u[k].f = 1.0f / sqrtf(src->value.u[k].f); -+ if (ctx->profile->major_version < 4 && !isfinite(dst->u[k].f)) -+ { -+ hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_NON_FINITE_RESULT, -+ "Infinities and NaNs are not allowed by the shader model."); -+ } -+ break; -+ -+ default: -+ FIXME("Fold 'rsq' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ -+static bool fold_sat(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, -+ const struct hlsl_ir_constant *src) -+{ -+ enum hlsl_base_type type = dst_type->base_type; -+ unsigned int k; -+ -+ assert(type == src->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k].f = min(max(0.0f, src->value.u[k].f), 1.0f); -+ break; -+ -+ default: -+ FIXME("Fold 'sat' for type %s.\n", debug_hlsl_type(ctx, dst_type)); -+ return false; -+ } -+ } -+ -+ return true; -+} -+ - static bool fold_sqrt(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, - const struct hlsl_ir_constant *src, const struct vkd3d_shader_location *loc) - { -@@ -679,6 +950,36 @@ static bool fold_less(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, con - return true; - } - -+static bool fold_lshift(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, -+ const struct hlsl_ir_constant *src1, const struct hlsl_ir_constant *src2) -+{ -+ unsigned int k; -+ -+ assert(dst_type->base_type == src1->node.data_type->base_type); -+ assert(src2->node.data_type->base_type == HLSL_TYPE_INT); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ unsigned int shift = src2->value.u[k].u % 32; -+ -+ switch (src1->node.data_type->base_type) -+ { -+ case HLSL_TYPE_INT: -+ dst->u[k].i = src1->value.u[k].i << shift; -+ break; -+ -+ case HLSL_TYPE_UINT: -+ dst->u[k].u = src1->value.u[k].u << shift; -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+ } -+ -+ return true; -+} -+ - static bool fold_max(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, - const struct hlsl_ir_constant *src1, const struct hlsl_ir_constant *src2) - { -@@ -869,6 +1170,70 @@ static bool fold_nequal(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, c - return true; - } - -+static bool fold_ternary(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, -+ const struct hlsl_ir_constant *src1, const struct hlsl_ir_constant *src2, const struct hlsl_ir_constant *src3) -+{ -+ unsigned int k; -+ -+ assert(dst_type->base_type == src2->node.data_type->base_type); -+ assert(dst_type->base_type == src3->node.data_type->base_type); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ switch (src1->node.data_type->base_type) -+ { -+ case HLSL_TYPE_FLOAT: -+ case HLSL_TYPE_HALF: -+ dst->u[k] = src1->value.u[k].f != 0.0f ? src2->value.u[k] : src3->value.u[k]; -+ break; -+ -+ case HLSL_TYPE_DOUBLE: -+ dst->u[k] = src1->value.u[k].d != 0.0 ? src2->value.u[k] : src3->value.u[k]; -+ break; -+ -+ case HLSL_TYPE_INT: -+ case HLSL_TYPE_UINT: -+ case HLSL_TYPE_BOOL: -+ dst->u[k] = src1->value.u[k].u ? src2->value.u[k] : src3->value.u[k]; -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+ } -+ return true; -+} -+ -+static bool fold_rshift(struct hlsl_ctx *ctx, struct hlsl_constant_value *dst, const struct hlsl_type *dst_type, -+ const struct hlsl_ir_constant *src1, const struct hlsl_ir_constant *src2) -+{ -+ unsigned int k; -+ -+ assert(dst_type->base_type == src1->node.data_type->base_type); -+ assert(src2->node.data_type->base_type == HLSL_TYPE_INT); -+ -+ for (k = 0; k < dst_type->dimx; ++k) -+ { -+ unsigned int shift = src2->value.u[k].u % 32; -+ -+ switch (src1->node.data_type->base_type) -+ { -+ case HLSL_TYPE_INT: -+ dst->u[k].i = src1->value.u[k].i >> shift; -+ break; -+ -+ case HLSL_TYPE_UINT: -+ dst->u[k].u = src1->value.u[k].u >> shift; -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+ } -+ -+ return true; -+} -+ - bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) - { - struct hlsl_ir_constant *arg1, *arg2 = NULL, *arg3 = NULL; -@@ -908,10 +1273,30 @@ bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - success = fold_abs(ctx, &res, instr->data_type, arg1); - break; - -+ case HLSL_OP1_BIT_NOT: -+ success = fold_bit_not(ctx, &res, instr->data_type, arg1); -+ break; -+ - case HLSL_OP1_CAST: - success = fold_cast(ctx, &res, instr->data_type, arg1); - break; - -+ case HLSL_OP1_CEIL: -+ success = fold_ceil(ctx, &res, instr->data_type, arg1); -+ break; -+ -+ case HLSL_OP1_EXP2: -+ success = fold_exp2(ctx, &res, instr->data_type, arg1); -+ break; -+ -+ case HLSL_OP1_FLOOR: -+ success = fold_floor(ctx, &res, instr->data_type, arg1); -+ break; -+ -+ case HLSL_OP1_FRACT: -+ success = fold_fract(ctx, &res, instr->data_type, arg1); -+ break; -+ - case HLSL_OP1_LOG2: - success = fold_log2(ctx, &res, instr->data_type, arg1, &instr->loc); - break; -@@ -920,10 +1305,22 @@ bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - success = fold_neg(ctx, &res, instr->data_type, arg1); - break; - -+ case HLSL_OP1_LOGIC_NOT: -+ success = fold_not(ctx, &res, instr->data_type, arg1); -+ break; -+ - case HLSL_OP1_RCP: - success = fold_rcp(ctx, &res, instr->data_type, arg1, &instr->loc); - break; - -+ case HLSL_OP1_RSQ: -+ success = fold_rsq(ctx, &res, instr->data_type, arg1, &instr->loc); -+ break; -+ -+ case HLSL_OP1_SAT: -+ success = fold_sat(ctx, &res, instr->data_type, arg1); -+ break; -+ - case HLSL_OP1_SQRT: - success = fold_sqrt(ctx, &res, instr->data_type, arg1, &instr->loc); - break; -@@ -966,6 +1363,10 @@ bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - success = fold_less(ctx, &res, instr->data_type, arg1, arg2); - break; - -+ case HLSL_OP2_LSHIFT: -+ success = fold_lshift(ctx, &res, instr->data_type, arg1, arg2); -+ break; -+ - case HLSL_OP2_MAX: - success = fold_max(ctx, &res, instr->data_type, arg1, arg2); - break; -@@ -986,10 +1387,18 @@ bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, - success = fold_nequal(ctx, &res, instr->data_type, arg1, arg2); - break; - -+ case HLSL_OP2_RSHIFT: -+ success = fold_rshift(ctx, &res, instr->data_type, arg1, arg2); -+ break; -+ - case HLSL_OP3_DP2ADD: - success = fold_dp2add(ctx, &res, instr->data_type, arg1, arg2, arg3); - break; - -+ case HLSL_OP3_TERNARY: -+ success = fold_ternary(ctx, &res, instr->data_type, arg1, arg2, arg3); -+ break; -+ - default: - FIXME("Fold \"%s\" expression.\n", debug_hlsl_expr_op(expr->op)); - success = false; -diff --git a/libs/vkd3d/libs/vkd3d-shader/ir.c b/libs/vkd3d/libs/vkd3d-shader/ir.c -index d2bfb933edc..acdb660ea82 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/ir.c -+++ b/libs/vkd3d/libs/vkd3d-shader/ir.c -@@ -31,11 +31,9 @@ static bool shader_instruction_is_dcl(const struct vkd3d_shader_instruction *ins - - static void vkd3d_shader_instruction_make_nop(struct vkd3d_shader_instruction *ins) - { -- ins->handler_idx = VKD3DSIH_NOP; -- ins->dst_count = 0; -- ins->src_count = 0; -- ins->dst = NULL; -- ins->src = NULL; -+ struct vkd3d_shader_location location = ins->location; -+ -+ vsir_instruction_init(ins, &location, VKD3DSIH_NOP); - } - - static void shader_register_eliminate_phase_addressing(struct vkd3d_shader_register *reg, -@@ -64,17 +62,7 @@ static void shader_instruction_eliminate_phase_instance_id(struct vkd3d_shader_i - reg = (struct vkd3d_shader_register *)&ins->src[i].reg; - if (shader_register_is_phase_instance_id(reg)) - { -- reg->type = VKD3DSPR_IMMCONST; -- reg->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; -- reg->non_uniform = false; -- reg->idx[0].offset = ~0u; -- reg->idx[0].rel_addr = NULL; -- reg->idx[1].offset = ~0u; -- reg->idx[1].rel_addr = NULL; -- reg->idx[2].offset = ~0u; -- reg->idx[2].rel_addr = NULL; -- reg->idx_count = 0; -- reg->immconst_type = VKD3D_IMMCONST_SCALAR; -+ vsir_register_init(reg, VKD3DSPR_IMMCONST, reg->data_type, 0); - reg->u.immconst_uint[0] = instance_id; - continue; - } -@@ -161,6 +149,7 @@ struct hull_flattener - unsigned int instance_count; - unsigned int phase_body_idx; - enum vkd3d_shader_opcode phase; -+ struct vkd3d_shader_location last_ret_location; - }; - - static bool flattener_is_in_fork_or_join_phase(const struct hull_flattener *flattener) -@@ -218,10 +207,15 @@ static void flattener_eliminate_phase_related_dcls(struct hull_flattener *normal - { - /* Leave only the first temp declaration and set it to the max count later. */ - if (!normaliser->max_temp_count) -+ { -+ normaliser->max_temp_count = ins->declaration.count; - normaliser->temp_dcl_idx = index; -+ } - else -+ { -+ normaliser->max_temp_count = max(normaliser->max_temp_count, ins->declaration.count); - vkd3d_shader_instruction_make_nop(ins); -- normaliser->max_temp_count = max(normaliser->max_temp_count, ins->declaration.count); -+ } - return; - } - -@@ -233,6 +227,7 @@ static void flattener_eliminate_phase_related_dcls(struct hull_flattener *normal - - if (ins->handler_idx == VKD3DSIH_RET) - { -+ normaliser->last_ret_location = ins->location; - vkd3d_shader_instruction_make_nop(ins); - if (locations->count >= ARRAY_SIZE(locations->locations)) - { -@@ -296,7 +291,7 @@ static enum vkd3d_result flattener_flatten_phases(struct hull_flattener *normali - return VKD3D_OK; - } - --void shader_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, -+void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, - enum vkd3d_data_type data_type, unsigned int idx_count) - { - reg->type = reg_type; -@@ -305,17 +300,23 @@ void shader_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_r - reg->data_type = data_type; - reg->idx[0].offset = ~0u; - reg->idx[0].rel_addr = NULL; -+ reg->idx[0].is_in_bounds = false; - reg->idx[1].offset = ~0u; - reg->idx[1].rel_addr = NULL; -+ reg->idx[1].is_in_bounds = false; - reg->idx[2].offset = ~0u; - reg->idx[2].rel_addr = NULL; -+ reg->idx[2].is_in_bounds = false; - reg->idx_count = idx_count; -- reg->immconst_type = VKD3D_IMMCONST_SCALAR; -+ reg->dimension = VSIR_DIMENSION_SCALAR; -+ reg->alignment = 0; - } - --void shader_instruction_init(struct vkd3d_shader_instruction *ins, enum vkd3d_shader_opcode handler_idx) -+void vsir_instruction_init(struct vkd3d_shader_instruction *ins, const struct vkd3d_shader_location *location, -+ enum vkd3d_shader_opcode handler_idx) - { - memset(ins, 0, sizeof(*ins)); -+ ins->location = *location; - ins->handler_idx = handler_idx; - } - -@@ -343,7 +344,7 @@ static enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd - - if (!shader_instruction_array_reserve(&flattener.instructions, flattener.instructions.count + 1)) - return VKD3D_ERROR_OUT_OF_MEMORY; -- shader_instruction_init(&instructions->elements[instructions->count++], VKD3DSIH_RET); -+ vsir_instruction_init(&instructions->elements[instructions->count++], &flattener.last_ret_location, VKD3DSIH_RET); - } - - *src_instructions = flattener.instructions; -@@ -370,7 +371,7 @@ static struct vkd3d_shader_src_param *instruction_array_create_outpointid_param( - if (!(rel_addr = shader_src_param_allocator_get(&instructions->src_params, 1))) - return NULL; - -- shader_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0); -+ vsir_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0); - rel_addr->swizzle = 0; - rel_addr->modifiers = 0; - -@@ -400,11 +401,12 @@ static void shader_dst_param_io_init(struct vkd3d_shader_dst_param *param, const - param->write_mask = e->mask; - param->modifiers = 0; - param->shift = 0; -- shader_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); -+ vsir_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); - } - - static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_point_normaliser *normaliser, -- const struct shader_signature *s, unsigned int input_control_point_count, unsigned int dst) -+ const struct shader_signature *s, unsigned int input_control_point_count, unsigned int dst, -+ const struct vkd3d_shader_location *location) - { - struct vkd3d_shader_instruction *ins; - struct vkd3d_shader_dst_param *param; -@@ -422,7 +424,7 @@ static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_p - normaliser->instructions.count += count; - - ins = &normaliser->instructions.elements[dst]; -- shader_instruction_init(ins, VKD3DSIH_HS_CONTROL_POINT_PHASE); -+ vsir_instruction_init(ins, location, VKD3DSIH_HS_CONTROL_POINT_PHASE); - ins->flags = 1; - ++ins; - -@@ -434,19 +436,20 @@ static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_p - - if (e->sysval_semantic != VKD3D_SHADER_SV_NONE) - { -- shader_instruction_init(ins, VKD3DSIH_DCL_INPUT_SIV); -+ vsir_instruction_init(ins, location, VKD3DSIH_DCL_INPUT_SIV); - param = &ins->declaration.register_semantic.reg; - ins->declaration.register_semantic.sysval_semantic = vkd3d_siv_from_sysval(e->sysval_semantic); - } - else - { -- shader_instruction_init(ins, VKD3DSIH_DCL_INPUT); -+ vsir_instruction_init(ins, location, VKD3DSIH_DCL_INPUT); - param = &ins->declaration.dst; - } - - shader_dst_param_io_init(param, e, VKD3DSPR_INPUT, 2); - param->reg.idx[0].offset = input_control_point_count; -- param->reg.idx[1].offset = i; -+ param->reg.idx[1].offset = e->register_index; -+ param->write_mask = e->mask; - - ++ins; - } -@@ -511,7 +514,7 @@ static enum vkd3d_result instruction_array_normalise_hull_shader_control_point_i - case VKD3DSIH_HS_FORK_PHASE: - case VKD3DSIH_HS_JOIN_PHASE: - ret = control_point_normaliser_emit_hs_input(&normaliser, input_signature, -- input_control_point_count, i); -+ input_control_point_count, i, &ins->location); - *src_instructions = normaliser.instructions; - return ret; - default: -@@ -547,6 +550,8 @@ struct io_normaliser - uint8_t input_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; - uint8_t output_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; - uint8_t pc_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; -+ -+ bool use_vocp; - }; - - static bool io_normaliser_is_in_fork_or_join_phase(const struct io_normaliser *normaliser) -@@ -578,6 +583,12 @@ static unsigned int shader_signature_find_element_for_reg(const struct shader_si - vkd3d_unreachable(); - } - -+struct signature_element *vsir_signature_find_element_for_reg(const struct shader_signature *signature, -+ unsigned int reg_idx, unsigned int write_mask) -+{ -+ return &signature->elements[shader_signature_find_element_for_reg(signature, reg_idx, write_mask)]; -+} -+ - static unsigned int range_map_get_register_count(uint8_t range_map[][VKD3D_VEC4_SIZE], - unsigned int register_idx, unsigned int write_mask) - { -@@ -816,12 +827,6 @@ static bool shader_signature_merge(struct shader_signature *s, uint8_t range_map - return true; - } - --static bool sysval_semantic_is_tess_factor(enum vkd3d_shader_sysval_semantic sysval_semantic) --{ -- return sysval_semantic >= VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE -- && sysval_semantic <= VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN; --} -- - static unsigned int shader_register_normalise_arrayed_addressing(struct vkd3d_shader_register *reg, - unsigned int id_idx, unsigned int register_index) - { -@@ -870,11 +875,13 @@ static bool shader_dst_param_io_normalise(struct vkd3d_shader_dst_param *dst_par - else if (reg->type == VKD3DSPR_OUTPUT || dst_param->reg.type == VKD3DSPR_COLOROUT) - { - signature = normaliser->output_signature; -+ reg->type = VKD3DSPR_OUTPUT; - dcl_params = normaliser->output_dcl_params; - } - else if (dst_param->reg.type == VKD3DSPR_INCONTROLPOINT || dst_param->reg.type == VKD3DSPR_INPUT) - { - signature = normaliser->input_signature; -+ reg->type = VKD3DSPR_INPUT; - dcl_params = normaliser->input_dcl_params; - } - else -@@ -922,7 +929,7 @@ static bool shader_dst_param_io_normalise(struct vkd3d_shader_dst_param *dst_par - id_idx = 1; - } - -- if ((e->register_count > 1 || sysval_semantic_is_tess_factor(e->sysval_semantic))) -+ if ((e->register_count > 1 || vsir_sysval_semantic_is_tess_factor(e->sysval_semantic))) - { - if (is_io_dcl) - { -@@ -974,15 +981,13 @@ static void shader_src_param_io_normalise(struct vkd3d_shader_src_param *src_par - signature = normaliser->patch_constant_signature; - break; - case VKD3DSPR_INCONTROLPOINT: -- if (normaliser->shader_type == VKD3D_SHADER_TYPE_HULL) -- reg->type = VKD3DSPR_INPUT; -+ reg->type = VKD3DSPR_INPUT; - /* fall through */ - case VKD3DSPR_INPUT: - signature = normaliser->input_signature; - break; - case VKD3DSPR_OUTCONTROLPOINT: -- if (normaliser->shader_type == VKD3D_SHADER_TYPE_HULL) -- reg->type = VKD3DSPR_OUTPUT; -+ reg->type = VKD3DSPR_OUTPUT; - /* fall through */ - case VKD3DSPR_OUTPUT: - signature = normaliser->output_signature; -@@ -997,7 +1002,7 @@ static void shader_src_param_io_normalise(struct vkd3d_shader_src_param *src_par - element_idx = shader_signature_find_element_for_reg(signature, reg_idx, write_mask); - - e = &signature->elements[element_idx]; -- if ((e->register_count > 1 || sysval_semantic_is_tess_factor(e->sysval_semantic))) -+ if ((e->register_count > 1 || vsir_sysval_semantic_is_tess_factor(e->sysval_semantic))) - id_idx = shader_register_normalise_arrayed_addressing(reg, id_idx, e->register_index); - reg->idx[id_idx].offset = element_idx; - reg->idx_count = id_idx + 1; -@@ -1014,7 +1019,6 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi - struct io_normaliser *normaliser) - { - struct vkd3d_shader_register *reg; -- bool keep = true; - unsigned int i; - - switch (ins->handler_idx) -@@ -1023,6 +1027,10 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi - if (normaliser->shader_type == VKD3D_SHADER_TYPE_HULL) - { - reg = &ins->declaration.dst.reg; -+ -+ if (reg->type == VKD3DSPR_OUTCONTROLPOINT) -+ normaliser->use_vocp = true; -+ - /* We don't need to keep OUTCONTROLPOINT or PATCHCONST input declarations since their - * equivalents were declared earlier, but INCONTROLPOINT may be the first occurrence. */ - if (reg->type == VKD3DSPR_OUTCONTROLPOINT || reg->type == VKD3DSPR_PATCHCONST) -@@ -1033,15 +1041,16 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi - /* fall through */ - case VKD3DSIH_DCL_INPUT_PS: - case VKD3DSIH_DCL_OUTPUT: -- keep = shader_dst_param_io_normalise(&ins->declaration.dst, true, normaliser); -+ if (!shader_dst_param_io_normalise(&ins->declaration.dst, true, normaliser)) -+ vkd3d_shader_instruction_make_nop(ins); - break; - case VKD3DSIH_DCL_INPUT_SGV: - case VKD3DSIH_DCL_INPUT_SIV: - case VKD3DSIH_DCL_INPUT_PS_SGV: - case VKD3DSIH_DCL_INPUT_PS_SIV: - case VKD3DSIH_DCL_OUTPUT_SIV: -- keep = shader_dst_param_io_normalise(&ins->declaration.register_semantic.reg, true, -- normaliser); -+ if (!shader_dst_param_io_normalise(&ins->declaration.register_semantic.reg, true, normaliser)) -+ vkd3d_shader_instruction_make_nop(ins); - break; - case VKD3DSIH_HS_CONTROL_POINT_PHASE: - case VKD3DSIH_HS_FORK_PHASE: -@@ -1060,29 +1069,24 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi - shader_src_param_io_normalise((struct vkd3d_shader_src_param *)&ins->src[i], normaliser); - break; - } -- -- if (!keep) -- shader_instruction_init(ins, VKD3DSIH_NOP); - } - --static enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_shader_instruction_array *instructions, -- enum vkd3d_shader_type shader_type, struct shader_signature *input_signature, -- struct shader_signature *output_signature, struct shader_signature *patch_constant_signature) -+static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parser *parser) - { -- struct io_normaliser normaliser = {*instructions}; -+ struct io_normaliser normaliser = {parser->instructions}; - struct vkd3d_shader_instruction *ins; - bool has_control_point_phase; - unsigned int i, j; - - normaliser.phase = VKD3DSIH_INVALID; -- normaliser.shader_type = shader_type; -- normaliser.input_signature = input_signature; -- normaliser.output_signature = output_signature; -- normaliser.patch_constant_signature = patch_constant_signature; -+ normaliser.shader_type = parser->shader_version.type; -+ normaliser.input_signature = &parser->shader_desc.input_signature; -+ normaliser.output_signature = &parser->shader_desc.output_signature; -+ normaliser.patch_constant_signature = &parser->shader_desc.patch_constant_signature; - -- for (i = 0, has_control_point_phase = false; i < instructions->count; ++i) -+ for (i = 0, has_control_point_phase = false; i < parser->instructions.count; ++i) - { -- ins = &instructions->elements[i]; -+ ins = &parser->instructions.elements[i]; - - switch (ins->handler_idx) - { -@@ -1121,11 +1125,11 @@ static enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_s - } - } - -- if (!shader_signature_merge(input_signature, normaliser.input_range_map, false) -- || !shader_signature_merge(output_signature, normaliser.output_range_map, false) -- || !shader_signature_merge(patch_constant_signature, normaliser.pc_range_map, true)) -+ if (!shader_signature_merge(&parser->shader_desc.input_signature, normaliser.input_range_map, false) -+ || !shader_signature_merge(&parser->shader_desc.output_signature, normaliser.output_range_map, false) -+ || !shader_signature_merge(&parser->shader_desc.patch_constant_signature, normaliser.pc_range_map, true)) - { -- *instructions = normaliser.instructions; -+ parser->instructions = normaliser.instructions; - return VKD3D_ERROR_OUT_OF_MEMORY; - } - -@@ -1133,7 +1137,8 @@ static enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_s - for (i = 0; i < normaliser.instructions.count; ++i) - shader_instruction_normalise_io_params(&normaliser.instructions.elements[i], &normaliser); - -- *instructions = normaliser.instructions; -+ parser->instructions = normaliser.instructions; -+ parser->shader_desc.use_vocp = normaliser.use_vocp; - return VKD3D_OK; - } - -@@ -1207,7 +1212,7 @@ static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_par - { - param->reg.type = VKD3DSPR_IMMCONST; - param->reg.idx_count = 0; -- param->reg.immconst_type = VKD3D_IMMCONST_VEC4; -+ param->reg.dimension = VSIR_DIMENSION_VEC4; - for (j = 0; j < 4; ++j) - param->reg.u.immconst_uint[j] = normaliser->defs[i].value[j]; - return; -@@ -1260,6 +1265,164 @@ static enum vkd3d_result instruction_array_normalise_flat_constants(struct vkd3d - return VKD3D_OK; - } - -+static void remove_dead_code(struct vkd3d_shader_parser *parser) -+{ -+ size_t i, depth = 0; -+ bool dead = false; -+ -+ for (i = 0; i < parser->instructions.count; ++i) -+ { -+ struct vkd3d_shader_instruction *ins = &parser->instructions.elements[i]; -+ -+ switch (ins->handler_idx) -+ { -+ case VKD3DSIH_IF: -+ case VKD3DSIH_LOOP: -+ case VKD3DSIH_SWITCH: -+ if (dead) -+ { -+ vkd3d_shader_instruction_make_nop(ins); -+ ++depth; -+ } -+ break; -+ -+ case VKD3DSIH_ENDIF: -+ case VKD3DSIH_ENDLOOP: -+ case VKD3DSIH_ENDSWITCH: -+ case VKD3DSIH_ELSE: -+ if (dead) -+ { -+ if (depth > 0) -+ { -+ if (ins->handler_idx != VKD3DSIH_ELSE) -+ --depth; -+ vkd3d_shader_instruction_make_nop(ins); -+ } -+ else -+ { -+ dead = false; -+ } -+ } -+ break; -+ -+ /* `depth' is counted with respect to where the dead code -+ * segment began. So it starts at zero and it signals the -+ * termination of the dead code segment when it would -+ * become negative. */ -+ case VKD3DSIH_BREAK: -+ case VKD3DSIH_RET: -+ case VKD3DSIH_CONTINUE: -+ if (dead) -+ { -+ vkd3d_shader_instruction_make_nop(ins); -+ } -+ else -+ { -+ dead = true; -+ depth = 0; -+ } -+ break; -+ -+ /* If `case' or `default' appears at zero depth, it means -+ * that they are a possible target for the corresponding -+ * switch, so the code is live again. */ -+ case VKD3DSIH_CASE: -+ case VKD3DSIH_DEFAULT: -+ if (dead) -+ { -+ if (depth == 0) -+ dead = false; -+ else -+ vkd3d_shader_instruction_make_nop(ins); -+ } -+ break; -+ -+ /* Phase instructions can only appear in hull shaders and -+ * outside of any block. When a phase returns, control is -+ * moved to the following phase, so they make code live -+ * again. */ -+ case VKD3DSIH_HS_CONTROL_POINT_PHASE: -+ case VKD3DSIH_HS_FORK_PHASE: -+ case VKD3DSIH_HS_JOIN_PHASE: -+ dead = false; -+ break; -+ -+ default: -+ if (dead) -+ vkd3d_shader_instruction_make_nop(ins); -+ break; -+ } -+ } -+} -+ -+static enum vkd3d_result normalise_combined_samplers(struct vkd3d_shader_parser *parser) -+{ -+ unsigned int i; -+ -+ for (i = 0; i < parser->instructions.count; ++i) -+ { -+ struct vkd3d_shader_instruction *ins = &parser->instructions.elements[i]; -+ struct vkd3d_shader_src_param *srcs; -+ -+ switch (ins->handler_idx) -+ { -+ case VKD3DSIH_TEX: -+ if (!(srcs = shader_src_param_allocator_get(&parser->instructions.src_params, 3))) -+ return VKD3D_ERROR_OUT_OF_MEMORY; -+ memset(srcs, 0, sizeof(*srcs) * 3); -+ -+ ins->handler_idx = VKD3DSIH_SAMPLE; -+ -+ srcs[0] = ins->src[0]; -+ -+ srcs[1].reg.type = VKD3DSPR_RESOURCE; -+ srcs[1].reg.idx[0] = ins->src[1].reg.idx[0]; -+ srcs[1].reg.idx[1] = ins->src[1].reg.idx[0]; -+ srcs[1].reg.idx_count = 2; -+ srcs[1].reg.data_type = VKD3D_DATA_RESOURCE; -+ srcs[1].swizzle = VKD3D_SHADER_NO_SWIZZLE; -+ -+ srcs[2].reg.type = VKD3DSPR_SAMPLER; -+ srcs[2].reg.idx[0] = ins->src[1].reg.idx[0]; -+ srcs[2].reg.idx[1] = ins->src[1].reg.idx[0]; -+ srcs[2].reg.idx_count = 2; -+ srcs[2].reg.data_type = VKD3D_DATA_SAMPLER; -+ -+ ins->src = srcs; -+ ins->src_count = 3; -+ break; -+ -+ case VKD3DSIH_TEXBEM: -+ case VKD3DSIH_TEXBEML: -+ case VKD3DSIH_TEXCOORD: -+ case VKD3DSIH_TEXDEPTH: -+ case VKD3DSIH_TEXDP3: -+ case VKD3DSIH_TEXDP3TEX: -+ case VKD3DSIH_TEXLDD: -+ case VKD3DSIH_TEXLDL: -+ case VKD3DSIH_TEXM3x2PAD: -+ case VKD3DSIH_TEXM3x2TEX: -+ case VKD3DSIH_TEXM3x3DIFF: -+ case VKD3DSIH_TEXM3x3PAD: -+ case VKD3DSIH_TEXM3x3SPEC: -+ case VKD3DSIH_TEXM3x3TEX: -+ case VKD3DSIH_TEXM3x3VSPEC: -+ case VKD3DSIH_TEXREG2AR: -+ case VKD3DSIH_TEXREG2GB: -+ case VKD3DSIH_TEXREG2RGB: -+ vkd3d_shader_parser_error(parser, VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED, -+ "Aborting due to not yet implemented feature: " -+ "Combined sampler instruction %#x.", ins->handler_idx); -+ return VKD3D_ERROR_NOT_IMPLEMENTED; -+ -+ default: -+ break; -+ } -+ } -+ -+ return VKD3D_OK; -+} -+ - enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, - const struct vkd3d_shader_compile_info *compile_info) - { -@@ -1280,15 +1443,366 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, - &parser->shader_desc.input_signature); - } - if (result >= 0) -- result = instruction_array_normalise_io_registers(instructions, parser->shader_version.type, -- &parser->shader_desc.input_signature, &parser->shader_desc.output_signature, -- &parser->shader_desc.patch_constant_signature); -+ result = shader_normalise_io_registers(parser); - - if (result >= 0) - result = instruction_array_normalise_flat_constants(parser); - -+ if (result >= 0) -+ remove_dead_code(parser); -+ -+ if (result >= 0) -+ result = normalise_combined_samplers(parser); -+ - if (result >= 0 && TRACE_ON()) - vkd3d_shader_trace(instructions, &parser->shader_version); - -+ if (result >= 0 && !parser->failed) -+ vsir_validate(parser); -+ -+ if (result >= 0 && parser->failed) -+ result = VKD3D_ERROR_INVALID_SHADER; -+ - return result; - } -+ -+struct validation_context -+{ -+ struct vkd3d_shader_parser *parser; -+ size_t instruction_idx; -+ bool dcl_temps_found; -+ unsigned int temp_count; -+ enum vkd3d_shader_opcode phase; -+ -+ enum vkd3d_shader_opcode *blocks; -+ size_t depth; -+ size_t blocks_capacity; -+}; -+ -+static void VKD3D_PRINTF_FUNC(3, 4) validator_error(struct validation_context *ctx, -+ enum vkd3d_shader_error error, const char *format, ...) -+{ -+ struct vkd3d_string_buffer buf; -+ va_list args; -+ -+ vkd3d_string_buffer_init(&buf); -+ -+ va_start(args, format); -+ vkd3d_string_buffer_vprintf(&buf, format, args); -+ va_end(args); -+ -+ vkd3d_shader_parser_error(ctx->parser, error, "instruction %zu: %s", ctx->instruction_idx + 1, buf.buffer); -+ ERR("VSIR validation error: instruction %zu: %s\n", ctx->instruction_idx + 1, buf.buffer); -+ -+ vkd3d_string_buffer_cleanup(&buf); -+} -+ -+static void vsir_validate_src_param(struct validation_context *ctx, -+ const struct vkd3d_shader_src_param *src); -+ -+static void vsir_validate_register(struct validation_context *ctx, -+ const struct vkd3d_shader_register *reg) -+{ -+ unsigned int i, temp_count = ctx->temp_count; -+ -+ /* SM1-3 shaders do not include a DCL_TEMPS instruction. */ -+ if (ctx->parser->shader_version.major <= 3) -+ temp_count = ctx->parser->shader_desc.temp_count; -+ -+ if (reg->type >= VKD3DSPR_COUNT) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_REGISTER_TYPE, "Invalid register type %#x.", -+ reg->type); -+ -+ if (reg->precision >= VKD3D_SHADER_REGISTER_PRECISION_COUNT) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_PRECISION, "Invalid register precision %#x.", -+ reg->precision); -+ -+ if (reg->data_type >= VKD3D_DATA_COUNT) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DATA_TYPE, "Invalid register data type %#x.", -+ reg->data_type); -+ -+ if (reg->dimension >= VSIR_DIMENSION_COUNT) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DIMENSION, "Invalid register dimension %#x.", -+ reg->dimension); -+ -+ if (reg->idx_count > ARRAY_SIZE(reg->idx)) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT, "Invalid register index count %u.", -+ reg->idx_count); -+ -+ for (i = 0; i < min(reg->idx_count, ARRAY_SIZE(reg->idx)); ++i) -+ { -+ const struct vkd3d_shader_src_param *param = reg->idx[i].rel_addr; -+ if (reg->idx[i].rel_addr) -+ vsir_validate_src_param(ctx, param); -+ } -+ -+ switch (reg->type) -+ { -+ case VKD3DSPR_TEMP: -+ if (reg->idx_count != 1) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT, "Invalid index count %u for a TEMP register.", -+ reg->idx_count); -+ -+ if (reg->idx_count >= 1 && reg->idx[0].rel_addr) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX, "Non-NULL relative address for a TEMP register."); -+ -+ if (reg->idx_count >= 1 && reg->idx[0].offset >= temp_count) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX, "TEMP register index %u exceeds the maximum count %u.", -+ reg->idx[0].offset, temp_count); -+ break; -+ -+ case VKD3DSPR_NULL: -+ if (reg->idx_count != 0) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT, "Invalid index count %u for a NULL register.", -+ reg->idx_count); -+ break; -+ -+ case VKD3DSPR_IMMCONST: -+ if (reg->idx_count != 0) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT, "Invalid index count %u for a IMMCONST register.", -+ reg->idx_count); -+ break; -+ -+ case VKD3DSPR_IMMCONST64: -+ if (reg->idx_count != 0) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT, "Invalid index count %u for a IMMCONST64 register.", -+ reg->idx_count); -+ break; -+ -+ default: -+ break; -+ } -+} -+ -+static void vsir_validate_dst_param(struct validation_context *ctx, -+ const struct vkd3d_shader_dst_param *dst) -+{ -+ vsir_validate_register(ctx, &dst->reg); -+ -+ if (dst->write_mask & ~VKD3DSP_WRITEMASK_ALL) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_WRITE_MASK, "Destination has invalid write mask %#x.", -+ dst->write_mask); -+ -+ if (dst->modifiers & ~VKD3DSPDM_MASK) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_MODIFIERS, "Destination has invalid modifiers %#x.", -+ dst->modifiers); -+ -+ switch (dst->shift) -+ { -+ case 0: -+ case 1: -+ case 2: -+ case 3: -+ case 13: -+ case 14: -+ case 15: -+ break; -+ -+ default: -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_SHIFT, "Destination has invalid shift %#x.", -+ dst->shift); -+ } -+} -+ -+static void vsir_validate_src_param(struct validation_context *ctx, -+ const struct vkd3d_shader_src_param *src) -+{ -+ vsir_validate_register(ctx, &src->reg); -+ -+ if (src->swizzle & ~0x03030303u) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_SWIZZLE, "Source has invalid swizzle %#x.", -+ src->swizzle); -+ -+ if (src->modifiers >= VKD3DSPSM_COUNT) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_MODIFIERS, "Source has invalid modifiers %#x.", -+ src->modifiers); -+} -+ -+static void vsir_validate_dst_count(struct validation_context *ctx, -+ const struct vkd3d_shader_instruction *instruction, unsigned int count) -+{ -+ if (instruction->dst_count != count) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DEST_COUNT, -+ "Invalid destination count %u for an instruction of type %#x, expected %u.", -+ instruction->dst_count, instruction->handler_idx, count); -+} -+ -+static void vsir_validate_src_count(struct validation_context *ctx, -+ const struct vkd3d_shader_instruction *instruction, unsigned int count) -+{ -+ if (instruction->src_count != count) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_SOURCE_COUNT, -+ "Invalid source count %u for an instruction of type %#x, expected %u.", -+ instruction->src_count, instruction->handler_idx, count); -+} -+ -+static void vsir_validate_instruction(struct validation_context *ctx) -+{ -+ const struct vkd3d_shader_instruction *instruction = &ctx->parser->instructions.elements[ctx->instruction_idx]; -+ size_t i; -+ -+ ctx->parser->location = instruction->location; -+ -+ for (i = 0; i < instruction->dst_count; ++i) -+ vsir_validate_dst_param(ctx, &instruction->dst[i]); -+ -+ for (i = 0; i < instruction->src_count; ++i) -+ vsir_validate_src_param(ctx, &instruction->src[i]); -+ -+ if (instruction->handler_idx >= VKD3DSIH_INVALID) -+ { -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, "Invalid instruction handler %#x.", -+ instruction->handler_idx); -+ } -+ -+ switch (instruction->handler_idx) -+ { -+ case VKD3DSIH_HS_DECLS: -+ case VKD3DSIH_HS_CONTROL_POINT_PHASE: -+ case VKD3DSIH_HS_FORK_PHASE: -+ case VKD3DSIH_HS_JOIN_PHASE: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->parser->shader_version.type != VKD3D_SHADER_TYPE_HULL) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, "Phase instruction %#x is only valid in a hull shader.", -+ instruction->handler_idx); -+ if (ctx->depth != 0) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "Phase instruction %#x must appear to top level.", -+ instruction->handler_idx); -+ ctx->phase = instruction->handler_idx; -+ ctx->dcl_temps_found = false; -+ ctx->temp_count = 0; -+ return; -+ -+ default: -+ break; -+ } -+ -+ if (ctx->parser->shader_version.type == VKD3D_SHADER_TYPE_HULL && -+ ctx->phase == VKD3DSIH_INVALID) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, "Instruction %#x appear before any phase instruction in a hull shader.", -+ instruction->handler_idx); -+ -+ switch (instruction->handler_idx) -+ { -+ case VKD3DSIH_DCL_TEMPS: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->dcl_temps_found) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_DUPLICATE_DCL_TEMPS, "Duplicate DCL_TEMPS instruction."); -+ if (instruction->declaration.count > ctx->parser->shader_desc.temp_count) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DCL_TEMPS, "Invalid DCL_TEMPS count %u, expected at most %u.", -+ instruction->declaration.count, ctx->parser->shader_desc.temp_count); -+ ctx->dcl_temps_found = true; -+ ctx->temp_count = instruction->declaration.count; -+ break; -+ -+ case VKD3DSIH_IF: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 1); -+ if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) -+ return; -+ ctx->blocks[ctx->depth++] = instruction->handler_idx; -+ break; -+ -+ case VKD3DSIH_IFC: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 2); -+ if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) -+ return; -+ ctx->blocks[ctx->depth++] = VKD3DSIH_IF; -+ break; -+ -+ case VKD3DSIH_ELSE: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->depth == 0 || ctx->blocks[ctx->depth - 1] != VKD3DSIH_IF) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "ELSE instruction doesn't terminate IF block."); -+ else -+ ctx->blocks[ctx->depth - 1] = instruction->handler_idx; -+ break; -+ -+ case VKD3DSIH_ENDIF: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->depth == 0 || (ctx->blocks[ctx->depth - 1] != VKD3DSIH_IF && ctx->blocks[ctx->depth - 1] != VKD3DSIH_ELSE)) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "ENDIF instruction doesn't terminate IF/ELSE block."); -+ else -+ --ctx->depth; -+ break; -+ -+ case VKD3DSIH_LOOP: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, ctx->parser->shader_version.major <= 3 ? 2 : 0); -+ if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) -+ return; -+ ctx->blocks[ctx->depth++] = instruction->handler_idx; -+ break; -+ -+ case VKD3DSIH_ENDLOOP: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->depth == 0 || ctx->blocks[ctx->depth - 1] != VKD3DSIH_LOOP) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "ENDLOOP instruction doesn't terminate LOOP block."); -+ else -+ --ctx->depth; -+ break; -+ -+ case VKD3DSIH_REP: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 1); -+ if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) -+ return; -+ ctx->blocks[ctx->depth++] = instruction->handler_idx; -+ break; -+ -+ case VKD3DSIH_ENDREP: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->depth == 0 || ctx->blocks[ctx->depth - 1] != VKD3DSIH_REP) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "ENDREP instruction doesn't terminate REP block."); -+ else -+ --ctx->depth; -+ break; -+ -+ case VKD3DSIH_SWITCH: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 1); -+ if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) -+ return; -+ ctx->blocks[ctx->depth++] = instruction->handler_idx; -+ break; -+ -+ case VKD3DSIH_ENDSWITCH: -+ vsir_validate_dst_count(ctx, instruction, 0); -+ vsir_validate_src_count(ctx, instruction, 0); -+ if (ctx->depth == 0 || ctx->blocks[ctx->depth - 1] != VKD3DSIH_SWITCH) -+ validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "ENDSWITCH instruction doesn't terminate SWITCH block."); -+ else -+ --ctx->depth; -+ break; -+ -+ default: -+ break; -+ } -+} -+ -+void vsir_validate(struct vkd3d_shader_parser *parser) -+{ -+ struct validation_context ctx = -+ { -+ .parser = parser, -+ .phase = VKD3DSIH_INVALID, -+ }; -+ -+ if (!(parser->config_flags & VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION)) -+ return; -+ -+ for (ctx.instruction_idx = 0; ctx.instruction_idx < parser->instructions.count; ++ctx.instruction_idx) -+ vsir_validate_instruction(&ctx); -+ -+ if (ctx.depth != 0) -+ validator_error(&ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING, "%zu nested blocks were not closed.", ctx.depth); -+ -+ free(ctx.blocks); -+} -diff --git a/libs/vkd3d/libs/vkd3d-shader/preproc.h b/libs/vkd3d/libs/vkd3d-shader/preproc.h -index 4860cf5f90e..e1cb75e177c 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/preproc.h -+++ b/libs/vkd3d/libs/vkd3d-shader/preproc.h -@@ -22,7 +22,7 @@ - #define __VKD3D_SHADER_PREPROC_H - - #include "vkd3d_shader_private.h" --#include "wine/rbtree.h" -+#include "rbtree.h" - - struct preproc_if_state - { -diff --git a/libs/vkd3d/libs/vkd3d-shader/spirv.c b/libs/vkd3d/libs/vkd3d-shader/spirv.c -index 638764b81bc..be149a0cf34 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/spirv.c -+++ b/libs/vkd3d/libs/vkd3d-shader/spirv.c -@@ -18,7 +18,7 @@ - */ - - #include "vkd3d_shader_private.h" --#include "wine/rbtree.h" -+#include "rbtree.h" - - #include - #include -@@ -173,7 +173,13 @@ enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed(enum vkd3d - { - switch (sysval) - { -+ case VKD3D_SHADER_SV_COVERAGE: -+ case VKD3D_SHADER_SV_DEPTH: -+ case VKD3D_SHADER_SV_DEPTH_GREATER_EQUAL: -+ case VKD3D_SHADER_SV_DEPTH_LESS_EQUAL: - case VKD3D_SHADER_SV_NONE: -+ case VKD3D_SHADER_SV_STENCIL_REF: -+ case VKD3D_SHADER_SV_TARGET: - return VKD3D_SIV_NONE; - case VKD3D_SHADER_SV_POSITION: - return VKD3D_SIV_POSITION; -@@ -181,6 +187,16 @@ enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed(enum vkd3d - return VKD3D_SIV_CLIP_DISTANCE; - case VKD3D_SHADER_SV_CULL_DISTANCE: - return VKD3D_SIV_CULL_DISTANCE; -+ case VKD3D_SHADER_SV_INSTANCE_ID: -+ return VKD3D_SIV_INSTANCE_ID; -+ case VKD3D_SHADER_SV_IS_FRONT_FACE: -+ return VKD3D_SIV_IS_FRONT_FACE; -+ case VKD3D_SHADER_SV_PRIMITIVE_ID: -+ return VKD3D_SIV_PRIMITIVE_ID; -+ case VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX: -+ return VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX; -+ case VKD3D_SHADER_SV_SAMPLE_INDEX: -+ return VKD3D_SIV_SAMPLE_INDEX; - case VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE: - return VKD3D_SIV_QUAD_U0_TESS_FACTOR + index; - case VKD3D_SHADER_SV_TESS_FACTOR_QUADINT: -@@ -193,6 +209,10 @@ enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed(enum vkd3d - return VKD3D_SIV_LINE_DETAIL_TESS_FACTOR; - case VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN: - return VKD3D_SIV_LINE_DENSITY_TESS_FACTOR; -+ case VKD3D_SHADER_SV_VERTEX_ID: -+ return VKD3D_SIV_VERTEX_ID; -+ case VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX: -+ return VKD3D_SIV_VIEWPORT_ARRAY_INDEX; - default: - FIXME("Unhandled sysval %#x, index %u.\n", sysval, index); - return VKD3D_SIV_NONE; -@@ -1130,6 +1150,20 @@ static uint32_t vkd3d_spirv_get_op_type_pointer(struct vkd3d_spirv_builder *buil - vkd3d_spirv_build_op_type_pointer); - } - -+static uint32_t vkd3d_spirv_build_op_constant_bool(struct vkd3d_spirv_builder *builder, -+ uint32_t result_type, uint32_t value) -+{ -+ return vkd3d_spirv_build_op_tr(builder, &builder->global_stream, -+ value ? SpvOpConstantTrue : SpvOpConstantFalse, result_type); -+} -+ -+static uint32_t vkd3d_spirv_get_op_constant_bool(struct vkd3d_spirv_builder *builder, -+ uint32_t result_type, uint32_t value) -+{ -+ return vkd3d_spirv_build_once2(builder, value ? SpvOpConstantTrue : SpvOpConstantFalse, result_type, value, -+ vkd3d_spirv_build_op_constant_bool); -+} -+ - /* Types larger than 32-bits are not supported. */ - static uint32_t vkd3d_spirv_build_op_constant(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint32_t value) -@@ -1215,10 +1249,14 @@ static uint32_t vkd3d_spirv_build_op_function_call(struct vkd3d_spirv_builder *b - SpvOpFunctionCall, result_type, function_id, arguments, argument_count); - } - --static uint32_t vkd3d_spirv_build_op_undef(struct vkd3d_spirv_builder *builder, -- struct vkd3d_spirv_stream *stream, uint32_t type_id) -+static uint32_t vkd3d_spirv_build_op_undef(struct vkd3d_spirv_builder *builder, uint32_t type_id) -+{ -+ return vkd3d_spirv_build_op_tr(builder, &builder->global_stream, SpvOpUndef, type_id); -+} -+ -+static uint32_t vkd3d_spirv_get_op_undef(struct vkd3d_spirv_builder *builder, uint32_t type_id) - { -- return vkd3d_spirv_build_op_tr(builder, stream, SpvOpUndef, type_id); -+ return vkd3d_spirv_build_once1(builder, SpvOpUndef, type_id, vkd3d_spirv_build_op_undef); - } - - static uint32_t vkd3d_spirv_build_op_access_chain(struct vkd3d_spirv_builder *builder, -@@ -1407,13 +1445,6 @@ static uint32_t vkd3d_spirv_build_op_udiv(struct vkd3d_spirv_builder *builder, - SpvOpUDiv, result_type, operand0, operand1); - } - --static uint32_t vkd3d_spirv_build_op_umod(struct vkd3d_spirv_builder *builder, -- uint32_t result_type, uint32_t operand0, uint32_t operand1) --{ -- return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, -- SpvOpUMod, result_type, operand0, operand1); --} -- - static uint32_t vkd3d_spirv_build_op_isub(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint32_t operand0, uint32_t operand1) - { -@@ -1710,6 +1741,15 @@ static uint32_t vkd3d_spirv_build_op_glsl_std450_cos(struct vkd3d_spirv_builder - return vkd3d_spirv_build_op_glsl_std450_tr1(builder, GLSLstd450Cos, result_type, operand); - } - -+static uint32_t vkd3d_spirv_build_op_glsl_std450_max(struct vkd3d_spirv_builder *builder, -+ uint32_t result_type, uint32_t x, uint32_t y) -+{ -+ uint32_t glsl_std450_id = vkd3d_spirv_get_glsl_std450_instr_set(builder); -+ uint32_t operands[] = {x, y}; -+ return vkd3d_spirv_build_op_ext_inst(builder, result_type, glsl_std450_id, -+ GLSLstd450NMax, operands, ARRAY_SIZE(operands)); -+} -+ - static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint32_t x, uint32_t min, uint32_t max) - { -@@ -1776,6 +1816,8 @@ static uint32_t vkd3d_spirv_get_type_id_for_data_type(struct vkd3d_spirv_builder - break; - case VKD3D_DATA_DOUBLE: - return vkd3d_spirv_get_op_type_float(builder, 64); -+ case VKD3D_DATA_BOOL: -+ return vkd3d_spirv_get_op_type_bool(builder); - default: - FIXME("Unhandled data type %#x.\n", data_type); - return 0; -@@ -2099,14 +2141,22 @@ static void vkd3d_symbol_make_register(struct vkd3d_symbol *symbol, - symbol->type = VKD3D_SYMBOL_REGISTER; - memset(&symbol->key, 0, sizeof(symbol->key)); - symbol->key.reg.type = reg->type; -- if (vkd3d_shader_register_is_input(reg) || vkd3d_shader_register_is_output(reg) -- || vkd3d_shader_register_is_patch_constant(reg)) -+ -+ switch (reg->type) - { -- symbol->key.reg.idx = reg->idx_count ? reg->idx[reg->idx_count - 1].offset : ~0u; -- assert(!reg->idx_count || symbol->key.reg.idx != ~0u); -+ case VKD3DSPR_INPUT: -+ case VKD3DSPR_OUTPUT: -+ case VKD3DSPR_PATCHCONST: -+ symbol->key.reg.idx = reg->idx_count ? reg->idx[reg->idx_count - 1].offset : ~0u; -+ assert(!reg->idx_count || symbol->key.reg.idx != ~0u); -+ break; -+ -+ case VKD3DSPR_IMMCONSTBUFFER: -+ break; -+ -+ default: -+ symbol->key.reg.idx = reg->idx_count ? reg->idx[0].offset : ~0u; - } -- else if (reg->type != VKD3DSPR_IMMCONSTBUFFER) -- symbol->key.reg.idx = reg->idx_count ? reg->idx[0].offset : ~0u; - } - - static void vkd3d_symbol_set_register_info(struct vkd3d_symbol *symbol, -@@ -2251,6 +2301,12 @@ struct vkd3d_hull_shader_variables - uint32_t patch_constants_id; - }; - -+struct ssa_register_info -+{ -+ enum vkd3d_data_type data_type; -+ uint32_t id; -+}; -+ - struct spirv_compiler - { - struct vkd3d_spirv_builder spirv_builder; -@@ -2262,6 +2318,7 @@ struct spirv_compiler - bool strip_debug; - bool ssbo_uavs; - bool uav_read_without_format; -+ SpvExecutionMode fragment_coordinate_origin; - - struct rb_tree symbol_table; - uint32_t temp_id; -@@ -2299,7 +2356,6 @@ struct spirv_compiler - uint32_t array_element_mask; - } *output_info; - uint32_t private_output_variable[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ -- uint32_t private_output_variable_array_idx[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ - uint32_t private_output_variable_write_mask[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ - uint32_t epilogue_function_id; - -@@ -2323,6 +2379,9 @@ struct spirv_compiler - bool write_tess_geom_point_size; - - struct vkd3d_string_buffer_cache string_buffers; -+ -+ struct ssa_register_info *ssa_register_info; -+ unsigned int ssa_register_count; - }; - - static bool is_in_default_phase(const struct spirv_compiler *compiler) -@@ -2370,6 +2429,8 @@ static void spirv_compiler_destroy(struct spirv_compiler *compiler) - shader_signature_cleanup(&compiler->output_signature); - shader_signature_cleanup(&compiler->patch_constant_signature); - -+ vkd3d_free(compiler->ssa_register_info); -+ - vkd3d_free(compiler); - } - -@@ -2422,6 +2483,7 @@ static struct spirv_compiler *spirv_compiler_create(const struct vkd3d_shader_ve - compiler->formatting = VKD3D_SHADER_COMPILE_OPTION_FORMATTING_INDENT - | VKD3D_SHADER_COMPILE_OPTION_FORMATTING_HEADER; - compiler->write_tess_geom_point_size = true; -+ compiler->fragment_coordinate_origin = SpvExecutionModeOriginUpperLeft; - - for (i = 0; i < compile_info->option_count; ++i) - { -@@ -2446,9 +2508,6 @@ static struct spirv_compiler *spirv_compiler_create(const struct vkd3d_shader_ve - compiler->formatting = option->value; - break; - -- default: -- WARN("Ignoring unrecognised option %#x with value %#x.\n", option->name, option->value); -- - case VKD3D_SHADER_COMPILE_OPTION_API_VERSION: - break; - -@@ -2464,6 +2523,19 @@ static struct spirv_compiler *spirv_compiler_create(const struct vkd3d_shader_ve - case VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE: - compiler->write_tess_geom_point_size = option->value; - break; -+ -+ case VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN: -+ if (option->value == VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_UPPER_LEFT) -+ compiler->fragment_coordinate_origin = SpvExecutionModeOriginUpperLeft; -+ else if (option->value == VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_LOWER_LEFT) -+ compiler->fragment_coordinate_origin = SpvExecutionModeOriginLowerLeft; -+ else -+ WARN("Ignoring unrecognised value %#x for option %#x.\n", option->value, option->name); -+ break; -+ -+ default: -+ WARN("Ignoring unrecognised option %#x with value %#x.\n", option->name, option->value); -+ break; - } - } - -@@ -2848,9 +2920,16 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, - case VKD3D_SHADER_COMPONENT_INT: - case VKD3D_SHADER_COMPONENT_FLOAT: - break; -+ case VKD3D_SHADER_COMPONENT_BOOL: -+ if (component_count == 1) -+ return vkd3d_spirv_get_op_constant_bool(builder, type_id, *values); -+ FIXME("Unsupported vector of bool.\n"); -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_TYPE, -+ "Vectors of bool type are not supported."); -+ return vkd3d_spirv_get_op_undef(builder, type_id); - default: - FIXME("Unhandled component_type %#x.\n", component_type); -- return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); -+ return vkd3d_spirv_get_op_undef(builder, type_id); - } - - if (component_count == 1) -@@ -2879,7 +2958,7 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, - if (component_type != VKD3D_SHADER_COMPONENT_DOUBLE) - { - FIXME("Unhandled component_type %#x.\n", component_type); -- return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); -+ return vkd3d_spirv_get_op_undef(builder, type_id); - } - - if (component_count == 1) -@@ -2975,13 +3054,12 @@ static bool spirv_compiler_get_register_name(char *buffer, unsigned int buffer_s - case VKD3DSPR_INPUT: - snprintf(buffer, buffer_size, "v%u", idx); - break; -- case VKD3DSPR_INCONTROLPOINT: -- snprintf(buffer, buffer_size, "vicp%u", idx); -- break; - case VKD3DSPR_OUTPUT: -- case VKD3DSPR_COLOROUT: - snprintf(buffer, buffer_size, "o%u", idx); - break; -+ case VKD3DSPR_COLOROUT: -+ snprintf(buffer, buffer_size, "oC%u", idx); -+ break; - case VKD3DSPR_DEPTHOUT: - case VKD3DSPR_DEPTHOUTGE: - case VKD3DSPR_DEPTHOUTLE: -@@ -3318,21 +3396,6 @@ static bool spirv_compiler_get_register_info(const struct spirv_compiler *compil - return true; - } - --static bool register_is_descriptor(const struct vkd3d_shader_register *reg) --{ -- switch (reg->type) -- { -- case VKD3DSPR_SAMPLER: -- case VKD3DSPR_RESOURCE: -- case VKD3DSPR_CONSTBUFFER: -- case VKD3DSPR_UAV: -- return true; -- -- default: -- return false; -- } --} -- - static bool spirv_compiler_enable_descriptor_indexing(struct spirv_compiler *compiler, - enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_resource_type resource_type) - { -@@ -3458,10 +3521,13 @@ static void spirv_compiler_emit_dereference_register(struct spirv_compiler *comp - FIXME("Relative addressing not implemented.\n"); - - /* Handle arrayed registers, e.g. v[3][0]. */ -- if (reg->idx_count > 1 && !register_is_descriptor(reg)) -+ if (reg->idx_count > 1 && !vsir_register_is_descriptor(reg)) - indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, ®->idx[0]); - } - -+ if (reg->alignment) -+ WARN("Ignoring alignment %u.\n", reg->alignment); -+ - if (index_count) - { - component_count = vkd3d_write_mask_component_count(register_info->write_mask); -@@ -3496,6 +3562,14 @@ static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask, - return vkd3d_compact_swizzle(VKD3D_SHADER_NO_SWIZZLE, dst_write_mask) == vkd3d_compact_swizzle(swizzle, write_mask); - } - -+static bool vkd3d_swizzle_is_scalar(unsigned int swizzle) -+{ -+ unsigned int component_idx = vkd3d_swizzle_get_component(swizzle, 0); -+ return vkd3d_swizzle_get_component(swizzle, 1) == component_idx -+ && vkd3d_swizzle_get_component(swizzle, 2) == component_idx -+ && vkd3d_swizzle_get_component(swizzle, 3) == component_idx; -+} -+ - static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler, - uint32_t val_id, unsigned int val_write_mask, enum vkd3d_shader_component_type component_type, - unsigned int swizzle, unsigned int write_mask) -@@ -3576,7 +3650,7 @@ static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compile - - assert(reg->type == VKD3DSPR_IMMCONST); - -- if (reg->immconst_type == VKD3D_IMMCONST_SCALAR) -+ if (reg->dimension == VSIR_DIMENSION_SCALAR) - { - for (i = 0; i < component_count; ++i) - values[i] = *reg->u.immconst_uint; -@@ -3603,7 +3677,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi - - assert(reg->type == VKD3DSPR_IMMCONST64); - -- if (reg->immconst_type == VKD3D_IMMCONST_SCALAR) -+ if (reg->dimension == VSIR_DIMENSION_SCALAR) - { - for (i = 0; i < component_count; ++i) - values[i] = *reg->u.immconst_uint64; -@@ -3631,7 +3705,7 @@ static uint32_t spirv_compiler_emit_load_undef(struct spirv_compiler *compiler, - assert(reg->type == VKD3DSPR_UNDEF); - - type_id = vkd3d_spirv_get_type_id_for_data_type(builder, reg->data_type, component_count); -- return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); -+ return vkd3d_spirv_get_op_undef(builder, type_id); - } - - static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, -@@ -3682,6 +3756,55 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, - return val_id; - } - -+static const struct ssa_register_info *spirv_compiler_get_ssa_register_info(const struct spirv_compiler *compiler, -+ const struct vkd3d_shader_register *reg) -+{ -+ assert(reg->idx[0].offset < compiler->ssa_register_count); -+ assert(reg->idx_count == 1); -+ return &compiler->ssa_register_info[reg->idx[0].offset]; -+} -+ -+static void spirv_compiler_set_ssa_register_info(const struct spirv_compiler *compiler, -+ const struct vkd3d_shader_register *reg, uint32_t val_id) -+{ -+ unsigned int i = reg->idx[0].offset; -+ assert(i < compiler->ssa_register_count); -+ compiler->ssa_register_info[i].data_type = reg->data_type; -+ compiler->ssa_register_info[i].id = val_id; -+} -+ -+static uint32_t spirv_compiler_emit_load_ssa_reg(struct spirv_compiler *compiler, -+ const struct vkd3d_shader_register *reg, enum vkd3d_shader_component_type component_type, -+ unsigned int swizzle) -+{ -+ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -+ enum vkd3d_shader_component_type reg_component_type; -+ const struct ssa_register_info *ssa; -+ unsigned int component_idx; -+ uint32_t type_id, val_id; -+ -+ ssa = spirv_compiler_get_ssa_register_info(compiler, reg); -+ val_id = ssa->id; -+ assert(val_id); -+ assert(vkd3d_swizzle_is_scalar(swizzle)); -+ -+ if (reg->dimension == VSIR_DIMENSION_SCALAR) -+ { -+ reg_component_type = vkd3d_component_type_from_data_type(ssa->data_type); -+ if (component_type != reg_component_type) -+ { -+ type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); -+ val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); -+ } -+ -+ return val_id; -+ } -+ -+ type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); -+ component_idx = vkd3d_swizzle_get_component(swizzle, 0); -+ return vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx); -+} -+ - static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, - const struct vkd3d_shader_register *reg, DWORD swizzle, DWORD write_mask) - { -@@ -3701,10 +3824,14 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, - - component_count = vkd3d_write_mask_component_count(write_mask); - component_type = vkd3d_component_type_from_data_type(reg->data_type); -+ -+ if (reg->type == VKD3DSPR_SSA) -+ return spirv_compiler_emit_load_ssa_reg(compiler, reg, component_type, swizzle); -+ - if (!spirv_compiler_get_register_info(compiler, reg, ®_info)) - { - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); -- return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); -+ return vkd3d_spirv_get_op_undef(builder, type_id); - } - assert(reg_info.component_type != VKD3D_SHADER_COMPONENT_DOUBLE); - spirv_compiler_emit_dereference_register(compiler, reg, ®_info); -@@ -3777,7 +3904,7 @@ static uint32_t spirv_compiler_emit_neg(struct spirv_compiler *compiler, - type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask); - if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE) - return vkd3d_spirv_build_op_fnegate(builder, type_id, val_id); -- else if (reg->data_type == VKD3D_DATA_INT) -+ else if (reg->data_type == VKD3D_DATA_INT || reg->data_type == VKD3D_DATA_UINT) - return vkd3d_spirv_build_op_snegate(builder, type_id, val_id); - - FIXME("Unhandled data type %#x.\n", reg->data_type); -@@ -3912,6 +4039,12 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, - - assert(!register_is_constant_or_undef(reg)); - -+ if (reg->type == VKD3DSPR_SSA) -+ { -+ spirv_compiler_set_ssa_register_info(compiler, reg, val_id); -+ return; -+ } -+ - if (!spirv_compiler_get_register_info(compiler, reg, ®_info)) - return; - spirv_compiler_emit_dereference_register(compiler, reg, ®_info); -@@ -4108,17 +4241,41 @@ static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, - } - - static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, -- unsigned int component_count, uint32_t val_id) -+ unsigned int component_count, uint32_t val_id, bool signedness) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id, true_id, false_id; - -- true_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count); -+ true_id = spirv_compiler_get_constant_uint_vector(compiler, signedness ? 0xffffffff : 1, component_count); - false_id = spirv_compiler_get_constant_uint_vector(compiler, 0, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count); - return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); - } - -+static uint32_t spirv_compiler_emit_bool_to_float(struct spirv_compiler *compiler, -+ unsigned int component_count, uint32_t val_id, bool signedness) -+{ -+ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -+ uint32_t type_id, true_id, false_id; -+ -+ true_id = spirv_compiler_get_constant_float_vector(compiler, signedness ? -1.0f : 1.0f, component_count); -+ false_id = spirv_compiler_get_constant_float_vector(compiler, 0.0f, component_count); -+ type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count); -+ return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -+} -+ -+static uint32_t spirv_compiler_emit_bool_to_double(struct spirv_compiler *compiler, -+ unsigned int component_count, uint32_t val_id, bool signedness) -+{ -+ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -+ uint32_t type_id, true_id, false_id; -+ -+ true_id = spirv_compiler_get_constant_double_vector(compiler, signedness ? -1.0 : 1.0, component_count); -+ false_id = spirv_compiler_get_constant_double_vector(compiler, 0.0, component_count); -+ type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_DOUBLE, component_count); -+ return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -+} -+ - typedef uint32_t (*vkd3d_spirv_builtin_fixup_pfn)(struct spirv_compiler *compiler, - uint32_t val_id); - -@@ -4161,7 +4318,7 @@ static uint32_t sv_instance_id_fixup(struct spirv_compiler *compiler, - static uint32_t sv_front_face_fixup(struct spirv_compiler *compiler, - uint32_t front_facing_id) - { -- return spirv_compiler_emit_bool_to_int(compiler, 1, front_facing_id); -+ return spirv_compiler_emit_bool_to_int(compiler, 1, front_facing_id, true); - } - - /* frag_coord.w = 1.0f / frag_coord.w */ -@@ -4195,47 +4352,41 @@ struct vkd3d_spirv_builtin - */ - static const struct - { -- enum vkd3d_shader_input_sysval_semantic sysval; -+ enum vkd3d_shader_sysval_semantic sysval; - struct vkd3d_spirv_builtin builtin; - enum vkd3d_shader_spirv_environment environment; - } - vkd3d_system_value_builtins[] = - { -- {VKD3D_SIV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexId}, -+ {VKD3D_SHADER_SV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexId}, - VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5}, -- {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceId}, -+ {VKD3D_SHADER_SV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceId}, - VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5}, - -- {VKD3D_SIV_POSITION, {VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInPosition}}, -- {VKD3D_SIV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}}, -- {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}}, -+ {VKD3D_SHADER_SV_POSITION, {VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInPosition}}, -+ {VKD3D_SHADER_SV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}}, -+ {VKD3D_SHADER_SV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}}, - -- {VKD3D_SIV_PRIMITIVE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}}, -+ {VKD3D_SHADER_SV_PRIMITIVE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}}, - -- {VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLayer}}, -- {VKD3D_SIV_VIEWPORT_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInViewportIndex}}, -+ {VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLayer}}, -+ {VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInViewportIndex}}, - -- {VKD3D_SIV_IS_FRONT_FACE, {VKD3D_SHADER_COMPONENT_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}}, -+ {VKD3D_SHADER_SV_IS_FRONT_FACE, {VKD3D_SHADER_COMPONENT_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}}, - -- {VKD3D_SIV_SAMPLE_INDEX, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleId}}, -+ {VKD3D_SHADER_SV_SAMPLE_INDEX, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleId}}, - -- {VKD3D_SIV_CLIP_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}}, -- {VKD3D_SIV_CULL_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}}, -+ {VKD3D_SHADER_SV_CLIP_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}}, -+ {VKD3D_SHADER_SV_CULL_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}}, - -- {VKD3D_SIV_QUAD_U0_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, -- {VKD3D_SIV_QUAD_V0_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, -- {VKD3D_SIV_QUAD_U1_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, -- {VKD3D_SIV_QUAD_V1_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 3}}, -- {VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}}, -- {VKD3D_SIV_QUAD_V_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 1}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_QUADINT, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2}}, - -- {VKD3D_SIV_TRIANGLE_U_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, -- {VKD3D_SIV_TRIANGLE_V_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, -- {VKD3D_SIV_TRIANGLE_W_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, -- {VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_TRIEDGE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_TRIINT, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2}}, - -- {VKD3D_SIV_LINE_DENSITY_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, -- {VKD3D_SIV_LINE_DETAIL_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, -+ {VKD3D_SHADER_SV_TESS_FACTOR_LINEDET, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, - }; - static const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin = - { -@@ -4299,7 +4450,7 @@ static void spirv_compiler_emit_register_execution_mode(struct spirv_compiler *c - } - - static const struct vkd3d_spirv_builtin *get_spirv_builtin_for_sysval( -- const struct spirv_compiler *compiler, enum vkd3d_shader_input_sysval_semantic sysval) -+ const struct spirv_compiler *compiler, enum vkd3d_shader_sysval_semantic sysval) - { - enum vkd3d_shader_spirv_environment environment; - unsigned int i; -@@ -4308,7 +4459,7 @@ static const struct vkd3d_spirv_builtin *get_spirv_builtin_for_sysval( - return NULL; - - /* In pixel shaders, SV_Position is mapped to SpvBuiltInFragCoord. */ -- if (sysval == VKD3D_SIV_POSITION && compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL) -+ if (sysval == VKD3D_SHADER_SV_POSITION && compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL) - return &vkd3d_pixel_shader_position_builtin; - - environment = spirv_compiler_get_target_environment(compiler); -@@ -4340,7 +4491,7 @@ static const struct vkd3d_spirv_builtin *get_spirv_builtin_for_register( - } - - static const struct vkd3d_spirv_builtin *vkd3d_get_spirv_builtin(const struct spirv_compiler *compiler, -- enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_input_sysval_semantic sysval) -+ enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_sysval_semantic sysval) - { - const struct vkd3d_spirv_builtin *builtin; - -@@ -4349,8 +4500,7 @@ static const struct vkd3d_spirv_builtin *vkd3d_get_spirv_builtin(const struct sp - if ((builtin = get_spirv_builtin_for_register(reg_type))) - return builtin; - -- if (sysval != VKD3D_SIV_NONE || (reg_type != VKD3DSPR_OUTPUT && reg_type != VKD3DSPR_COLOROUT -- && reg_type != VKD3DSPR_PATCHCONST)) -+ if (sysval != VKD3D_SHADER_SV_NONE || (reg_type != VKD3DSPR_OUTPUT && reg_type != VKD3DSPR_PATCHCONST)) - FIXME("Unhandled builtin (register type %#x, sysval %#x).\n", reg_type, sysval); - return NULL; - } -@@ -4361,11 +4511,7 @@ static uint32_t spirv_compiler_get_invocation_id(struct spirv_compiler *compiler - - assert(compiler->shader_type == VKD3D_SHADER_TYPE_HULL); - -- memset(&r, 0, sizeof(r)); -- r.type = VKD3DSPR_OUTPOINTID; -- r.idx[0].offset = ~0u; -- r.idx[1].offset = ~0u; -- r.idx_count = 0; -+ vsir_register_init(&r, VKD3DSPR_OUTPOINTID, VKD3D_DATA_FLOAT, 0); - return spirv_compiler_get_register_id(compiler, &r); - } - -@@ -4486,7 +4632,7 @@ static uint32_t spirv_compiler_emit_builtin_variable_v(struct spirv_compiler *co - assert(size_count <= ARRAY_SIZE(sizes)); - memcpy(sizes, array_sizes, size_count * sizeof(sizes[0])); - array_sizes = sizes; -- sizes[0] = max(sizes[0], builtin->spirv_array_size); -+ sizes[size_count - 1] = max(sizes[size_count - 1], builtin->spirv_array_size); - - id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, storage_class, - builtin->component_type, builtin->component_count, array_sizes, size_count); -@@ -4524,27 +4670,8 @@ static unsigned int shader_signature_next_location(const struct shader_signature - return max_row; - } - --static unsigned int shader_register_get_io_indices(const struct vkd3d_shader_register *reg, -- unsigned int *array_sizes) --{ -- unsigned int i, element_idx; -- -- array_sizes[0] = 0; -- array_sizes[1] = 0; -- element_idx = reg->idx[0].offset; -- for (i = 1; i < reg->idx_count; ++i) -- { -- array_sizes[1] = array_sizes[0]; -- array_sizes[0] = element_idx; -- element_idx = reg->idx[i].offset; -- } -- -- return element_idx; --} -- - static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, -- const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_input_sysval_semantic sysval, -- enum vkd3d_shader_interpolation_mode interpolation_mode) -+ const struct vkd3d_shader_dst_param *dst) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - const struct vkd3d_shader_register *reg = &dst->reg; -@@ -4552,18 +4679,18 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, - const struct signature_element *signature_element; - const struct shader_signature *shader_signature; - enum vkd3d_shader_component_type component_type; -- uint32_t type_id, ptr_type_id, float_type_id; - const struct vkd3d_spirv_builtin *builtin; -+ enum vkd3d_shader_sysval_semantic sysval; - unsigned int write_mask, reg_write_mask; - struct vkd3d_symbol *symbol = NULL; - uint32_t val_id, input_id, var_id; -+ uint32_t type_id, float_type_id; - struct vkd3d_symbol reg_symbol; - SpvStorageClass storage_class; - struct rb_entry *entry = NULL; - bool use_private_var = false; - unsigned int array_sizes[2]; - unsigned int element_idx; -- uint32_t i, index; - - assert(!reg->idx_count || !reg->idx[0].rel_addr); - assert(reg->idx_count < 2 || !reg->idx[1].rel_addr); -@@ -4571,15 +4698,22 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, - shader_signature = reg->type == VKD3DSPR_PATCHCONST - ? &compiler->patch_constant_signature : &compiler->input_signature; - -- element_idx = shader_register_get_io_indices(reg, array_sizes); -+ element_idx = reg->idx[reg->idx_count - 1].offset; - signature_element = &shader_signature->elements[element_idx]; -- -- if ((compiler->shader_type == VKD3D_SHADER_TYPE_HULL || compiler->shader_type == VKD3D_SHADER_TYPE_GEOMETRY) -- && !sysval && signature_element->sysval_semantic) -- sysval = vkd3d_siv_from_sysval(signature_element->sysval_semantic); -+ sysval = signature_element->sysval_semantic; -+ /* The Vulkan spec does not explicitly forbid passing varyings from the -+ * TCS to the TES via builtins. However, Mesa doesn't seem to handle it -+ * well, and we don't actually need them to be in builtins. */ -+ if (compiler->shader_type == VKD3D_SHADER_TYPE_DOMAIN && reg->type != VKD3DSPR_PATCHCONST) -+ sysval = VKD3D_SHADER_SV_NONE; - - builtin = get_spirv_builtin_for_sysval(compiler, sysval); - -+ array_sizes[0] = (reg->type == VKD3DSPR_PATCHCONST ? 0 : compiler->input_control_point_count); -+ array_sizes[1] = signature_element->register_count; -+ if (array_sizes[1] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic)) -+ array_sizes[1] = 0; -+ - write_mask = signature_element->mask; - - if (builtin) -@@ -4644,7 +4778,7 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, - if (component_idx) - vkd3d_spirv_build_op_decorate1(builder, input_id, SpvDecorationComponent, component_idx); - -- spirv_compiler_emit_interpolation_decorations(compiler, input_id, interpolation_mode); -+ spirv_compiler_emit_interpolation_decorations(compiler, input_id, signature_element->interpolation_mode); - } - - var_id = input_id; -@@ -4666,47 +4800,27 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, - - if (use_private_var) - { -+ struct vkd3d_shader_register dst_reg = *reg; -+ dst_reg.data_type = VKD3D_DATA_FLOAT; -+ - type_id = vkd3d_spirv_get_type_id(builder, component_type, input_component_count); -- for (i = 0; i < max(array_sizes[0], 1); ++i) -- { -- struct vkd3d_shader_register dst_reg = *reg; -- dst_reg.data_type = VKD3D_DATA_FLOAT; - -- val_id = input_id; -- if (array_sizes[0]) -- { -- ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassInput, type_id); -- index = spirv_compiler_get_constant_uint(compiler, i); -- val_id = vkd3d_spirv_build_op_in_bounds_access_chain1(builder, ptr_type_id, input_id, index); -- dst_reg.idx[0].offset = i; -- } -- else if (builtin && builtin->spirv_array_size) -- { -- /* The D3D builtin is not an array, but the SPIR-V builtin is, -- * so we'll need to index into the SPIR-V builtin when loading -- * it. This happens when reading TessLevel in domain shaders. */ -- ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassInput, type_id); -- index = spirv_compiler_get_constant_uint(compiler, builtin->member_idx); -- val_id = vkd3d_spirv_build_op_in_bounds_access_chain1(builder, ptr_type_id, input_id, index); -- dst_reg.idx[0].offset = element_idx + i; -- } -- val_id = vkd3d_spirv_build_op_load(builder, type_id, val_id, SpvMemoryAccessMaskNone); -+ val_id = vkd3d_spirv_build_op_load(builder, type_id, input_id, SpvMemoryAccessMaskNone); - -- if (builtin && builtin->fixup_pfn) -- val_id = builtin->fixup_pfn(compiler, val_id); -+ if (builtin && builtin->fixup_pfn) -+ val_id = builtin->fixup_pfn(compiler, val_id); - -- if (component_type != VKD3D_SHADER_COMPONENT_FLOAT) -- { -- float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, input_component_count); -- val_id = vkd3d_spirv_build_op_bitcast(builder, float_type_id, val_id); -- } -+ if (component_type != VKD3D_SHADER_COMPONENT_FLOAT) -+ { -+ float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, input_component_count); -+ val_id = vkd3d_spirv_build_op_bitcast(builder, float_type_id, val_id); -+ } - -- val_id = spirv_compiler_emit_swizzle(compiler, val_id, -- vkd3d_write_mask_from_component_count(input_component_count), -- VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx); -+ val_id = spirv_compiler_emit_swizzle(compiler, val_id, -+ vkd3d_write_mask_from_component_count(input_component_count), -+ VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx); - -- spirv_compiler_emit_store_reg(compiler, &dst_reg, dst->write_mask, val_id); -- } -+ spirv_compiler_emit_store_reg(compiler, &dst_reg, dst->write_mask, val_id); - } - - return input_id; -@@ -4747,30 +4861,6 @@ static void spirv_compiler_emit_input_register(struct spirv_compiler *compiler, - spirv_compiler_emit_register_debug_name(builder, input_id, reg); - } - --static void spirv_compiler_emit_shader_phase_input(struct spirv_compiler *compiler, -- const struct vkd3d_shader_dst_param *dst) --{ -- const struct vkd3d_shader_register *reg = &dst->reg; -- -- switch (reg->type) -- { -- case VKD3DSPR_INPUT: -- case VKD3DSPR_INCONTROLPOINT: -- case VKD3DSPR_PATCHCONST: -- spirv_compiler_emit_input(compiler, dst, VKD3D_SIV_NONE, VKD3DSIM_NONE); -- return; -- case VKD3DSPR_PRIMID: -- spirv_compiler_emit_input_register(compiler, dst); -- return; -- case VKD3DSPR_OUTPOINTID: /* Emitted in spirv_compiler_emit_initial_declarations(). */ -- case VKD3DSPR_OUTCONTROLPOINT: /* See spirv_compiler_leave_shader_phase(). */ -- return; -- default: -- FIXME("Unhandled shader phase input register %#x.\n", reg->type); -- return; -- } --} -- - static unsigned int get_shader_output_swizzle(const struct spirv_compiler *compiler, - unsigned int register_idx) - { -@@ -4835,7 +4925,7 @@ static void spirv_compiler_emit_shader_signature_outputs(struct spirv_compiler * - if (clip_distance_mask) - { - count = vkd3d_popcount(clip_distance_mask); -- builtin = get_spirv_builtin_for_sysval(compiler, VKD3D_SIV_CLIP_DISTANCE); -+ builtin = get_spirv_builtin_for_sysval(compiler, VKD3D_SHADER_SV_CLIP_DISTANCE); - clip_distance_id = spirv_compiler_emit_builtin_variable(compiler, - builtin, SpvStorageClassOutput, count); - } -@@ -4843,7 +4933,7 @@ static void spirv_compiler_emit_shader_signature_outputs(struct spirv_compiler * - if (cull_distance_mask) - { - count = vkd3d_popcount(cull_distance_mask); -- builtin = get_spirv_builtin_for_sysval(compiler, VKD3D_SIV_CULL_DISTANCE); -+ builtin = get_spirv_builtin_for_sysval(compiler, VKD3D_SHADER_SV_CULL_DISTANCE); - cull_distance_id = spirv_compiler_emit_builtin_variable(compiler, - builtin, SpvStorageClassOutput, count); - } -@@ -4904,7 +4994,7 @@ static void spirv_compiler_emit_output_register(struct spirv_compiler *compiler, - } - - static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_compiler *compiler, -- const struct vkd3d_spirv_builtin *builtin) -+ const struct vkd3d_spirv_builtin *builtin, const unsigned int *array_sizes, unsigned int size_count) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t *variable_id, id; -@@ -4919,7 +5009,7 @@ static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_c - if (variable_id && *variable_id) - return *variable_id; - -- id = spirv_compiler_emit_builtin_variable(compiler, builtin, SpvStorageClassOutput, 0); -+ id = spirv_compiler_emit_builtin_variable_v(compiler, builtin, SpvStorageClassOutput, array_sizes, size_count); - if (is_in_fork_or_join_phase(compiler)) - vkd3d_spirv_build_op_decorate(builder, id, SpvDecorationPatch, NULL, 0); - -@@ -4928,8 +5018,7 @@ static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_c - return id; - } - --static void spirv_compiler_emit_output(struct spirv_compiler *compiler, -- const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_input_sysval_semantic sysval) -+static void spirv_compiler_emit_output(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - const struct vkd3d_shader_register *reg = &dst->reg; -@@ -4938,6 +5027,7 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, - enum vkd3d_shader_component_type component_type; - const struct shader_signature *shader_signature; - const struct vkd3d_spirv_builtin *builtin; -+ enum vkd3d_shader_sysval_semantic sysval; - unsigned int write_mask, reg_write_mask; - bool use_private_variable = false; - struct vkd3d_symbol reg_symbol; -@@ -4951,8 +5041,16 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, - - shader_signature = is_patch_constant ? &compiler->patch_constant_signature : &compiler->output_signature; - -- element_idx = shader_register_get_io_indices(reg, array_sizes); -+ element_idx = reg->idx[reg->idx_count - 1].offset; - signature_element = &shader_signature->elements[element_idx]; -+ sysval = signature_element->sysval_semantic; -+ /* Don't use builtins for TCS -> TES varyings. See spirv_compiler_emit_input(). */ -+ if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL && !is_patch_constant) -+ sysval = VKD3D_SHADER_SV_NONE; -+ array_sizes[0] = (reg->type == VKD3DSPR_PATCHCONST ? 0 : compiler->output_control_point_count); -+ array_sizes[1] = signature_element->register_count; -+ if (array_sizes[1] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic)) -+ array_sizes[1] = 0; - - builtin = vkd3d_get_spirv_builtin(compiler, dst->reg.type, sysval); - -@@ -4997,7 +5095,7 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, - else if (builtin) - { - if (spirv_compiler_get_current_shader_phase(compiler)) -- id = spirv_compiler_emit_shader_phase_builtin_variable(compiler, builtin); -+ id = spirv_compiler_emit_shader_phase_builtin_variable(compiler, builtin, array_sizes, 2); - else - id = spirv_compiler_emit_builtin_variable_v(compiler, builtin, storage_class, array_sizes, 2); - -@@ -5015,6 +5113,9 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, - - if (is_patch_constant) - location += shader_signature_next_location(&compiler->output_signature); -+ else if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL -+ && signature_element->sysval_semantic == VKD3D_SHADER_SV_TARGET) -+ location = signature_element->semantic_index; - - id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, - storage_class, component_type, output_component_count, array_sizes, 2); -@@ -5073,16 +5174,15 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, - static uint32_t spirv_compiler_get_output_array_index(struct spirv_compiler *compiler, - const struct signature_element *e) - { -- enum vkd3d_shader_input_sysval_semantic sysval; -+ enum vkd3d_shader_sysval_semantic sysval = e->sysval_semantic; - const struct vkd3d_spirv_builtin *builtin; - -- sysval = vkd3d_siv_from_sysval_indexed(e->sysval_semantic, e->semantic_index); - builtin = get_spirv_builtin_for_sysval(compiler, sysval); - - switch (sysval) - { -- case VKD3D_SIV_LINE_DETAIL_TESS_FACTOR: -- case VKD3D_SIV_LINE_DENSITY_TESS_FACTOR: -+ case VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN: -+ case VKD3D_SHADER_SV_TESS_FACTOR_LINEDET: - return builtin->member_idx; - default: - return e->semantic_index; -@@ -5196,7 +5296,6 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler * - - STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_id)); - STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_type_id)); -- STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_array_idx)); - STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_write_mask)); - - is_patch_constant = is_in_fork_or_join_phase(compiler); -@@ -5252,7 +5351,6 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler * - vkd3d_spirv_build_op_function_end(builder); - - memset(compiler->private_output_variable, 0, sizeof(compiler->private_output_variable)); -- memset(compiler->private_output_variable_array_idx, 0, sizeof(compiler->private_output_variable_array_idx)); - memset(compiler->private_output_variable_write_mask, 0, sizeof(compiler->private_output_variable_write_mask)); - compiler->epilogue_function_id = 0; - } -@@ -5262,10 +5360,7 @@ static void spirv_compiler_emit_hull_shader_builtins(struct spirv_compiler *comp - struct vkd3d_shader_dst_param dst; - - memset(&dst, 0, sizeof(dst)); -- dst.reg.type = VKD3DSPR_OUTPOINTID; -- dst.reg.idx[0].offset = ~0u; -- dst.reg.idx[1].offset = ~0u; -- dst.reg.idx_count = 0; -+ vsir_register_init(&dst.reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_FLOAT, 0); - dst.write_mask = VKD3DSP_WRITEMASK_0; - spirv_compiler_emit_input_register(compiler, &dst); - } -@@ -5293,7 +5388,7 @@ static void spirv_compiler_emit_initial_declarations(struct spirv_compiler *comp - break; - case VKD3D_SHADER_TYPE_PIXEL: - vkd3d_spirv_set_execution_model(builder, SpvExecutionModelFragment); -- spirv_compiler_emit_execution_mode(compiler, SpvExecutionModeOriginUpperLeft, NULL, 0); -+ spirv_compiler_emit_execution_mode(compiler, compiler->fragment_coordinate_origin, NULL, 0); - break; - case VKD3D_SHADER_TYPE_COMPUTE: - vkd3d_spirv_set_execution_model(builder, SpvExecutionModelGLCompute); -@@ -5329,7 +5424,7 @@ static size_t spirv_compiler_get_current_function_location(struct spirv_compiler - static void spirv_compiler_emit_dcl_global_flags(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { -- unsigned int flags = instruction->flags; -+ enum vkd3d_shader_global_flags flags = instruction->declaration.global_flags; - - if (flags & VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL) - { -@@ -5344,9 +5439,9 @@ static void spirv_compiler_emit_dcl_global_flags(struct spirv_compiler *compiler - } - - if (flags & ~(VKD3DSGF_REFACTORING_ALLOWED | VKD3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS)) -- FIXME("Unhandled global flags %#x.\n", flags); -+ FIXME("Unhandled global flags %#"PRIx64".\n", (uint64_t)flags); - else -- WARN("Unhandled global flags %#x.\n", flags); -+ WARN("Unhandled global flags %#"PRIx64".\n", (uint64_t)flags); - } - - static void spirv_compiler_emit_temps(struct spirv_compiler *compiler, uint32_t count) -@@ -5375,6 +5470,18 @@ static void spirv_compiler_emit_temps(struct spirv_compiler *compiler, uint32_t - vkd3d_spirv_end_function_stream_insertion(builder); - } - -+static void spirv_compiler_allocate_ssa_register_ids(struct spirv_compiler *compiler, unsigned int count) -+{ -+ assert(!compiler->ssa_register_info); -+ if (!(compiler->ssa_register_info = vkd3d_calloc(count, sizeof(*compiler->ssa_register_info)))) -+ { -+ ERR("Failed to allocate SSA register value id array, count %u.\n", count); -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY, -+ "Failed to allocate SSA register value id array of count %u.", count); -+ } -+ compiler->ssa_register_count = count; -+} -+ - static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { -@@ -5388,11 +5495,17 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil - if (temp->component_count != 4) - FIXME("Unhandled component count %u.\n", temp->component_count); - -- memset(®, 0, sizeof(reg)); -- reg.type = VKD3DSPR_IDXTEMP; -+ vsir_register_init(®, VKD3DSPR_IDXTEMP, VKD3D_DATA_FLOAT, 1); - reg.idx[0].offset = temp->register_idx; -- reg.idx[1].offset = ~0u; -- reg.idx_count = 1; -+ -+ if (temp->alignment) -+ WARN("Ignoring alignment %u.\n", temp->alignment); -+ if (temp->initialiser) -+ { -+ FIXME("Initialisers are not supported.\n"); -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED, -+ "Initialisers for indexable temps are not supported."); -+ } - - function_location = spirv_compiler_get_current_function_location(compiler); - vkd3d_spirv_begin_function_stream_insertion(builder, function_location); -@@ -5461,13 +5574,14 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com - - struct_id = vkd3d_spirv_build_op_type_struct(builder, member_ids, count); - vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0); -- vkd3d_spirv_build_op_name(builder, struct_id, "push_cb"); -+ vkd3d_spirv_build_op_name(builder, struct_id, "push_cb_struct"); - vkd3d_free(member_ids); - - pointer_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, struct_id); - var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream, - pointer_type_id, storage_class, 0); - compiler->push_constants_var_id = var_id; -+ vkd3d_spirv_build_op_name(builder, var_id, "push_cb"); - - for (i = 0, j = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i) - { -@@ -5571,17 +5685,17 @@ static void spirv_compiler_emit_cbv_declaration(struct spirv_compiler *compiler, - const SpvStorageClass storage_class = SpvStorageClassUniform; - struct vkd3d_push_constant_buffer_binding *push_cb; - struct vkd3d_descriptor_variable_info var_info; -+ struct vkd3d_shader_register reg; - struct vkd3d_symbol reg_symbol; - unsigned int size; - -- struct vkd3d_shader_register reg = -- { -- .type = VKD3DSPR_CONSTBUFFER, -- .idx[0].offset = register_id, -- .idx_count = 1, -- }; -+ vsir_register_init(®, VKD3DSPR_CONSTBUFFER, VKD3D_DATA_FLOAT, 3); -+ reg.idx[0].offset = register_id; -+ reg.idx[1].offset = range->first; -+ reg.idx[2].offset = range->last; - -- size = size_in_bytes / (VKD3D_VEC4_SIZE * sizeof(uint32_t)); -+ size = align(size_in_bytes, VKD3D_VEC4_SIZE * sizeof(uint32_t)); -+ size /= VKD3D_VEC4_SIZE * sizeof(uint32_t); - - if ((push_cb = spirv_compiler_find_push_constant_buffer(compiler, range))) - { -@@ -5629,23 +5743,25 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi - struct vkd3d_symbol reg_symbol; - unsigned int i; - -- if (!(elements = vkd3d_calloc(icb->vec4_count, sizeof(*elements)))) -+ assert(icb->data_type == VKD3D_DATA_FLOAT); -+ assert(icb->component_count == VKD3D_VEC4_SIZE); -+ -+ if (!(elements = vkd3d_calloc(icb->element_count, sizeof(*elements)))) - return; -- for (i = 0; i < icb->vec4_count; ++i) -+ for (i = 0; i < icb->element_count; ++i) - elements[i] = spirv_compiler_get_constant(compiler, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, &icb->data[4 * i]); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); -- length_id = spirv_compiler_get_constant_uint(compiler, icb->vec4_count); -+ length_id = spirv_compiler_get_constant_uint(compiler, icb->element_count); - type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id); -- const_id = vkd3d_spirv_build_op_constant_composite(builder, type_id, elements, icb->vec4_count); -+ const_id = vkd3d_spirv_build_op_constant_composite(builder, type_id, elements, icb->element_count); - ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id); - icb_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream, - ptr_type_id, SpvStorageClassPrivate, const_id); - vkd3d_spirv_build_op_name(builder, icb_id, "icb"); - vkd3d_free(elements); - -- memset(®, 0, sizeof(reg)); -- reg.type = VKD3DSPR_IMMCONSTBUFFER; -+ vsir_register_init(®, VKD3DSPR_IMMCONSTBUFFER, VKD3D_DATA_FLOAT, 0); - vkd3d_symbol_make_register(®_symbol, ®); - vkd3d_symbol_set_register_info(®_symbol, icb_id, SpvStorageClassPrivate, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); -@@ -5658,15 +5774,12 @@ static void spirv_compiler_emit_sampler_declaration(struct spirv_compiler *compi - const SpvStorageClass storage_class = SpvStorageClassUniformConstant; - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - struct vkd3d_descriptor_variable_info var_info; -+ struct vkd3d_shader_register reg; - struct vkd3d_symbol reg_symbol; - uint32_t type_id, var_id; - -- const struct vkd3d_shader_register reg = -- { -- .type = VKD3DSPR_SAMPLER, -- .idx[0].offset = register_id, -- .idx_count = 1, -- }; -+ vsir_register_init(®, VKD3DSPR_SAMPLER, VKD3D_DATA_FLOAT, 1); -+ reg.idx[0].offset = register_id; - - vkd3d_symbol_make_sampler(®_symbol, ®); - reg_symbol.info.sampler.range = *range; -@@ -5847,6 +5960,7 @@ static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compi - current->sampler_index == VKD3D_SHADER_DUMMY_SAMPLER_INDEX ? 0 : current->sampler_space, - current->sampler_index); - symbol.id = var_id; -+ symbol.descriptor_array = NULL; - symbol.info.resource.range = *resource_range; - symbol.info.resource.sampled_type = sampled_type; - symbol.info.resource.type_id = image_type_id; -@@ -5872,13 +5986,10 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp - const struct vkd3d_spirv_resource_type *resource_type_info; - enum vkd3d_shader_component_type sampled_type; - struct vkd3d_symbol resource_symbol; -+ struct vkd3d_shader_register reg; - -- struct vkd3d_shader_register reg = -- { -- .type = is_uav ? VKD3DSPR_UAV : VKD3DSPR_RESOURCE, -- .idx[0].offset = register_id, -- .idx_count = 1, -- }; -+ vsir_register_init(®, is_uav ? VKD3DSPR_UAV : VKD3DSPR_RESOURCE, VKD3D_DATA_FLOAT, 1); -+ reg.idx[0].offset = register_id; - - if (resource_type == VKD3D_SHADER_RESOURCE_TEXTURE_2DMS && sample_count == 1) - resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D; -@@ -6030,36 +6141,17 @@ static void spirv_compiler_emit_dcl_input(struct spirv_compiler *compiler, - { - const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst; - -- if (spirv_compiler_get_current_shader_phase(compiler)) -- spirv_compiler_emit_shader_phase_input(compiler, dst); -- else if (vkd3d_shader_register_is_input(&dst->reg) || dst->reg.type == VKD3DSPR_PATCHCONST) -- spirv_compiler_emit_input(compiler, dst, VKD3D_SIV_NONE, VKD3DSIM_NONE); -- else -+ /* OUTPOINTID is handled in spirv_compiler_emit_hull_shader_builtins(). */ -+ if (dst->reg.type == VKD3DSPR_INPUT || dst->reg.type == VKD3DSPR_PATCHCONST) -+ spirv_compiler_emit_input(compiler, dst); -+ else if (dst->reg.type != VKD3DSPR_OUTPOINTID) - spirv_compiler_emit_input_register(compiler, dst); -- -- if (dst->reg.type == VKD3DSPR_OUTCONTROLPOINT) -- compiler->use_vocp = true; --} -- --static void spirv_compiler_emit_dcl_input_ps(struct spirv_compiler *compiler, -- const struct vkd3d_shader_instruction *instruction) --{ -- spirv_compiler_emit_input(compiler, &instruction->declaration.dst, VKD3D_SIV_NONE, instruction->flags); --} -- --static void spirv_compiler_emit_dcl_input_ps_sysval(struct spirv_compiler *compiler, -- const struct vkd3d_shader_instruction *instruction) --{ -- const struct vkd3d_shader_register_semantic *semantic = &instruction->declaration.register_semantic; -- -- spirv_compiler_emit_input(compiler, &semantic->reg, semantic->sysval_semantic, instruction->flags); - } - - static void spirv_compiler_emit_dcl_input_sysval(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { -- spirv_compiler_emit_input(compiler, &instruction->declaration.register_semantic.reg, -- instruction->declaration.register_semantic.sysval_semantic, VKD3DSIM_NONE); -+ spirv_compiler_emit_input(compiler, &instruction->declaration.register_semantic.reg); - } - - static void spirv_compiler_emit_dcl_output(struct spirv_compiler *compiler, -@@ -6067,9 +6159,9 @@ static void spirv_compiler_emit_dcl_output(struct spirv_compiler *compiler, - { - const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst; - -- if (vkd3d_shader_register_is_output(&dst->reg) -- || (is_in_fork_or_join_phase(compiler) && vkd3d_shader_register_is_patch_constant(&dst->reg))) -- spirv_compiler_emit_output(compiler, dst, VKD3D_SIV_NONE); -+ if (dst->reg.type == VKD3DSPR_OUTPUT -+ || (is_in_fork_or_join_phase(compiler) && dst->reg.type == VKD3DSPR_PATCHCONST)) -+ spirv_compiler_emit_output(compiler, dst); - else - spirv_compiler_emit_output_register(compiler, dst); - } -@@ -6077,13 +6169,7 @@ static void spirv_compiler_emit_dcl_output(struct spirv_compiler *compiler, - static void spirv_compiler_emit_dcl_output_siv(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { -- enum vkd3d_shader_input_sysval_semantic sysval; -- const struct vkd3d_shader_dst_param *dst; -- -- dst = &instruction->declaration.register_semantic.reg; -- sysval = instruction->declaration.register_semantic.sysval_semantic; -- -- spirv_compiler_emit_output(compiler, dst, sysval); -+ spirv_compiler_emit_output(compiler, &instruction->declaration.register_semantic.reg); - } - - static void spirv_compiler_emit_dcl_stream(struct spirv_compiler *compiler, -@@ -6305,7 +6391,6 @@ static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler) - * Control point phase has separate output registers. */ - memset(compiler->output_info, 0, signature->element_count * sizeof(*compiler->output_info)); - memset(compiler->private_output_variable, 0, sizeof(compiler->private_output_variable)); -- memset(compiler->private_output_variable_array_idx, 0, sizeof(compiler->private_output_variable_array_idx)); - memset(compiler->private_output_variable_write_mask, 0, sizeof(compiler->private_output_variable_write_mask)); - } - } -@@ -6361,20 +6446,13 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile - invocation_id = spirv_compiler_emit_load_invocation_id(compiler); - - memset(&invocation, 0, sizeof(invocation)); -- invocation.reg.type = VKD3DSPR_OUTPOINTID; -- invocation.reg.data_type = VKD3D_DATA_INT; -- invocation.reg.idx[0].offset = ~0u; -- invocation.reg.idx[1].offset = ~0u; -- invocation.reg.idx[2].offset = ~0u; -- invocation.reg.idx_count = 0; -+ vsir_register_init(&invocation.reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_INT, 0); - invocation.swizzle = VKD3D_SHADER_NO_SWIZZLE; - -- memset(&input_reg, 0, sizeof(input_reg)); -- input_reg.type = VKD3DSPR_INPUT; -- input_reg.data_type = VKD3D_DATA_FLOAT; -+ vsir_register_init(&input_reg, VKD3DSPR_INPUT, VKD3D_DATA_FLOAT, 2); -+ input_reg.idx[0].offset = 0; - input_reg.idx[0].rel_addr = &invocation; -- input_reg.idx[2].offset = ~0u; -- input_reg.idx_count = 2; -+ input_reg.idx[1].offset = 0; - input_id = spirv_compiler_get_register_id(compiler, &input_reg); - - assert(input_signature->element_count == output_signature->element_count); -@@ -6441,36 +6519,17 @@ static void spirv_compiler_emit_hull_shader_barrier(struct spirv_compiler *compi - static void spirv_compiler_emit_shader_epilogue_invocation(struct spirv_compiler *compiler) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -- uint32_t void_id, type_id, ptr_type_id, function_id; - uint32_t arguments[MAX_REG_OUTPUT]; -+ uint32_t void_id, function_id; - unsigned int i, count; - - if ((function_id = compiler->epilogue_function_id)) - { - void_id = vkd3d_spirv_get_op_type_void(builder); -- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 4); -- ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id); - for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i) - { - if (compiler->private_output_variable[i]) -- { -- uint32_t argument_id = compiler->private_output_variable[i]; -- unsigned int argument_idx = count++; -- -- if (compiler->private_output_variable_array_idx[i]) -- { -- uint32_t tmp_id; -- -- tmp_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, -- argument_id, compiler->private_output_variable_array_idx[i]); -- tmp_id = vkd3d_spirv_build_op_load(builder, type_id, tmp_id, SpvMemoryAccessMaskNone); -- argument_id = vkd3d_spirv_build_op_variable(builder, -- &builder->global_stream, ptr_type_id, SpvStorageClassPrivate, 0); -- vkd3d_spirv_build_op_store(builder, argument_id, tmp_id, SpvMemoryAccessMaskNone); -- } -- -- arguments[argument_idx] = argument_id; -- } -+ arguments[count++] = compiler->private_output_variable[i]; - } - - vkd3d_spirv_build_op_function_call(builder, void_id, function_id, arguments, count); -@@ -6520,9 +6579,8 @@ static SpvOp spirv_compiler_map_alu_instruction(const struct vkd3d_shader_instru - {VKD3DSIH_DTOF, SpvOpFConvert}, - {VKD3DSIH_DTOI, SpvOpConvertFToS}, - {VKD3DSIH_DTOU, SpvOpConvertFToU}, -+ {VKD3DSIH_FREM, SpvOpFRem}, - {VKD3DSIH_FTOD, SpvOpFConvert}, -- {VKD3DSIH_FTOI, SpvOpConvertFToS}, -- {VKD3DSIH_FTOU, SpvOpConvertFToU}, - {VKD3DSIH_IADD, SpvOpIAdd}, - {VKD3DSIH_INEG, SpvOpSNegate}, - {VKD3DSIH_ISHL, SpvOpShiftLeftLogical}, -@@ -6548,7 +6606,55 @@ static SpvOp spirv_compiler_map_alu_instruction(const struct vkd3d_shader_instru - return SpvOpMax; - } - --static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, -+static SpvOp spirv_compiler_map_logical_instruction(const struct vkd3d_shader_instruction *instruction) -+{ -+ switch (instruction->handler_idx) -+ { -+ case VKD3DSIH_AND: -+ return SpvOpLogicalAnd; -+ case VKD3DSIH_OR: -+ return SpvOpLogicalOr; -+ case VKD3DSIH_XOR: -+ return SpvOpLogicalNotEqual; -+ default: -+ return SpvOpMax; -+ } -+} -+ -+static void spirv_compiler_emit_bool_cast(struct spirv_compiler *compiler, -+ const struct vkd3d_shader_instruction *instruction) -+{ -+ const struct vkd3d_shader_dst_param *dst = instruction->dst; -+ const struct vkd3d_shader_src_param *src = instruction->src; -+ uint32_t val_id; -+ -+ assert(src->reg.data_type == VKD3D_DATA_BOOL && dst->reg.data_type != VKD3D_DATA_BOOL); -+ -+ val_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask); -+ if (dst->reg.data_type == VKD3D_DATA_FLOAT) -+ { -+ val_id = spirv_compiler_emit_bool_to_float(compiler, 1, val_id, instruction->handler_idx == VKD3DSIH_ITOF); -+ } -+ else if (dst->reg.data_type == VKD3D_DATA_DOUBLE) -+ { -+ /* ITOD is not supported. Frontends which emit bool casts must use ITOF for double. */ -+ val_id = spirv_compiler_emit_bool_to_double(compiler, 1, val_id, instruction->handler_idx == VKD3DSIH_ITOF); -+ } -+ else if (dst->reg.data_type == VKD3D_DATA_UINT) -+ { -+ val_id = spirv_compiler_emit_bool_to_int(compiler, 1, val_id, instruction->handler_idx == VKD3DSIH_ITOI); -+ } -+ else -+ { -+ WARN("Unhandled data type %u.\n", dst->reg.data_type); -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_TYPE, -+ "Register data type %u is unhandled.", dst->reg.data_type); -+ } -+ -+ spirv_compiler_emit_store_dst(compiler, dst, val_id); -+} -+ -+static enum vkd3d_result spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -@@ -6556,14 +6662,36 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, - const struct vkd3d_shader_src_param *src = instruction->src; - uint32_t src_ids[SPIRV_MAX_SRC_COUNT]; - uint32_t type_id, val_id; -+ SpvOp op = SpvOpMax; - unsigned int i; -- SpvOp op; - -- op = spirv_compiler_map_alu_instruction(instruction); -+ if (src->reg.data_type == VKD3D_DATA_BOOL) -+ { -+ if (dst->reg.data_type == VKD3D_DATA_BOOL) -+ { -+ /* VSIR supports logic ops AND/OR/XOR on bool values. */ -+ op = spirv_compiler_map_logical_instruction(instruction); -+ } -+ else if (instruction->handler_idx == VKD3DSIH_ITOF || instruction->handler_idx == VKD3DSIH_UTOF -+ || instruction->handler_idx == VKD3DSIH_ITOI || instruction->handler_idx == VKD3DSIH_UTOU) -+ { -+ /* VSIR supports cast from bool to signed/unsigned integer types and floating point types, -+ * where bool is treated as a 1-bit integer and a signed 'true' value converts to -1. */ -+ spirv_compiler_emit_bool_cast(compiler, instruction); -+ return VKD3D_OK; -+ } -+ } -+ else -+ { -+ op = spirv_compiler_map_alu_instruction(instruction); -+ } -+ - if (op == SpvOpMax) - { - ERR("Unexpected instruction %#x.\n", instruction->handler_idx); -- return; -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER, -+ "Encountered invalid/unhandled instruction handler %#x.", instruction->handler_idx); -+ return VKD3D_ERROR_INVALID_SHADER; - } - - assert(instruction->dst_count == 1); -@@ -6595,6 +6723,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, - vkd3d_spirv_build_op_decorate(builder, val_id, SpvDecorationNoContraction, NULL, 0); - - spirv_compiler_emit_store_dst(compiler, dst, val_id); -+ return VKD3D_OK; - } - - static enum GLSLstd450 spirv_compiler_map_ext_glsl_instruction( -@@ -6694,7 +6823,8 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler, - uint32_t components[VKD3D_VEC4_SIZE]; - unsigned int i, component_count; - -- if (register_is_constant_or_undef(&src->reg) || dst->modifiers || src->modifiers) -+ if (register_is_constant_or_undef(&src->reg) || src->reg.type == VKD3DSPR_SSA || dst->reg.type == VKD3DSPR_SSA -+ || dst->modifiers || src->modifiers) - goto general_implementation; - - spirv_compiler_get_register_info(compiler, &dst->reg, &dst_reg_info); -@@ -6760,8 +6890,9 @@ static void spirv_compiler_emit_movc(struct spirv_compiler *compiler, - component_count = vkd3d_write_mask_component_count(dst->write_mask); - type_id = spirv_compiler_get_type_id_for_dst(compiler, dst); - -- condition_id = spirv_compiler_emit_int_to_bool(compiler, -- VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); -+ if (src[0].reg.data_type != VKD3D_DATA_BOOL) -+ condition_id = spirv_compiler_emit_int_to_bool(compiler, -+ VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); - val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src1_id, src2_id); - - spirv_compiler_emit_store_dst(compiler, dst, val_id); -@@ -6899,7 +7030,7 @@ static void spirv_compiler_emit_imul(struct spirv_compiler *compiler, - uint32_t type_id, val_id, src0_id, src1_id; - - if (dst[0].reg.type != VKD3DSPR_NULL) -- FIXME("Extended multiplies not implemented.\n"); /* SpvOpSMulExtended */ -+ FIXME("Extended multiplies not implemented.\n"); /* SpvOpSMulExtended/SpvOpUMulExtended */ - - if (dst[1].reg.type == VKD3DSPR_NULL) - return; -@@ -6935,7 +7066,7 @@ static void spirv_compiler_emit_imad(struct spirv_compiler *compiler, - spirv_compiler_emit_store_dst(compiler, dst, val_id); - } - --static void spirv_compiler_emit_udiv(struct spirv_compiler *compiler, -+static void spirv_compiler_emit_int_div(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { - uint32_t type_id, val_id, src0_id, src1_id, condition_id, uint_max_id; -@@ -6943,6 +7074,10 @@ static void spirv_compiler_emit_udiv(struct spirv_compiler *compiler, - const struct vkd3d_shader_dst_param *dst = instruction->dst; - const struct vkd3d_shader_src_param *src = instruction->src; - unsigned int component_count = 0; -+ SpvOp div_op, mod_op; -+ -+ div_op = instruction->handler_idx == VKD3DSIH_IDIV ? SpvOpSDiv : SpvOpUDiv; -+ mod_op = instruction->handler_idx == VKD3DSIH_IDIV ? SpvOpSRem : SpvOpUMod; - - if (dst[0].reg.type != VKD3DSPR_NULL) - { -@@ -6957,7 +7092,7 @@ static void spirv_compiler_emit_udiv(struct spirv_compiler *compiler, - uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, - 0xffffffff, component_count); - -- val_id = vkd3d_spirv_build_op_udiv(builder, type_id, src0_id, src1_id); -+ val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, div_op, type_id, src0_id, src1_id); - /* The SPIR-V spec says: "The resulting value is undefined if Operand 2 is 0." */ - val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, val_id, uint_max_id); - -@@ -6980,7 +7115,7 @@ static void spirv_compiler_emit_udiv(struct spirv_compiler *compiler, - 0xffffffff, component_count); - } - -- val_id = vkd3d_spirv_build_op_umod(builder, type_id, src0_id, src1_id); -+ val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, mod_op, type_id, src0_id, src1_id); - /* The SPIR-V spec says: "The resulting value is undefined if Operand 2 is 0." */ - val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, val_id, uint_max_id); - -@@ -6988,6 +7123,106 @@ static void spirv_compiler_emit_udiv(struct spirv_compiler *compiler, - } - } - -+static void spirv_compiler_emit_ftoi(struct spirv_compiler *compiler, -+ const struct vkd3d_shader_instruction *instruction) -+{ -+ uint32_t src_id, int_min_id, int_max_id, zero_id, float_max_id, condition_id, val_id; -+ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -+ const struct vkd3d_shader_dst_param *dst = instruction->dst; -+ const struct vkd3d_shader_src_param *src = instruction->src; -+ uint32_t src_type_id, dst_type_id, condition_type_id; -+ enum vkd3d_shader_component_type component_type; -+ unsigned int component_count; -+ -+ assert(instruction->dst_count == 1); -+ assert(instruction->src_count == 1); -+ -+ /* OpConvertFToI has undefined results if the result cannot be represented -+ * as a signed integer, but Direct3D expects the result to saturate, -+ * and for NaN to yield zero. */ -+ -+ component_count = vkd3d_write_mask_component_count(dst->write_mask); -+ src_type_id = spirv_compiler_get_type_id_for_reg(compiler, &src->reg, dst->write_mask); -+ dst_type_id = spirv_compiler_get_type_id_for_dst(compiler, dst); -+ src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask); -+ -+ if (src->reg.data_type == VKD3D_DATA_DOUBLE) -+ { -+ int_min_id = spirv_compiler_get_constant_double_vector(compiler, -2147483648.0, component_count); -+ float_max_id = spirv_compiler_get_constant_double_vector(compiler, 2147483648.0, component_count); -+ } -+ else -+ { -+ int_min_id = spirv_compiler_get_constant_float_vector(compiler, -2147483648.0f, component_count); -+ float_max_id = spirv_compiler_get_constant_float_vector(compiler, 2147483648.0f, component_count); -+ } -+ -+ val_id = vkd3d_spirv_build_op_glsl_std450_max(builder, src_type_id, src_id, int_min_id); -+ -+ /* VSIR allows the destination of a signed conversion to be unsigned. */ -+ component_type = vkd3d_component_type_from_data_type(dst->reg.data_type); -+ -+ int_max_id = spirv_compiler_get_constant_vector(compiler, component_type, component_count, INT_MAX); -+ condition_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); -+ condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, -+ SpvOpFOrdGreaterThanEqual, condition_type_id, val_id, float_max_id); -+ -+ val_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpConvertFToS, dst_type_id, val_id); -+ val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, int_max_id, val_id); -+ -+ zero_id = spirv_compiler_get_constant_vector(compiler, component_type, component_count, 0); -+ condition_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpIsNan, condition_type_id, src_id); -+ val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, zero_id, val_id); -+ -+ spirv_compiler_emit_store_dst(compiler, dst, val_id); -+} -+ -+static void spirv_compiler_emit_ftou(struct spirv_compiler *compiler, -+ const struct vkd3d_shader_instruction *instruction) -+{ -+ uint32_t src_id, zero_id, uint_max_id, float_max_id, condition_id, val_id; -+ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; -+ const struct vkd3d_shader_dst_param *dst = instruction->dst; -+ const struct vkd3d_shader_src_param *src = instruction->src; -+ uint32_t src_type_id, dst_type_id, condition_type_id; -+ unsigned int component_count; -+ -+ assert(instruction->dst_count == 1); -+ assert(instruction->src_count == 1); -+ -+ /* OpConvertFToU has undefined results if the result cannot be represented -+ * as an unsigned integer, but Direct3D expects the result to saturate, -+ * and for NaN to yield zero. */ -+ -+ component_count = vkd3d_write_mask_component_count(dst->write_mask); -+ src_type_id = spirv_compiler_get_type_id_for_reg(compiler, &src->reg, dst->write_mask); -+ dst_type_id = spirv_compiler_get_type_id_for_dst(compiler, dst); -+ src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask); -+ -+ if (src->reg.data_type == VKD3D_DATA_DOUBLE) -+ { -+ zero_id = spirv_compiler_get_constant_double_vector(compiler, 0.0, component_count); -+ float_max_id = spirv_compiler_get_constant_double_vector(compiler, 4294967296.0, component_count); -+ } -+ else -+ { -+ zero_id = spirv_compiler_get_constant_float_vector(compiler, 0.0f, component_count); -+ float_max_id = spirv_compiler_get_constant_float_vector(compiler, 4294967296.0f, component_count); -+ } -+ -+ val_id = vkd3d_spirv_build_op_glsl_std450_max(builder, src_type_id, src_id, zero_id); -+ -+ uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, UINT_MAX, component_count); -+ condition_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); -+ condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, -+ SpvOpFOrdGreaterThanEqual, condition_type_id, val_id, float_max_id); -+ -+ val_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpConvertFToU, dst_type_id, val_id); -+ val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, uint_max_id, val_id); -+ -+ spirv_compiler_emit_store_dst(compiler, dst, val_id); -+} -+ - static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) - { -@@ -7123,18 +7358,22 @@ static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *co - - switch (instruction->handler_idx) - { -- case VKD3DSIH_DEQ: -- case VKD3DSIH_EQ: op = SpvOpFOrdEqual; break; -- case VKD3DSIH_DGE: -- case VKD3DSIH_GE: op = SpvOpFOrdGreaterThanEqual; break; -+ case VKD3DSIH_DEQO: -+ case VKD3DSIH_EQO: op = SpvOpFOrdEqual; break; -+ case VKD3DSIH_EQU: op = SpvOpFUnordEqual; break; -+ case VKD3DSIH_DGEO: -+ case VKD3DSIH_GEO: op = SpvOpFOrdGreaterThanEqual; break; -+ case VKD3DSIH_GEU: op = SpvOpFUnordGreaterThanEqual; break; - case VKD3DSIH_IEQ: op = SpvOpIEqual; break; - case VKD3DSIH_IGE: op = SpvOpSGreaterThanEqual; break; - case VKD3DSIH_ILT: op = SpvOpSLessThan; break; - case VKD3DSIH_INE: op = SpvOpINotEqual; break; - case VKD3DSIH_DLT: -- case VKD3DSIH_LT: op = SpvOpFOrdLessThan; break; -+ case VKD3DSIH_LTO: op = SpvOpFOrdLessThan; break; -+ case VKD3DSIH_LTU: op = SpvOpFUnordLessThan; break; -+ case VKD3DSIH_NEO: op = SpvOpFOrdNotEqual; break; - case VKD3DSIH_DNE: -- case VKD3DSIH_NE: op = SpvOpFUnordNotEqual; break; -+ case VKD3DSIH_NEU: op = SpvOpFUnordNotEqual; break; - case VKD3DSIH_UGE: op = SpvOpUGreaterThanEqual; break; - case VKD3DSIH_ULT: op = SpvOpULessThan; break; - default: -@@ -7151,7 +7390,8 @@ static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *co - result_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, - op, type_id, src0_id, src1_id); - -- result_id = spirv_compiler_emit_bool_to_int(compiler, component_count, result_id); -+ if (dst->reg.data_type != VKD3D_DATA_BOOL) -+ result_id = spirv_compiler_emit_bool_to_int(compiler, component_count, result_id, true); - spirv_compiler_emit_store_reg(compiler, &dst->reg, dst->write_mask, result_id); - } - -@@ -9175,16 +9415,12 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - case VKD3DSIH_DCL_TGSM_STRUCTURED: - spirv_compiler_emit_dcl_tgsm_structured(compiler, instruction); - break; -+ case VKD3DSIH_DCL_INPUT_PS: - case VKD3DSIH_DCL_INPUT: - spirv_compiler_emit_dcl_input(compiler, instruction); - break; -- case VKD3DSIH_DCL_INPUT_PS: -- spirv_compiler_emit_dcl_input_ps(compiler, instruction); -- break; - case VKD3DSIH_DCL_INPUT_PS_SGV: - case VKD3DSIH_DCL_INPUT_PS_SIV: -- spirv_compiler_emit_dcl_input_ps_sysval(compiler, instruction); -- break; - case VKD3DSIH_DCL_INPUT_SGV: - case VKD3DSIH_DCL_INPUT_SIV: - spirv_compiler_emit_dcl_input_sysval(compiler, instruction); -@@ -9210,11 +9446,7 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - case VKD3DSIH_DCL_GS_INSTANCES: - spirv_compiler_emit_dcl_gs_instances(compiler, instruction); - break; -- case VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT: -- compiler->input_control_point_count = instruction->declaration.count; -- break; - case VKD3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT: -- compiler->output_control_point_count = instruction->declaration.count; - spirv_compiler_emit_output_vertex_count(compiler, instruction); - break; - case VKD3DSIH_DCL_TESSELLATOR_DOMAIN: -@@ -9256,25 +9488,24 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - case VKD3DSIH_DIV: - case VKD3DSIH_DMUL: - case VKD3DSIH_DTOF: -- case VKD3DSIH_DTOI: -- case VKD3DSIH_DTOU: -+ case VKD3DSIH_FREM: - case VKD3DSIH_FTOD: -- case VKD3DSIH_FTOI: -- case VKD3DSIH_FTOU: - case VKD3DSIH_IADD: - case VKD3DSIH_INEG: - case VKD3DSIH_ISHL: - case VKD3DSIH_ISHR: - case VKD3DSIH_ITOD: - case VKD3DSIH_ITOF: -+ case VKD3DSIH_ITOI: - case VKD3DSIH_MUL: - case VKD3DSIH_NOT: - case VKD3DSIH_OR: - case VKD3DSIH_USHR: - case VKD3DSIH_UTOD: - case VKD3DSIH_UTOF: -+ case VKD3DSIH_UTOU: - case VKD3DSIH_XOR: -- spirv_compiler_emit_alu_instruction(compiler, instruction); -+ ret = spirv_compiler_emit_alu_instruction(compiler, instruction); - break; - case VKD3DSIH_DFMA: - case VKD3DSIH_DMAX: -@@ -9313,26 +9544,40 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - spirv_compiler_emit_sincos(compiler, instruction); - break; - case VKD3DSIH_IMUL: -+ case VKD3DSIH_UMUL: - spirv_compiler_emit_imul(compiler, instruction); - break; - case VKD3DSIH_IMAD: - spirv_compiler_emit_imad(compiler, instruction); - break; -+ case VKD3DSIH_IDIV: - case VKD3DSIH_UDIV: -- spirv_compiler_emit_udiv(compiler, instruction); -+ spirv_compiler_emit_int_div(compiler, instruction); - break; -- case VKD3DSIH_DEQ: -- case VKD3DSIH_DGE: -+ case VKD3DSIH_DTOI: -+ case VKD3DSIH_FTOI: -+ spirv_compiler_emit_ftoi(compiler, instruction); -+ break; -+ case VKD3DSIH_DTOU: -+ case VKD3DSIH_FTOU: -+ spirv_compiler_emit_ftou(compiler, instruction); -+ break; -+ case VKD3DSIH_DEQO: -+ case VKD3DSIH_DGEO: - case VKD3DSIH_DLT: - case VKD3DSIH_DNE: -- case VKD3DSIH_EQ: -- case VKD3DSIH_GE: -+ case VKD3DSIH_EQO: -+ case VKD3DSIH_EQU: -+ case VKD3DSIH_GEO: -+ case VKD3DSIH_GEU: - case VKD3DSIH_IEQ: - case VKD3DSIH_IGE: - case VKD3DSIH_ILT: - case VKD3DSIH_INE: -- case VKD3DSIH_LT: -- case VKD3DSIH_NE: -+ case VKD3DSIH_LTO: -+ case VKD3DSIH_LTU: -+ case VKD3DSIH_NEO: -+ case VKD3DSIH_NEU: - case VKD3DSIH_UGE: - case VKD3DSIH_ULT: - spirv_compiler_emit_comparison_instruction(compiler, instruction); -@@ -9467,6 +9712,7 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - case VKD3DSIH_DCL: - case VKD3DSIH_DCL_CONSTANT_BUFFER: - case VKD3DSIH_DCL_HS_MAX_TESSFACTOR: -+ case VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT: - case VKD3DSIH_DCL_RESOURCE_RAW: - case VKD3DSIH_DCL_RESOURCE_STRUCTURED: - case VKD3DSIH_DCL_SAMPLER: -@@ -9480,6 +9726,9 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, - break; - default: - FIXME("Unhandled instruction %#x.\n", instruction->handler_idx); -+ spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER, -+ "Encountered invalid/unhandled instruction handler %#x.", instruction->handler_idx); -+ break; - } - - return ret; -@@ -9543,6 +9792,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, - - if (parser->shader_desc.temp_count) - spirv_compiler_emit_temps(compiler, parser->shader_desc.temp_count); -+ if (parser->shader_desc.ssa_count) -+ spirv_compiler_allocate_ssa_register_ids(compiler, parser->shader_desc.ssa_count); - - spirv_compiler_emit_descriptor_declarations(compiler); - -@@ -9561,6 +9812,10 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, - memset(&shader_desc->input_signature, 0, sizeof(shader_desc->input_signature)); - memset(&shader_desc->output_signature, 0, sizeof(shader_desc->output_signature)); - memset(&shader_desc->patch_constant_signature, 0, sizeof(shader_desc->patch_constant_signature)); -+ compiler->use_vocp = parser->shader_desc.use_vocp; -+ -+ compiler->input_control_point_count = shader_desc->input_control_point_count; -+ compiler->output_control_point_count = shader_desc->output_control_point_count; - - if (compiler->shader_type != VKD3D_SHADER_TYPE_HULL) - spirv_compiler_emit_shader_signature_outputs(compiler); -diff --git a/libs/vkd3d/libs/vkd3d-shader/tpf.c b/libs/vkd3d/libs/vkd3d-shader/tpf.c -index 045fb6c5f64..61d14e30d3c 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/tpf.c -+++ b/libs/vkd3d/libs/vkd3d-shader/tpf.c -@@ -146,6 +146,9 @@ STATIC_ASSERT(SM4_MAX_SRC_COUNT <= SPIRV_MAX_SRC_COUNT); - #define VKD3D_SM4_SWIZZLE_SHIFT 4 - #define VKD3D_SM4_SWIZZLE_MASK (0xffu << VKD3D_SM4_SWIZZLE_SHIFT) - -+#define VKD3D_SM4_SCALAR_DIM_SHIFT 4 -+#define VKD3D_SM4_SCALAR_DIM_MASK (0x3u << VKD3D_SM4_SCALAR_DIM_SHIFT) -+ - #define VKD3D_SM4_VERSION_MAJOR(version) (((version) >> 4) & 0xf) - #define VKD3D_SM4_VERSION_MINOR(version) (((version) >> 0) & 0xf) - -@@ -383,6 +386,8 @@ enum vkd3d_sm4_opcode - VKD3D_SM5_OP_SAMPLE_GRAD_CL_S = 0xe8, - VKD3D_SM5_OP_SAMPLE_C_CL_S = 0xe9, - VKD3D_SM5_OP_CHECK_ACCESS_FULLY_MAPPED = 0xea, -+ -+ VKD3D_SM4_OP_COUNT, - }; - - enum vkd3d_sm4_instruction_modifier -@@ -510,6 +515,9 @@ enum vkd3d_sm4_swizzle_type - VKD3D_SM4_SWIZZLE_NONE = 0x0, /* swizzle bitfield contains a mask */ - VKD3D_SM4_SWIZZLE_VEC4 = 0x1, - VKD3D_SM4_SWIZZLE_SCALAR = 0x2, -+ -+ VKD3D_SM4_SWIZZLE_DEFAULT = ~0u - 1, -+ VKD3D_SM4_SWIZZLE_INVALID = ~0u, - }; - - enum vkd3d_sm4_dimension -@@ -519,6 +527,38 @@ enum vkd3d_sm4_dimension - VKD3D_SM4_DIMENSION_VEC4 = 0x2, - }; - -+static enum vsir_dimension vsir_dimension_from_sm4_dimension(enum vkd3d_sm4_dimension dim) -+{ -+ switch (dim) -+ { -+ case VKD3D_SM4_DIMENSION_NONE: -+ return VSIR_DIMENSION_NONE; -+ case VKD3D_SM4_DIMENSION_SCALAR: -+ return VSIR_DIMENSION_SCALAR; -+ case VKD3D_SM4_DIMENSION_VEC4: -+ return VSIR_DIMENSION_VEC4; -+ default: -+ FIXME("Unknown SM4 dimension %#x.\n", dim); -+ return VSIR_DIMENSION_NONE; -+ } -+} -+ -+static enum vkd3d_sm4_dimension sm4_dimension_from_vsir_dimension(enum vsir_dimension dim) -+{ -+ switch (dim) -+ { -+ case VSIR_DIMENSION_NONE: -+ return VKD3D_SM4_DIMENSION_NONE; -+ case VSIR_DIMENSION_SCALAR: -+ return VKD3D_SM4_DIMENSION_SCALAR; -+ case VSIR_DIMENSION_VEC4: -+ return VKD3D_SM4_DIMENSION_VEC4; -+ case VSIR_DIMENSION_COUNT: -+ vkd3d_unreachable(); -+ } -+ vkd3d_unreachable(); -+} -+ - enum vkd3d_sm4_resource_type - { - VKD3D_SM4_RESOURCE_BUFFER = 0x1, -@@ -575,6 +615,7 @@ struct sm4_index_range_array - - struct vkd3d_sm4_lookup_tables - { -+ const struct vkd3d_sm4_opcode_info *opcode_info_from_sm4[VKD3D_SM4_OP_COUNT]; - const struct vkd3d_sm4_register_type_info *register_type_info_from_sm4[VKD3D_SM4_REGISTER_TYPE_COUNT]; - const struct vkd3d_sm4_register_type_info *register_type_info_from_vkd3d[VKD3DSPR_COUNT]; - }; -@@ -583,8 +624,6 @@ struct vkd3d_shader_sm4_parser - { - const uint32_t *start, *end, *ptr; - -- unsigned int output_map[MAX_REG_OUTPUT]; -- - enum vkd3d_shader_opcode phase; - bool has_control_point_phase; - unsigned int input_register_masks[MAX_REG_OUTPUT]; -@@ -620,16 +659,18 @@ static const enum vkd3d_primitive_type output_primitive_type_table[] = - /* VKD3D_SM4_OUTPUT_PT_TRIANGLESTRIP */ VKD3D_PT_TRIANGLESTRIP, - }; - --static const enum vkd3d_primitive_type input_primitive_type_table[] = -+static const struct - { -- /* UNKNOWN */ VKD3D_PT_UNDEFINED, -- /* VKD3D_SM4_INPUT_PT_POINT */ VKD3D_PT_POINTLIST, -- /* VKD3D_SM4_INPUT_PT_LINE */ VKD3D_PT_LINELIST, -- /* VKD3D_SM4_INPUT_PT_TRIANGLE */ VKD3D_PT_TRIANGLELIST, -- /* UNKNOWN */ VKD3D_PT_UNDEFINED, -- /* UNKNOWN */ VKD3D_PT_UNDEFINED, -- /* VKD3D_SM4_INPUT_PT_LINEADJ */ VKD3D_PT_LINELIST_ADJ, -- /* VKD3D_SM4_INPUT_PT_TRIANGLEADJ */ VKD3D_PT_TRIANGLELIST_ADJ, -+ unsigned int control_point_count; -+ enum vkd3d_primitive_type vkd3d_type; -+} -+input_primitive_type_table[] = -+{ -+ [VKD3D_SM4_INPUT_PT_POINT] = {1, VKD3D_PT_POINTLIST}, -+ [VKD3D_SM4_INPUT_PT_LINE] = {2, VKD3D_PT_LINELIST}, -+ [VKD3D_SM4_INPUT_PT_TRIANGLE] = {3, VKD3D_PT_TRIANGLELIST}, -+ [VKD3D_SM4_INPUT_PT_LINEADJ] = {4, VKD3D_PT_LINELIST_ADJ}, -+ [VKD3D_SM4_INPUT_PT_TRIANGLEADJ] = {6, VKD3D_PT_TRIANGLELIST_ADJ}, - }; - - static const enum vkd3d_shader_resource_type resource_type_table[] = -@@ -751,7 +792,9 @@ static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins, ui - ins->handler_idx = VKD3DSIH_INVALID; - return; - } -- icb->vec4_count = icb_size / 4; -+ icb->data_type = VKD3D_DATA_FLOAT; -+ icb->component_count = VKD3D_VEC4_SIZE; -+ icb->element_count = icb_size / VKD3D_VEC4_SIZE; - memcpy(icb->data, tokens, sizeof(*tokens) * icb_size); - shader_instruction_array_add_icb(&priv->p.instructions, icb); - ins->declaration.icb = icb; -@@ -849,6 +892,8 @@ static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction - ins->declaration.cb.size = *tokens++; - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.cb.range.space); - } -+ -+ ins->declaration.cb.size *= VKD3D_VEC4_SIZE * sizeof(float); - } - - static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token, -@@ -994,6 +1039,7 @@ static void shader_sm4_read_dcl_input_primitive(struct vkd3d_shader_instruction - { - ins->declaration.primitive_type.type = VKD3D_PT_PATCH; - ins->declaration.primitive_type.patch_vertex_count = primitive_type - VKD3D_SM5_INPUT_PT_PATCH1 + 1; -+ priv->p.shader_desc.input_control_point_count = ins->declaration.primitive_type.patch_vertex_count; - } - else if (primitive_type >= ARRAY_SIZE(input_primitive_type_table)) - { -@@ -1001,7 +1047,8 @@ static void shader_sm4_read_dcl_input_primitive(struct vkd3d_shader_instruction - } - else - { -- ins->declaration.primitive_type.type = input_primitive_type_table[primitive_type]; -+ ins->declaration.primitive_type.type = input_primitive_type_table[primitive_type].vkd3d_type; -+ priv->p.shader_desc.input_control_point_count = input_primitive_type_table[primitive_type].control_point_count; - } - - if (ins->declaration.primitive_type.type == VKD3D_PT_UNDEFINED) -@@ -1033,16 +1080,31 @@ static void shader_sm4_read_declaration_register_semantic(struct vkd3d_shader_in - static void shader_sm4_read_dcl_input_ps(struct vkd3d_shader_instruction *ins, uint32_t opcode, - uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv) - { -+ struct vkd3d_shader_dst_param *dst = &ins->declaration.dst; -+ - ins->flags = (opcode_token & VKD3D_SM4_INTERPOLATION_MODE_MASK) >> VKD3D_SM4_INTERPOLATION_MODE_SHIFT; -- shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, &ins->declaration.dst); -+ if (shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, dst)) -+ { -+ struct signature_element *e = vsir_signature_find_element_for_reg( -+ &priv->p.shader_desc.input_signature, dst->reg.idx[dst->reg.idx_count - 1].offset, dst->write_mask); -+ -+ e->interpolation_mode = ins->flags; -+ } - } - - static void shader_sm4_read_dcl_input_ps_siv(struct vkd3d_shader_instruction *ins, uint32_t opcode, - uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv) - { -+ struct vkd3d_shader_dst_param *dst = &ins->declaration.register_semantic.reg; -+ - ins->flags = (opcode_token & VKD3D_SM4_INTERPOLATION_MODE_MASK) >> VKD3D_SM4_INTERPOLATION_MODE_SHIFT; -- shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, -- &ins->declaration.register_semantic.reg); -+ if (shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, dst)) -+ { -+ struct signature_element *e = vsir_signature_find_element_for_reg( -+ &priv->p.shader_desc.input_signature, dst->reg.idx[dst->reg.idx_count - 1].offset, dst->write_mask); -+ -+ e->interpolation_mode = ins->flags; -+ } - ins->declaration.register_semantic.sysval_semantic = *tokens; - } - -@@ -1051,13 +1113,15 @@ static void shader_sm4_read_dcl_indexable_temp(struct vkd3d_shader_instruction * - { - ins->declaration.indexable_temp.register_idx = *tokens++; - ins->declaration.indexable_temp.register_size = *tokens++; -+ ins->declaration.indexable_temp.alignment = 0; -+ ins->declaration.indexable_temp.data_type = VKD3D_DATA_FLOAT; - ins->declaration.indexable_temp.component_count = *tokens; - } - - static void shader_sm4_read_dcl_global_flags(struct vkd3d_shader_instruction *ins, uint32_t opcode, - uint32_t opcode_token, const uint32_t *tokens, unsigned int token_count, struct vkd3d_shader_sm4_parser *priv) - { -- ins->flags = (opcode_token & VKD3D_SM4_GLOBAL_FLAGS_MASK) >> VKD3D_SM4_GLOBAL_FLAGS_SHIFT; -+ ins->declaration.global_flags = (opcode_token & VKD3D_SM4_GLOBAL_FLAGS_MASK) >> VKD3D_SM4_GLOBAL_FLAGS_SHIFT; - } - - static void shader_sm5_read_fcall(struct vkd3d_shader_instruction *ins, uint32_t opcode, uint32_t opcode_token, -@@ -1096,6 +1160,11 @@ static void shader_sm5_read_control_point_count(struct vkd3d_shader_instruction - { - ins->declaration.count = (opcode_token & VKD3D_SM5_CONTROL_POINT_COUNT_MASK) - >> VKD3D_SM5_CONTROL_POINT_COUNT_SHIFT; -+ -+ if (opcode == VKD3D_SM5_OP_DCL_INPUT_CONTROL_POINT_COUNT) -+ priv->p.shader_desc.input_control_point_count = ins->declaration.count; -+ else -+ priv->p.shader_desc.output_control_point_count = ins->declaration.count; - } - - static void shader_sm5_read_dcl_tessellator_domain(struct vkd3d_shader_instruction *ins, uint32_t opcode, -@@ -1211,291 +1280,13 @@ static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins, uint32_t - ins->flags = (opcode_token & VKD3D_SM5_SYNC_FLAGS_MASK) >> VKD3D_SM5_SYNC_FLAGS_SHIFT; - } - --/* -- * d -> VKD3D_DATA_DOUBLE -- * f -> VKD3D_DATA_FLOAT -- * i -> VKD3D_DATA_INT -- * u -> VKD3D_DATA_UINT -- * O -> VKD3D_DATA_OPAQUE -- * R -> VKD3D_DATA_RESOURCE -- * S -> VKD3D_DATA_SAMPLER -- * U -> VKD3D_DATA_UAV -- */ --static const struct vkd3d_sm4_opcode_info opcode_table[] = --{ -- {VKD3D_SM4_OP_ADD, VKD3DSIH_ADD, "f", "ff"}, -- {VKD3D_SM4_OP_AND, VKD3DSIH_AND, "u", "uu"}, -- {VKD3D_SM4_OP_BREAK, VKD3DSIH_BREAK, "", ""}, -- {VKD3D_SM4_OP_BREAKC, VKD3DSIH_BREAKP, "", "u", -- shader_sm4_read_conditional_op}, -- {VKD3D_SM4_OP_CASE, VKD3DSIH_CASE, "", "u", -- shader_sm4_read_case_condition}, -- {VKD3D_SM4_OP_CONTINUE, VKD3DSIH_CONTINUE, "", ""}, -- {VKD3D_SM4_OP_CONTINUEC, VKD3DSIH_CONTINUEP, "", "u", -- shader_sm4_read_conditional_op}, -- {VKD3D_SM4_OP_CUT, VKD3DSIH_CUT, "", ""}, -- {VKD3D_SM4_OP_DEFAULT, VKD3DSIH_DEFAULT, "", ""}, -- {VKD3D_SM4_OP_DERIV_RTX, VKD3DSIH_DSX, "f", "f"}, -- {VKD3D_SM4_OP_DERIV_RTY, VKD3DSIH_DSY, "f", "f"}, -- {VKD3D_SM4_OP_DISCARD, VKD3DSIH_DISCARD, "", "u", -- shader_sm4_read_conditional_op}, -- {VKD3D_SM4_OP_DIV, VKD3DSIH_DIV, "f", "ff"}, -- {VKD3D_SM4_OP_DP2, VKD3DSIH_DP2, "f", "ff"}, -- {VKD3D_SM4_OP_DP3, VKD3DSIH_DP3, "f", "ff"}, -- {VKD3D_SM4_OP_DP4, VKD3DSIH_DP4, "f", "ff"}, -- {VKD3D_SM4_OP_ELSE, VKD3DSIH_ELSE, "", ""}, -- {VKD3D_SM4_OP_EMIT, VKD3DSIH_EMIT, "", ""}, -- {VKD3D_SM4_OP_ENDIF, VKD3DSIH_ENDIF, "", ""}, -- {VKD3D_SM4_OP_ENDLOOP, VKD3DSIH_ENDLOOP, "", ""}, -- {VKD3D_SM4_OP_ENDSWITCH, VKD3DSIH_ENDSWITCH, "", ""}, -- {VKD3D_SM4_OP_EQ, VKD3DSIH_EQ, "u", "ff"}, -- {VKD3D_SM4_OP_EXP, VKD3DSIH_EXP, "f", "f"}, -- {VKD3D_SM4_OP_FRC, VKD3DSIH_FRC, "f", "f"}, -- {VKD3D_SM4_OP_FTOI, VKD3DSIH_FTOI, "i", "f"}, -- {VKD3D_SM4_OP_FTOU, VKD3DSIH_FTOU, "u", "f"}, -- {VKD3D_SM4_OP_GE, VKD3DSIH_GE, "u", "ff"}, -- {VKD3D_SM4_OP_IADD, VKD3DSIH_IADD, "i", "ii"}, -- {VKD3D_SM4_OP_IF, VKD3DSIH_IF, "", "u", -- shader_sm4_read_conditional_op}, -- {VKD3D_SM4_OP_IEQ, VKD3DSIH_IEQ, "u", "ii"}, -- {VKD3D_SM4_OP_IGE, VKD3DSIH_IGE, "u", "ii"}, -- {VKD3D_SM4_OP_ILT, VKD3DSIH_ILT, "u", "ii"}, -- {VKD3D_SM4_OP_IMAD, VKD3DSIH_IMAD, "i", "iii"}, -- {VKD3D_SM4_OP_IMAX, VKD3DSIH_IMAX, "i", "ii"}, -- {VKD3D_SM4_OP_IMIN, VKD3DSIH_IMIN, "i", "ii"}, -- {VKD3D_SM4_OP_IMUL, VKD3DSIH_IMUL, "ii", "ii"}, -- {VKD3D_SM4_OP_INE, VKD3DSIH_INE, "u", "ii"}, -- {VKD3D_SM4_OP_INEG, VKD3DSIH_INEG, "i", "i"}, -- {VKD3D_SM4_OP_ISHL, VKD3DSIH_ISHL, "i", "ii"}, -- {VKD3D_SM4_OP_ISHR, VKD3DSIH_ISHR, "i", "ii"}, -- {VKD3D_SM4_OP_ITOF, VKD3DSIH_ITOF, "f", "i"}, -- {VKD3D_SM4_OP_LABEL, VKD3DSIH_LABEL, "", "O"}, -- {VKD3D_SM4_OP_LD, VKD3DSIH_LD, "u", "iR"}, -- {VKD3D_SM4_OP_LD2DMS, VKD3DSIH_LD2DMS, "u", "iRi"}, -- {VKD3D_SM4_OP_LOG, VKD3DSIH_LOG, "f", "f"}, -- {VKD3D_SM4_OP_LOOP, VKD3DSIH_LOOP, "", ""}, -- {VKD3D_SM4_OP_LT, VKD3DSIH_LT, "u", "ff"}, -- {VKD3D_SM4_OP_MAD, VKD3DSIH_MAD, "f", "fff"}, -- {VKD3D_SM4_OP_MIN, VKD3DSIH_MIN, "f", "ff"}, -- {VKD3D_SM4_OP_MAX, VKD3DSIH_MAX, "f", "ff"}, -- {VKD3D_SM4_OP_SHADER_DATA, VKD3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER, "", "", -- shader_sm4_read_shader_data}, -- {VKD3D_SM4_OP_MOV, VKD3DSIH_MOV, "f", "f"}, -- {VKD3D_SM4_OP_MOVC, VKD3DSIH_MOVC, "f", "uff"}, -- {VKD3D_SM4_OP_MUL, VKD3DSIH_MUL, "f", "ff"}, -- {VKD3D_SM4_OP_NE, VKD3DSIH_NE, "u", "ff"}, -- {VKD3D_SM4_OP_NOP, VKD3DSIH_NOP, "", ""}, -- {VKD3D_SM4_OP_NOT, VKD3DSIH_NOT, "u", "u"}, -- {VKD3D_SM4_OP_OR, VKD3DSIH_OR, "u", "uu"}, -- {VKD3D_SM4_OP_RESINFO, VKD3DSIH_RESINFO, "f", "iR"}, -- {VKD3D_SM4_OP_RET, VKD3DSIH_RET, "", ""}, -- {VKD3D_SM4_OP_RETC, VKD3DSIH_RETP, "", "u", -- shader_sm4_read_conditional_op}, -- {VKD3D_SM4_OP_ROUND_NE, VKD3DSIH_ROUND_NE, "f", "f"}, -- {VKD3D_SM4_OP_ROUND_NI, VKD3DSIH_ROUND_NI, "f", "f"}, -- {VKD3D_SM4_OP_ROUND_PI, VKD3DSIH_ROUND_PI, "f", "f"}, -- {VKD3D_SM4_OP_ROUND_Z, VKD3DSIH_ROUND_Z, "f", "f"}, -- {VKD3D_SM4_OP_RSQ, VKD3DSIH_RSQ, "f", "f"}, -- {VKD3D_SM4_OP_SAMPLE, VKD3DSIH_SAMPLE, "u", "fRS"}, -- {VKD3D_SM4_OP_SAMPLE_C, VKD3DSIH_SAMPLE_C, "f", "fRSf"}, -- {VKD3D_SM4_OP_SAMPLE_C_LZ, VKD3DSIH_SAMPLE_C_LZ, "f", "fRSf"}, -- {VKD3D_SM4_OP_SAMPLE_LOD, VKD3DSIH_SAMPLE_LOD, "u", "fRSf"}, -- {VKD3D_SM4_OP_SAMPLE_GRAD, VKD3DSIH_SAMPLE_GRAD, "u", "fRSff"}, -- {VKD3D_SM4_OP_SAMPLE_B, VKD3DSIH_SAMPLE_B, "u", "fRSf"}, -- {VKD3D_SM4_OP_SQRT, VKD3DSIH_SQRT, "f", "f"}, -- {VKD3D_SM4_OP_SWITCH, VKD3DSIH_SWITCH, "", "i"}, -- {VKD3D_SM4_OP_SINCOS, VKD3DSIH_SINCOS, "ff", "f"}, -- {VKD3D_SM4_OP_UDIV, VKD3DSIH_UDIV, "uu", "uu"}, -- {VKD3D_SM4_OP_ULT, VKD3DSIH_ULT, "u", "uu"}, -- {VKD3D_SM4_OP_UGE, VKD3DSIH_UGE, "u", "uu"}, -- {VKD3D_SM4_OP_UMUL, VKD3DSIH_UMUL, "uu", "uu"}, -- {VKD3D_SM4_OP_UMAX, VKD3DSIH_UMAX, "u", "uu"}, -- {VKD3D_SM4_OP_UMIN, VKD3DSIH_UMIN, "u", "uu"}, -- {VKD3D_SM4_OP_USHR, VKD3DSIH_USHR, "u", "uu"}, -- {VKD3D_SM4_OP_UTOF, VKD3DSIH_UTOF, "f", "u"}, -- {VKD3D_SM4_OP_XOR, VKD3DSIH_XOR, "u", "uu"}, -- {VKD3D_SM4_OP_DCL_RESOURCE, VKD3DSIH_DCL, "", "", -- shader_sm4_read_dcl_resource}, -- {VKD3D_SM4_OP_DCL_CONSTANT_BUFFER, VKD3DSIH_DCL_CONSTANT_BUFFER, "", "", -- shader_sm4_read_dcl_constant_buffer}, -- {VKD3D_SM4_OP_DCL_SAMPLER, VKD3DSIH_DCL_SAMPLER, "", "", -- shader_sm4_read_dcl_sampler}, -- {VKD3D_SM4_OP_DCL_INDEX_RANGE, VKD3DSIH_DCL_INDEX_RANGE, "", "", -- shader_sm4_read_dcl_index_range}, -- {VKD3D_SM4_OP_DCL_OUTPUT_TOPOLOGY, VKD3DSIH_DCL_OUTPUT_TOPOLOGY, "", "", -- shader_sm4_read_dcl_output_topology}, -- {VKD3D_SM4_OP_DCL_INPUT_PRIMITIVE, VKD3DSIH_DCL_INPUT_PRIMITIVE, "", "", -- shader_sm4_read_dcl_input_primitive}, -- {VKD3D_SM4_OP_DCL_VERTICES_OUT, VKD3DSIH_DCL_VERTICES_OUT, "", "", -- shader_sm4_read_declaration_count}, -- {VKD3D_SM4_OP_DCL_INPUT, VKD3DSIH_DCL_INPUT, "", "", -- shader_sm4_read_declaration_dst}, -- {VKD3D_SM4_OP_DCL_INPUT_SGV, VKD3DSIH_DCL_INPUT_SGV, "", "", -- shader_sm4_read_declaration_register_semantic}, -- {VKD3D_SM4_OP_DCL_INPUT_SIV, VKD3DSIH_DCL_INPUT_SIV, "", "", -- shader_sm4_read_declaration_register_semantic}, -- {VKD3D_SM4_OP_DCL_INPUT_PS, VKD3DSIH_DCL_INPUT_PS, "", "", -- shader_sm4_read_dcl_input_ps}, -- {VKD3D_SM4_OP_DCL_INPUT_PS_SGV, VKD3DSIH_DCL_INPUT_PS_SGV, "", "", -- shader_sm4_read_declaration_register_semantic}, -- {VKD3D_SM4_OP_DCL_INPUT_PS_SIV, VKD3DSIH_DCL_INPUT_PS_SIV, "", "", -- shader_sm4_read_dcl_input_ps_siv}, -- {VKD3D_SM4_OP_DCL_OUTPUT, VKD3DSIH_DCL_OUTPUT, "", "", -- shader_sm4_read_declaration_dst}, -- {VKD3D_SM4_OP_DCL_OUTPUT_SIV, VKD3DSIH_DCL_OUTPUT_SIV, "", "", -- shader_sm4_read_declaration_register_semantic}, -- {VKD3D_SM4_OP_DCL_TEMPS, VKD3DSIH_DCL_TEMPS, "", "", -- shader_sm4_read_declaration_count}, -- {VKD3D_SM4_OP_DCL_INDEXABLE_TEMP, VKD3DSIH_DCL_INDEXABLE_TEMP, "", "", -- shader_sm4_read_dcl_indexable_temp}, -- {VKD3D_SM4_OP_DCL_GLOBAL_FLAGS, VKD3DSIH_DCL_GLOBAL_FLAGS, "", "", -- shader_sm4_read_dcl_global_flags}, -- {VKD3D_SM4_OP_LOD, VKD3DSIH_LOD, "f", "fRS"}, -- {VKD3D_SM4_OP_GATHER4, VKD3DSIH_GATHER4, "u", "fRS"}, -- {VKD3D_SM4_OP_SAMPLE_POS, VKD3DSIH_SAMPLE_POS, "f", "Ru"}, -- {VKD3D_SM4_OP_SAMPLE_INFO, VKD3DSIH_SAMPLE_INFO, "f", "R"}, -- {VKD3D_SM5_OP_HS_DECLS, VKD3DSIH_HS_DECLS, "", ""}, -- {VKD3D_SM5_OP_HS_CONTROL_POINT_PHASE, VKD3DSIH_HS_CONTROL_POINT_PHASE, "", ""}, -- {VKD3D_SM5_OP_HS_FORK_PHASE, VKD3DSIH_HS_FORK_PHASE, "", ""}, -- {VKD3D_SM5_OP_HS_JOIN_PHASE, VKD3DSIH_HS_JOIN_PHASE, "", ""}, -- {VKD3D_SM5_OP_EMIT_STREAM, VKD3DSIH_EMIT_STREAM, "", "f"}, -- {VKD3D_SM5_OP_CUT_STREAM, VKD3DSIH_CUT_STREAM, "", "f"}, -- {VKD3D_SM5_OP_FCALL, VKD3DSIH_FCALL, "", "O", -- shader_sm5_read_fcall}, -- {VKD3D_SM5_OP_BUFINFO, VKD3DSIH_BUFINFO, "i", "U"}, -- {VKD3D_SM5_OP_DERIV_RTX_COARSE, VKD3DSIH_DSX_COARSE, "f", "f"}, -- {VKD3D_SM5_OP_DERIV_RTX_FINE, VKD3DSIH_DSX_FINE, "f", "f"}, -- {VKD3D_SM5_OP_DERIV_RTY_COARSE, VKD3DSIH_DSY_COARSE, "f", "f"}, -- {VKD3D_SM5_OP_DERIV_RTY_FINE, VKD3DSIH_DSY_FINE, "f", "f"}, -- {VKD3D_SM5_OP_GATHER4_C, VKD3DSIH_GATHER4_C, "f", "fRSf"}, -- {VKD3D_SM5_OP_GATHER4_PO, VKD3DSIH_GATHER4_PO, "f", "fiRS"}, -- {VKD3D_SM5_OP_GATHER4_PO_C, VKD3DSIH_GATHER4_PO_C, "f", "fiRSf"}, -- {VKD3D_SM5_OP_RCP, VKD3DSIH_RCP, "f", "f"}, -- {VKD3D_SM5_OP_F32TOF16, VKD3DSIH_F32TOF16, "u", "f"}, -- {VKD3D_SM5_OP_F16TOF32, VKD3DSIH_F16TOF32, "f", "u"}, -- {VKD3D_SM5_OP_COUNTBITS, VKD3DSIH_COUNTBITS, "u", "u"}, -- {VKD3D_SM5_OP_FIRSTBIT_HI, VKD3DSIH_FIRSTBIT_HI, "u", "u"}, -- {VKD3D_SM5_OP_FIRSTBIT_LO, VKD3DSIH_FIRSTBIT_LO, "u", "u"}, -- {VKD3D_SM5_OP_FIRSTBIT_SHI, VKD3DSIH_FIRSTBIT_SHI, "u", "i"}, -- {VKD3D_SM5_OP_UBFE, VKD3DSIH_UBFE, "u", "iiu"}, -- {VKD3D_SM5_OP_IBFE, VKD3DSIH_IBFE, "i", "iii"}, -- {VKD3D_SM5_OP_BFI, VKD3DSIH_BFI, "u", "iiuu"}, -- {VKD3D_SM5_OP_BFREV, VKD3DSIH_BFREV, "u", "u"}, -- {VKD3D_SM5_OP_SWAPC, VKD3DSIH_SWAPC, "ff", "uff"}, -- {VKD3D_SM5_OP_DCL_STREAM, VKD3DSIH_DCL_STREAM, "", "O"}, -- {VKD3D_SM5_OP_DCL_FUNCTION_BODY, VKD3DSIH_DCL_FUNCTION_BODY, "", "", -- shader_sm5_read_dcl_function_body}, -- {VKD3D_SM5_OP_DCL_FUNCTION_TABLE, VKD3DSIH_DCL_FUNCTION_TABLE, "", "", -- shader_sm5_read_dcl_function_table}, -- {VKD3D_SM5_OP_DCL_INTERFACE, VKD3DSIH_DCL_INTERFACE, "", "", -- shader_sm5_read_dcl_interface}, -- {VKD3D_SM5_OP_DCL_INPUT_CONTROL_POINT_COUNT, VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT, "", "", -- shader_sm5_read_control_point_count}, -- {VKD3D_SM5_OP_DCL_OUTPUT_CONTROL_POINT_COUNT, VKD3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT, "", "", -- shader_sm5_read_control_point_count}, -- {VKD3D_SM5_OP_DCL_TESSELLATOR_DOMAIN, VKD3DSIH_DCL_TESSELLATOR_DOMAIN, "", "", -- shader_sm5_read_dcl_tessellator_domain}, -- {VKD3D_SM5_OP_DCL_TESSELLATOR_PARTITIONING, VKD3DSIH_DCL_TESSELLATOR_PARTITIONING, "", "", -- shader_sm5_read_dcl_tessellator_partitioning}, -- {VKD3D_SM5_OP_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, VKD3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, "", "", -- shader_sm5_read_dcl_tessellator_output_primitive}, -- {VKD3D_SM5_OP_DCL_HS_MAX_TESSFACTOR, VKD3DSIH_DCL_HS_MAX_TESSFACTOR, "", "", -- shader_sm5_read_dcl_hs_max_tessfactor}, -- {VKD3D_SM5_OP_DCL_HS_FORK_PHASE_INSTANCE_COUNT, VKD3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT, "", "", -- shader_sm4_read_declaration_count}, -- {VKD3D_SM5_OP_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, VKD3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, "", "", -- shader_sm4_read_declaration_count}, -- {VKD3D_SM5_OP_DCL_THREAD_GROUP, VKD3DSIH_DCL_THREAD_GROUP, "", "", -- shader_sm5_read_dcl_thread_group}, -- {VKD3D_SM5_OP_DCL_UAV_TYPED, VKD3DSIH_DCL_UAV_TYPED, "", "", -- shader_sm4_read_dcl_resource}, -- {VKD3D_SM5_OP_DCL_UAV_RAW, VKD3DSIH_DCL_UAV_RAW, "", "", -- shader_sm5_read_dcl_uav_raw}, -- {VKD3D_SM5_OP_DCL_UAV_STRUCTURED, VKD3DSIH_DCL_UAV_STRUCTURED, "", "", -- shader_sm5_read_dcl_uav_structured}, -- {VKD3D_SM5_OP_DCL_TGSM_RAW, VKD3DSIH_DCL_TGSM_RAW, "", "", -- shader_sm5_read_dcl_tgsm_raw}, -- {VKD3D_SM5_OP_DCL_TGSM_STRUCTURED, VKD3DSIH_DCL_TGSM_STRUCTURED, "", "", -- shader_sm5_read_dcl_tgsm_structured}, -- {VKD3D_SM5_OP_DCL_RESOURCE_RAW, VKD3DSIH_DCL_RESOURCE_RAW, "", "", -- shader_sm5_read_dcl_resource_raw}, -- {VKD3D_SM5_OP_DCL_RESOURCE_STRUCTURED, VKD3DSIH_DCL_RESOURCE_STRUCTURED, "", "", -- shader_sm5_read_dcl_resource_structured}, -- {VKD3D_SM5_OP_LD_UAV_TYPED, VKD3DSIH_LD_UAV_TYPED, "u", "iU"}, -- {VKD3D_SM5_OP_STORE_UAV_TYPED, VKD3DSIH_STORE_UAV_TYPED, "U", "iu"}, -- {VKD3D_SM5_OP_LD_RAW, VKD3DSIH_LD_RAW, "u", "iU"}, -- {VKD3D_SM5_OP_STORE_RAW, VKD3DSIH_STORE_RAW, "U", "uu"}, -- {VKD3D_SM5_OP_LD_STRUCTURED, VKD3DSIH_LD_STRUCTURED, "u", "iiR"}, -- {VKD3D_SM5_OP_STORE_STRUCTURED, VKD3DSIH_STORE_STRUCTURED, "U", "iiu"}, -- {VKD3D_SM5_OP_ATOMIC_AND, VKD3DSIH_ATOMIC_AND, "U", "iu"}, -- {VKD3D_SM5_OP_ATOMIC_OR, VKD3DSIH_ATOMIC_OR, "U", "iu"}, -- {VKD3D_SM5_OP_ATOMIC_XOR, VKD3DSIH_ATOMIC_XOR, "U", "iu"}, -- {VKD3D_SM5_OP_ATOMIC_CMP_STORE, VKD3DSIH_ATOMIC_CMP_STORE, "U", "iuu"}, -- {VKD3D_SM5_OP_ATOMIC_IADD, VKD3DSIH_ATOMIC_IADD, "U", "ii"}, -- {VKD3D_SM5_OP_ATOMIC_IMAX, VKD3DSIH_ATOMIC_IMAX, "U", "ii"}, -- {VKD3D_SM5_OP_ATOMIC_IMIN, VKD3DSIH_ATOMIC_IMIN, "U", "ii"}, -- {VKD3D_SM5_OP_ATOMIC_UMAX, VKD3DSIH_ATOMIC_UMAX, "U", "iu"}, -- {VKD3D_SM5_OP_ATOMIC_UMIN, VKD3DSIH_ATOMIC_UMIN, "U", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_ALLOC, VKD3DSIH_IMM_ATOMIC_ALLOC, "u", "U"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_CONSUME, VKD3DSIH_IMM_ATOMIC_CONSUME, "u", "U"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_IADD, VKD3DSIH_IMM_ATOMIC_IADD, "uU", "ii"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_AND, VKD3DSIH_IMM_ATOMIC_AND, "uU", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_OR, VKD3DSIH_IMM_ATOMIC_OR, "uU", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_XOR, VKD3DSIH_IMM_ATOMIC_XOR, "uU", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_EXCH, VKD3DSIH_IMM_ATOMIC_EXCH, "uU", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_CMP_EXCH, VKD3DSIH_IMM_ATOMIC_CMP_EXCH, "uU", "iuu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_IMAX, VKD3DSIH_IMM_ATOMIC_IMAX, "iU", "ii"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_IMIN, VKD3DSIH_IMM_ATOMIC_IMIN, "iU", "ii"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_UMAX, VKD3DSIH_IMM_ATOMIC_UMAX, "uU", "iu"}, -- {VKD3D_SM5_OP_IMM_ATOMIC_UMIN, VKD3DSIH_IMM_ATOMIC_UMIN, "uU", "iu"}, -- {VKD3D_SM5_OP_SYNC, VKD3DSIH_SYNC, "", "", -- shader_sm5_read_sync}, -- {VKD3D_SM5_OP_DADD, VKD3DSIH_DADD, "d", "dd"}, -- {VKD3D_SM5_OP_DMAX, VKD3DSIH_DMAX, "d", "dd"}, -- {VKD3D_SM5_OP_DMIN, VKD3DSIH_DMIN, "d", "dd"}, -- {VKD3D_SM5_OP_DMUL, VKD3DSIH_DMUL, "d", "dd"}, -- {VKD3D_SM5_OP_DEQ, VKD3DSIH_DEQ, "u", "dd"}, -- {VKD3D_SM5_OP_DGE, VKD3DSIH_DGE, "u", "dd"}, -- {VKD3D_SM5_OP_DLT, VKD3DSIH_DLT, "u", "dd"}, -- {VKD3D_SM5_OP_DNE, VKD3DSIH_DNE, "u", "dd"}, -- {VKD3D_SM5_OP_DMOV, VKD3DSIH_DMOV, "d", "d"}, -- {VKD3D_SM5_OP_DMOVC, VKD3DSIH_DMOVC, "d", "udd"}, -- {VKD3D_SM5_OP_DTOF, VKD3DSIH_DTOF, "f", "d"}, -- {VKD3D_SM5_OP_FTOD, VKD3DSIH_FTOD, "d", "f"}, -- {VKD3D_SM5_OP_EVAL_SAMPLE_INDEX, VKD3DSIH_EVAL_SAMPLE_INDEX, "f", "fi"}, -- {VKD3D_SM5_OP_EVAL_CENTROID, VKD3DSIH_EVAL_CENTROID, "f", "f"}, -- {VKD3D_SM5_OP_DCL_GS_INSTANCES, VKD3DSIH_DCL_GS_INSTANCES, "", "", -- shader_sm4_read_declaration_count}, -- {VKD3D_SM5_OP_DDIV, VKD3DSIH_DDIV, "d", "dd"}, -- {VKD3D_SM5_OP_DFMA, VKD3DSIH_DFMA, "d", "ddd"}, -- {VKD3D_SM5_OP_DRCP, VKD3DSIH_DRCP, "d", "d"}, -- {VKD3D_SM5_OP_MSAD, VKD3DSIH_MSAD, "u", "uuu"}, -- {VKD3D_SM5_OP_DTOI, VKD3DSIH_DTOI, "i", "d"}, -- {VKD3D_SM5_OP_DTOU, VKD3DSIH_DTOU, "u", "d"}, -- {VKD3D_SM5_OP_ITOD, VKD3DSIH_ITOD, "d", "i"}, -- {VKD3D_SM5_OP_UTOD, VKD3DSIH_UTOD, "d", "u"}, -- {VKD3D_SM5_OP_GATHER4_S, VKD3DSIH_GATHER4_S, "uu", "fRS"}, -- {VKD3D_SM5_OP_GATHER4_C_S, VKD3DSIH_GATHER4_C_S, "fu", "fRSf"}, -- {VKD3D_SM5_OP_GATHER4_PO_S, VKD3DSIH_GATHER4_PO_S, "fu", "fiRS"}, -- {VKD3D_SM5_OP_GATHER4_PO_C_S, VKD3DSIH_GATHER4_PO_C_S, "fu", "fiRSf"}, -- {VKD3D_SM5_OP_LD_S, VKD3DSIH_LD_S, "uu", "iR"}, -- {VKD3D_SM5_OP_LD2DMS_S, VKD3DSIH_LD2DMS_S, "uu", "iRi"}, -- {VKD3D_SM5_OP_LD_UAV_TYPED_S, VKD3DSIH_LD_UAV_TYPED_S, "uu", "iU"}, -- {VKD3D_SM5_OP_LD_RAW_S, VKD3DSIH_LD_RAW_S, "uu", "iU"}, -- {VKD3D_SM5_OP_LD_STRUCTURED_S, VKD3DSIH_LD_STRUCTURED_S, "uu", "iiR"}, -- {VKD3D_SM5_OP_SAMPLE_LOD_S, VKD3DSIH_SAMPLE_LOD_S, "uu", "fRSf"}, -- {VKD3D_SM5_OP_SAMPLE_C_LZ_S, VKD3DSIH_SAMPLE_C_LZ_S, "fu", "fRSf"}, -- {VKD3D_SM5_OP_SAMPLE_CL_S, VKD3DSIH_SAMPLE_CL_S, "uu", "fRSf"}, -- {VKD3D_SM5_OP_SAMPLE_B_CL_S, VKD3DSIH_SAMPLE_B_CL_S, "uu", "fRSff"}, -- {VKD3D_SM5_OP_SAMPLE_GRAD_CL_S, VKD3DSIH_SAMPLE_GRAD_CL_S, "uu", "fRSfff"}, -- {VKD3D_SM5_OP_SAMPLE_C_CL_S, VKD3DSIH_SAMPLE_C_CL_S, "fu", "fRSff"}, -- {VKD3D_SM5_OP_CHECK_ACCESS_FULLY_MAPPED, VKD3DSIH_CHECK_ACCESS_FULLY_MAPPED, "u", "u"}, --}; -- - struct vkd3d_sm4_register_type_info - { - enum vkd3d_sm4_register_type sm4_type; - enum vkd3d_shader_register_type vkd3d_type; -+ -+ /* Swizzle type to be used for src registers when their dimension is VKD3D_SM4_DIMENSION_VEC4. */ -+ enum vkd3d_sm4_swizzle_type default_src_swizzle_type; - }; - - static const enum vkd3d_shader_register_precision register_precision_table[] = -@@ -1515,69 +1306,344 @@ struct tpf_writer - struct vkd3d_sm4_lookup_tables lookup; - }; - --static const struct vkd3d_sm4_opcode_info *get_opcode_info(enum vkd3d_sm4_opcode opcode) --{ -- unsigned int i; -- -- for (i = 0; i < sizeof(opcode_table) / sizeof(*opcode_table); ++i) -- { -- if (opcode == opcode_table[i].opcode) -- return &opcode_table[i]; -- } -- -- return NULL; --} -- - static void init_sm4_lookup_tables(struct vkd3d_sm4_lookup_tables *lookup) - { -- const struct vkd3d_sm4_register_type_info *info; - unsigned int i; - -+ /* -+ * d -> VKD3D_DATA_DOUBLE -+ * f -> VKD3D_DATA_FLOAT -+ * i -> VKD3D_DATA_INT -+ * u -> VKD3D_DATA_UINT -+ * O -> VKD3D_DATA_OPAQUE -+ * R -> VKD3D_DATA_RESOURCE -+ * S -> VKD3D_DATA_SAMPLER -+ * U -> VKD3D_DATA_UAV -+ */ -+ static const struct vkd3d_sm4_opcode_info opcode_table[] = -+ { -+ {VKD3D_SM4_OP_ADD, VKD3DSIH_ADD, "f", "ff"}, -+ {VKD3D_SM4_OP_AND, VKD3DSIH_AND, "u", "uu"}, -+ {VKD3D_SM4_OP_BREAK, VKD3DSIH_BREAK, "", ""}, -+ {VKD3D_SM4_OP_BREAKC, VKD3DSIH_BREAKP, "", "u", -+ shader_sm4_read_conditional_op}, -+ {VKD3D_SM4_OP_CASE, VKD3DSIH_CASE, "", "u", -+ shader_sm4_read_case_condition}, -+ {VKD3D_SM4_OP_CONTINUE, VKD3DSIH_CONTINUE, "", ""}, -+ {VKD3D_SM4_OP_CONTINUEC, VKD3DSIH_CONTINUEP, "", "u", -+ shader_sm4_read_conditional_op}, -+ {VKD3D_SM4_OP_CUT, VKD3DSIH_CUT, "", ""}, -+ {VKD3D_SM4_OP_DEFAULT, VKD3DSIH_DEFAULT, "", ""}, -+ {VKD3D_SM4_OP_DERIV_RTX, VKD3DSIH_DSX, "f", "f"}, -+ {VKD3D_SM4_OP_DERIV_RTY, VKD3DSIH_DSY, "f", "f"}, -+ {VKD3D_SM4_OP_DISCARD, VKD3DSIH_DISCARD, "", "u", -+ shader_sm4_read_conditional_op}, -+ {VKD3D_SM4_OP_DIV, VKD3DSIH_DIV, "f", "ff"}, -+ {VKD3D_SM4_OP_DP2, VKD3DSIH_DP2, "f", "ff"}, -+ {VKD3D_SM4_OP_DP3, VKD3DSIH_DP3, "f", "ff"}, -+ {VKD3D_SM4_OP_DP4, VKD3DSIH_DP4, "f", "ff"}, -+ {VKD3D_SM4_OP_ELSE, VKD3DSIH_ELSE, "", ""}, -+ {VKD3D_SM4_OP_EMIT, VKD3DSIH_EMIT, "", ""}, -+ {VKD3D_SM4_OP_ENDIF, VKD3DSIH_ENDIF, "", ""}, -+ {VKD3D_SM4_OP_ENDLOOP, VKD3DSIH_ENDLOOP, "", ""}, -+ {VKD3D_SM4_OP_ENDSWITCH, VKD3DSIH_ENDSWITCH, "", ""}, -+ {VKD3D_SM4_OP_EQ, VKD3DSIH_EQO, "u", "ff"}, -+ {VKD3D_SM4_OP_EXP, VKD3DSIH_EXP, "f", "f"}, -+ {VKD3D_SM4_OP_FRC, VKD3DSIH_FRC, "f", "f"}, -+ {VKD3D_SM4_OP_FTOI, VKD3DSIH_FTOI, "i", "f"}, -+ {VKD3D_SM4_OP_FTOU, VKD3DSIH_FTOU, "u", "f"}, -+ {VKD3D_SM4_OP_GE, VKD3DSIH_GEO, "u", "ff"}, -+ {VKD3D_SM4_OP_IADD, VKD3DSIH_IADD, "i", "ii"}, -+ {VKD3D_SM4_OP_IF, VKD3DSIH_IF, "", "u", -+ shader_sm4_read_conditional_op}, -+ {VKD3D_SM4_OP_IEQ, VKD3DSIH_IEQ, "u", "ii"}, -+ {VKD3D_SM4_OP_IGE, VKD3DSIH_IGE, "u", "ii"}, -+ {VKD3D_SM4_OP_ILT, VKD3DSIH_ILT, "u", "ii"}, -+ {VKD3D_SM4_OP_IMAD, VKD3DSIH_IMAD, "i", "iii"}, -+ {VKD3D_SM4_OP_IMAX, VKD3DSIH_IMAX, "i", "ii"}, -+ {VKD3D_SM4_OP_IMIN, VKD3DSIH_IMIN, "i", "ii"}, -+ {VKD3D_SM4_OP_IMUL, VKD3DSIH_IMUL, "ii", "ii"}, -+ {VKD3D_SM4_OP_INE, VKD3DSIH_INE, "u", "ii"}, -+ {VKD3D_SM4_OP_INEG, VKD3DSIH_INEG, "i", "i"}, -+ {VKD3D_SM4_OP_ISHL, VKD3DSIH_ISHL, "i", "ii"}, -+ {VKD3D_SM4_OP_ISHR, VKD3DSIH_ISHR, "i", "ii"}, -+ {VKD3D_SM4_OP_ITOF, VKD3DSIH_ITOF, "f", "i"}, -+ {VKD3D_SM4_OP_LABEL, VKD3DSIH_LABEL, "", "O"}, -+ {VKD3D_SM4_OP_LD, VKD3DSIH_LD, "u", "iR"}, -+ {VKD3D_SM4_OP_LD2DMS, VKD3DSIH_LD2DMS, "u", "iRi"}, -+ {VKD3D_SM4_OP_LOG, VKD3DSIH_LOG, "f", "f"}, -+ {VKD3D_SM4_OP_LOOP, VKD3DSIH_LOOP, "", ""}, -+ {VKD3D_SM4_OP_LT, VKD3DSIH_LTO, "u", "ff"}, -+ {VKD3D_SM4_OP_MAD, VKD3DSIH_MAD, "f", "fff"}, -+ {VKD3D_SM4_OP_MIN, VKD3DSIH_MIN, "f", "ff"}, -+ {VKD3D_SM4_OP_MAX, VKD3DSIH_MAX, "f", "ff"}, -+ {VKD3D_SM4_OP_SHADER_DATA, VKD3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER, "", "", -+ shader_sm4_read_shader_data}, -+ {VKD3D_SM4_OP_MOV, VKD3DSIH_MOV, "f", "f"}, -+ {VKD3D_SM4_OP_MOVC, VKD3DSIH_MOVC, "f", "uff"}, -+ {VKD3D_SM4_OP_MUL, VKD3DSIH_MUL, "f", "ff"}, -+ {VKD3D_SM4_OP_NE, VKD3DSIH_NEU, "u", "ff"}, -+ {VKD3D_SM4_OP_NOP, VKD3DSIH_NOP, "", ""}, -+ {VKD3D_SM4_OP_NOT, VKD3DSIH_NOT, "u", "u"}, -+ {VKD3D_SM4_OP_OR, VKD3DSIH_OR, "u", "uu"}, -+ {VKD3D_SM4_OP_RESINFO, VKD3DSIH_RESINFO, "f", "iR"}, -+ {VKD3D_SM4_OP_RET, VKD3DSIH_RET, "", ""}, -+ {VKD3D_SM4_OP_RETC, VKD3DSIH_RETP, "", "u", -+ shader_sm4_read_conditional_op}, -+ {VKD3D_SM4_OP_ROUND_NE, VKD3DSIH_ROUND_NE, "f", "f"}, -+ {VKD3D_SM4_OP_ROUND_NI, VKD3DSIH_ROUND_NI, "f", "f"}, -+ {VKD3D_SM4_OP_ROUND_PI, VKD3DSIH_ROUND_PI, "f", "f"}, -+ {VKD3D_SM4_OP_ROUND_Z, VKD3DSIH_ROUND_Z, "f", "f"}, -+ {VKD3D_SM4_OP_RSQ, VKD3DSIH_RSQ, "f", "f"}, -+ {VKD3D_SM4_OP_SAMPLE, VKD3DSIH_SAMPLE, "u", "fRS"}, -+ {VKD3D_SM4_OP_SAMPLE_C, VKD3DSIH_SAMPLE_C, "f", "fRSf"}, -+ {VKD3D_SM4_OP_SAMPLE_C_LZ, VKD3DSIH_SAMPLE_C_LZ, "f", "fRSf"}, -+ {VKD3D_SM4_OP_SAMPLE_LOD, VKD3DSIH_SAMPLE_LOD, "u", "fRSf"}, -+ {VKD3D_SM4_OP_SAMPLE_GRAD, VKD3DSIH_SAMPLE_GRAD, "u", "fRSff"}, -+ {VKD3D_SM4_OP_SAMPLE_B, VKD3DSIH_SAMPLE_B, "u", "fRSf"}, -+ {VKD3D_SM4_OP_SQRT, VKD3DSIH_SQRT, "f", "f"}, -+ {VKD3D_SM4_OP_SWITCH, VKD3DSIH_SWITCH, "", "i"}, -+ {VKD3D_SM4_OP_SINCOS, VKD3DSIH_SINCOS, "ff", "f"}, -+ {VKD3D_SM4_OP_UDIV, VKD3DSIH_UDIV, "uu", "uu"}, -+ {VKD3D_SM4_OP_ULT, VKD3DSIH_ULT, "u", "uu"}, -+ {VKD3D_SM4_OP_UGE, VKD3DSIH_UGE, "u", "uu"}, -+ {VKD3D_SM4_OP_UMUL, VKD3DSIH_UMUL, "uu", "uu"}, -+ {VKD3D_SM4_OP_UMAX, VKD3DSIH_UMAX, "u", "uu"}, -+ {VKD3D_SM4_OP_UMIN, VKD3DSIH_UMIN, "u", "uu"}, -+ {VKD3D_SM4_OP_USHR, VKD3DSIH_USHR, "u", "uu"}, -+ {VKD3D_SM4_OP_UTOF, VKD3DSIH_UTOF, "f", "u"}, -+ {VKD3D_SM4_OP_XOR, VKD3DSIH_XOR, "u", "uu"}, -+ {VKD3D_SM4_OP_DCL_RESOURCE, VKD3DSIH_DCL, "", "", -+ shader_sm4_read_dcl_resource}, -+ {VKD3D_SM4_OP_DCL_CONSTANT_BUFFER, VKD3DSIH_DCL_CONSTANT_BUFFER, "", "", -+ shader_sm4_read_dcl_constant_buffer}, -+ {VKD3D_SM4_OP_DCL_SAMPLER, VKD3DSIH_DCL_SAMPLER, "", "", -+ shader_sm4_read_dcl_sampler}, -+ {VKD3D_SM4_OP_DCL_INDEX_RANGE, VKD3DSIH_DCL_INDEX_RANGE, "", "", -+ shader_sm4_read_dcl_index_range}, -+ {VKD3D_SM4_OP_DCL_OUTPUT_TOPOLOGY, VKD3DSIH_DCL_OUTPUT_TOPOLOGY, "", "", -+ shader_sm4_read_dcl_output_topology}, -+ {VKD3D_SM4_OP_DCL_INPUT_PRIMITIVE, VKD3DSIH_DCL_INPUT_PRIMITIVE, "", "", -+ shader_sm4_read_dcl_input_primitive}, -+ {VKD3D_SM4_OP_DCL_VERTICES_OUT, VKD3DSIH_DCL_VERTICES_OUT, "", "", -+ shader_sm4_read_declaration_count}, -+ {VKD3D_SM4_OP_DCL_INPUT, VKD3DSIH_DCL_INPUT, "", "", -+ shader_sm4_read_declaration_dst}, -+ {VKD3D_SM4_OP_DCL_INPUT_SGV, VKD3DSIH_DCL_INPUT_SGV, "", "", -+ shader_sm4_read_declaration_register_semantic}, -+ {VKD3D_SM4_OP_DCL_INPUT_SIV, VKD3DSIH_DCL_INPUT_SIV, "", "", -+ shader_sm4_read_declaration_register_semantic}, -+ {VKD3D_SM4_OP_DCL_INPUT_PS, VKD3DSIH_DCL_INPUT_PS, "", "", -+ shader_sm4_read_dcl_input_ps}, -+ {VKD3D_SM4_OP_DCL_INPUT_PS_SGV, VKD3DSIH_DCL_INPUT_PS_SGV, "", "", -+ shader_sm4_read_declaration_register_semantic}, -+ {VKD3D_SM4_OP_DCL_INPUT_PS_SIV, VKD3DSIH_DCL_INPUT_PS_SIV, "", "", -+ shader_sm4_read_dcl_input_ps_siv}, -+ {VKD3D_SM4_OP_DCL_OUTPUT, VKD3DSIH_DCL_OUTPUT, "", "", -+ shader_sm4_read_declaration_dst}, -+ {VKD3D_SM4_OP_DCL_OUTPUT_SIV, VKD3DSIH_DCL_OUTPUT_SIV, "", "", -+ shader_sm4_read_declaration_register_semantic}, -+ {VKD3D_SM4_OP_DCL_TEMPS, VKD3DSIH_DCL_TEMPS, "", "", -+ shader_sm4_read_declaration_count}, -+ {VKD3D_SM4_OP_DCL_INDEXABLE_TEMP, VKD3DSIH_DCL_INDEXABLE_TEMP, "", "", -+ shader_sm4_read_dcl_indexable_temp}, -+ {VKD3D_SM4_OP_DCL_GLOBAL_FLAGS, VKD3DSIH_DCL_GLOBAL_FLAGS, "", "", -+ shader_sm4_read_dcl_global_flags}, -+ {VKD3D_SM4_OP_LOD, VKD3DSIH_LOD, "f", "fRS"}, -+ {VKD3D_SM4_OP_GATHER4, VKD3DSIH_GATHER4, "u", "fRS"}, -+ {VKD3D_SM4_OP_SAMPLE_POS, VKD3DSIH_SAMPLE_POS, "f", "Ru"}, -+ {VKD3D_SM4_OP_SAMPLE_INFO, VKD3DSIH_SAMPLE_INFO, "f", "R"}, -+ {VKD3D_SM5_OP_HS_DECLS, VKD3DSIH_HS_DECLS, "", ""}, -+ {VKD3D_SM5_OP_HS_CONTROL_POINT_PHASE, VKD3DSIH_HS_CONTROL_POINT_PHASE, "", ""}, -+ {VKD3D_SM5_OP_HS_FORK_PHASE, VKD3DSIH_HS_FORK_PHASE, "", ""}, -+ {VKD3D_SM5_OP_HS_JOIN_PHASE, VKD3DSIH_HS_JOIN_PHASE, "", ""}, -+ {VKD3D_SM5_OP_EMIT_STREAM, VKD3DSIH_EMIT_STREAM, "", "f"}, -+ {VKD3D_SM5_OP_CUT_STREAM, VKD3DSIH_CUT_STREAM, "", "f"}, -+ {VKD3D_SM5_OP_FCALL, VKD3DSIH_FCALL, "", "O", -+ shader_sm5_read_fcall}, -+ {VKD3D_SM5_OP_BUFINFO, VKD3DSIH_BUFINFO, "i", "U"}, -+ {VKD3D_SM5_OP_DERIV_RTX_COARSE, VKD3DSIH_DSX_COARSE, "f", "f"}, -+ {VKD3D_SM5_OP_DERIV_RTX_FINE, VKD3DSIH_DSX_FINE, "f", "f"}, -+ {VKD3D_SM5_OP_DERIV_RTY_COARSE, VKD3DSIH_DSY_COARSE, "f", "f"}, -+ {VKD3D_SM5_OP_DERIV_RTY_FINE, VKD3DSIH_DSY_FINE, "f", "f"}, -+ {VKD3D_SM5_OP_GATHER4_C, VKD3DSIH_GATHER4_C, "f", "fRSf"}, -+ {VKD3D_SM5_OP_GATHER4_PO, VKD3DSIH_GATHER4_PO, "f", "fiRS"}, -+ {VKD3D_SM5_OP_GATHER4_PO_C, VKD3DSIH_GATHER4_PO_C, "f", "fiRSf"}, -+ {VKD3D_SM5_OP_RCP, VKD3DSIH_RCP, "f", "f"}, -+ {VKD3D_SM5_OP_F32TOF16, VKD3DSIH_F32TOF16, "u", "f"}, -+ {VKD3D_SM5_OP_F16TOF32, VKD3DSIH_F16TOF32, "f", "u"}, -+ {VKD3D_SM5_OP_COUNTBITS, VKD3DSIH_COUNTBITS, "u", "u"}, -+ {VKD3D_SM5_OP_FIRSTBIT_HI, VKD3DSIH_FIRSTBIT_HI, "u", "u"}, -+ {VKD3D_SM5_OP_FIRSTBIT_LO, VKD3DSIH_FIRSTBIT_LO, "u", "u"}, -+ {VKD3D_SM5_OP_FIRSTBIT_SHI, VKD3DSIH_FIRSTBIT_SHI, "u", "i"}, -+ {VKD3D_SM5_OP_UBFE, VKD3DSIH_UBFE, "u", "iiu"}, -+ {VKD3D_SM5_OP_IBFE, VKD3DSIH_IBFE, "i", "iii"}, -+ {VKD3D_SM5_OP_BFI, VKD3DSIH_BFI, "u", "iiuu"}, -+ {VKD3D_SM5_OP_BFREV, VKD3DSIH_BFREV, "u", "u"}, -+ {VKD3D_SM5_OP_SWAPC, VKD3DSIH_SWAPC, "ff", "uff"}, -+ {VKD3D_SM5_OP_DCL_STREAM, VKD3DSIH_DCL_STREAM, "", "O"}, -+ {VKD3D_SM5_OP_DCL_FUNCTION_BODY, VKD3DSIH_DCL_FUNCTION_BODY, "", "", -+ shader_sm5_read_dcl_function_body}, -+ {VKD3D_SM5_OP_DCL_FUNCTION_TABLE, VKD3DSIH_DCL_FUNCTION_TABLE, "", "", -+ shader_sm5_read_dcl_function_table}, -+ {VKD3D_SM5_OP_DCL_INTERFACE, VKD3DSIH_DCL_INTERFACE, "", "", -+ shader_sm5_read_dcl_interface}, -+ {VKD3D_SM5_OP_DCL_INPUT_CONTROL_POINT_COUNT, VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT, "", "", -+ shader_sm5_read_control_point_count}, -+ {VKD3D_SM5_OP_DCL_OUTPUT_CONTROL_POINT_COUNT, VKD3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT, "", "", -+ shader_sm5_read_control_point_count}, -+ {VKD3D_SM5_OP_DCL_TESSELLATOR_DOMAIN, VKD3DSIH_DCL_TESSELLATOR_DOMAIN, "", "", -+ shader_sm5_read_dcl_tessellator_domain}, -+ {VKD3D_SM5_OP_DCL_TESSELLATOR_PARTITIONING, VKD3DSIH_DCL_TESSELLATOR_PARTITIONING, "", "", -+ shader_sm5_read_dcl_tessellator_partitioning}, -+ {VKD3D_SM5_OP_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, VKD3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, "", "", -+ shader_sm5_read_dcl_tessellator_output_primitive}, -+ {VKD3D_SM5_OP_DCL_HS_MAX_TESSFACTOR, VKD3DSIH_DCL_HS_MAX_TESSFACTOR, "", "", -+ shader_sm5_read_dcl_hs_max_tessfactor}, -+ {VKD3D_SM5_OP_DCL_HS_FORK_PHASE_INSTANCE_COUNT, VKD3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT, "", "", -+ shader_sm4_read_declaration_count}, -+ {VKD3D_SM5_OP_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, VKD3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, "", "", -+ shader_sm4_read_declaration_count}, -+ {VKD3D_SM5_OP_DCL_THREAD_GROUP, VKD3DSIH_DCL_THREAD_GROUP, "", "", -+ shader_sm5_read_dcl_thread_group}, -+ {VKD3D_SM5_OP_DCL_UAV_TYPED, VKD3DSIH_DCL_UAV_TYPED, "", "", -+ shader_sm4_read_dcl_resource}, -+ {VKD3D_SM5_OP_DCL_UAV_RAW, VKD3DSIH_DCL_UAV_RAW, "", "", -+ shader_sm5_read_dcl_uav_raw}, -+ {VKD3D_SM5_OP_DCL_UAV_STRUCTURED, VKD3DSIH_DCL_UAV_STRUCTURED, "", "", -+ shader_sm5_read_dcl_uav_structured}, -+ {VKD3D_SM5_OP_DCL_TGSM_RAW, VKD3DSIH_DCL_TGSM_RAW, "", "", -+ shader_sm5_read_dcl_tgsm_raw}, -+ {VKD3D_SM5_OP_DCL_TGSM_STRUCTURED, VKD3DSIH_DCL_TGSM_STRUCTURED, "", "", -+ shader_sm5_read_dcl_tgsm_structured}, -+ {VKD3D_SM5_OP_DCL_RESOURCE_RAW, VKD3DSIH_DCL_RESOURCE_RAW, "", "", -+ shader_sm5_read_dcl_resource_raw}, -+ {VKD3D_SM5_OP_DCL_RESOURCE_STRUCTURED, VKD3DSIH_DCL_RESOURCE_STRUCTURED, "", "", -+ shader_sm5_read_dcl_resource_structured}, -+ {VKD3D_SM5_OP_LD_UAV_TYPED, VKD3DSIH_LD_UAV_TYPED, "u", "iU"}, -+ {VKD3D_SM5_OP_STORE_UAV_TYPED, VKD3DSIH_STORE_UAV_TYPED, "U", "iu"}, -+ {VKD3D_SM5_OP_LD_RAW, VKD3DSIH_LD_RAW, "u", "iU"}, -+ {VKD3D_SM5_OP_STORE_RAW, VKD3DSIH_STORE_RAW, "U", "uu"}, -+ {VKD3D_SM5_OP_LD_STRUCTURED, VKD3DSIH_LD_STRUCTURED, "u", "iiR"}, -+ {VKD3D_SM5_OP_STORE_STRUCTURED, VKD3DSIH_STORE_STRUCTURED, "U", "iiu"}, -+ {VKD3D_SM5_OP_ATOMIC_AND, VKD3DSIH_ATOMIC_AND, "U", "iu"}, -+ {VKD3D_SM5_OP_ATOMIC_OR, VKD3DSIH_ATOMIC_OR, "U", "iu"}, -+ {VKD3D_SM5_OP_ATOMIC_XOR, VKD3DSIH_ATOMIC_XOR, "U", "iu"}, -+ {VKD3D_SM5_OP_ATOMIC_CMP_STORE, VKD3DSIH_ATOMIC_CMP_STORE, "U", "iuu"}, -+ {VKD3D_SM5_OP_ATOMIC_IADD, VKD3DSIH_ATOMIC_IADD, "U", "ii"}, -+ {VKD3D_SM5_OP_ATOMIC_IMAX, VKD3DSIH_ATOMIC_IMAX, "U", "ii"}, -+ {VKD3D_SM5_OP_ATOMIC_IMIN, VKD3DSIH_ATOMIC_IMIN, "U", "ii"}, -+ {VKD3D_SM5_OP_ATOMIC_UMAX, VKD3DSIH_ATOMIC_UMAX, "U", "iu"}, -+ {VKD3D_SM5_OP_ATOMIC_UMIN, VKD3DSIH_ATOMIC_UMIN, "U", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_ALLOC, VKD3DSIH_IMM_ATOMIC_ALLOC, "u", "U"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_CONSUME, VKD3DSIH_IMM_ATOMIC_CONSUME, "u", "U"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_IADD, VKD3DSIH_IMM_ATOMIC_IADD, "uU", "ii"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_AND, VKD3DSIH_IMM_ATOMIC_AND, "uU", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_OR, VKD3DSIH_IMM_ATOMIC_OR, "uU", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_XOR, VKD3DSIH_IMM_ATOMIC_XOR, "uU", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_EXCH, VKD3DSIH_IMM_ATOMIC_EXCH, "uU", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_CMP_EXCH, VKD3DSIH_IMM_ATOMIC_CMP_EXCH, "uU", "iuu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_IMAX, VKD3DSIH_IMM_ATOMIC_IMAX, "iU", "ii"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_IMIN, VKD3DSIH_IMM_ATOMIC_IMIN, "iU", "ii"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_UMAX, VKD3DSIH_IMM_ATOMIC_UMAX, "uU", "iu"}, -+ {VKD3D_SM5_OP_IMM_ATOMIC_UMIN, VKD3DSIH_IMM_ATOMIC_UMIN, "uU", "iu"}, -+ {VKD3D_SM5_OP_SYNC, VKD3DSIH_SYNC, "", "", -+ shader_sm5_read_sync}, -+ {VKD3D_SM5_OP_DADD, VKD3DSIH_DADD, "d", "dd"}, -+ {VKD3D_SM5_OP_DMAX, VKD3DSIH_DMAX, "d", "dd"}, -+ {VKD3D_SM5_OP_DMIN, VKD3DSIH_DMIN, "d", "dd"}, -+ {VKD3D_SM5_OP_DMUL, VKD3DSIH_DMUL, "d", "dd"}, -+ {VKD3D_SM5_OP_DEQ, VKD3DSIH_DEQO, "u", "dd"}, -+ {VKD3D_SM5_OP_DGE, VKD3DSIH_DGEO, "u", "dd"}, -+ {VKD3D_SM5_OP_DLT, VKD3DSIH_DLT, "u", "dd"}, -+ {VKD3D_SM5_OP_DNE, VKD3DSIH_DNE, "u", "dd"}, -+ {VKD3D_SM5_OP_DMOV, VKD3DSIH_DMOV, "d", "d"}, -+ {VKD3D_SM5_OP_DMOVC, VKD3DSIH_DMOVC, "d", "udd"}, -+ {VKD3D_SM5_OP_DTOF, VKD3DSIH_DTOF, "f", "d"}, -+ {VKD3D_SM5_OP_FTOD, VKD3DSIH_FTOD, "d", "f"}, -+ {VKD3D_SM5_OP_EVAL_SAMPLE_INDEX, VKD3DSIH_EVAL_SAMPLE_INDEX, "f", "fi"}, -+ {VKD3D_SM5_OP_EVAL_CENTROID, VKD3DSIH_EVAL_CENTROID, "f", "f"}, -+ {VKD3D_SM5_OP_DCL_GS_INSTANCES, VKD3DSIH_DCL_GS_INSTANCES, "", "", -+ shader_sm4_read_declaration_count}, -+ {VKD3D_SM5_OP_DDIV, VKD3DSIH_DDIV, "d", "dd"}, -+ {VKD3D_SM5_OP_DFMA, VKD3DSIH_DFMA, "d", "ddd"}, -+ {VKD3D_SM5_OP_DRCP, VKD3DSIH_DRCP, "d", "d"}, -+ {VKD3D_SM5_OP_MSAD, VKD3DSIH_MSAD, "u", "uuu"}, -+ {VKD3D_SM5_OP_DTOI, VKD3DSIH_DTOI, "i", "d"}, -+ {VKD3D_SM5_OP_DTOU, VKD3DSIH_DTOU, "u", "d"}, -+ {VKD3D_SM5_OP_ITOD, VKD3DSIH_ITOD, "d", "i"}, -+ {VKD3D_SM5_OP_UTOD, VKD3DSIH_UTOD, "d", "u"}, -+ {VKD3D_SM5_OP_GATHER4_S, VKD3DSIH_GATHER4_S, "uu", "fRS"}, -+ {VKD3D_SM5_OP_GATHER4_C_S, VKD3DSIH_GATHER4_C_S, "fu", "fRSf"}, -+ {VKD3D_SM5_OP_GATHER4_PO_S, VKD3DSIH_GATHER4_PO_S, "fu", "fiRS"}, -+ {VKD3D_SM5_OP_GATHER4_PO_C_S, VKD3DSIH_GATHER4_PO_C_S, "fu", "fiRSf"}, -+ {VKD3D_SM5_OP_LD_S, VKD3DSIH_LD_S, "uu", "iR"}, -+ {VKD3D_SM5_OP_LD2DMS_S, VKD3DSIH_LD2DMS_S, "uu", "iRi"}, -+ {VKD3D_SM5_OP_LD_UAV_TYPED_S, VKD3DSIH_LD_UAV_TYPED_S, "uu", "iU"}, -+ {VKD3D_SM5_OP_LD_RAW_S, VKD3DSIH_LD_RAW_S, "uu", "iU"}, -+ {VKD3D_SM5_OP_LD_STRUCTURED_S, VKD3DSIH_LD_STRUCTURED_S, "uu", "iiR"}, -+ {VKD3D_SM5_OP_SAMPLE_LOD_S, VKD3DSIH_SAMPLE_LOD_S, "uu", "fRSf"}, -+ {VKD3D_SM5_OP_SAMPLE_C_LZ_S, VKD3DSIH_SAMPLE_C_LZ_S, "fu", "fRSf"}, -+ {VKD3D_SM5_OP_SAMPLE_CL_S, VKD3DSIH_SAMPLE_CL_S, "uu", "fRSf"}, -+ {VKD3D_SM5_OP_SAMPLE_B_CL_S, VKD3DSIH_SAMPLE_B_CL_S, "uu", "fRSff"}, -+ {VKD3D_SM5_OP_SAMPLE_GRAD_CL_S, VKD3DSIH_SAMPLE_GRAD_CL_S, "uu", "fRSfff"}, -+ {VKD3D_SM5_OP_SAMPLE_C_CL_S, VKD3DSIH_SAMPLE_C_CL_S, "fu", "fRSff"}, -+ {VKD3D_SM5_OP_CHECK_ACCESS_FULLY_MAPPED, VKD3DSIH_CHECK_ACCESS_FULLY_MAPPED, "u", "u"}, -+ }; -+ - static const struct vkd3d_sm4_register_type_info register_type_table[] = - { -- {VKD3D_SM4_RT_TEMP, VKD3DSPR_TEMP}, -- {VKD3D_SM4_RT_INPUT, VKD3DSPR_INPUT}, -- {VKD3D_SM4_RT_OUTPUT, VKD3DSPR_OUTPUT}, -- {VKD3D_SM4_RT_INDEXABLE_TEMP, VKD3DSPR_IDXTEMP}, -- {VKD3D_SM4_RT_IMMCONST, VKD3DSPR_IMMCONST}, -- {VKD3D_SM4_RT_IMMCONST64, VKD3DSPR_IMMCONST64}, -- {VKD3D_SM4_RT_SAMPLER, VKD3DSPR_SAMPLER}, -- {VKD3D_SM4_RT_RESOURCE, VKD3DSPR_RESOURCE}, -- {VKD3D_SM4_RT_CONSTBUFFER, VKD3DSPR_CONSTBUFFER}, -- {VKD3D_SM4_RT_IMMCONSTBUFFER, VKD3DSPR_IMMCONSTBUFFER}, -- {VKD3D_SM4_RT_PRIMID, VKD3DSPR_PRIMID}, -- {VKD3D_SM4_RT_DEPTHOUT, VKD3DSPR_DEPTHOUT}, -- {VKD3D_SM4_RT_NULL, VKD3DSPR_NULL}, -- {VKD3D_SM4_RT_RASTERIZER, VKD3DSPR_RASTERIZER}, -- {VKD3D_SM4_RT_OMASK, VKD3DSPR_SAMPLEMASK}, -- {VKD3D_SM5_RT_STREAM, VKD3DSPR_STREAM}, -- {VKD3D_SM5_RT_FUNCTION_BODY, VKD3DSPR_FUNCTIONBODY}, -- {VKD3D_SM5_RT_FUNCTION_POINTER, VKD3DSPR_FUNCTIONPOINTER}, -- {VKD3D_SM5_RT_OUTPUT_CONTROL_POINT_ID, VKD3DSPR_OUTPOINTID}, -- {VKD3D_SM5_RT_FORK_INSTANCE_ID, VKD3DSPR_FORKINSTID}, -- {VKD3D_SM5_RT_JOIN_INSTANCE_ID, VKD3DSPR_JOININSTID}, -- {VKD3D_SM5_RT_INPUT_CONTROL_POINT, VKD3DSPR_INCONTROLPOINT}, -- {VKD3D_SM5_RT_OUTPUT_CONTROL_POINT, VKD3DSPR_OUTCONTROLPOINT}, -- {VKD3D_SM5_RT_PATCH_CONSTANT_DATA, VKD3DSPR_PATCHCONST}, -- {VKD3D_SM5_RT_DOMAIN_LOCATION, VKD3DSPR_TESSCOORD}, -- {VKD3D_SM5_RT_UAV, VKD3DSPR_UAV}, -- {VKD3D_SM5_RT_SHARED_MEMORY, VKD3DSPR_GROUPSHAREDMEM}, -- {VKD3D_SM5_RT_THREAD_ID, VKD3DSPR_THREADID}, -- {VKD3D_SM5_RT_THREAD_GROUP_ID, VKD3DSPR_THREADGROUPID}, -- {VKD3D_SM5_RT_LOCAL_THREAD_ID, VKD3DSPR_LOCALTHREADID}, -- {VKD3D_SM5_RT_COVERAGE, VKD3DSPR_COVERAGE}, -- {VKD3D_SM5_RT_LOCAL_THREAD_INDEX, VKD3DSPR_LOCALTHREADINDEX}, -- {VKD3D_SM5_RT_GS_INSTANCE_ID, VKD3DSPR_GSINSTID}, -- {VKD3D_SM5_RT_DEPTHOUT_GREATER_EQUAL, VKD3DSPR_DEPTHOUTGE}, -- {VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL, VKD3DSPR_DEPTHOUTLE}, -- {VKD3D_SM5_RT_OUTPUT_STENCIL_REF, VKD3DSPR_OUTSTENCILREF}, -+ {VKD3D_SM4_RT_TEMP, VKD3DSPR_TEMP, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_INPUT, VKD3DSPR_INPUT, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_OUTPUT, VKD3DSPR_OUTPUT, VKD3D_SM4_SWIZZLE_INVALID}, -+ {VKD3D_SM4_RT_INDEXABLE_TEMP, VKD3DSPR_IDXTEMP, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_IMMCONST, VKD3DSPR_IMMCONST, VKD3D_SM4_SWIZZLE_NONE}, -+ {VKD3D_SM4_RT_IMMCONST64, VKD3DSPR_IMMCONST64, VKD3D_SM4_SWIZZLE_NONE}, -+ {VKD3D_SM4_RT_SAMPLER, VKD3DSPR_SAMPLER, VKD3D_SM4_SWIZZLE_SCALAR}, -+ {VKD3D_SM4_RT_RESOURCE, VKD3DSPR_RESOURCE, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_CONSTBUFFER, VKD3DSPR_CONSTBUFFER, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_IMMCONSTBUFFER, VKD3DSPR_IMMCONSTBUFFER, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_PRIMID, VKD3DSPR_PRIMID, VKD3D_SM4_SWIZZLE_NONE}, -+ {VKD3D_SM4_RT_DEPTHOUT, VKD3DSPR_DEPTHOUT, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_NULL, VKD3DSPR_NULL, VKD3D_SM4_SWIZZLE_INVALID}, -+ {VKD3D_SM4_RT_RASTERIZER, VKD3DSPR_RASTERIZER, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM4_RT_OMASK, VKD3DSPR_SAMPLEMASK, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_STREAM, VKD3DSPR_STREAM, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_FUNCTION_BODY, VKD3DSPR_FUNCTIONBODY, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_FUNCTION_POINTER, VKD3DSPR_FUNCTIONPOINTER, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_OUTPUT_CONTROL_POINT_ID, VKD3DSPR_OUTPOINTID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_FORK_INSTANCE_ID, VKD3DSPR_FORKINSTID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_JOIN_INSTANCE_ID, VKD3DSPR_JOININSTID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_INPUT_CONTROL_POINT, VKD3DSPR_INCONTROLPOINT, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_OUTPUT_CONTROL_POINT, VKD3DSPR_OUTCONTROLPOINT, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_PATCH_CONSTANT_DATA, VKD3DSPR_PATCHCONST, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_DOMAIN_LOCATION, VKD3DSPR_TESSCOORD, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_UAV, VKD3DSPR_UAV, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_SHARED_MEMORY, VKD3DSPR_GROUPSHAREDMEM, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_THREAD_ID, VKD3DSPR_THREADID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_THREAD_GROUP_ID, VKD3DSPR_THREADGROUPID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_LOCAL_THREAD_ID, VKD3DSPR_LOCALTHREADID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_COVERAGE, VKD3DSPR_COVERAGE, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_LOCAL_THREAD_INDEX, VKD3DSPR_LOCALTHREADINDEX,VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_GS_INSTANCE_ID, VKD3DSPR_GSINSTID, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_DEPTHOUT_GREATER_EQUAL, VKD3DSPR_DEPTHOUTGE, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL, VKD3DSPR_DEPTHOUTLE, VKD3D_SM4_SWIZZLE_VEC4}, -+ {VKD3D_SM5_RT_OUTPUT_STENCIL_REF, VKD3DSPR_OUTSTENCILREF, VKD3D_SM4_SWIZZLE_VEC4}, - }; - - memset(lookup, 0, sizeof(*lookup)); - -+ for (i = 0; i < ARRAY_SIZE(opcode_table); ++i) -+ { -+ const struct vkd3d_sm4_opcode_info *info = &opcode_table[i]; -+ -+ lookup->opcode_info_from_sm4[info->opcode] = info; -+ } -+ - for (i = 0; i < ARRAY_SIZE(register_type_table); ++i) - { -- info = ®ister_type_table[i]; -+ const struct vkd3d_sm4_register_type_info *info = ®ister_type_table[i]; -+ - lookup->register_type_info_from_sm4[info->sm4_type] = info; - lookup->register_type_info_from_vkd3d[info->vkd3d_type] = info; - } -@@ -1590,6 +1656,14 @@ static void tpf_writer_init(struct tpf_writer *tpf, struct hlsl_ctx *ctx, struct - init_sm4_lookup_tables(&tpf->lookup); - } - -+static const struct vkd3d_sm4_opcode_info *get_info_from_sm4_opcode( -+ const struct vkd3d_sm4_lookup_tables *lookup, enum vkd3d_sm4_opcode sm4_opcode) -+{ -+ if (sm4_opcode >= VKD3D_SM4_OP_COUNT) -+ return NULL; -+ return lookup->opcode_info_from_sm4[sm4_opcode]; -+} -+ - static const struct vkd3d_sm4_register_type_info *get_info_from_sm4_register_type( - const struct vkd3d_sm4_lookup_tables *lookup, enum vkd3d_sm4_register_type sm4_type) - { -@@ -1606,29 +1680,14 @@ static const struct vkd3d_sm4_register_type_info *get_info_from_vkd3d_register_t - return lookup->register_type_info_from_vkd3d[vkd3d_type]; - } - --static void map_register(const struct vkd3d_shader_sm4_parser *sm4, struct vkd3d_shader_register *reg) -+static enum vkd3d_sm4_swizzle_type vkd3d_sm4_get_default_swizzle_type( -+ const struct vkd3d_sm4_lookup_tables *lookup, enum vkd3d_shader_register_type vkd3d_type) - { -- switch (sm4->p.shader_version.type) -- { -- case VKD3D_SHADER_TYPE_PIXEL: -- if (reg->type == VKD3DSPR_OUTPUT) -- { -- unsigned int reg_idx = reg->idx[0].offset; -+ const struct vkd3d_sm4_register_type_info *register_type_info = -+ get_info_from_vkd3d_register_type(lookup, vkd3d_type); - -- if (reg_idx >= ARRAY_SIZE(sm4->output_map)) -- { -- /* Validated later */ -- break; -- } -- -- reg->type = VKD3DSPR_COLOROUT; -- reg->idx[0].offset = sm4->output_map[reg_idx]; -- } -- break; -- -- default: -- break; -- } -+ assert(register_type_info); -+ return register_type_info->default_src_swizzle_type; - } - - static enum vkd3d_data_type map_data_type(char t) -@@ -1694,29 +1753,16 @@ static bool shader_sm4_read_reg_idx(struct vkd3d_shader_sm4_parser *priv, const - return true; - } - --static bool sm4_register_is_descriptor(enum vkd3d_sm4_register_type register_type) --{ -- switch (register_type) -- { -- case VKD3D_SM4_RT_SAMPLER: -- case VKD3D_SM4_RT_RESOURCE: -- case VKD3D_SM4_RT_CONSTBUFFER: -- case VKD3D_SM5_RT_UAV: -- return true; -- -- default: -- return false; -- } --} -- - static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const uint32_t **ptr, const uint32_t *end, - enum vkd3d_data_type data_type, struct vkd3d_shader_register *param, enum vkd3d_shader_src_modifier *modifier) - { - const struct vkd3d_sm4_register_type_info *register_type_info; -+ enum vkd3d_shader_register_type vsir_register_type; - enum vkd3d_sm4_register_precision precision; - enum vkd3d_sm4_register_type register_type; - enum vkd3d_sm4_extended_operand_type type; - enum vkd3d_sm4_register_modifier m; -+ enum vkd3d_sm4_dimension sm4_dimension; - uint32_t token, order, extended; - - if (*ptr >= end) -@@ -1731,15 +1777,18 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - if (!register_type_info) - { - FIXME("Unhandled register type %#x.\n", register_type); -- param->type = VKD3DSPR_TEMP; -+ vsir_register_type = VKD3DSPR_TEMP; - } - else - { -- param->type = register_type_info->vkd3d_type; -+ vsir_register_type = register_type_info->vkd3d_type; - } -+ -+ order = (token & VKD3D_SM4_REGISTER_ORDER_MASK) >> VKD3D_SM4_REGISTER_ORDER_SHIFT; -+ -+ vsir_register_init(param, vsir_register_type, data_type, order); - param->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; - param->non_uniform = false; -- param->data_type = data_type; - - *modifier = VKD3DSPSM_NONE; - if (token & VKD3D_SM4_EXTENDED_OPERAND) -@@ -1775,10 +1824,11 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - *modifier = VKD3DSPSM_ABSNEG; - break; - -+ case VKD3D_SM4_REGISTER_MODIFIER_NONE: -+ break; -+ - default: - FIXME("Unhandled register modifier %#x.\n", m); -- /* fall-through */ -- case VKD3D_SM4_REGISTER_MODIFIER_NONE: - break; - } - -@@ -1809,14 +1859,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - } - } - -- order = (token & VKD3D_SM4_REGISTER_ORDER_MASK) >> VKD3D_SM4_REGISTER_ORDER_SHIFT; -- -- if (order < 1) -- { -- param->idx[0].offset = ~0u; -- param->idx[0].rel_addr = NULL; -- } -- else -+ if (order >= 1) - { - DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK0) >> VKD3D_SM4_ADDRESSING_SHIFT0; - if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[0]))) -@@ -1826,12 +1869,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - } - } - -- if (order < 2) -- { -- param->idx[1].offset = ~0u; -- param->idx[1].rel_addr = NULL; -- } -- else -+ if (order >= 2) - { - DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK1) >> VKD3D_SM4_ADDRESSING_SHIFT1; - if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[1]))) -@@ -1841,12 +1879,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - } - } - -- if (order < 3) -- { -- param->idx[2].offset = ~0u; -- param->idx[2].rel_addr = NULL; -- } -- else -+ if (order >= 3) - { - DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK2) >> VKD3D_SM4_ADDRESSING_SHIFT2; - if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[2]))) -@@ -1862,17 +1895,16 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - return false; - } - -- param->idx_count = order; -+ sm4_dimension = (token & VKD3D_SM4_DIMENSION_MASK) >> VKD3D_SM4_DIMENSION_SHIFT; -+ param->dimension = vsir_dimension_from_sm4_dimension(sm4_dimension); - - if (register_type == VKD3D_SM4_RT_IMMCONST || register_type == VKD3D_SM4_RT_IMMCONST64) - { -- enum vkd3d_sm4_dimension dimension = (token & VKD3D_SM4_DIMENSION_MASK) >> VKD3D_SM4_DIMENSION_SHIFT; - unsigned int dword_count; - -- switch (dimension) -+ switch (param->dimension) - { -- case VKD3D_SM4_DIMENSION_SCALAR: -- param->immconst_type = VKD3D_IMMCONST_SCALAR; -+ case VSIR_DIMENSION_SCALAR: - dword_count = 1 + (register_type == VKD3D_SM4_RT_IMMCONST64); - if (end - *ptr < dword_count) - { -@@ -1883,8 +1915,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - *ptr += dword_count; - break; - -- case VKD3D_SM4_DIMENSION_VEC4: -- param->immconst_type = VKD3D_IMMCONST_VEC4; -+ case VSIR_DIMENSION_VEC4: - if (end - *ptr < VKD3D_VEC4_SIZE) - { - WARN("Invalid ptr %p, end %p.\n", *ptr, end); -@@ -1895,11 +1926,11 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - break; - - default: -- FIXME("Unhandled dimension %#x.\n", dimension); -+ FIXME("Unhandled dimension %#x.\n", param->dimension); - break; - } - } -- else if (!shader_is_sm_5_1(priv) && sm4_register_is_descriptor(register_type)) -+ else if (!shader_is_sm_5_1(priv) && vsir_register_is_descriptor(param)) - { - /* SM5.1 places a symbol identifier in idx[0] and moves - * other values up one slot. Normalize to SM5.1. */ -@@ -1908,8 +1939,6 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui - ++param->idx_count; - } - -- map_register(priv, param); -- - return true; - } - -@@ -1938,6 +1967,16 @@ static uint32_t swizzle_from_sm4(uint32_t s) - return vkd3d_shader_create_swizzle(s & 0x3, (s >> 2) & 0x3, (s >> 4) & 0x3, (s >> 6) & 0x3); - } - -+static uint32_t swizzle_to_sm4(uint32_t s) -+{ -+ uint32_t ret = 0; -+ ret |= ((vkd3d_swizzle_get_component(s, 0)) & 0x3); -+ ret |= ((vkd3d_swizzle_get_component(s, 1)) & 0x3) << 2; -+ ret |= ((vkd3d_swizzle_get_component(s, 2)) & 0x3) << 4; -+ ret |= ((vkd3d_swizzle_get_component(s, 3)) & 0x3) << 6; -+ return ret; -+} -+ - static bool register_is_input_output(const struct vkd3d_shader_register *reg) - { - switch (reg->type) -@@ -2319,7 +2358,7 @@ static void shader_sm4_read_instruction(struct vkd3d_shader_sm4_parser *sm4, str - } - --len; - -- if (!(opcode_info = get_opcode_info(opcode))) -+ if (!(opcode_info = get_info_from_sm4_opcode(&sm4->lookup, opcode))) - { - FIXME("Unrecognized opcode %#x, opcode_token 0x%08x.\n", opcode, opcode_token); - ins->handler_idx = VKD3DSIH_INVALID; -@@ -2327,7 +2366,7 @@ static void shader_sm4_read_instruction(struct vkd3d_shader_sm4_parser *sm4, str - return; - } - -- ins->handler_idx = opcode_info->handler_idx; -+ vsir_instruction_init(ins, &sm4->p.location, opcode_info->handler_idx); - if (ins->handler_idx == VKD3DSIH_HS_CONTROL_POINT_PHASE || ins->handler_idx == VKD3DSIH_HS_FORK_PHASE - || ins->handler_idx == VKD3DSIH_HS_JOIN_PHASE) - sm4->phase = ins->handler_idx; -@@ -2430,7 +2469,6 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t - { - struct vkd3d_shader_version version; - uint32_t version_token, token_count; -- unsigned int i; - - if (byte_code_size / sizeof(*byte_code) < 2) - { -@@ -2490,23 +2528,6 @@ static bool shader_sm4_init(struct vkd3d_shader_sm4_parser *sm4, const uint32_t - return false; - sm4->ptr = sm4->start; - -- memset(sm4->output_map, 0xff, sizeof(sm4->output_map)); -- for (i = 0; i < output_signature->element_count; ++i) -- { -- struct signature_element *e = &output_signature->elements[i]; -- -- if (version.type == VKD3D_SHADER_TYPE_PIXEL -- && ascii_strcasecmp(e->semantic_name, "SV_Target")) -- continue; -- if (e->register_index >= ARRAY_SIZE(sm4->output_map)) -- { -- WARN("Invalid output index %u.\n", e->register_index); -- continue; -- } -- -- sm4->output_map[e->register_index] = e->semantic_index; -- } -- - init_sm4_lookup_tables(&sm4->lookup); - - return true; -@@ -2642,9 +2663,19 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi - if (sm4->p.shader_version.type == VKD3D_SHADER_TYPE_HULL && !sm4->has_control_point_phase && !sm4->p.failed) - shader_sm4_validate_default_phase_index_ranges(sm4); - -+ if (!sm4->p.failed) -+ vsir_validate(&sm4->p); -+ -+ if (sm4->p.failed) -+ { -+ WARN("Failed to parse shader.\n"); -+ shader_sm4_destroy(&sm4->p); -+ return VKD3D_ERROR_INVALID_SHADER; -+ } -+ - *parser = &sm4->p; - -- return sm4->p.failed ? VKD3D_ERROR_INVALID_SHADER : VKD3D_OK; -+ return VKD3D_OK; - } - - static void write_sm4_block(const struct tpf_writer *tpf, const struct hlsl_block *block); -@@ -2664,7 +2695,7 @@ static bool type_is_integer(const struct hlsl_type *type) - } - - bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, -- bool output, enum vkd3d_shader_register_type *type, enum vkd3d_sm4_swizzle_type *swizzle_type, bool *has_idx) -+ bool output, enum vkd3d_shader_register_type *type, bool *has_idx) - { - unsigned int i; - -@@ -2673,25 +2704,24 @@ bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_sem - const char *semantic; - bool output; - enum vkd3d_shader_type shader_type; -- enum vkd3d_sm4_swizzle_type swizzle_type; - enum vkd3d_shader_register_type type; - bool has_idx; - } - register_table[] = - { -- {"sv_dispatchthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_THREADID, false}, -- {"sv_groupid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_THREADGROUPID, false}, -- {"sv_groupthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_LOCALTHREADID, false}, -+ {"sv_dispatchthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3DSPR_THREADID, false}, -+ {"sv_groupid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3DSPR_THREADGROUPID, false}, -+ {"sv_groupthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, VKD3DSPR_LOCALTHREADID, false}, - -- {"sv_primitiveid", false, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SM4_SWIZZLE_NONE, VKD3DSPR_PRIMID, false}, -+ {"sv_primitiveid", false, VKD3D_SHADER_TYPE_GEOMETRY, VKD3DSPR_PRIMID, false}, - - /* Put sv_target in this table, instead of letting it fall through to - * default varying allocation, so that the register index matches the - * usage index. */ -- {"color", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_OUTPUT, true}, -- {"depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_DEPTHOUT, false}, -- {"sv_depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_DEPTHOUT, false}, -- {"sv_target", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SM4_SWIZZLE_VEC4, VKD3DSPR_OUTPUT, true}, -+ {"color", true, VKD3D_SHADER_TYPE_PIXEL, VKD3DSPR_OUTPUT, true}, -+ {"depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3DSPR_DEPTHOUT, false}, -+ {"sv_depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3DSPR_DEPTHOUT, false}, -+ {"sv_target", true, VKD3D_SHADER_TYPE_PIXEL, VKD3DSPR_OUTPUT, true}, - }; - - for (i = 0; i < ARRAY_SIZE(register_table); ++i) -@@ -2702,8 +2732,6 @@ bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_sem - { - if (type) - *type = register_table[i].type; -- if (swizzle_type) -- *swizzle_type = register_table[i].swizzle_type; - *has_idx = register_table[i].has_idx; - return true; - } -@@ -2722,7 +2750,7 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant - const char *name; - bool output; - enum vkd3d_shader_type shader_type; -- D3DDECLUSAGE usage; -+ D3D_NAME usage; - } - semantics[] = - { -@@ -2753,20 +2781,21 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant - {"position", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_POSITION}, - {"sv_position", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_POSITION}, - }; -+ bool needs_compat_mapping = ascii_strncasecmp(semantic->name, "sv_", 3); - - for (i = 0; i < ARRAY_SIZE(semantics); ++i) - { - if (!ascii_strcasecmp(semantic->name, semantics[i].name) - && output == semantics[i].output -- && ctx->profile->type == semantics[i].shader_type -- && !ascii_strncasecmp(semantic->name, "sv_", 3)) -+ && (ctx->semantic_compat_mapping == needs_compat_mapping || !needs_compat_mapping) -+ && ctx->profile->type == semantics[i].shader_type) - { - *usage = semantics[i].usage; - return true; - } - } - -- if (!ascii_strncasecmp(semantic->name, "sv_", 3)) -+ if (!needs_compat_mapping) - return false; - - *usage = D3D_NAME_UNDEFINED; -@@ -2815,7 +2844,7 @@ static void write_sm4_signature(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc, - continue; - usage_idx = var->semantic.index; - -- if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, output, NULL, NULL, &has_idx)) -+ if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, output, NULL, &has_idx)) - { - reg_idx = has_idx ? var->semantic.index : ~0u; - } -@@ -3202,8 +3231,7 @@ static struct extern_resource *sm4_get_extern_resources(struct hlsl_ctx *ctx, un - if (!hlsl_type_is_resource(component_type)) - continue; - -- regset = hlsl_type_get_regset(component_type); -- regset_offset = hlsl_type_get_component_offset(ctx, var->data_type, regset, k); -+ regset_offset = hlsl_type_get_component_offset(ctx, var->data_type, k, ®set); - - if (regset_offset > var->regs[regset].allocation_size) - continue; -@@ -3249,38 +3277,43 @@ static struct extern_resource *sm4_get_extern_resources(struct hlsl_ctx *ctx, un - } - else - { -+ unsigned int r; -+ - if (!hlsl_type_is_resource(var->data_type)) - continue; -- regset = hlsl_type_get_regset(var->data_type); -- if (!var->regs[regset].allocated) -- continue; - -- if (!(hlsl_array_reserve(ctx, (void **)&extern_resources, &capacity, *count + 1, -- sizeof(*extern_resources)))) -+ for (r = 0; r <= HLSL_REGSET_LAST; ++r) - { -- sm4_free_extern_resources(extern_resources, *count); -- *count = 0; -- return NULL; -- } -+ if (!var->regs[r].allocated) -+ continue; - -- if (!(name = hlsl_strdup(ctx, string_skip_tag(var->name)))) -- { -- sm4_free_extern_resources(extern_resources, *count); -- *count = 0; -- return NULL; -- } -+ if (!(hlsl_array_reserve(ctx, (void **)&extern_resources, &capacity, *count + 1, -+ sizeof(*extern_resources)))) -+ { -+ sm4_free_extern_resources(extern_resources, *count); -+ *count = 0; -+ return NULL; -+ } -+ -+ if (!(name = hlsl_strdup(ctx, string_skip_tag(var->name)))) -+ { -+ sm4_free_extern_resources(extern_resources, *count); -+ *count = 0; -+ return NULL; -+ } - -- extern_resources[*count].var = var; -+ extern_resources[*count].var = var; - -- extern_resources[*count].name = name; -- extern_resources[*count].data_type = var->data_type; -- extern_resources[*count].is_user_packed = !!var->reg_reservation.reg_type; -+ extern_resources[*count].name = name; -+ extern_resources[*count].data_type = var->data_type; -+ extern_resources[*count].is_user_packed = !!var->reg_reservation.reg_type; - -- extern_resources[*count].regset = regset; -- extern_resources[*count].id = var->regs[regset].id; -- extern_resources[*count].bind_count = var->bind_count[regset]; -+ extern_resources[*count].regset = r; -+ extern_resources[*count].id = var->regs[r].id; -+ extern_resources[*count].bind_count = var->bind_count[r]; - -- ++*count; -+ ++*count; -+ } - } - } - -@@ -3427,7 +3460,8 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc) - - LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) - { -- if (var->is_uniform && var->buffer == cbuffer) -+ if (var->is_uniform && var->buffer == cbuffer -+ && var->data_type->class != HLSL_CLASS_OBJECT) - ++var_count; - } - -@@ -3461,7 +3495,8 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc) - - LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) - { -- if (var->is_uniform && var->buffer == cbuffer) -+ if (var->is_uniform && var->buffer == cbuffer -+ && var->data_type->class != HLSL_CLASS_OBJECT) - { - uint32_t flags = 0; - -@@ -3488,7 +3523,8 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc) - j = 0; - LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) - { -- if (var->is_uniform && var->buffer == cbuffer) -+ if (var->is_uniform && var->buffer == cbuffer -+ && var->data_type->class != HLSL_CLASS_OBJECT) - { - const unsigned int var_size = (profile->major_version >= 5 ? 10 : 6); - size_t var_offset = vars_start + j * var_size * sizeof(uint32_t); -@@ -3577,61 +3613,100 @@ static uint32_t sm4_encode_instruction_modifier(const struct sm4_instruction_mod - return word; - } - --struct sm4_register --{ -- enum vkd3d_shader_register_type type; -- struct vkd3d_shader_register_index idx[2]; -- unsigned int idx_count; -- enum vkd3d_sm4_dimension dim; -- uint32_t immconst_uint[4]; -- unsigned int mod; --}; -- - struct sm4_instruction - { - enum vkd3d_sm4_opcode opcode; -+ uint32_t extra_bits; - - struct sm4_instruction_modifier modifiers[1]; - unsigned int modifier_count; - -- struct sm4_dst_register -- { -- struct sm4_register reg; -- unsigned int writemask; -- } dsts[2]; -+ struct vkd3d_shader_dst_param dsts[2]; - unsigned int dst_count; - -- struct sm4_src_register -- { -- struct sm4_register reg; -- enum vkd3d_sm4_swizzle_type swizzle_type; -- unsigned int swizzle; -- } srcs[5]; -+ struct vkd3d_shader_src_param srcs[5]; - unsigned int src_count; - - unsigned int byte_stride; - - uint32_t idx[3]; - unsigned int idx_count; -+ -+ struct vkd3d_shader_src_param idx_srcs[7]; -+ unsigned int idx_src_count; - }; - --static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *reg, -- unsigned int *writemask, enum vkd3d_sm4_swizzle_type *swizzle_type, -- const struct hlsl_deref *deref) -+static void sm4_register_from_node(struct vkd3d_shader_register *reg, uint32_t *writemask, -+ const struct hlsl_ir_node *instr) -+{ -+ assert(instr->reg.allocated); -+ reg->type = VKD3DSPR_TEMP; -+ reg->dimension = VSIR_DIMENSION_VEC4; -+ reg->idx[0].offset = instr->reg.id; -+ reg->idx_count = 1; -+ *writemask = instr->reg.writemask; -+} -+ -+static void sm4_numeric_register_from_deref(struct hlsl_ctx *ctx, struct vkd3d_shader_register *reg, -+ enum vkd3d_shader_register_type type, uint32_t *writemask, const struct hlsl_deref *deref, -+ struct sm4_instruction *sm4_instr) -+{ -+ const struct hlsl_ir_var *var = deref->var; -+ unsigned int offset_const_deref; -+ -+ reg->type = type; -+ reg->idx[0].offset = var->regs[HLSL_REGSET_NUMERIC].id; -+ reg->dimension = VSIR_DIMENSION_VEC4; -+ -+ assert(var->regs[HLSL_REGSET_NUMERIC].allocated); -+ -+ if (!var->indexable) -+ { -+ offset_const_deref = hlsl_offset_from_deref_safe(ctx, deref); -+ reg->idx[0].offset += offset_const_deref / 4; -+ reg->idx_count = 1; -+ } -+ else -+ { -+ offset_const_deref = deref->const_offset; -+ reg->idx[1].offset = offset_const_deref / 4; -+ reg->idx_count = 2; -+ -+ if (deref->rel_offset.node) -+ { -+ struct vkd3d_shader_src_param *idx_src; -+ unsigned int idx_writemask; -+ -+ assert(sm4_instr->idx_src_count < ARRAY_SIZE(sm4_instr->idx_srcs)); -+ idx_src = &sm4_instr->idx_srcs[sm4_instr->idx_src_count++]; -+ memset(idx_src, 0, sizeof(*idx_src)); -+ -+ reg->idx[1].rel_addr = idx_src; -+ sm4_register_from_node(&idx_src->reg, &idx_writemask, deref->rel_offset.node); -+ assert(idx_writemask != 0); -+ idx_src->swizzle = swizzle_from_sm4(hlsl_swizzle_from_writemask(idx_writemask)); -+ } -+ } -+ -+ *writemask = 0xf & (0xf << (offset_const_deref % 4)); -+ if (var->regs[HLSL_REGSET_NUMERIC].writemask) -+ *writemask = hlsl_combine_writemasks(var->regs[HLSL_REGSET_NUMERIC].writemask, *writemask); -+} -+ -+static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct vkd3d_shader_register *reg, -+ uint32_t *writemask, const struct hlsl_deref *deref, struct sm4_instruction *sm4_instr) - { - const struct hlsl_type *data_type = hlsl_deref_get_type(ctx, deref); - const struct hlsl_ir_var *var = deref->var; - - if (var->is_uniform) - { -- enum hlsl_regset regset = hlsl_type_get_regset(data_type); -+ enum hlsl_regset regset = hlsl_deref_get_regset(ctx, deref); - - if (regset == HLSL_REGSET_TEXTURES) - { - reg->type = VKD3DSPR_RESOURCE; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - reg->idx[0].offset = var->regs[HLSL_REGSET_TEXTURES].id; - reg->idx[0].offset += hlsl_offset_from_deref_safe(ctx, deref); - assert(regset == HLSL_REGSET_TEXTURES); -@@ -3641,9 +3716,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - else if (regset == HLSL_REGSET_UAVS) - { - reg->type = VKD3DSPR_UAV; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - reg->idx[0].offset = var->regs[HLSL_REGSET_UAVS].id; - reg->idx[0].offset += hlsl_offset_from_deref_safe(ctx, deref); - assert(regset == HLSL_REGSET_UAVS); -@@ -3653,9 +3726,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - else if (regset == HLSL_REGSET_SAMPLERS) - { - reg->type = VKD3DSPR_SAMPLER; -- reg->dim = VKD3D_SM4_DIMENSION_NONE; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_NONE; -+ reg->dimension = VSIR_DIMENSION_NONE; - reg->idx[0].offset = var->regs[HLSL_REGSET_SAMPLERS].id; - reg->idx[0].offset += hlsl_offset_from_deref_safe(ctx, deref); - assert(regset == HLSL_REGSET_SAMPLERS); -@@ -3668,9 +3739,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - - assert(data_type->class <= HLSL_CLASS_VECTOR); - reg->type = VKD3DSPR_CONSTBUFFER; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - reg->idx[0].offset = var->buffer->reg.id; - reg->idx[1].offset = offset / 4; - reg->idx_count = 2; -@@ -3681,7 +3750,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - { - bool has_idx; - -- if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, false, ®->type, swizzle_type, &has_idx)) -+ if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, false, ®->type, &has_idx)) - { - unsigned int offset = hlsl_offset_from_deref_safe(ctx, deref); - -@@ -3691,7 +3760,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - reg->idx_count = 1; - } - -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - *writemask = ((1u << data_type->dimx) - 1) << (offset % 4); - } - else -@@ -3700,9 +3769,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - - assert(hlsl_reg.allocated); - reg->type = VKD3DSPR_INPUT; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - reg->idx[0].offset = hlsl_reg.id; - reg->idx_count = 1; - *writemask = hlsl_reg.writemask; -@@ -3712,7 +3779,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - { - bool has_idx; - -- if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, true, ®->type, swizzle_type, &has_idx)) -+ if (hlsl_sm4_register_from_semantic(ctx, &var->semantic, true, ®->type, &has_idx)) - { - unsigned int offset = hlsl_offset_from_deref_safe(ctx, deref); - -@@ -3723,9 +3790,9 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - } - - if (reg->type == VKD3DSPR_DEPTHOUT) -- reg->dim = VKD3D_SM4_DIMENSION_SCALAR; -+ reg->dimension = VSIR_DIMENSION_SCALAR; - else -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - *writemask = ((1u << data_type->dimx) - 1) << (offset % 4); - } - else -@@ -3734,7 +3801,7 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - - assert(hlsl_reg.allocated); - reg->type = VKD3DSPR_OUTPUT; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -+ reg->dimension = VSIR_DIMENSION_VEC4; - reg->idx[0].offset = hlsl_reg.id; - reg->idx_count = 1; - *writemask = hlsl_reg.writemask; -@@ -3742,77 +3809,61 @@ static void sm4_register_from_deref(struct hlsl_ctx *ctx, struct sm4_register *r - } - else - { -- struct hlsl_reg hlsl_reg = hlsl_reg_from_deref(ctx, deref); -+ enum vkd3d_shader_register_type type = deref->var->indexable ? VKD3DSPR_IDXTEMP : VKD3DSPR_TEMP; - -- assert(hlsl_reg.allocated); -- reg->type = VKD3DSPR_TEMP; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- if (swizzle_type) -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -- reg->idx[0].offset = hlsl_reg.id; -- reg->idx_count = 1; -- *writemask = hlsl_reg.writemask; -+ sm4_numeric_register_from_deref(ctx, reg, type, writemask, deref, sm4_instr); - } - } - --static void sm4_src_from_deref(struct hlsl_ctx *ctx, struct sm4_src_register *src, -- const struct hlsl_deref *deref, unsigned int map_writemask) -+static void sm4_src_from_deref(const struct tpf_writer *tpf, struct vkd3d_shader_src_param *src, -+ const struct hlsl_deref *deref, unsigned int map_writemask, struct sm4_instruction *sm4_instr) - { -- unsigned int writemask; -+ unsigned int hlsl_swizzle; -+ uint32_t writemask; - -- sm4_register_from_deref(ctx, &src->reg, &writemask, &src->swizzle_type, deref); -- if (src->swizzle_type == VKD3D_SM4_SWIZZLE_VEC4) -- src->swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), map_writemask); --} -- --static void sm4_register_from_node(struct sm4_register *reg, unsigned int *writemask, -- enum vkd3d_sm4_swizzle_type *swizzle_type, const struct hlsl_ir_node *instr) --{ -- assert(instr->reg.allocated); -- reg->type = VKD3DSPR_TEMP; -- reg->dim = VKD3D_SM4_DIMENSION_VEC4; -- *swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; -- reg->idx[0].offset = instr->reg.id; -- reg->idx_count = 1; -- *writemask = instr->reg.writemask; -+ sm4_register_from_deref(tpf->ctx, &src->reg, &writemask, deref, sm4_instr); -+ if (vkd3d_sm4_get_default_swizzle_type(&tpf->lookup, src->reg.type) == VKD3D_SM4_SWIZZLE_VEC4) -+ { -+ hlsl_swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), map_writemask); -+ src->swizzle = swizzle_from_sm4(hlsl_swizzle); -+ } - } - --static void sm4_dst_from_node(struct sm4_dst_register *dst, const struct hlsl_ir_node *instr) -+static void sm4_dst_from_node(struct vkd3d_shader_dst_param *dst, const struct hlsl_ir_node *instr) - { -- unsigned int swizzle_type; -- -- sm4_register_from_node(&dst->reg, &dst->writemask, &swizzle_type, instr); -+ sm4_register_from_node(&dst->reg, &dst->write_mask, instr); - } - --static void sm4_src_from_constant_value(struct sm4_src_register *src, -+static void sm4_src_from_constant_value(struct vkd3d_shader_src_param *src, - const struct hlsl_constant_value *value, unsigned int width, unsigned int map_writemask) - { -- src->swizzle_type = VKD3D_SM4_SWIZZLE_NONE; -+ src->swizzle = 0; - src->reg.type = VKD3DSPR_IMMCONST; - if (width == 1) - { -- src->reg.dim = VKD3D_SM4_DIMENSION_SCALAR; -- src->reg.immconst_uint[0] = value->u[0].u; -+ src->reg.dimension = VSIR_DIMENSION_SCALAR; -+ src->reg.u.immconst_uint[0] = value->u[0].u; - } - else - { - unsigned int i, j = 0; - -- src->reg.dim = VKD3D_SM4_DIMENSION_VEC4; -+ src->reg.dimension = VSIR_DIMENSION_VEC4; - for (i = 0; i < 4; ++i) - { - if ((map_writemask & (1u << i)) && (j < width)) -- src->reg.immconst_uint[i] = value->u[j++].u; -+ src->reg.u.immconst_uint[i] = value->u[j++].u; - else -- src->reg.immconst_uint[i] = 0; -+ src->reg.u.immconst_uint[i] = 0; - } - } - } - --static void sm4_src_from_node(struct sm4_src_register *src, -- const struct hlsl_ir_node *instr, unsigned int map_writemask) -+static void sm4_src_from_node(const struct tpf_writer *tpf, struct vkd3d_shader_src_param *src, -+ const struct hlsl_ir_node *instr, uint32_t map_writemask) - { -- unsigned int writemask; -+ unsigned int hlsl_swizzle; -+ uint32_t writemask; - - if (instr->type == HLSL_IR_CONSTANT) - { -@@ -3822,139 +3873,211 @@ static void sm4_src_from_node(struct sm4_src_register *src, - return; - } - -- sm4_register_from_node(&src->reg, &writemask, &src->swizzle_type, instr); -- if (src->swizzle_type == VKD3D_SM4_SWIZZLE_VEC4) -- src->swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), map_writemask); -+ sm4_register_from_node(&src->reg, &writemask, instr); -+ if (vkd3d_sm4_get_default_swizzle_type(&tpf->lookup, src->reg.type) == VKD3D_SM4_SWIZZLE_VEC4) -+ { -+ hlsl_swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), map_writemask); -+ src->swizzle = swizzle_from_sm4(hlsl_swizzle); -+ } - } - --static void sm4_write_dst_register(const struct tpf_writer *tpf, const struct sm4_dst_register *dst) -+static unsigned int sm4_get_index_addressing_from_reg(const struct vkd3d_shader_register *reg, -+ unsigned int i) -+{ -+ if (reg->idx[i].rel_addr) -+ { -+ if (reg->idx[i].offset == 0) -+ return VKD3D_SM4_ADDRESSING_RELATIVE; -+ else -+ return VKD3D_SM4_ADDRESSING_RELATIVE | VKD3D_SM4_ADDRESSING_OFFSET; -+ } -+ -+ return 0; -+} -+ -+static uint32_t sm4_encode_register(const struct tpf_writer *tpf, const struct vkd3d_shader_register *reg, -+ enum vkd3d_sm4_swizzle_type sm4_swizzle_type, uint32_t sm4_swizzle) - { - const struct vkd3d_sm4_register_type_info *register_type_info; -- struct vkd3d_bytecode_buffer *buffer = tpf->buffer; -- uint32_t sm4_reg_type, reg_dim; -+ uint32_t sm4_reg_type, sm4_reg_dim; - uint32_t token = 0; -- unsigned int j; - -- register_type_info = get_info_from_vkd3d_register_type(&tpf->lookup, dst->reg.type); -+ register_type_info = get_info_from_vkd3d_register_type(&tpf->lookup, reg->type); - if (!register_type_info) - { -- FIXME("Unhandled vkd3d-shader register type %#x.\n", dst->reg.type); -+ FIXME("Unhandled vkd3d-shader register type %#x.\n", reg->type); - sm4_reg_type = VKD3D_SM4_RT_TEMP; -+ if (sm4_swizzle_type == VKD3D_SM4_SWIZZLE_DEFAULT) -+ sm4_swizzle_type = VKD3D_SM4_SWIZZLE_VEC4; - } - else - { - sm4_reg_type = register_type_info->sm4_type; -+ if (sm4_swizzle_type == VKD3D_SM4_SWIZZLE_DEFAULT) -+ sm4_swizzle_type = register_type_info->default_src_swizzle_type; - } -- -- reg_dim = dst->reg.dim; -+ sm4_reg_dim = sm4_dimension_from_vsir_dimension(reg->dimension); - - token |= sm4_reg_type << VKD3D_SM4_REGISTER_TYPE_SHIFT; -- token |= dst->reg.idx_count << VKD3D_SM4_REGISTER_ORDER_SHIFT; -- token |= reg_dim << VKD3D_SM4_DIMENSION_SHIFT; -- if (reg_dim == VKD3D_SM4_DIMENSION_VEC4) -- token |= dst->writemask << VKD3D_SM4_WRITEMASK_SHIFT; -- put_u32(buffer, token); -+ token |= reg->idx_count << VKD3D_SM4_REGISTER_ORDER_SHIFT; -+ token |= sm4_reg_dim << VKD3D_SM4_DIMENSION_SHIFT; -+ if (reg->idx_count > 0) -+ token |= sm4_get_index_addressing_from_reg(reg, 0) << VKD3D_SM4_ADDRESSING_SHIFT0; -+ if (reg->idx_count > 1) -+ token |= sm4_get_index_addressing_from_reg(reg, 1) << VKD3D_SM4_ADDRESSING_SHIFT1; -+ if (reg->idx_count > 2) -+ token |= sm4_get_index_addressing_from_reg(reg, 2) << VKD3D_SM4_ADDRESSING_SHIFT2; - -- for (j = 0; j < dst->reg.idx_count; ++j) -+ if (sm4_reg_dim == VKD3D_SM4_DIMENSION_VEC4) - { -- put_u32(buffer, dst->reg.idx[j].offset); -- assert(!dst->reg.idx[j].rel_addr); -+ token |= (uint32_t)sm4_swizzle_type << VKD3D_SM4_SWIZZLE_TYPE_SHIFT; -+ -+ switch (sm4_swizzle_type) -+ { -+ case VKD3D_SM4_SWIZZLE_NONE: -+ assert(sm4_swizzle || register_is_constant(reg)); -+ token |= (sm4_swizzle << VKD3D_SM4_WRITEMASK_SHIFT) & VKD3D_SM4_WRITEMASK_MASK; -+ break; -+ -+ case VKD3D_SM4_SWIZZLE_VEC4: -+ token |= (sm4_swizzle << VKD3D_SM4_SWIZZLE_SHIFT) & VKD3D_SM4_SWIZZLE_MASK; -+ break; -+ -+ case VKD3D_SM4_SWIZZLE_SCALAR: -+ token |= (sm4_swizzle << VKD3D_SM4_SCALAR_DIM_SHIFT) & VKD3D_SM4_SCALAR_DIM_MASK; -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } - } -+ -+ return token; - } - --static void sm4_write_src_register(const struct tpf_writer *tpf, const struct sm4_src_register *src) -+static void sm4_write_register_index(const struct tpf_writer *tpf, const struct vkd3d_shader_register *reg, -+ unsigned int j) - { -- const struct vkd3d_sm4_register_type_info *register_type_info; -+ unsigned int addressing = sm4_get_index_addressing_from_reg(reg, j); - struct vkd3d_bytecode_buffer *buffer = tpf->buffer; -- uint32_t sm4_reg_type, reg_dim; -- uint32_t token = 0; -- unsigned int j; -+ unsigned int k; - -- register_type_info = get_info_from_vkd3d_register_type(&tpf->lookup, src->reg.type); -- if (!register_type_info) -+ if (addressing & VKD3D_SM4_ADDRESSING_RELATIVE) - { -- FIXME("Unhandled vkd3d-shader register type %#x.\n", src->reg.type); -- sm4_reg_type = VKD3D_SM4_RT_TEMP; -+ const struct vkd3d_shader_src_param *idx_src = reg->idx[j].rel_addr; -+ uint32_t idx_src_token; -+ -+ assert(idx_src); -+ assert(!idx_src->modifiers); -+ assert(idx_src->reg.type != VKD3DSPR_IMMCONST); -+ idx_src_token = sm4_encode_register(tpf, &idx_src->reg, VKD3D_SM4_SWIZZLE_SCALAR, idx_src->swizzle); -+ -+ put_u32(buffer, idx_src_token); -+ for (k = 0; k < idx_src->reg.idx_count; ++k) -+ { -+ put_u32(buffer, idx_src->reg.idx[k].offset); -+ assert(!idx_src->reg.idx[k].rel_addr); -+ } - } - else - { -- sm4_reg_type = register_type_info->sm4_type; -+ put_u32(tpf->buffer, reg->idx[j].offset); - } -+} - -- reg_dim = src->reg.dim; -+static void sm4_write_dst_register(const struct tpf_writer *tpf, const struct vkd3d_shader_dst_param *dst) -+{ -+ struct vkd3d_bytecode_buffer *buffer = tpf->buffer; -+ uint32_t token = 0; -+ unsigned int j; - -- token |= sm4_reg_type << VKD3D_SM4_REGISTER_TYPE_SHIFT; -- token |= src->reg.idx_count << VKD3D_SM4_REGISTER_ORDER_SHIFT; -- token |= reg_dim << VKD3D_SM4_DIMENSION_SHIFT; -- if (reg_dim == VKD3D_SM4_DIMENSION_VEC4) -- { -- token |= (uint32_t)src->swizzle_type << VKD3D_SM4_SWIZZLE_TYPE_SHIFT; -- token |= src->swizzle << VKD3D_SM4_SWIZZLE_SHIFT; -- } -- if (src->reg.mod) -- token |= VKD3D_SM4_EXTENDED_OPERAND; -+ token = sm4_encode_register(tpf, &dst->reg, VKD3D_SM4_SWIZZLE_NONE, dst->write_mask); - put_u32(buffer, token); - -- if (src->reg.mod) -- put_u32(buffer, (src->reg.mod << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) -- | VKD3D_SM4_EXTENDED_OPERAND_MODIFIER); -+ for (j = 0; j < dst->reg.idx_count; ++j) -+ sm4_write_register_index(tpf, &dst->reg, j); -+} - -- for (j = 0; j < src->reg.idx_count; ++j) -+static void sm4_write_src_register(const struct tpf_writer *tpf, const struct vkd3d_shader_src_param *src) -+{ -+ struct vkd3d_bytecode_buffer *buffer = tpf->buffer; -+ uint32_t token = 0, mod_token = 0; -+ unsigned int j; -+ -+ token = sm4_encode_register(tpf, &src->reg, VKD3D_SM4_SWIZZLE_DEFAULT, swizzle_to_sm4(src->swizzle)); -+ -+ switch (src->modifiers) - { -- put_u32(buffer, src->reg.idx[j].offset); -- assert(!src->reg.idx[j].rel_addr); -+ case VKD3DSPSM_NONE: -+ mod_token = VKD3D_SM4_REGISTER_MODIFIER_NONE; -+ break; -+ -+ case VKD3DSPSM_ABS: -+ mod_token = (VKD3D_SM4_REGISTER_MODIFIER_ABS << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) -+ | VKD3D_SM4_EXTENDED_OPERAND_MODIFIER; -+ break; -+ -+ case VKD3DSPSM_NEG: -+ mod_token = (VKD3D_SM4_REGISTER_MODIFIER_NEGATE << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) -+ | VKD3D_SM4_EXTENDED_OPERAND_MODIFIER; -+ break; -+ -+ case VKD3DSPSM_ABSNEG: -+ mod_token = (VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) -+ | VKD3D_SM4_EXTENDED_OPERAND_MODIFIER; -+ break; -+ -+ default: -+ ERR("Unhandled register modifier %#x.\n", src->modifiers); -+ vkd3d_unreachable(); -+ break; - } - -+ if (src->modifiers) -+ { -+ token |= VKD3D_SM4_EXTENDED_OPERAND; -+ put_u32(buffer, token); -+ put_u32(buffer, mod_token); -+ } -+ else -+ { -+ put_u32(buffer, token); -+ } -+ -+ for (j = 0; j < src->reg.idx_count; ++j) -+ sm4_write_register_index(tpf, &src->reg, j); -+ - if (src->reg.type == VKD3DSPR_IMMCONST) - { -- put_u32(buffer, src->reg.immconst_uint[0]); -- if (reg_dim == VKD3D_SM4_DIMENSION_VEC4) -+ put_u32(buffer, src->reg.u.immconst_uint[0]); -+ if (src->reg.dimension == VSIR_DIMENSION_VEC4) - { -- put_u32(buffer, src->reg.immconst_uint[1]); -- put_u32(buffer, src->reg.immconst_uint[2]); -- put_u32(buffer, src->reg.immconst_uint[3]); -+ put_u32(buffer, src->reg.u.immconst_uint[1]); -+ put_u32(buffer, src->reg.u.immconst_uint[2]); -+ put_u32(buffer, src->reg.u.immconst_uint[3]); - } - } - } - --static uint32_t sm4_register_order(const struct sm4_register *reg) --{ -- uint32_t order = 1; -- if (reg->type == VKD3DSPR_IMMCONST) -- order += reg->dim == VKD3D_SM4_DIMENSION_VEC4 ? 4 : 1; -- order += reg->idx_count; -- if (reg->mod) -- ++order; -- return order; --} -- - static void write_sm4_instruction(const struct tpf_writer *tpf, const struct sm4_instruction *instr) - { - struct vkd3d_bytecode_buffer *buffer = tpf->buffer; -- uint32_t token = instr->opcode; -- unsigned int size = 1, i, j; -- -- size += instr->modifier_count; -- for (i = 0; i < instr->dst_count; ++i) -- size += sm4_register_order(&instr->dsts[i].reg); -- for (i = 0; i < instr->src_count; ++i) -- size += sm4_register_order(&instr->srcs[i].reg); -- size += instr->idx_count; -- if (instr->byte_stride) -- ++size; -- -- token |= (size << VKD3D_SM4_INSTRUCTION_LENGTH_SHIFT); -+ uint32_t token = instr->opcode | instr->extra_bits; -+ unsigned int size, i, j; -+ size_t token_position; - - if (instr->modifier_count > 0) - token |= VKD3D_SM4_INSTRUCTION_MODIFIER; -- put_u32(buffer, token); -+ -+ token_position = put_u32(buffer, 0); - - for (i = 0; i < instr->modifier_count; ++i) - { -- token = sm4_encode_instruction_modifier(&instr->modifiers[i]); -+ uint32_t modifier_token = sm4_encode_instruction_modifier(&instr->modifiers[i]); -+ - if (instr->modifier_count > i + 1) -- token |= VKD3D_SM4_INSTRUCTION_MODIFIER; -- put_u32(buffer, token); -+ modifier_token |= VKD3D_SM4_INSTRUCTION_MODIFIER; -+ put_u32(buffer, modifier_token); - } - - for (i = 0; i < instr->dst_count; ++i) -@@ -3968,6 +4091,10 @@ static void write_sm4_instruction(const struct tpf_writer *tpf, const struct sm4 - - for (j = 0; j < instr->idx_count; ++j) - put_u32(buffer, instr->idx[j]); -+ -+ size = (bytecode_get_size(buffer) - token_position) / sizeof(uint32_t); -+ token |= (size << VKD3D_SM4_INSTRUCTION_LENGTH_SHIFT); -+ set_u32(buffer, token_position, token); - } - - static bool encode_texel_offset_as_aoffimmi(struct sm4_instruction *instr, -@@ -4003,13 +4130,12 @@ static void write_sm4_dcl_constant_buffer(const struct tpf_writer *tpf, const st - { - .opcode = VKD3D_SM4_OP_DCL_CONSTANT_BUFFER, - -- .srcs[0].reg.dim = VKD3D_SM4_DIMENSION_VEC4, -+ .srcs[0].reg.dimension = VSIR_DIMENSION_VEC4, - .srcs[0].reg.type = VKD3DSPR_CONSTBUFFER, - .srcs[0].reg.idx[0].offset = cbuffer->reg.id, - .srcs[0].reg.idx[1].offset = (cbuffer->used_size + 3) / 4, - .srcs[0].reg.idx_count = 2, -- .srcs[0].swizzle_type = VKD3D_SM4_SWIZZLE_VEC4, -- .srcs[0].swizzle = HLSL_SWIZZLE(X, Y, Z, W), -+ .srcs[0].swizzle = VKD3D_SHADER_NO_SWIZZLE, - .src_count = 1, - }; - write_sm4_instruction(tpf, &instr); -@@ -4031,7 +4157,7 @@ static void write_sm4_dcl_samplers(const struct tpf_writer *tpf, const struct ex - component_type = hlsl_type_get_component_type(tpf->ctx, resource->data_type, 0); - - if (component_type->sampler_dim == HLSL_SAMPLER_DIM_COMPARISON) -- instr.opcode |= VKD3D_SM4_SAMPLER_COMPARISON << VKD3D_SM4_SAMPLER_MODE_SHIFT; -+ instr.extra_bits |= VKD3D_SM4_SAMPLER_COMPARISON << VKD3D_SM4_SAMPLER_MODE_SHIFT; - - assert(resource->regset == HLSL_REGSET_SAMPLERS); - -@@ -4090,12 +4216,12 @@ static void write_sm4_dcl_textures(const struct tpf_writer *tpf, const struct ex - { - instr.opcode = VKD3D_SM4_OP_DCL_RESOURCE; - } -- instr.opcode |= (sm4_resource_dimension(component_type) << VKD3D_SM4_RESOURCE_TYPE_SHIFT); -+ instr.extra_bits |= (sm4_resource_dimension(component_type) << VKD3D_SM4_RESOURCE_TYPE_SHIFT); - - if (component_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS - || component_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY) - { -- instr.opcode |= component_type->sample_count << VKD3D_SM4_RESOURCE_SAMPLE_COUNT_SHIFT; -+ instr.extra_bits |= component_type->sample_count << VKD3D_SM4_RESOURCE_SAMPLE_COUNT_SHIFT; - } - - write_sm4_instruction(tpf, &instr); -@@ -4111,11 +4237,11 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl - - struct sm4_instruction instr = - { -- .dsts[0].reg.dim = VKD3D_SM4_DIMENSION_VEC4, -+ .dsts[0].reg.dimension = VSIR_DIMENSION_VEC4, - .dst_count = 1, - }; - -- if (hlsl_sm4_register_from_semantic(tpf->ctx, &var->semantic, output, &instr.dsts[0].reg.type, NULL, &has_idx)) -+ if (hlsl_sm4_register_from_semantic(tpf->ctx, &var->semantic, output, &instr.dsts[0].reg.type, &has_idx)) - { - if (has_idx) - { -@@ -4126,18 +4252,18 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl - { - instr.dsts[0].reg.idx_count = 0; - } -- instr.dsts[0].writemask = (1 << var->data_type->dimx) - 1; -+ instr.dsts[0].write_mask = (1 << var->data_type->dimx) - 1; - } - else - { - instr.dsts[0].reg.type = output ? VKD3DSPR_OUTPUT : VKD3DSPR_INPUT; - instr.dsts[0].reg.idx[0].offset = var->regs[HLSL_REGSET_NUMERIC].id; - instr.dsts[0].reg.idx_count = 1; -- instr.dsts[0].writemask = var->regs[HLSL_REGSET_NUMERIC].writemask; -+ instr.dsts[0].write_mask = var->regs[HLSL_REGSET_NUMERIC].writemask; - } - - if (instr.dsts[0].reg.type == VKD3DSPR_DEPTHOUT) -- instr.dsts[0].reg.dim = VKD3D_SM4_DIMENSION_SCALAR; -+ instr.dsts[0].reg.dimension = VSIR_DIMENSION_SCALAR; - - hlsl_sm4_usage_from_semantic(tpf->ctx, &var->semantic, output, &usage); - if (usage == ~0u) -@@ -4170,9 +4296,35 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl - enum vkd3d_shader_interpolation_mode mode = VKD3DSIM_LINEAR; - - if ((var->storage_modifiers & HLSL_STORAGE_NOINTERPOLATION) || type_is_integer(var->data_type)) -+ { - mode = VKD3DSIM_CONSTANT; -+ } -+ else -+ { -+ static const struct -+ { -+ unsigned int modifiers; -+ enum vkd3d_shader_interpolation_mode mode; -+ } -+ modes[] = -+ { -+ { HLSL_STORAGE_CENTROID | HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE_CENTROID }, -+ { HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE }, -+ { HLSL_STORAGE_CENTROID, VKD3DSIM_LINEAR_CENTROID }, -+ }; -+ unsigned int i; - -- instr.opcode |= mode << VKD3D_SM4_INTERPOLATION_MODE_SHIFT; -+ for (i = 0; i < ARRAY_SIZE(modes); ++i) -+ { -+ if ((var->storage_modifiers & modes[i].modifiers) == modes[i].modifiers) -+ { -+ mode = modes[i].mode; -+ break; -+ } -+ } -+ } -+ -+ instr.extra_bits |= mode << VKD3D_SM4_INTERPOLATION_MODE_SHIFT; - } - } - else -@@ -4215,6 +4367,20 @@ static void write_sm4_dcl_temps(const struct tpf_writer *tpf, uint32_t temp_coun - write_sm4_instruction(tpf, &instr); - } - -+static void write_sm4_dcl_indexable_temp(const struct tpf_writer *tpf, uint32_t idx, -+ uint32_t size, uint32_t comp_count) -+{ -+ struct sm4_instruction instr = -+ { -+ .opcode = VKD3D_SM4_OP_DCL_INDEXABLE_TEMP, -+ -+ .idx = {idx, size, comp_count}, -+ .idx_count = 3, -+ }; -+ -+ write_sm4_instruction(tpf, &instr); -+} -+ - static void write_sm4_dcl_thread_group(const struct tpf_writer *tpf, const uint32_t thread_count[3]) - { - struct sm4_instruction instr = -@@ -4241,7 +4407,7 @@ static void write_sm4_ret(const struct tpf_writer *tpf) - } - - static void write_sm4_unary_op(const struct tpf_writer *tpf, enum vkd3d_sm4_opcode opcode, -- const struct hlsl_ir_node *dst, const struct hlsl_ir_node *src, unsigned int src_mod) -+ const struct hlsl_ir_node *dst, const struct hlsl_ir_node *src, enum vkd3d_shader_src_modifier src_mod) - { - struct sm4_instruction instr; - -@@ -4251,8 +4417,8 @@ static void write_sm4_unary_op(const struct tpf_writer *tpf, enum vkd3d_sm4_opco - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], src, instr.dsts[0].writemask); -- instr.srcs[0].reg.mod = src_mod; -+ sm4_src_from_node(tpf, &instr.srcs[0], src, instr.dsts[0].write_mask); -+ instr.srcs[0].modifiers = src_mod; - instr.src_count = 1; - - write_sm4_instruction(tpf, &instr); -@@ -4270,11 +4436,11 @@ static void write_sm4_unary_op_with_two_destinations(const struct tpf_writer *tp - sm4_dst_from_node(&instr.dsts[dst_idx], dst); - assert(1 - dst_idx >= 0); - instr.dsts[1 - dst_idx].reg.type = VKD3DSPR_NULL; -- instr.dsts[1 - dst_idx].reg.dim = VKD3D_SM4_DIMENSION_NONE; -+ instr.dsts[1 - dst_idx].reg.dimension = VSIR_DIMENSION_NONE; - instr.dsts[1 - dst_idx].reg.idx_count = 0; - instr.dst_count = 2; - -- sm4_src_from_node(&instr.srcs[0], src, instr.dsts[dst_idx].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], src, instr.dsts[dst_idx].write_mask); - instr.src_count = 1; - - write_sm4_instruction(tpf, &instr); -@@ -4291,8 +4457,8 @@ static void write_sm4_binary_op(const struct tpf_writer *tpf, enum vkd3d_sm4_opc - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], src1, instr.dsts[0].writemask); -- sm4_src_from_node(&instr.srcs[1], src2, instr.dsts[0].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], src1, instr.dsts[0].write_mask); -+ sm4_src_from_node(tpf, &instr.srcs[1], src2, instr.dsts[0].write_mask); - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4310,8 +4476,8 @@ static void write_sm4_binary_op_dot(const struct tpf_writer *tpf, enum vkd3d_sm4 - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], src1, VKD3DSP_WRITEMASK_ALL); -- sm4_src_from_node(&instr.srcs[1], src2, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[0], src1, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[1], src2, VKD3DSP_WRITEMASK_ALL); - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4330,12 +4496,12 @@ static void write_sm4_binary_op_with_two_destinations(const struct tpf_writer *t - sm4_dst_from_node(&instr.dsts[dst_idx], dst); - assert(1 - dst_idx >= 0); - instr.dsts[1 - dst_idx].reg.type = VKD3DSPR_NULL; -- instr.dsts[1 - dst_idx].reg.dim = VKD3D_SM4_DIMENSION_NONE; -+ instr.dsts[1 - dst_idx].reg.dimension = VSIR_DIMENSION_NONE; - instr.dsts[1 - dst_idx].reg.idx_count = 0; - instr.dst_count = 2; - -- sm4_src_from_node(&instr.srcs[0], src1, instr.dsts[dst_idx].writemask); -- sm4_src_from_node(&instr.srcs[1], src2, instr.dsts[dst_idx].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], src1, instr.dsts[dst_idx].write_mask); -+ sm4_src_from_node(tpf, &instr.srcs[1], src2, instr.dsts[dst_idx].write_mask); - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4353,9 +4519,9 @@ static void write_sm4_ternary_op(const struct tpf_writer *tpf, enum vkd3d_sm4_op - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], src1, instr.dsts[0].writemask); -- sm4_src_from_node(&instr.srcs[1], src2, instr.dsts[0].writemask); -- sm4_src_from_node(&instr.srcs[2], src3, instr.dsts[0].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], src1, instr.dsts[0].write_mask); -+ sm4_src_from_node(tpf, &instr.srcs[1], src2, instr.dsts[0].write_mask); -+ sm4_src_from_node(tpf, &instr.srcs[2], src3, instr.dsts[0].write_mask); - instr.src_count = 3; - - write_sm4_instruction(tpf, &instr); -@@ -4369,7 +4535,7 @@ static void write_sm4_ld(const struct tpf_writer *tpf, const struct hlsl_ir_node - const struct hlsl_type *resource_type = hlsl_deref_get_type(tpf->ctx, resource); - bool multisampled = resource_type->base_type == HLSL_TYPE_TEXTURE - && (resource_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS || resource_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY); -- bool uav = (hlsl_type_get_regset(resource_type) == HLSL_REGSET_UAVS); -+ bool uav = (hlsl_deref_get_regset(tpf->ctx, resource) == HLSL_REGSET_UAVS); - unsigned int coords_writemask = VKD3DSP_WRITEMASK_ALL; - struct sm4_instruction instr; - -@@ -4404,9 +4570,9 @@ static void write_sm4_ld(const struct tpf_writer *tpf, const struct hlsl_ir_node - coords_writemask = VKD3DSP_WRITEMASK_0 | VKD3DSP_WRITEMASK_1 | VKD3DSP_WRITEMASK_3; - } - -- sm4_src_from_node(&instr.srcs[0], coords, coords_writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], coords, coords_writemask); - -- sm4_src_from_deref(tpf->ctx, &instr.srcs[1], resource, instr.dsts[0].writemask); -+ sm4_src_from_deref(tpf, &instr.srcs[1], resource, instr.dsts[0].write_mask, &instr); - - instr.src_count = 2; - -@@ -4414,16 +4580,15 @@ static void write_sm4_ld(const struct tpf_writer *tpf, const struct hlsl_ir_node - { - if (sample_index->type == HLSL_IR_CONSTANT) - { -- struct sm4_register *reg = &instr.srcs[2].reg; -+ struct vkd3d_shader_register *reg = &instr.srcs[2].reg; - struct hlsl_ir_constant *index; - - index = hlsl_ir_constant(sample_index); - - memset(&instr.srcs[2], 0, sizeof(instr.srcs[2])); -- instr.srcs[2].swizzle_type = VKD3D_SM4_SWIZZLE_NONE; - reg->type = VKD3DSPR_IMMCONST; -- reg->dim = VKD3D_SM4_DIMENSION_SCALAR; -- reg->immconst_uint[0] = index->value.u[0].u; -+ reg->dimension = VSIR_DIMENSION_SCALAR; -+ reg->u.immconst_uint[0] = index->value.u[0].u; - } - else if (tpf->ctx->profile->major_version == 4 && tpf->ctx->profile->minor_version == 0) - { -@@ -4431,7 +4596,7 @@ static void write_sm4_ld(const struct tpf_writer *tpf, const struct hlsl_ir_node - } - else - { -- sm4_src_from_node(&instr.srcs[2], sample_index, 0); -+ sm4_src_from_node(tpf, &instr.srcs[2], sample_index, 0); - } - - ++instr.src_count; -@@ -4493,27 +4658,27 @@ static void write_sm4_sample(const struct tpf_writer *tpf, const struct hlsl_ir_ - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], coords, VKD3DSP_WRITEMASK_ALL); -- sm4_src_from_deref(tpf->ctx, &instr.srcs[1], resource, instr.dsts[0].writemask); -- sm4_src_from_deref(tpf->ctx, &instr.srcs[2], sampler, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[0], coords, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_deref(tpf, &instr.srcs[1], resource, instr.dsts[0].write_mask, &instr); -+ sm4_src_from_deref(tpf, &instr.srcs[2], sampler, VKD3DSP_WRITEMASK_ALL, &instr); - instr.src_count = 3; - - if (load->load_type == HLSL_RESOURCE_SAMPLE_LOD - || load->load_type == HLSL_RESOURCE_SAMPLE_LOD_BIAS) - { -- sm4_src_from_node(&instr.srcs[3], load->lod.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[3], load->lod.node, VKD3DSP_WRITEMASK_ALL); - ++instr.src_count; - } - else if (load->load_type == HLSL_RESOURCE_SAMPLE_GRAD) - { -- sm4_src_from_node(&instr.srcs[3], load->ddx.node, VKD3DSP_WRITEMASK_ALL); -- sm4_src_from_node(&instr.srcs[4], load->ddy.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[3], load->ddx.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[4], load->ddy.node, VKD3DSP_WRITEMASK_ALL); - instr.src_count += 2; - } - else if (load->load_type == HLSL_RESOURCE_SAMPLE_CMP - || load->load_type == HLSL_RESOURCE_SAMPLE_CMP_LZ) - { -- sm4_src_from_node(&instr.srcs[3], load->cmp.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[3], load->cmp.node, VKD3DSP_WRITEMASK_ALL); - ++instr.src_count; - } - -@@ -4531,12 +4696,12 @@ static void write_sm4_sampleinfo(const struct tpf_writer *tpf, const struct hlsl - memset(&instr, 0, sizeof(instr)); - instr.opcode = VKD3D_SM4_OP_SAMPLE_INFO; - if (dst->data_type->base_type == HLSL_TYPE_UINT) -- instr.opcode |= VKD3DSI_SAMPLE_INFO_UINT << VKD3D_SM4_INSTRUCTION_FLAGS_SHIFT; -+ instr.extra_bits |= VKD3DSI_SAMPLE_INFO_UINT << VKD3D_SM4_INSTRUCTION_FLAGS_SHIFT; - - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_deref(tpf->ctx, &instr.srcs[0], resource, instr.dsts[0].writemask); -+ sm4_src_from_deref(tpf, &instr.srcs[0], resource, instr.dsts[0].write_mask, &instr); - instr.src_count = 1; - - write_sm4_instruction(tpf, &instr); -@@ -4553,13 +4718,13 @@ static void write_sm4_resinfo(const struct tpf_writer *tpf, const struct hlsl_ir - memset(&instr, 0, sizeof(instr)); - instr.opcode = VKD3D_SM4_OP_RESINFO; - if (dst->data_type->base_type == HLSL_TYPE_UINT) -- instr.opcode |= VKD3DSI_RESINFO_UINT << VKD3D_SM4_INSTRUCTION_FLAGS_SHIFT; -+ instr.extra_bits |= VKD3DSI_RESINFO_UINT << VKD3D_SM4_INSTRUCTION_FLAGS_SHIFT; - - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], load->lod.node, VKD3DSP_WRITEMASK_ALL); -- sm4_src_from_deref(tpf->ctx, &instr.srcs[1], resource, instr.dsts[0].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], load->lod.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_deref(tpf, &instr.srcs[1], resource, instr.dsts[0].write_mask, &instr); - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4581,11 +4746,10 @@ static void write_sm4_cast_from_bool(const struct tpf_writer *tpf, const struct - sm4_dst_from_node(&instr.dsts[0], &expr->node); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], arg, instr.dsts[0].writemask); -- instr.srcs[1].swizzle_type = VKD3D_SM4_SWIZZLE_NONE; -+ sm4_src_from_node(tpf, &instr.srcs[0], arg, instr.dsts[0].write_mask); - instr.srcs[1].reg.type = VKD3DSPR_IMMCONST; -- instr.srcs[1].reg.dim = VKD3D_SM4_DIMENSION_SCALAR; -- instr.srcs[1].reg.immconst_uint[0] = mask; -+ instr.srcs[1].reg.dimension = VSIR_DIMENSION_SCALAR; -+ instr.srcs[1].reg.u.immconst_uint[0] = mask; - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4708,11 +4872,11 @@ static void write_sm4_store_uav_typed(const struct tpf_writer *tpf, const struct - memset(&instr, 0, sizeof(instr)); - instr.opcode = VKD3D_SM5_OP_STORE_UAV_TYPED; - -- sm4_register_from_deref(tpf->ctx, &instr.dsts[0].reg, &instr.dsts[0].writemask, NULL, dst); -+ sm4_register_from_deref(tpf->ctx, &instr.dsts[0].reg, &instr.dsts[0].write_mask, dst, &instr); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], coords, VKD3DSP_WRITEMASK_ALL); -- sm4_src_from_node(&instr.srcs[1], value, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[0], coords, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[1], value, VKD3DSP_WRITEMASK_ALL); - instr.src_count = 2; - - write_sm4_instruction(tpf, &instr); -@@ -4737,7 +4901,7 @@ static void write_sm4_expr(const struct tpf_writer *tpf, const struct hlsl_ir_ex - switch (dst_type->base_type) - { - case HLSL_TYPE_FLOAT: -- write_sm4_unary_op(tpf, VKD3D_SM4_OP_MOV, &expr->node, arg1, VKD3D_SM4_REGISTER_MODIFIER_ABS); -+ write_sm4_unary_op(tpf, VKD3D_SM4_OP_MOV, &expr->node, arg1, VKD3DSPSM_ABS); - break; - - default: -@@ -4754,6 +4918,11 @@ static void write_sm4_expr(const struct tpf_writer *tpf, const struct hlsl_ir_ex - write_sm4_cast(tpf, expr); - break; - -+ case HLSL_OP1_CEIL: -+ assert(type_is_float(dst_type)); -+ write_sm4_unary_op(tpf, VKD3D_SM4_OP_ROUND_PI, &expr->node, arg1, 0); -+ break; -+ - case HLSL_OP1_COS: - assert(type_is_float(dst_type)); - write_sm4_unary_op_with_two_destinations(tpf, VKD3D_SM4_OP_SINCOS, &expr->node, 1, arg1); -@@ -4818,7 +4987,7 @@ static void write_sm4_expr(const struct tpf_writer *tpf, const struct hlsl_ir_ex - switch (dst_type->base_type) - { - case HLSL_TYPE_FLOAT: -- write_sm4_unary_op(tpf, VKD3D_SM4_OP_MOV, &expr->node, arg1, VKD3D_SM4_REGISTER_MODIFIER_NEGATE); -+ write_sm4_unary_op(tpf, VKD3D_SM4_OP_MOV, &expr->node, arg1, VKD3DSPSM_NEG); - break; - - case HLSL_TYPE_INT: -@@ -5169,7 +5338,7 @@ static void write_sm4_if(const struct tpf_writer *tpf, const struct hlsl_ir_if * - - assert(iff->condition.node->data_type->dimx == 1); - -- sm4_src_from_node(&instr.srcs[0], iff->condition.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[0], iff->condition.node, VKD3DSP_WRITEMASK_ALL); - write_sm4_instruction(tpf, &instr); - - write_sm4_block(tpf, &iff->then_block); -@@ -5198,13 +5367,17 @@ static void write_sm4_jump(const struct tpf_writer *tpf, const struct hlsl_ir_ju - instr.opcode = VKD3D_SM4_OP_BREAK; - break; - -+ case HLSL_IR_JUMP_CONTINUE: -+ instr.opcode = VKD3D_SM4_OP_CONTINUE; -+ break; -+ - case HLSL_IR_JUMP_DISCARD_NZ: - { - instr.opcode = VKD3D_SM4_OP_DISCARD | VKD3D_SM4_CONDITIONAL_NZ; - - memset(&instr.srcs[0], 0, sizeof(*instr.srcs)); - instr.src_count = 1; -- sm4_src_from_node(&instr.srcs[0], jump->condition.node, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[0], jump->condition.node, VKD3DSP_WRITEMASK_ALL); - break; - } - -@@ -5240,7 +5413,7 @@ static void write_sm4_load(const struct tpf_writer *tpf, const struct hlsl_ir_lo - sm4_dst_from_node(&instr.dsts[0], &load->node); - instr.dst_count = 1; - -- assert(type->class <= HLSL_CLASS_LAST_NUMERIC); -+ assert(hlsl_is_numeric_type(type)); - if (type->base_type == HLSL_TYPE_BOOL && var_is_user_input(tpf->ctx, load->src.var)) - { - struct hlsl_constant_value value; -@@ -5250,19 +5423,19 @@ static void write_sm4_load(const struct tpf_writer *tpf, const struct hlsl_ir_lo - - instr.opcode = VKD3D_SM4_OP_MOVC; - -- sm4_src_from_deref(tpf->ctx, &instr.srcs[0], &load->src, instr.dsts[0].writemask); -+ sm4_src_from_deref(tpf, &instr.srcs[0], &load->src, instr.dsts[0].write_mask, &instr); - - memset(&value, 0xff, sizeof(value)); -- sm4_src_from_constant_value(&instr.srcs[1], &value, type->dimx, instr.dsts[0].writemask); -+ sm4_src_from_constant_value(&instr.srcs[1], &value, type->dimx, instr.dsts[0].write_mask); - memset(&value, 0, sizeof(value)); -- sm4_src_from_constant_value(&instr.srcs[2], &value, type->dimx, instr.dsts[0].writemask); -+ sm4_src_from_constant_value(&instr.srcs[2], &value, type->dimx, instr.dsts[0].write_mask); - instr.src_count = 3; - } - else - { - instr.opcode = VKD3D_SM4_OP_MOV; - -- sm4_src_from_deref(tpf->ctx, &instr.srcs[0], &load->src, instr.dsts[0].writemask); -+ sm4_src_from_deref(tpf, &instr.srcs[0], &load->src, instr.dsts[0].write_mask, &instr); - instr.src_count = 1; - } - -@@ -5285,10 +5458,10 @@ static void write_sm4_loop(const struct tpf_writer *tpf, const struct hlsl_ir_lo - } - - static void write_sm4_gather(const struct tpf_writer *tpf, const struct hlsl_ir_node *dst, -- const struct hlsl_deref *resource, const struct hlsl_deref *sampler, const struct hlsl_ir_node *coords, -- unsigned int swizzle, const struct hlsl_ir_node *texel_offset) -+ const struct hlsl_deref *resource, const struct hlsl_deref *sampler, -+ const struct hlsl_ir_node *coords, DWORD swizzle, const struct hlsl_ir_node *texel_offset) - { -- struct sm4_src_register *src; -+ struct vkd3d_shader_src_param *src; - struct sm4_instruction instr; - - memset(&instr, 0, sizeof(instr)); -@@ -5298,7 +5471,7 @@ static void write_sm4_gather(const struct tpf_writer *tpf, const struct hlsl_ir_ - sm4_dst_from_node(&instr.dsts[0], dst); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[instr.src_count++], coords, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[instr.src_count++], coords, VKD3DSP_WRITEMASK_ALL); - - if (texel_offset) - { -@@ -5311,16 +5484,15 @@ static void write_sm4_gather(const struct tpf_writer *tpf, const struct hlsl_ir_ - return; - } - instr.opcode = VKD3D_SM5_OP_GATHER4_PO; -- sm4_src_from_node(&instr.srcs[instr.src_count++], texel_offset, VKD3DSP_WRITEMASK_ALL); -+ sm4_src_from_node(tpf, &instr.srcs[instr.src_count++], texel_offset, VKD3DSP_WRITEMASK_ALL); - } - } - -- sm4_src_from_deref(tpf->ctx, &instr.srcs[instr.src_count++], resource, instr.dsts[0].writemask); -+ sm4_src_from_deref(tpf, &instr.srcs[instr.src_count++], resource, instr.dsts[0].write_mask, &instr); - - src = &instr.srcs[instr.src_count++]; -- sm4_src_from_deref(tpf->ctx, src, sampler, VKD3DSP_WRITEMASK_ALL); -- src->reg.dim = VKD3D_SM4_DIMENSION_VEC4; -- src->swizzle_type = VKD3D_SM4_SWIZZLE_SCALAR; -+ sm4_src_from_deref(tpf, src, sampler, VKD3DSP_WRITEMASK_ALL, &instr); -+ src->reg.dimension = VSIR_DIMENSION_VEC4; - src->swizzle = swizzle; - - write_sm4_instruction(tpf, &instr); -@@ -5364,22 +5536,22 @@ static void write_sm4_resource_load(const struct tpf_writer *tpf, const struct h - - case HLSL_RESOURCE_GATHER_RED: - write_sm4_gather(tpf, &load->node, &load->resource, &load->sampler, coords, -- HLSL_SWIZZLE(X, X, X, X), texel_offset); -+ VKD3D_SHADER_SWIZZLE(X, X, X, X), texel_offset); - break; - - case HLSL_RESOURCE_GATHER_GREEN: - write_sm4_gather(tpf, &load->node, &load->resource, &load->sampler, coords, -- HLSL_SWIZZLE(Y, Y, Y, Y), texel_offset); -+ VKD3D_SHADER_SWIZZLE(Y, Y, Y, Y), texel_offset); - break; - - case HLSL_RESOURCE_GATHER_BLUE: - write_sm4_gather(tpf, &load->node, &load->resource, &load->sampler, coords, -- HLSL_SWIZZLE(Z, Z, Z, Z), texel_offset); -+ VKD3D_SHADER_SWIZZLE(Z, Z, Z, Z), texel_offset); - break; - - case HLSL_RESOURCE_GATHER_ALPHA: - write_sm4_gather(tpf, &load->node, &load->resource, &load->sampler, coords, -- HLSL_SWIZZLE(W, W, W, W), texel_offset); -+ VKD3D_SHADER_SWIZZLE(W, W, W, W), texel_offset); - break; - - case HLSL_RESOURCE_SAMPLE_INFO: -@@ -5389,6 +5561,9 @@ static void write_sm4_resource_load(const struct tpf_writer *tpf, const struct h - case HLSL_RESOURCE_RESINFO: - write_sm4_resinfo(tpf, load); - break; -+ -+ case HLSL_RESOURCE_SAMPLE_PROJ: -+ vkd3d_unreachable(); - } - } - -@@ -5415,25 +5590,66 @@ static void write_sm4_store(const struct tpf_writer *tpf, const struct hlsl_ir_s - { - const struct hlsl_ir_node *rhs = store->rhs.node; - struct sm4_instruction instr; -- unsigned int writemask; -+ uint32_t writemask; - - memset(&instr, 0, sizeof(instr)); - instr.opcode = VKD3D_SM4_OP_MOV; - -- sm4_register_from_deref(tpf->ctx, &instr.dsts[0].reg, &writemask, NULL, &store->lhs); -- instr.dsts[0].writemask = hlsl_combine_writemasks(writemask, store->writemask); -+ sm4_register_from_deref(tpf->ctx, &instr.dsts[0].reg, &writemask, &store->lhs, &instr); -+ instr.dsts[0].write_mask = hlsl_combine_writemasks(writemask, store->writemask); - instr.dst_count = 1; - -- sm4_src_from_node(&instr.srcs[0], rhs, instr.dsts[0].writemask); -+ sm4_src_from_node(tpf, &instr.srcs[0], rhs, instr.dsts[0].write_mask); - instr.src_count = 1; - - write_sm4_instruction(tpf, &instr); - } - -+static void write_sm4_switch(const struct tpf_writer *tpf, const struct hlsl_ir_switch *s) -+{ -+ const struct hlsl_ir_node *selector = s->selector.node; -+ struct hlsl_ir_switch_case *c; -+ struct sm4_instruction instr; -+ -+ memset(&instr, 0, sizeof(instr)); -+ instr.opcode = VKD3D_SM4_OP_SWITCH; -+ -+ sm4_src_from_node(tpf, &instr.srcs[0], selector, VKD3DSP_WRITEMASK_ALL); -+ instr.src_count = 1; -+ -+ write_sm4_instruction(tpf, &instr); -+ -+ LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry) -+ { -+ memset(&instr, 0, sizeof(instr)); -+ if (c->is_default) -+ { -+ instr.opcode = VKD3D_SM4_OP_DEFAULT; -+ } -+ else -+ { -+ struct hlsl_constant_value value = { .u[0].u = c->value }; -+ -+ instr.opcode = VKD3D_SM4_OP_CASE; -+ sm4_src_from_constant_value(&instr.srcs[0], &value, 1, VKD3DSP_WRITEMASK_ALL); -+ instr.src_count = 1; -+ } -+ -+ write_sm4_instruction(tpf, &instr); -+ write_sm4_block(tpf, &c->body); -+ } -+ -+ memset(&instr, 0, sizeof(instr)); -+ instr.opcode = VKD3D_SM4_OP_ENDSWITCH; -+ -+ write_sm4_instruction(tpf, &instr); -+} -+ - static void write_sm4_swizzle(const struct tpf_writer *tpf, const struct hlsl_ir_swizzle *swizzle) - { -+ unsigned int hlsl_swizzle; - struct sm4_instruction instr; -- unsigned int writemask; -+ uint32_t writemask; - - memset(&instr, 0, sizeof(instr)); - instr.opcode = VKD3D_SM4_OP_MOV; -@@ -5441,9 +5657,10 @@ static void write_sm4_swizzle(const struct tpf_writer *tpf, const struct hlsl_ir - sm4_dst_from_node(&instr.dsts[0], &swizzle->node); - instr.dst_count = 1; - -- sm4_register_from_node(&instr.srcs[0].reg, &writemask, &instr.srcs[0].swizzle_type, swizzle->val.node); -- instr.srcs[0].swizzle = hlsl_map_swizzle(hlsl_combine_swizzles(hlsl_swizzle_from_writemask(writemask), -- swizzle->swizzle, swizzle->node.data_type->dimx), instr.dsts[0].writemask); -+ sm4_register_from_node(&instr.srcs[0].reg, &writemask, swizzle->val.node); -+ hlsl_swizzle = hlsl_map_swizzle(hlsl_combine_swizzles(hlsl_swizzle_from_writemask(writemask), -+ swizzle->swizzle, swizzle->node.data_type->dimx), instr.dsts[0].write_mask); -+ instr.srcs[0].swizzle = swizzle_from_sm4(hlsl_swizzle); - instr.src_count = 1; - - write_sm4_instruction(tpf, &instr); -@@ -5515,6 +5732,10 @@ static void write_sm4_block(const struct tpf_writer *tpf, const struct hlsl_bloc - write_sm4_store(tpf, hlsl_ir_store(instr)); - break; - -+ case HLSL_IR_SWITCH: -+ write_sm4_switch(tpf, hlsl_ir_switch(instr)); -+ break; -+ - case HLSL_IR_SWIZZLE: - write_sm4_swizzle(tpf, hlsl_ir_swizzle(instr)); - break; -@@ -5533,6 +5754,7 @@ static void write_sm4_shdr(struct hlsl_ctx *ctx, - struct extern_resource *extern_resources; - unsigned int extern_resources_count, i; - const struct hlsl_buffer *cbuffer; -+ const struct hlsl_scope *scope; - const struct hlsl_ir_var *var; - size_t token_count_position; - struct tpf_writer tpf; -@@ -5587,6 +5809,25 @@ static void write_sm4_shdr(struct hlsl_ctx *ctx, - if (ctx->temp_count) - write_sm4_dcl_temps(&tpf, ctx->temp_count); - -+ LIST_FOR_EACH_ENTRY(scope, &ctx->scopes, struct hlsl_scope, entry) -+ { -+ LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry) -+ { -+ if (var->is_uniform || var->is_input_semantic || var->is_output_semantic) -+ continue; -+ if (!var->regs[HLSL_REGSET_NUMERIC].allocated) -+ continue; -+ -+ if (var->indexable) -+ { -+ unsigned int id = var->regs[HLSL_REGSET_NUMERIC].id; -+ unsigned int size = align(var->data_type->reg_size[HLSL_REGSET_NUMERIC], 4) / 4; -+ -+ write_sm4_dcl_indexable_temp(&tpf, id, size, 4); -+ } -+ } -+ } -+ - write_sm4_block(&tpf, &entry_func->body); - - write_sm4_ret(&tpf); -diff --git a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c -index f25dbb04d69..b60dc17e902 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c -+++ b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c -@@ -18,10 +18,13 @@ - - #include "vkd3d_shader_private.h" - #include "vkd3d_version.h" -+#include "hlsl.h" - - #include - #include - -+/* VKD3D_DEBUG_ENV_NAME("VKD3D_SHADER_DEBUG"); */ -+ - static inline int char_to_int(char c) - { - if ('0' <= c && c <= '9') -@@ -379,7 +382,7 @@ void set_u32(struct vkd3d_bytecode_buffer *buffer, size_t offset, uint32_t value - memcpy(buffer->data + offset, &value, sizeof(value)); - } - --static void vkd3d_shader_dump_blob(const char *path, const char *prefix, -+static void vkd3d_shader_dump_blob(const char *path, const char *profile, - const char *suffix, const void *data, size_t size) - { - static LONG shader_id = 0; -@@ -389,7 +392,10 @@ static void vkd3d_shader_dump_blob(const char *path, const char *prefix, - - id = InterlockedIncrement(&shader_id) - 1; - -- snprintf(filename, ARRAY_SIZE(filename), "%s/vkd3d-shader-%s-%u.%s", path, prefix, id, suffix); -+ if (profile) -+ snprintf(filename, ARRAY_SIZE(filename), "%s/vkd3d-shader-%u-%s.%s", path, id, profile, suffix); -+ else -+ snprintf(filename, ARRAY_SIZE(filename), "%s/vkd3d-shader-%u.%s", path, id, suffix); - if ((f = fopen(filename, "wb"))) - { - if (fwrite(data, 1, size, f) != size) -@@ -421,9 +427,12 @@ static const char *shader_get_source_type_suffix(enum vkd3d_shader_source_type t - } - } - --void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type, -- enum vkd3d_shader_type shader_type, const struct vkd3d_shader_code *shader) -+void vkd3d_shader_dump_shader(const struct vkd3d_shader_compile_info *compile_info) - { -+ const struct vkd3d_shader_code *shader = &compile_info->source; -+ const struct vkd3d_shader_hlsl_source_info *hlsl_source_info; -+ const struct hlsl_profile_info *profile; -+ const char *profile_name = NULL; - static bool enabled = true; - const char *path; - -@@ -436,8 +445,19 @@ void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type, - return; - } - -- vkd3d_shader_dump_blob(path, shader_get_type_prefix(shader_type), -- shader_get_source_type_suffix(source_type), shader->code, shader->size); -+ if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL) -+ { -+ if (!(hlsl_source_info = vkd3d_find_struct(compile_info->next, HLSL_SOURCE_INFO))) -+ return; -+ -+ if (!(profile = hlsl_get_target_info(hlsl_source_info->profile))) -+ return; -+ -+ profile_name = profile->name; -+ } -+ -+ vkd3d_shader_dump_blob(path, profile_name, shader_get_source_type_suffix(compile_info->source_type), -+ shader->code, shader->size); - } - - static void init_scan_signature_info(const struct vkd3d_shader_compile_info *info) -@@ -452,6 +472,25 @@ static void init_scan_signature_info(const struct vkd3d_shader_compile_info *inf - } - } - -+static const struct vkd3d_debug_option vkd3d_shader_config_options[] = -+{ -+ {"force_validation", VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION}, /* force validation of internal shader representations */ -+}; -+ -+static uint64_t vkd3d_shader_init_config_flags(void) -+{ -+ uint64_t config_flags; -+ const char *config; -+ -+ config = getenv("VKD3D_SHADER_CONFIG"); -+ config_flags = vkd3d_parse_debug_options(config, vkd3d_shader_config_options, ARRAY_SIZE(vkd3d_shader_config_options)); -+ -+ if (config_flags) -+ TRACE("VKD3D_SHADER_CONFIG='%s'.\n", config); -+ -+ return config_flags; -+} -+ - bool vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser, - struct vkd3d_shader_message_context *message_context, const char *source_name, - const struct vkd3d_shader_version *version, const struct vkd3d_shader_parser_ops *ops, -@@ -463,6 +502,7 @@ bool vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser, - parser->location.column = 0; - parser->shader_version = *version; - parser->ops = ops; -+ parser->config_flags = vkd3d_shader_init_config_flags(); - return shader_instruction_array_init(&parser->instructions, instruction_reserve); - } - -@@ -577,6 +617,8 @@ static bool vkd3d_shader_signature_from_shader_signature(struct vkd3d_shader_sig - - struct vkd3d_shader_scan_context - { -+ const struct vkd3d_shader_version *version; -+ - struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info; - size_t descriptors_size; - -@@ -598,21 +640,48 @@ struct vkd3d_shader_scan_context - size_t cf_info_count; - - enum vkd3d_shader_api_version api_version; -+ -+ struct vkd3d_shader_scan_combined_resource_sampler_info *combined_sampler_info; -+ size_t combined_samplers_size; - }; - -+static VKD3D_PRINTF_FUNC(3, 4) void vkd3d_shader_scan_error(struct vkd3d_shader_scan_context *context, -+ enum vkd3d_shader_error error, const char *format, ...) -+{ -+ va_list args; -+ -+ va_start(args, format); -+ vkd3d_shader_verror(context->message_context, &context->location, error, format, args); -+ va_end(args); -+} -+ -+static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_shader_scan_warning(struct vkd3d_shader_scan_context *context, -+ enum vkd3d_shader_error error, const char *format, ...) -+{ -+ va_list args; -+ -+ va_start(args, format); -+ vkd3d_shader_vwarning(context->message_context, &context->location, error, format, args); -+ va_end(args); -+} -+ - static void vkd3d_shader_scan_context_init(struct vkd3d_shader_scan_context *context, -+ const struct vkd3d_shader_version *version, - const struct vkd3d_shader_compile_info *compile_info, - struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info, -+ struct vkd3d_shader_scan_combined_resource_sampler_info *combined_sampler_info, - struct vkd3d_shader_message_context *message_context) - { - unsigned int i; - - memset(context, 0, sizeof(*context)); -+ context->version = version; - context->scan_descriptor_info = scan_descriptor_info; - context->message_context = message_context; - context->location.source_name = compile_info->source_name; - context->location.line = 2; /* Line 1 is the version token. */ - context->api_version = VKD3D_SHADER_API_VERSION_1_2; -+ context->combined_sampler_info = combined_sampler_info; - - for (i = 0; i < compile_info->option_count; ++i) - { -@@ -762,6 +831,9 @@ static struct vkd3d_shader_descriptor_info1 *vkd3d_shader_scan_add_descriptor(st - struct vkd3d_shader_scan_descriptor_info1 *info = context->scan_descriptor_info; - struct vkd3d_shader_descriptor_info1 *d; - -+ if (!info) -+ return NULL; -+ - if (!vkd3d_array_reserve((void **)&info->descriptors, &context->descriptors_size, - info->descriptor_count + 1, sizeof(*info->descriptors))) - { -@@ -789,13 +861,10 @@ static void vkd3d_shader_scan_constant_buffer_declaration(struct vkd3d_shader_sc - const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb; - struct vkd3d_shader_descriptor_info1 *d; - -- if (!context->scan_descriptor_info) -- return; -- - if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV, - &cb->src.reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT))) - return; -- d->buffer_size = cb->size * 16; -+ d->buffer_size = cb->size; - } - - static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_context *context, -@@ -804,9 +873,6 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte - const struct vkd3d_shader_sampler *sampler = &instruction->declaration.sampler; - struct vkd3d_shader_descriptor_info1 *d; - -- if (!context->scan_descriptor_info) -- return; -- - if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, - &sampler->src.reg, &sampler->range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT))) - return; -@@ -815,6 +881,103 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte - d->flags |= VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_SAMPLER_COMPARISON_MODE; - } - -+static void vkd3d_shader_scan_combined_sampler_declaration( -+ struct vkd3d_shader_scan_context *context, const struct vkd3d_shader_semantic *semantic) -+{ -+ vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, &semantic->resource.reg.reg, -+ &semantic->resource.range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT); -+ vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SRV, &semantic->resource.reg.reg, -+ &semantic->resource.range, semantic->resource_type, VKD3D_SHADER_RESOURCE_DATA_FLOAT); -+} -+ -+static void vkd3d_shader_scan_combined_sampler_usage(struct vkd3d_shader_scan_context *context, -+ const struct vkd3d_shader_register *resource, const struct vkd3d_shader_register *sampler) -+{ -+ struct vkd3d_shader_scan_combined_resource_sampler_info *info; -+ struct vkd3d_shader_combined_resource_sampler_info *s; -+ unsigned resource_space = 0, sampler_space = 0; -+ unsigned int resource_idx, sampler_idx, i; -+ -+ if (!(info = context->combined_sampler_info)) -+ return; -+ -+ if (resource->type == VKD3DSPR_RESOURCE) -+ resource_idx = resource->idx[1].offset; -+ else -+ resource_idx = resource->idx[0].offset; -+ -+ if (!sampler) -+ sampler_idx = VKD3D_SHADER_DUMMY_SAMPLER_INDEX; -+ else if (sampler->type == VKD3DSPR_SAMPLER) -+ sampler_idx = sampler->idx[1].offset; -+ else -+ sampler_idx = sampler->idx[0].offset; -+ -+ if (vkd3d_shader_ver_ge(context->version, 5, 1)) -+ { -+ const struct vkd3d_shader_scan_descriptor_info1 *info = context->scan_descriptor_info; -+ const struct vkd3d_shader_descriptor_info1 *d; -+ bool dynamic_resource, dynamic_sampler; -+ -+ if ((dynamic_resource = resource->idx[1].rel_addr)) -+ vkd3d_shader_scan_warning(context, VKD3D_SHADER_WARNING_VSIR_DYNAMIC_DESCRIPTOR_ARRAY, -+ "Resource descriptor array %u is being dynamically indexed, " -+ "not recording a combined resource-sampler pair.", resource->idx[0].offset); -+ if ((dynamic_sampler = sampler && sampler->idx[1].rel_addr)) -+ vkd3d_shader_scan_warning(context, VKD3D_SHADER_WARNING_VSIR_DYNAMIC_DESCRIPTOR_ARRAY, -+ "Sampler descriptor array %u is being dynamically indexed, " -+ "not recording a combined resource-sampler pair.", sampler->idx[0].offset); -+ if (dynamic_resource || dynamic_sampler) -+ return; -+ -+ for (i = 0; i < info->descriptor_count; ++i) -+ { -+ d = &info->descriptors[i]; -+ if (d->type != VKD3D_SHADER_DESCRIPTOR_TYPE_SRV) -+ continue; -+ if (d->register_id != resource->idx[0].offset) -+ continue; -+ resource_space = d->register_space; -+ break; -+ } -+ -+ if (sampler) -+ { -+ for (i = 0; i < info->descriptor_count; ++i) -+ { -+ d = &info->descriptors[i]; -+ if (d->type != VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER) -+ continue; -+ if (d->register_id != sampler->idx[0].offset) -+ continue; -+ sampler_space = d->register_space; -+ break; -+ } -+ } -+ } -+ -+ for (i = 0; i < info->combined_sampler_count; ++i) -+ { -+ s = &info->combined_samplers[i]; -+ if (s->resource_space == resource_space && s->resource_index == resource_idx -+ && s->sampler_space == sampler_space && s->sampler_index == sampler_idx) -+ return; -+ } -+ -+ if (!vkd3d_array_reserve((void **)&info->combined_samplers, &context->combined_samplers_size, -+ info->combined_sampler_count + 1, sizeof(*info->combined_samplers))) -+ { -+ ERR("Failed to allocate combined sampler info.\n"); -+ return; -+ } -+ -+ s = &info->combined_samplers[info->combined_sampler_count++]; -+ s->resource_space = resource_space; -+ s->resource_index = resource_idx; -+ s->sampler_space = sampler_space; -+ s->sampler_index = sampler_idx; -+} -+ - static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_context *context, - const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type, - enum vkd3d_shader_resource_data_type resource_data_type, -@@ -823,9 +986,6 @@ static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_cont - struct vkd3d_shader_descriptor_info1 *d; - enum vkd3d_shader_descriptor_type type; - -- if (!context->scan_descriptor_info) -- return; -- - if (resource->reg.reg.type == VKD3DSPR_UAV) - type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV; - else -@@ -898,22 +1058,15 @@ static void vkd3d_shader_scan_typed_resource_declaration(struct vkd3d_shader_sca - semantic->resource_type, resource_data_type, semantic->sample_count, 0, false); - } - --static void vkd3d_shader_scan_error(struct vkd3d_shader_scan_context *context, -- enum vkd3d_shader_error error, const char *format, ...) --{ -- va_list args; -- -- va_start(args, format); -- vkd3d_shader_verror(context->message_context, &context->location, error, format, args); -- va_end(args); --} -- - static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *context, - const struct vkd3d_shader_instruction *instruction) - { -+ const struct vkd3d_shader_register *sampler_reg; - struct vkd3d_shader_cf_info *cf_info; - unsigned int i; - -+ context->location = instruction->location; -+ - switch (instruction->handler_idx) - { - case VKD3DSIH_DCL_CONSTANT_BUFFER: -@@ -923,6 +1076,12 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte - vkd3d_shader_scan_sampler_declaration(context, instruction); - break; - case VKD3DSIH_DCL: -+ if (instruction->declaration.semantic.resource.reg.reg.type == VKD3DSPR_COMBINED_SAMPLER) -+ { -+ vkd3d_shader_scan_combined_sampler_declaration(context, &instruction->declaration.semantic); -+ break; -+ } -+ /* fall through */ - case VKD3DSIH_DCL_UAV_TYPED: - vkd3d_shader_scan_typed_resource_declaration(context, instruction); - break; -@@ -1053,6 +1212,58 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte - if (context->cf_info_count) - context->cf_info[context->cf_info_count - 1].inside_block = false; - break; -+ case VKD3DSIH_TEX: -+ if (context->version->major == 1) -+ sampler_reg = &instruction->dst[0].reg; -+ else -+ sampler_reg = &instruction->src[1].reg; -+ vkd3d_shader_scan_combined_sampler_usage(context, sampler_reg, sampler_reg); -+ break; -+ case VKD3DSIH_TEXBEM: -+ case VKD3DSIH_TEXBEML: -+ case VKD3DSIH_TEXDP3TEX: -+ case VKD3DSIH_TEXM3x2TEX: -+ case VKD3DSIH_TEXM3x3SPEC: -+ case VKD3DSIH_TEXM3x3TEX: -+ case VKD3DSIH_TEXM3x3VSPEC: -+ case VKD3DSIH_TEXREG2AR: -+ case VKD3DSIH_TEXREG2GB: -+ case VKD3DSIH_TEXREG2RGB: -+ sampler_reg = &instruction->dst[0].reg; -+ vkd3d_shader_scan_combined_sampler_usage(context, sampler_reg, sampler_reg); -+ break; -+ case VKD3DSIH_GATHER4: -+ case VKD3DSIH_GATHER4_C: -+ case VKD3DSIH_SAMPLE: -+ case VKD3DSIH_SAMPLE_B: -+ case VKD3DSIH_SAMPLE_C: -+ case VKD3DSIH_SAMPLE_C_LZ: -+ case VKD3DSIH_SAMPLE_GRAD: -+ case VKD3DSIH_SAMPLE_LOD: -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, &instruction->src[2].reg); -+ break; -+ case VKD3DSIH_GATHER4_PO: -+ case VKD3DSIH_GATHER4_PO_C: -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[2].reg, &instruction->src[3].reg); -+ break; -+ case VKD3DSIH_LD: -+ case VKD3DSIH_LD2DMS: -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, NULL); -+ break; -+ case VKD3DSIH_BUFINFO: -+ case VKD3DSIH_SAMPLE_INFO: -+ if (instruction->src[0].reg.type == VKD3DSPR_RESOURCE) -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[0].reg, NULL); -+ break; -+ case VKD3DSIH_LD_RAW: -+ case VKD3DSIH_RESINFO: -+ if (instruction->src[1].reg.type == VKD3DSPR_RESOURCE) -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, NULL); -+ break; -+ case VKD3DSIH_LD_STRUCTURED: -+ if (instruction->src[2].reg.type == VKD3DSPR_RESOURCE) -+ vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[2].reg, NULL); -+ break; - default: - break; - } -@@ -1083,7 +1294,6 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte - } - } - -- ++context->location.line; - return VKD3D_OK; - } - -@@ -1124,6 +1334,7 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info - struct vkd3d_shader_message_context *message_context, - struct vkd3d_shader_scan_descriptor_info1 *descriptor_info1, struct vkd3d_shader_parser *parser) - { -+ struct vkd3d_shader_scan_combined_resource_sampler_info *combined_sampler_info; - struct vkd3d_shader_scan_descriptor_info1 local_descriptor_info1 = {0}; - struct vkd3d_shader_scan_descriptor_info *descriptor_info; - struct vkd3d_shader_scan_signature_info *signature_info; -@@ -1144,7 +1355,16 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info - } - signature_info = vkd3d_find_struct(compile_info->next, SCAN_SIGNATURE_INFO); - -- vkd3d_shader_scan_context_init(&context, compile_info, descriptor_info1, message_context); -+ if ((combined_sampler_info = vkd3d_find_struct(compile_info->next, SCAN_COMBINED_RESOURCE_SAMPLER_INFO))) -+ { -+ combined_sampler_info->combined_samplers = NULL; -+ combined_sampler_info->combined_sampler_count = 0; -+ if (!descriptor_info1) -+ descriptor_info1 = &local_descriptor_info1; -+ } -+ -+ vkd3d_shader_scan_context_init(&context, &parser->shader_version, compile_info, -+ descriptor_info1, combined_sampler_info, message_context); - - if (TRACE_ON()) - { -@@ -1190,6 +1410,8 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info - - if (ret < 0) - { -+ if (combined_sampler_info) -+ vkd3d_shader_free_scan_combined_resource_sampler_info(combined_sampler_info); - if (descriptor_info) - vkd3d_shader_free_scan_descriptor_info(descriptor_info); - if (descriptor_info1) -@@ -1276,6 +1498,8 @@ int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char - - vkd3d_shader_message_context_init(&message_context, compile_info->log_level); - -+ vkd3d_shader_dump_shader(compile_info); -+ - switch (compile_info->source_type) - { - case VKD3D_SHADER_SOURCE_DXBC_TPF: -@@ -1317,8 +1541,6 @@ static int vkd3d_shader_parser_compile(struct vkd3d_shader_parser *parser, - struct vkd3d_shader_compile_info scan_info; - int ret; - -- vkd3d_shader_dump_shader(compile_info->source_type, parser->shader_version.type, &compile_info->source); -- - scan_info = *compile_info; - - if ((ret = scan_with_parser(&scan_info, message_context, &scan_descriptor_info, parser)) < 0) -@@ -1402,8 +1624,6 @@ static int compile_d3d_bytecode(const struct vkd3d_shader_compile_info *compile_ - return ret; - } - -- vkd3d_shader_dump_shader(compile_info->source_type, parser->shader_version.type, &compile_info->source); -- - if (compile_info->target_type == VKD3D_SHADER_TARGET_D3D_ASM) - { - ret = vkd3d_dxbc_binary_to_text(&parser->instructions, &parser->shader_version, compile_info, out); -@@ -1450,6 +1670,8 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, - - vkd3d_shader_message_context_init(&message_context, compile_info->log_level); - -+ vkd3d_shader_dump_shader(compile_info); -+ - switch (compile_info->source_type) - { - case VKD3D_SHADER_SOURCE_DXBC_TPF: -@@ -1479,6 +1701,14 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, - return ret; - } - -+void vkd3d_shader_free_scan_combined_resource_sampler_info( -+ struct vkd3d_shader_scan_combined_resource_sampler_info *info) -+{ -+ TRACE("info %p.\n", info); -+ -+ vkd3d_free(info->combined_samplers); -+} -+ - 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); -@@ -1751,7 +1981,7 @@ static struct vkd3d_shader_param_node *shader_param_allocator_node_create( - static void shader_param_allocator_init(struct vkd3d_shader_param_allocator *allocator, - unsigned int count, unsigned int stride) - { -- allocator->count = max(count, 4); -+ allocator->count = max(count, MAX_REG_OUTPUT); - allocator->stride = stride; - allocator->head = NULL; - allocator->current = NULL; -diff --git a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h -index 9443df6c232..d3989672b89 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h -+++ b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h -@@ -49,7 +49,7 @@ - #include "vkd3d_common.h" - #include "vkd3d_memory.h" - #include "vkd3d_shader.h" --#include "wine/list.h" -+#include "list.h" - - #include - #include -@@ -92,6 +92,10 @@ enum vkd3d_shader_error - VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING = 2002, - VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_IDX_UNSUPPORTED = 2003, - VKD3D_SHADER_ERROR_SPV_STENCIL_EXPORT_UNSUPPORTED = 2004, -+ VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY = 2005, -+ VKD3D_SHADER_ERROR_SPV_INVALID_TYPE = 2006, -+ VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER = 2007, -+ VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED = 2008, - - VKD3D_SHADER_WARNING_SPV_INVALID_SWIZZLE = 2300, - -@@ -141,6 +145,7 @@ enum vkd3d_shader_error - VKD3D_SHADER_ERROR_HLSL_RECURSIVE_CALL = 5025, - VKD3D_SHADER_ERROR_HLSL_INCONSISTENT_SAMPLER = 5026, - VKD3D_SHADER_ERROR_HLSL_NON_FINITE_RESULT = 5027, -+ VKD3D_SHADER_ERROR_HLSL_DUPLICATE_SWITCH_CASE = 5028, - - VKD3D_SHADER_WARNING_HLSL_IMPLICIT_TRUNCATION = 5300, - VKD3D_SHADER_WARNING_HLSL_DIVISION_BY_ZERO = 5301, -@@ -174,15 +179,43 @@ enum vkd3d_shader_error - VKD3D_SHADER_ERROR_DXIL_INVALID_TYPE_ID = 8010, - VKD3D_SHADER_ERROR_DXIL_INVALID_MODULE = 8011, - VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND = 8012, -+ VKD3D_SHADER_ERROR_DXIL_UNHANDLED_INTRINSIC = 8013, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_METADATA = 8014, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_ENTRY_POINT = 8015, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_SIGNATURE = 8016, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES = 8017, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCES = 8018, -+ VKD3D_SHADER_ERROR_DXIL_INVALID_RESOURCE_HANDLE = 8019, - - VKD3D_SHADER_WARNING_DXIL_UNKNOWN_MAGIC_NUMBER = 8300, - VKD3D_SHADER_WARNING_DXIL_UNKNOWN_SHADER_TYPE = 8301, - VKD3D_SHADER_WARNING_DXIL_INVALID_BLOCK_LENGTH = 8302, - VKD3D_SHADER_WARNING_DXIL_INVALID_MODULE_LENGTH = 8303, - VKD3D_SHADER_WARNING_DXIL_IGNORING_OPERANDS = 8304, -- VKD3D_SHADER_WARNING_DXIL_UNHANDLED_INTRINSIC = 8305, -+ VKD3D_SHADER_WARNING_DXIL_TYPE_MISMATCH = 8305, -+ VKD3D_SHADER_WARNING_DXIL_ENTRY_POINT_MISMATCH = 8306, -+ VKD3D_SHADER_WARNING_DXIL_INVALID_MASK = 8307, -+ VKD3D_SHADER_WARNING_DXIL_INVALID_OPERATION = 8308, - - VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED = 9000, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER = 9001, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_REGISTER_TYPE = 9002, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_WRITE_MASK = 9003, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_MODIFIERS = 9004, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_SHIFT = 9005, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_SWIZZLE = 9006, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_PRECISION = 9007, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_DATA_TYPE = 9008, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_DIMENSION = 9009, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX_COUNT = 9010, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_DEST_COUNT = 9011, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_SOURCE_COUNT = 9012, -+ VKD3D_SHADER_ERROR_VSIR_DUPLICATE_DCL_TEMPS = 9013, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_DCL_TEMPS = 9014, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX = 9015, -+ VKD3D_SHADER_ERROR_VSIR_INVALID_INSTRUCTION_NESTING = 9016, -+ -+ VKD3D_SHADER_WARNING_VSIR_DYNAMIC_DESCRIPTOR_ARRAY = 9300, - }; - - enum vkd3d_shader_opcode -@@ -264,9 +297,9 @@ enum vkd3d_shader_opcode - VKD3DSIH_DEFAULT, - VKD3DSIH_DEFB, - VKD3DSIH_DEFI, -- VKD3DSIH_DEQ, -+ VKD3DSIH_DEQO, - VKD3DSIH_DFMA, -- VKD3DSIH_DGE, -+ VKD3DSIH_DGEO, - VKD3DSIH_DISCARD, - VKD3DSIH_DIV, - VKD3DSIH_DLT, -@@ -298,7 +331,8 @@ enum vkd3d_shader_opcode - VKD3DSIH_ENDLOOP, - VKD3DSIH_ENDREP, - VKD3DSIH_ENDSWITCH, -- VKD3DSIH_EQ, -+ VKD3DSIH_EQO, -+ VKD3DSIH_EQU, - VKD3DSIH_EVAL_CENTROID, - VKD3DSIH_EVAL_SAMPLE_INDEX, - VKD3DSIH_EXP, -@@ -310,6 +344,7 @@ enum vkd3d_shader_opcode - VKD3DSIH_FIRSTBIT_LO, - VKD3DSIH_FIRSTBIT_SHI, - VKD3DSIH_FRC, -+ VKD3DSIH_FREM, - VKD3DSIH_FTOD, - VKD3DSIH_FTOI, - VKD3DSIH_FTOU, -@@ -321,13 +356,15 @@ enum vkd3d_shader_opcode - VKD3DSIH_GATHER4_PO_C_S, - VKD3DSIH_GATHER4_PO_S, - VKD3DSIH_GATHER4_S, -- VKD3DSIH_GE, -+ VKD3DSIH_GEO, -+ VKD3DSIH_GEU, - VKD3DSIH_HS_CONTROL_POINT_PHASE, - VKD3DSIH_HS_DECLS, - VKD3DSIH_HS_FORK_PHASE, - VKD3DSIH_HS_JOIN_PHASE, - VKD3DSIH_IADD, - VKD3DSIH_IBFE, -+ VKD3DSIH_IDIV, - VKD3DSIH_IEQ, - VKD3DSIH_IF, - VKD3DSIH_IFC, -@@ -355,6 +392,7 @@ enum vkd3d_shader_opcode - VKD3DSIH_ISHR, - VKD3DSIH_ITOD, - VKD3DSIH_ITOF, -+ VKD3DSIH_ITOI, - VKD3DSIH_LABEL, - VKD3DSIH_LD, - VKD3DSIH_LD2DMS, -@@ -372,7 +410,8 @@ enum vkd3d_shader_opcode - VKD3DSIH_LOGP, - VKD3DSIH_LOOP, - VKD3DSIH_LRP, -- VKD3DSIH_LT, -+ VKD3DSIH_LTO, -+ VKD3DSIH_LTU, - VKD3DSIH_M3x2, - VKD3DSIH_M3x3, - VKD3DSIH_M3x4, -@@ -386,7 +425,8 @@ enum vkd3d_shader_opcode - VKD3DSIH_MOVC, - VKD3DSIH_MSAD, - VKD3DSIH_MUL, -- VKD3DSIH_NE, -+ VKD3DSIH_NEO, -+ VKD3DSIH_NEU, - VKD3DSIH_NOP, - VKD3DSIH_NOT, - VKD3DSIH_NRM, -@@ -462,6 +502,7 @@ enum vkd3d_shader_opcode - VKD3DSIH_USHR, - VKD3DSIH_UTOD, - VKD3DSIH_UTOF, -+ VKD3DSIH_UTOU, - VKD3DSIH_XOR, - - VKD3DSIH_INVALID, -@@ -481,7 +522,7 @@ enum vkd3d_shader_register_type - VKD3DSPR_CONSTINT = 7, - VKD3DSPR_COLOROUT = 8, - VKD3DSPR_DEPTHOUT = 9, -- VKD3DSPR_SAMPLER = 10, -+ VKD3DSPR_COMBINED_SAMPLER = 10, - VKD3DSPR_CONST2 = 11, - VKD3DSPR_CONST3 = 12, - VKD3DSPR_CONST4 = 13, -@@ -497,6 +538,7 @@ enum vkd3d_shader_register_type - VKD3DSPR_IMMCONSTBUFFER, - VKD3DSPR_PRIMID, - VKD3DSPR_NULL, -+ VKD3DSPR_SAMPLER, - VKD3DSPR_RESOURCE, - VKD3DSPR_UAV, - VKD3DSPR_OUTPOINTID, -@@ -523,6 +565,7 @@ enum vkd3d_shader_register_type - VKD3DSPR_RASTERIZER, - VKD3DSPR_OUTSTENCILREF, - VKD3DSPR_UNDEF, -+ VKD3DSPR_SSA, - - VKD3DSPR_COUNT, - -@@ -537,6 +580,8 @@ enum vkd3d_shader_register_precision - VKD3D_SHADER_REGISTER_PRECISION_MIN_INT_16, - VKD3D_SHADER_REGISTER_PRECISION_MIN_UINT_16, - -+ VKD3D_SHADER_REGISTER_PRECISION_COUNT, -+ - VKD3D_SHADER_REGISTER_PRECISION_INVALID = ~0u, - }; - -@@ -556,17 +601,30 @@ enum vkd3d_data_type - VKD3D_DATA_CONTINUED, - VKD3D_DATA_UNUSED, - VKD3D_DATA_UINT8, -+ VKD3D_DATA_UINT64, -+ VKD3D_DATA_BOOL, -+ -+ VKD3D_DATA_COUNT, - }; - - static inline bool data_type_is_integer(enum vkd3d_data_type data_type) - { -- return data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT8 || data_type == VKD3D_DATA_UINT; -+ return data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT8 || data_type == VKD3D_DATA_UINT -+ || data_type == VKD3D_DATA_UINT64; - } - --enum vkd3d_immconst_type -+static inline bool data_type_is_bool(enum vkd3d_data_type data_type) - { -- VKD3D_IMMCONST_SCALAR, -- VKD3D_IMMCONST_VEC4, -+ return data_type == VKD3D_DATA_BOOL; -+} -+ -+enum vsir_dimension -+{ -+ VSIR_DIMENSION_NONE, -+ VSIR_DIMENSION_SCALAR, -+ VSIR_DIMENSION_VEC4, -+ -+ VSIR_DIMENSION_COUNT, - }; - - enum vkd3d_shader_src_modifier -@@ -585,6 +643,7 @@ enum vkd3d_shader_src_modifier - VKD3DSPSM_ABS = 11, - VKD3DSPSM_ABSNEG = 12, - VKD3DSPSM_NOT = 13, -+ VKD3DSPSM_COUNT, - }; - - #define VKD3DSP_WRITEMASK_0 0x1u /* .x r */ -@@ -599,6 +658,7 @@ enum vkd3d_shader_dst_modifier - VKD3DSPDM_SATURATE = 1, - VKD3DSPDM_PARTIALPRECISION = 2, - VKD3DSPDM_MSAMPCENTROID = 4, -+ VKD3DSPDM_MASK = 7, - }; - - enum vkd3d_shader_interpolation_mode -@@ -611,6 +671,8 @@ enum vkd3d_shader_interpolation_mode - VKD3DSIM_LINEAR_NOPERSPECTIVE_CENTROID = 5, - VKD3DSIM_LINEAR_SAMPLE = 6, - VKD3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE = 7, -+ -+ VKD3DSIM_COUNT = 8, - }; - - enum vkd3d_shader_global_flags -@@ -622,6 +684,32 @@ enum vkd3d_shader_global_flags - VKD3DSGF_SKIP_OPTIMIZATION = 0x10, - VKD3DSGF_ENABLE_MINIMUM_PRECISION = 0x20, - VKD3DSGF_ENABLE_11_1_DOUBLE_EXTENSIONS = 0x40, -+ VKD3DSGF_ENABLE_SHADER_EXTENSIONS = 0x80, /* never emitted? */ -+ VKD3DSGF_BIND_FOR_DURATION = 0x100, -+ VKD3DSGF_ENABLE_VP_AND_RT_ARRAY_INDEX = 0x200, -+ VKD3DSGF_ENABLE_INNER_COVERAGE = 0x400, -+ VKD3DSGF_ENABLE_STENCIL_REF = 0x800, -+ VKD3DSGF_ENABLE_TILED_RESOURCE_INTRINSICS = 0x1000, -+ VKD3DSGF_ENABLE_RELAXED_TYPED_UAV_FORMATS = 0x2000, -+ VKD3DSGF_ENABLE_LVL_9_COMPARISON_FILTERING = 0x4000, -+ VKD3DSGF_ENABLE_UP_TO_64_UAVS = 0x8000, -+ VKD3DSGF_ENABLE_UAVS_AT_EVERY_STAGE = 0x10000, -+ VKD3DSGF_ENABLE_CS4_RAW_STRUCTURED_BUFFERS = 0x20000, -+ VKD3DSGF_ENABLE_RASTERIZER_ORDERED_VIEWS = 0x40000, -+ VKD3DSGF_ENABLE_WAVE_INTRINSICS = 0x80000, -+ VKD3DSGF_ENABLE_INT64 = 0x100000, -+ VKD3DSGF_ENABLE_VIEWID = 0x200000, -+ VKD3DSGF_ENABLE_BARYCENTRICS = 0x400000, -+ VKD3DSGF_FORCE_NATIVE_LOW_PRECISION = 0x800000, -+ VKD3DSGF_ENABLE_SHADINGRATE = 0x1000000, -+ VKD3DSGF_ENABLE_RAYTRACING_TIER_1_1 = 0x2000000, -+ VKD3DSGF_ENABLE_SAMPLER_FEEDBACK = 0x4000000, -+ VKD3DSGF_ENABLE_ATOMIC_INT64_ON_TYPED_RESOURCE = 0x8000000, -+ VKD3DSGF_ENABLE_ATOMIC_INT64_ON_GROUP_SHARED = 0x10000000, -+ VKD3DSGF_ENABLE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS = 0x20000000, -+ VKD3DSGF_ENABLE_RESOURCE_DESCRIPTOR_HEAP_INDEXING = 0x40000000, -+ VKD3DSGF_ENABLE_SAMPLER_DESCRIPTOR_HEAP_INDEXING = 0x80000000, -+ VKD3DSGF_ENABLE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = 0x100000000ull, - }; - - enum vkd3d_shader_sync_flags -@@ -633,7 +721,8 @@ enum vkd3d_shader_sync_flags - - enum vkd3d_shader_uav_flags - { -- VKD3DSUF_GLOBALLY_COHERENT = 0x2, -+ VKD3DSUF_GLOBALLY_COHERENT = 0x002, -+ VKD3DSUF_RASTERISER_ORDERED_VIEW = 0x004, - VKD3DSUF_ORDER_PRESERVING_COUNTER = 0x100, - }; - -@@ -704,22 +793,29 @@ struct vkd3d_shader_version - - struct vkd3d_shader_immediate_constant_buffer - { -- unsigned int vec4_count; -+ enum vkd3d_data_type data_type; -+ /* total count is element_count * component_count */ -+ unsigned int element_count; -+ unsigned int component_count; - uint32_t data[]; - }; - - struct vkd3d_shader_indexable_temp - { -- struct list entry; - unsigned int register_idx; - unsigned int register_size; -+ unsigned int alignment; -+ enum vkd3d_data_type data_type; - unsigned int component_count; -+ const struct vkd3d_shader_immediate_constant_buffer *initialiser; - }; - - struct vkd3d_shader_register_index - { - const struct vkd3d_shader_src_param *rel_addr; - unsigned int offset; -+ /* address is known to fall within the object (for optimisation) */ -+ bool is_in_bounds; - }; - - struct vkd3d_shader_register -@@ -730,7 +826,9 @@ struct vkd3d_shader_register - enum vkd3d_data_type data_type; - struct vkd3d_shader_register_index idx[3]; - unsigned int idx_count; -- enum vkd3d_immconst_type immconst_type; -+ enum vsir_dimension dimension; -+ /* known address alignment for optimisation, or zero */ -+ unsigned int alignment; - union - { - DWORD immconst_uint[VKD3D_VEC4_SIZE]; -@@ -741,13 +839,28 @@ struct vkd3d_shader_register - } u; - }; - --void shader_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, -+void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, - enum vkd3d_data_type data_type, unsigned int idx_count); - -+static inline bool vsir_register_is_descriptor(const struct vkd3d_shader_register *reg) -+{ -+ switch (reg->type) -+ { -+ case VKD3DSPR_SAMPLER: -+ case VKD3DSPR_RESOURCE: -+ case VKD3DSPR_CONSTBUFFER: -+ case VKD3DSPR_UAV: -+ return true; -+ -+ default: -+ return false; -+ } -+} -+ - struct vkd3d_shader_dst_param - { - struct vkd3d_shader_register reg; -- DWORD write_mask; -+ uint32_t write_mask; - DWORD modifiers; - DWORD shift; - }; -@@ -848,6 +961,7 @@ struct signature_element - unsigned int mask; - unsigned int used_mask; - enum vkd3d_shader_minimum_precision min_precision; -+ enum vkd3d_shader_interpolation_mode interpolation_mode; - /* Register index / location in the target shader. - * If SIGNATURE_TARGET_LOCATION_UNUSED, this element should not be written. */ - unsigned int target_location; -@@ -860,6 +974,14 @@ struct shader_signature - unsigned int element_count; - }; - -+static inline bool vsir_sysval_semantic_is_tess_factor(enum vkd3d_shader_sysval_semantic sysval_semantic) -+{ -+ return sysval_semantic >= VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE -+ && sysval_semantic <= VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN; -+} -+ -+struct signature_element *vsir_signature_find_element_for_reg(const struct shader_signature *signature, -+ unsigned int reg_idx, unsigned int write_mask); - void shader_signature_cleanup(struct shader_signature *signature); - - struct vkd3d_shader_desc -@@ -871,12 +993,17 @@ struct vkd3d_shader_desc - struct shader_signature output_signature; - struct shader_signature patch_constant_signature; - -+ unsigned int input_control_point_count, output_control_point_count; -+ - uint32_t temp_count; -+ unsigned int ssa_count; - - struct - { - uint32_t used, external; - } flat_constant_count[3]; -+ -+ bool use_vocp; - }; - - struct vkd3d_shader_register_semantic -@@ -968,8 +1095,15 @@ struct vkd3d_shader_primitive_type - unsigned int patch_vertex_count; - }; - -+struct vkd3d_shader_location -+{ -+ const char *source_name; -+ unsigned int line, column; -+}; -+ - struct vkd3d_shader_instruction - { -+ struct vkd3d_shader_location location; - enum vkd3d_shader_opcode handler_idx; - DWORD flags; - unsigned int dst_count; -@@ -984,6 +1118,7 @@ struct vkd3d_shader_instruction - const struct vkd3d_shader_src_param *predicate; - union - { -+ enum vkd3d_shader_global_flags global_flags; - struct vkd3d_shader_semantic semantic; - struct vkd3d_shader_register_semantic register_semantic; - struct vkd3d_shader_primitive_type primitive_type; -@@ -1008,26 +1143,22 @@ struct vkd3d_shader_instruction - } declaration; - }; - --void shader_instruction_init(struct vkd3d_shader_instruction *ins, enum vkd3d_shader_opcode handler_idx); -- --static inline bool vkd3d_shader_instruction_has_texel_offset(const struct vkd3d_shader_instruction *ins) -+static inline bool vkd3d_shader_ver_ge(const struct vkd3d_shader_version *v, unsigned int major, unsigned int minor) - { -- return ins->texel_offset.u || ins->texel_offset.v || ins->texel_offset.w; -+ return v->major > major || (v->major == major && v->minor >= minor); - } - --static inline bool vkd3d_shader_register_is_input(const struct vkd3d_shader_register *reg) -+static inline bool vkd3d_shader_ver_le(const struct vkd3d_shader_version *v, unsigned int major, unsigned int minor) - { -- return reg->type == VKD3DSPR_INPUT || reg->type == VKD3DSPR_INCONTROLPOINT || reg->type == VKD3DSPR_OUTCONTROLPOINT; -+ return v->major < major || (v->major == major && v->minor <= minor); - } - --static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_register *reg) --{ -- return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT; --} -+void vsir_instruction_init(struct vkd3d_shader_instruction *ins, const struct vkd3d_shader_location *location, -+ enum vkd3d_shader_opcode handler_idx); - --static inline bool vkd3d_shader_register_is_patch_constant(const struct vkd3d_shader_register *reg) -+static inline bool vkd3d_shader_instruction_has_texel_offset(const struct vkd3d_shader_instruction *ins) - { -- return reg->type == VKD3DSPR_PATCHCONST; -+ return ins->texel_offset.u || ins->texel_offset.v || ins->texel_offset.w; - } - - static inline bool register_is_constant(const struct vkd3d_shader_register *reg) -@@ -1035,12 +1166,6 @@ static inline bool register_is_constant(const struct vkd3d_shader_register *reg) - return (reg->type == VKD3DSPR_IMMCONST || reg->type == VKD3DSPR_IMMCONST64); - } - --struct vkd3d_shader_location --{ -- const char *source_name; -- unsigned int line, column; --}; -- - struct vkd3d_shader_param_node - { - struct vkd3d_shader_param_node *next; -@@ -1093,6 +1218,11 @@ bool shader_instruction_array_clone_instruction(struct vkd3d_shader_instruction_ - unsigned int dst, unsigned int src); - void shader_instruction_array_destroy(struct vkd3d_shader_instruction_array *instructions); - -+enum vkd3d_shader_config_flags -+{ -+ VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION = 0x00000001, -+}; -+ - struct vkd3d_shader_parser - { - struct vkd3d_shader_message_context *message_context; -@@ -1103,6 +1233,8 @@ struct vkd3d_shader_parser - struct vkd3d_shader_version shader_version; - const struct vkd3d_shader_parser_ops *ops; - struct vkd3d_shader_instruction_array instructions; -+ -+ uint64_t config_flags; - }; - - struct vkd3d_shader_parser_ops -@@ -1248,8 +1380,7 @@ void vkd3d_shader_vnote(struct vkd3d_shader_message_context *context, const stru - 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); - --void vkd3d_shader_dump_shader(enum vkd3d_shader_source_type source_type, -- enum vkd3d_shader_type shader_type, const struct vkd3d_shader_code *shader); -+void vkd3d_shader_dump_shader(const struct vkd3d_shader_compile_info *compile_info); - void vkd3d_shader_trace_text_(const char *text, size_t size, const char *function); - #define vkd3d_shader_trace_text(text, size) \ - vkd3d_shader_trace_text_(text, size, __FUNCTION__) -@@ -1291,6 +1422,8 @@ int preproc_lexer_parse(const struct vkd3d_shader_compile_info *compile_info, - int hlsl_compile_shader(const struct vkd3d_shader_code *hlsl, const struct vkd3d_shader_compile_info *compile_info, - struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context); - -+void vsir_validate(struct vkd3d_shader_parser *parser); -+ - static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_type( - enum vkd3d_data_type data_type) - { -@@ -1306,6 +1439,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty - return VKD3D_SHADER_COMPONENT_INT; - case VKD3D_DATA_DOUBLE: - return VKD3D_SHADER_COMPONENT_DOUBLE; -+ case VKD3D_DATA_BOOL: -+ return VKD3D_SHADER_COMPONENT_BOOL; - default: - FIXME("Unhandled data type %#x.\n", data_type); - /* fall-through */ -@@ -1458,23 +1593,6 @@ static inline void *vkd3d_find_struct_(const struct vkd3d_struct *chain, - #define VKD3D_DXBC_HEADER_SIZE (8 * sizeof(uint32_t)) - #define VKD3D_DXBC_CHUNK_ALIGNMENT sizeof(uint32_t) - --#define TAG_AON9 VKD3D_MAKE_TAG('A', 'o', 'n', '9') --#define TAG_DXBC VKD3D_MAKE_TAG('D', 'X', 'B', 'C') --#define TAG_DXIL VKD3D_MAKE_TAG('D', 'X', 'I', 'L') --#define TAG_ISG1 VKD3D_MAKE_TAG('I', 'S', 'G', '1') --#define TAG_ISGN VKD3D_MAKE_TAG('I', 'S', 'G', 'N') --#define TAG_OSG1 VKD3D_MAKE_TAG('O', 'S', 'G', '1') --#define TAG_OSG5 VKD3D_MAKE_TAG('O', 'S', 'G', '5') --#define TAG_OSGN VKD3D_MAKE_TAG('O', 'S', 'G', 'N') --#define TAG_PCSG VKD3D_MAKE_TAG('P', 'C', 'S', 'G') --#define TAG_PSG1 VKD3D_MAKE_TAG('P', 'S', 'G', '1') --#define TAG_RD11 VKD3D_MAKE_TAG('R', 'D', '1', '1') --#define TAG_RDEF VKD3D_MAKE_TAG('R', 'D', 'E', 'F') --#define TAG_RTS0 VKD3D_MAKE_TAG('R', 'T', 'S', '0') --#define TAG_SHDR VKD3D_MAKE_TAG('S', 'H', 'D', 'R') --#define TAG_SHEX VKD3D_MAKE_TAG('S', 'H', 'E', 'X') --#define TAG_TEXT VKD3D_MAKE_TAG('T', 'E', 'X', 'T') -- - #define DXBC_MAX_SECTION_COUNT 5 - - struct dxbc_writer -diff --git a/libs/vkd3d/libs/vkd3d/command.c b/libs/vkd3d/libs/vkd3d/command.c -index 42a98763438..77d0f2751cf 100644 ---- a/libs/vkd3d/libs/vkd3d/command.c -+++ b/libs/vkd3d/libs/vkd3d/command.c -@@ -1942,9 +1942,9 @@ static void d3d12_command_signature_decref(struct d3d12_command_signature *signa - } - - /* ID3D12CommandList */ --static inline struct d3d12_command_list *impl_from_ID3D12GraphicsCommandList3(ID3D12GraphicsCommandList3 *iface) -+static inline struct d3d12_command_list *impl_from_ID3D12GraphicsCommandList5(ID3D12GraphicsCommandList5 *iface) - { -- return CONTAINING_RECORD(iface, struct d3d12_command_list, ID3D12GraphicsCommandList3_iface); -+ return CONTAINING_RECORD(iface, struct d3d12_command_list, ID3D12GraphicsCommandList5_iface); - } - - static void d3d12_command_list_invalidate_current_framebuffer(struct d3d12_command_list *list) -@@ -2290,12 +2290,14 @@ static void d3d12_command_list_track_resource_usage(struct d3d12_command_list *l - } - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_QueryInterface(ID3D12GraphicsCommandList3 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_QueryInterface(ID3D12GraphicsCommandList5 *iface, - REFIID iid, void **object) - { - TRACE("iface %p, iid %s, object %p.\n", iface, debugstr_guid(iid), object); - -- if (IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList3) -+ if (IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList5) -+ || IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList4) -+ || IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList3) - || IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList2) - || IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList1) - || IsEqualGUID(iid, &IID_ID3D12GraphicsCommandList) -@@ -2304,7 +2306,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_QueryInterface(ID3D12Graphic - || IsEqualGUID(iid, &IID_ID3D12Object) - || IsEqualGUID(iid, &IID_IUnknown)) - { -- ID3D12GraphicsCommandList3_AddRef(iface); -+ ID3D12GraphicsCommandList5_AddRef(iface); - *object = iface; - return S_OK; - } -@@ -2315,9 +2317,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_QueryInterface(ID3D12Graphic - return E_NOINTERFACE; - } - --static ULONG STDMETHODCALLTYPE d3d12_command_list_AddRef(ID3D12GraphicsCommandList3 *iface) -+static ULONG STDMETHODCALLTYPE d3d12_command_list_AddRef(ID3D12GraphicsCommandList5 *iface) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - ULONG refcount = InterlockedIncrement(&list->refcount); - - TRACE("%p increasing refcount to %u.\n", list, refcount); -@@ -2330,9 +2332,9 @@ static void vkd3d_pipeline_bindings_cleanup(struct vkd3d_pipeline_bindings *bind - vkd3d_free(bindings->vk_uav_counter_views); - } - --static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandList3 *iface) -+static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandList5 *iface) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - ULONG refcount = InterlockedDecrement(&list->refcount); - - TRACE("%p decreasing refcount to %u.\n", list, refcount); -@@ -2358,66 +2360,66 @@ static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandL - return refcount; - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_GetPrivateData(ID3D12GraphicsCommandList3 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_GetPrivateData(ID3D12GraphicsCommandList5 *iface, - REFGUID guid, UINT *data_size, void *data) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_get_private_data(&list->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetPrivateData(ID3D12GraphicsCommandList3 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetPrivateData(ID3D12GraphicsCommandList5 *iface, - REFGUID guid, UINT data_size, const void *data) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_set_private_data(&list->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetPrivateDataInterface(ID3D12GraphicsCommandList3 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetPrivateDataInterface(ID3D12GraphicsCommandList5 *iface, - REFGUID guid, const IUnknown *data) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data); - - return vkd3d_set_private_data_interface(&list->private_store, guid, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetName(ID3D12GraphicsCommandList3 *iface, const WCHAR *name) -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_SetName(ID3D12GraphicsCommandList5 *iface, const WCHAR *name) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, name %s.\n", iface, debugstr_w(name, list->device->wchar_size)); - - return name ? S_OK : E_INVALIDARG; - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_GetDevice(ID3D12GraphicsCommandList3 *iface, REFIID iid, void **device) -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_GetDevice(ID3D12GraphicsCommandList5 *iface, REFIID iid, void **device) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, iid %s, device %p.\n", iface, debugstr_guid(iid), device); - - return d3d12_device_query_interface(list->device, iid, device); - } - --static D3D12_COMMAND_LIST_TYPE STDMETHODCALLTYPE d3d12_command_list_GetType(ID3D12GraphicsCommandList3 *iface) -+static D3D12_COMMAND_LIST_TYPE STDMETHODCALLTYPE d3d12_command_list_GetType(ID3D12GraphicsCommandList5 *iface) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p.\n", iface); - - return list->type; - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_Close(ID3D12GraphicsCommandList3 *iface) -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_Close(ID3D12GraphicsCommandList5 *iface) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - VkResult vr; - -@@ -2461,7 +2463,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_Close(ID3D12GraphicsCommandL - static void d3d12_command_list_reset_state(struct d3d12_command_list *list, - ID3D12PipelineState *initial_pipeline_state) - { -- ID3D12GraphicsCommandList3 *iface = &list->ID3D12GraphicsCommandList3_iface; -+ ID3D12GraphicsCommandList5 *iface = &list->ID3D12GraphicsCommandList5_iface; - - memset(list->strides, 0, sizeof(list->strides)); - list->primitive_topology = D3D_PRIMITIVE_TOPOLOGY_POINTLIST; -@@ -2497,14 +2499,14 @@ static void d3d12_command_list_reset_state(struct d3d12_command_list *list, - - list->descriptor_heap_count = 0; - -- ID3D12GraphicsCommandList3_SetPipelineState(iface, initial_pipeline_state); -+ ID3D12GraphicsCommandList5_SetPipelineState(iface, initial_pipeline_state); - } - --static HRESULT STDMETHODCALLTYPE d3d12_command_list_Reset(ID3D12GraphicsCommandList3 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_command_list_Reset(ID3D12GraphicsCommandList5 *iface, - ID3D12CommandAllocator *allocator, ID3D12PipelineState *initial_pipeline_state) - { - struct d3d12_command_allocator *allocator_impl = unsafe_impl_from_ID3D12CommandAllocator(allocator); -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - HRESULT hr; - - TRACE("iface %p, allocator %p, initial_pipeline_state %p.\n", -@@ -2531,10 +2533,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_Reset(ID3D12GraphicsCommandL - return hr; - } - --static void STDMETHODCALLTYPE d3d12_command_list_ClearState(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ClearState(ID3D12GraphicsCommandList5 *iface, - ID3D12PipelineState *pipeline_state) - { -- FIXME("iface %p, pipline_state %p stub!\n", iface, pipeline_state); -+ FIXME("iface %p, pipeline_state %p stub!\n", iface, pipeline_state); - } - - static bool d3d12_command_list_has_depth_stencil_view(struct d3d12_command_list *list) -@@ -3390,11 +3392,11 @@ static void d3d12_command_list_check_index_buffer_strip_cut_value(struct d3d12_c - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_DrawInstanced(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_DrawInstanced(ID3D12GraphicsCommandList5 *iface, - UINT vertex_count_per_instance, UINT instance_count, UINT start_vertex_location, - UINT start_instance_location) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - - TRACE("iface %p, vertex_count_per_instance %u, instance_count %u, " -@@ -3414,11 +3416,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_DrawInstanced(ID3D12GraphicsCom - instance_count, start_vertex_location, start_instance_location)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_DrawIndexedInstanced(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_DrawIndexedInstanced(ID3D12GraphicsCommandList5 *iface, - UINT index_count_per_instance, UINT instance_count, UINT start_vertex_location, - INT base_vertex_location, UINT start_instance_location) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - - TRACE("iface %p, index_count_per_instance %u, instance_count %u, start_vertex_location %u, " -@@ -3440,10 +3442,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_DrawIndexedInstanced(ID3D12Grap - instance_count, start_vertex_location, base_vertex_location, start_instance_location)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_Dispatch(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_Dispatch(ID3D12GraphicsCommandList5 *iface, - UINT x, UINT y, UINT z) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - - TRACE("iface %p, x %u, y %u, z %u.\n", iface, x, y, z); -@@ -3459,10 +3461,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_Dispatch(ID3D12GraphicsCommandL - VK_CALL(vkCmdDispatch(list->vk_command_buffer, x, y, z)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_CopyBufferRegion(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_CopyBufferRegion(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst, UINT64 dst_offset, ID3D12Resource *src, UINT64 src_offset, UINT64 byte_count) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *dst_resource, *src_resource; - const struct vkd3d_vk_device_procs *vk_procs; - VkBufferCopy buffer_copy; -@@ -3744,11 +3746,11 @@ static bool validate_d3d12_box(const D3D12_BOX *box) - && box->back > box->front; - } - --static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(ID3D12GraphicsCommandList5 *iface, - const D3D12_TEXTURE_COPY_LOCATION *dst, UINT dst_x, UINT dst_y, UINT dst_z, - const D3D12_TEXTURE_COPY_LOCATION *src, const D3D12_BOX *src_box) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *dst_resource, *src_resource; - const struct vkd3d_format *src_format, *dst_format; - const struct vkd3d_vk_device_procs *vk_procs; -@@ -3869,10 +3871,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(ID3D12Graphic - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_CopyResource(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_CopyResource(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst, ID3D12Resource *src) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *dst_resource, *src_resource; - const struct vkd3d_format *dst_format, *src_format; - const struct vkd3d_vk_device_procs *vk_procs; -@@ -3939,7 +3941,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyResource(ID3D12GraphicsComm - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *tiled_resource, const D3D12_TILED_RESOURCE_COORDINATE *tile_region_start_coordinate, - const D3D12_TILE_REGION_SIZE *tile_region_size, ID3D12Resource *buffer, UINT64 buffer_offset, - D3D12_TILE_COPY_FLAGS flags) -@@ -3950,11 +3952,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(ID3D12GraphicsCommand - buffer, buffer_offset, flags); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresource(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresource(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst, UINT dst_sub_resource_idx, - ID3D12Resource *src, UINT src_sub_resource_idx, DXGI_FORMAT format) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_format *src_format, *dst_format, *vk_format; - struct d3d12_resource *dst_resource, *src_resource; - const struct vkd3d_vk_device_procs *vk_procs; -@@ -4017,10 +4019,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresource(ID3D12Graphi - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vk_image_resolve)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_IASetPrimitiveTopology(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_IASetPrimitiveTopology(ID3D12GraphicsCommandList5 *iface, - D3D12_PRIMITIVE_TOPOLOGY topology) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, topology %#x.\n", iface, topology); - -@@ -4031,11 +4033,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_IASetPrimitiveTopology(ID3D12Gr - d3d12_command_list_invalidate_current_pipeline(list); - } - --static void STDMETHODCALLTYPE d3d12_command_list_RSSetViewports(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_RSSetViewports(ID3D12GraphicsCommandList5 *iface, - UINT viewport_count, const D3D12_VIEWPORT *viewports) - { - VkViewport vk_viewports[D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE]; -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - unsigned int i; - -@@ -4069,10 +4071,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_RSSetViewports(ID3D12GraphicsCo - VK_CALL(vkCmdSetViewport(list->vk_command_buffer, 0, viewport_count, vk_viewports)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_RSSetScissorRects(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_RSSetScissorRects(ID3D12GraphicsCommandList5 *iface, - UINT rect_count, const D3D12_RECT *rects) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - VkRect2D vk_rects[D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE]; - const struct vkd3d_vk_device_procs *vk_procs; - unsigned int i; -@@ -4097,10 +4099,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_RSSetScissorRects(ID3D12Graphic - VK_CALL(vkCmdSetScissor(list->vk_command_buffer, 0, rect_count, vk_rects)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_OMSetBlendFactor(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_OMSetBlendFactor(ID3D12GraphicsCommandList5 *iface, - const FLOAT blend_factor[4]) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - - TRACE("iface %p, blend_factor %p.\n", iface, blend_factor); -@@ -4109,10 +4111,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetBlendFactor(ID3D12Graphics - VK_CALL(vkCmdSetBlendConstants(list->vk_command_buffer, blend_factor)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_OMSetStencilRef(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_OMSetStencilRef(ID3D12GraphicsCommandList5 *iface, - UINT stencil_ref) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - - TRACE("iface %p, stencil_ref %u.\n", iface, stencil_ref); -@@ -4121,11 +4123,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetStencilRef(ID3D12GraphicsC - VK_CALL(vkCmdSetStencilReference(list->vk_command_buffer, VK_STENCIL_FRONT_AND_BACK, stencil_ref)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetPipelineState(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetPipelineState(ID3D12GraphicsCommandList5 *iface, - ID3D12PipelineState *pipeline_state) - { - struct d3d12_pipeline_state *state = unsafe_impl_from_ID3D12PipelineState(pipeline_state); -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, pipeline_state %p.\n", iface, pipeline_state); - -@@ -4176,10 +4178,10 @@ static unsigned int d3d12_find_ds_multiplanar_transition(const D3D12_RESOURCE_BA - return 0; - } - --static void STDMETHODCALLTYPE d3d12_command_list_ResourceBarrier(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ResourceBarrier(ID3D12GraphicsCommandList5 *iface, - UINT barrier_count, const D3D12_RESOURCE_BARRIER *barriers) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - bool have_aliasing_barriers = false, have_split_barriers = false; - const struct vkd3d_vk_device_procs *vk_procs; - const struct vkd3d_vulkan_info *vk_info; -@@ -4402,13 +4404,13 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResourceBarrier(ID3D12GraphicsC - WARN("Issuing split barrier(s) on D3D12_RESOURCE_BARRIER_FLAG_END_ONLY.\n"); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ExecuteBundle(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ExecuteBundle(ID3D12GraphicsCommandList5 *iface, - ID3D12GraphicsCommandList *command_list) - { - FIXME("iface %p, command_list %p stub!\n", iface, command_list); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetDescriptorHeaps(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetDescriptorHeaps(ID3D12GraphicsCommandList5 *iface, - UINT heap_count, ID3D12DescriptorHeap *const *heaps) - { - TRACE("iface %p, heap_count %u, heaps %p.\n", iface, heap_count, heaps); -@@ -4434,10 +4436,10 @@ static void d3d12_command_list_set_root_signature(struct d3d12_command_list *lis - d3d12_command_list_invalidate_root_parameters(list, bind_point); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootSignature(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootSignature(ID3D12GraphicsCommandList5 *iface, - ID3D12RootSignature *root_signature) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_signature %p.\n", iface, root_signature); - -@@ -4445,10 +4447,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootSignature(ID3D12G - unsafe_impl_from_ID3D12RootSignature(root_signature)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootSignature(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootSignature(ID3D12GraphicsCommandList5 *iface, - ID3D12RootSignature *root_signature) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_signature %p.\n", iface, root_signature); - -@@ -4487,10 +4489,10 @@ static void d3d12_command_list_set_descriptor_table(struct d3d12_command_list *l - bindings->descriptor_table_active_mask |= (uint64_t)1 << index; - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootDescriptorTable(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootDescriptorTable(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, base_descriptor %#"PRIx64".\n", - iface, root_parameter_index, base_descriptor.ptr); -@@ -4499,10 +4501,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootDescriptorTable(I - root_parameter_index, base_descriptor); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootDescriptorTable(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootDescriptorTable(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, base_descriptor %#"PRIx64".\n", - iface, root_parameter_index, base_descriptor.ptr); -@@ -4524,10 +4526,10 @@ static void d3d12_command_list_set_root_constants(struct d3d12_command_list *lis - c->stage_flags, c->offset + offset * sizeof(uint32_t), count * sizeof(uint32_t), data)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstant(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstant(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, UINT data, UINT dst_offset) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, data 0x%08x, dst_offset %u.\n", - iface, root_parameter_index, data, dst_offset); -@@ -4536,10 +4538,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstant(ID3 - root_parameter_index, dst_offset, 1, &data); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRoot32BitConstant(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRoot32BitConstant(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, UINT data, UINT dst_offset) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, data 0x%08x, dst_offset %u.\n", - iface, root_parameter_index, data, dst_offset); -@@ -4548,10 +4550,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRoot32BitConstant(ID - root_parameter_index, dst_offset, 1, &data); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstants(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstants(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, UINT constant_count, const void *data, UINT dst_offset) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, constant_count %u, data %p, dst_offset %u.\n", - iface, root_parameter_index, constant_count, data, dst_offset); -@@ -4560,10 +4562,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRoot32BitConstants(ID - root_parameter_index, dst_offset, constant_count, data); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRoot32BitConstants(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRoot32BitConstants(ID3D12GraphicsCommandList5 *iface, - UINT root_parameter_index, UINT constant_count, const void *data, UINT dst_offset) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, constant_count %u, data %p, dst_offset %u.\n", - iface, root_parameter_index, constant_count, data, dst_offset); -@@ -4625,9 +4627,9 @@ static void d3d12_command_list_set_root_cbv(struct d3d12_command_list *list, - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootConstantBufferView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4636,9 +4638,9 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootConstantBufferVie - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootConstantBufferView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4697,9 +4699,9 @@ static void d3d12_command_list_set_root_descriptor(struct d3d12_command_list *li - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootShaderResourceView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4709,9 +4711,9 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootShaderResourceVie - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootShaderResourceView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4721,9 +4723,9 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootShaderResourceVi - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootUnorderedAccessView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4733,9 +4735,9 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootUnorderedAccessVi - } - - static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootUnorderedAccessView( -- ID3D12GraphicsCommandList3 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) -+ ID3D12GraphicsCommandList5 *iface, UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - - TRACE("iface %p, root_parameter_index %u, address %#"PRIx64".\n", - iface, root_parameter_index, address); -@@ -4744,10 +4746,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetGraphicsRootUnorderedAccessV - root_parameter_index, address); - } - --static void STDMETHODCALLTYPE d3d12_command_list_IASetIndexBuffer(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_IASetIndexBuffer(ID3D12GraphicsCommandList5 *iface, - const D3D12_INDEX_BUFFER_VIEW *view) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_vk_device_procs *vk_procs; - struct d3d12_resource *resource; - enum VkIndexType index_type; -@@ -4787,10 +4789,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_IASetIndexBuffer(ID3D12Graphics - view->BufferLocation - resource->gpu_address, index_type)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_IASetVertexBuffers(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_IASetVertexBuffers(ID3D12GraphicsCommandList5 *iface, - UINT start_slot, UINT view_count, const D3D12_VERTEX_BUFFER_VIEW *views) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct vkd3d_null_resources *null_resources; - struct vkd3d_gpu_va_allocator *gpu_va_allocator; - VkDeviceSize offsets[ARRAY_SIZE(list->strides)]; -@@ -4845,10 +4847,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_IASetVertexBuffers(ID3D12Graphi - d3d12_command_list_invalidate_current_pipeline(list); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SOSetTargets(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SOSetTargets(ID3D12GraphicsCommandList5 *iface, - UINT start_slot, UINT view_count, const D3D12_STREAM_OUTPUT_BUFFER_VIEW *views) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - VkDeviceSize offsets[ARRAY_SIZE(list->so_counter_buffers)]; - VkDeviceSize sizes[ARRAY_SIZE(list->so_counter_buffers)]; - VkBuffer buffers[ARRAY_SIZE(list->so_counter_buffers)]; -@@ -4910,11 +4912,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_SOSetTargets(ID3D12GraphicsComm - VK_CALL(vkCmdBindTransformFeedbackBuffersEXT(list->vk_command_buffer, first, count, buffers, offsets, sizes)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12GraphicsCommandList5 *iface, - UINT render_target_descriptor_count, const D3D12_CPU_DESCRIPTOR_HANDLE *render_target_descriptors, - BOOL single_descriptor_handle, const D3D12_CPU_DESCRIPTOR_HANDLE *depth_stencil_descriptor) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct d3d12_rtv_desc *rtv_desc; - const struct d3d12_dsv_desc *dsv_desc; - VkFormat prev_dsv_format; -@@ -5115,12 +5117,12 @@ static void d3d12_command_list_clear(struct d3d12_command_list *list, - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_ClearDepthStencilView(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ClearDepthStencilView(ID3D12GraphicsCommandList5 *iface, - D3D12_CPU_DESCRIPTOR_HANDLE dsv, D3D12_CLEAR_FLAGS flags, float depth, UINT8 stencil, - UINT rect_count, const D3D12_RECT *rects) - { - const union VkClearValue clear_value = {.depthStencil = {depth, stencil}}; -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct d3d12_dsv_desc *dsv_desc = d3d12_dsv_desc_from_cpu_handle(dsv); - struct VkAttachmentDescription attachment_desc; - struct VkAttachmentReference ds_reference; -@@ -5164,10 +5166,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearDepthStencilView(ID3D12Gra - &clear_value, rect_count, rects); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ClearRenderTargetView(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ClearRenderTargetView(ID3D12GraphicsCommandList5 *iface, - D3D12_CPU_DESCRIPTOR_HANDLE rtv, const FLOAT color[4], UINT rect_count, const D3D12_RECT *rects) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const struct d3d12_rtv_desc *rtv_desc = d3d12_rtv_desc_from_cpu_handle(rtv); - struct VkAttachmentDescription attachment_desc; - struct VkAttachmentReference color_reference; -@@ -5412,11 +5414,11 @@ static const struct vkd3d_format *vkd3d_fixup_clear_uav_uint_colour(struct d3d12 - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(ID3D12GraphicsCommandList5 *iface, - D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle, D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, - const UINT values[4], UINT rect_count, const D3D12_RECT *rects) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct vkd3d_view *descriptor, *uint_view = NULL; - struct d3d12_device *device = list->device; - struct vkd3d_texture_view_desc view_desc; -@@ -5461,6 +5463,8 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(ID - view_desc.miplevel_count = 1; - view_desc.layer_idx = view->info.texture.layer_idx; - view_desc.layer_count = view->info.texture.layer_count; -+ view_desc.vk_image_aspect = VK_IMAGE_ASPECT_COLOR_BIT; -+ view_desc.usage = VK_IMAGE_USAGE_STORAGE_BIT; - - if (!vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_UAV, resource_impl->u.vk_image, &view_desc, - &uint_view)) -@@ -5478,11 +5482,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(ID - vkd3d_view_decref(uint_view, device); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewFloat(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewFloat(ID3D12GraphicsCommandList5 *iface, - D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle, D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, - const float values[4], UINT rect_count, const D3D12_RECT *rects) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *resource_impl; - VkClearColorValue colour; - struct vkd3d_view *view; -@@ -5498,16 +5502,16 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewFloat(I - d3d12_command_list_clear_uav(list, resource_impl, view, &colour, rect_count, rects); - } - --static void STDMETHODCALLTYPE d3d12_command_list_DiscardResource(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_DiscardResource(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *resource, const D3D12_DISCARD_REGION *region) - { - FIXME_ONCE("iface %p, resource %p, region %p stub!\n", iface, resource, region); - } - --static void STDMETHODCALLTYPE d3d12_command_list_BeginQuery(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_BeginQuery(ID3D12GraphicsCommandList5 *iface, - ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_query_heap *query_heap = unsafe_impl_from_ID3D12QueryHeap(heap); - const struct vkd3d_vk_device_procs *vk_procs; - VkQueryControlFlags flags = 0; -@@ -5534,10 +5538,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_BeginQuery(ID3D12GraphicsComman - VK_CALL(vkCmdBeginQuery(list->vk_command_buffer, query_heap->vk_query_pool, index, flags)); - } - --static void STDMETHODCALLTYPE d3d12_command_list_EndQuery(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_EndQuery(ID3D12GraphicsCommandList5 *iface, - ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_query_heap *query_heap = unsafe_impl_from_ID3D12QueryHeap(heap); - const struct vkd3d_vk_device_procs *vk_procs; - -@@ -5579,12 +5583,12 @@ static size_t get_query_stride(D3D12_QUERY_TYPE type) - return sizeof(uint64_t); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(ID3D12GraphicsCommandList5 *iface, - ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT start_index, UINT query_count, - ID3D12Resource *dst_buffer, UINT64 aligned_dst_buffer_offset) - { - const struct d3d12_query_heap *query_heap = unsafe_impl_from_ID3D12QueryHeap(heap); -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *buffer = unsafe_impl_from_ID3D12Resource(dst_buffer); - const struct vkd3d_vk_device_procs *vk_procs; - unsigned int i, first, count; -@@ -5660,10 +5664,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(ID3D12Graphics - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetPredication(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetPredication(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *buffer, UINT64 aligned_buffer_offset, D3D12_PREDICATION_OP operation) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *resource = unsafe_impl_from_ID3D12Resource(buffer); - const struct vkd3d_vulkan_info *vk_info = &list->device->vk_info; - const struct vkd3d_vk_device_procs *vk_procs; -@@ -5732,19 +5736,19 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetPredication(ID3D12GraphicsCo - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetMarker(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetMarker(ID3D12GraphicsCommandList5 *iface, - UINT metadata, const void *data, UINT size) - { - FIXME("iface %p, metadata %#x, data %p, size %u stub!\n", iface, metadata, data, size); - } - --static void STDMETHODCALLTYPE d3d12_command_list_BeginEvent(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_BeginEvent(ID3D12GraphicsCommandList5 *iface, - UINT metadata, const void *data, UINT size) - { - FIXME("iface %p, metadata %#x, data %p, size %u stub!\n", iface, metadata, data, size); - } - --static void STDMETHODCALLTYPE d3d12_command_list_EndEvent(ID3D12GraphicsCommandList3 *iface) -+static void STDMETHODCALLTYPE d3d12_command_list_EndEvent(ID3D12GraphicsCommandList5 *iface) - { - FIXME("iface %p stub!\n", iface); - } -@@ -5753,14 +5757,14 @@ STATIC_ASSERT(sizeof(VkDispatchIndirectCommand) == sizeof(D3D12_DISPATCH_ARGUMEN - STATIC_ASSERT(sizeof(VkDrawIndexedIndirectCommand) == sizeof(D3D12_DRAW_INDEXED_ARGUMENTS)); - STATIC_ASSERT(sizeof(VkDrawIndirectCommand) == sizeof(D3D12_DRAW_ARGUMENTS)); - --static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(ID3D12GraphicsCommandList5 *iface, - ID3D12CommandSignature *command_signature, UINT max_command_count, ID3D12Resource *arg_buffer, - UINT64 arg_buffer_offset, ID3D12Resource *count_buffer, UINT64 count_buffer_offset) - { - struct d3d12_command_signature *sig_impl = unsafe_impl_from_ID3D12CommandSignature(command_signature); - struct d3d12_resource *count_impl = unsafe_impl_from_ID3D12Resource(count_buffer); - struct d3d12_resource *arg_impl = unsafe_impl_from_ID3D12Resource(arg_buffer); -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - const D3D12_COMMAND_SIGNATURE_DESC *signature_desc; - const struct vkd3d_vk_device_procs *vk_procs; - unsigned int i; -@@ -5859,7 +5863,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(ID3D12GraphicsC - d3d12_command_signature_decref(sig_impl); - } - --static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst_buffer, UINT64 dst_offset, - ID3D12Resource *src_buffer, UINT64 src_offset, - UINT dependent_resource_count, ID3D12Resource * const *dependent_resources, -@@ -5872,7 +5876,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT(ID3D12Grap - dependent_resource_count, dependent_resources, dependent_sub_resource_ranges); - } - --static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT64(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT64(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst_buffer, UINT64 dst_offset, - ID3D12Resource *src_buffer, UINT64 src_offset, - UINT dependent_resource_count, ID3D12Resource * const *dependent_resources, -@@ -5885,20 +5889,20 @@ static void STDMETHODCALLTYPE d3d12_command_list_AtomicCopyBufferUINT64(ID3D12Gr - dependent_resource_count, dependent_resources, dependent_sub_resource_ranges); - } - --static void STDMETHODCALLTYPE d3d12_command_list_OMSetDepthBounds(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_OMSetDepthBounds(ID3D12GraphicsCommandList5 *iface, - FLOAT min, FLOAT max) - { - FIXME("iface %p, min %.8e, max %.8e stub!\n", iface, min, max); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetSamplePositions(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetSamplePositions(ID3D12GraphicsCommandList5 *iface, - UINT sample_count, UINT pixel_count, D3D12_SAMPLE_POSITION *sample_positions) - { - FIXME("iface %p, sample_count %u, pixel_count %u, sample_positions %p stub!\n", - iface, sample_count, pixel_count, sample_positions); - } - --static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresourceRegion(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresourceRegion(ID3D12GraphicsCommandList5 *iface, - ID3D12Resource *dst_resource, UINT dst_sub_resource_idx, UINT dst_x, UINT dst_y, - ID3D12Resource *src_resource, UINT src_sub_resource_idx, - D3D12_RECT *src_rect, DXGI_FORMAT format, D3D12_RESOLVE_MODE mode) -@@ -5910,16 +5914,16 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresourceRegion(ID3D12 - src_resource, src_sub_resource_idx, src_rect, format, mode); - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetViewInstanceMask(ID3D12GraphicsCommandList3 *iface, UINT mask) -+static void STDMETHODCALLTYPE d3d12_command_list_SetViewInstanceMask(ID3D12GraphicsCommandList5 *iface, UINT mask) - { - FIXME("iface %p, mask %#x stub!\n", iface, mask); - } - --static void STDMETHODCALLTYPE d3d12_command_list_WriteBufferImmediate(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_WriteBufferImmediate(ID3D12GraphicsCommandList5 *iface, - UINT count, const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *parameters, - const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes) - { -- struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList3(iface); -+ struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList5(iface); - struct d3d12_resource *resource; - unsigned int i; - -@@ -5932,13 +5936,88 @@ static void STDMETHODCALLTYPE d3d12_command_list_WriteBufferImmediate(ID3D12Grap - } - } - --static void STDMETHODCALLTYPE d3d12_command_list_SetProtectedResourceSession(ID3D12GraphicsCommandList3 *iface, -+static void STDMETHODCALLTYPE d3d12_command_list_SetProtectedResourceSession(ID3D12GraphicsCommandList5 *iface, - ID3D12ProtectedResourceSession *protected_session) - { - FIXME("iface %p, protected_session %p stub!\n", iface, protected_session); - } - --static const struct ID3D12GraphicsCommandList3Vtbl d3d12_command_list_vtbl = -+static void STDMETHODCALLTYPE d3d12_command_list_BeginRenderPass(ID3D12GraphicsCommandList5 *iface, -+ UINT count, const D3D12_RENDER_PASS_RENDER_TARGET_DESC *render_targets, -+ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *depth_stencil, D3D12_RENDER_PASS_FLAGS flags) -+{ -+ FIXME("iface %p, count %u, render_targets %p, depth_stencil %p, flags %#x stub!\n", iface, -+ count, render_targets, depth_stencil, flags); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_EndRenderPass(ID3D12GraphicsCommandList5 *iface) -+{ -+ FIXME("iface %p stub!\n", iface); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_InitializeMetaCommand(ID3D12GraphicsCommandList5 *iface, -+ ID3D12MetaCommand *meta_command, const void *parameters_data, SIZE_T data_size_in_bytes) -+{ -+ FIXME("iface %p, meta_command %p, parameters_data %p, data_size_in_bytes %lu stub!\n", iface, -+ meta_command, parameters_data, data_size_in_bytes); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_ExecuteMetaCommand(ID3D12GraphicsCommandList5 *iface, -+ ID3D12MetaCommand *meta_command, const void *parameters_data, SIZE_T data_size_in_bytes) -+{ -+ FIXME("iface %p, meta_command %p, parameters_data %p, data_size_in_bytes %lu stub!\n", iface, -+ meta_command, parameters_data, data_size_in_bytes); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_BuildRaytracingAccelerationStructure(ID3D12GraphicsCommandList5 *iface, -+ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *desc, UINT count, -+ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *postbuild_info_descs) -+{ -+ FIXME("iface %p, desc %p, count %u, postbuild_info_descs %p stub!\n", iface, desc, count, postbuild_info_descs); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_EmitRaytracingAccelerationStructurePostbuildInfo(ID3D12GraphicsCommandList5 *iface, -+ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *desc, -+ UINT structures_count, const D3D12_GPU_VIRTUAL_ADDRESS *src_structure_data) -+{ -+ FIXME("iface %p, desc %p, structures_count %u, src_structure_data %p stub!\n", -+ iface, desc, structures_count, src_structure_data); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_CopyRaytracingAccelerationStructure(ID3D12GraphicsCommandList5 *iface, -+ D3D12_GPU_VIRTUAL_ADDRESS dst_structure_data, -+ D3D12_GPU_VIRTUAL_ADDRESS src_structure_data, -+ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode) -+{ -+ FIXME("iface %p, dst_structure_data %#"PRIx64", src_structure_data %#"PRIx64", mode %u stub!\n", -+ iface, dst_structure_data, src_structure_data, mode); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_SetPipelineState1(ID3D12GraphicsCommandList5 *iface, -+ ID3D12StateObject *state_object) -+{ -+ FIXME("iface %p, state_object %p stub!\n", iface, state_object); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_DispatchRays(ID3D12GraphicsCommandList5 *iface, -+ const D3D12_DISPATCH_RAYS_DESC *desc) -+{ -+ FIXME("iface %p, desc %p stub!\n", iface, desc); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_RSSetShadingRate(ID3D12GraphicsCommandList5 *iface, -+ D3D12_SHADING_RATE rate, const D3D12_SHADING_RATE_COMBINER *combiners) -+{ -+ FIXME("iface %p, rate %#x, combiners %p stub!\n", iface, rate, combiners); -+} -+ -+static void STDMETHODCALLTYPE d3d12_command_list_RSSetShadingRateImage(ID3D12GraphicsCommandList5 *iface, -+ ID3D12Resource *rate_image) -+{ -+ FIXME("iface %p, rate_image %p stub!\n", iface, rate_image); -+} -+ -+static const struct ID3D12GraphicsCommandList5Vtbl d3d12_command_list_vtbl = - { - /* IUnknown methods */ - d3d12_command_list_QueryInterface, -@@ -6016,6 +6095,19 @@ static const struct ID3D12GraphicsCommandList3Vtbl d3d12_command_list_vtbl = - d3d12_command_list_WriteBufferImmediate, - /* ID3D12GraphicsCommandList3 methods */ - d3d12_command_list_SetProtectedResourceSession, -+ /* ID3D12GraphicsCommandList4 methods */ -+ d3d12_command_list_BeginRenderPass, -+ d3d12_command_list_EndRenderPass, -+ d3d12_command_list_InitializeMetaCommand, -+ d3d12_command_list_ExecuteMetaCommand, -+ d3d12_command_list_BuildRaytracingAccelerationStructure, -+ d3d12_command_list_EmitRaytracingAccelerationStructurePostbuildInfo, -+ d3d12_command_list_CopyRaytracingAccelerationStructure, -+ d3d12_command_list_SetPipelineState1, -+ d3d12_command_list_DispatchRays, -+ /* ID3D12GraphicsCommandList5 methods */ -+ d3d12_command_list_RSSetShadingRate, -+ d3d12_command_list_RSSetShadingRateImage, - }; - - static struct d3d12_command_list *unsafe_impl_from_ID3D12CommandList(ID3D12CommandList *iface) -@@ -6023,7 +6115,7 @@ static struct d3d12_command_list *unsafe_impl_from_ID3D12CommandList(ID3D12Comma - if (!iface) - return NULL; - assert(iface->lpVtbl == (struct ID3D12CommandListVtbl *)&d3d12_command_list_vtbl); -- return CONTAINING_RECORD(iface, struct d3d12_command_list, ID3D12GraphicsCommandList3_iface); -+ return CONTAINING_RECORD(iface, struct d3d12_command_list, ID3D12GraphicsCommandList5_iface); - } - - static HRESULT d3d12_command_list_init(struct d3d12_command_list *list, struct d3d12_device *device, -@@ -6032,7 +6124,7 @@ static HRESULT d3d12_command_list_init(struct d3d12_command_list *list, struct d - { - HRESULT hr; - -- list->ID3D12GraphicsCommandList3_iface.lpVtbl = &d3d12_command_list_vtbl; -+ list->ID3D12GraphicsCommandList5_iface.lpVtbl = &d3d12_command_list_vtbl; - list->refcount = 1; - - list->type = type; -diff --git a/libs/vkd3d/libs/vkd3d/device.c b/libs/vkd3d/libs/vkd3d/device.c -index c33061073a3..79028fc3dd8 100644 ---- a/libs/vkd3d/libs/vkd3d/device.c -+++ b/libs/vkd3d/libs/vkd3d/device.c -@@ -83,6 +83,7 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = - VK_EXTENSION(KHR_DRAW_INDIRECT_COUNT, KHR_draw_indirect_count), - VK_EXTENSION(KHR_GET_MEMORY_REQUIREMENTS_2, KHR_get_memory_requirements2), - VK_EXTENSION(KHR_IMAGE_FORMAT_LIST, KHR_image_format_list), -+ VK_EXTENSION(KHR_MAINTENANCE2, KHR_maintenance2), - VK_EXTENSION(KHR_MAINTENANCE3, KHR_maintenance3), - VK_EXTENSION(KHR_PUSH_DESCRIPTOR, KHR_push_descriptor), - VK_EXTENSION(KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE, KHR_sampler_mirror_clamp_to_edge), -@@ -1521,9 +1522,7 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, - device->feature_options1.ExpandedComputeResourceStates = TRUE; - device->feature_options1.Int64ShaderOps = features->shaderInt64; - -- /* Depth bounds test is enabled in D3D12_DEPTH_STENCIL_DESC1, which is not -- * supported. */ -- device->feature_options2.DepthBoundsTestSupported = FALSE; -+ device->feature_options2.DepthBoundsTestSupported = features->depthBounds; - /* d3d12_command_list_SetSamplePositions() is not implemented. */ - device->feature_options2.ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED; - -@@ -2456,17 +2455,21 @@ static void vkd3d_desc_object_cache_cleanup(struct vkd3d_desc_object_cache *cach - } - - /* ID3D12Device */ --static inline struct d3d12_device *impl_from_ID3D12Device1(ID3D12Device1 *iface) -+static inline struct d3d12_device *impl_from_ID3D12Device5(ID3D12Device5 *iface) - { -- return CONTAINING_RECORD(iface, struct d3d12_device, ID3D12Device1_iface); -+ return CONTAINING_RECORD(iface, struct d3d12_device, ID3D12Device5_iface); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_QueryInterface(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_QueryInterface(ID3D12Device5 *iface, - REFIID riid, void **object) - { - TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object); - -- if (IsEqualGUID(riid, &IID_ID3D12Device1) -+ if (IsEqualGUID(riid, &IID_ID3D12Device5) -+ || IsEqualGUID(riid, &IID_ID3D12Device4) -+ || IsEqualGUID(riid, &IID_ID3D12Device3) -+ || IsEqualGUID(riid, &IID_ID3D12Device2) -+ || IsEqualGUID(riid, &IID_ID3D12Device1) - || IsEqualGUID(riid, &IID_ID3D12Device) - || IsEqualGUID(riid, &IID_ID3D12Object) - || IsEqualGUID(riid, &IID_IUnknown)) -@@ -2482,9 +2485,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_QueryInterface(ID3D12Device1 *ifac - return E_NOINTERFACE; - } - --static ULONG STDMETHODCALLTYPE d3d12_device_AddRef(ID3D12Device1 *iface) -+static ULONG STDMETHODCALLTYPE d3d12_device_AddRef(ID3D12Device5 *iface) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - ULONG refcount = InterlockedIncrement(&device->refcount); - - TRACE("%p increasing refcount to %u.\n", device, refcount); -@@ -2492,9 +2495,9 @@ static ULONG STDMETHODCALLTYPE d3d12_device_AddRef(ID3D12Device1 *iface) - return refcount; - } - --static ULONG STDMETHODCALLTYPE d3d12_device_Release(ID3D12Device1 *iface) -+static ULONG STDMETHODCALLTYPE d3d12_device_Release(ID3D12Device5 *iface) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - ULONG refcount = InterlockedDecrement(&device->refcount); - - TRACE("%p decreasing refcount to %u.\n", device, refcount); -@@ -2528,10 +2531,10 @@ static ULONG STDMETHODCALLTYPE d3d12_device_Release(ID3D12Device1 *iface) - return refcount; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_GetPrivateData(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_GetPrivateData(ID3D12Device5 *iface, - REFGUID guid, UINT *data_size, void *data) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, guid %s, data_size %p, data %p.\n", - iface, debugstr_guid(guid), data_size, data); -@@ -2539,10 +2542,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_GetPrivateData(ID3D12Device1 *ifac - return vkd3d_get_private_data(&device->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetPrivateData(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetPrivateData(ID3D12Device5 *iface, - REFGUID guid, UINT data_size, const void *data) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, guid %s, data_size %u, data %p.\n", - iface, debugstr_guid(guid), data_size, data); -@@ -2550,19 +2553,19 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_SetPrivateData(ID3D12Device1 *ifac - return vkd3d_set_private_data(&device->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetPrivateDataInterface(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetPrivateDataInterface(ID3D12Device5 *iface, - REFGUID guid, const IUnknown *data) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data); - - return vkd3d_set_private_data_interface(&device->private_store, guid, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetName(ID3D12Device1 *iface, const WCHAR *name) -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetName(ID3D12Device5 *iface, const WCHAR *name) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, name %s.\n", iface, debugstr_w(name, device->wchar_size)); - -@@ -2570,17 +2573,17 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_SetName(ID3D12Device1 *iface, cons - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, name); - } - --static UINT STDMETHODCALLTYPE d3d12_device_GetNodeCount(ID3D12Device1 *iface) -+static UINT STDMETHODCALLTYPE d3d12_device_GetNodeCount(ID3D12Device5 *iface) - { - TRACE("iface %p.\n", iface); - - return 1; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandQueue(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandQueue(ID3D12Device5 *iface, - const D3D12_COMMAND_QUEUE_DESC *desc, REFIID riid, void **command_queue) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_command_queue *object; - HRESULT hr; - -@@ -2594,10 +2597,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandQueue(ID3D12Device1 * - riid, command_queue); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandAllocator(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandAllocator(ID3D12Device5 *iface, - D3D12_COMMAND_LIST_TYPE type, REFIID riid, void **command_allocator) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_command_allocator *object; - HRESULT hr; - -@@ -2611,10 +2614,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandAllocator(ID3D12Devic - riid, command_allocator); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateGraphicsPipelineState(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateGraphicsPipelineState(ID3D12Device5 *iface, - const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, REFIID riid, void **pipeline_state) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_pipeline_state *object; - HRESULT hr; - -@@ -2628,10 +2631,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateGraphicsPipelineState(ID3D12 - &IID_ID3D12PipelineState, riid, pipeline_state); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateComputePipelineState(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateComputePipelineState(ID3D12Device5 *iface, - const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, REFIID riid, void **pipeline_state) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_pipeline_state *object; - HRESULT hr; - -@@ -2645,11 +2648,11 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateComputePipelineState(ID3D12D - &IID_ID3D12PipelineState, riid, pipeline_state); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandList(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandList(ID3D12Device5 *iface, - UINT node_mask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator *command_allocator, - ID3D12PipelineState *initial_pipeline_state, REFIID riid, void **command_list) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_command_list *object; - HRESULT hr; - -@@ -2662,8 +2665,8 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandList(ID3D12Device1 *i - initial_pipeline_state, &object))) - return hr; - -- return return_interface(&object->ID3D12GraphicsCommandList3_iface, -- &IID_ID3D12GraphicsCommandList3, riid, command_list); -+ return return_interface(&object->ID3D12GraphicsCommandList5_iface, -+ &IID_ID3D12GraphicsCommandList5, riid, command_list); - } - - /* Direct3D feature levels restrict which formats can be optionally supported. */ -@@ -2772,10 +2775,10 @@ bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent) - return true; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device5 *iface, - D3D12_FEATURE feature, void *feature_data, UINT feature_data_size) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, feature %#x, feature_data %p, feature_data_size %u.\n", - iface, feature, feature_data, feature_data_size); -@@ -2925,7 +2928,14 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device1 - if (image_features & VK_FORMAT_FEATURE_BLIT_SRC_BIT) - data->Support1 |= D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE; - if (image_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) -+ { - data->Support1 |= D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW; -+ if (device->vk_info.uav_read_without_format) -+ data->Support2 |= D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD; -+ /* We effectively require shaderStorageImageWriteWithoutFormat, -+ * so we can just report UAV_TYPED_STORE unconditionally. */ -+ data->Support2 |= D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE; -+ } - - if (image_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT) - data->Support2 |= D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD -@@ -3274,10 +3284,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device1 - } - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateDescriptorHeap(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateDescriptorHeap(ID3D12Device5 *iface, - const D3D12_DESCRIPTOR_HEAP_DESC *desc, REFIID riid, void **descriptor_heap) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_descriptor_heap *object; - HRESULT hr; - -@@ -3291,7 +3301,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateDescriptorHeap(ID3D12Device1 - &IID_ID3D12DescriptorHeap, riid, descriptor_heap); - } - --static UINT STDMETHODCALLTYPE d3d12_device_GetDescriptorHandleIncrementSize(ID3D12Device1 *iface, -+static UINT STDMETHODCALLTYPE d3d12_device_GetDescriptorHandleIncrementSize(ID3D12Device5 *iface, - D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type) - { - TRACE("iface %p, descriptor_heap_type %#x.\n", iface, descriptor_heap_type); -@@ -3314,11 +3324,11 @@ static UINT STDMETHODCALLTYPE d3d12_device_GetDescriptorHandleIncrementSize(ID3D - } - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateRootSignature(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateRootSignature(ID3D12Device5 *iface, - UINT node_mask, const void *bytecode, SIZE_T bytecode_length, - REFIID riid, void **root_signature) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_root_signature *object; - HRESULT hr; - -@@ -3334,10 +3344,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateRootSignature(ID3D12Device1 - &IID_ID3D12RootSignature, riid, root_signature); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateConstantBufferView(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateConstantBufferView(ID3D12Device5 *iface, - const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc, D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_desc tmp = {0}; - - TRACE("iface %p, desc %p, descriptor %#lx.\n", iface, desc, descriptor.ptr); -@@ -3346,11 +3356,11 @@ static void STDMETHODCALLTYPE d3d12_device_CreateConstantBufferView(ID3D12Device - d3d12_desc_write_atomic(d3d12_desc_from_cpu_handle(descriptor), &tmp, device); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateShaderResourceView(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateShaderResourceView(ID3D12Device5 *iface, - ID3D12Resource *resource, const D3D12_SHADER_RESOURCE_VIEW_DESC *desc, - D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_desc tmp = {0}; - - TRACE("iface %p, resource %p, desc %p, descriptor %#lx.\n", -@@ -3360,11 +3370,11 @@ static void STDMETHODCALLTYPE d3d12_device_CreateShaderResourceView(ID3D12Device - d3d12_desc_write_atomic(d3d12_desc_from_cpu_handle(descriptor), &tmp, device); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateUnorderedAccessView(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateUnorderedAccessView(ID3D12Device5 *iface, - ID3D12Resource *resource, ID3D12Resource *counter_resource, - const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc, D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_desc tmp = {0}; - - TRACE("iface %p, resource %p, counter_resource %p, desc %p, descriptor %#lx.\n", -@@ -3375,7 +3385,7 @@ static void STDMETHODCALLTYPE d3d12_device_CreateUnorderedAccessView(ID3D12Devic - d3d12_desc_write_atomic(d3d12_desc_from_cpu_handle(descriptor), &tmp, device); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateRenderTargetView(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateRenderTargetView(ID3D12Device5 *iface, - ID3D12Resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc, - D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -@@ -3383,10 +3393,10 @@ static void STDMETHODCALLTYPE d3d12_device_CreateRenderTargetView(ID3D12Device1 - iface, resource, desc, descriptor.ptr); - - d3d12_rtv_desc_create_rtv(d3d12_rtv_desc_from_cpu_handle(descriptor), -- impl_from_ID3D12Device1(iface), unsafe_impl_from_ID3D12Resource(resource), desc); -+ impl_from_ID3D12Device5(iface), unsafe_impl_from_ID3D12Resource(resource), desc); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateDepthStencilView(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateDepthStencilView(ID3D12Device5 *iface, - ID3D12Resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc, - D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -@@ -3394,13 +3404,13 @@ static void STDMETHODCALLTYPE d3d12_device_CreateDepthStencilView(ID3D12Device1 - iface, resource, desc, descriptor.ptr); - - d3d12_dsv_desc_create_dsv(d3d12_dsv_desc_from_cpu_handle(descriptor), -- impl_from_ID3D12Device1(iface), unsafe_impl_from_ID3D12Resource(resource), desc); -+ impl_from_ID3D12Device5(iface), unsafe_impl_from_ID3D12Resource(resource), desc); - } - --static void STDMETHODCALLTYPE d3d12_device_CreateSampler(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CreateSampler(ID3D12Device5 *iface, - const D3D12_SAMPLER_DESC *desc, D3D12_CPU_DESCRIPTOR_HANDLE descriptor) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_desc tmp = {0}; - - TRACE("iface %p, desc %p, descriptor %#lx.\n", iface, desc, descriptor.ptr); -@@ -3409,14 +3419,14 @@ static void STDMETHODCALLTYPE d3d12_device_CreateSampler(ID3D12Device1 *iface, - d3d12_desc_write_atomic(d3d12_desc_from_cpu_handle(descriptor), &tmp, device); - } - --static void STDMETHODCALLTYPE d3d12_device_CopyDescriptors(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CopyDescriptors(ID3D12Device5 *iface, - UINT dst_descriptor_range_count, const D3D12_CPU_DESCRIPTOR_HANDLE *dst_descriptor_range_offsets, - const UINT *dst_descriptor_range_sizes, - UINT src_descriptor_range_count, const D3D12_CPU_DESCRIPTOR_HANDLE *src_descriptor_range_offsets, - const UINT *src_descriptor_range_sizes, - D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - unsigned int dst_range_idx, dst_idx, src_range_idx, src_idx; - unsigned int dst_range_size, src_range_size; - struct d3d12_descriptor_heap *dst_heap; -@@ -3472,7 +3482,7 @@ static void STDMETHODCALLTYPE d3d12_device_CopyDescriptors(ID3D12Device1 *iface, - } - } - --static void STDMETHODCALLTYPE d3d12_device_CopyDescriptorsSimple(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_CopyDescriptorsSimple(ID3D12Device5 *iface, - UINT descriptor_count, const D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor_range_offset, - const D3D12_CPU_DESCRIPTOR_HANDLE src_descriptor_range_offset, - D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type) -@@ -3487,10 +3497,10 @@ static void STDMETHODCALLTYPE d3d12_device_CopyDescriptorsSimple(ID3D12Device1 * - } - - static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResourceAllocationInfo( -- ID3D12Device1 *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, -+ ID3D12Device5 *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, - UINT count, const D3D12_RESOURCE_DESC *resource_descs) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - const D3D12_RESOURCE_DESC *desc; - uint64_t requested_alignment; - -@@ -3563,10 +3573,10 @@ invalid: - return info; - } - --static D3D12_HEAP_PROPERTIES * STDMETHODCALLTYPE d3d12_device_GetCustomHeapProperties(ID3D12Device1 *iface, -+static D3D12_HEAP_PROPERTIES * STDMETHODCALLTYPE d3d12_device_GetCustomHeapProperties(ID3D12Device5 *iface, - D3D12_HEAP_PROPERTIES *heap_properties, UINT node_mask, D3D12_HEAP_TYPE heap_type) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - bool coherent; - - TRACE("iface %p, heap_properties %p, node_mask 0x%08x, heap_type %#x.\n", -@@ -3606,12 +3616,12 @@ static D3D12_HEAP_PROPERTIES * STDMETHODCALLTYPE d3d12_device_GetCustomHeapPrope - return heap_properties; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommittedResource(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommittedResource(ID3D12Device5 *iface, - 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, REFIID iid, void **resource) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_resource *object; - HRESULT hr; - -@@ -3621,26 +3631,26 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommittedResource(ID3D12Devi - optimized_clear_value, debugstr_guid(iid), resource); - - if (FAILED(hr = d3d12_committed_resource_create(device, heap_properties, heap_flags, -- desc, initial_state, optimized_clear_value, &object))) -+ desc, initial_state, optimized_clear_value, NULL, &object))) - { - *resource = NULL; - return hr; - } - -- return return_interface(&object->ID3D12Resource_iface, &IID_ID3D12Resource, iid, resource); -+ return return_interface(&object->ID3D12Resource1_iface, &IID_ID3D12Resource1, iid, resource); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateHeap(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateHeap(ID3D12Device5 *iface, - const D3D12_HEAP_DESC *desc, REFIID iid, void **heap) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_heap *object; - HRESULT hr; - - TRACE("iface %p, desc %p, iid %s, heap %p.\n", - iface, desc, debugstr_guid(iid), heap); - -- if (FAILED(hr = d3d12_heap_create(device, desc, NULL, &object))) -+ if (FAILED(hr = d3d12_heap_create(device, desc, NULL, NULL, &object))) - { - *heap = NULL; - return hr; -@@ -3649,12 +3659,12 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateHeap(ID3D12Device1 *iface, - return return_interface(&object->ID3D12Heap_iface, &IID_ID3D12Heap, iid, heap); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePlacedResource(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePlacedResource(ID3D12Device5 *iface, - ID3D12Heap *heap, UINT64 heap_offset, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, REFIID iid, void **resource) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_heap *heap_object; - struct d3d12_resource *object; - HRESULT hr; -@@ -3670,14 +3680,14 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePlacedResource(ID3D12Device1 - desc, initial_state, optimized_clear_value, &object))) - return hr; - -- return return_interface(&object->ID3D12Resource_iface, &IID_ID3D12Resource, iid, resource); -+ return return_interface(&object->ID3D12Resource1_iface, &IID_ID3D12Resource1, iid, resource); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateReservedResource(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateReservedResource(ID3D12Device5 *iface, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, REFIID iid, void **resource) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_resource *object; - HRESULT hr; - -@@ -3688,14 +3698,14 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateReservedResource(ID3D12Devic - desc, initial_state, optimized_clear_value, &object))) - return hr; - -- return return_interface(&object->ID3D12Resource_iface, &IID_ID3D12Resource, iid, resource); -+ return return_interface(&object->ID3D12Resource1_iface, &IID_ID3D12Resource1, iid, resource); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateSharedHandle(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateSharedHandle(ID3D12Device5 *iface, - ID3D12DeviceChild *object, const SECURITY_ATTRIBUTES *attributes, DWORD access, - const WCHAR *name, HANDLE *handle) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - FIXME("iface %p, object %p, attributes %p, access %#x, name %s, handle %p stub!\n", - iface, object, attributes, access, debugstr_w(name, device->wchar_size), handle); -@@ -3703,7 +3713,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateSharedHandle(ID3D12Device1 * - return E_NOTIMPL; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandle(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandle(ID3D12Device5 *iface, - HANDLE handle, REFIID riid, void **object) - { - FIXME("iface %p, handle %p, riid %s, object %p stub!\n", -@@ -3712,10 +3722,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandle(ID3D12Device1 *if - return E_NOTIMPL; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandleByName(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandleByName(ID3D12Device5 *iface, - const WCHAR *name, DWORD access, HANDLE *handle) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - FIXME("iface %p, name %s, access %#x, handle %p stub!\n", - iface, debugstr_w(name, device->wchar_size), access, handle); -@@ -3723,7 +3733,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandleByName(ID3D12Devic - return E_NOTIMPL; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_MakeResident(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_MakeResident(ID3D12Device5 *iface, - UINT object_count, ID3D12Pageable * const *objects) - { - FIXME_ONCE("iface %p, object_count %u, objects %p stub!\n", -@@ -3732,7 +3742,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_MakeResident(ID3D12Device1 *iface, - return S_OK; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_Evict(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_Evict(ID3D12Device5 *iface, - UINT object_count, ID3D12Pageable * const *objects) - { - FIXME_ONCE("iface %p, object_count %u, objects %p stub!\n", -@@ -3741,10 +3751,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_Evict(ID3D12Device1 *iface, - return S_OK; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateFence(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateFence(ID3D12Device5 *iface, - UINT64 initial_value, D3D12_FENCE_FLAGS flags, REFIID riid, void **fence) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_fence *object; - HRESULT hr; - -@@ -3757,21 +3767,21 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateFence(ID3D12Device1 *iface, - return return_interface(&object->ID3D12Fence1_iface, &IID_ID3D12Fence1, riid, fence); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_GetDeviceRemovedReason(ID3D12Device1 *iface) -+static HRESULT STDMETHODCALLTYPE d3d12_device_GetDeviceRemovedReason(ID3D12Device5 *iface) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p.\n", iface); - - return device->removed_reason; - } - --static void STDMETHODCALLTYPE d3d12_device_GetCopyableFootprints(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_GetCopyableFootprints(ID3D12Device5 *iface, - const D3D12_RESOURCE_DESC *desc, UINT first_sub_resource, UINT sub_resource_count, - UINT64 base_offset, D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts, - UINT *row_counts, UINT64 *row_sizes, UINT64 *total_bytes) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - unsigned int i, sub_resource_idx, miplevel_idx, row_count, row_size, row_pitch; - unsigned int width, height, depth, plane_count, sub_resources_per_plane; -@@ -3851,10 +3861,10 @@ static void STDMETHODCALLTYPE d3d12_device_GetCopyableFootprints(ID3D12Device1 * - *total_bytes = total; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateQueryHeap(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateQueryHeap(ID3D12Device5 *iface, - const D3D12_QUERY_HEAP_DESC *desc, REFIID iid, void **heap) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_query_heap *object; - HRESULT hr; - -@@ -3867,18 +3877,18 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateQueryHeap(ID3D12Device1 *ifa - return return_interface(&object->ID3D12QueryHeap_iface, &IID_ID3D12QueryHeap, iid, heap); - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetStablePowerState(ID3D12Device1 *iface, BOOL enable) -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetStablePowerState(ID3D12Device5 *iface, BOOL enable) - { - FIXME("iface %p, enable %#x stub!\n", iface, enable); - - return E_NOTIMPL; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandSignature(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandSignature(ID3D12Device5 *iface, - const D3D12_COMMAND_SIGNATURE_DESC *desc, ID3D12RootSignature *root_signature, - REFIID iid, void **command_signature) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - struct d3d12_command_signature *object; - HRESULT hr; - -@@ -3892,14 +3902,14 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandSignature(ID3D12Devic - &IID_ID3D12CommandSignature, iid, command_signature); - } - --static void STDMETHODCALLTYPE d3d12_device_GetResourceTiling(ID3D12Device1 *iface, -+static void STDMETHODCALLTYPE d3d12_device_GetResourceTiling(ID3D12Device5 *iface, - ID3D12Resource *resource, UINT *total_tile_count, - D3D12_PACKED_MIP_INFO *packed_mip_info, D3D12_TILE_SHAPE *standard_tile_shape, - UINT *sub_resource_tiling_count, UINT first_sub_resource_tiling, - D3D12_SUBRESOURCE_TILING *sub_resource_tilings) - { - const struct d3d12_resource *resource_impl = impl_from_ID3D12Resource(resource); -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, resource %p, total_tile_count %p, packed_mip_info %p, " - "standard_title_shape %p, sub_resource_tiling_count %p, " -@@ -3912,9 +3922,9 @@ static void STDMETHODCALLTYPE d3d12_device_GetResourceTiling(ID3D12Device1 *ifac - sub_resource_tiling_count, first_sub_resource_tiling, sub_resource_tilings); - } - --static LUID * STDMETHODCALLTYPE d3d12_device_GetAdapterLuid(ID3D12Device1 *iface, LUID *luid) -+static LUID * STDMETHODCALLTYPE d3d12_device_GetAdapterLuid(ID3D12Device5 *iface, LUID *luid) - { -- struct d3d12_device *device = impl_from_ID3D12Device1(iface); -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); - - TRACE("iface %p, luid %p.\n", iface, luid); - -@@ -3923,7 +3933,7 @@ static LUID * STDMETHODCALLTYPE d3d12_device_GetAdapterLuid(ID3D12Device1 *iface - return luid; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePipelineLibrary(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePipelineLibrary(ID3D12Device5 *iface, - const void *blob, SIZE_T blob_size, REFIID iid, void **lib) - { - FIXME("iface %p, blob %p, blob_size %lu, iid %s, lib %p stub!\n", iface, blob, blob_size, debugstr_guid(iid), lib); -@@ -3931,7 +3941,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePipelineLibrary(ID3D12Device - return DXGI_ERROR_UNSUPPORTED; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetEventOnMultipleFenceCompletion(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetEventOnMultipleFenceCompletion(ID3D12Device5 *iface, - ID3D12Fence *const *fences, const UINT64 *values, UINT fence_count, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS flags, HANDLE event) - { -@@ -3941,7 +3951,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_SetEventOnMultipleFenceCompletion( - return E_NOTIMPL; - } - --static HRESULT STDMETHODCALLTYPE d3d12_device_SetResidencyPriority(ID3D12Device1 *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_device_SetResidencyPriority(ID3D12Device5 *iface, - UINT object_count, ID3D12Pageable *const *objects, const D3D12_RESIDENCY_PRIORITY *priorities) - { - FIXME_ONCE("iface %p, object_count %u, objects %p, priorities %p stub!\n", iface, object_count, objects, priorities); -@@ -3949,7 +3959,204 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_SetResidencyPriority(ID3D12Device1 - return S_OK; - } - --static const struct ID3D12Device1Vtbl d3d12_device_vtbl = -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePipelineState(ID3D12Device5 *iface, -+ const D3D12_PIPELINE_STATE_STREAM_DESC *desc, REFIID iid, void **pipeline_state) -+{ -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); -+ struct d3d12_pipeline_state *object; -+ HRESULT hr; -+ -+ TRACE("iface %p, desc %p, iid %s, pipeline_state %p.\n", iface, desc, debugstr_guid(iid), pipeline_state); -+ -+ if (FAILED(hr = d3d12_pipeline_state_create(device, desc, &object))) -+ return hr; -+ -+ return return_interface(&object->ID3D12PipelineState_iface, &IID_ID3D12PipelineState, iid, pipeline_state); -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_OpenExistingHeapFromAddress(ID3D12Device5 *iface, -+ const void *address, REFIID iid, void **heap) -+{ -+ FIXME("iface %p, address %p, iid %s, heap %p stub!\n", iface, address, debugstr_guid(iid), heap); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_OpenExistingHeapFromFileMapping(ID3D12Device5 *iface, -+ HANDLE file_mapping, REFIID iid, void **heap) -+{ -+ FIXME("iface %p, file_mapping %p, iid %s, heap %p stub!\n", iface, file_mapping, debugstr_guid(iid), heap); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_EnqueueMakeResident(ID3D12Device5 *iface, -+ D3D12_RESIDENCY_FLAGS flags, UINT num_objects, ID3D12Pageable *const *objects, -+ ID3D12Fence *fence, UINT64 fence_value) -+{ -+ FIXME("iface %p, flags %#x, num_objects %u, objects %p, fence %p, fence_value %#"PRIx64" stub!\n", -+ iface, flags, num_objects, objects, fence, fence_value); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandList1(ID3D12Device5 *iface, -+ UINT node_mask, D3D12_COMMAND_LIST_TYPE type, D3D12_COMMAND_LIST_FLAGS flags, -+ REFIID iid, void **command_list) -+{ -+ FIXME("iface %p, node_mask 0x%08x, type %#x, flags %#x, iid %s, command_list %p stub!\n", -+ iface, node_mask, type, flags, debugstr_guid(iid), command_list); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateProtectedResourceSession(ID3D12Device5 *iface, -+ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *desc, REFIID iid, void **session) -+{ -+ FIXME("iface %p, desc %p, iid %s, session %p stub!\n", iface, desc, debugstr_guid(iid), session); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommittedResource1(ID3D12Device5 *iface, -+ 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, -+ ID3D12ProtectedResourceSession *protected_session, REFIID iid, void **resource) -+{ -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); -+ struct d3d12_resource *object; -+ HRESULT hr; -+ -+ TRACE("iface %p, heap_properties %p, heap_flags %#x, desc %p, initial_state %#x, " -+ "optimized_clear_value %p, protected_session %p, iid %s, resource %p.\n", -+ iface, heap_properties, heap_flags, desc, initial_state, -+ optimized_clear_value, protected_session, debugstr_guid(iid), resource); -+ -+ if (FAILED(hr = d3d12_committed_resource_create(device, heap_properties, heap_flags, -+ desc, initial_state, optimized_clear_value, protected_session, &object))) -+ { -+ *resource = NULL; -+ return hr; -+ } -+ -+ return return_interface(&object->ID3D12Resource1_iface, &IID_ID3D12Resource1, iid, resource); -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateHeap1(ID3D12Device5 *iface, -+ const D3D12_HEAP_DESC *desc, ID3D12ProtectedResourceSession *protected_session, -+ REFIID iid, void **heap) -+{ -+ struct d3d12_device *device = impl_from_ID3D12Device5(iface); -+ struct d3d12_heap *object; -+ HRESULT hr; -+ -+ TRACE("iface %p, desc %p, protected_session %p, iid %s, heap %p.\n", -+ iface, desc, protected_session, debugstr_guid(iid), heap); -+ -+ if (FAILED(hr = d3d12_heap_create(device, desc, NULL, protected_session, &object))) -+ { -+ *heap = NULL; -+ return hr; -+ } -+ -+ return return_interface(&object->ID3D12Heap_iface, &IID_ID3D12Heap, iid, heap); -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateReservedResource1(ID3D12Device5 *iface, -+ const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, -+ const D3D12_CLEAR_VALUE *optimized_clear_value, -+ ID3D12ProtectedResourceSession *protected_session, REFIID iid, void **resource) -+{ -+ FIXME("iface %p, desc %p, initial_state %#x, optimized_clear_value %p, " -+ "protected_session %p, iid %s, resource %p stub!\n", -+ iface, desc, initial_state, optimized_clear_value, protected_session, -+ debugstr_guid(iid), resource); -+ -+ return E_NOTIMPL; -+} -+ -+static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResourceAllocationInfo1( -+ ID3D12Device5 *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, -+ UINT count, const D3D12_RESOURCE_DESC *resource_descs, -+ D3D12_RESOURCE_ALLOCATION_INFO1 *info1) -+{ -+ FIXME("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p, info1 %p stub!\n", -+ iface, info, visible_mask, count, resource_descs, info1); -+ -+ return info; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateLifetimeTracker(ID3D12Device5 *iface, -+ ID3D12LifetimeOwner *owner, REFIID iid, void **tracker) -+{ -+ FIXME("iface %p, owner %p, iid %s, tracker %p stub!\n", iface, owner, debugstr_guid(iid), tracker); -+ -+ return E_NOTIMPL; -+} -+ -+static void STDMETHODCALLTYPE d3d12_device_RemoveDevice(ID3D12Device5 *iface) -+{ -+ FIXME("iface %p stub!\n", iface); -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_EnumerateMetaCommands(ID3D12Device5 *iface, -+ UINT *num_meta_commands, D3D12_META_COMMAND_DESC *command_desc) -+{ -+ FIXME("iface %p, num_meta_commands %p, command_desc %p stub!\n", iface, -+ num_meta_commands, command_desc); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_EnumerateMetaCommandParameters(ID3D12Device5 *iface, -+ REFGUID command_id, D3D12_META_COMMAND_PARAMETER_STAGE stage, -+ UINT *size_in_bytes, UINT *parameter_count, -+ D3D12_META_COMMAND_PARAMETER_DESC *parameter_desc) -+{ -+ FIXME("iface %p, command_id %s, stage %u, size_in_bytes %p, " -+ "parameter_count %p, parameter_desc %p stub!\n", iface, -+ debugstr_guid(command_id), stage, size_in_bytes, parameter_count, parameter_desc); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateMetaCommand(ID3D12Device5 *iface, -+ REFGUID command_id, UINT node_mask, const void *parameters_data, -+ SIZE_T data_size_in_bytes, REFIID iid, void **meta_command) -+{ -+ FIXME("iface %p, command_id %s, node_mask %#x, parameters_data %p, " -+ "data_size_in_bytes %lu, iid %s, meta_command %p stub!\n", iface, -+ debugstr_guid(command_id), node_mask, parameters_data, -+ data_size_in_bytes, debugstr_guid(iid), meta_command); -+ -+ return E_NOTIMPL; -+} -+ -+static HRESULT STDMETHODCALLTYPE d3d12_device_CreateStateObject(ID3D12Device5 *iface, -+ const D3D12_STATE_OBJECT_DESC *desc, REFIID iid, void **state_object) -+{ -+ FIXME("iface %p, desc %p, iid %s, state_object %p stub!\n", iface, desc, debugstr_guid(iid), state_object); -+ -+ return E_NOTIMPL; -+} -+ -+static void STDMETHODCALLTYPE d3d12_device_GetRaytracingAccelerationStructurePrebuildInfo(ID3D12Device5 *iface, -+ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *desc, -+ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *info) -+{ -+ FIXME("iface %p, desc %p, info %p stub!\n", iface, desc, info); -+} -+ -+static D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE d3d12_device_CheckDriverMatchingIdentifier(ID3D12Device5 *iface, -+ D3D12_SERIALIZED_DATA_TYPE data_type, const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *identifier) -+{ -+ FIXME("iface %p, data_type %u, identifier %p stub!\n", iface, data_type, identifier); -+ -+ return D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED; -+} -+ -+static const struct ID3D12Device5Vtbl d3d12_device_vtbl = - { - /* IUnknown methods */ - d3d12_device_QueryInterface, -@@ -4002,14 +4209,36 @@ static const struct ID3D12Device1Vtbl d3d12_device_vtbl = - d3d12_device_CreatePipelineLibrary, - d3d12_device_SetEventOnMultipleFenceCompletion, - d3d12_device_SetResidencyPriority, -+ /* ID3D12Device2 methods */ -+ d3d12_device_CreatePipelineState, -+ /* ID3D12Device3 methods */ -+ d3d12_device_OpenExistingHeapFromAddress, -+ d3d12_device_OpenExistingHeapFromFileMapping, -+ d3d12_device_EnqueueMakeResident, -+ /* ID3D12Device4 methods */ -+ d3d12_device_CreateCommandList1, -+ d3d12_device_CreateProtectedResourceSession, -+ d3d12_device_CreateCommittedResource1, -+ d3d12_device_CreateHeap1, -+ d3d12_device_CreateReservedResource1, -+ d3d12_device_GetResourceAllocationInfo1, -+ /* ID3D12Device5 methods */ -+ d3d12_device_CreateLifetimeTracker, -+ d3d12_device_RemoveDevice, -+ d3d12_device_EnumerateMetaCommands, -+ d3d12_device_EnumerateMetaCommandParameters, -+ d3d12_device_CreateMetaCommand, -+ d3d12_device_CreateStateObject, -+ d3d12_device_GetRaytracingAccelerationStructurePrebuildInfo, -+ d3d12_device_CheckDriverMatchingIdentifier, - }; - --struct d3d12_device *unsafe_impl_from_ID3D12Device1(ID3D12Device1 *iface) -+struct d3d12_device *unsafe_impl_from_ID3D12Device5(ID3D12Device5 *iface) - { - if (!iface) - return NULL; - assert(iface->lpVtbl == &d3d12_device_vtbl); -- return impl_from_ID3D12Device1(iface); -+ return impl_from_ID3D12Device5(iface); - } - - static HRESULT d3d12_device_init(struct d3d12_device *device, -@@ -4018,7 +4247,7 @@ static HRESULT d3d12_device_init(struct d3d12_device *device, - const struct vkd3d_vk_device_procs *vk_procs; - HRESULT hr; - -- device->ID3D12Device1_iface.lpVtbl = &d3d12_device_vtbl; -+ device->ID3D12Device5_iface.lpVtbl = &d3d12_device_vtbl; - device->refcount = 1; - - vkd3d_instance_incref(device->vkd3d_instance = instance); -@@ -4215,28 +4444,28 @@ HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_ha - - IUnknown *vkd3d_get_device_parent(ID3D12Device *device) - { -- struct d3d12_device *d3d12_device = impl_from_ID3D12Device1((ID3D12Device1 *)device); -+ struct d3d12_device *d3d12_device = impl_from_ID3D12Device5((ID3D12Device5 *)device); - - return d3d12_device->parent; - } - - VkDevice vkd3d_get_vk_device(ID3D12Device *device) - { -- struct d3d12_device *d3d12_device = impl_from_ID3D12Device1((ID3D12Device1 *)device); -+ struct d3d12_device *d3d12_device = impl_from_ID3D12Device5((ID3D12Device5 *)device); - - return d3d12_device->vk_device; - } - - VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device) - { -- struct d3d12_device *d3d12_device = impl_from_ID3D12Device1((ID3D12Device1 *)device); -+ struct d3d12_device *d3d12_device = impl_from_ID3D12Device5((ID3D12Device5 *)device); - - return d3d12_device->vk_physical_device; - } - - struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device) - { -- struct d3d12_device *d3d12_device = impl_from_ID3D12Device1((ID3D12Device1 *)device); -+ struct d3d12_device *d3d12_device = impl_from_ID3D12Device5((ID3D12Device5 *)device); - - return d3d12_device->vkd3d_instance; - } -diff --git a/libs/vkd3d/libs/vkd3d/resource.c b/libs/vkd3d/libs/vkd3d/resource.c -index f3842958d96..abbdfbe2015 100644 ---- a/libs/vkd3d/libs/vkd3d/resource.c -+++ b/libs/vkd3d/libs/vkd3d/resource.c -@@ -574,11 +574,15 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, - } - - HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, -- const struct d3d12_resource *resource, struct d3d12_heap **heap) -+ const struct d3d12_resource *resource, ID3D12ProtectedResourceSession *protected_session, -+ struct d3d12_heap **heap) - { - struct d3d12_heap *object; - HRESULT hr; - -+ if (protected_session) -+ FIXME("Protected session is not supported.\n"); -+ - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - -@@ -1254,12 +1258,13 @@ static bool d3d12_resource_init_tiles(struct d3d12_resource *resource, struct d3 - } - - /* ID3D12Resource */ --static HRESULT STDMETHODCALLTYPE d3d12_resource_QueryInterface(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_QueryInterface(ID3D12Resource1 *iface, - REFIID riid, void **object) - { - TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object); - -- if (IsEqualGUID(riid, &IID_ID3D12Resource) -+ if (IsEqualGUID(riid, &IID_ID3D12Resource1) -+ || IsEqualGUID(riid, &IID_ID3D12Resource) - || IsEqualGUID(riid, &IID_ID3D12Pageable) - || IsEqualGUID(riid, &IID_ID3D12DeviceChild) - || IsEqualGUID(riid, &IID_ID3D12Object) -@@ -1276,9 +1281,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_QueryInterface(ID3D12Resource *i - return E_NOINTERFACE; - } - --static ULONG STDMETHODCALLTYPE d3d12_resource_AddRef(ID3D12Resource *iface) -+static ULONG STDMETHODCALLTYPE d3d12_resource_AddRef(ID3D12Resource1 *iface) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - ULONG refcount = InterlockedIncrement(&resource->refcount); - - TRACE("%p increasing refcount to %u.\n", resource, refcount); -@@ -1294,9 +1299,9 @@ static ULONG STDMETHODCALLTYPE d3d12_resource_AddRef(ID3D12Resource *iface) - return refcount; - } - --static ULONG STDMETHODCALLTYPE d3d12_resource_Release(ID3D12Resource *iface) -+static ULONG STDMETHODCALLTYPE d3d12_resource_Release(ID3D12Resource1 *iface) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - ULONG refcount = InterlockedDecrement(&resource->refcount); - - TRACE("%p decreasing refcount to %u.\n", resource, refcount); -@@ -1313,39 +1318,39 @@ static ULONG STDMETHODCALLTYPE d3d12_resource_Release(ID3D12Resource *iface) - return refcount; - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_GetPrivateData(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_GetPrivateData(ID3D12Resource1 *iface, - REFGUID guid, UINT *data_size, void *data) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_get_private_data(&resource->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_SetPrivateData(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_SetPrivateData(ID3D12Resource1 *iface, - REFGUID guid, UINT data_size, const void *data) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_set_private_data(&resource->private_store, guid, data_size, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_SetPrivateDataInterface(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_SetPrivateDataInterface(ID3D12Resource1 *iface, - REFGUID guid, const IUnknown *data) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data); - - return vkd3d_set_private_data_interface(&resource->private_store, guid, data); - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_SetName(ID3D12Resource *iface, const WCHAR *name) -+static HRESULT STDMETHODCALLTYPE d3d12_resource_SetName(ID3D12Resource1 *iface, const WCHAR *name) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - HRESULT hr; - - TRACE("iface %p, name %s.\n", iface, debugstr_w(name, resource->device->wchar_size)); -@@ -1364,9 +1369,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_SetName(ID3D12Resource *iface, c - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, name); - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_GetDevice(ID3D12Resource *iface, REFIID iid, void **device) -+static HRESULT STDMETHODCALLTYPE d3d12_resource_GetDevice(ID3D12Resource1 *iface, REFIID iid, void **device) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p, iid %s, device %p.\n", iface, debugstr_guid(iid), device); - -@@ -1417,10 +1422,10 @@ static void d3d12_resource_flush(struct d3d12_resource *resource, uint64_t offse - ERR("Failed to flush memory, vr %d.\n", vr); - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_Map(ID3D12Resource *iface, UINT sub_resource, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_Map(ID3D12Resource1 *iface, UINT sub_resource, - const D3D12_RANGE *read_range, void **data) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - unsigned int sub_resource_count; - - TRACE("iface %p, sub_resource %u, read_range %p, data %p.\n", -@@ -1466,10 +1471,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_Map(ID3D12Resource *iface, UINT - return S_OK; - } - --static void STDMETHODCALLTYPE d3d12_resource_Unmap(ID3D12Resource *iface, UINT sub_resource, -+static void STDMETHODCALLTYPE d3d12_resource_Unmap(ID3D12Resource1 *iface, UINT sub_resource, - const D3D12_RANGE *written_range) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - unsigned int sub_resource_count; - - TRACE("iface %p, sub_resource %u, written_range %p.\n", -@@ -1488,10 +1493,10 @@ static void STDMETHODCALLTYPE d3d12_resource_Unmap(ID3D12Resource *iface, UINT s - d3d12_resource_flush(resource, written_range->Begin, written_range->End - written_range->Begin); - } - --static D3D12_RESOURCE_DESC * STDMETHODCALLTYPE d3d12_resource_GetDesc(ID3D12Resource *iface, -+static D3D12_RESOURCE_DESC * STDMETHODCALLTYPE d3d12_resource_GetDesc(ID3D12Resource1 *iface, - D3D12_RESOURCE_DESC *resource_desc) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p, resource_desc %p.\n", iface, resource_desc); - -@@ -1499,20 +1504,20 @@ static D3D12_RESOURCE_DESC * STDMETHODCALLTYPE d3d12_resource_GetDesc(ID3D12Reso - return resource_desc; - } - --static D3D12_GPU_VIRTUAL_ADDRESS STDMETHODCALLTYPE d3d12_resource_GetGPUVirtualAddress(ID3D12Resource *iface) -+static D3D12_GPU_VIRTUAL_ADDRESS STDMETHODCALLTYPE d3d12_resource_GetGPUVirtualAddress(ID3D12Resource1 *iface) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - - TRACE("iface %p.\n", iface); - - return resource->gpu_address; - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_WriteToSubresource(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_WriteToSubresource(ID3D12Resource1 *iface, - UINT dst_sub_resource, const D3D12_BOX *dst_box, const void *src_data, - UINT src_row_pitch, UINT src_slice_pitch) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - const struct vkd3d_vk_device_procs *vk_procs; - VkImageSubresource vk_sub_resource; - const struct vkd3d_format *format; -@@ -1593,11 +1598,11 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_WriteToSubresource(ID3D12Resourc - return S_OK; - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(ID3D12Resource1 *iface, - void *dst_data, UINT dst_row_pitch, UINT dst_slice_pitch, - UINT src_sub_resource, const D3D12_BOX *src_box) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - const struct vkd3d_vk_device_procs *vk_procs; - VkImageSubresource vk_sub_resource; - const struct vkd3d_format *format; -@@ -1678,10 +1683,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(ID3D12Resour - return S_OK; - } - --static HRESULT STDMETHODCALLTYPE d3d12_resource_GetHeapProperties(ID3D12Resource *iface, -+static HRESULT STDMETHODCALLTYPE d3d12_resource_GetHeapProperties(ID3D12Resource1 *iface, - D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS *flags) - { -- struct d3d12_resource *resource = impl_from_ID3D12Resource(iface); -+ struct d3d12_resource *resource = impl_from_ID3D12Resource1(iface); - struct d3d12_heap *heap; - - TRACE("iface %p, heap_properties %p, flags %p.\n", -@@ -1715,7 +1720,15 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_GetHeapProperties(ID3D12Resource - return S_OK; - } - --static const struct ID3D12ResourceVtbl d3d12_resource_vtbl = -+static HRESULT STDMETHODCALLTYPE d3d12_resource_GetProtectedResourceSession(ID3D12Resource1 *iface, -+ REFIID iid, void **session) -+{ -+ FIXME("iface %p, iid %s, session %p stub!\n", iface, debugstr_guid(iid), session); -+ -+ return E_NOTIMPL; -+} -+ -+static const struct ID3D12Resource1Vtbl d3d12_resource_vtbl = - { - /* IUnknown methods */ - d3d12_resource_QueryInterface, -@@ -1736,13 +1749,15 @@ static const struct ID3D12ResourceVtbl d3d12_resource_vtbl = - d3d12_resource_WriteToSubresource, - d3d12_resource_ReadFromSubresource, - d3d12_resource_GetHeapProperties, -+ /* ID3D12Resource1 methods */ -+ d3d12_resource_GetProtectedResourceSession, - }; - - struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) - { - if (!iface) - return NULL; -- assert(iface->lpVtbl == &d3d12_resource_vtbl); -+ assert(iface->lpVtbl == (ID3D12ResourceVtbl *)&d3d12_resource_vtbl); - return impl_from_ID3D12Resource(iface); - } - -@@ -1940,7 +1955,7 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 - { - HRESULT hr; - -- resource->ID3D12Resource_iface.lpVtbl = &d3d12_resource_vtbl; -+ resource->ID3D12Resource1_iface.lpVtbl = &d3d12_resource_vtbl; - resource->refcount = 1; - resource->internal_refcount = 1; - -@@ -2064,7 +2079,7 @@ static HRESULT vkd3d_allocate_resource_memory( - heap_desc.Properties = *heap_properties; - heap_desc.Alignment = 0; - heap_desc.Flags = heap_flags; -- if (SUCCEEDED(hr = d3d12_heap_create(device, &heap_desc, resource, &resource->heap))) -+ if (SUCCEEDED(hr = d3d12_heap_create(device, &heap_desc, resource, NULL, &resource->heap))) - resource->flags |= VKD3D_RESOURCE_DEDICATED_HEAP; - return hr; - } -@@ -2072,7 +2087,8 @@ static HRESULT vkd3d_allocate_resource_memory( - 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) -+ const D3D12_CLEAR_VALUE *optimized_clear_value, ID3D12ProtectedResourceSession *protected_session, -+ struct d3d12_resource **resource) - { - struct d3d12_resource *object; - HRESULT hr; -@@ -2083,13 +2099,16 @@ HRESULT d3d12_committed_resource_create(struct d3d12_device *device, - return E_INVALIDARG; - } - -+ if (protected_session) -+ FIXME("Protected session is not supported.\n"); -+ - if (FAILED(hr = d3d12_resource_create(device, heap_properties, heap_flags, - desc, initial_state, optimized_clear_value, &object))) - return hr; - - if (FAILED(hr = vkd3d_allocate_resource_memory(device, object, heap_properties, heap_flags))) - { -- d3d12_resource_Release(&object->ID3D12Resource_iface); -+ d3d12_resource_Release(&object->ID3D12Resource1_iface); - return hr; - } - -@@ -2182,7 +2201,7 @@ HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_h - - if (FAILED(hr = vkd3d_bind_heap_memory(device, object, heap, heap_offset))) - { -- d3d12_resource_Release(&object->ID3D12Resource_iface); -+ d3d12_resource_Release(&object->ID3D12Resource1_iface); - return hr; - } - -@@ -2206,7 +2225,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, - - if (!d3d12_resource_init_tiles(object, device)) - { -- d3d12_resource_Release(&object->ID3D12Resource_iface); -+ d3d12_resource_Release(&object->ID3D12Resource1_iface); - return E_OUTOFMEMORY; - } - -@@ -2220,7 +2239,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, - 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_ID3D12Device1((ID3D12Device1 *)device); -+ struct d3d12_device *d3d12_device = unsafe_impl_from_ID3D12Device5((ID3D12Device5 *)device); - struct d3d12_resource *object; - HRESULT hr; - -@@ -2241,7 +2260,7 @@ HRESULT vkd3d_create_image_resource(ID3D12Device *device, - - memset(object, 0, sizeof(*object)); - -- object->ID3D12Resource_iface.lpVtbl = &d3d12_resource_vtbl; -+ object->ID3D12Resource1_iface.lpVtbl = &d3d12_resource_vtbl; - object->refcount = 1; - object->internal_refcount = 1; - object->desc = create_info->desc; -@@ -2265,7 +2284,7 @@ HRESULT vkd3d_create_image_resource(ID3D12Device *device, - - TRACE("Created resource %p.\n", object); - -- *resource = &object->ID3D12Resource_iface; -+ *resource = (ID3D12Resource *)&object->ID3D12Resource1_iface; - - return S_OK; - } -@@ -2998,6 +3017,7 @@ static bool init_default_texture_view_desc(struct vkd3d_texture_view_desc *desc, - desc->components.b = VK_COMPONENT_SWIZZLE_IDENTITY; - desc->components.a = VK_COMPONENT_SWIZZLE_IDENTITY; - desc->allowed_swizzle = false; -+ desc->usage = 0; - return true; - } - -@@ -3039,6 +3059,7 @@ bool vkd3d_create_texture_view(struct d3d12_device *device, uint32_t magic, VkIm - { - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - const struct vkd3d_format *format = desc->format; -+ VkImageViewUsageCreateInfoKHR usage_desc; - struct VkImageViewCreateInfo view_desc; - VkImageView vk_view = VK_NULL_HANDLE; - struct vkd3d_view *object; -@@ -3060,6 +3081,13 @@ bool vkd3d_create_texture_view(struct d3d12_device *device, uint32_t magic, VkIm - view_desc.subresourceRange.levelCount = desc->miplevel_count; - view_desc.subresourceRange.baseArrayLayer = desc->layer_idx; - view_desc.subresourceRange.layerCount = desc->layer_count; -+ if (device->vk_info.KHR_maintenance2) -+ { -+ usage_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; -+ usage_desc.pNext = NULL; -+ usage_desc.usage = desc->usage; -+ view_desc.pNext = &usage_desc; -+ } - if ((vr = VK_CALL(vkCreateImageView(device->vk_device, &view_desc, NULL, &vk_view))) < 0) - { - WARN("Failed to create Vulkan image view, vr %d.\n", vr); -@@ -3196,6 +3224,7 @@ static void vkd3d_create_null_srv(struct d3d12_desc *descriptor, - vkd3d_desc.components.b = VK_COMPONENT_SWIZZLE_ZERO; - vkd3d_desc.components.a = VK_COMPONENT_SWIZZLE_ZERO; - vkd3d_desc.allowed_swizzle = true; -+ vkd3d_desc.usage = VK_IMAGE_USAGE_SAMPLED_BIT; - - vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_SRV, vk_image, &vkd3d_desc, &descriptor->s.u.view); - } -@@ -3268,6 +3297,7 @@ void d3d12_desc_create_srv(struct d3d12_desc *descriptor, - - vkd3d_desc.miplevel_count = VK_REMAINING_MIP_LEVELS; - vkd3d_desc.allowed_swizzle = true; -+ vkd3d_desc.usage = VK_IMAGE_USAGE_SAMPLED_BIT; - - if (desc) - { -@@ -3421,6 +3451,7 @@ static void vkd3d_create_null_uav(struct d3d12_desc *descriptor, - vkd3d_desc.components.b = VK_COMPONENT_SWIZZLE_B; - vkd3d_desc.components.a = VK_COMPONENT_SWIZZLE_A; - vkd3d_desc.allowed_swizzle = false; -+ vkd3d_desc.usage = VK_IMAGE_USAGE_STORAGE_BIT; - - vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_UAV, vk_image, &vkd3d_desc, &descriptor->s.u.view); - } -@@ -3480,6 +3511,8 @@ static void vkd3d_create_texture_uav(struct d3d12_desc *descriptor, - if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0)) - return; - -+ vkd3d_desc.usage = VK_IMAGE_USAGE_STORAGE_BIT; -+ - if (vkd3d_format_is_compressed(vkd3d_desc.format)) - { - WARN("UAVs cannot be created for compressed formats.\n"); -@@ -3747,6 +3780,8 @@ void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_dev - if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0)) - return; - -+ vkd3d_desc.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; -+ - if (vkd3d_desc.format->vk_aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT) - { - WARN("Trying to create RTV for depth/stencil format %#x.\n", vkd3d_desc.format->dxgi_format); -@@ -3847,6 +3882,8 @@ void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_dev - if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0)) - return; - -+ vkd3d_desc.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; -+ - if (!(vkd3d_desc.format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) - { - WARN("Trying to create DSV for format %#x.\n", vkd3d_desc.format->dxgi_format); -diff --git a/libs/vkd3d/libs/vkd3d/state.c b/libs/vkd3d/libs/vkd3d/state.c -index 0b92cffcde3..de0e04ea1e6 100644 ---- a/libs/vkd3d/libs/vkd3d/state.c -+++ b/libs/vkd3d/libs/vkd3d/state.c -@@ -836,7 +836,7 @@ static unsigned int vk_heap_binding_count_from_descriptor_range(const struct d3d - else - { - /* Prefer an unsupported binding count vs a zero count, because shader compilation will fail -- * to match a declaration to a zero binding, resulting in failure of pipline state creation. */ -+ * to match a declaration to a zero binding, resulting in failure of pipeline state creation. */ - return max_count + !max_count; - } - } -@@ -1736,6 +1736,189 @@ void vkd3d_render_pass_cache_cleanup(struct vkd3d_render_pass_cache *cache, - cache->render_passes = NULL; - } - -+static void d3d12_init_pipeline_state_desc(struct d3d12_pipeline_state_desc *desc) -+{ -+ D3D12_DEPTH_STENCIL_DESC1 *ds_state = &desc->depth_stencil_state; -+ D3D12_RASTERIZER_DESC *rs_state = &desc->rasterizer_state; -+ D3D12_BLEND_DESC *blend_state = &desc->blend_state; -+ DXGI_SAMPLE_DESC *sample_desc = &desc->sample_desc; -+ -+ memset(desc, 0, sizeof(*desc)); -+ ds_state->DepthEnable = TRUE; -+ ds_state->DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; -+ ds_state->DepthFunc = D3D12_COMPARISON_FUNC_LESS; -+ ds_state->StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; -+ ds_state->StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; -+ ds_state->FrontFace.StencilFunc = ds_state->BackFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS; -+ ds_state->FrontFace.StencilDepthFailOp = ds_state->BackFace.StencilDepthFailOp = D3D12_STENCIL_OP_KEEP; -+ ds_state->FrontFace.StencilPassOp = ds_state->BackFace.StencilPassOp = D3D12_STENCIL_OP_KEEP; -+ ds_state->FrontFace.StencilFailOp = ds_state->BackFace.StencilFailOp = D3D12_STENCIL_OP_KEEP; -+ -+ rs_state->FillMode = D3D12_FILL_MODE_SOLID; -+ rs_state->CullMode = D3D12_CULL_MODE_BACK; -+ rs_state->DepthClipEnable = TRUE; -+ rs_state->ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; -+ -+ blend_state->RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL; -+ -+ sample_desc->Count = 1; -+ sample_desc->Quality = 0; -+ -+ desc->sample_mask = D3D12_DEFAULT_SAMPLE_MASK; -+} -+ -+static void pipeline_state_desc_from_d3d12_graphics_desc(struct d3d12_pipeline_state_desc *desc, -+ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *d3d12_desc) -+{ -+ memset(desc, 0, sizeof(*desc)); -+ desc->root_signature = d3d12_desc->pRootSignature; -+ desc->vs = d3d12_desc->VS; -+ desc->ps = d3d12_desc->PS; -+ desc->ds = d3d12_desc->DS; -+ desc->hs = d3d12_desc->HS; -+ desc->gs = d3d12_desc->GS; -+ desc->stream_output = d3d12_desc->StreamOutput; -+ desc->blend_state = d3d12_desc->BlendState; -+ desc->sample_mask = d3d12_desc->SampleMask; -+ desc->rasterizer_state = d3d12_desc->RasterizerState; -+ memcpy(&desc->depth_stencil_state, &d3d12_desc->DepthStencilState, sizeof(d3d12_desc->DepthStencilState)); -+ desc->input_layout = d3d12_desc->InputLayout; -+ desc->strip_cut_value = d3d12_desc->IBStripCutValue; -+ desc->primitive_topology_type = d3d12_desc->PrimitiveTopologyType; -+ desc->rtv_formats.NumRenderTargets = d3d12_desc->NumRenderTargets; -+ memcpy(desc->rtv_formats.RTFormats, d3d12_desc->RTVFormats, sizeof(desc->rtv_formats.RTFormats)); -+ desc->dsv_format = d3d12_desc->DSVFormat; -+ desc->sample_desc = d3d12_desc->SampleDesc; -+ desc->node_mask = d3d12_desc->NodeMask; -+ desc->cached_pso = d3d12_desc->CachedPSO; -+ desc->flags = d3d12_desc->Flags; -+} -+ -+static void pipeline_state_desc_from_d3d12_compute_desc(struct d3d12_pipeline_state_desc *desc, -+ const D3D12_COMPUTE_PIPELINE_STATE_DESC *d3d12_desc) -+{ -+ memset(desc, 0, sizeof(*desc)); -+ desc->root_signature = d3d12_desc->pRootSignature; -+ desc->cs = d3d12_desc->CS; -+ desc->node_mask = d3d12_desc->NodeMask; -+ desc->cached_pso = d3d12_desc->CachedPSO; -+ desc->flags = d3d12_desc->Flags; -+} -+ -+static HRESULT pipeline_state_desc_from_d3d12_stream_desc(struct d3d12_pipeline_state_desc *desc, -+ const D3D12_PIPELINE_STATE_STREAM_DESC *d3d12_desc, VkPipelineBindPoint *vk_bind_point) -+{ -+ D3D12_PIPELINE_STATE_SUBOBJECT_TYPE subobject_type; -+ uint64_t defined_subobjects = 0; -+ const uint8_t *stream_ptr; -+ uint64_t subobject_bit; -+ size_t start, size, i; -+ uint8_t *desc_bytes; -+ -+ static const struct -+ { -+ size_t alignment; -+ size_t size; -+ size_t dst_offset; -+ } -+ subobject_info[] = -+ { -+#define DCL_SUBOBJECT_INFO(type, field) {__alignof__(type), sizeof(type), offsetof(struct d3d12_pipeline_state_desc, field)} -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE] = DCL_SUBOBJECT_INFO(ID3D12RootSignature *, root_signature), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, vs), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, ps), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, ds), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, hs), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, gs), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS] = DCL_SUBOBJECT_INFO(D3D12_SHADER_BYTECODE, cs), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT] = DCL_SUBOBJECT_INFO(D3D12_STREAM_OUTPUT_DESC, stream_output), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND] = DCL_SUBOBJECT_INFO(D3D12_BLEND_DESC, blend_state), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK] = DCL_SUBOBJECT_INFO(UINT, sample_mask), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER] = DCL_SUBOBJECT_INFO(D3D12_RASTERIZER_DESC, rasterizer_state), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL] = DCL_SUBOBJECT_INFO(D3D12_DEPTH_STENCIL_DESC, depth_stencil_state), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT] = DCL_SUBOBJECT_INFO(D3D12_INPUT_LAYOUT_DESC, input_layout), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE] = DCL_SUBOBJECT_INFO(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, strip_cut_value), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY] = DCL_SUBOBJECT_INFO(D3D12_PRIMITIVE_TOPOLOGY_TYPE, primitive_topology_type), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS] = DCL_SUBOBJECT_INFO(D3D12_RT_FORMAT_ARRAY, rtv_formats), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT] = DCL_SUBOBJECT_INFO(DXGI_FORMAT, dsv_format), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC] = DCL_SUBOBJECT_INFO(DXGI_SAMPLE_DESC, sample_desc), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK] = DCL_SUBOBJECT_INFO(UINT, node_mask), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO] = DCL_SUBOBJECT_INFO(D3D12_CACHED_PIPELINE_STATE, cached_pso), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS] = DCL_SUBOBJECT_INFO(D3D12_PIPELINE_STATE_FLAGS, flags), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1] = DCL_SUBOBJECT_INFO(D3D12_DEPTH_STENCIL_DESC1, depth_stencil_state), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING] = DCL_SUBOBJECT_INFO(D3D12_VIEW_INSTANCING_DESC, view_instancing_desc), -+#undef DCL_SUBOBJECT_INFO -+ }; -+ STATIC_ASSERT(ARRAY_SIZE(subobject_info) <= sizeof(defined_subobjects) * CHAR_BIT); -+ -+ /* Initialize defaults for undefined subobjects. */ -+ d3d12_init_pipeline_state_desc(desc); -+ -+ stream_ptr = d3d12_desc->pPipelineStateSubobjectStream; -+ desc_bytes = (uint8_t *)desc; -+ -+ for (i = 0; i < d3d12_desc->SizeInBytes; ) -+ { -+ if (!vkd3d_bound_range(0, sizeof(subobject_type), d3d12_desc->SizeInBytes - i)) -+ { -+ WARN("Invalid pipeline state stream.\n"); -+ return E_INVALIDARG; -+ } -+ -+ subobject_type = *(const D3D12_PIPELINE_STATE_SUBOBJECT_TYPE *)&stream_ptr[i]; -+ if (subobject_type >= ARRAY_SIZE(subobject_info)) -+ { -+ FIXME("Unhandled pipeline subobject type %#x.\n", subobject_type); -+ return E_INVALIDARG; -+ } -+ -+ subobject_bit = 1ull << subobject_type; -+ if (defined_subobjects & subobject_bit) -+ { -+ WARN("Duplicate pipeline subobject type %u.\n", subobject_type); -+ return E_INVALIDARG; -+ } -+ defined_subobjects |= subobject_bit; -+ -+ start = align(sizeof(subobject_type), subobject_info[subobject_type].alignment); -+ size = subobject_info[subobject_type].size; -+ -+ if (!vkd3d_bound_range(start, size, d3d12_desc->SizeInBytes - i)) -+ { -+ WARN("Invalid pipeline state stream.\n"); -+ return E_INVALIDARG; -+ } -+ -+ memcpy(&desc_bytes[subobject_info[subobject_type].dst_offset], &stream_ptr[i + start], size); -+ /* Stream packets are aligned to the size of pointers. */ -+ i += align(start + size, sizeof(void *)); -+ } -+ -+ /* Deduce pipeline type from specified shaders. */ -+ if (desc->vs.BytecodeLength && desc->vs.pShaderBytecode) -+ { -+ *vk_bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS; -+ } -+ else if (desc->cs.BytecodeLength && desc->cs.pShaderBytecode) -+ { -+ *vk_bind_point = VK_PIPELINE_BIND_POINT_COMPUTE; -+ } -+ else -+ { -+ WARN("Cannot deduce pipeline type from shader stages.\n"); -+ return E_INVALIDARG; -+ } -+ -+ if (desc->vs.BytecodeLength && desc->vs.pShaderBytecode -+ && desc->cs.BytecodeLength && desc->cs.pShaderBytecode) -+ { -+ WARN("Invalid combination of shader stages VS and CS.\n"); -+ return E_INVALIDARG; -+ } -+ -+ return S_OK; -+} -+ - struct vkd3d_pipeline_key - { - D3D12_PRIMITIVE_TOPOLOGY topology; -@@ -2193,7 +2376,7 @@ static HRESULT d3d12_pipeline_state_find_and_init_uav_counters(struct d3d12_pipe - } - - static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *state, -- struct d3d12_device *device, const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc) -+ struct d3d12_device *device, const struct d3d12_pipeline_state_desc *desc) - { - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - struct vkd3d_shader_interface_info shader_interface; -@@ -2208,14 +2391,14 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st - - memset(&state->uav_counters, 0, sizeof(state->uav_counters)); - -- if (!(root_signature = unsafe_impl_from_ID3D12RootSignature(desc->pRootSignature))) -+ if (!(root_signature = unsafe_impl_from_ID3D12RootSignature(desc->root_signature))) - { - WARN("Root signature is NULL.\n"); - return E_INVALIDARG; - } - - if (FAILED(hr = d3d12_pipeline_state_find_and_init_uav_counters(state, device, root_signature, -- &desc->CS, VK_SHADER_STAGE_COMPUTE_BIT))) -+ &desc->cs, VK_SHADER_STAGE_COMPUTE_BIT))) - return hr; - - memset(&target_info, 0, sizeof(target_info)); -@@ -2256,7 +2439,7 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st - - vk_pipeline_layout = state->uav_counters.vk_pipeline_layout - ? state->uav_counters.vk_pipeline_layout : root_signature->vk_pipeline_layout; -- if (FAILED(hr = vkd3d_create_compute_pipeline(device, &desc->CS, &shader_interface, -+ if (FAILED(hr = vkd3d_create_compute_pipeline(device, &desc->cs, &shader_interface, - vk_pipeline_layout, &state->u.compute.vk_pipeline))) - { - WARN("Failed to create Vulkan compute pipeline, hr %#x.\n", hr); -@@ -2280,13 +2463,16 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st - HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device, - const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) - { -+ struct d3d12_pipeline_state_desc pipeline_desc; - struct d3d12_pipeline_state *object; - HRESULT hr; - -+ pipeline_state_desc_from_d3d12_compute_desc(&pipeline_desc, desc); -+ - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - -- if (FAILED(hr = d3d12_pipeline_state_init_compute(object, device, desc))) -+ if (FAILED(hr = d3d12_pipeline_state_init_compute(object, device, &pipeline_desc))) - { - vkd3d_free(object); - return hr; -@@ -2457,7 +2643,7 @@ static void vk_stencil_op_state_from_d3d12(struct VkStencilOpState *vk_desc, - } - - static void ds_desc_from_d3d12(struct VkPipelineDepthStencilStateCreateInfo *vk_desc, -- const D3D12_DEPTH_STENCIL_DESC *d3d12_desc) -+ const D3D12_DEPTH_STENCIL_DESC1 *d3d12_desc) - { - memset(vk_desc, 0, sizeof(*vk_desc)); - vk_desc->sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; -@@ -2473,7 +2659,7 @@ static void ds_desc_from_d3d12(struct VkPipelineDepthStencilStateCreateInfo *vk_ - vk_desc->depthWriteEnable = VK_FALSE; - vk_desc->depthCompareOp = VK_COMPARE_OP_NEVER; - } -- vk_desc->depthBoundsTestEnable = VK_FALSE; -+ vk_desc->depthBoundsTestEnable = d3d12_desc->DepthBoundsTestEnable; - if ((vk_desc->stencilTestEnable = d3d12_desc->StencilEnable)) - { - vk_stencil_op_state_from_d3d12(&vk_desc->front, &d3d12_desc->FrontFace, -@@ -2738,12 +2924,12 @@ static VkLogicOp vk_logic_op_from_d3d12(D3D12_LOGIC_OP op) - } - - static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *state, -- struct d3d12_device *device, const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc) -+ struct d3d12_device *device, const struct d3d12_pipeline_state_desc *desc) - { - unsigned int ps_output_swizzle[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; - struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics; - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; -- const D3D12_STREAM_OUTPUT_DESC *so_desc = &desc->StreamOutput; -+ const D3D12_STREAM_OUTPUT_DESC *so_desc = &desc->stream_output; - VkVertexInputBindingDivisorDescriptionEXT *binding_divisor; - const struct vkd3d_vulkan_info *vk_info = &device->vk_info; - uint32_t instance_divisors[D3D12_VS_INPUT_REGISTER_COUNT]; -@@ -2787,11 +2973,11 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - } - shader_stages[] = - { -- {VK_SHADER_STAGE_VERTEX_BIT, offsetof(D3D12_GRAPHICS_PIPELINE_STATE_DESC, VS)}, -- {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, offsetof(D3D12_GRAPHICS_PIPELINE_STATE_DESC, HS)}, -- {VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, offsetof(D3D12_GRAPHICS_PIPELINE_STATE_DESC, DS)}, -- {VK_SHADER_STAGE_GEOMETRY_BIT, offsetof(D3D12_GRAPHICS_PIPELINE_STATE_DESC, GS)}, -- {VK_SHADER_STAGE_FRAGMENT_BIT, offsetof(D3D12_GRAPHICS_PIPELINE_STATE_DESC, PS)}, -+ {VK_SHADER_STAGE_VERTEX_BIT, offsetof(struct d3d12_pipeline_state_desc, vs)}, -+ {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, offsetof(struct d3d12_pipeline_state_desc, hs)}, -+ {VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, offsetof(struct d3d12_pipeline_state_desc, ds)}, -+ {VK_SHADER_STAGE_GEOMETRY_BIT, offsetof(struct d3d12_pipeline_state_desc, gs)}, -+ {VK_SHADER_STAGE_FRAGMENT_BIT, offsetof(struct d3d12_pipeline_state_desc, ps)}, - }; - - state->ID3D12PipelineState_iface.lpVtbl = &d3d12_pipeline_state_vtbl; -@@ -2802,26 +2988,26 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - - memset(&input_signature, 0, sizeof(input_signature)); - -- for (i = desc->NumRenderTargets; i < ARRAY_SIZE(desc->RTVFormats); ++i) -+ for (i = desc->rtv_formats.NumRenderTargets; i < ARRAY_SIZE(desc->rtv_formats.RTFormats); ++i) - { -- if (desc->RTVFormats[i] != DXGI_FORMAT_UNKNOWN) -+ if (desc->rtv_formats.RTFormats[i] != DXGI_FORMAT_UNKNOWN) - { - WARN("Format must be set to DXGI_FORMAT_UNKNOWN for inactive render targets.\n"); - return E_INVALIDARG; - } - } - -- if (!(root_signature = unsafe_impl_from_ID3D12RootSignature(desc->pRootSignature))) -+ if (!(root_signature = unsafe_impl_from_ID3D12RootSignature(desc->root_signature))) - { - WARN("Root signature is NULL.\n"); - return E_INVALIDARG; - } - -- sample_count = vk_samples_from_dxgi_sample_desc(&desc->SampleDesc); -- if (desc->SampleDesc.Count != 1 && desc->SampleDesc.Quality) -- WARN("Ignoring sample quality %u.\n", desc->SampleDesc.Quality); -+ sample_count = vk_samples_from_dxgi_sample_desc(&desc->sample_desc); -+ if (desc->sample_desc.Count != 1 && desc->sample_desc.Quality) -+ WARN("Ignoring sample quality %u.\n", desc->sample_desc.Quality); - -- rt_count = desc->NumRenderTargets; -+ rt_count = desc->rtv_formats.NumRenderTargets; - if (rt_count > ARRAY_SIZE(graphics->blend_attachments)) - { - FIXME("NumRenderTargets %zu > %zu, ignoring extra formats.\n", -@@ -2829,40 +3015,40 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - rt_count = ARRAY_SIZE(graphics->blend_attachments); - } - -- graphics->om_logic_op_enable = desc->BlendState.RenderTarget[0].LogicOpEnable -+ graphics->om_logic_op_enable = desc->blend_state.RenderTarget[0].LogicOpEnable - && device->feature_options.OutputMergerLogicOp; - graphics->om_logic_op = graphics->om_logic_op_enable -- ? vk_logic_op_from_d3d12(desc->BlendState.RenderTarget[0].LogicOp) -+ ? vk_logic_op_from_d3d12(desc->blend_state.RenderTarget[0].LogicOp) - : VK_LOGIC_OP_COPY; -- if (desc->BlendState.RenderTarget[0].LogicOpEnable && !graphics->om_logic_op_enable) -+ if (desc->blend_state.RenderTarget[0].LogicOpEnable && !graphics->om_logic_op_enable) - WARN("The device does not support output merger logic ops. Ignoring logic op %#x.\n", -- desc->BlendState.RenderTarget[0].LogicOp); -+ desc->blend_state.RenderTarget[0].LogicOp); - - graphics->null_attachment_mask = 0; - for (i = 0; i < rt_count; ++i) - { - const D3D12_RENDER_TARGET_BLEND_DESC *rt_desc; - -- if (desc->RTVFormats[i] == DXGI_FORMAT_UNKNOWN) -+ if (desc->rtv_formats.RTFormats[i] == DXGI_FORMAT_UNKNOWN) - { - graphics->null_attachment_mask |= 1u << i; - ps_output_swizzle[i] = VKD3D_SHADER_NO_SWIZZLE; - graphics->rtv_formats[i] = VK_FORMAT_UNDEFINED; - } -- else if ((format = vkd3d_get_format(device, desc->RTVFormats[i], false))) -+ else if ((format = vkd3d_get_format(device, desc->rtv_formats.RTFormats[i], false))) - { - ps_output_swizzle[i] = vkd3d_get_rt_format_swizzle(format); - graphics->rtv_formats[i] = format->vk_format; - } - else - { -- WARN("Invalid RTV format %#x.\n", desc->RTVFormats[i]); -+ WARN("Invalid RTV format %#x.\n", desc->rtv_formats.RTFormats[i]); - hr = E_INVALIDARG; - goto fail; - } - -- rt_desc = &desc->BlendState.RenderTarget[desc->BlendState.IndependentBlendEnable ? i : 0]; -- if (desc->BlendState.IndependentBlendEnable && rt_desc->LogicOpEnable) -+ rt_desc = &desc->blend_state.RenderTarget[desc->blend_state.IndependentBlendEnable ? i : 0]; -+ if (desc->blend_state.IndependentBlendEnable && rt_desc->LogicOpEnable) - { - WARN("IndependentBlendEnable must be FALSE when logic operations are enabled.\n"); - hr = E_INVALIDARG; -@@ -2881,8 +3067,14 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - graphics->rtv_formats[i] = VK_FORMAT_UNDEFINED; - graphics->rt_count = rt_count; - -- ds_desc_from_d3d12(&graphics->ds_desc, &desc->DepthStencilState); -- if (desc->DSVFormat == DXGI_FORMAT_UNKNOWN -+ ds_desc_from_d3d12(&graphics->ds_desc, &desc->depth_stencil_state); -+ if (graphics->ds_desc.depthBoundsTestEnable && !device->feature_options2.DepthBoundsTestSupported) -+ { -+ WARN("Depth bounds test not supported by device.\n"); -+ hr = E_INVALIDARG; -+ goto fail; -+ } -+ if (desc->dsv_format == DXGI_FORMAT_UNKNOWN - && graphics->ds_desc.depthTestEnable && !graphics->ds_desc.depthWriteEnable - && graphics->ds_desc.depthCompareOp == VK_COMPARE_OP_ALWAYS && !graphics->ds_desc.stencilTestEnable) - { -@@ -2891,15 +3083,16 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - } - - graphics->dsv_format = VK_FORMAT_UNDEFINED; -- if (graphics->ds_desc.depthTestEnable || graphics->ds_desc.stencilTestEnable) -+ if (graphics->ds_desc.depthTestEnable || graphics->ds_desc.stencilTestEnable -+ || graphics->ds_desc.depthBoundsTestEnable) - { -- if (desc->DSVFormat == DXGI_FORMAT_UNKNOWN) -+ if (desc->dsv_format == DXGI_FORMAT_UNKNOWN) - { - WARN("DSV format is DXGI_FORMAT_UNKNOWN.\n"); - graphics->dsv_format = VK_FORMAT_UNDEFINED; - graphics->null_attachment_mask |= dsv_attachment_mask(graphics); - } -- else if ((format = vkd3d_get_format(device, desc->DSVFormat, true))) -+ else if ((format = vkd3d_get_format(device, desc->dsv_format, true))) - { - if (!(format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) - FIXME("Format %#x is not depth/stencil format.\n", format->dxgi_format); -@@ -2908,12 +3101,12 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - } - else - { -- WARN("Invalid DSV format %#x.\n", desc->DSVFormat); -+ WARN("Invalid DSV format %#x.\n", desc->dsv_format); - hr = E_INVALIDARG; - goto fail; - } - -- if (!desc->PS.pShaderBytecode) -+ if (!desc->ps.pShaderBytecode) - { - if (FAILED(hr = create_shader_stage(device, &graphics->stages[graphics->stage_count], - VK_SHADER_STAGE_FRAGMENT_BIT, &default_ps, NULL))) -@@ -2936,7 +3129,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - ps_target_info.extension_count = vk_info->shader_extension_count; - ps_target_info.parameters = ps_shader_parameters; - ps_target_info.parameter_count = ARRAY_SIZE(ps_shader_parameters); -- ps_target_info.dual_source_blending = is_dual_source_blending(&desc->BlendState.RenderTarget[0]); -+ ps_target_info.dual_source_blending = is_dual_source_blending(&desc->blend_state.RenderTarget[0]); - ps_target_info.output_swizzles = ps_output_swizzle; - ps_target_info.output_swizzle_count = rt_count; - -@@ -2946,11 +3139,11 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - hr = E_INVALIDARG; - goto fail; - } -- if (ps_target_info.dual_source_blending && desc->BlendState.IndependentBlendEnable) -+ if (ps_target_info.dual_source_blending && desc->blend_state.IndependentBlendEnable) - { -- for (i = 1; i < ARRAY_SIZE(desc->BlendState.RenderTarget); ++i) -+ for (i = 1; i < ARRAY_SIZE(desc->blend_state.RenderTarget); ++i) - { -- if (desc->BlendState.RenderTarget[i].BlendEnable) -+ if (desc->blend_state.RenderTarget[i].BlendEnable) - { - WARN("Blend enable cannot be set for render target %u when dual source blending is used.\n", i); - hr = E_INVALIDARG; -@@ -2992,9 +3185,9 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - xfb_info.buffer_strides = so_desc->pBufferStrides; - xfb_info.buffer_stride_count = so_desc->NumStrides; - -- if (desc->GS.pShaderBytecode) -+ if (desc->gs.pShaderBytecode) - xfb_stage = VK_SHADER_STAGE_GEOMETRY_BIT; -- else if (desc->DS.pShaderBytecode) -+ else if (desc->ds.pShaderBytecode) - xfb_stage = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; - else - xfb_stage = VK_SHADER_STAGE_VERTEX_BIT; -@@ -3046,7 +3239,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - - case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: - case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: -- if (desc->PrimitiveTopologyType != D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH) -+ if (desc->primitive_topology_type != D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH) - { - WARN("D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH must be used with tessellation shaders.\n"); - hr = E_INVALIDARG; -@@ -3088,7 +3281,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - ++graphics->stage_count; - } - -- graphics->attribute_count = desc->InputLayout.NumElements; -+ graphics->attribute_count = desc->input_layout.NumElements; - if (graphics->attribute_count > ARRAY_SIZE(graphics->attributes)) - { - FIXME("InputLayout.NumElements %zu > %zu, ignoring extra elements.\n", -@@ -3104,13 +3297,13 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - goto fail; - } - -- if (FAILED(hr = compute_input_layout_offsets(device, &desc->InputLayout, aligned_offsets))) -+ if (FAILED(hr = compute_input_layout_offsets(device, &desc->input_layout, aligned_offsets))) - goto fail; - - graphics->instance_divisor_count = 0; - for (i = 0, j = 0, mask = 0; i < graphics->attribute_count; ++i) - { -- const D3D12_INPUT_ELEMENT_DESC *e = &desc->InputLayout.pInputElementDescs[i]; -+ const D3D12_INPUT_ELEMENT_DESC *e = &desc->input_layout.pInputElementDescs[i]; - const struct vkd3d_shader_signature_element *signature_element; - - /* TODO: DXGI_FORMAT_UNKNOWN will succeed here, which may not match -@@ -3194,30 +3387,30 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - graphics->attribute_count = j; - vkd3d_shader_free_shader_signature(&input_signature); - -- switch (desc->IBStripCutValue) -+ switch (desc->strip_cut_value) - { - case D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED: - case D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF: - case D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF: -- graphics->index_buffer_strip_cut_value = desc->IBStripCutValue; -+ graphics->index_buffer_strip_cut_value = desc->strip_cut_value; - break; - default: -- WARN("Invalid index buffer strip cut value %#x.\n", desc->IBStripCutValue); -+ WARN("Invalid index buffer strip cut value %#x.\n", desc->strip_cut_value); - hr = E_INVALIDARG; - goto fail; - } - - is_dsv_format_unknown = graphics->null_attachment_mask & dsv_attachment_mask(graphics); - -- rs_desc_from_d3d12(&graphics->rs_desc, &desc->RasterizerState); -+ rs_desc_from_d3d12(&graphics->rs_desc, &desc->rasterizer_state); - have_attachment = graphics->rt_count || graphics->dsv_format || is_dsv_format_unknown; -- if ((!have_attachment && !(desc->PS.pShaderBytecode && desc->PS.BytecodeLength)) -+ if ((!have_attachment && !(desc->ps.pShaderBytecode && desc->ps.BytecodeLength)) - || (graphics->xfb_enabled && so_desc->RasterizedStream == D3D12_SO_NO_RASTERIZED_STREAM)) - graphics->rs_desc.rasterizerDiscardEnable = VK_TRUE; - - rs_stream_info_from_d3d12(&graphics->rs_stream_info, &graphics->rs_desc, so_desc, vk_info); - if (vk_info->EXT_depth_clip_enable) -- rs_depth_clip_info_from_d3d12(&graphics->rs_depth_clip_info, &graphics->rs_desc, &desc->RasterizerState); -+ rs_depth_clip_info_from_d3d12(&graphics->rs_depth_clip_info, &graphics->rs_desc, &desc->rasterizer_state); - - graphics->ms_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - graphics->ms_desc.pNext = NULL; -@@ -3226,17 +3419,24 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s - graphics->ms_desc.sampleShadingEnable = VK_FALSE; - graphics->ms_desc.minSampleShading = 0.0f; - graphics->ms_desc.pSampleMask = NULL; -- if (desc->SampleMask != ~0u) -+ if (desc->sample_mask != ~0u) - { - assert(DIV_ROUND_UP(sample_count, 32) <= ARRAY_SIZE(graphics->sample_mask)); -- graphics->sample_mask[0] = desc->SampleMask; -+ graphics->sample_mask[0] = desc->sample_mask; - graphics->sample_mask[1] = 0xffffffffu; - graphics->ms_desc.pSampleMask = graphics->sample_mask; - } -- graphics->ms_desc.alphaToCoverageEnable = desc->BlendState.AlphaToCoverageEnable; -+ graphics->ms_desc.alphaToCoverageEnable = desc->blend_state.AlphaToCoverageEnable; - graphics->ms_desc.alphaToOneEnable = VK_FALSE; - -- /* We defer creating the render pass for pipelines wth DSVFormat equal to -+ if (desc->view_instancing_desc.ViewInstanceCount) -+ { -+ FIXME("View instancing is not supported yet.\n"); -+ hr = E_INVALIDARG; -+ goto fail; -+ } -+ -+ /* We defer creating the render pass for pipelines with DSVFormat equal to - * DXGI_FORMAT_UNKNOWN. We take the actual DSV format from the bound DSV. */ - if (is_dsv_format_unknown) - graphics->render_pass = VK_NULL_HANDLE; -@@ -3271,13 +3471,16 @@ fail: - HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, - const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) - { -+ struct d3d12_pipeline_state_desc pipeline_desc; - struct d3d12_pipeline_state *object; - HRESULT hr; - -+ pipeline_state_desc_from_d3d12_graphics_desc(&pipeline_desc, desc); -+ - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - -- if (FAILED(hr = d3d12_pipeline_state_init_graphics(object, device, desc))) -+ if (FAILED(hr = d3d12_pipeline_state_init_graphics(object, device, &pipeline_desc))) - { - vkd3d_free(object); - return hr; -@@ -3290,6 +3493,46 @@ HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, - return S_OK; - } - -+HRESULT d3d12_pipeline_state_create(struct d3d12_device *device, -+ const D3D12_PIPELINE_STATE_STREAM_DESC *desc, struct d3d12_pipeline_state **state) -+{ -+ struct d3d12_pipeline_state_desc pipeline_desc; -+ struct d3d12_pipeline_state *object; -+ VkPipelineBindPoint bind_point; -+ HRESULT hr; -+ -+ if (FAILED(hr = pipeline_state_desc_from_d3d12_stream_desc(&pipeline_desc, desc, &bind_point))) -+ return hr; -+ -+ if (!(object = vkd3d_calloc(1, sizeof(*object)))) -+ return E_OUTOFMEMORY; -+ -+ switch (bind_point) -+ { -+ case VK_PIPELINE_BIND_POINT_COMPUTE: -+ hr = d3d12_pipeline_state_init_compute(object, device, &pipeline_desc); -+ break; -+ -+ case VK_PIPELINE_BIND_POINT_GRAPHICS: -+ hr = d3d12_pipeline_state_init_graphics(object, device, &pipeline_desc); -+ break; -+ -+ default: -+ vkd3d_unreachable(); -+ } -+ -+ if (FAILED(hr)) -+ { -+ vkd3d_free(object); -+ return hr; -+ } -+ -+ TRACE("Created pipeline state %p.\n", object); -+ -+ *state = object; -+ return S_OK; -+} -+ - static enum VkPrimitiveTopology vk_topology_from_d3d12_topology(D3D12_PRIMITIVE_TOPOLOGY topology) - { - switch (topology) -@@ -3605,6 +3848,36 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta - return vk_pipeline; - } - -+static int compile_hlsl_cs(const struct vkd3d_shader_code *hlsl, struct vkd3d_shader_code *dxbc) -+{ -+ struct vkd3d_shader_hlsl_source_info hlsl_info; -+ struct vkd3d_shader_compile_info info; -+ -+ static const struct vkd3d_shader_compile_option options[] = -+ { -+ {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_9}, -+ }; -+ -+ info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; -+ info.next = &hlsl_info; -+ info.source = *hlsl; -+ info.source_type = VKD3D_SHADER_SOURCE_HLSL; -+ info.target_type = VKD3D_SHADER_TARGET_DXBC_TPF; -+ info.options = options; -+ info.option_count = ARRAY_SIZE(options); -+ info.log_level = VKD3D_SHADER_LOG_NONE; -+ info.source_name = NULL; -+ -+ hlsl_info.type = VKD3D_SHADER_STRUCTURE_TYPE_HLSL_SOURCE_INFO; -+ hlsl_info.next = NULL; -+ hlsl_info.entry_point = "main"; -+ hlsl_info.secondary_code.code = NULL; -+ hlsl_info.secondary_code.size = 0; -+ hlsl_info.profile = "cs_5_0"; -+ -+ return vkd3d_shader_compile(&info, dxbc, NULL); -+} -+ - static void vkd3d_uav_clear_pipelines_cleanup(struct vkd3d_uav_clear_pipelines *pipelines, - struct d3d12_device *device) - { -@@ -3658,7 +3931,7 @@ HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d - { - VkPipeline *pipeline; - VkPipelineLayout *pipeline_layout; -- D3D12_SHADER_BYTECODE code; -+ struct vkd3d_shader_code code; - } - pipelines[] = - { -@@ -3748,13 +4021,25 @@ HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d - - for (i = 0; i < ARRAY_SIZE(pipelines); ++i) - { -+ struct vkd3d_shader_code dxbc; -+ int ret; -+ -+ if ((ret = compile_hlsl_cs(&pipelines[i].code, &dxbc))) -+ { -+ ERR("Failed to compile HLSL compute shader %u, ret %d.\n", i, ret); -+ hr = hresult_from_vk_result(ret); -+ goto fail; -+ } -+ - if (pipelines[i].pipeline_layout == &state->vk_pipeline_layout_buffer) - binding.flags = VKD3D_SHADER_BINDING_FLAG_BUFFER; - else - binding.flags = VKD3D_SHADER_BINDING_FLAG_IMAGE; - -- if (FAILED(hr = vkd3d_create_compute_pipeline(device, &pipelines[i].code, &shader_interface, -- *pipelines[i].pipeline_layout, pipelines[i].pipeline))) -+ hr = vkd3d_create_compute_pipeline(device, &(D3D12_SHADER_BYTECODE){dxbc.code, dxbc.size}, -+ &shader_interface, *pipelines[i].pipeline_layout, pipelines[i].pipeline); -+ vkd3d_shader_free_shader_code(&dxbc); -+ if (FAILED(hr)) - { - ERR("Failed to create compute pipeline %u, hr %#x.\n", i, hr); - goto fail; -diff --git a/libs/vkd3d/libs/vkd3d/vkd3d_main.c b/libs/vkd3d/libs/vkd3d/vkd3d_main.c -index 159560afd8e..245edb5aeac 100644 ---- a/libs/vkd3d/libs/vkd3d/vkd3d_main.c -+++ b/libs/vkd3d/libs/vkd3d/vkd3d_main.c -@@ -71,11 +71,11 @@ HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info, - - if (!device) - { -- ID3D12Device_Release(&object->ID3D12Device1_iface); -+ ID3D12Device_Release(&object->ID3D12Device5_iface); - return S_FALSE; - } - -- return return_interface(&object->ID3D12Device1_iface, &IID_ID3D12Device, iid, device); -+ return return_interface(&object->ID3D12Device5_iface, &IID_ID3D12Device, iid, device); - } - - /* ID3D12RootSignatureDeserializer */ -diff --git a/libs/vkd3d/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/libs/vkd3d/vkd3d_private.h -index 363a7132c3a..231bc615e5c 100644 ---- a/libs/vkd3d/libs/vkd3d/vkd3d_private.h -+++ b/libs/vkd3d/libs/vkd3d/vkd3d_private.h -@@ -22,6 +22,9 @@ - #define COBJMACROS - #define NONAMELESSUNION - #define VK_NO_PROTOTYPES -+#ifndef CONST_VTABLE -+#define CONST_VTABLE -+#endif - - #ifdef _WIN32 - # define _WIN32_WINNT 0x0600 /* for condition variables */ -@@ -31,8 +34,8 @@ - #include "vkd3d_blob.h" - #include "vkd3d_memory.h" - #include "vkd3d_utf8.h" --#include "wine/list.h" --#include "wine/rbtree.h" -+#include "list.h" -+#include "rbtree.h" - - #include "vkd3d.h" - #include "vkd3d_shader.h" -@@ -121,6 +124,7 @@ struct vkd3d_vulkan_info - bool KHR_draw_indirect_count; - bool KHR_get_memory_requirements2; - bool KHR_image_format_list; -+ bool KHR_maintenance2; - bool KHR_maintenance3; - bool KHR_push_descriptor; - bool KHR_sampler_mirror_clamp_to_edge; -@@ -680,7 +684,7 @@ 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); -+ const struct d3d12_resource *resource, ID3D12ProtectedResourceSession *protected_session, struct d3d12_heap **heap); - struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface); - - #define VKD3D_RESOURCE_PUBLIC_FLAGS \ -@@ -716,7 +720,7 @@ struct d3d12_resource_tile_info - /* ID3D12Resource */ - struct d3d12_resource - { -- ID3D12Resource ID3D12Resource_iface; -+ ID3D12Resource1 ID3D12Resource1_iface; - LONG refcount; - LONG internal_refcount; - -@@ -748,7 +752,12 @@ struct d3d12_resource - - static inline struct d3d12_resource *impl_from_ID3D12Resource(ID3D12Resource *iface) - { -- return CONTAINING_RECORD(iface, struct d3d12_resource, ID3D12Resource_iface); -+ return CONTAINING_RECORD(iface, struct d3d12_resource, ID3D12Resource1_iface); -+} -+ -+static inline struct d3d12_resource *impl_from_ID3D12Resource1(ID3D12Resource1 *iface) -+{ -+ return CONTAINING_RECORD(iface, struct d3d12_resource, ID3D12Resource1_iface); - } - - static inline bool d3d12_resource_is_buffer(const struct d3d12_resource *resource) -@@ -771,7 +780,8 @@ void d3d12_resource_get_tiling(struct d3d12_device *device, const struct d3d12_r - 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); -+ const D3D12_CLEAR_VALUE *optimized_clear_value, ID3D12ProtectedResourceSession *protected_session, -+ 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); -@@ -835,6 +845,7 @@ struct vkd3d_texture_view_desc - VkImageAspectFlags vk_image_aspect; - VkComponentMapping components; - bool allowed_swizzle; -+ VkImageUsageFlags usage; - }; - - struct vkd3d_desc_header -@@ -1090,7 +1101,7 @@ HRESULT d3d12_query_heap_create(struct d3d12_device *device, - 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. -+ * available. In D3D12 it is legal to get query results for not issued queries. - */ - static inline bool d3d12_query_heap_is_result_available(const struct d3d12_query_heap *heap, - unsigned int query_index) -@@ -1308,10 +1319,38 @@ static inline bool d3d12_pipeline_state_has_unknown_dsv_format(struct d3d12_pipe - return false; - } - -+struct d3d12_pipeline_state_desc -+{ -+ ID3D12RootSignature *root_signature; -+ D3D12_SHADER_BYTECODE vs; -+ D3D12_SHADER_BYTECODE ps; -+ D3D12_SHADER_BYTECODE ds; -+ D3D12_SHADER_BYTECODE hs; -+ D3D12_SHADER_BYTECODE gs; -+ D3D12_SHADER_BYTECODE cs; -+ D3D12_STREAM_OUTPUT_DESC stream_output; -+ D3D12_BLEND_DESC blend_state; -+ unsigned int sample_mask; -+ D3D12_RASTERIZER_DESC rasterizer_state; -+ D3D12_DEPTH_STENCIL_DESC1 depth_stencil_state; -+ D3D12_INPUT_LAYOUT_DESC input_layout; -+ D3D12_INDEX_BUFFER_STRIP_CUT_VALUE strip_cut_value; -+ D3D12_PRIMITIVE_TOPOLOGY_TYPE primitive_topology_type; -+ D3D12_RT_FORMAT_ARRAY rtv_formats; -+ DXGI_FORMAT dsv_format; -+ DXGI_SAMPLE_DESC sample_desc; -+ D3D12_VIEW_INSTANCING_DESC view_instancing_desc; -+ unsigned int node_mask; -+ D3D12_CACHED_PIPELINE_STATE cached_pso; -+ D3D12_PIPELINE_STATE_FLAGS flags; -+}; -+ - HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device, - 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); -+HRESULT d3d12_pipeline_state_create(struct d3d12_device *device, -+ const D3D12_PIPELINE_STATE_STREAM_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); - struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface); -@@ -1426,7 +1465,7 @@ enum vkd3d_pipeline_bind_point - /* ID3D12CommandList */ - struct d3d12_command_list - { -- ID3D12GraphicsCommandList3 ID3D12GraphicsCommandList3_iface; -+ ID3D12GraphicsCommandList5 ID3D12GraphicsCommandList5_iface; - LONG refcount; - - D3D12_COMMAND_LIST_TYPE type; -@@ -1709,7 +1748,7 @@ struct vkd3d_desc_object_cache - /* ID3D12Device */ - struct d3d12_device - { -- ID3D12Device1 ID3D12Device1_iface; -+ ID3D12Device5 ID3D12Device5_iface; - LONG refcount; - - VkDevice vk_device; -@@ -1775,27 +1814,27 @@ struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, D3 - 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); --struct d3d12_device *unsafe_impl_from_ID3D12Device1(ID3D12Device1 *iface); -+struct d3d12_device *unsafe_impl_from_ID3D12Device5(ID3D12Device5 *iface); - - static inline HRESULT d3d12_device_query_interface(struct d3d12_device *device, REFIID iid, void **object) - { -- return ID3D12Device1_QueryInterface(&device->ID3D12Device1_iface, iid, object); -+ return ID3D12Device5_QueryInterface(&device->ID3D12Device5_iface, iid, object); - } - - static inline ULONG d3d12_device_add_ref(struct d3d12_device *device) - { -- return ID3D12Device1_AddRef(&device->ID3D12Device1_iface); -+ return ID3D12Device5_AddRef(&device->ID3D12Device5_iface); - } - - static inline ULONG d3d12_device_release(struct d3d12_device *device) - { -- return ID3D12Device1_Release(&device->ID3D12Device1_iface); -+ return ID3D12Device5_Release(&device->ID3D12Device5_iface); - } - - static inline unsigned int d3d12_device_get_descriptor_handle_increment_size(struct d3d12_device *device, - D3D12_DESCRIPTOR_HEAP_TYPE descriptor_type) - { -- return ID3D12Device1_GetDescriptorHandleIncrementSize(&device->ID3D12Device1_iface, descriptor_type); -+ return ID3D12Device5_GetDescriptorHandleIncrementSize(&device->ID3D12Device5_iface, descriptor_type); - } - - /* utils */ -diff --git a/libs/vkd3d/libs/vkd3d/vkd3d_shaders.h b/libs/vkd3d/libs/vkd3d/vkd3d_shaders.h -index b2a90cdbf3c..3fefe0da849 100644 ---- a/libs/vkd3d/libs/vkd3d/vkd3d_shaders.h -+++ b/libs/vkd3d/libs/vkd3d/vkd3d_shaders.h -@@ -19,370 +19,208 @@ - #ifndef __VKD3D_SHADERS_H - #define __VKD3D_SHADERS_H - --static const uint32_t cs_uav_clear_buffer_float_code[] = --{ --#if 0 -- RWBuffer dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(128, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value; -- } --#endif -- 0x43425844, 0xe114ba61, 0xff6a0d0b, 0x7b25c8f4, 0xfcf7cf22, 0x00000001, 0x0000010c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000b8, 0x00050050, 0x0000002e, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400089c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, 0x00000080, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100006, 0x00000000, 0x00208e46, 0x00000000, -- 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_buffer_uint_code[] = --{ --#if 0 -- RWBuffer dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(128, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x3afd0cfd, 0x5145c166, 0x5b9f76b8, 0xa73775cd, 0x00000001, 0x0000010c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000b8, 0x00050050, 0x0000002e, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400089c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, 0x00000080, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100006, 0x00000000, 0x00208e46, 0x00000000, -- 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_1d_array_float_code[] = --{ --#if 0 -- RWTexture1DArray dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(64, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[int2(u_info.dst_offset.x + thread_id.x, thread_id.y)] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x3d73bc2d, 0x2b635f3d, 0x6bf98e92, 0xbe0aa5d9, 0x00000001, 0x0000011c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000c8, 0x00050050, 0x00000032, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400389c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020032, 0x02000068, 0x00000001, 0x0400009b, 0x00000040, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x04000036, 0x001000e2, 0x00000000, 0x00020556, 0x080000a4, 0x0011e0f2, 0x00000000, -- 0x00100e46, 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_1d_array_uint_code[] = --{ --#if 0 -- RWTexture1DArray dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(64, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[int2(u_info.dst_offset.x + thread_id.x, thread_id.y)] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x2f0ca457, 0x72068b34, 0xd9dadc2b, 0xd3178c3e, 0x00000001, 0x0000011c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000c8, 0x00050050, 0x00000032, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400389c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020032, 0x02000068, 0x00000001, 0x0400009b, 0x00000040, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x04000036, 0x001000e2, 0x00000000, 0x00020556, 0x080000a4, 0x0011e0f2, 0x00000000, -- 0x00100e46, 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_1d_float_code[] = --{ --#if 0 -- RWTexture1D dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(64, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x05266503, 0x4b97006f, 0x01a5cc63, 0xe617d0a1, 0x00000001, 0x0000010c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000b8, 0x00050050, 0x0000002e, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400109c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, 0x00000040, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100006, 0x00000000, 0x00208e46, 0x00000000, -- 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_1d_uint_code[] = --{ --#if 0 -- RWTexture1D dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(64, 1, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (thread_id.x < u_info.dst_extent.x) -- dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x19d5c8f2, 0x3ca4ac24, 0x9e258499, 0xf0463fd6, 0x00000001, 0x0000010c, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000b8, 0x00050050, 0x0000002e, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400109c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, 0x00000040, 0x00000001, 0x00000001, -- 0x07000022, 0x00100012, 0x00000000, 0x0002000a, 0x0020802a, 0x00000000, 0x00000001, 0x0304001f, -- 0x0010000a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0002000a, 0x0020800a, 0x00000000, -- 0x00000001, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100006, 0x00000000, 0x00208e46, 0x00000000, -- 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_2d_array_float_code[] = --{ --#if 0 -- RWTexture2DArray dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[int3(u_info.dst_offset.xy + thread_id.xy, thread_id.z)] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x924d2d2c, 0xb9166376, 0x99f83871, 0x8ef65025, 0x00000001, 0x00000138, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000e4, 0x00050050, 0x00000039, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400409c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020072, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x00100032, 0x00000000, 0x00020046, 0x00208046, 0x00000000, 0x00000001, -- 0x04000036, 0x001000c2, 0x00000000, 0x00020aa6, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, -- 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_2d_array_uint_code[] = --{ --#if 0 -- RWTexture2DArray dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[int3(u_info.dst_offset.xy + thread_id.xy, thread_id.z)] = u_info.clear_value; -- } --#endif -- 0x43425844, 0xa92219d4, 0xa2c5e47d, 0x0d308500, 0xf32197b4, 0x00000001, 0x00000138, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000e4, 0x00050050, 0x00000039, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400409c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020072, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x00100032, 0x00000000, 0x00020046, 0x00208046, 0x00000000, 0x00000001, -- 0x04000036, 0x001000c2, 0x00000000, 0x00020aa6, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, -- 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_2d_float_code[] = --{ --#if 0 -- RWTexture2D dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[u_info.dst_offset.xy + thread_id.xy] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x6e735b3f, 0x7348c4fa, 0xb3634e42, 0x50e2d99b, 0x00000001, 0x00000128, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000d4, 0x00050050, 0x00000035, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400189c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020032, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x001000f2, 0x00000000, 0x00020546, 0x00208546, 0x00000000, 0x00000001, -- 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, 0x00000000, 0x00208e46, 0x00000000, 0x00000000, -- 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_2d_uint_code[] = --{ --#if 0 -- RWTexture2D dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[u_info.dst_offset.xy + thread_id.xy] = u_info.clear_value; -- } --#endif -- 0x43425844, 0xf01db5dd, 0xc7dc5e55, 0xb017c1a8, 0x55abd52d, 0x00000001, 0x00000128, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000d4, 0x00050050, 0x00000035, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400189c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020032, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x001000f2, 0x00000000, 0x00020546, 0x00208546, 0x00000000, 0x00000001, -- 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, 0x00000000, 0x00208e46, 0x00000000, 0x00000000, -- 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_3d_float_code[] = --{ --#if 0 -- RWTexture3D dst; -- -- struct -- { -- float4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[int3(u_info.dst_offset.xy, 0) + thread_id.xyz] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x5d8f36a0, 0x30fa86a5, 0xfec7f2ef, 0xdfd76cbb, 0x00000001, 0x00000138, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000e4, 0x00050050, 0x00000039, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400289c, 0x0011e000, 0x00000000, 0x00005555, -- 0x0200005f, 0x00020072, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x00100032, 0x00000000, 0x00020046, 0x00208046, 0x00000000, 0x00000001, -- 0x04000036, 0x001000c2, 0x00000000, 0x00020aa6, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, -- 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -- --static const uint32_t cs_uav_clear_3d_uint_code[] = --{ --#if 0 -- RWTexture3D dst; -- -- struct -- { -- uint4 clear_value; -- int2 dst_offset; -- int2 dst_extent; -- } u_info; -- -- [numthreads(8, 8, 1)] -- void main(int3 thread_id : SV_DispatchThreadID) -- { -- if (all(thread_id.xy < u_info.dst_extent.xy)) -- dst[int3(u_info.dst_offset.xy, 0) + thread_id.xyz] = u_info.clear_value; -- } --#endif -- 0x43425844, 0x5b9c95b1, 0xc9bde4e3, 0x9aaff806, 0x24a1d264, 0x00000001, 0x00000138, 0x00000003, -- 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, -- 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000000e4, 0x00050050, 0x00000039, 0x0100086a, -- 0x04000059, 0x00208e46, 0x00000000, 0x00000002, 0x0400289c, 0x0011e000, 0x00000000, 0x00004444, -- 0x0200005f, 0x00020072, 0x02000068, 0x00000001, 0x0400009b, 0x00000008, 0x00000008, 0x00000001, -- 0x07000022, 0x00100032, 0x00000000, 0x00020046, 0x00208ae6, 0x00000000, 0x00000001, 0x07000001, -- 0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, -- 0x00000000, 0x0700001e, 0x00100032, 0x00000000, 0x00020046, 0x00208046, 0x00000000, 0x00000001, -- 0x04000036, 0x001000c2, 0x00000000, 0x00020aa6, 0x080000a4, 0x0011e0f2, 0x00000000, 0x00100e46, -- 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x01000015, 0x0100003e, --}; -+static const char cs_uav_clear_buffer_float_code[] = -+ "RWBuffer dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(128, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_buffer_uint_code[] = -+ "RWBuffer dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(128, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_1d_array_float_code[] = -+ "RWTexture1DArray dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(64, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[int2(u_info.dst_offset.x + thread_id.x, thread_id.y)] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_1d_array_uint_code[] = -+ "RWTexture1DArray dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(64, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[int2(u_info.dst_offset.x + thread_id.x, thread_id.y)] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_1d_float_code[] = -+ "RWTexture1D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(64, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_1d_uint_code[] = -+ "RWTexture1D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(64, 1, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (thread_id.x < u_info.dst_extent.x)\n" -+ " dst[u_info.dst_offset.x + thread_id.x] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_2d_array_float_code[] = -+ "RWTexture2DArray dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[int3(u_info.dst_offset.xy + thread_id.xy, thread_id.z)] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_2d_array_uint_code[] = -+ "RWTexture2DArray dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[int3(u_info.dst_offset.xy + thread_id.xy, thread_id.z)] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_2d_float_code[] = -+ "RWTexture2D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[u_info.dst_offset.xy + thread_id.xy] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_2d_uint_code[] = -+ "RWTexture2D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[u_info.dst_offset.xy + thread_id.xy] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_3d_float_code[] = -+ "RWTexture3D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " float4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[int3(u_info.dst_offset.xy, 0) + thread_id.xyz] = u_info.clear_value;\n" -+ "}\n"; -+ -+static const char cs_uav_clear_3d_uint_code[] = -+ "RWTexture3D dst;\n" -+ "\n" -+ "struct\n" -+ "{\n" -+ " uint4 clear_value;\n" -+ " int2 dst_offset;\n" -+ " int2 dst_extent;\n" -+ "} u_info;\n" -+ "\n" -+ "[numthreads(8, 8, 1)]\n" -+ "void main(int3 thread_id : SV_DispatchThreadID)\n" -+ "{\n" -+ " if (all(thread_id.xy < u_info.dst_extent.xy))\n" -+ " dst[int3(u_info.dst_offset.xy, 0) + thread_id.xyz] = u_info.clear_value;\n" -+ "}\n"; - - #endif /* __VKD3D_SHADERS_H */ --- -2.43.0 - diff --git a/patches/vkd3d-latest/0002-Updated-vkd3d-to-6a4a9a4518689a7db5eff362cc5e0fff099.patch b/patches/vkd3d-latest/0002-Updated-vkd3d-to-6a4a9a4518689a7db5eff362cc5e0fff099.patch deleted file mode 100644 index 1a3188ce..00000000 --- a/patches/vkd3d-latest/0002-Updated-vkd3d-to-6a4a9a4518689a7db5eff362cc5e0fff099.patch +++ /dev/null @@ -1,287 +0,0 @@ -From 8d4080e846b03a63494fb71f3890046143be85f5 Mon Sep 17 00:00:00 2001 -From: Alistair Leslie-Hughes -Date: Tue, 28 Nov 2023 10:20:40 +1100 -Subject: [PATCH] Updated vkd3d to 6a4a9a4518689a7db5eff362cc5e0fff0994a7af. - ---- - libs/vkd3d/libs/vkd3d-shader/dxil.c | 6 ++---- - libs/vkd3d/libs/vkd3d-shader/hlsl.c | 2 ++ - libs/vkd3d/libs/vkd3d-shader/hlsl.h | 3 ++- - libs/vkd3d/libs/vkd3d-shader/hlsl.l | 1 + - libs/vkd3d/libs/vkd3d-shader/hlsl.y | 5 +++++ - libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c | 10 +++++----- - libs/vkd3d/libs/vkd3d-shader/tpf.c | 3 ++- - libs/vkd3d/libs/vkd3d/command.c | 4 ++-- - libs/vkd3d/libs/vkd3d/device.c | 20 +++++++++++++++----- - libs/vkd3d/libs/vkd3d/state.c | 2 +- - libs/vkd3d/libs/vkd3d/vkd3d_private.h | 4 +--- - 11 files changed, 38 insertions(+), 22 deletions(-) - -diff --git a/libs/vkd3d/libs/vkd3d-shader/dxil.c b/libs/vkd3d/libs/vkd3d-shader/dxil.c -index 1709212fa99..c03948aef53 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/dxil.c -+++ b/libs/vkd3d/libs/vkd3d-shader/dxil.c -@@ -4895,8 +4895,7 @@ static enum vkd3d_result sm6_parser_resources_init(struct sm6_parser *sm6) - static void signature_element_read_additional_element_values(struct signature_element *e, - const struct sm6_metadata_node *node, struct sm6_parser *sm6) - { -- unsigned int i, operand_count, value; -- enum dxil_element_additional_tag tag; -+ unsigned int i, operand_count, value, tag; - - if (node->operand_count < 11 || !node->operands[10]) - return; -@@ -5254,8 +5253,7 @@ static enum vkd3d_result sm6_parser_entry_point_init(struct sm6_parser *sm6) - { - const struct sm6_metadata_value *m = sm6_parser_find_named_metadata(sm6, "dx.entryPoints"); - const struct sm6_metadata_node *node, *entry_node = m ? m->u.node : NULL; -- enum dxil_shader_properties_tag tag; -- unsigned int i, operand_count; -+ unsigned int i, operand_count, tag; - const struct sm6_value *value; - enum vkd3d_result ret; - -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.c b/libs/vkd3d/libs/vkd3d-shader/hlsl.c -index 501bff8cfb8..da3bbda1bc3 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.c -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.c -@@ -2255,6 +2255,8 @@ struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsig - - if (modifiers & HLSL_STORAGE_EXTERN) - vkd3d_string_buffer_printf(string, "extern "); -+ if (modifiers & HLSL_STORAGE_LINEAR) -+ vkd3d_string_buffer_printf(string, "linear "); - if (modifiers & HLSL_STORAGE_NOINTERPOLATION) - vkd3d_string_buffer_printf(string, "nointerpolation "); - if (modifiers & HLSL_STORAGE_CENTROID) -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.h b/libs/vkd3d/libs/vkd3d-shader/hlsl.h -index a0065572539..bd6682be6ac 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.h -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.h -@@ -357,13 +357,14 @@ struct hlsl_attribute - #define HLSL_MODIFIER_INLINE 0x00002000 - #define HLSL_STORAGE_CENTROID 0x00004000 - #define HLSL_STORAGE_NOPERSPECTIVE 0x00008000 -+#define HLSL_STORAGE_LINEAR 0x00010000 - - #define HLSL_TYPE_MODIFIERS_MASK (HLSL_MODIFIER_PRECISE | HLSL_MODIFIER_VOLATILE | \ - HLSL_MODIFIER_CONST | HLSL_MODIFIER_ROW_MAJOR | \ - HLSL_MODIFIER_COLUMN_MAJOR) - - #define HLSL_INTERPOLATION_MODIFIERS_MASK (HLSL_STORAGE_NOINTERPOLATION | HLSL_STORAGE_CENTROID | \ -- HLSL_STORAGE_NOPERSPECTIVE) -+ HLSL_STORAGE_NOPERSPECTIVE | HLSL_STORAGE_LINEAR) - - #define HLSL_MODIFIERS_MAJORITY_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR) - -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.l b/libs/vkd3d/libs/vkd3d-shader/hlsl.l -index 401fba60422..fe838750747 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.l -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.l -@@ -95,6 +95,7 @@ if {return KW_IF; } - in {return KW_IN; } - inline {return KW_INLINE; } - inout {return KW_INOUT; } -+linear {return KW_LINEAR; } - matrix {return KW_MATRIX; } - namespace {return KW_NAMESPACE; } - nointerpolation {return KW_NOINTERPOLATION; } -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl.y b/libs/vkd3d/libs/vkd3d-shader/hlsl.y -index 67b01293683..0dde4c18587 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl.y -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl.y -@@ -4893,6 +4893,7 @@ static void check_duplicated_switch_cases(struct hlsl_ctx *ctx, const struct hls - %token KW_IN - %token KW_INLINE - %token KW_INOUT -+%token KW_LINEAR - %token KW_MATRIX - %token KW_NAMESPACE - %token KW_NOINTERPOLATION -@@ -6262,6 +6263,10 @@ var_modifiers: - { - $$ = add_modifiers(ctx, $2, HLSL_STORAGE_CENTROID, &@1); - } -+ | KW_LINEAR var_modifiers -+ { -+ $$ = add_modifiers(ctx, $2, HLSL_STORAGE_LINEAR, &@1); -+ } - | KW_NOPERSPECTIVE var_modifiers - { - $$ = add_modifiers(ctx, $2, HLSL_STORAGE_NOPERSPECTIVE, &@1); -diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -index 5a70878bca7..628de79676e 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -+++ b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c -@@ -1304,12 +1304,10 @@ static struct copy_propagation_value *copy_propagation_get_value(const struct co - { - struct copy_propagation_var_def *var_def = RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); - unsigned int component_count = hlsl_type_component_count(var->data_type); -- enum copy_propagation_value_state state; - - assert(component < component_count); -- state = var_def->values[component].state; - -- switch (state) -+ switch (var_def->values[component].state) - { - case VALUE_STATE_STATICALLY_WRITTEN: - return &var_def->values[component]; -@@ -4089,7 +4087,7 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var - [VKD3D_SHADER_TYPE_COMPUTE] = "Compute", - }; - -- unsigned int type; -+ enum vkd3d_shader_register_type type; - uint32_t reg; - bool builtin; - -@@ -4097,6 +4095,7 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var - - if (ctx->profile->major_version < 4) - { -+ D3DSHADER_PARAM_REGISTER_TYPE sm1_type; - D3DDECLUSAGE usage; - uint32_t usage_idx; - -@@ -4104,7 +4103,7 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var - if (ctx->profile->major_version == 1 && output && ctx->profile->type == VKD3D_SHADER_TYPE_PIXEL) - return; - -- builtin = hlsl_sm1_register_from_semantic(ctx, &var->semantic, output, &type, ®); -+ builtin = hlsl_sm1_register_from_semantic(ctx, &var->semantic, output, &sm1_type, ®); - if (!builtin && !hlsl_sm1_usage_from_semantic(&var->semantic, &usage, &usage_idx)) - { - hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC, -@@ -4114,6 +4113,7 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var - - if ((!output && !var->last_read) || (output && !var->first_write)) - return; -+ type = (enum vkd3d_shader_register_type)sm1_type; - } - else - { -diff --git a/libs/vkd3d/libs/vkd3d-shader/tpf.c b/libs/vkd3d/libs/vkd3d-shader/tpf.c -index 61d14e30d3c..80f8ab98c08 100644 ---- a/libs/vkd3d/libs/vkd3d-shader/tpf.c -+++ b/libs/vkd3d/libs/vkd3d-shader/tpf.c -@@ -3528,8 +3528,8 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc) - { - const unsigned int var_size = (profile->major_version >= 5 ? 10 : 6); - size_t var_offset = vars_start + j * var_size * sizeof(uint32_t); -- size_t string_offset = put_string(&buffer, var->name); - -+ string_offset = put_string(&buffer, var->name); - set_u32(&buffer, var_offset, string_offset); - write_sm4_type(ctx, &buffer, var->data_type); - set_u32(&buffer, var_offset + 4 * sizeof(uint32_t), var->data_type->bytecode_offset); -@@ -4311,6 +4311,7 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl - { HLSL_STORAGE_CENTROID | HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE_CENTROID }, - { HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE }, - { HLSL_STORAGE_CENTROID, VKD3DSIM_LINEAR_CENTROID }, -+ { HLSL_STORAGE_CENTROID | HLSL_STORAGE_LINEAR, VKD3DSIM_LINEAR_CENTROID }, - }; - unsigned int i; - -diff --git a/libs/vkd3d/libs/vkd3d/command.c b/libs/vkd3d/libs/vkd3d/command.c -index 77d0f2751cf..15c8317b191 100644 ---- a/libs/vkd3d/libs/vkd3d/command.c -+++ b/libs/vkd3d/libs/vkd3d/command.c -@@ -6852,7 +6852,7 @@ fail: - static HRESULT d3d12_command_queue_wait_binary_semaphore_locked(struct d3d12_command_queue *command_queue, - struct d3d12_fence *fence, uint64_t value) - { -- static const VkPipelineStageFlagBits wait_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; -+ static const VkPipelineStageFlags wait_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; - const struct vkd3d_vk_device_procs *vk_procs; - struct vkd3d_signaled_semaphore *semaphore; - uint64_t completed_value = 0; -@@ -6948,7 +6948,7 @@ fail: - static HRESULT d3d12_command_queue_wait_locked(struct d3d12_command_queue *command_queue, - struct d3d12_fence *fence, uint64_t value) - { -- static const VkPipelineStageFlagBits wait_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; -+ static const VkPipelineStageFlags wait_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; - VkTimelineSemaphoreSubmitInfoKHR timeline_submit_info; - const struct vkd3d_vk_device_procs *vk_procs; - struct vkd3d_queue *queue; -diff --git a/libs/vkd3d/libs/vkd3d/device.c b/libs/vkd3d/libs/vkd3d/device.c -index 79028fc3dd8..5c801ca4676 100644 ---- a/libs/vkd3d/libs/vkd3d/device.c -+++ b/libs/vkd3d/libs/vkd3d/device.c -@@ -3736,10 +3736,19 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandleByName(ID3D12Devic - static HRESULT STDMETHODCALLTYPE d3d12_device_MakeResident(ID3D12Device5 *iface, - UINT object_count, ID3D12Pageable * const *objects) - { -- FIXME_ONCE("iface %p, object_count %u, objects %p stub!\n", -- iface, object_count, objects); -+ ID3D12Fence *fence; -+ HRESULT hr; - -- return S_OK; -+ TRACE("iface %p, object_count %u, objects %p.\n", iface, object_count, objects); -+ -+ if (FAILED(hr = ID3D12Device5_CreateFence(iface, 0, 0, &IID_ID3D12Fence, (void **)&fence))) -+ return hr; -+ -+ hr = ID3D12Device5_EnqueueMakeResident(iface, 0, object_count, objects, fence, 1); -+ if (SUCCEEDED(hr)) -+ ID3D12Fence_SetEventOnCompletion(fence, 1, NULL); -+ ID3D12Fence_Release(fence); -+ return hr; - } - - static HRESULT STDMETHODCALLTYPE d3d12_device_Evict(ID3D12Device5 *iface, -@@ -3994,10 +4003,11 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_EnqueueMakeResident(ID3D12Device5 - D3D12_RESIDENCY_FLAGS flags, UINT num_objects, ID3D12Pageable *const *objects, - ID3D12Fence *fence, UINT64 fence_value) - { -- FIXME("iface %p, flags %#x, num_objects %u, objects %p, fence %p, fence_value %#"PRIx64" stub!\n", -+ FIXME_ONCE("iface %p, flags %#x, num_objects %u, objects %p, fence %p, fence_value %#"PRIx64" stub!\n", - iface, flags, num_objects, objects, fence, fence_value); - -- return E_NOTIMPL; -+ ID3D12Fence_Signal(fence, fence_value); -+ return S_OK; - } - - static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommandList1(ID3D12Device5 *iface, -diff --git a/libs/vkd3d/libs/vkd3d/state.c b/libs/vkd3d/libs/vkd3d/state.c -index de0e04ea1e6..6665a1fd6cb 100644 ---- a/libs/vkd3d/libs/vkd3d/state.c -+++ b/libs/vkd3d/libs/vkd3d/state.c -@@ -1839,7 +1839,7 @@ static HRESULT pipeline_state_desc_from_d3d12_stream_desc(struct d3d12_pipeline_ - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT] = DCL_SUBOBJECT_INFO(D3D12_INPUT_LAYOUT_DESC, input_layout), - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE] = DCL_SUBOBJECT_INFO(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, strip_cut_value), - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY] = DCL_SUBOBJECT_INFO(D3D12_PRIMITIVE_TOPOLOGY_TYPE, primitive_topology_type), -- [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS] = DCL_SUBOBJECT_INFO(D3D12_RT_FORMAT_ARRAY, rtv_formats), -+ [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS] = DCL_SUBOBJECT_INFO(struct D3D12_RT_FORMAT_ARRAY, rtv_formats), - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT] = DCL_SUBOBJECT_INFO(DXGI_FORMAT, dsv_format), - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC] = DCL_SUBOBJECT_INFO(DXGI_SAMPLE_DESC, sample_desc), - [D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK] = DCL_SUBOBJECT_INFO(UINT, node_mask), -diff --git a/libs/vkd3d/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/libs/vkd3d/vkd3d_private.h -index 231bc615e5c..e0eb9f3d3fe 100644 ---- a/libs/vkd3d/libs/vkd3d/vkd3d_private.h -+++ b/libs/vkd3d/libs/vkd3d/vkd3d_private.h -@@ -22,9 +22,7 @@ - #define COBJMACROS - #define NONAMELESSUNION - #define VK_NO_PROTOTYPES --#ifndef CONST_VTABLE - #define CONST_VTABLE --#endif - - #ifdef _WIN32 - # define _WIN32_WINNT 0x0600 /* for condition variables */ -@@ -1336,7 +1334,7 @@ struct d3d12_pipeline_state_desc - D3D12_INPUT_LAYOUT_DESC input_layout; - D3D12_INDEX_BUFFER_STRIP_CUT_VALUE strip_cut_value; - D3D12_PRIMITIVE_TOPOLOGY_TYPE primitive_topology_type; -- D3D12_RT_FORMAT_ARRAY rtv_formats; -+ struct D3D12_RT_FORMAT_ARRAY rtv_formats; - DXGI_FORMAT dsv_format; - DXGI_SAMPLE_DESC sample_desc; - D3D12_VIEW_INSTANCING_DESC view_instancing_desc; --- -2.43.0 - diff --git a/staging/upstream-commit b/staging/upstream-commit index 4ac86988..bc659e74 100644 --- a/staging/upstream-commit +++ b/staging/upstream-commit @@ -1 +1 @@ -30c074963acd05a3a31676085653460eea86bc78 +f0c08bd01e6d3b01bfc28961bb5922b94ecbb7bc