[PATCH vkd3d 5/6] vkd3d-shader/sm1: Introduce a parser for the legacy D3D byte-code format.
This is largely derived from the parser in Wine/wined3d, as of wine-6.18.
Signed-off-by: Henri Verbeet hverbeet@codeweavers.com --- Makefile.am | 1 + include/private/vkd3d_debug.h | 1 + include/vkd3d_shader.h | 5 + libs/vkd3d-common/debug.c | 18 +- libs/vkd3d-shader/d3dbc.c | 958 +++++++++++++++++++++++ libs/vkd3d-shader/vkd3d_shader_main.c | 50 ++ libs/vkd3d-shader/vkd3d_shader_private.h | 12 + programs/vkd3d-compiler/main.c | 4 + tests/vkd3d_shader_api.c | 89 +++ 9 files changed, 1133 insertions(+), 5 deletions(-) create mode 100644 libs/vkd3d-shader/d3dbc.c
diff --git a/Makefile.am b/Makefile.am index ee3d7495..eaa4f816 100644 --- a/Makefile.am +++ b/Makefile.am @@ -184,6 +184,7 @@ libvkd3d_shader_la_SOURCES = \ include/private/vkd3d_memory.h \ include/vkd3d_shader.h \ libs/vkd3d-shader/checksum.c \ + libs/vkd3d-shader/d3dbc.c \ libs/vkd3d-shader/dxbc.c \ libs/vkd3d-shader/glsl.c \ libs/vkd3d-shader/hlsl.c \ diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h index a206a92b..8ab653ae 100644 --- a/include/private/vkd3d_debug.h +++ b/include/private/vkd3d_debug.h @@ -51,6 +51,7 @@ void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const ch const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2); const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args); const char *debugstr_a(const char *str); +const char *debugstr_an(const char *str, size_t n); const char *debugstr_w(const WCHAR *wstr, size_t wchar_size);
#define VKD3D_DBG_LOG(level) \ diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 58e507b7..37b5936d 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -467,6 +467,11 @@ enum vkd3d_shader_source_type VKD3D_SHADER_SOURCE_DXBC_TPF, /** High-Level Shader Language source code. */ VKD3D_SHADER_SOURCE_HLSL, + /** + * Legacy Direct3D byte-code. This is the format used for Direct3D shader + * model 1, 2, and 3 shaders. + */ + VKD3D_SHADER_SOURCE_D3D_BYTECODE,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SOURCE_TYPE), }; diff --git a/libs/vkd3d-common/debug.c b/libs/vkd3d-common/debug.c index dcf53fa9..4868f3fb 100644 --- a/libs/vkd3d-common/debug.c +++ b/libs/vkd3d-common/debug.c @@ -132,22 +132,25 @@ static int get_escape_char(int c) } }
-const char *debugstr_a(const char *str) +const char *debugstr_an(const char *str, size_t n) { char *buffer, *ptr; + int escape_char; char c;
if (!str) return "(null)"; + if (n == SIZE_MAX) + n = strlen(str);
ptr = buffer = get_buffer();
*ptr++ = '"'; - while ((c = *str++) && ptr <= buffer + VKD3D_DEBUG_BUFFER_SIZE - 8) + while (n-- && ptr <= buffer + VKD3D_DEBUG_BUFFER_SIZE - 8) { - int escape_char = get_escape_char(c); + c = *str++;
- if (escape_char) + if ((escape_char = get_escape_char(c))) { *ptr++ = '\'; *ptr++ = escape_char; @@ -167,7 +170,7 @@ const char *debugstr_a(const char *str) } *ptr++ = '"';
- if (c) + if (++n) { *ptr++ = '.'; *ptr++ = '.'; @@ -178,6 +181,11 @@ const char *debugstr_a(const char *str) return buffer; }
+const char *debugstr_a(const char *str) +{ + return debugstr_an(str, SIZE_MAX); +} + static const char *debugstr_w16(const uint16_t *wstr) { char *buffer, *ptr; diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c new file mode 100644 index 00000000..267f9609 --- /dev/null +++ b/libs/vkd3d-shader/d3dbc.c @@ -0,0 +1,958 @@ +/* + * Copyright 2002-2003 Jason Edmeades + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2004 Christian Costa + * Copyright 2005 Oliver Stieber + * Copyright 2006 Ivan Gyurdiev + * Copyright 2007-2008 Stefan Dösinger for CodeWeavers + * Copyright 2009, 2021 Henri Verbeet 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 + */ + +#include "vkd3d_shader_private.h" + +#define VKD3D_SM1_VS 0xfffeu +#define VKD3D_SM1_PS 0xffffu + +#define VKD3D_SM1_DCL_USAGE_SHIFT 0u +#define VKD3D_SM1_DCL_USAGE_MASK (0xfu << VKD3D_SM1_DCL_USAGE_SHIFT) +#define VKD3D_SM1_DCL_USAGE_INDEX_SHIFT 16u +#define VKD3D_SM1_DCL_USAGE_INDEX_MASK (0xfu << VKD3D_SM1_DCL_USAGE_INDEX_SHIFT) + +#define VKD3D_SM1_RESOURCE_TYPE_SHIFT 27u +#define VKD3D_SM1_RESOURCE_TYPE_MASK (0xfu << VKD3D_SM1_RESOURCE_TYPE_SHIFT) + +#define VKD3D_SM1_OPCODE_MASK 0x0000ffffu + +#define VKD3D_SM1_INSTRUCTION_FLAGS_SHIFT 16u +#define VKD3D_SM1_INSTRUCTION_FLAGS_MASK (0xffu << VKD3D_SM1_INSTRUCTION_FLAGS_SHIFT) + +#define VKD3D_SM1_INSTRUCTION_LENGTH_SHIFT 24u +#define VKD3D_SM1_INSTRUCTION_LENGTH_MASK (0xfu << VKD3D_SM1_INSTRUCTION_LENGTH_SHIFT) + +#define VKD3D_SM1_COISSUE (0x1u << 30u) + +#define VKD3D_SM1_COMMENT_SIZE_SHIFT 16u +#define VKD3D_SM1_COMMENT_SIZE_MASK (0x7fffu << VKD3D_SM1_COMMENT_SIZE_SHIFT) + +#define VKD3D_SM1_INSTRUCTION_PREDICATED (0x1u << 28u) + +#define VKD3D_SM1_INSTRUCTION_PARAMETER (0x1u << 31u) + +#define VKD3D_SM1_REGISTER_NUMBER_MASK 0x000007ffu + +#define VKD3D_SM1_REGISTER_TYPE_SHIFT 28u +#define VKD3D_SM1_REGISTER_TYPE_MASK (0x7u << VKD3D_SM1_REGISTER_TYPE_SHIFT) +#define VKD3D_SM1_REGISTER_TYPE_SHIFT2 8u +#define VKD3D_SM1_REGISTER_TYPE_MASK2 (0x18u << VKD3D_SM1_REGISTER_TYPE_SHIFT2) + +#define VKD3D_SM1_ADDRESS_MODE_SHIFT 13u +#define VKD3D_SM1_ADDRESS_MODE_MASK (0x1u << VKD3D_SM1_ADDRESS_MODE_SHIFT) + +#define VKD3D_SM1_DST_MODIFIER_SHIFT 20u +#define VKD3D_SM1_DST_MODIFIER_MASK (0xfu << VKD3D_SM1_DST_MODIFIER_SHIFT) + +#define VKD3D_SM1_DSTSHIFT_SHIFT 24u +#define VKD3D_SM1_DSTSHIFT_MASK (0xfu << VKD3D_SM1_DSTSHIFT_SHIFT) + +#define VKD3D_SM1_WRITEMASK_SHIFT 16u +#define VKD3D_SM1_WRITEMASK_MASK (0xfu << VKD3D_SM1_WRITEMASK_SHIFT) + +#define VKD3D_SM1_SWIZZLE_SHIFT 16u +#define VKD3D_SM1_SWIZZLE_MASK (0xffu << VKD3D_SM1_SWIZZLE_SHIFT) +#define VKD3D_SM1_SWIZZLE_DEFAULT (0u | (1u << 2) | (2u << 4) | (3u << 6)) + +#define VKD3D_SM1_SWIZZLE_COMPONENT_SHIFT(idx) (2u * (idx)) +#define VKD3D_SM1_SWIZZLE_COMPONENT_MASK(idx) (0x3u << VKD3D_SM1_SWIZZLE_COMPONENT_SHIFT(idx)) + +#define VKD3D_SM1_SRC_MODIFIER_SHIFT 24u +#define VKD3D_SM1_SRC_MODIFIER_MASK (0xfu << VKD3D_SM1_SRC_MODIFIER_SHIFT) + +#define VKD3D_SM1_END 0x0000ffffu + +#define VKD3D_SM1_VERSION_MAJOR(version) (((version) >> 8u) & 0xffu) +#define VKD3D_SM1_VERSION_MINOR(version) (((version) >> 0u) & 0xffu) + +enum vkd3d_sm1_address_mode_type +{ + VKD3D_SM1_ADDRESS_MODE_ABSOLUTE = 0x0, + VKD3D_SM1_ADDRESS_MODE_RELATIVE = 0x1, +}; + +enum vkd3d_sm1_resource_type +{ + VKD3D_SM1_RESOURCE_UNKNOWN = 0x0, + VKD3D_SM1_RESOURCE_TEXTURE_1D = 0x1, + VKD3D_SM1_RESOURCE_TEXTURE_2D = 0x2, + VKD3D_SM1_RESOURCE_TEXTURE_CUBE = 0x3, + VKD3D_SM1_RESOURCE_TEXTURE_3D = 0x4, +}; + +enum vkd3d_sm1_opcode +{ + VKD3D_SM1_OP_NOP = 0x00, + VKD3D_SM1_OP_MOV = 0x01, + VKD3D_SM1_OP_ADD = 0x02, + VKD3D_SM1_OP_SUB = 0x03, + VKD3D_SM1_OP_MAD = 0x04, + VKD3D_SM1_OP_MUL = 0x05, + VKD3D_SM1_OP_RCP = 0x06, + VKD3D_SM1_OP_RSQ = 0x07, + VKD3D_SM1_OP_DP3 = 0x08, + VKD3D_SM1_OP_DP4 = 0x09, + VKD3D_SM1_OP_MIN = 0x0a, + VKD3D_SM1_OP_MAX = 0x0b, + VKD3D_SM1_OP_SLT = 0x0c, + VKD3D_SM1_OP_SGE = 0x0d, + VKD3D_SM1_OP_EXP = 0x0e, + VKD3D_SM1_OP_LOG = 0x0f, + VKD3D_SM1_OP_LIT = 0x10, + VKD3D_SM1_OP_DST = 0x11, + VKD3D_SM1_OP_LRP = 0x12, + VKD3D_SM1_OP_FRC = 0x13, + VKD3D_SM1_OP_M4x4 = 0x14, + VKD3D_SM1_OP_M4x3 = 0x15, + VKD3D_SM1_OP_M3x4 = 0x16, + VKD3D_SM1_OP_M3x3 = 0x17, + VKD3D_SM1_OP_M3x2 = 0x18, + VKD3D_SM1_OP_CALL = 0x19, + VKD3D_SM1_OP_CALLNZ = 0x1a, + VKD3D_SM1_OP_LOOP = 0x1b, + VKD3D_SM1_OP_RET = 0x1c, + VKD3D_SM1_OP_ENDLOOP = 0x1d, + VKD3D_SM1_OP_LABEL = 0x1e, + VKD3D_SM1_OP_DCL = 0x1f, + VKD3D_SM1_OP_POW = 0x20, + VKD3D_SM1_OP_CRS = 0x21, + VKD3D_SM1_OP_SGN = 0x22, + VKD3D_SM1_OP_ABS = 0x23, + VKD3D_SM1_OP_NRM = 0x24, + VKD3D_SM1_OP_SINCOS = 0x25, + VKD3D_SM1_OP_REP = 0x26, + VKD3D_SM1_OP_ENDREP = 0x27, + VKD3D_SM1_OP_IF = 0x28, + VKD3D_SM1_OP_IFC = 0x29, + VKD3D_SM1_OP_ELSE = 0x2a, + VKD3D_SM1_OP_ENDIF = 0x2b, + VKD3D_SM1_OP_BREAK = 0x2c, + VKD3D_SM1_OP_BREAKC = 0x2d, + VKD3D_SM1_OP_MOVA = 0x2e, + VKD3D_SM1_OP_DEFB = 0x2f, + VKD3D_SM1_OP_DEFI = 0x30, + + VKD3D_SM1_OP_TEXCOORD = 0x40, + VKD3D_SM1_OP_TEXKILL = 0x41, + VKD3D_SM1_OP_TEX = 0x42, + VKD3D_SM1_OP_TEXBEM = 0x43, + VKD3D_SM1_OP_TEXBEML = 0x44, + VKD3D_SM1_OP_TEXREG2AR = 0x45, + VKD3D_SM1_OP_TEXREG2GB = 0x46, + VKD3D_SM1_OP_TEXM3x2PAD = 0x47, + VKD3D_SM1_OP_TEXM3x2TEX = 0x48, + VKD3D_SM1_OP_TEXM3x3PAD = 0x49, + VKD3D_SM1_OP_TEXM3x3TEX = 0x4a, + VKD3D_SM1_OP_TEXM3x3DIFF = 0x4b, + VKD3D_SM1_OP_TEXM3x3SPEC = 0x4c, + VKD3D_SM1_OP_TEXM3x3VSPEC = 0x4d, + VKD3D_SM1_OP_EXPP = 0x4e, + VKD3D_SM1_OP_LOGP = 0x4f, + VKD3D_SM1_OP_CND = 0x50, + VKD3D_SM1_OP_DEF = 0x51, + VKD3D_SM1_OP_TEXREG2RGB = 0x52, + VKD3D_SM1_OP_TEXDP3TEX = 0x53, + VKD3D_SM1_OP_TEXM3x2DEPTH = 0x54, + VKD3D_SM1_OP_TEXDP3 = 0x55, + VKD3D_SM1_OP_TEXM3x3 = 0x56, + VKD3D_SM1_OP_TEXDEPTH = 0x57, + VKD3D_SM1_OP_CMP = 0x58, + VKD3D_SM1_OP_BEM = 0x59, + VKD3D_SM1_OP_DP2ADD = 0x5a, + VKD3D_SM1_OP_DSX = 0x5b, + VKD3D_SM1_OP_DSY = 0x5c, + VKD3D_SM1_OP_TEXLDD = 0x5d, + VKD3D_SM1_OP_SETP = 0x5e, + VKD3D_SM1_OP_TEXLDL = 0x5f, + VKD3D_SM1_OP_BREAKP = 0x60, + + VKD3D_SM1_OP_PHASE = 0xfffd, + VKD3D_SM1_OP_COMMENT = 0xfffe, + VKD3D_SM1_OP_END = 0Xffff, +}; + +struct vkd3d_sm1_opcode_info +{ + enum vkd3d_sm1_opcode sm1_opcode; + unsigned int dst_count; + unsigned int src_count; + enum vkd3d_shader_opcode vkd3d_opcode; + struct + { + unsigned int major, minor; + } min_version, max_version; +}; + +struct vkd3d_shader_sm1_parser +{ + const struct vkd3d_sm1_opcode_info *opcode_table; + const uint32_t *start, *end; + bool abort; + + struct vkd3d_shader_src_param src_rel_addr[4]; + struct vkd3d_shader_src_param pred_rel_addr; + struct vkd3d_shader_src_param dst_rel_addr; + struct vkd3d_shader_src_param src_param[4]; + struct vkd3d_shader_src_param pred_param; + struct vkd3d_shader_dst_param dst_param; + + struct vkd3d_shader_parser p; +}; + +/* This table is not order or position dependent. */ +static const struct vkd3d_sm1_opcode_info vs_opcode_table[] = +{ + /* Arithmetic */ + {VKD3D_SM1_OP_NOP, 0, 0, VKD3DSIH_NOP}, + {VKD3D_SM1_OP_MOV, 1, 1, VKD3DSIH_MOV}, + {VKD3D_SM1_OP_MOVA, 1, 1, VKD3DSIH_MOVA, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ADD, 1, 2, VKD3DSIH_ADD}, + {VKD3D_SM1_OP_SUB, 1, 2, VKD3DSIH_SUB}, + {VKD3D_SM1_OP_MAD, 1, 3, VKD3DSIH_MAD}, + {VKD3D_SM1_OP_MUL, 1, 2, VKD3DSIH_MUL}, + {VKD3D_SM1_OP_RCP, 1, 1, VKD3DSIH_RCP}, + {VKD3D_SM1_OP_RSQ, 1, 1, VKD3DSIH_RSQ}, + {VKD3D_SM1_OP_DP3, 1, 2, VKD3DSIH_DP3}, + {VKD3D_SM1_OP_DP4, 1, 2, VKD3DSIH_DP4}, + {VKD3D_SM1_OP_MIN, 1, 2, VKD3DSIH_MIN}, + {VKD3D_SM1_OP_MAX, 1, 2, VKD3DSIH_MAX}, + {VKD3D_SM1_OP_SLT, 1, 2, VKD3DSIH_SLT}, + {VKD3D_SM1_OP_SGE, 1, 2, VKD3DSIH_SGE}, + {VKD3D_SM1_OP_ABS, 1, 1, VKD3DSIH_ABS}, + {VKD3D_SM1_OP_EXP, 1, 1, VKD3DSIH_EXP}, + {VKD3D_SM1_OP_LOG, 1, 1, VKD3DSIH_LOG}, + {VKD3D_SM1_OP_EXPP, 1, 1, VKD3DSIH_EXPP}, + {VKD3D_SM1_OP_LOGP, 1, 1, VKD3DSIH_LOGP}, + {VKD3D_SM1_OP_LIT, 1, 1, VKD3DSIH_LIT}, + {VKD3D_SM1_OP_DST, 1, 2, VKD3DSIH_DST}, + {VKD3D_SM1_OP_LRP, 1, 3, VKD3DSIH_LRP}, + {VKD3D_SM1_OP_FRC, 1, 1, VKD3DSIH_FRC}, + {VKD3D_SM1_OP_POW, 1, 2, VKD3DSIH_POW}, + {VKD3D_SM1_OP_CRS, 1, 2, VKD3DSIH_CRS}, + {VKD3D_SM1_OP_SGN, 1, 3, VKD3DSIH_SGN, {2, 0}, { 2, 1}}, + {VKD3D_SM1_OP_SGN, 1, 1, VKD3DSIH_SGN, {3, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_NRM, 1, 1, VKD3DSIH_NRM,}, + {VKD3D_SM1_OP_SINCOS, 1, 3, VKD3DSIH_SINCOS, {2, 0}, { 2, 1}}, + {VKD3D_SM1_OP_SINCOS, 1, 1, VKD3DSIH_SINCOS, {3, 0}, {~0u, ~0u}}, + /* Matrix */ + {VKD3D_SM1_OP_M4x4, 1, 2, VKD3DSIH_M4x4}, + {VKD3D_SM1_OP_M4x3, 1, 2, VKD3DSIH_M4x3}, + {VKD3D_SM1_OP_M3x4, 1, 2, VKD3DSIH_M3x4}, + {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}, + /* Constant definitions */ + {VKD3D_SM1_OP_DEF, 1, 4, VKD3DSIH_DEF}, + {VKD3D_SM1_OP_DEFB, 1, 1, VKD3DSIH_DEFB}, + {VKD3D_SM1_OP_DEFI, 1, 4, VKD3DSIH_DEFI}, + /* Control flow */ + {VKD3D_SM1_OP_REP, 0, 1, VKD3DSIH_REP, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDREP, 0, 0, VKD3DSIH_ENDREP, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_IF, 0, 1, VKD3DSIH_IF, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_IFC, 0, 2, VKD3DSIH_IFC, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ELSE, 0, 0, VKD3DSIH_ELSE, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDIF, 0, 0, VKD3DSIH_ENDIF, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAK, 0, 0, VKD3DSIH_BREAK, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAKC, 0, 2, VKD3DSIH_BREAKC, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAKP, 0, 1, VKD3DSIH_BREAKP}, + {VKD3D_SM1_OP_CALL, 0, 1, VKD3DSIH_CALL, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_CALLNZ, 0, 2, VKD3DSIH_CALLNZ, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_LOOP, 0, 2, VKD3DSIH_LOOP, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_RET, 0, 0, VKD3DSIH_RET, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDLOOP, 0, 0, VKD3DSIH_ENDLOOP, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_LABEL, 0, 1, VKD3DSIH_LABEL, {2, 0}, {~0u, ~0u}}, + + {VKD3D_SM1_OP_SETP, 1, 2, VKD3DSIH_SETP}, + {VKD3D_SM1_OP_TEXLDL, 1, 2, VKD3DSIH_TEXLDL, {3, 0}, {~0u, ~0u}}, + {0, 0, 0, VKD3DSIH_INVALID}, +}; + +static const struct vkd3d_sm1_opcode_info ps_opcode_table[] = +{ + /* Arithmetic */ + {VKD3D_SM1_OP_NOP, 0, 0, VKD3DSIH_NOP}, + {VKD3D_SM1_OP_MOV, 1, 1, VKD3DSIH_MOV}, + {VKD3D_SM1_OP_ADD, 1, 2, VKD3DSIH_ADD}, + {VKD3D_SM1_OP_SUB, 1, 2, VKD3DSIH_SUB}, + {VKD3D_SM1_OP_MAD, 1, 3, VKD3DSIH_MAD}, + {VKD3D_SM1_OP_MUL, 1, 2, VKD3DSIH_MUL}, + {VKD3D_SM1_OP_RCP, 1, 1, VKD3DSIH_RCP}, + {VKD3D_SM1_OP_RSQ, 1, 1, VKD3DSIH_RSQ}, + {VKD3D_SM1_OP_DP3, 1, 2, VKD3DSIH_DP3}, + {VKD3D_SM1_OP_DP4, 1, 2, VKD3DSIH_DP4}, + {VKD3D_SM1_OP_MIN, 1, 2, VKD3DSIH_MIN}, + {VKD3D_SM1_OP_MAX, 1, 2, VKD3DSIH_MAX}, + {VKD3D_SM1_OP_SLT, 1, 2, VKD3DSIH_SLT}, + {VKD3D_SM1_OP_SGE, 1, 2, VKD3DSIH_SGE}, + {VKD3D_SM1_OP_ABS, 1, 1, VKD3DSIH_ABS}, + {VKD3D_SM1_OP_EXP, 1, 1, VKD3DSIH_EXP}, + {VKD3D_SM1_OP_LOG, 1, 1, VKD3DSIH_LOG}, + {VKD3D_SM1_OP_EXPP, 1, 1, VKD3DSIH_EXPP}, + {VKD3D_SM1_OP_LOGP, 1, 1, VKD3DSIH_LOGP}, + {VKD3D_SM1_OP_DST, 1, 2, VKD3DSIH_DST}, + {VKD3D_SM1_OP_LRP, 1, 3, VKD3DSIH_LRP}, + {VKD3D_SM1_OP_FRC, 1, 1, VKD3DSIH_FRC}, + {VKD3D_SM1_OP_CND, 1, 3, VKD3DSIH_CND, {1, 0}, { 1, 4}}, + {VKD3D_SM1_OP_CMP, 1, 3, VKD3DSIH_CMP, {1, 2}, { 3, 0}}, + {VKD3D_SM1_OP_POW, 1, 2, VKD3DSIH_POW}, + {VKD3D_SM1_OP_CRS, 1, 2, VKD3DSIH_CRS}, + {VKD3D_SM1_OP_NRM, 1, 1, VKD3DSIH_NRM}, + {VKD3D_SM1_OP_SINCOS, 1, 3, VKD3DSIH_SINCOS, {2, 0}, { 2, 1}}, + {VKD3D_SM1_OP_SINCOS, 1, 1, VKD3DSIH_SINCOS, {3, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_DP2ADD, 1, 3, VKD3DSIH_DP2ADD, {2, 0}, {~0u, ~0u}}, + /* Matrix */ + {VKD3D_SM1_OP_M4x4, 1, 2, VKD3DSIH_M4x4}, + {VKD3D_SM1_OP_M4x3, 1, 2, VKD3DSIH_M4x3}, + {VKD3D_SM1_OP_M3x4, 1, 2, VKD3DSIH_M3x4}, + {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}, + /* Constant definitions */ + {VKD3D_SM1_OP_DEF, 1, 4, VKD3DSIH_DEF}, + {VKD3D_SM1_OP_DEFB, 1, 1, VKD3DSIH_DEFB}, + {VKD3D_SM1_OP_DEFI, 1, 4, VKD3DSIH_DEFI}, + /* Control flow */ + {VKD3D_SM1_OP_REP, 0, 1, VKD3DSIH_REP, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDREP, 0, 0, VKD3DSIH_ENDREP, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_IF, 0, 1, VKD3DSIH_IF, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_IFC, 0, 2, VKD3DSIH_IFC, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ELSE, 0, 0, VKD3DSIH_ELSE, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDIF, 0, 0, VKD3DSIH_ENDIF, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAK, 0, 0, VKD3DSIH_BREAK, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAKC, 0, 2, VKD3DSIH_BREAKC, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_BREAKP, 0, 1, VKD3DSIH_BREAKP}, + {VKD3D_SM1_OP_CALL, 0, 1, VKD3DSIH_CALL, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_CALLNZ, 0, 2, VKD3DSIH_CALLNZ, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_LOOP, 0, 2, VKD3DSIH_LOOP, {3, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_RET, 0, 0, VKD3DSIH_RET, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_ENDLOOP, 0, 0, VKD3DSIH_ENDLOOP, {3, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_LABEL, 0, 1, VKD3DSIH_LABEL, {2, 1}, {~0u, ~0u}}, + /* Texture */ + {VKD3D_SM1_OP_TEXCOORD, 1, 0, VKD3DSIH_TEXCOORD, {0, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXCOORD, 1, 1, VKD3DSIH_TEXCOORD, {1 ,4}, { 1, 4}}, + {VKD3D_SM1_OP_TEXKILL, 1, 0, VKD3DSIH_TEXKILL, {1 ,0}, { 3, 0}}, + {VKD3D_SM1_OP_TEX, 1, 0, VKD3DSIH_TEX, {0, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEX, 1, 1, VKD3DSIH_TEX, {1, 4}, { 1, 4}}, + {VKD3D_SM1_OP_TEX, 1, 2, VKD3DSIH_TEX, {2, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_TEXBEM, 1, 1, VKD3DSIH_TEXBEM, {0, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXBEML, 1, 1, VKD3DSIH_TEXBEML, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXREG2AR, 1, 1, VKD3DSIH_TEXREG2AR, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXREG2GB, 1, 1, VKD3DSIH_TEXREG2GB, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXREG2RGB, 1, 1, VKD3DSIH_TEXREG2RGB, {1, 2}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x2PAD, 1, 1, VKD3DSIH_TEXM3x2PAD, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x2TEX, 1, 1, VKD3DSIH_TEXM3x2TEX, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x3PAD, 1, 1, VKD3DSIH_TEXM3x3PAD, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x3DIFF, 1, 1, VKD3DSIH_TEXM3x3DIFF, {0, 0}, { 0, 0}}, + {VKD3D_SM1_OP_TEXM3x3SPEC, 1, 2, VKD3DSIH_TEXM3x3SPEC, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x3VSPEC, 1, 1, VKD3DSIH_TEXM3x3VSPEC, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x3TEX, 1, 1, VKD3DSIH_TEXM3x3TEX, {1, 0}, { 1, 3}}, + {VKD3D_SM1_OP_TEXDP3TEX, 1, 1, VKD3DSIH_TEXDP3TEX, {1, 2}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x2DEPTH, 1, 1, VKD3DSIH_TEXM3x2DEPTH, {1, 3}, { 1, 3}}, + {VKD3D_SM1_OP_TEXDP3, 1, 1, VKD3DSIH_TEXDP3, {1, 2}, { 1, 3}}, + {VKD3D_SM1_OP_TEXM3x3, 1, 1, VKD3DSIH_TEXM3x3, {1, 2}, { 1, 3}}, + {VKD3D_SM1_OP_TEXDEPTH, 1, 0, VKD3DSIH_TEXDEPTH, {1, 4}, { 1, 4}}, + {VKD3D_SM1_OP_BEM, 1, 2, VKD3DSIH_BEM, {1, 4}, { 1, 4}}, + {VKD3D_SM1_OP_DSX, 1, 1, VKD3DSIH_DSX, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_DSY, 1, 1, VKD3DSIH_DSY, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_TEXLDD, 1, 4, VKD3DSIH_TEXLDD, {2, 1}, {~0u, ~0u}}, + {VKD3D_SM1_OP_SETP, 1, 2, VKD3DSIH_SETP}, + {VKD3D_SM1_OP_TEXLDL, 1, 2, VKD3DSIH_TEXLDL, {3, 0}, {~0u, ~0u}}, + {VKD3D_SM1_OP_PHASE, 0, 0, VKD3DSIH_PHASE}, + {0, 0, 0, VKD3DSIH_INVALID}, +}; + +static const enum vkd3d_shader_resource_type resource_type_table[] = +{ + /* VKD3D_SM1_RESOURCE_UNKNOWN */ VKD3D_SHADER_RESOURCE_NONE, + /* VKD3D_SM1_RESOURCE_TEXTURE_1D */ VKD3D_SHADER_RESOURCE_TEXTURE_1D, + /* VKD3D_SM1_RESOURCE_TEXTURE_2D */ VKD3D_SHADER_RESOURCE_TEXTURE_2D, + /* VKD3D_SM1_RESOURCE_TEXTURE_CUBE */ VKD3D_SHADER_RESOURCE_TEXTURE_CUBE, + /* VKD3D_SM1_RESOURCE_TEXTURE_3D */ VKD3D_SHADER_RESOURCE_TEXTURE_3D, +}; + +static struct vkd3d_shader_sm1_parser *vkd3d_shader_sm1_parser(struct vkd3d_shader_parser *parser) +{ + return CONTAINING_RECORD(parser, struct vkd3d_shader_sm1_parser, p); +} + +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; + + address_mode = (param & VKD3D_SM1_ADDRESS_MODE_MASK) >> VKD3D_SM1_ADDRESS_MODE_SHIFT; + + return address_mode == VKD3D_SM1_ADDRESS_MODE_RELATIVE; +} + +static const struct vkd3d_sm1_opcode_info *shader_sm1_get_opcode_info( + const struct vkd3d_shader_sm1_parser *sm1, enum vkd3d_sm1_opcode opcode) +{ + const struct vkd3d_sm1_opcode_info *info; + unsigned int i = 0; + + for (;;) + { + info = &sm1->opcode_table[i++]; + if (info->vkd3d_opcode == VKD3DSIH_INVALID) + 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) + || !info->max_version.major)) + return info; + } +} + +static unsigned int shader_sm1_get_swizzle_component(uint32_t swizzle, unsigned int idx) +{ + return (swizzle & VKD3D_SM1_SWIZZLE_COMPONENT_MASK(idx)) >> VKD3D_SM1_SWIZZLE_COMPONENT_SHIFT(idx); +} + +static uint32_t swizzle_from_sm1(uint32_t swizzle) +{ + return vkd3d_shader_create_swizzle(shader_sm1_get_swizzle_component(swizzle, 0), + shader_sm1_get_swizzle_component(swizzle, 1), + shader_sm1_get_swizzle_component(swizzle, 2), + shader_sm1_get_swizzle_component(swizzle, 3)); +} + +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) + | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); + 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->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; +} + +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) + | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); + 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->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; +} + +/* Read a parameter token from the input stream, and possibly a relative + * addressing token. */ +static void shader_sm1_read_param(struct vkd3d_shader_sm1_parser *sm1, + const uint32_t **ptr, uint32_t *token, uint32_t *addr_token) +{ + if (*ptr >= sm1->end) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Attempted to read a parameter token, but no more tokens are remaining."); + sm1->abort = true; + *token = 0; + return; + } + *token = read_u32(ptr); + if (!has_relative_address(*token)) + return; + + /* PS >= 3.0 have relative addressing (with token) + * VS >= 2.0 have relative addressing (with token) + * VS >= 1.0 < 2.0 have relative addressing (without token) + * The version check below should work in general. */ + if (sm1->p.shader_version.major < 2) + { + *addr_token = (1u << 31) + | ((VKD3DSPR_ADDR << VKD3D_SM1_REGISTER_TYPE_SHIFT2) & VKD3D_SM1_REGISTER_TYPE_MASK2) + | ((VKD3DSPR_ADDR << VKD3D_SM1_REGISTER_TYPE_SHIFT) & VKD3D_SM1_REGISTER_TYPE_MASK) + | (VKD3D_SM1_SWIZZLE_DEFAULT << VKD3D_SM1_SWIZZLE_SHIFT); + return; + } + + if (*ptr >= sm1->end) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Attempted to read an indirect addressing token, but no more tokens are remaining."); + sm1->abort = true; + *addr_token = 0; + return; + } + *addr_token = read_u32(ptr); +} + +/* Skip the parameter tokens for an opcode. */ +static void shader_sm1_skip_opcode(const struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr, + const struct vkd3d_sm1_opcode_info *opcode_info, uint32_t opcode_token) +{ + unsigned int length; + + /* Version 2.0+ shaders may contain address tokens, but fortunately they + * have a useful length mask - use it here. Version 1.x shaders contain no + * such tokens. */ + if (sm1->p.shader_version.major >= 2) + { + length = (opcode_token & VKD3D_SM1_INSTRUCTION_LENGTH_MASK) >> VKD3D_SM1_INSTRUCTION_LENGTH_SHIFT; + *ptr += length; + return; + } + + *ptr += (opcode_info->dst_count + opcode_info->src_count); +} + +static void shader_sm1_destroy(struct vkd3d_shader_parser *parser) +{ + struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser); + + free_shader_desc(&sm1->p.shader_desc); + vkd3d_free(sm1); +} + +static void shader_sm1_read_src_param(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr, + struct vkd3d_shader_src_param *src_param, struct vkd3d_shader_src_param *src_rel_addr) +{ + uint32_t token, addr_token; + + shader_sm1_read_param(sm1, ptr, &token, &addr_token); + if (has_relative_address(token)) + shader_sm1_parse_src_param(addr_token, NULL, src_rel_addr); + else + src_rel_addr = NULL; + shader_sm1_parse_src_param(token, src_rel_addr, src_param); +} + +static void shader_sm1_read_dst_param(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr, + struct vkd3d_shader_dst_param *dst_param, struct vkd3d_shader_src_param *dst_rel_addr) +{ + uint32_t token, addr_token; + + shader_sm1_read_param(sm1, ptr, &token, &addr_token); + if (has_relative_address(token)) + shader_sm1_parse_src_param(addr_token, NULL, dst_rel_addr); + else + dst_rel_addr = NULL; + shader_sm1_parse_dst_param(token, dst_rel_addr, dst_param); +} + +static void shader_sm1_read_semantic(struct vkd3d_shader_sm1_parser *sm1, + const uint32_t **ptr, struct vkd3d_shader_semantic *semantic) +{ + enum vkd3d_sm1_resource_type resource_type; + struct vkd3d_shader_register_range *range; + uint32_t usage_token, dst_token; + + if (*ptr >= sm1->end || sm1->end - *ptr < 2) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Attempted to read a declaration instruction, but not enough tokens are remaining."); + sm1->abort = true; + return; + } + + usage_token = read_u32(ptr); + dst_token = read_u32(ptr); + + semantic->usage = (usage_token & VKD3D_SM1_DCL_USAGE_MASK) >> VKD3D_SM1_DCL_USAGE_SHIFT; + semantic->usage_idx = (usage_token & VKD3D_SM1_DCL_USAGE_INDEX_MASK) >> VKD3D_SM1_DCL_USAGE_INDEX_SHIFT; + resource_type = (usage_token & VKD3D_SM1_RESOURCE_TYPE_MASK) >> VKD3D_SM1_RESOURCE_TYPE_SHIFT; + if (resource_type >= ARRAY_SIZE(resource_type_table)) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_INVALID_RESOURCE_TYPE, + "Invalid resource type %#x.", resource_type); + semantic->resource_type = VKD3D_SHADER_RESOURCE_NONE; + } + else + { + semantic->resource_type = resource_type_table[resource_type]; + } + semantic->resource_data_type[0] = VKD3D_DATA_FLOAT; + semantic->resource_data_type[1] = VKD3D_DATA_FLOAT; + semantic->resource_data_type[2] = VKD3D_DATA_FLOAT; + semantic->resource_data_type[3] = VKD3D_DATA_FLOAT; + shader_sm1_parse_dst_param(dst_token, NULL, &semantic->resource.reg); + range = &semantic->resource.range; + range->space = 0; + range->first = range->last = semantic->resource.reg.reg.idx[0].offset; +} + +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) +{ + unsigned int count = type == VKD3D_IMMCONST_VEC4 ? 4 : 1; + + if (*ptr >= sm1->end || sm1->end - *ptr < count) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Attempted to read a constant definition, but not enough tokens are remaining. " + "%zu token(s) available, %u required.", sm1->end - *ptr, count); + sm1->abort = true; + return; + } + + src_param->reg.type = VKD3DSPR_IMMCONST; + src_param->reg.precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; + src_param->reg.non_uniform = false; + src_param->reg.data_type = data_type; + src_param->reg.idx[0].offset = ~0u; + src_param->reg.idx[0].rel_addr = NULL; + src_param->reg.idx[1].offset = ~0u; + src_param->reg.idx[1].rel_addr = NULL; + src_param->reg.idx[2].offset = ~0u; + src_param->reg.idx[2].rel_addr = NULL; + src_param->reg.immconst_type = type; + memcpy(src_param->reg.u.immconst_uint, *ptr, count * sizeof(uint32_t)); + src_param->swizzle = VKD3D_SHADER_NO_SWIZZLE; + src_param->modifiers = 0; + + *ptr += count; +} + +static void shader_sm1_read_comment(struct vkd3d_shader_sm1_parser *sm1) +{ + const uint32_t **ptr = &sm1->p.ptr; + const char *comment; + unsigned int size; + size_t remaining; + uint32_t token; + + if (*ptr >= sm1->end) + return; + + remaining = sm1->end - *ptr; + + token = **ptr; + while ((token & VKD3D_SM1_OPCODE_MASK) == VKD3D_SM1_OP_COMMENT) + { + size = (token & VKD3D_SM1_COMMENT_SIZE_MASK) >> VKD3D_SM1_COMMENT_SIZE_SHIFT; + + if (size > --remaining) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Encountered a %u token comment, but only %zu token(s) is/are remaining.", + size, remaining); + return; + } + + comment = (const char *)++(*ptr); + remaining -= size; + *ptr += size; + + if (size > 1 && *(const uint32_t *)comment == TAG_TEXT) + { + const char *end = comment + size * sizeof(token); + const char *p = comment + sizeof(token); + const char *line; + + TRACE("// TEXT\n"); + for (line = p; line < end; line = p) + { + if (!(p = memchr(line, '\n', end - line))) + p = end; + else + ++p; + TRACE("// %s\n", debugstr_an(line, p - line)); + } + } + else if (size) + { + TRACE("// %s\n", debugstr_an(comment, size * sizeof(token))); + } + else + break; + + if (!remaining) + break; + token = **ptr; + } +} + +static void shader_sm1_validate_instruction(struct vkd3d_shader_sm1_parser *sm1, struct vkd3d_shader_instruction *ins) +{ + if ((ins->handler_idx == VKD3DSIH_BREAKP || ins->handler_idx == VKD3DSIH_IF) && ins->flags) + { + vkd3d_shader_parser_warning(&sm1->p, VKD3D_SHADER_WARNING_D3DBC_IGNORED_INSTRUCTION_FLAGS, + "Ignoring unexpected instruction flags %#x.", ins->flags); + ins->flags = 0; + } +} + +static void shader_sm1_read_instruction(struct vkd3d_shader_parser *parser, struct vkd3d_shader_instruction *ins) +{ + struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser); + const struct vkd3d_sm1_opcode_info *opcode_info; + const uint32_t **ptr = &parser->ptr; + uint32_t opcode_token; + const uint32_t *p; + unsigned int i; + + shader_sm1_read_comment(sm1); + + if (*ptr >= sm1->end) + { + WARN("End of byte-code, failed to read opcode.\n"); + goto fail; + } + + ++parser->location.line; + opcode_token = read_u32(ptr); + if (!(opcode_info = shader_sm1_get_opcode_info(sm1, opcode_token & VKD3D_SM1_OPCODE_MASK))) + { + vkd3d_shader_parser_error(parser, VKD3D_SHADER_ERROR_D3DBC_INVALID_OPCODE, + "Invalid opcode %#x (token 0x%08x, shader version %u.%u).", + opcode_token & VKD3D_SM1_OPCODE_MASK, opcode_token, + sm1->p.shader_version.major, sm1->p.shader_version.minor); + goto fail; + } + + ins->handler_idx = 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; + ins->structured = false; + ins->predicate = opcode_token & VKD3D_SM1_INSTRUCTION_PREDICATED ? &sm1->pred_param : NULL; + ins->dst_count = opcode_info->dst_count; + ins->dst = &sm1->dst_param; + ins->src_count = opcode_info->src_count; + ins->src = sm1->src_param; + ins->resource_type = VKD3D_SHADER_RESOURCE_NONE; + ins->resource_stride = 0; + ins->resource_data_type[0] = VKD3D_DATA_FLOAT; + ins->resource_data_type[1] = VKD3D_DATA_FLOAT; + ins->resource_data_type[2] = VKD3D_DATA_FLOAT; + ins->resource_data_type[3] = VKD3D_DATA_FLOAT; + memset(&ins->texel_offset, 0, sizeof(ins->texel_offset)); + + p = *ptr; + shader_sm1_skip_opcode(sm1, ptr, opcode_info, opcode_token); + if (*ptr > sm1->end) + { + vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "The current instruction ends %zu token(s) past the end of the shader.", + *ptr - sm1->end); + goto fail; + } + + if (ins->handler_idx == VKD3DSIH_DCL) + { + shader_sm1_read_semantic(sm1, &p, &ins->declaration.semantic); + } + else if (ins->handler_idx == VKD3DSIH_DEF) + { + shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr); + shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_FLOAT); + } + else if (ins->handler_idx == VKD3DSIH_DEFB) + { + shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr); + shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_SCALAR, VKD3D_DATA_UINT); + } + else if (ins->handler_idx == VKD3DSIH_DEFI) + { + shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr); + shader_sm1_read_immconst(sm1, &p, &sm1->src_param[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_INT); + } + else + { + /* Destination token */ + if (ins->dst_count) + shader_sm1_read_dst_param(sm1, &p, &sm1->dst_param, &sm1->dst_rel_addr); + + /* Predication token */ + if (ins->predicate) + shader_sm1_read_src_param(sm1, &p, &sm1->pred_param, &sm1->pred_rel_addr); + + /* Other source tokens */ + for (i = 0; i < ins->src_count; ++i) + shader_sm1_read_src_param(sm1, &p, &sm1->src_param[i], &sm1->src_rel_addr[i]); + } + + if (sm1->abort) + { + sm1->abort = false; + goto fail; + } + + shader_sm1_validate_instruction(sm1, ins); + return; + +fail: + ins->handler_idx = VKD3DSIH_INVALID; + *ptr = sm1->end; +} + +static bool shader_sm1_is_end(struct vkd3d_shader_parser *parser) +{ + struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser); + const uint32_t **ptr = &parser->ptr; + + shader_sm1_read_comment(sm1); + + if (*ptr >= sm1->end) + return true; + + if (**ptr == VKD3D_SM1_END) + { + ++(*ptr); + return true; + } + + return false; +} + +static void shader_sm1_reset(struct vkd3d_shader_parser *parser) +{ + struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser); + + parser->ptr = sm1->start; + parser->failed = false; +} + +const struct vkd3d_shader_parser_ops shader_sm1_parser_ops = +{ + .parser_reset = shader_sm1_reset, + .parser_destroy = shader_sm1_destroy, + .parser_read_instruction = shader_sm1_read_instruction, + .parser_is_end = shader_sm1_is_end, +}; + +static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1, + const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_message_context *message_context) +{ + const struct vkd3d_shader_location location = {.source_name = compile_info->source_name}; + const uint32_t *code = compile_info->source.code; + size_t code_size = compile_info->source.size; + struct vkd3d_shader_desc *shader_desc; + struct vkd3d_shader_version version; + uint16_t shader_type; + size_t token_count; + + code = compile_info->source.code; + code_size = compile_info->source.size; + token_count = code_size / sizeof(*sm1->start); + + if (token_count < 2) + { + vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF, + "Invalid shader size %zu (token count %zu). At least 2 tokens are required.", + code_size, token_count); + return VKD3D_ERROR_INVALID_SHADER; + } + + TRACE("Version: 0x%08x.\n", code[0]); + + shader_type = code[0] >> 16; + version.major = VKD3D_SM1_VERSION_MAJOR(code[0]); + version.minor = VKD3D_SM1_VERSION_MINOR(code[0]); + + switch (shader_type) + { + case VKD3D_SM1_VS: + version.type = VKD3D_SHADER_TYPE_VERTEX; + sm1->opcode_table = vs_opcode_table; + break; + + case VKD3D_SM1_PS: + version.type = VKD3D_SHADER_TYPE_PIXEL; + sm1->opcode_table = ps_opcode_table; + break; + + default: + vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_D3DBC_INVALID_VERSION_TOKEN, + "Invalid shader type %#x (token 0x%08x).", shader_type, code[0]); + return VKD3D_ERROR_INVALID_SHADER; + } + + if (!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]); + return VKD3D_ERROR_INVALID_SHADER; + } + + sm1->start = &code[1]; + sm1->end = &code[token_count]; + + vkd3d_shader_parser_init(&sm1->p, message_context, compile_info->source_name, &version, &shader_sm1_parser_ops); + shader_desc = &sm1->p.shader_desc; + shader_desc->byte_code = code; + shader_desc->byte_code_size = code_size; + sm1->p.ptr = sm1->start; + + return VKD3D_OK; +} + +int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compile_info, + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser) +{ + struct vkd3d_shader_sm1_parser *sm1; + int ret; + + if (!(sm1 = vkd3d_calloc(1, sizeof(*sm1)))) + { + ERR("Failed to allocate parser.\n"); + return VKD3D_ERROR_OUT_OF_MEMORY; + } + + if ((ret = shader_sm1_init(sm1, compile_info, message_context)) < 0) + { + WARN("Failed to initialise shader parser, ret %d.\n", ret); + vkd3d_free(sm1); + return ret; + } + + *parser = &sm1->p; + + return VKD3D_OK; +} diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 98607154..6c9301c2 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -337,6 +337,8 @@ static const char *shader_get_source_type_suffix(enum vkd3d_shader_source_type t return "dxbc"; case VKD3D_SHADER_SOURCE_HLSL: return "hlsl"; + case VKD3D_SHADER_SOURCE_D3D_BYTECODE: + return "d3dbc"; default: FIXME("Unhandled source type %#x.\n", type); return "bin"; @@ -386,6 +388,16 @@ void VKD3D_PRINTF_FUNC(3, 4) vkd3d_shader_parser_error(struct vkd3d_shader_parse parser->failed = true; }
+void VKD3D_PRINTF_FUNC(3, 4) vkd3d_shader_parser_warning(struct vkd3d_shader_parser *parser, + enum vkd3d_shader_error error, const char *format, ...) +{ + va_list args; + + va_start(args, format); + vkd3d_shader_vwarning(parser->message_context, &parser->location, error, format, args); + va_end(args); +} + static int vkd3d_shader_validate_compile_info(const struct vkd3d_shader_compile_info *compile_info, bool validate_target_type) { @@ -1119,6 +1131,30 @@ static int compile_hlsl(const struct vkd3d_shader_compile_info *compile_info, return ret; }
+static int compile_d3d_bytecode(const struct vkd3d_shader_compile_info *compile_info, + struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context) +{ + struct vkd3d_shader_parser *parser; + int ret; + + if ((ret = vkd3d_shader_sm1_parser_create(compile_info, message_context, &parser)) < 0) + { + WARN("Failed to initialise shader parser.\n"); + 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, compile_info, out); + vkd3d_shader_parser_destroy(parser); + return ret; + } + + return VKD3D_ERROR; +} + int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, char **messages) { @@ -1145,6 +1181,10 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, ret = compile_hlsl(compile_info, out, &message_context); break;
+ case VKD3D_SHADER_SOURCE_D3D_BYTECODE: + ret = compile_d3d_bytecode(compile_info, out, &message_context); + break; + default: assert(0); } @@ -1301,6 +1341,7 @@ const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(uns { VKD3D_SHADER_SOURCE_DXBC_TPF, VKD3D_SHADER_SOURCE_HLSL, + VKD3D_SHADER_SOURCE_D3D_BYTECODE, };
TRACE("count %p.\n", count); @@ -1327,6 +1368,11 @@ const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( VKD3D_SHADER_TARGET_DXBC_TPF, };
+ static const enum vkd3d_shader_target_type d3dbc_types[] = + { + VKD3D_SHADER_TARGET_D3D_ASM, + }; + TRACE("source_type %#x, count %p.\n", source_type, count);
switch (source_type) @@ -1339,6 +1385,10 @@ const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( *count = ARRAY_SIZE(hlsl_types); return hlsl_types;
+ case VKD3D_SHADER_SOURCE_D3D_BYTECODE: + *count = ARRAY_SIZE(d3dbc_types); + return d3dbc_types; + default: *count = 0; return NULL; diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index da12247a..cacba300 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -117,6 +117,13 @@ enum vkd3d_shader_error VKD3D_SHADER_WARNING_HLSL_IMPLICIT_TRUNCATION = 5300,
VKD3D_SHADER_ERROR_GLSL_INTERNAL = 6000, + + VKD3D_SHADER_ERROR_D3DBC_UNEXPECTED_EOF = 7000, + VKD3D_SHADER_ERROR_D3DBC_INVALID_VERSION_TOKEN = 7001, + VKD3D_SHADER_ERROR_D3DBC_INVALID_OPCODE = 7002, + VKD3D_SHADER_ERROR_D3DBC_INVALID_RESOURCE_TYPE = 7003, + + VKD3D_SHADER_WARNING_D3DBC_IGNORED_INSTRUCTION_FLAGS= 7300, };
enum vkd3d_shader_opcode @@ -918,6 +925,8 @@ void vkd3d_shader_parser_error(struct vkd3d_shader_parser *parser, void 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); +void vkd3d_shader_parser_warning(struct vkd3d_shader_parser *parser, + enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(3, 4);
static inline void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser) { @@ -1029,6 +1038,8 @@ void vkd3d_shader_trace_text_(const char *text, size_t size, const char *functio #define vkd3d_shader_trace_text(text, size) \ vkd3d_shader_trace_text_(text, size, __FUNCTION__)
+int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compile_info, + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser); int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_parser **parser);
@@ -1217,6 +1228,7 @@ static inline void *vkd3d_find_struct_(const struct vkd3d_struct *chain, #define TAG_RTS0 MAKE_TAG('R', 'T', 'S', '0') #define TAG_SHDR MAKE_TAG('S', 'H', 'D', 'R') #define TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X') +#define TAG_TEXT MAKE_TAG('T', 'E', 'X', 'T')
struct dxbc_writer_section { diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c index ac01d59a..4d7d628c 100644 --- a/programs/vkd3d-compiler/main.c +++ b/programs/vkd3d-compiler/main.c @@ -65,6 +65,10 @@ source_type_info[] = {VKD3D_SHADER_SOURCE_HLSL, "hlsl", "High Level Shader Language source code.\n", false}, + {VKD3D_SHADER_SOURCE_D3D_BYTECODE, + "d3dbc", "Legacy Direct3D byte-code.\n" + " This is the format used for Direct3D shader model 1, 2, and 3 shaders.\n", + true}, };
static const struct target_type_info diff --git a/tests/vkd3d_shader_api.c b/tests/vkd3d_shader_api.c index d0f3f5d2..c9045b81 100644 --- a/tests/vkd3d_shader_api.c +++ b/tests/vkd3d_shader_api.c @@ -227,6 +227,94 @@ static void test_version(void) ok(minor == expected_minor, "Got unexpected minor version %u.\n", minor); }
+static void test_d3dbc(void) +{ + struct vkd3d_shader_compile_info info; + struct vkd3d_shader_code d3d_asm; + int rc; + + static const uint32_t vs_minimal[] = + { + 0xfffe0100, /* vs_1_0 */ + 0x0000ffff, /* end */ + }; + static const uint32_t invalid_type[] = + { + 0x00010100, /* <invalid>_1_0 */ + 0x0000ffff, /* end */ + }; + static const uint32_t invalid_version[] = + { + 0xfffe0400, /* vs_4_0 */ + 0x0000ffff, /* end */ + }; + static const uint32_t ps[] = + { + 0xffff0101, /* ps_1_1 */ + 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */ + 0x0000ffff, /* end */ + }; + static const char expected[] = "vs_1_0\n"; + + info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; + info.next = NULL; + info.source.code = vs_minimal; + info.source.size = sizeof(vs_minimal); + info.source_type = VKD3D_SHADER_SOURCE_D3D_BYTECODE; + info.target_type = VKD3D_SHADER_TARGET_D3D_ASM; + info.options = NULL; + info.option_count = 0; + info.log_level = VKD3D_SHADER_LOG_NONE; + info.source_name = NULL; + + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); + ok(d3d_asm.size == strlen(expected), "Got unexpected size %zu.\n", d3d_asm.size); + ok(!memcmp(d3d_asm.code, expected, d3d_asm.size), "Got unexpected code "%.*s"\n", + (int)d3d_asm.size, (char *)d3d_asm.code); + vkd3d_shader_free_shader_code(&d3d_asm); + + info.source.size = sizeof(vs_minimal) + 1; + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); + vkd3d_shader_free_shader_code(&d3d_asm); + + info.source.size = ~(size_t)0; + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); + vkd3d_shader_free_shader_code(&d3d_asm); + + info.source.size = sizeof(vs_minimal) - 1; + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); + + info.source.code = invalid_type; + info.source.size = sizeof(invalid_type); + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); + + info.source.code = invalid_version; + info.source.size = sizeof(invalid_version); + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); + + info.source.code = ps; + info.source.size = sizeof(ps); + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_OK, "Got unexpected error code %d.\n", rc); + vkd3d_shader_free_shader_code(&d3d_asm); + + /* Truncated before the destination parameter. */ + info.source.size = sizeof(ps) - 3 * sizeof(*ps); + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); + + /* Truncated before the source parameter. */ + info.source.size = sizeof(ps) - 2 * sizeof(*ps); + rc = vkd3d_shader_compile(&info, &d3d_asm, NULL); + ok(rc == VKD3D_ERROR_INVALID_SHADER, "Got unexpected error code %d.\n", rc); +} + START_TEST(vkd3d_shader_api) { setlocale(LC_ALL, ""); @@ -234,4 +322,5 @@ START_TEST(vkd3d_shader_api) run_test(test_invalid_shaders); run_test(test_vkd3d_shader_pfns); run_test(test_version); + run_test(test_d3dbc); }
Hi,
While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check?
Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=99575
Your paranoid android.
=== debiant2 (build log) ===
Task: Patch failed to apply
=== debiant2 (build log) ===
Task: Patch failed to apply
-
Henri Verbeet -
Marvin