dxbc.c File Reference

#include "vkd3d_shader_private.h"

Include dependency graph for dxbc.c:

Go to the source code of this file.

Classes
struct	root_signature_parser_context
struct	root_signature_writer_context

Macros
#define	DXBC_CHECKSUM_SKIP_BYTE_COUNT   20
#define	VKD3D_ROOT_SIGNATURE_1_0_ROOT_DESCRIPTOR_FLAGS   VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE
#define	VKD3D_ROOT_SIGNATURE_1_0_DESCRIPTOR_RANGE_FLAGS    (VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE)

Functions
static void	compute_dxbc_checksum (const void *dxbc, size_t size, uint32_t checksum[4])
void	dxbc_writer_init (struct dxbc_writer *dxbc)
void	dxbc_writer_add_section (struct dxbc_writer *dxbc, uint32_t tag, const void *data, size_t size)
int	vkd3d_shader_serialize_dxbc (size_t section_count, const struct vkd3d_shader_dxbc_section_desc *sections, struct vkd3d_shader_code *dxbc, char **messages)
int	dxbc_writer_write (struct dxbc_writer *dxbc, struct vkd3d_shader_code *out)
static bool	require_space (size_t offset, size_t count, size_t size, size_t data_size)
static uint32_t	read_u32 (const char **ptr)
static float	read_float (const char **ptr)
static void	skip_dword_unknown (const char **ptr, unsigned int count)
static const char *	shader_get_string (const char *data, size_t data_size, size_t offset)
static int	parse_dxbc (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context, const char *source_name, uint32_t flags, struct vkd3d_shader_dxbc_desc *desc)
void	vkd3d_shader_free_dxbc (struct vkd3d_shader_dxbc_desc *dxbc)
static int	for_each_dxbc_section (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context, const char *source_name, int(*section_handler)(const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, void *ctx), void *ctx)
int	vkd3d_shader_parse_dxbc (const struct vkd3d_shader_code *dxbc, uint32_t flags, struct vkd3d_shader_dxbc_desc *desc, char **messages)
static enum vkd3d_shader_sysval_semantic	map_fragment_output_sysval (const char *name)
static int	shader_parse_signature (const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, struct shader_signature *s)
static int	isgn_handler (const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, void *ctx)
int	shader_parse_input_signature (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context, struct shader_signature *signature)
static int	shdr_handler (const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, void *context)
void	free_dxbc_shader_desc (struct dxbc_shader_desc *desc)
int	shader_extract_from_dxbc (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context, const char *source_name, struct dxbc_shader_desc *desc)
static int	shader_parse_descriptor_ranges (struct root_signature_parser_context *context, unsigned int offset, unsigned int count, struct vkd3d_shader_descriptor_range *ranges)
static void	shader_validate_descriptor_range1 (const struct vkd3d_shader_descriptor_range1 *range)
static int	shader_parse_descriptor_ranges1 (struct root_signature_parser_context *context, unsigned int offset, unsigned int count, struct vkd3d_shader_descriptor_range1 *ranges)
static int	shader_parse_descriptor_table (struct root_signature_parser_context *context, unsigned int offset, struct vkd3d_shader_root_descriptor_table *table)
static int	shader_parse_descriptor_table1 (struct root_signature_parser_context *context, unsigned int offset, struct vkd3d_shader_root_descriptor_table1 *table)
static int	shader_parse_root_constants (struct root_signature_parser_context *context, unsigned int offset, struct vkd3d_shader_root_constants *constants)
static int	shader_parse_root_descriptor (struct root_signature_parser_context *context, unsigned int offset, struct vkd3d_shader_root_descriptor *descriptor)
static void	shader_validate_root_descriptor1 (const struct vkd3d_shader_root_descriptor1 *descriptor)
static int	shader_parse_root_descriptor1 (struct root_signature_parser_context *context, unsigned int offset, struct vkd3d_shader_root_descriptor1 *descriptor)
static int	shader_parse_root_parameters (struct root_signature_parser_context *context, unsigned int offset, unsigned int count, struct vkd3d_shader_root_parameter *parameters)
static int	shader_parse_root_parameters1 (struct root_signature_parser_context *context, uint32_t offset, unsigned int count, struct vkd3d_shader_root_parameter1 *parameters)
static int	shader_parse_static_samplers (struct root_signature_parser_context *context, unsigned int offset, unsigned int count, struct vkd3d_shader_static_sampler_desc *sampler_descs)
static int	shader_parse_root_signature (const struct vkd3d_shader_code *data, struct vkd3d_shader_versioned_root_signature_desc *desc)
static int	rts0_handler (const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, void *context)
int	vkd3d_shader_parse_root_signature (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages)
static unsigned int	versioned_root_signature_get_parameter_count (const struct vkd3d_shader_versioned_root_signature_desc *desc)
static enum vkd3d_shader_root_parameter_type	versioned_root_signature_get_parameter_type (const struct vkd3d_shader_versioned_root_signature_desc *desc, unsigned int i)
static enum vkd3d_shader_visibility	versioned_root_signature_get_parameter_shader_visibility (const struct vkd3d_shader_versioned_root_signature_desc *desc, unsigned int i)
static const struct vkd3d_shader_root_constants *	versioned_root_signature_get_root_constants (const struct vkd3d_shader_versioned_root_signature_desc *desc, unsigned int i)
static unsigned int	versioned_root_signature_get_static_sampler_count (const struct vkd3d_shader_versioned_root_signature_desc *desc)
static const struct vkd3d_shader_static_sampler_desc *	versioned_root_signature_get_static_samplers (const struct vkd3d_shader_versioned_root_signature_desc *desc)
static unsigned int	versioned_root_signature_get_flags (const struct vkd3d_shader_versioned_root_signature_desc *desc)
static size_t	get_chunk_offset (struct root_signature_writer_context *context)
static void	shader_write_root_signature_header (struct root_signature_writer_context *context)
static void	shader_write_descriptor_ranges (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_root_descriptor_table *table)
static void	shader_write_descriptor_ranges1 (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_root_descriptor_table1 *table)
static void	shader_write_descriptor_table (struct root_signature_writer_context *context, const struct vkd3d_shader_root_descriptor_table *table)
static void	shader_write_descriptor_table1 (struct root_signature_writer_context *context, const struct vkd3d_shader_root_descriptor_table1 *table)
static void	shader_write_root_constants (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_root_constants *constants)
static void	shader_write_root_descriptor (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_root_descriptor *descriptor)
static void	shader_write_root_descriptor1 (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_root_descriptor1 *descriptor)
static int	shader_write_root_parameters (struct root_signature_writer_context *context, const struct vkd3d_shader_versioned_root_signature_desc *desc)
static void	shader_write_static_samplers (struct vkd3d_bytecode_buffer *buffer, const struct vkd3d_shader_versioned_root_signature_desc *desc)
static int	shader_write_root_signature (struct root_signature_writer_context *context, const struct vkd3d_shader_versioned_root_signature_desc *desc)
static int	validate_descriptor_table_v_1_0 (const struct vkd3d_shader_root_descriptor_table *descriptor_table, struct vkd3d_shader_message_context *message_context)
static int	validate_descriptor_table_v_1_1 (const struct vkd3d_shader_root_descriptor_table1 *descriptor_table, struct vkd3d_shader_message_context *message_context)
static int	validate_root_signature_desc (const struct vkd3d_shader_versioned_root_signature_desc *desc, struct vkd3d_shader_message_context *message_context)
int	vkd3d_shader_serialize_root_signature (const struct vkd3d_shader_versioned_root_signature_desc *root_signature, struct vkd3d_shader_code *dxbc, char **messages)
static void	free_descriptor_ranges (const struct vkd3d_shader_root_parameter *parameters, unsigned int count)
static int	convert_root_parameters_to_v_1_0 (struct vkd3d_shader_root_parameter *dst, const struct vkd3d_shader_root_parameter1 *src, unsigned int count)
static int	convert_root_signature_to_v1_0 (struct vkd3d_shader_versioned_root_signature_desc *dst, const struct vkd3d_shader_versioned_root_signature_desc *src)
static void	free_descriptor_ranges1 (const struct vkd3d_shader_root_parameter1 *parameters, unsigned int count)
static int	convert_root_parameters_to_v_1_1 (struct vkd3d_shader_root_parameter1 *dst, const struct vkd3d_shader_root_parameter *src, unsigned int count)
static int	convert_root_signature_to_v1_1 (struct vkd3d_shader_versioned_root_signature_desc *dst, const struct vkd3d_shader_versioned_root_signature_desc *src)
int	vkd3d_shader_convert_root_signature (struct vkd3d_shader_versioned_root_signature_desc *dst, enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src)

Macro Definition Documentation

DXBC_CHECKSUM_SKIP_BYTE_COUNT

#define DXBC_CHECKSUM_SKIP_BYTE_COUNT   20

Definition at line 23 of file dxbc.c.

VKD3D_ROOT_SIGNATURE_1_0_DESCRIPTOR_RANGE_FLAGS

#define VKD3D_ROOT_SIGNATURE_1_0_DESCRIPTOR_RANGE_FLAGS    (VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE)

Definition at line 601 of file dxbc.c.

VKD3D_ROOT_SIGNATURE_1_0_ROOT_DESCRIPTOR_FLAGS

#define VKD3D_ROOT_SIGNATURE_1_0_ROOT_DESCRIPTOR_FLAGS   VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE

Definition at line 599 of file dxbc.c.

Function Documentation

compute_dxbc_checksum()

static void compute_dxbc_checksum ( const void *  dxbc, size_t  size, uint32_t  checksum[4]  )

static

Definition at line 25 of file dxbc.c.

{
    const uint8_t *ptr = dxbc;
 
    VKD3D_ASSERT(size > DXBC_CHECKSUM_SKIP_BYTE_COUNT);
    ptr += DXBC_CHECKSUM_SKIP_BYTE_COUNT;
    size -= DXBC_CHECKSUM_SKIP_BYTE_COUNT;
 
    vkd3d_compute_md5(ptr, size, checksum, VKD3D_MD5_DXBC);
}

