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>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>

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 \

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) \

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),
 };

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;

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;

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
 {

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

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);
 }