wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-04-13 05:43:18 -07:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader/sm1: Introduce a parser for the legacy D3D byte-code format.

Browse Source 
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>
This commit is contained in:
Henri Verbeet
2021-10-06 17:11:48 +02:00
committed by Alexandre Julliard
parent 28316b2694
commit f7662f9878
9 changed files with 1133 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

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

1
include/private/vkd3d_debug.h
View File

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

5
include/vkd3d_shader.h
View File

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

18
libs/vkd3d-common/debug.c
View File

@ -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;

958
libs/vkd3d-shader/d3dbc.c Normal file
View File

File diff suppressed because it is too large Load Diff

50
libs/vkd3d-shader/vkd3d_shader_main.c
View File

@ -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;

12
libs/vkd3d-shader/vkd3d_shader_private.h
View File

@ -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
{

4
programs/vkd3d-compiler/main.c
View File

@ -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

89
tests/vkd3d_shader_api.c
View File

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