Referenced by parse_dxbc(), vkd3d_shader_serialize_dxbc(), and vkd3d_shader_serialize_root_signature().

convert_root_parameters_to_v_1_0()

static int convert_root_parameters_to_v_1_0 ( struct vkd3d_shader_root_parameter *  dst, const struct vkd3d_shader_root_parameter1 *  src, unsigned int  count  )

static

Definition at line 1532 of file dxbc.c.

{
    const struct vkd3d_shader_descriptor_range1 *ranges1;
    struct vkd3d_shader_descriptor_range *ranges;
    unsigned int i, j;
    int ret;
 
    for (i = 0; i < count; ++i)
    {
        const struct vkd3d_shader_root_parameter1 *p1 = &src[i];
        struct vkd3d_shader_root_parameter *p = &dst[i];
 
        p->parameter_type = p1->parameter_type;
        switch (p->parameter_type)
        {
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
                ranges = NULL;
                if ((p->u.descriptor_table.descriptor_range_count = p1->u.descriptor_table.descriptor_range_count))
                {
                    if (!(ranges = vkd3d_calloc(p->u.descriptor_table.descriptor_range_count, sizeof(*ranges))))
                    {
                        ret = VKD3D_ERROR_OUT_OF_MEMORY;
                        goto fail;
                    }
                }
                p->u.descriptor_table.descriptor_ranges = ranges;
                ranges1 = p1->u.descriptor_table.descriptor_ranges;
                for (j = 0; j < p->u.descriptor_table.descriptor_range_count; ++j)
                {
                    ranges[j].range_type = ranges1[j].range_type;
                    ranges[j].descriptor_count = ranges1[j].descriptor_count;
                    ranges[j].base_shader_register = ranges1[j].base_shader_register;
                    ranges[j].register_space = ranges1[j].register_space;
                    ranges[j].descriptor_table_offset = ranges1[j].descriptor_table_offset;
                }
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
                p->u.constants = p1->u.constants;
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV:
                p->u.descriptor.shader_register = p1->u.descriptor.shader_register;
                p->u.descriptor.register_space = p1->u.descriptor.register_space;
                break;
            default:
                WARN("Invalid root parameter type %#x.\n", p->parameter_type);
                ret = VKD3D_ERROR_INVALID_ARGUMENT;
                goto fail;
 
        }
        p->shader_visibility = p1->shader_visibility;
    }
 
    return VKD3D_OK;
 
fail:
    free_descriptor_ranges(dst, i);
    return ret;
}

Referenced by convert_root_signature_to_v1_0().

convert_root_parameters_to_v_1_1()

static int convert_root_parameters_to_v_1_1 ( struct vkd3d_shader_root_parameter1 *  dst, const struct vkd3d_shader_root_parameter *  src, unsigned int  count  )

static

Definition at line 1651 of file dxbc.c.

{
    const struct vkd3d_shader_descriptor_range *ranges;
    struct vkd3d_shader_descriptor_range1 *ranges1;
    unsigned int i, j;
    int ret;
 
    for (i = 0; i < count; ++i)
    {
        const struct vkd3d_shader_root_parameter *p = &src[i];
        struct vkd3d_shader_root_parameter1 *p1 = &dst[i];
 
        p1->parameter_type = p->parameter_type;
        switch (p1->parameter_type)
        {
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
                ranges1 = NULL;
                if ((p1->u.descriptor_table.descriptor_range_count = p->u.descriptor_table.descriptor_range_count))
                {
                    if (!(ranges1 = vkd3d_calloc(p1->u.descriptor_table.descriptor_range_count, sizeof(*ranges1))))
                    {
                        ret = VKD3D_ERROR_OUT_OF_MEMORY;
                        goto fail;
                    }
                }
                p1->u.descriptor_table.descriptor_ranges = ranges1;
                ranges = p->u.descriptor_table.descriptor_ranges;
                for (j = 0; j < p1->u.descriptor_table.descriptor_range_count; ++j)
                {
                    ranges1[j].range_type = ranges[j].range_type;
                    ranges1[j].descriptor_count = ranges[j].descriptor_count;
                    ranges1[j].base_shader_register = ranges[j].base_shader_register;
                    ranges1[j].register_space = ranges[j].register_space;
                    ranges1[j].flags = VKD3D_ROOT_SIGNATURE_1_0_DESCRIPTOR_RANGE_FLAGS;
                    ranges1[j].descriptor_table_offset = ranges[j].descriptor_table_offset;
                }
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
                p1->u.constants = p->u.constants;
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV:
                p1->u.descriptor.shader_register = p->u.descriptor.shader_register;
                p1->u.descriptor.register_space = p->u.descriptor.register_space;
                p1->u.descriptor.flags = VKD3D_ROOT_SIGNATURE_1_0_ROOT_DESCRIPTOR_FLAGS;
                break;
            default:
                WARN("Invalid root parameter type %#x.\n", p1->parameter_type);
                ret = VKD3D_ERROR_INVALID_ARGUMENT;
                goto fail;
 
        }
        p1->shader_visibility = p->shader_visibility;
    }
 
    return VKD3D_OK;
 
fail:
    free_descriptor_ranges1(dst, i);
    return ret;
}

Referenced by convert_root_signature_to_v1_1().

convert_root_signature_to_v1_0()

static int convert_root_signature_to_v1_0 ( struct vkd3d_shader_versioned_root_signature_desc *  dst, const struct vkd3d_shader_versioned_root_signature_desc *  src  )

static

Definition at line 1594 of file dxbc.c.

{
    const struct vkd3d_shader_root_signature_desc1 *src_desc = &src->u.v_1_1;
    struct vkd3d_shader_root_signature_desc *dst_desc = &dst->u.v_1_0;
    struct vkd3d_shader_static_sampler_desc *samplers = NULL;
    struct vkd3d_shader_root_parameter *parameters = NULL;
    int ret;
 
    if ((dst_desc->parameter_count = src_desc->parameter_count))
    {
        if (!(parameters = vkd3d_calloc(dst_desc->parameter_count, sizeof(*parameters))))
        {
            ret = VKD3D_ERROR_OUT_OF_MEMORY;
            goto fail;
        }
        if ((ret = convert_root_parameters_to_v_1_0(parameters, src_desc->parameters, src_desc->parameter_count)) < 0)
            goto fail;
    }
    dst_desc->parameters = parameters;
    if ((dst_desc->static_sampler_count = src_desc->static_sampler_count))
    {
        if (!(samplers = vkd3d_calloc(dst_desc->static_sampler_count, sizeof(*samplers))))
        {
            ret = VKD3D_ERROR_OUT_OF_MEMORY;
            goto fail;
        }
        memcpy(samplers, src_desc->static_samplers, src_desc->static_sampler_count * sizeof(*samplers));
    }
    dst_desc->static_samplers = samplers;
    dst_desc->flags = src_desc->flags;
 
    return VKD3D_OK;
 
fail:
    free_descriptor_ranges(parameters, dst_desc->parameter_count);
    vkd3d_free(parameters);
    vkd3d_free(samplers);
    return ret;
}

Referenced by vkd3d_shader_convert_root_signature().

convert_root_signature_to_v1_1()

static int convert_root_signature_to_v1_1 ( struct vkd3d_shader_versioned_root_signature_desc *  dst, const struct vkd3d_shader_versioned_root_signature_desc *  src  )

static

Definition at line 1715 of file dxbc.c.

{
    const struct vkd3d_shader_root_signature_desc *src_desc = &src->u.v_1_0;
    struct vkd3d_shader_root_signature_desc1 *dst_desc = &dst->u.v_1_1;
    struct vkd3d_shader_static_sampler_desc *samplers = NULL;
    struct vkd3d_shader_root_parameter1 *parameters = NULL;
    int ret;
 
    if ((dst_desc->parameter_count = src_desc->parameter_count))
    {
        if (!(parameters = vkd3d_calloc(dst_desc->parameter_count, sizeof(*parameters))))
        {
            ret = VKD3D_ERROR_OUT_OF_MEMORY;
            goto fail;
        }
        if ((ret = convert_root_parameters_to_v_1_1(parameters, src_desc->parameters, src_desc->parameter_count)) < 0)
            goto fail;
    }
    dst_desc->parameters = parameters;
    if ((dst_desc->static_sampler_count = src_desc->static_sampler_count))
    {
        if (!(samplers = vkd3d_calloc(dst_desc->static_sampler_count, sizeof(*samplers))))
        {
            ret = VKD3D_ERROR_OUT_OF_MEMORY;
            goto fail;
        }
        memcpy(samplers, src_desc->static_samplers, src_desc->static_sampler_count * sizeof(*samplers));
    }
    dst_desc->static_samplers = samplers;
    dst_desc->flags = src_desc->flags;
 
    return VKD3D_OK;
 
fail:
    free_descriptor_ranges1(parameters, dst_desc->parameter_count);
    vkd3d_free(parameters);
    vkd3d_free(samplers);
    return ret;
}

Referenced by vkd3d_shader_convert_root_signature().

dxbc_writer_add_section()

void dxbc_writer_add_section	(	struct dxbc_writer *	dxbc,
		uint32_t	tag,
		const void *	data,
		size_t	size
	)

Definition at line 41 of file dxbc.c.

{
    struct vkd3d_shader_dxbc_section_desc *section;
 
    VKD3D_ASSERT(dxbc->section_count < ARRAY_SIZE(dxbc->sections));
 
    section = &dxbc->sections[dxbc->section_count++];
    section->tag = tag;
    section->data.code = data;
    section->data.size = size;
}

Referenced by add_section(), and tpf_write_sfi0().

dxbc_writer_init()

void dxbc_writer_init

(

struct dxbc_writer *

dxbc

)

Definition at line 36 of file dxbc.c.

{
    memset(dxbc, 0, sizeof(*dxbc));
}

Referenced by tpf_compile().

dxbc_writer_write()

int dxbc_writer_write	(	struct dxbc_writer *	dxbc,
		struct vkd3d_shader_code *	out
	)

Definition at line 100 of file dxbc.c.

{
    return vkd3d_shader_serialize_dxbc(dxbc->section_count, dxbc->sections, out, NULL);
}

Referenced by tpf_compile().

for_each_dxbc_section()

static int for_each_dxbc_section ( const struct vkd3d_shader_code *  dxbc, struct vkd3d_shader_message_context *  message_context, const char *  source_name, int(*)(const struct vkd3d_shader_dxbc_section_desc *section, struct vkd3d_shader_message_context *message_context, void *ctx)  section_handler, void *  ctx  )

static

Definition at line 297 of file dxbc.c.

{
    struct vkd3d_shader_dxbc_desc desc;
    unsigned int i;
    int ret;
 
    if ((ret = parse_dxbc(dxbc, message_context, source_name, 0, &desc)) < 0)
        return ret;
 
    for (i = 0; i < desc.section_count; ++i)
    {
        if ((ret = section_handler(&desc.sections[i], message_context, ctx)) < 0)
            break;
    }
 
    vkd3d_shader_free_dxbc(&desc);
 
    return ret;
}

Referenced by shader_extract_from_dxbc(), shader_parse_input_signature(), and vkd3d_shader_parse_root_signature().

free_descriptor_ranges()

static void free_descriptor_ranges ( const struct vkd3d_shader_root_parameter *  parameters, unsigned int  count  )

static

Definition at line 1516 of file dxbc.c.

{
    unsigned int i;
 
    if (!parameters)
        return;
 
    for (i = 0; i < count; ++i)
    {
        const struct vkd3d_shader_root_parameter *p = &parameters[i];
 
        if (p->parameter_type == VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
            vkd3d_free((void *)p->u.descriptor_table.descriptor_ranges);
    }
}

Referenced by convert_root_parameters_to_v_1_0(), and convert_root_signature_to_v1_0().

free_descriptor_ranges1()

static void free_descriptor_ranges1 ( const struct vkd3d_shader_root_parameter1 *  parameters, unsigned int  count  )

static

Definition at line 1635 of file dxbc.c.

{
    unsigned int i;
 
    if (!parameters)
        return;
 
    for (i = 0; i < count; ++i)
    {
        const struct vkd3d_shader_root_parameter1 *p = &parameters[i];
 
        if (p->parameter_type == VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
            vkd3d_free((void *)p->u.descriptor_table.descriptor_ranges);
    }
}

Referenced by convert_root_parameters_to_v_1_1(), and convert_root_signature_to_v1_1().

free_dxbc_shader_desc()

void free_dxbc_shader_desc

(

struct dxbc_shader_desc *

desc

)

Definition at line 573 of file dxbc.c.

{
    shader_signature_cleanup(&desc->input_signature);
    shader_signature_cleanup(&desc->output_signature);
    shader_signature_cleanup(&desc->patch_constant_signature);
}

Referenced by dxil_parse(), shader_extract_from_dxbc(), and tpf_parse().

get_chunk_offset()

static size_t get_chunk_offset ( struct root_signature_writer_context *  context )

static

Definition at line 1140 of file dxbc.c.

{
    return bytecode_get_size(&context->buffer) - context->chunk_position;
}

Referenced by shader_write_descriptor_table(), shader_write_descriptor_table1(), shader_write_root_parameters(), shader_write_root_signature(), and vkd3d_shader_serialize_root_signature().

isgn_handler()

static int isgn_handler ( const struct vkd3d_shader_dxbc_section_desc *  section, struct vkd3d_shader_message_context *  message_context, void *  ctx  )

static

Definition at line 477 of file dxbc.c.

{
    struct shader_signature *is = ctx;
 
    if (section->tag != TAG_ISGN && section->tag != TAG_ISG1)
        return VKD3D_OK;
 
    if (is->elements)
    {
        FIXME("Multiple input signatures.\n");
        shader_signature_cleanup(is);
    }
    return shader_parse_signature(section, message_context, is);
}

Referenced by shader_parse_input_signature().

map_fragment_output_sysval()

static enum vkd3d_shader_sysval_semantic map_fragment_output_sysval ( const char *  name )

static

Definition at line 350 of file dxbc.c.

{
    if (!ascii_strcasecmp(name, "sv_target"))
        return VKD3D_SHADER_SV_TARGET;
    if (!ascii_strcasecmp(name, "sv_depth"))
        return VKD3D_SHADER_SV_DEPTH;
    if (!ascii_strcasecmp(name, "sv_coverage"))
        return VKD3D_SHADER_SV_COVERAGE;
    if (!ascii_strcasecmp(name, "sv_depthgreaterequal"))
        return VKD3D_SHADER_SV_DEPTH_GREATER_EQUAL;
    if (!ascii_strcasecmp(name, "sv_depthlessequal"))
        return VKD3D_SHADER_SV_DEPTH_LESS_EQUAL;
    if (!ascii_strcasecmp(name, "sv_stencilref"))
        return VKD3D_SHADER_SV_STENCIL_REF;
 
    return VKD3D_SHADER_SV_NONE;
}

Referenced by shader_parse_signature().

parse_dxbc()

static int parse_dxbc ( const struct vkd3d_shader_code *  dxbc, struct vkd3d_shader_message_context *  message_context, const char *  source_name, uint32_t  flags, struct vkd3d_shader_dxbc_desc *  desc  )

static

Definition at line 165 of file dxbc.c.

{
    const struct vkd3d_shader_location location = {.source_name = source_name};
    struct vkd3d_shader_dxbc_section_desc *sections, *section;
    uint32_t checksum[4], calculated_checksum[4];
    const char *data = dxbc->code;
    size_t data_size = dxbc->size;
    const char *ptr = data;
    uint32_t chunk_count;
    uint32_t total_size;
    uint32_t version;
    unsigned int i;
    uint32_t tag;
 
    if (data_size < VKD3D_DXBC_HEADER_SIZE)
    {
        WARN("Invalid data size %zu.\n", data_size);
        vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_SIZE,
                "DXBC size %zu is smaller than the DXBC header size.", data_size);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    tag = read_u32(&ptr);
    TRACE("tag: %#x.\n", tag);
 
    if (tag != TAG_DXBC)
    {
        WARN("Wrong tag.\n");
        vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_MAGIC, "Invalid DXBC magic.");
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    checksum[0] = read_u32(&ptr);
    checksum[1] = read_u32(&ptr);
    checksum[2] = read_u32(&ptr);
    checksum[3] = read_u32(&ptr);
    if (!(flags & VKD3D_SHADER_PARSE_DXBC_IGNORE_CHECKSUM))
    {
        compute_dxbc_checksum(data, data_size, calculated_checksum);
        if (memcmp(checksum, calculated_checksum, sizeof(checksum)))
        {
            WARN("Checksum {0x%08x, 0x%08x, 0x%08x, 0x%08x} does not match "
                    "calculated checksum {0x%08x, 0x%08x, 0x%08x, 0x%08x}.\n",
                    checksum[0], checksum[1], checksum[2], checksum[3],
                    calculated_checksum[0], calculated_checksum[1],
                    calculated_checksum[2], calculated_checksum[3]);
            vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_CHECKSUM,
                    "Invalid DXBC checksum.");
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
    }
 
    version = read_u32(&ptr);
    TRACE("version: %#x.\n", version);
    if (version != 0x00000001)
    {
        WARN("Got unexpected DXBC version %#x.\n", version);
        vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_VERSION,
                "DXBC version %#x is not supported.", version);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    total_size = read_u32(&ptr);
    TRACE("total size: %#x\n", total_size);
 
    chunk_count = read_u32(&ptr);
    TRACE("chunk count: %#x\n", chunk_count);
 
    if (!(sections = vkd3d_calloc(chunk_count, sizeof(*sections))))
    {
        vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_OUT_OF_MEMORY, "Out of memory.");
        return VKD3D_ERROR_OUT_OF_MEMORY;
    }
 
    for (i = 0; i < chunk_count; ++i)
    {
        uint32_t chunk_tag, chunk_size;
        const char *chunk_ptr;
        uint32_t 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(uint32_t), data_size))
        {
            WARN("Invalid chunk offset %#x (data size %zu).\n", chunk_offset, data_size);
            vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_CHUNK_OFFSET,
                    "DXBC chunk %u has invalid offset %#x (data size %#zx).", i, chunk_offset, data_size);
            vkd3d_free(sections);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
 
        chunk_ptr = data + chunk_offset;
 
        chunk_tag = read_u32(&chunk_ptr);
        chunk_size = read_u32(&chunk_ptr);
 
        if (!require_space(chunk_ptr - data, 1, chunk_size, data_size))
        {
            WARN("Invalid chunk size %#x (data size %zu, chunk offset %#x).\n",
                    chunk_size, data_size, chunk_offset);
            vkd3d_shader_error(message_context, &location, VKD3D_SHADER_ERROR_DXBC_INVALID_CHUNK_SIZE,
                    "DXBC chunk %u has invalid size %#x (data size %#zx, chunk offset %#x).",
                    i, chunk_offset, data_size, chunk_offset);
            vkd3d_free(sections);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
 
        section = &sections[i];
        section->tag = chunk_tag;
        section->data.code = chunk_ptr;
        section->data.size = chunk_size;
    }
 
    desc->tag = tag;
    memcpy(desc->checksum, checksum, sizeof(checksum));
    desc->version = version;
    desc->size = total_size;
    desc->section_count = chunk_count;
    desc->sections = sections;
 
    return VKD3D_OK;
}

Referenced by for_each_dxbc_section(), and vkd3d_shader_parse_dxbc().

read_float()

static float read_float ( const char **  ptr )

static

Definition at line 118 of file dxbc.c.

{
    union
    {
        uint32_t i;
        float f;
    } u;
    STATIC_ASSERT(sizeof(float) == sizeof(uint32_t));
    u.i = read_u32(ptr);
    return u.f;
}

Referenced by shader_parse_static_samplers().

read_u32()

static uint32_t read_u32 ( const char **  ptr )

static

Definition at line 110 of file dxbc.c.

{
    unsigned int ret;
    memcpy(&ret, *ptr, sizeof(ret));
    *ptr += sizeof(ret);
    return ret;
}

Referenced by parse_dxbc(), read_float(), shader_parse_descriptor_ranges(), shader_parse_descriptor_ranges1(), shader_parse_descriptor_table(), shader_parse_descriptor_table1(), shader_parse_root_constants(), shader_parse_root_descriptor(), shader_parse_root_descriptor1(), shader_parse_root_parameters(), shader_parse_root_parameters1(), shader_parse_root_signature(), shader_parse_signature(), shader_parse_static_samplers(), and skip_dword_unknown().

require_space()

static bool require_space ( size_t  offset, size_t  count, size_t  size, size_t  data_size  )

static

Definition at line 105 of file dxbc.c.

{
    return !count || (data_size - offset) / count >= size;
}

Referenced by parse_dxbc(), shader_parse_descriptor_ranges(), shader_parse_descriptor_ranges1(), shader_parse_descriptor_table(), shader_parse_descriptor_table1(), shader_parse_root_constants(), shader_parse_root_descriptor(), shader_parse_root_descriptor1(), shader_parse_root_parameters(), shader_parse_root_parameters1(), shader_parse_root_signature(), shader_parse_signature(), and shader_parse_static_samplers().

rts0_handler()

static int rts0_handler ( const struct vkd3d_shader_dxbc_section_desc *  section, struct vkd3d_shader_message_context *  message_context, void *  context  )

static

Definition at line 1032 of file dxbc.c.

{
    struct vkd3d_shader_versioned_root_signature_desc *desc = context;
 
    if (section->tag != TAG_RTS0)
        return VKD3D_OK;
 
    return shader_parse_root_signature(&section->data, desc);
}

Referenced by vkd3d_shader_parse_root_signature().

shader_extract_from_dxbc()

int shader_extract_from_dxbc	(	const struct vkd3d_shader_code *	dxbc,
		struct vkd3d_shader_message_context *	message_context,
		const char *	source_name,
		struct dxbc_shader_desc *	desc
	)

Definition at line 580 of file dxbc.c.

{
    int ret;
 
    ret = for_each_dxbc_section(dxbc, message_context, source_name, shdr_handler, desc);
    if (!desc->byte_code)
        ret = VKD3D_ERROR_INVALID_ARGUMENT;
 
    if (ret < 0)
    {
        WARN("Failed to parse shader, vkd3d result %d.\n", ret);
        free_dxbc_shader_desc(desc);
    }
 
    return ret;
}

Referenced by dxil_parse(), and tpf_parse().

shader_get_string()

static const char * shader_get_string ( const char *  data, size_t  data_size, size_t  offset  )

static

Definition at line 146 of file dxbc.c.

{
    size_t len, max_len;
 
    if (offset >= data_size)
    {
        WARN("Invalid offset %#zx (data size %#zx).\n", offset, data_size);
        return NULL;
    }
 
    max_len = data_size - offset;
    len = strnlen(data + offset, max_len);
 
    if (len == max_len)
        return NULL;
 
    return data + offset;
}

Referenced by shader_parse_signature().

shader_parse_descriptor_ranges()

static int shader_parse_descriptor_ranges ( struct root_signature_parser_context *  context, unsigned int  offset, unsigned int  count, struct vkd3d_shader_descriptor_range *  ranges  )

static

Definition at line 610 of file dxbc.c.

{
    const char *ptr;
    unsigned int i;
 
    if (!require_space(offset, 5 * count, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u, count %u).\n", context->data_size, offset, count);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    for (i = 0; i < count; ++i)
    {
        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",
                ranges[i].range_type, ranges[i].descriptor_count,
                ranges[i].base_shader_register, ranges[i].register_space,
                ranges[i].descriptor_table_offset);
    }
 
    return VKD3D_OK;
}

Referenced by shader_parse_descriptor_table().

shader_parse_descriptor_ranges1()

static int shader_parse_descriptor_ranges1 ( struct root_signature_parser_context *  context, unsigned int  offset, unsigned int  count, struct vkd3d_shader_descriptor_range1 *  ranges  )

static

Definition at line 654 of file dxbc.c.

{
    const char *ptr;
    unsigned int i;
 
    if (!require_space(offset, 6 * count, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u, count %u).\n", context->data_size, offset, count);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    for (i = 0; i < count; ++i)
    {
        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",
                ranges[i].range_type, ranges[i].descriptor_count,
                ranges[i].base_shader_register, ranges[i].register_space,
                ranges[i].flags, ranges[i].descriptor_table_offset);
 
        shader_validate_descriptor_range1(&ranges[i]);
    }
 
    return VKD3D_OK;
}

Referenced by shader_parse_descriptor_table1().

shader_parse_descriptor_table()

static int shader_parse_descriptor_table ( struct root_signature_parser_context *  context, unsigned int  offset, struct vkd3d_shader_root_descriptor_table *  table  )

static

Definition at line 688 of file dxbc.c.

{
    struct vkd3d_shader_descriptor_range *ranges;
    unsigned int count;
    const char *ptr;
 
    if (!require_space(offset, 2, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u).\n", context->data_size, offset);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    count = read_u32(&ptr);
    offset = read_u32(&ptr);
 
    TRACE("Descriptor range count %u.\n", count);
 
    table->descriptor_range_count = count;
 
    if (!(ranges = vkd3d_calloc(count, sizeof(*ranges))))
        return VKD3D_ERROR_OUT_OF_MEMORY;
    table->descriptor_ranges = ranges;
    return shader_parse_descriptor_ranges(context, offset, count, ranges);
}

Referenced by shader_parse_root_parameters().

shader_parse_descriptor_table1()

static int shader_parse_descriptor_table1 ( struct root_signature_parser_context *  context, unsigned int  offset, struct vkd3d_shader_root_descriptor_table1 *  table  )

static

Definition at line 715 of file dxbc.c.

{
    struct vkd3d_shader_descriptor_range1 *ranges;
    unsigned int count;
    const char *ptr;
 
    if (!require_space(offset, 2, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u).\n", context->data_size, offset);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    count = read_u32(&ptr);
    offset = read_u32(&ptr);
 
    TRACE("Descriptor range count %u.\n", count);
 
    table->descriptor_range_count = count;
 
    if (!(ranges = vkd3d_calloc(count, sizeof(*ranges))))
        return VKD3D_ERROR_OUT_OF_MEMORY;
    table->descriptor_ranges = ranges;
    return shader_parse_descriptor_ranges1(context, offset, count, ranges);
}

Referenced by shader_parse_root_parameters1().

shader_parse_input_signature()

int shader_parse_input_signature	(	const struct vkd3d_shader_code *	dxbc,
		struct vkd3d_shader_message_context *	message_context,
		struct shader_signature *	signature
	)

Definition at line 493 of file dxbc.c.

{
    int ret;
 
    memset(signature, 0, sizeof(*signature));
    if ((ret = for_each_dxbc_section(dxbc, message_context, NULL, isgn_handler, signature)) < 0)
        ERR("Failed to parse input signature.\n");
 
    return ret;
}

Referenced by vkd3d_shader_parse_input_signature().

shader_parse_root_constants()

static int shader_parse_root_constants ( struct root_signature_parser_context *  context, unsigned int  offset, struct vkd3d_shader_root_constants *  constants  )

static

Definition at line 742 of file dxbc.c.

{
    const char *ptr;
 
    if (!require_space(offset, 3, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u).\n", context->data_size, offset);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    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);
 
    return VKD3D_OK;
}

Referenced by shader_parse_root_parameters(), and shader_parse_root_parameters1().

shader_parse_root_descriptor()

static int shader_parse_root_descriptor ( struct root_signature_parser_context *  context, unsigned int  offset, struct vkd3d_shader_root_descriptor *  descriptor  )

static

Definition at line 764 of file dxbc.c.

{
    const char *ptr;
 
    if (!require_space(offset, 2, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u).\n", context->data_size, offset);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    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);
 
    return VKD3D_OK;
}

Referenced by shader_parse_root_parameters().

shader_parse_root_descriptor1()

static int shader_parse_root_descriptor1 ( struct root_signature_parser_context *  context, unsigned int  offset, struct vkd3d_shader_root_descriptor1 *  descriptor  )

static

Definition at line 796 of file dxbc.c.

{
    const char *ptr;
 
    if (!require_space(offset, 3, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u).\n", context->data_size, offset);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    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);
 
    shader_validate_root_descriptor1(descriptor);
 
    return VKD3D_OK;
}

Referenced by shader_parse_root_parameters1().

shader_parse_root_parameters()

static int shader_parse_root_parameters ( struct root_signature_parser_context *  context, unsigned int  offset, unsigned int  count, struct vkd3d_shader_root_parameter *  parameters  )

static

Definition at line 820 of file dxbc.c.

{
    const char *ptr;
    unsigned int i;
    int ret;
 
    if (!require_space(offset, 3 * count, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u, count %u).\n", context->data_size, offset, count);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    for (i = 0; i < count; ++i)
    {
        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);
 
        switch (parameters[i].parameter_type)
        {
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
                ret = shader_parse_descriptor_table(context, offset, &parameters[i].u.descriptor_table);
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
                ret = shader_parse_root_constants(context, offset, &parameters[i].u.constants);
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV:
                ret = shader_parse_root_descriptor(context, offset, &parameters[i].u.descriptor);
                break;
            default:
                FIXME("Unrecognized type %#x.\n", parameters[i].parameter_type);
                return VKD3D_ERROR_INVALID_ARGUMENT;
        }
 
        if (ret < 0)
            return ret;
    }
 
    return VKD3D_OK;
}

Referenced by shader_parse_root_signature().

shader_parse_root_parameters1()

static int shader_parse_root_parameters1 ( struct root_signature_parser_context *  context, uint32_t  offset, unsigned int  count, struct vkd3d_shader_root_parameter1 *  parameters  )

static

Definition at line 868 of file dxbc.c.

{
    const char *ptr;
    unsigned int i;
    int ret;
 
    if (!require_space(offset, 3 * count, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u, count %u).\n", context->data_size, offset, count);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    for (i = 0; i < count; ++i)
    {
        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);
 
        switch (parameters[i].parameter_type)
        {
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
                ret = shader_parse_descriptor_table1(context, offset, &parameters[i].u.descriptor_table);
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
                ret = shader_parse_root_constants(context, offset, &parameters[i].u.constants);
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV:
                ret = shader_parse_root_descriptor1(context, offset, &parameters[i].u.descriptor);
                break;
            default:
                FIXME("Unrecognized type %#x.\n", parameters[i].parameter_type);
                return VKD3D_ERROR_INVALID_ARGUMENT;
        }
 
        if (ret < 0)
            return ret;
    }
 
    return VKD3D_OK;
}

Referenced by shader_parse_root_signature().

shader_parse_root_signature()

static int shader_parse_root_signature ( const struct vkd3d_shader_code *  data, struct vkd3d_shader_versioned_root_signature_desc *  desc  )

static

Definition at line 949 of file dxbc.c.

{
    struct vkd3d_shader_root_signature_desc *v_1_0 = &desc->u.v_1_0;
    struct root_signature_parser_context context;
    unsigned int count, offset, version;
    const char *ptr = data->code;
    int ret;
 
    context.data = data->code;
    context.data_size = data->size;
 
    if (!require_space(0, 6, sizeof(uint32_t), data->size))
    {
        WARN("Invalid data size %#zx.\n", data->size);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    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)
    {
        FIXME("Unknown version %#x.\n", version);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    desc->version = version;
 
    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)
    {
        v_1_0->parameter_count = count;
        if (v_1_0->parameter_count)
        {
            struct vkd3d_shader_root_parameter *parameters;
            if (!(parameters = vkd3d_calloc(v_1_0->parameter_count, sizeof(*parameters))))
                return VKD3D_ERROR_OUT_OF_MEMORY;
            v_1_0->parameters = parameters;
            if ((ret = shader_parse_root_parameters(&context, offset, count, parameters)) < 0)
                return ret;
        }
    }
    else
    {
        struct vkd3d_shader_root_signature_desc1 *v_1_1 = &desc->u.v_1_1;
 
        VKD3D_ASSERT(version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1);
 
        v_1_1->parameter_count = count;
        if (v_1_1->parameter_count)
        {
            struct vkd3d_shader_root_parameter1 *parameters;
            if (!(parameters = vkd3d_calloc(v_1_1->parameter_count, sizeof(*parameters))))
                return VKD3D_ERROR_OUT_OF_MEMORY;
            v_1_1->parameters = parameters;
            if ((ret = shader_parse_root_parameters1(&context, offset, count, parameters)) < 0)
                return ret;
        }
    }
 
    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;
    if (v_1_0->static_sampler_count)
    {
        struct vkd3d_shader_static_sampler_desc *samplers;
        if (!(samplers = vkd3d_calloc(v_1_0->static_sampler_count, sizeof(*samplers))))
            return VKD3D_ERROR_OUT_OF_MEMORY;
        v_1_0->static_samplers = samplers;
        if ((ret = shader_parse_static_samplers(&context, offset, count, samplers)) < 0)
            return ret;
    }
 
    v_1_0->flags = read_u32(&ptr);
    TRACE("Flags %#x.\n", v_1_0->flags);
 
    return VKD3D_OK;
}

Referenced by rts0_handler().

shader_parse_signature()

static int shader_parse_signature ( const struct vkd3d_shader_dxbc_section_desc *  section, struct vkd3d_shader_message_context *  message_context, struct shader_signature *  s  )

static

Definition at line 368 of file dxbc.c.

{
    bool has_stream_index, has_min_precision;
    const char *data = section->data.code;
    uint32_t count, header_size;
    struct signature_element *e;
    const char *ptr = data;
    unsigned int i, j;
 
    if (!require_space(0, 2, sizeof(uint32_t), section->data.size))
    {
        WARN("Invalid data size %#zx.\n", section->data.size);
        vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_DXBC_INVALID_SIGNATURE,
                "Section size %zu is smaller than the minimum signature header size.\n", section->data.size);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    count = read_u32(&ptr);
    TRACE("%u elements.\n", count);
 
    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))
    {
        WARN("Invalid header size %#x.\n", header_size);
        vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_DXBC_INVALID_SIGNATURE,
                "Signature header size %#x is invalid.\n", header_size);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    skip_dword_unknown(&ptr, i - 2);
 
    if (!require_space(ptr - data, count, 6 * sizeof(uint32_t), section->data.size))
    {
        WARN("Invalid count %#x (data size %#zx).\n", count, section->data.size);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    if (!(e = vkd3d_calloc(count, sizeof(*e))))
    {
        ERR("Failed to allocate input signature memory.\n");
        return VKD3D_ERROR_OUT_OF_MEMORY;
    }
 
    has_min_precision = section->tag == TAG_OSG1 || section->tag == TAG_PSG1 || section->tag == TAG_ISG1;
    has_stream_index = section->tag == TAG_OSG5 || has_min_precision;
 
    for (i = 0; i < count; ++i)
    {
        size_t name_offset;
        const char *name;
        uint32_t mask;
 
        if (has_stream_index)
            e[i].stream_index = read_u32(&ptr);
        else
            e[i].stream_index = 0;
 
        name_offset = read_u32(&ptr);
        if (!(name = shader_get_string(data, section->data.size, name_offset))
                || !(e[i].semantic_name = vkd3d_strdup(name)))
        {
            WARN("Invalid name offset %#zx (data size %#zx).\n", name_offset, section->data.size);
            for (j = 0; j < i; ++j)
            {
                vkd3d_free((void *)e[j].semantic_name);
            }
            vkd3d_free(e);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
        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;
        mask = read_u32(&ptr);
        e[i].mask = mask & 0xff;
        e[i].used_mask = (mask >> 8) & 0xff;
        switch (section->tag)
        {
            case TAG_OSGN:
            case TAG_OSG1:
            case TAG_OSG5:
                if (e[i].sysval_semantic == VKD3D_SHADER_SV_NONE)
                    e[i].sysval_semantic = map_fragment_output_sysval(e[i].semantic_name);
                break;
        }
 
        if (has_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,
                e[i].component_type, e[i].register_index, e[i].used_mask, e[i].mask, e[i].min_precision);
    }
 
    s->elements = e;
    s->element_count = count;
 
    return VKD3D_OK;
}

Referenced by isgn_handler(), and shdr_handler().

shader_parse_static_samplers()

static int shader_parse_static_samplers ( struct root_signature_parser_context *  context, unsigned int  offset, unsigned int  count, struct vkd3d_shader_static_sampler_desc *  sampler_descs  )

static

Definition at line 916 of file dxbc.c.

{
    const char *ptr;
    unsigned int i;
 
    if (!require_space(offset, 13 * count, sizeof(uint32_t), context->data_size))
    {
        WARN("Invalid data size %#x (offset %u, count %u).\n", context->data_size, offset, count);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
    ptr = &context->data[offset];
 
    for (i = 0; i < count; ++i)
    {
        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;
}

Referenced by shader_parse_root_signature().

shader_validate_descriptor_range1()

static void shader_validate_descriptor_range1 ( const struct vkd3d_shader_descriptor_range1 *  range )

static

Definition at line 641 of file dxbc.c.

{
    unsigned int unknown_flags = range->flags & ~(VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_NONE
            | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE
            | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE
            | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE
            | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_STATIC
            | VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS);
 
    if (unknown_flags)
        FIXME("Unknown descriptor range flags %#x.\n", unknown_flags);
}

Referenced by shader_parse_descriptor_ranges1().

shader_validate_root_descriptor1()

static void shader_validate_root_descriptor1 ( const struct vkd3d_shader_root_descriptor1 *  descriptor )

static

Definition at line 785 of file dxbc.c.

{
    unsigned int unknown_flags = descriptor->flags & ~(VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_NONE
            | VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE
            | VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE
            | VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_STATIC);
 
    if (unknown_flags)
        FIXME("Unknown root descriptor flags %#x.\n", unknown_flags);
}

Referenced by shader_parse_root_descriptor1().

shader_write_descriptor_ranges()

static void shader_write_descriptor_ranges ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_root_descriptor_table *  table  )

static

Definition at line 1164 of file dxbc.c.

{
    const struct vkd3d_shader_descriptor_range *ranges = table->descriptor_ranges;
    unsigned int i;
 
    for (i = 0; i < table->descriptor_range_count; ++i)
    {
        put_u32(buffer, ranges[i].range_type);
        put_u32(buffer, ranges[i].descriptor_count);
        put_u32(buffer, ranges[i].base_shader_register);
        put_u32(buffer, ranges[i].register_space);
        put_u32(buffer, ranges[i].descriptor_table_offset);
    }
}

Referenced by shader_write_descriptor_table().

shader_write_descriptor_ranges1()

static void shader_write_descriptor_ranges1 ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_root_descriptor_table1 *  table  )

static

Definition at line 1180 of file dxbc.c.

{
    const struct vkd3d_shader_descriptor_range1 *ranges = table->descriptor_ranges;
    unsigned int i;
 
    for (i = 0; i < table->descriptor_range_count; ++i)
    {
        put_u32(buffer, ranges[i].range_type);
        put_u32(buffer, ranges[i].descriptor_count);
        put_u32(buffer, ranges[i].base_shader_register);
        put_u32(buffer, ranges[i].register_space);
        put_u32(buffer, ranges[i].flags);
        put_u32(buffer, ranges[i].descriptor_table_offset);
    }
}

Referenced by shader_write_descriptor_table1().

shader_write_descriptor_table()

static void shader_write_descriptor_table ( struct root_signature_writer_context *  context, const struct vkd3d_shader_root_descriptor_table *  table  )

static

Definition at line 1197 of file dxbc.c.

{
    struct vkd3d_bytecode_buffer *buffer = &context->buffer;
 
    put_u32(buffer, table->descriptor_range_count);
    put_u32(buffer, get_chunk_offset(context) + sizeof(uint32_t)); /* offset */
 
    shader_write_descriptor_ranges(buffer, table);
}

Referenced by shader_write_root_parameters().

shader_write_descriptor_table1()

static void shader_write_descriptor_table1 ( struct root_signature_writer_context *  context, const struct vkd3d_shader_root_descriptor_table1 *  table  )

static

Definition at line 1208 of file dxbc.c.

{
    struct vkd3d_bytecode_buffer *buffer = &context->buffer;
 
    put_u32(buffer, table->descriptor_range_count);
    put_u32(buffer, get_chunk_offset(context) + sizeof(uint32_t)); /* offset */
 
    shader_write_descriptor_ranges1(buffer, table);
}

Referenced by shader_write_root_parameters().

shader_write_root_constants()

static void shader_write_root_constants ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_root_constants *  constants  )

static

Definition at line 1219 of file dxbc.c.

{
    put_u32(buffer, constants->shader_register);
    put_u32(buffer, constants->register_space);
    put_u32(buffer, constants->value_count);
}

Referenced by shader_write_root_parameters().

shader_write_root_descriptor()

static void shader_write_root_descriptor ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_root_descriptor *  descriptor  )

static

Definition at line 1227 of file dxbc.c.

{
    put_u32(buffer, descriptor->shader_register);
    put_u32(buffer, descriptor->register_space);
}

Referenced by shader_write_root_parameters().

shader_write_root_descriptor1()

static void shader_write_root_descriptor1 ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_root_descriptor1 *  descriptor  )

static

Definition at line 1234 of file dxbc.c.

{
    put_u32(buffer, descriptor->shader_register);
    put_u32(buffer, descriptor->register_space);
    put_u32(buffer, descriptor->flags);
}

Referenced by shader_write_root_parameters().

shader_write_root_parameters()

static int shader_write_root_parameters ( struct root_signature_writer_context *  context, const struct vkd3d_shader_versioned_root_signature_desc *  desc  )

static

Definition at line 1242 of file dxbc.c.

{
    unsigned int parameter_count = versioned_root_signature_get_parameter_count(desc);
    struct vkd3d_bytecode_buffer *buffer = &context->buffer;
    size_t parameters_position;
    unsigned int i;
 
    parameters_position = bytecode_align(buffer);
    for (i = 0; i < parameter_count; ++i)
    {
        put_u32(buffer, versioned_root_signature_get_parameter_type(desc, i));
        put_u32(buffer, versioned_root_signature_get_parameter_shader_visibility(desc, i));
        put_u32(buffer, 0xffffffff); /* offset */
    }
 
    for (i = 0; i < parameter_count; ++i)
    {
        set_u32(buffer, parameters_position + ((3 * i + 2) * sizeof(uint32_t)), get_chunk_offset(context));
 
        switch (versioned_root_signature_get_parameter_type(desc, i))
        {
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
                if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
                    shader_write_descriptor_table(context, &desc->u.v_1_0.parameters[i].u.descriptor_table);
                else
                    shader_write_descriptor_table1(context, &desc->u.v_1_1.parameters[i].u.descriptor_table);
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
                shader_write_root_constants(buffer, versioned_root_signature_get_root_constants(desc, i));
                break;
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV:
            case VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV:
                if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
                    shader_write_root_descriptor(buffer, &desc->u.v_1_0.parameters[i].u.descriptor);
                else
                    shader_write_root_descriptor1(buffer, &desc->u.v_1_1.parameters[i].u.descriptor);
                break;
            default:
                FIXME("Unrecognized type %#x.\n", versioned_root_signature_get_parameter_type(desc, i));
                vkd3d_shader_error(&context->message_context, NULL, VKD3D_SHADER_ERROR_RS_INVALID_ROOT_PARAMETER_TYPE,
                        "Invalid/unrecognised root signature root parameter type %#x.",
                        versioned_root_signature_get_parameter_type(desc, i));
                return VKD3D_ERROR_INVALID_ARGUMENT;
        }
    }
 
    return VKD3D_OK;
}

Referenced by shader_write_root_signature().

shader_write_root_signature()

static int shader_write_root_signature ( struct root_signature_writer_context *  context, const struct vkd3d_shader_versioned_root_signature_desc *  desc  )

static

Definition at line 1317 of file dxbc.c.

{
    struct vkd3d_bytecode_buffer *buffer = &context->buffer;
    size_t samplers_offset_position;
    int ret;
 
    put_u32(buffer, desc->version);
    put_u32(buffer, versioned_root_signature_get_parameter_count(desc));
    put_u32(buffer, get_chunk_offset(context) + 4 * sizeof(uint32_t)); /* offset */
    put_u32(buffer, versioned_root_signature_get_static_sampler_count(desc));
    samplers_offset_position = put_u32(buffer, 0xffffffff);
    put_u32(buffer, versioned_root_signature_get_flags(desc));
 
    if ((ret = shader_write_root_parameters(context, desc)) < 0)
        return ret;
 
    set_u32(buffer, samplers_offset_position, get_chunk_offset(context));
    shader_write_static_samplers(buffer, desc);
    return 0;
}

Referenced by vkd3d_shader_serialize_root_signature().

shader_write_root_signature_header()

static void shader_write_root_signature_header ( struct root_signature_writer_context *  context )

static

Definition at line 1145 of file dxbc.c.

{
    struct vkd3d_bytecode_buffer *buffer = &context->buffer;
    unsigned int i;
 
    put_u32(buffer, TAG_DXBC);
 
    /* The checksum is computed when all data is generated. */
    for (i = 0; i < 4; ++i)
        put_u32(buffer, 0);
    put_u32(buffer, 1);
    context->total_size_position = put_u32(buffer, 0xffffffff);
    put_u32(buffer, 1); /* chunk count */
    put_u32(buffer, bytecode_get_size(buffer) + sizeof(uint32_t)); /* chunk offset */
    put_u32(buffer, TAG_RTS0);
    put_u32(buffer, 0xffffffff);
    context->chunk_position = bytecode_get_size(buffer);
}

Referenced by vkd3d_shader_serialize_root_signature().

shader_write_static_samplers()

static void shader_write_static_samplers ( struct vkd3d_bytecode_buffer *  buffer, const struct vkd3d_shader_versioned_root_signature_desc *  desc  )

static

Definition at line 1293 of file dxbc.c.

{
    const struct vkd3d_shader_static_sampler_desc *samplers = versioned_root_signature_get_static_samplers(desc);
    unsigned int i;
 
    for (i = 0; i < versioned_root_signature_get_static_sampler_count(desc); ++i)
    {
        put_u32(buffer, samplers[i].filter);
        put_u32(buffer, samplers[i].address_u);
        put_u32(buffer, samplers[i].address_v);
        put_u32(buffer, samplers[i].address_w);
        put_f32(buffer, samplers[i].mip_lod_bias);
        put_u32(buffer, samplers[i].max_anisotropy);
        put_u32(buffer, samplers[i].comparison_func);
        put_u32(buffer, samplers[i].border_colour);
        put_f32(buffer, samplers[i].min_lod);
        put_f32(buffer, samplers[i].max_lod);
        put_u32(buffer, samplers[i].shader_register);
        put_u32(buffer, samplers[i].register_space);
        put_u32(buffer, samplers[i].shader_visibility);
    }
}

Referenced by shader_write_root_signature().

shdr_handler()

static int shdr_handler ( const struct vkd3d_shader_dxbc_section_desc *  section, struct vkd3d_shader_message_context *  message_context, void *  context  )

static

Definition at line 505 of file dxbc.c.

{
    struct dxbc_shader_desc *desc = context;
    int ret;
 
    switch (section->tag)
    {
        case TAG_ISGN:
        case TAG_ISG1:
            if (desc->input_signature.elements)
            {
                FIXME("Multiple input signatures.\n");
                break;
            }
            if ((ret = shader_parse_signature(section, message_context, &desc->input_signature)) < 0)
                return ret;
            break;
 
        case TAG_OSGN:
        case TAG_OSG5:
        case TAG_OSG1:
            if (desc->output_signature.elements)
            {
                FIXME("Multiple output signatures.\n");
                break;
            }
            if ((ret = shader_parse_signature(section, message_context, &desc->output_signature)) < 0)
                return ret;
            break;
 
        case TAG_PCSG:
        case TAG_PSG1:
            if (desc->patch_constant_signature.elements)
            {
                FIXME("Multiple patch constant signatures.\n");
                break;
            }
            if ((ret = shader_parse_signature(section, message_context, &desc->patch_constant_signature)) < 0)
                return ret;
            break;
 
        case TAG_DXIL:
        case TAG_SHDR:
        case TAG_SHEX:
            if ((section->tag == TAG_DXIL) != desc->is_dxil)
            {
                TRACE("Skipping chunk %#x.\n", section->tag);
                break;
            }
            if (desc->byte_code)
                FIXME("Multiple shader code chunks.\n");
            desc->byte_code = section->data.code;
            desc->byte_code_size = section->data.size;
            break;
 
        case TAG_AON9:
            TRACE("Skipping AON9 shader code chunk.\n");
            break;
 
        default:
            TRACE("Skipping chunk %#x.\n", section->tag);
            break;
    }
 
    return VKD3D_OK;
}

Referenced by shader_extract_from_dxbc().

skip_dword_unknown()

static void skip_dword_unknown ( const char **  ptr, unsigned int  count  )

static

Definition at line 130 of file dxbc.c.

{
    unsigned int i;
    uint32_t d;
 
    if (!count)
        return;
 
    WARN("Skipping %u unknown DWORDs:\n", count);
    for (i = 0; i < count; ++i)
    {
        d = read_u32(ptr);
        WARN("\t0x%08x\n", d);
    }
}

Referenced by shader_parse_signature().

validate_descriptor_table_v_1_0()

static int validate_descriptor_table_v_1_0 ( const struct vkd3d_shader_root_descriptor_table *  descriptor_table, struct vkd3d_shader_message_context *  message_context  )

static

Definition at line 1339 of file dxbc.c.

{
    bool have_srv_uav_cbv = false;
    bool have_sampler = false;
    unsigned int i;
 
    for (i = 0; i < descriptor_table->descriptor_range_count; ++i)
    {
        const struct vkd3d_shader_descriptor_range *r = &descriptor_table->descriptor_ranges[i];
 
        if (r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_SRV
                || r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
                || r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_CBV)
        {
            have_srv_uav_cbv = true;
        }
        else if (r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER)
        {
            have_sampler = true;
        }
        else
        {
            WARN("Invalid descriptor range type %#x.\n", r->range_type);
            vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_RS_INVALID_DESCRIPTOR_RANGE_TYPE,
                    "Invalid root signature descriptor range type %#x.", r->range_type);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
    }
 
    if (have_srv_uav_cbv && have_sampler)
    {
        WARN("Samplers cannot be mixed with CBVs/SRVs/UAVs in descriptor tables.\n");
        vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_RS_MIXED_DESCRIPTOR_RANGE_TYPES,
                "Encountered both CBV/SRV/UAV and sampler descriptor ranges in the same root descriptor table.");
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    return VKD3D_OK;
}

Referenced by validate_root_signature_desc().

validate_descriptor_table_v_1_1()

static int validate_descriptor_table_v_1_1 ( const struct vkd3d_shader_root_descriptor_table1 *  descriptor_table, struct vkd3d_shader_message_context *  message_context  )

static

Definition at line 1380 of file dxbc.c.

{
    bool have_srv_uav_cbv = false;
    bool have_sampler = false;
    unsigned int i;
 
    for (i = 0; i < descriptor_table->descriptor_range_count; ++i)
    {
        const struct vkd3d_shader_descriptor_range1 *r = &descriptor_table->descriptor_ranges[i];
 
        if (r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_SRV
                || r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
                || r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_CBV)
        {
            have_srv_uav_cbv = true;
        }
        else if (r->range_type == VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER)
        {
            have_sampler = true;
        }
        else
        {
            WARN("Invalid descriptor range type %#x.\n", r->range_type);
            vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_RS_INVALID_DESCRIPTOR_RANGE_TYPE,
                    "Invalid root signature descriptor range type %#x.", r->range_type);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
    }
 
    if (have_srv_uav_cbv && have_sampler)
    {
        WARN("Samplers cannot be mixed with CBVs/SRVs/UAVs in descriptor tables.\n");
        vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_RS_MIXED_DESCRIPTOR_RANGE_TYPES,
                "Encountered both CBV/SRV/UAV and sampler descriptor ranges in the same root descriptor table.");
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    return VKD3D_OK;
}

Referenced by validate_root_signature_desc().

validate_root_signature_desc()

static int validate_root_signature_desc ( const struct vkd3d_shader_versioned_root_signature_desc *  desc, struct vkd3d_shader_message_context *  message_context  )

static

Definition at line 1421 of file dxbc.c.

{
    int ret = VKD3D_OK;
    unsigned int i;
 
    for (i = 0; i < versioned_root_signature_get_parameter_count(desc); ++i)
    {
        enum vkd3d_shader_root_parameter_type type;
 
        type = versioned_root_signature_get_parameter_type(desc, i);
        if (type == VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
        {
            if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
                ret = validate_descriptor_table_v_1_0(&desc->u.v_1_0.parameters[i].u.descriptor_table, message_context);
            else
                ret = validate_descriptor_table_v_1_1(&desc->u.v_1_1.parameters[i].u.descriptor_table, message_context);
        }
 
        if (ret < 0)
            break;
    }
 
    return ret;
}

Referenced by vkd3d_shader_serialize_root_signature().

versioned_root_signature_get_flags()

static unsigned int versioned_root_signature_get_flags ( const struct vkd3d_shader_versioned_root_signature_desc *  desc )

static

Definition at line 1122 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.flags;
    else
        return desc->u.v_1_1.flags;
}

Referenced by shader_write_root_signature().

versioned_root_signature_get_parameter_count()

static unsigned int versioned_root_signature_get_parameter_count ( const struct vkd3d_shader_versioned_root_signature_desc *  desc )

static

Definition at line 1068 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.parameter_count;
    else
        return desc->u.v_1_1.parameter_count;
}

Referenced by shader_write_root_parameters(), shader_write_root_signature(), and validate_root_signature_desc().

versioned_root_signature_get_parameter_shader_visibility()

static enum vkd3d_shader_visibility versioned_root_signature_get_parameter_shader_visibility ( const struct vkd3d_shader_versioned_root_signature_desc *  desc, unsigned int  i  )

static

Definition at line 1086 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.parameters[i].shader_visibility;
    else
        return desc->u.v_1_1.parameters[i].shader_visibility;
}

Referenced by shader_write_root_parameters().

versioned_root_signature_get_parameter_type()

static enum vkd3d_shader_root_parameter_type versioned_root_signature_get_parameter_type ( const struct vkd3d_shader_versioned_root_signature_desc *  desc, unsigned int  i  )

static

Definition at line 1077 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.parameters[i].parameter_type;
    else
        return desc->u.v_1_1.parameters[i].parameter_type;
}

Referenced by shader_write_root_parameters(), and validate_root_signature_desc().

versioned_root_signature_get_root_constants()

static const struct vkd3d_shader_root_constants * versioned_root_signature_get_root_constants ( const struct vkd3d_shader_versioned_root_signature_desc *  desc, unsigned int  i  )

static

Definition at line 1095 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return &desc->u.v_1_0.parameters[i].u.constants;
    else
        return &desc->u.v_1_1.parameters[i].u.constants;
}

Referenced by shader_write_root_parameters().

versioned_root_signature_get_static_sampler_count()

static unsigned int versioned_root_signature_get_static_sampler_count ( const struct vkd3d_shader_versioned_root_signature_desc *  desc )

static

Definition at line 1104 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.static_sampler_count;
    else
        return desc->u.v_1_1.static_sampler_count;
}

Referenced by shader_write_root_signature(), and shader_write_static_samplers().

versioned_root_signature_get_static_samplers()

static const struct vkd3d_shader_static_sampler_desc * versioned_root_signature_get_static_samplers ( const struct vkd3d_shader_versioned_root_signature_desc *  desc )

static

Definition at line 1113 of file dxbc.c.

{
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
        return desc->u.v_1_0.static_samplers;
    else
        return desc->u.v_1_1.static_samplers;
}

Referenced by shader_write_static_samplers().

vkd3d_shader_convert_root_signature()

int vkd3d_shader_convert_root_signature	(	struct vkd3d_shader_versioned_root_signature_desc *	dst,
		enum vkd3d_shader_root_signature_version	version,
		const struct vkd3d_shader_versioned_root_signature_desc *	src
	)

Convert a structural representation of a root signature to a different version of structural representation.

This function corresponds to ID3D12VersionedRootSignatureDeserializer::GetRootSignatureDescAtVersion().

Parameters

dst	A pointer to a vkd3d_shader_versioned_root_signature_desc structure in which the converted signature will be stored. Members of dst may be allocated by vkd3d-shader. The signature should be freed with vkd3d_shader_free_root_signature() when no longer needed.
version	The desired version to convert src to. This version must not be equal to src->version.
src	Input root signature description.

Returns

A member of vkd3d_result.

Definition at line 1756 of file dxbc.c.

{
    int ret;
 
    TRACE("dst %p, version %#x, src %p.\n", dst, version, src);
 
    if (src->version == version)
    {
        WARN("Nothing to convert.\n");
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    if (version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0 && version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1)
    {
        WARN("Root signature version %#x not supported.\n", version);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    if (src->version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0
            && src->version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1)
    {
        WARN("Root signature version %#x not supported.\n", src->version);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    memset(dst, 0, sizeof(*dst));
    dst->version = version;
 
    if (version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
    {
        ret = convert_root_signature_to_v1_0(dst, src);
    }
    else
    {
        VKD3D_ASSERT(version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1);
        ret = convert_root_signature_to_v1_1(dst, src);
    }
 
    return ret;
}

Referenced by d3d12_versioned_root_signature_deserializer_GetRootSignatureDescAtVersion(), and vkd3d_parse_root_signature_v_1_0().

vkd3d_shader_free_dxbc()

void vkd3d_shader_free_dxbc

(

struct vkd3d_shader_dxbc_desc *

dxbc

)

Free the contents of a vkd3d_shader_dxbc_desc structure allocated by another vkd3d-shader function, such as vkd3d_shader_parse_dxbc().

This function may free the vkd3d_shader_dxbc_desc::sections member, but does not free the structure itself.

Parameters

dxbc	The vkd3d_shader_dxbc_desc structure to free.

Since

1.7

Definition at line 290 of file dxbc.c.

{
    TRACE("dxbc %p.\n", dxbc);
 
    vkd3d_free(dxbc->sections);
}

Referenced by d3d10_effect_parse(), d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), d3dcompiler_strip_shader(), for_each_dxbc_section(), parse_fx10_preshader(), vkd3d_shader_parse_dxbc(), vkd3d_shader_parse_dxbc_source_type(), and wined3d_shader_extract_from_dxbc().

vkd3d_shader_parse_dxbc()

int vkd3d_shader_parse_dxbc	(	const struct vkd3d_shader_code *	dxbc,
		uint32_t	flags,
		struct vkd3d_shader_dxbc_desc *	desc,
		char **	messages
	)

Parse a DXBC blob contained in a vkd3d_shader_code structure.

Parameters

dxbc	A vkd3d_shader_code structure containing the DXBC blob to parse.
flags	A combination of zero or more elements of enum vkd3d_shader_parse_dxbc_flags.
desc	A vkd3d_shader_dxbc_desc structure describing the contents of the DXBC blob. Its vkd3d_shader_dxbc_section_desc structures will contain pointers into the input blob; its contents are only valid while the input blob is valid. The contents of this structure should be freed with vkd3d_shader_free_dxbc() when no longer needed.
messages	Optional output location for error or informational messages produced by the parser. This string is null-terminated and UTF-8 encoded. The messages are allocated by vkd3d-shader and should be freed with vkd3d_shader_free_messages() when no longer needed. If no messages are produced by the parser, this parameter may receive NULL instead of a valid string pointer.

Returns

A member of vkd3d_result.

Since

1.7

Definition at line 320 of file dxbc.c.

{
    struct vkd3d_shader_message_context message_context;
    int ret;
 
    TRACE("dxbc {%p, %zu}, flags %#x, desc %p, messages %p.\n", dxbc->code, dxbc->size, flags, desc, messages);
 
    if (messages)
        *messages = NULL;
    vkd3d_shader_message_context_init(&message_context, VKD3D_SHADER_LOG_INFO);
 
    ret = parse_dxbc(dxbc, &message_context, NULL, flags, desc);
 
    vkd3d_shader_message_context_trace_messages(&message_context);
    if (!vkd3d_shader_message_context_copy_messages(&message_context, messages) && ret >= 0)
    {
        vkd3d_shader_free_dxbc(desc);
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
    }
    vkd3d_shader_message_context_cleanup(&message_context);
 
    if (ret < 0)
        memset(desc, 0, sizeof(*desc));
 
    return ret;
}

Referenced by d3d10_effect_parse(), d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), d3dcompiler_strip_shader(), parse_fx10_preshader(), vkd3d_shader_parse_dxbc_source_type(), and wined3d_shader_extract_from_dxbc().

vkd3d_shader_parse_root_signature()

int vkd3d_shader_parse_root_signature	(	const struct vkd3d_shader_code *	dxbc,
		struct vkd3d_shader_versioned_root_signature_desc *	root_signature,
		char **	messages
	)

Convert a byte code description of a shader root signature to a structural description which can be easily parsed by C code.

This function corresponds to ID3D12VersionedRootSignatureDeserializer::GetUnconvertedRootSignatureDesc().

This function performs the reverse transformation of vkd3d_shader_serialize_root_signature().

This function parses a standalone root signature, and should not be confused with vkd3d_shader_parse_input_signature().

Parameters

dxbc	Compiled byte code, in DXBC format.
root_signature	Output location in which the decompiled root signature will be stored. Members of root_signature may be allocated by vkd3d-shader. The signature should be freed with vkd3d_shader_free_root_signature() when no longer needed.
messages	Optional output location for error or informational messages produced by the parser. This string is null-terminated and UTF-8 encoded. The messages are allocated by vkd3d-shader and should be freed with vkd3d_shader_free_messages() when no longer needed. If no messages are produced by the parser, this parameter may receive NULL instead of a valid string pointer.

Returns

A member of vkd3d_result.

Definition at line 1043 of file dxbc.c.

{
    struct vkd3d_shader_message_context message_context;
    int ret;
 
    TRACE("dxbc {%p, %zu}, root_signature %p, messages %p.\n", dxbc->code, dxbc->size, root_signature, messages);
 
    memset(root_signature, 0, sizeof(*root_signature));
    if (messages)
        *messages = NULL;
    vkd3d_shader_message_context_init(&message_context, VKD3D_SHADER_LOG_INFO);
 
    ret = for_each_dxbc_section(dxbc, &message_context, NULL, rts0_handler, root_signature);
    vkd3d_shader_message_context_trace_messages(&message_context);
    if (!vkd3d_shader_message_context_copy_messages(&message_context, messages))
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
 
    vkd3d_shader_message_context_cleanup(&message_context);
    if (ret < 0)
        vkd3d_shader_free_root_signature(root_signature);
 
    return ret;
}

Referenced by d3d12_versioned_root_signature_deserializer_init(), and vkd3d_parse_root_signature_v_1_0().

vkd3d_shader_serialize_dxbc()

int vkd3d_shader_serialize_dxbc	(	size_t	section_count,
		const struct vkd3d_shader_dxbc_section_desc *	sections,
		struct vkd3d_shader_code *	dxbc,
		char **	messages
	)

Serialize a DXBC description into a blob stored in a vkd3d_shader_code structure.

Parameters

section_count	The number of DXBC sections to serialize.
sections	An array of vkd3d_shader_dxbc_section_desc structures to serialize.
dxbc	A pointer to a vkd3d_shader_code structure in which the serialized blob will be stored. The output blob is allocated by vkd3d-shader and should be freed with vkd3d_shader_free_shader_code() when no longer needed.
messages	Optional output location for error or informational messages produced by the serializer. This string is null-terminated and UTF-8 encoded. The messages are allocated by vkd3d-shader and should be freed with vkd3d_shader_free_messages() when no longer needed. If no messages are produced by the serializer, this parameter may receive NULL instead of a valid string pointer.

Returns

A member of vkd3d_result.

Since

1.7

Definition at line 53 of file dxbc.c.

{
    size_t size_position, offsets_position, checksum_position, i;
    struct vkd3d_bytecode_buffer buffer = {0};
    uint32_t checksum[4];
 
    TRACE("section_count %zu, sections %p, dxbc %p, messages %p.\n", section_count, sections, dxbc, messages);
 
    if (messages)
        *messages = NULL;
 
    put_u32(&buffer, TAG_DXBC);
 
    checksum_position = bytecode_get_size(&buffer);
    for (i = 0; i < 4; ++i)
        put_u32(&buffer, 0);
 
    put_u32(&buffer, 1); /* version */
    size_position = put_u32(&buffer, 0);
    put_u32(&buffer, section_count);
 
    offsets_position = bytecode_get_size(&buffer);
    for (i = 0; i < section_count; ++i)
        put_u32(&buffer, 0);
 
    for (i = 0; i < section_count; ++i)
    {
        set_u32(&buffer, offsets_position + i * sizeof(uint32_t), bytecode_align(&buffer));
        put_u32(&buffer, sections[i].tag);
        put_u32(&buffer, sections[i].data.size);
        bytecode_put_bytes(&buffer, sections[i].data.code, sections[i].data.size);
    }
    set_u32(&buffer, size_position, bytecode_get_size(&buffer));
 
    compute_dxbc_checksum(buffer.data, buffer.size, checksum);
    for (i = 0; i < 4; ++i)
        set_u32(&buffer, checksum_position + i * sizeof(uint32_t), checksum[i]);
 
    if (!buffer.status)
    {
        dxbc->code = buffer.data;
        dxbc->size = buffer.size;
    }
    return buffer.status;
}

Referenced by D3DCompile2(), d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), and dxbc_writer_write().

vkd3d_shader_serialize_root_signature()

int vkd3d_shader_serialize_root_signature	(	const struct vkd3d_shader_versioned_root_signature_desc *	root_signature,
		struct vkd3d_shader_code *	dxbc,
		char **	messages
	)

Convert a structural description of a shader root signature to a byte code format capable of being read by ID3D12Device::CreateRootSignature. The compiled signature is compatible with Microsoft D3D 12.

This function corresponds to D3D12SerializeVersionedRootSignature().

Parameters

root_signature	Description of the root signature.
dxbc	A pointer to a vkd3d_shader_code structure in which the compiled code will be stored. The compiled signature is allocated by vkd3d-shader and should be freed with vkd3d_shader_free_shader_code() when no longer needed.
messages	Optional output location for error or informational messages produced by the serializer. This string is null-terminated and UTF-8 encoded. The messages are allocated by vkd3d-shader and should be freed with vkd3d_shader_free_messages() when no longer needed. If no messages are produced by the serializer, this parameter may receive NULL instead of a valid string pointer.

Returns

A member of vkd3d_result.

Definition at line 1447 of file dxbc.c.

{
    struct root_signature_writer_context context;
    size_t total_size, chunk_size;
    uint32_t checksum[4];
    unsigned int i;
    int ret;
 
    TRACE("root_signature %p, dxbc %p, messages %p.\n", root_signature, dxbc, messages);
 
    if (messages)
        *messages = NULL;
 
    memset(&context, 0, sizeof(context));
    vkd3d_shader_message_context_init(&context.message_context, VKD3D_SHADER_LOG_INFO);
 
    if (root_signature->version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0
            && root_signature->version != VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1)
    {
        ret = VKD3D_ERROR_INVALID_ARGUMENT;
        WARN("Root signature version %#x not supported.\n", root_signature->version);
        vkd3d_shader_error(&context.message_context, NULL, VKD3D_SHADER_ERROR_RS_INVALID_VERSION,
                "Root signature version %#x is not supported.", root_signature->version);
        goto done;
    }
 
    if ((ret = validate_root_signature_desc(root_signature, &context.message_context)) < 0)
        goto done;
 
    memset(dxbc, 0, sizeof(*dxbc));
    shader_write_root_signature_header(&context);
 
    if ((ret = shader_write_root_signature(&context, root_signature)) < 0)
    {
        vkd3d_free(context.buffer.data);
        goto done;
    }
 
    if (context.buffer.status)
    {
        vkd3d_shader_error(&context.message_context, NULL, VKD3D_SHADER_ERROR_RS_OUT_OF_MEMORY,
                "Out of memory while writing root signature.");
        vkd3d_free(context.buffer.data);
        goto done;
    }
 
    total_size = bytecode_get_size(&context.buffer);
    chunk_size = get_chunk_offset(&context);
    set_u32(&context.buffer, context.total_size_position, total_size);
    set_u32(&context.buffer, context.chunk_position - sizeof(uint32_t), chunk_size);
 
    dxbc->code = context.buffer.data;
    dxbc->size = total_size;
 
    compute_dxbc_checksum(dxbc->code, dxbc->size, checksum);
    for (i = 0; i < 4; ++i)
        set_u32(&context.buffer, (i + 1) * sizeof(uint32_t), checksum[i]);
 
    ret = VKD3D_OK;
 
done:
    vkd3d_shader_message_context_trace_messages(&context.message_context);
    if (!vkd3d_shader_message_context_copy_messages(&context.message_context, messages))
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
    vkd3d_shader_message_context_cleanup(&context.message_context);
    return ret;
}

Referenced by vkd3d_serialize_root_signature(), and vkd3d_serialize_versioned_root_signature().