#include "vkd3d_shader_private.h"
#include "vkd3d_version.h"
#include "hlsl.h"
#include <stdio.h>
#include <math.h>

Include dependency graph for vkd3d_shader_main.c:

Classes
struct	shader_dump_data

struct	vkd3d_shader_scan_context

struct	vkd3d_shader_scan_context::vkd3d_shader_cf_info

Functions
static int	char_to_int (char c)

uint32_t	vkd3d_parse_integer (const char *s)

void	vkd3d_string_buffer_init (struct vkd3d_string_buffer *buffer)

void	vkd3d_string_buffer_cleanup (struct vkd3d_string_buffer *buffer)

void	vkd3d_string_buffer_clear (struct vkd3d_string_buffer *buffer)

void	vkd3d_string_buffer_truncate (struct vkd3d_string_buffer *buffer, size_t size)

static bool	vkd3d_string_buffer_resize (struct vkd3d_string_buffer *buffer, int rc)

int	vkd3d_string_buffer_vprintf (struct vkd3d_string_buffer buffer, const char format, va_list args)

int	vkd3d_string_buffer_printf (struct vkd3d_string_buffer buffer, const char format,...)

int	vkd3d_string_buffer_print_f32 (struct vkd3d_string_buffer *buffer, float f)

int	vkd3d_string_buffer_print_f64 (struct vkd3d_string_buffer *buffer, double d)

void	vkd3d_string_buffer_trace_ (const struct vkd3d_string_buffer buffer, const char function)

void	vkd3d_shader_trace_text_ (const char text, size_t size, const char function)

void	vkd3d_string_buffer_cache_init (struct vkd3d_string_buffer_cache *cache)

void	vkd3d_string_buffer_cache_cleanup (struct vkd3d_string_buffer_cache *cache)

struct vkd3d_string_buffer *	vkd3d_string_buffer_get (struct vkd3d_string_buffer_cache *cache)

void	vkd3d_string_buffer_release (struct vkd3d_string_buffer_cache cache, struct vkd3d_string_buffer buffer)

void	vkd3d_shader_code_from_string_buffer (struct vkd3d_shader_code code, struct vkd3d_string_buffer buffer)

void	vkd3d_shader_message_context_init (struct vkd3d_shader_message_context *context, enum vkd3d_shader_log_level log_level)

void	vkd3d_shader_message_context_cleanup (struct vkd3d_shader_message_context *context)

void	vkd3d_shader_message_context_trace_messages_ (const struct vkd3d_shader_message_context context, const char function)

bool	vkd3d_shader_message_context_copy_messages (struct vkd3d_shader_message_context context, char *out)

void	vkd3d_shader_vnote (struct vkd3d_shader_message_context context, const struct vkd3d_shader_location location, enum vkd3d_shader_log_level level, const char *format, va_list args)

void	vkd3d_shader_vwarning (struct vkd3d_shader_message_context context, const struct vkd3d_shader_location location, enum vkd3d_shader_error error, const char *format, va_list args)

void	vkd3d_shader_warning (struct vkd3d_shader_message_context context, const struct vkd3d_shader_location location, enum vkd3d_shader_error error, const char *format,...)

void	vkd3d_shader_verror (struct vkd3d_shader_message_context context, const struct vkd3d_shader_location location, enum vkd3d_shader_error error, const char *format, va_list args)

void	vkd3d_shader_error (struct vkd3d_shader_message_context context, const struct vkd3d_shader_location location, enum vkd3d_shader_error error, const char *format,...)

size_t	bytecode_align (struct vkd3d_bytecode_buffer *buffer)

size_t	bytecode_put_bytes_unaligned (struct vkd3d_bytecode_buffer buffer, const void bytes, size_t size)

size_t	bytecode_put_bytes (struct vkd3d_bytecode_buffer buffer, const void bytes, size_t size)

size_t	bytecode_reserve_bytes (struct vkd3d_bytecode_buffer *buffer, size_t size)

static void	bytecode_set_bytes (struct vkd3d_bytecode_buffer buffer, size_t offset, const void value, size_t size)

void	set_u32 (struct vkd3d_bytecode_buffer *buffer, size_t offset, uint32_t value)

void	set_string (struct vkd3d_bytecode_buffer buffer, size_t offset, const char string, size_t length)

static void	vkd3d_shader_dump_shader (const struct shader_dump_data dump_data, const void data, size_t size, bool source)

static const char *	shader_get_source_type_suffix (enum vkd3d_shader_source_type type)

static const char *	shader_get_target_type_suffix (enum vkd3d_shader_target_type type)

static void	fill_shader_dump_data (const struct vkd3d_shader_compile_info compile_info, struct shader_dump_data data)

static void	init_scan_signature_info (const struct vkd3d_shader_compile_info *info)

uint64_t	vkd3d_shader_init_config_flags (void)

void	vkd3d_shader_parser_init (struct vkd3d_shader_parser parser, struct vsir_program program, struct vkd3d_shader_message_context message_context, const char source_name)

void	VKD3D_PRINTF_FUNC (3, 4)

static int	vkd3d_shader_validate_compile_info (const struct vkd3d_shader_compile_info *compile_info, bool validate_target_type)

static enum vkd3d_result	vsir_parse (const struct vkd3d_shader_compile_info compile_info, uint64_t config_flags, struct vkd3d_shader_message_context message_context, struct vsir_program *program)

void	vkd3d_shader_free_messages (char *messages)

static bool	vkd3d_shader_signature_from_shader_signature (struct vkd3d_shader_signature signature, const struct shader_signature src)

static void	vkd3d_shader_scan_context_init (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_version version, const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_scan_descriptor_info1 scan_descriptor_info, struct vkd3d_shader_scan_combined_resource_sampler_info combined_sampler_info, struct vkd3d_shader_message_context message_context)

static void	vkd3d_shader_scan_context_cleanup (struct vkd3d_shader_scan_context *context)

static struct vkd3d_shader_cf_info *	vkd3d_shader_scan_get_current_cf_info (struct vkd3d_shader_scan_context *context)

static struct vkd3d_shader_cf_info *	vkd3d_shader_scan_push_cf_info (struct vkd3d_shader_scan_context *context)

static void	vkd3d_shader_scan_pop_cf_info (struct vkd3d_shader_scan_context *context)

static struct vkd3d_shader_cf_info *	vkd3d_shader_scan_find_innermost_breakable_cf_info (struct vkd3d_shader_scan_context *context)

static struct vkd3d_shader_cf_info *	vkd3d_shader_scan_find_innermost_loop_cf_info (struct vkd3d_shader_scan_context *context)

static void	vkd3d_shader_scan_add_uav_flag (const struct vkd3d_shader_scan_context context, const struct vkd3d_shader_register reg, uint32_t flag)

static bool	vkd3d_shader_instruction_is_uav_read (const struct vkd3d_shader_instruction *instruction)

static void	vkd3d_shader_scan_record_uav_read (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_register reg)

static bool	vkd3d_shader_instruction_is_uav_counter (const struct vkd3d_shader_instruction *instruction)

static void	vkd3d_shader_scan_record_uav_counter (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_register reg)

static bool	vkd3d_shader_instruction_is_uav_atomic_op (const struct vkd3d_shader_instruction *instruction)

static void	vkd3d_shader_scan_record_uav_atomic_op (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_register reg)

static struct vkd3d_shader_descriptor_info1 *	vkd3d_shader_scan_add_descriptor (struct vkd3d_shader_scan_context context, enum vkd3d_shader_descriptor_type type, const struct vkd3d_shader_register reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_resource_data_type resource_data_type)

static void	vkd3d_shader_scan_constant_buffer_declaration (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_instruction instruction)

static void	vkd3d_shader_scan_sampler_declaration (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_instruction instruction)

static void	vkd3d_shader_scan_combined_sampler_declaration (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_semantic semantic)

static const struct vkd3d_shader_descriptor_info1 *	find_descriptor (const struct vkd3d_shader_scan_descriptor_info1 *info, enum vkd3d_shader_descriptor_type type, unsigned int register_id)

static void	vkd3d_shader_scan_combined_sampler_usage (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_register resource, const struct vkd3d_shader_register *sampler)

static void	vkd3d_shader_scan_resource_declaration (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_resource resource, enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_resource_data_type resource_data_type, unsigned int sample_count, unsigned int structure_stride, bool raw, uint32_t flags)

static void	vkd3d_shader_scan_typed_resource_declaration (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_instruction instruction)

static int	vkd3d_shader_scan_instruction (struct vkd3d_shader_scan_context context, const struct vkd3d_shader_instruction instruction)

static enum vkd3d_result	convert_descriptor_info (struct vkd3d_shader_scan_descriptor_info info, const struct vkd3d_shader_scan_descriptor_info1 info1)

static void	vkd3d_shader_free_scan_descriptor_info1 (struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info)

static int	vsir_program_scan (struct vsir_program program, const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_message_context message_context, struct vkd3d_shader_scan_descriptor_info1 descriptor_info1)

int	vkd3d_shader_scan (const struct vkd3d_shader_compile_info compile_info, char *messages)

int	vsir_program_compile (struct vsir_program program, uint64_t config_flags, const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_code out, struct vkd3d_shader_message_context message_context)

static int	compile_hlsl (const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_code out, struct vkd3d_shader_message_context *message_context)

int	vkd3d_shader_compile (const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_code out, char **messages)

void	vkd3d_shader_free_scan_combined_resource_sampler_info (struct vkd3d_shader_scan_combined_resource_sampler_info *info)

void	vkd3d_shader_free_scan_descriptor_info (struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info)

void	vkd3d_shader_free_scan_signature_info (struct vkd3d_shader_scan_signature_info *info)

void	vkd3d_shader_free_shader_code (struct vkd3d_shader_code *shader_code)

static void	vkd3d_shader_free_root_signature_v_1_0 (struct vkd3d_shader_root_signature_desc *root_signature)

static void	vkd3d_shader_free_root_signature_v_1_1 (struct vkd3d_shader_root_signature_desc1 *root_signature)

void	vkd3d_shader_free_root_signature (struct vkd3d_shader_versioned_root_signature_desc *desc)

void	shader_signature_cleanup (struct shader_signature *signature)

int	vkd3d_shader_parse_input_signature (const struct vkd3d_shader_code dxbc, struct vkd3d_shader_signature signature, char **messages)

struct vkd3d_shader_signature_element *	vkd3d_shader_find_signature_element (const struct vkd3d_shader_signature signature, const char semantic_name, unsigned int semantic_index, unsigned int stream_index)

void	vkd3d_shader_free_shader_signature (struct vkd3d_shader_signature *signature)

const char *	vkd3d_shader_get_version (unsigned int major, unsigned int minor)

enum vkd3d_shader_source_type *	vkd3d_shader_get_supported_source_types (unsigned int *count)

enum vkd3d_shader_target_type *	vkd3d_shader_get_supported_target_types (enum vkd3d_shader_source_type source_type, unsigned int *count)

int	vkd3d_shader_preprocess (const struct vkd3d_shader_compile_info compile_info, struct vkd3d_shader_code out, char **messages)

void	vkd3d_shader_set_log_callback (PFN_vkd3d_log callback)

static struct vkd3d_shader_param_node *	shader_param_allocator_node_create (struct vkd3d_shader_param_allocator *allocator)

static void	shader_param_allocator_init (struct vkd3d_shader_param_allocator *allocator, unsigned int count, unsigned int stride)

static void	shader_param_allocator_destroy (struct vkd3d_shader_param_allocator *allocator)

void *	shader_param_allocator_get (struct vkd3d_shader_param_allocator *allocator, unsigned int count)

bool	shader_instruction_array_init (struct vkd3d_shader_instruction_array *instructions, unsigned int reserve)

bool	shader_instruction_array_reserve (struct vkd3d_shader_instruction_array *instructions, unsigned int reserve)

bool	shader_instruction_array_insert_at (struct vkd3d_shader_instruction_array *instructions, unsigned int idx, unsigned int count)

bool	shader_instruction_array_add_icb (struct vkd3d_shader_instruction_array instructions, struct vkd3d_shader_immediate_constant_buffer icb)

static struct vkd3d_shader_src_param *	shader_instruction_array_clone_src_params (struct vkd3d_shader_instruction_array instructions, const struct vkd3d_shader_src_param params, unsigned int count)

static bool	shader_register_clone_relative_addresses (struct vkd3d_shader_register reg, struct vkd3d_shader_instruction_array instructions)

static struct vkd3d_shader_dst_param *	shader_instruction_array_clone_dst_params (struct vkd3d_shader_instruction_array instructions, const struct vkd3d_shader_dst_param params, unsigned int count)

bool	shader_instruction_array_clone_instruction (struct vkd3d_shader_instruction_array *instructions, unsigned int dst, unsigned int src)

void	shader_instruction_array_destroy (struct vkd3d_shader_instruction_array *instructions)

void	vkd3d_shader_build_varying_map (const struct vkd3d_shader_signature output_signature, const struct vkd3d_shader_signature input_signature, unsigned int ret_count, struct vkd3d_shader_varying_map varyings)

Variables
static const struct vkd3d_debug_option	vkd3d_shader_config_options []

Function Documentation

◆ bytecode_align()

size_t bytecode_align ( struct vkd3d_bytecode_buffer * buffer )

Definition at line 370 of file vkd3d_shader_main.c.

{
    size_t aligned_size = align(buffer->size, 4);
 
    if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->capacity, aligned_size, 1))
    {
        buffer->status = VKD3D_ERROR_OUT_OF_MEMORY;
        return aligned_size;
    }
 
    memset(buffer->data + buffer->size, 0xab, aligned_size - buffer->size);
    buffer->size = aligned_size;
    return aligned_size;
}

Referenced by add_section(), bytecode_put_bytes(), bytecode_reserve_bytes(), shader_write_root_parameters(), vkd3d_shader_serialize_dxbc(), write_sm1_type(), write_sm1_uniforms(), write_sm4_rdef(), and write_sm4_type().

◆ bytecode_put_bytes()

size_t bytecode_put_bytes	(	struct vkd3d_bytecode_buffer *	buffer,
		const void *	bytes,
		size_t	size
	)

Definition at line 402 of file vkd3d_shader_main.c.

{
    bytecode_align(buffer);
    return bytecode_put_bytes_unaligned(buffer, bytes, size);
}

Referenced by d3dbc_compile(), hlsl_fx_2_write(), hlsl_fx_4_write(), hlsl_fx_5_write(), put_f32(), put_string(), put_u32(), vkd3d_shader_serialize_dxbc(), write_fx_2_object_initializer(), and write_fx_2_string().

◆ bytecode_put_bytes_unaligned()

size_t bytecode_put_bytes_unaligned	(	struct vkd3d_bytecode_buffer *	buffer,
		const void *	bytes,
		size_t	size
	)

Definition at line 385 of file vkd3d_shader_main.c.

{
    size_t offset = buffer->size;
 
    if (buffer->status)
        return offset;
 
    if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->capacity, offset + size, 1))
    {
        buffer->status = VKD3D_ERROR_OUT_OF_MEMORY;
        return offset;
    }
    memcpy(buffer->data + offset, bytes, size);
    buffer->size = offset + size;
    return offset;
}

Referenced by bytecode_put_bytes(), hlsl_fx_4_write(), hlsl_fx_5_write(), put_u32_unaligned(), write_fx_2_string(), and write_fx_4_string().

◆ bytecode_reserve_bytes()

size_t bytecode_reserve_bytes	(	struct vkd3d_bytecode_buffer *	buffer,
		size_t	size
	)

Definition at line 408 of file vkd3d_shader_main.c.

{
    size_t offset = bytecode_align(buffer);
 
    if (buffer->status)
        return offset;
 
    if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->capacity, offset + size, 1))
    {
        buffer->status = VKD3D_ERROR_OUT_OF_MEMORY;
        return offset;
    }
 
    memset(buffer->data + offset, 0, size);
    buffer->size = offset + size;
    return offset;
}

Referenced by write_sm1_uniforms(), and write_sm4_rdef().

◆ bytecode_set_bytes()

static void bytecode_set_bytes	(	struct vkd3d_bytecode_buffer *	buffer,
		size_t	offset,
		const void *	value,
		size_t	size
	)

static

Definition at line 426 of file vkd3d_shader_main.c.

{
    if (buffer->status)
        return;
 
    VKD3D_ASSERT(vkd3d_bound_range(offset, size, buffer->size));
    memcpy(buffer->data + offset, value, size);
}

Referenced by set_string(), and set_u32().

◆ char_to_int()

static int char_to_int ( char c )

inlinestatic

Definition at line 26 of file vkd3d_shader_main.c.

{
    if ('0' <= c && c <= '9')
        return c - '0';
    if ('A' <= c && c <= 'F')
        return c - 'A' + 10;
    if ('a' <= c && c <= 'f')
        return c - 'a' + 10;
    return -1;
}

Referenced by vkd3d_parse_integer().

◆ compile_hlsl()

static int compile_hlsl	(	const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_code *	out,
		struct vkd3d_shader_message_context *	message_context
	)

static

Definition at line 1693 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_code preprocessed;
    int ret;
 
    if ((ret = preproc_lexer_parse(compile_info, &preprocessed, message_context)))
        return ret;
 
    ret = hlsl_compile_shader(&preprocessed, compile_info, out, message_context);
 
    vkd3d_shader_free_shader_code(&preprocessed);
    return ret;
}

Referenced by vkd3d_shader_compile().

◆ convert_descriptor_info()

static enum vkd3d_result convert_descriptor_info	(	struct vkd3d_shader_scan_descriptor_info *	info,
		const struct vkd3d_shader_scan_descriptor_info1 *	info1
	)

static

Definition at line 1467 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    if (!(info->descriptors = vkd3d_calloc(info1->descriptor_count, sizeof(*info->descriptors))))
        return VKD3D_ERROR_OUT_OF_MEMORY;
 
    for (i = 0; i < info1->descriptor_count; ++i)
    {
        const struct vkd3d_shader_descriptor_info1 *src = &info1->descriptors[i];
        struct vkd3d_shader_descriptor_info *dst = &info->descriptors[i];
 
        dst->type = src->type;
        dst->register_space = src->register_space;
        dst->register_index = src->register_index;
        dst->resource_type = src->resource_type;
        dst->resource_data_type = src->resource_data_type;
        dst->flags = src->flags;
        dst->count = src->count;
    }
    info->descriptor_count = info1->descriptor_count;
 
    return VKD3D_OK;
}

Referenced by vsir_program_scan().

◆ fill_shader_dump_data()

static void fill_shader_dump_data	(	const struct vkd3d_shader_compile_info *	compile_info,
		struct shader_dump_data *	data
	)

static

Definition at line 544 of file vkd3d_shader_main.c.

{
    static bool enabled = true;
 
    data->path = NULL;
 
    if (!enabled)
        return;
 
    if (!(data->path = getenv("VKD3D_SHADER_DUMP_PATH")))
    {
        enabled = false;
        return;
    }
 
    data->profile = NULL;
    if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL)
    {
        const struct vkd3d_shader_hlsl_source_info *hlsl_source_info;
 
        if ((hlsl_source_info = vkd3d_find_struct(compile_info->next, HLSL_SOURCE_INFO)))
            data->profile = hlsl_source_info->profile;
    }
 
    vkd3d_compute_md5(compile_info->source.code, compile_info->source.size,
            (uint32_t *)data->checksum, VKD3D_MD5_STANDARD);
    data->source_suffix = shader_get_source_type_suffix(compile_info->source_type);
    data->target_suffix = shader_get_target_type_suffix(compile_info->target_type);
}

Referenced by vkd3d_shader_compile(), and vkd3d_shader_scan().

◆ find_descriptor()

static const struct vkd3d_shader_descriptor_info1 * find_descriptor	(	const struct vkd3d_shader_scan_descriptor_info1 *	info,
		enum vkd3d_shader_descriptor_type	type,
		unsigned int	register_id
	)

static

Definition at line 1057 of file vkd3d_shader_main.c.

{
    for (unsigned int i = 0; i < info->descriptor_count; ++i)
    {
        const struct vkd3d_shader_descriptor_info1 *d = &info->descriptors[i];
 
        if (d->type == type && d->register_id == register_id)
            return d;
    }
 
    return NULL;
}

Referenced by vkd3d_shader_scan_combined_sampler_usage().

◆ init_scan_signature_info()

static void init_scan_signature_info ( const struct vkd3d_shader_compile_info * info )

static

Definition at line 575 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_scan_signature_info *signature_info;
 
    if ((signature_info = vkd3d_find_struct(info->next, SCAN_SIGNATURE_INFO)))
    {
        memset(&signature_info->input, 0, sizeof(signature_info->input));
        memset(&signature_info->output, 0, sizeof(signature_info->output));
        memset(&signature_info->patch_constant, 0, sizeof(signature_info->patch_constant));
    }
}

Referenced by vkd3d_shader_compile(), and vkd3d_shader_scan().

◆ set_string()

void set_string	(	struct vkd3d_bytecode_buffer *	buffer,
		size_t	offset,
		const char *	string,
		size_t	length
	)

Definition at line 441 of file vkd3d_shader_main.c.

{
    bytecode_set_bytes(buffer, offset, string, length);
}

◆ set_u32()

void set_u32	(	struct vkd3d_bytecode_buffer *	buffer,
		size_t	offset,
		uint32_t	value
	)

◆ shader_get_source_type_suffix()

static const char * shader_get_source_type_suffix ( enum vkd3d_shader_source_type type )

static

Definition at line 500 of file vkd3d_shader_main.c.

{
    switch (type)
    {
        case VKD3D_SHADER_SOURCE_DXBC_TPF:
            return "dxbc";
        case VKD3D_SHADER_SOURCE_HLSL:
            return "hlsl";
        case VKD3D_SHADER_SOURCE_D3D_BYTECODE:
            return "d3dbc";
        case VKD3D_SHADER_SOURCE_DXBC_DXIL:
            return "dxil";
        default:
            FIXME("Unhandled source type %#x.\n", type);
            return "bin";
    }
}

Referenced by fill_shader_dump_data().

◆ shader_get_target_type_suffix()

static const char * shader_get_target_type_suffix ( enum vkd3d_shader_target_type type )

static

Definition at line 518 of file vkd3d_shader_main.c.

{
    switch (type)
    {
        case VKD3D_SHADER_TARGET_SPIRV_BINARY:
            return "spv";
        case VKD3D_SHADER_TARGET_SPIRV_TEXT:
            return "spv.s";
        case VKD3D_SHADER_TARGET_D3D_ASM:
            return "d3d.s";
        case VKD3D_SHADER_TARGET_D3D_BYTECODE:
            return "d3dbc";
        case VKD3D_SHADER_TARGET_DXBC_TPF:
            return "dxbc";
        case VKD3D_SHADER_TARGET_GLSL:
            return "glsl";
        case VKD3D_SHADER_TARGET_FX:
            return "fx";
        case VKD3D_SHADER_TARGET_MSL:
            return "msl";
        default:
            FIXME("Unhandled target type %#x.\n", type);
            return "bin";
    }
}

Referenced by fill_shader_dump_data().

◆ shader_instruction_array_add_icb()

bool shader_instruction_array_add_icb	(	struct vkd3d_shader_instruction_array *	instructions,
		struct vkd3d_shader_immediate_constant_buffer *	icb
	)

Definition at line 2171 of file vkd3d_shader_main.c.

{
    if (!vkd3d_array_reserve((void **)&instructions->icbs, &instructions->icb_capacity, instructions->icb_count + 1,
            sizeof(*instructions->icbs)))
        return false;
    instructions->icbs[instructions->icb_count++] = icb;
    return true;
}

Referenced by shader_sm4_read_shader_data(), and value_allocate_constant_array().

◆ shader_instruction_array_clone_dst_params()

static struct vkd3d_shader_dst_param * shader_instruction_array_clone_dst_params	(	struct vkd3d_shader_instruction_array *	instructions,
		const struct vkd3d_shader_dst_param *	params,
		unsigned int	count
	)

static

Definition at line 2202 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_dst_param *dst_params;
    unsigned int i;
 
    if (!(dst_params = shader_dst_param_allocator_get(&instructions->dst_params, count)))
        return NULL;
 
    memcpy(dst_params, params, count * sizeof(*params));
    for (i = 0; i < count; ++i)
    {
        if (!shader_register_clone_relative_addresses(&dst_params[i].reg, instructions))
            return NULL;
    }
 
    return dst_params;
}

Referenced by shader_instruction_array_clone_instruction().

◆ shader_instruction_array_clone_instruction()

bool shader_instruction_array_clone_instruction	(	struct vkd3d_shader_instruction_array *	instructions,
		unsigned int	dst,
		unsigned int	src
	)

Definition at line 2244 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_instruction *ins = &instructions->elements[dst];
 
    *ins = instructions->elements[src];
 
    if (ins->dst_count && ins->dst && !(ins->dst = shader_instruction_array_clone_dst_params(instructions,
            ins->dst, ins->dst_count)))
        return false;
 
    return !ins->src_count || !!(ins->src = shader_instruction_array_clone_src_params(instructions,
            ins->src, ins->src_count));
}

Referenced by flattener_flatten_phases().

◆ shader_instruction_array_clone_src_params()

static struct vkd3d_shader_src_param * shader_instruction_array_clone_src_params	(	struct vkd3d_shader_instruction_array *	instructions,
		const struct vkd3d_shader_src_param *	params,
		unsigned int	count
	)

static

Definition at line 2222 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_src_param *src_params;
    unsigned int i;
 
    if (!(src_params = shader_src_param_allocator_get(&instructions->src_params, count)))
        return NULL;
 
    memcpy(src_params, params, count * sizeof(*params));
    for (i = 0; i < count; ++i)
    {
        if (!shader_register_clone_relative_addresses(&src_params[i].reg, instructions))
            return NULL;
    }
 
    return src_params;
}

Referenced by shader_instruction_array_clone_instruction(), and shader_register_clone_relative_addresses().

◆ shader_instruction_array_destroy()

void shader_instruction_array_destroy ( struct vkd3d_shader_instruction_array * instructions )

Definition at line 2259 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    vkd3d_free(instructions->elements);
    shader_param_allocator_destroy(&instructions->dst_params);
    shader_param_allocator_destroy(&instructions->src_params);
    for (i = 0; i < instructions->icb_count; ++i)
        vkd3d_free(instructions->icbs[i]);
    vkd3d_free(instructions->icbs);
}

Referenced by spirv_compiler_generate_spirv(), and vsir_program_cleanup().

◆ shader_instruction_array_init()

bool shader_instruction_array_init	(	struct vkd3d_shader_instruction_array *	instructions,
		unsigned int	reserve
	)

Definition at line 2132 of file vkd3d_shader_main.c.

{
    memset(instructions, 0, sizeof(*instructions));
    /* Size the parameter initial allocations so they are large enough for most shaders. The
     * code path for chained allocations will be tested if a few shaders need to use it. */
    shader_param_allocator_init(&instructions->dst_params, reserve - reserve / 8u,
            sizeof(*instructions->elements->dst));
    shader_param_allocator_init(&instructions->src_params, reserve * 2u, sizeof(*instructions->elements->src));
    return shader_instruction_array_reserve(instructions, reserve);
}

Referenced by vsir_program_init().

◆ shader_instruction_array_insert_at()

bool shader_instruction_array_insert_at	(	struct vkd3d_shader_instruction_array *	instructions,
		unsigned int	idx,
		unsigned int	count
	)

Definition at line 2154 of file vkd3d_shader_main.c.

{
    VKD3D_ASSERT(idx <= instructions->count);
 
    if (!shader_instruction_array_reserve(instructions, instructions->count + count))
        return false;
 
    memmove(&instructions->elements[idx + count], &instructions->elements[idx],
            (instructions->count - idx) * sizeof(*instructions->elements));
    memset(&instructions->elements[idx], 0, count * sizeof(*instructions->elements));
 
    instructions->count += count;
 
    return true;
}

Referenced by insert_alpha_test_before_ret(), insert_clip_planes_before_ret(), insert_point_size_before_ret(), vsir_program_ensure_diffuse(), vsir_program_ensure_ret(), vsir_program_insert_point_coord(), vsir_program_insert_point_size_clamp(), vsir_program_lower_ifc(), vsir_program_lower_precise_mad(), vsir_program_lower_sm1_sincos(), vsir_program_lower_texkill(), and vsir_program_remap_output_signature().

◆ shader_instruction_array_reserve()

bool shader_instruction_array_reserve	(	struct vkd3d_shader_instruction_array *	instructions,
		unsigned int	reserve
	)

Definition at line 2143 of file vkd3d_shader_main.c.

{
    if (!vkd3d_array_reserve((void **)&instructions->elements, &instructions->capacity, reserve,
            sizeof(*instructions->elements)))
    {
        ERR("Failed to allocate instructions.\n");
        return false;
    }
    return true;
}

Referenced by control_point_normaliser_emit_hs_input(), d3dbc_parse(), flattener_flatten_phases(), generate_vsir_add_program_instruction(), shader_instruction_array_init(), shader_instruction_array_insert_at(), sm1_generate_vsir_constant_defs(), sm1_generate_vsir_sampler_dcls(), sm6_parser_require_space(), tpf_parse(), and vsir_program_flatten_hull_shader_phases().

◆ shader_param_allocator_destroy()

static void shader_param_allocator_destroy ( struct vkd3d_shader_param_allocator * allocator )

static

Definition at line 2094 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_param_node *current = allocator->head;
 
    while (current)
    {
        struct vkd3d_shader_param_node *next = current->next;
        vkd3d_free(current);
        current = next;
    }
}

Referenced by shader_instruction_array_destroy().

◆ shader_param_allocator_get()

void * shader_param_allocator_get	(	struct vkd3d_shader_param_allocator *	allocator,
		unsigned int	count
	)

Definition at line 2106 of file vkd3d_shader_main.c.

{
    void *params;
 
    if (!allocator->current || count > allocator->count - allocator->index)
    {
        struct vkd3d_shader_param_node *next;
 
        /* Monolithic switch has no definite parameter count limit. */
        allocator->count = max(allocator->count, count);
 
        if (!(next = shader_param_allocator_node_create(allocator)))
            return NULL;
        if (allocator->current)
            allocator->current->next = next;
        else
            allocator->head = next;
        allocator->current = next;
        allocator->index = 0;
    }
 
    params = &allocator->current->param[allocator->index * allocator->stride];
    allocator->index += count;
    return params;
}

Referenced by shader_dst_param_allocator_get(), and shader_src_param_allocator_get().

◆ shader_param_allocator_init()

static void shader_param_allocator_init	(	struct vkd3d_shader_param_allocator *	allocator,
		unsigned int	count,
		unsigned int	stride
	)

static

Definition at line 2084 of file vkd3d_shader_main.c.

{
    allocator->count = max(count, MAX_REG_OUTPUT);
    allocator->stride = stride;
    allocator->head = NULL;
    allocator->current = NULL;
    allocator->index = allocator->count;
}

Referenced by shader_instruction_array_init().

◆ shader_param_allocator_node_create()

static struct vkd3d_shader_param_node * shader_param_allocator_node_create ( struct vkd3d_shader_param_allocator * allocator )

static

Definition at line 2073 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_param_node *node;
 
    if (!(node = vkd3d_malloc(offsetof(struct vkd3d_shader_param_node, param[allocator->count * allocator->stride]))))
        return NULL;
    node->next = NULL;
    return node;
}

Referenced by shader_param_allocator_get().

◆ shader_register_clone_relative_addresses()

static bool shader_register_clone_relative_addresses	(	struct vkd3d_shader_register *	reg,
		struct vkd3d_shader_instruction_array *	instructions
	)

static

Definition at line 2185 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    for (i = 0; i < reg->idx_count; ++i)
    {
        if (!reg->idx[i].rel_addr)
            continue;
 
        if (!(reg->idx[i].rel_addr = shader_instruction_array_clone_src_params(instructions, reg->idx[i].rel_addr, 1)))
            return false;
    }
 
    return true;
}

Referenced by shader_instruction_array_clone_dst_params(), and shader_instruction_array_clone_src_params().

◆ shader_signature_cleanup()

void shader_signature_cleanup ( struct shader_signature * signature )

Definition at line 1846 of file vkd3d_shader_main.c.

{
    for (unsigned int i = 0; i < signature->element_count; ++i)
    {
        vkd3d_free((void *)signature->elements[i].semantic_name);
    }
    vkd3d_free(signature->elements);
    signature->elements = NULL;
    signature->elements_capacity = 0;
    signature->element_count = 0;
}

Referenced by free_dxbc_shader_desc(), isgn_handler(), sm6_parser_init(), sm6_parser_read_signature(), spirv_compiler_destroy(), tpf_parse(), vkd3d_shader_parse_input_signature(), and vsir_program_cleanup().

◆ vkd3d_parse_integer()

uint32_t vkd3d_parse_integer ( const char * s )

Definition at line 37 of file vkd3d_shader_main.c.

{
    uint32_t base = 10, ret = 0;
    int digit;
 
    if (*s == '0')
    {
        base = 8;
        ++s;
        if (*s == 'x' || *s == 'X')
        {
            base = 16;
            ++s;
        }
    }
 
    while ((digit = char_to_int(*s++)) >= 0)
        ret = ret * base + (uint32_t)digit;
    return ret;
}

◆ VKD3D_PRINTF_FUNC()

static void VKD3D_PRINTF_FUNC	(	3	,
		4
	)

Definition at line 616 of file vkd3d_shader_main.c.

{
    va_list args;
 
    va_start(args, format);
    vkd3d_shader_verror(parser->message_context, &parser->location, error, format, args);
    va_end(args);
 
    parser->failed = true;
}

◆ vkd3d_shader_build_varying_map()

void vkd3d_shader_build_varying_map	(	const struct vkd3d_shader_signature *	output_signature,
		const struct vkd3d_shader_signature *	input_signature,
		unsigned int *	count,
		struct vkd3d_shader_varying_map *	varyings
	)

Build a mapping of output varyings in a shader stage to input varyings in the following shader stage.

This mapping should be used in struct vkd3d_shader_varying_map_info to compile the first shader.

Parameters

output_signature	The output signature of the first shader.
input_signature	The input signature of the second shader.
count	On output, contains the number of entries written into "varyings".
varyings	Pointer to an output array of varyings. This must point to space for N varyings, where N is the number of elements in the input signature.

Remarks: Valid legacy Direct3D pixel shaders have at most 12 varying inputs: 10 inter-stage varyings, face, and position. Therefore, in practice, it is safe to call this function with a pre-allocated array with a fixed size of 12.

Since: 1.9

Definition at line 2271 of file vkd3d_shader_main.c.

{
    unsigned int count = 0;
    unsigned int i;
 
    TRACE("output_signature %p, input_signature %p, ret_count %p, varyings %p.\n",
            output_signature, input_signature, ret_count, varyings);
 
    for (i = 0; i < input_signature->element_count; ++i)
    {
        const struct vkd3d_shader_signature_element *input_element, *output_element;
 
        input_element = &input_signature->elements[i];
 
        if (input_element->sysval_semantic != VKD3D_SHADER_SV_NONE)
            continue;
 
        varyings[count].input_register_index = input_element->register_index;
        varyings[count].input_mask = input_element->mask;
 
        if ((output_element = vkd3d_shader_find_signature_element(output_signature,
                input_element->semantic_name, input_element->semantic_index, 0)))
        {
            varyings[count].output_signature_index = output_element - output_signature->elements;
        }
        else
        {
            varyings[count].output_signature_index = output_signature->element_count;
        }
 
        ++count;
    }
 
    *ret_count = count;
}

Referenced by shader_spirv_compile_arguments_init().

◆ vkd3d_shader_code_from_string_buffer()

void vkd3d_shader_code_from_string_buffer	(	struct vkd3d_shader_code *	code,
		struct vkd3d_string_buffer *	buffer
	)

Definition at line 235 of file vkd3d_shader_main.c.

{
    code->code = buffer->buffer;
    code->size = buffer->content_size;
 
    buffer->buffer = NULL;
    buffer->buffer_size = 0;
    buffer->content_size = 0;
}

Referenced by d3d_asm_compile(), fx_parse(), and msl_generator_generate().

◆ vkd3d_shader_compile()

int vkd3d_shader_compile	(	const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_code *	out,
		char **	messages
	)

Transform a form of GPU shader source code or byte code into another form of source code or byte code.

This version of vkd3d-shader supports the following transformations:

VKD3D_SHADER_SOURCE_DXBC_TPF to VKD3D_SHADER_TARGET_SPIRV_BINARY
VKD3D_SHADER_SOURCE_DXBC_TPF to VKD3D_SHADER_TARGET_SPIRV_TEXT (if vkd3d was compiled with SPIRV-Tools)
VKD3D_SHADER_SOURCE_DXBC_TPF to VKD3D_SHADER_TARGET_D3D_ASM
VKD3D_SHADER_SOURCE_D3D_BYTECODE to VKD3D_SHADER_TARGET_SPIRV_BINARY
VKD3D_SHADER_SOURCE_D3D_BYTECODE to VKD3D_SHADER_TARGET_SPIRV_TEXT (if vkd3d was compiled with SPIRV-Tools)
VKD3D_SHADER_SOURCE_D3D_BYTECODE to VKD3D_SHADER_TARGET_D3D_ASM
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_SPIRV_BINARY
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_SPIRV_TEXT (if vkd3d was compiled with SPIRV-Tools)
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_D3D_ASM
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_D3D_BYTECODE
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_DXBC_TPF
VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_FX
VKD3D_SHADER_SOURCE_FX to VKD3D_SHADER_TARGET_D3D_ASM

Supported transformations can also be detected at runtime with the functions vkd3d_shader_get_supported_source_types() and vkd3d_shader_get_supported_target_types().

Depending on the source and target types, this function may support the following chained structures:

Parameters

compile_info	A chained structure containing compilation parameters.
out	A pointer to a vkd3d_shader_code structure in which the compiled code will be stored. The compiled shader 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 compiler. 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. The messages returned can be regulated with the log_level member of struct vkd3d_shader_compile_info. Regardless of the requested level, if this parameter is NULL, no compilation messages will be returned. If no messages are produced by the compiler, this parameter may receive NULL instead of a valid string pointer.

Returns: A member of vkd3d_result.

Definition at line 1708 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_message_context message_context;
    struct shader_dump_data dump_data;
    int ret;
 
    TRACE("compile_info %p, out %p, messages %p.\n", compile_info, out, messages);
 
    if (messages)
        *messages = NULL;
 
    if ((ret = vkd3d_shader_validate_compile_info(compile_info, true)) < 0)
        return ret;
 
    init_scan_signature_info(compile_info);
 
    vkd3d_shader_message_context_init(&message_context, compile_info->log_level);
 
    fill_shader_dump_data(compile_info, &dump_data);
    vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, true);
 
    if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL)
    {
        ret = compile_hlsl(compile_info, out, &message_context);
    }
    else if (compile_info->source_type == VKD3D_SHADER_SOURCE_FX)
    {
        ret = fx_parse(compile_info, out, &message_context);
    }
    else
    {
        uint64_t config_flags = vkd3d_shader_init_config_flags();
        struct vsir_program program;
 
        if (!(ret = vsir_parse(compile_info, config_flags, &message_context, &program)))
        {
            ret = vsir_program_compile(&program, config_flags, compile_info, out, &message_context);
            vsir_program_cleanup(&program);
        }
    }
 
    if (ret >= 0)
        vkd3d_shader_dump_shader(&dump_data, out->code, out->size, false);
 
    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);
    return ret;
}

Referenced by compile_hlsl_cs(), compile_hlsl_shader(), create_shader_stage(), D3DCompile2(), D3DDisassemble(), fx_4_parse_shader_initializer(), shader_glsl_generate_vkd3d_shader(), shader_spirv_compile_shader(), and shader_trace().

◆ vkd3d_shader_dump_shader()

static void vkd3d_shader_dump_shader	(	const struct shader_dump_data *	dump_data,
		const void *	data,
		size_t	size,
		bool	source
	)

static

Definition at line 455 of file vkd3d_shader_main.c.

{
    static const char hexadecimal_digits[] = "0123456789abcdef";
    const uint8_t *checksum = dump_data->checksum;
    char str_checksum[33];
    unsigned int pos = 0;
    char filename[1024];
    unsigned int i;
    FILE *f;
 
    if (!dump_data->path)
        return;
 
    for (i = 0; i < ARRAY_SIZE(dump_data->checksum); ++i)
    {
        str_checksum[2 * i] = hexadecimal_digits[checksum[i] >> 4];
        str_checksum[2 * i + 1] = hexadecimal_digits[checksum[i] & 0xf];
    }
    str_checksum[32] = '\0';
 
    pos = snprintf(filename, ARRAY_SIZE(filename), "%s/vkd3d-shader-%s", dump_data->path, str_checksum);
 
    if (dump_data->profile)
        pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-%s", dump_data->profile);
 
    if (source)
        pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-source.%s", dump_data->source_suffix);
    else
        pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-target.%s", dump_data->target_suffix);
 
    TRACE("Dumping shader to \"%s\".\n", filename);
    if ((f = fopen(filename, "wb")))
    {
        if (fwrite(data, 1, size, f) != size)
            WARN("Failed to write shader to %s.\n", filename);
        if (fclose(f))
            WARN("Failed to close stream %s.\n", filename);
    }
    else
    {
        WARN("Failed to open %s for dumping shader.\n", filename);
    }
}

Referenced by vkd3d_shader_compile(), and vkd3d_shader_scan().

◆ vkd3d_shader_error()

void vkd3d_shader_error	(	struct vkd3d_shader_message_context *	context,
		const struct vkd3d_shader_location *	location,
		enum vkd3d_shader_error	error,
		const char *	format,
			...
	)

Definition at line 360 of file vkd3d_shader_main.c.

{
    va_list args;
 
    va_start(args, format);
    vkd3d_shader_verror(context, location, error, format, args);
    va_end(args);
}

◆ vkd3d_shader_find_signature_element()

struct vkd3d_shader_signature_element * vkd3d_shader_find_signature_element	(	const struct vkd3d_shader_signature *	signature,
		const char *	semantic_name,
		unsigned int	semantic_index,
		unsigned int	stream_index
	)

Find a single element of a parsed input signature.

Parameters

signature	The parsed input signature. This structure is normally populated by vkd3d_shader_parse_input_signature().
semantic_name	Semantic name of the desired element. This function performs a case-insensitive comparison with respect to the ASCII plane.
semantic_index	Semantic index of the desired element.
stream_index	Geometry shader stream index of the desired element. If the signature is not a geometry shader output signature, this parameter must be set to 0.

Returns: A description of the element matching the requested parameters, or NULL if no such element was found. If not NULL, the return value points into the signature parameter and should not be explicitly freed.

Definition at line 1885 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_signature_element *e;
    unsigned int i;
 
    TRACE("signature %p, semantic_name %s, semantic_index %u, stream_index %u.\n",
            signature, debugstr_a(semantic_name), semantic_index, stream_index);
 
    e = signature->elements;
    for (i = 0; i < signature->element_count; ++i)
    {
        if (!ascii_strcasecmp(e[i].semantic_name, semantic_name)
                && e[i].semantic_index == semantic_index
                && e[i].stream_index == stream_index)
            return &e[i];
    }
 
    return NULL;
}

Referenced by d3d12_pipeline_state_init_graphics(), and vkd3d_shader_build_varying_map().

◆ vkd3d_shader_free_messages()

void vkd3d_shader_free_messages ( char * messages )

Free shader messages allocated by another vkd3d-shader function, such as vkd3d_shader_compile().

Parameters

messages Messages to free. This pointer is optional and may be NULL, in which case no action will be taken.

Definition at line 728 of file vkd3d_shader_main.c.

{
    TRACE("messages %p.\n", messages);
 
    vkd3d_free(messages);
}

Referenced by compile_hlsl_shader(), D3DCompile2(), D3DDisassemble(), preprocess_shader(), shader_glsl_generate_vkd3d_shader(), shader_spirv_compile_shader(), shader_spirv_scan_shader(), shader_trace(), vkd3d_serialize_root_signature(), and vkd3d_serialize_versioned_root_signature().

◆ vkd3d_shader_free_root_signature()

void vkd3d_shader_free_root_signature ( struct vkd3d_shader_versioned_root_signature_desc * root_signature )

Free a structural representation of a shader root signature allocated by vkd3d_shader_convert_root_signature() or vkd3d_shader_parse_root_signature().

This function may free members of struct vkd3d_shader_versioned_root_signature_desc, but does not free the structure itself.

Parameters

root_signature Signature description to free.

Definition at line 1825 of file vkd3d_shader_main.c.

{
    TRACE("desc %p.\n", desc);
 
    if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
    {
        vkd3d_shader_free_root_signature_v_1_0(&desc->u.v_1_0);
    }
    else if (desc->version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1)
    {
        vkd3d_shader_free_root_signature_v_1_1(&desc->u.v_1_1);
    }
    else if (desc->version)
    {
        FIXME("Unknown version %#x.\n", desc->version);
        return;
    }
 
    desc->version = 0;
}

Referenced by d3d12_root_signature_create(), d3d12_root_signature_deserializer_Release(), d3d12_versioned_root_signature_deserializer_Release(), vkd3d_parse_root_signature_v_1_0(), and vkd3d_shader_parse_root_signature().

◆ vkd3d_shader_free_root_signature_v_1_0()

static void vkd3d_shader_free_root_signature_v_1_0 ( struct vkd3d_shader_root_signature_desc * root_signature )

static

Definition at line 1791 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    for (i = 0; i < root_signature->parameter_count; ++i)
    {
        const struct vkd3d_shader_root_parameter *parameter = &root_signature->parameters[i];
 
        if (parameter->parameter_type == VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
            vkd3d_free((void *)parameter->u.descriptor_table.descriptor_ranges);
    }
    vkd3d_free((void *)root_signature->parameters);
    vkd3d_free((void *)root_signature->static_samplers);
 
    memset(root_signature, 0, sizeof(*root_signature));
}

Referenced by vkd3d_shader_free_root_signature().

◆ vkd3d_shader_free_root_signature_v_1_1()

static void vkd3d_shader_free_root_signature_v_1_1 ( struct vkd3d_shader_root_signature_desc1 * root_signature )

static

Definition at line 1808 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    for (i = 0; i < root_signature->parameter_count; ++i)
    {
        const struct vkd3d_shader_root_parameter1 *parameter = &root_signature->parameters[i];
 
        if (parameter->parameter_type == VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
            vkd3d_free((void *)parameter->u.descriptor_table.descriptor_ranges);
    }
    vkd3d_free((void *)root_signature->parameters);
    vkd3d_free((void *)root_signature->static_samplers);
 
    memset(root_signature, 0, sizeof(*root_signature));
}

Referenced by vkd3d_shader_free_root_signature().

◆ vkd3d_shader_free_scan_combined_resource_sampler_info()

void vkd3d_shader_free_scan_combined_resource_sampler_info ( struct vkd3d_shader_scan_combined_resource_sampler_info * info )

Free members of struct vkd3d_shader_scan_combined_resource_sampler_info allocated by vkd3d_shader_scan().

This function may free members of vkd3d_shader_scan_combined_resource_sampler_info, but does not free the structure itself.

Parameters

info	Combined resource-sampler information to free.

Since: 1.10

Definition at line 1760 of file vkd3d_shader_main.c.

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

Referenced by vsir_program_compile(), and vsir_program_scan().

◆ vkd3d_shader_free_scan_descriptor_info()

void vkd3d_shader_free_scan_descriptor_info ( struct vkd3d_shader_scan_descriptor_info * scan_descriptor_info )

Free members of struct vkd3d_shader_scan_descriptor_info() allocated by vkd3d_shader_scan().

This function may free members of vkd3d_shader_scan_descriptor_info, but does not free the structure itself.

Parameters

scan_descriptor_info Descriptor information to free.

Definition at line 1768 of file vkd3d_shader_main.c.

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

Referenced by d3d12_pipeline_state_find_and_init_uav_counters(), shader_spirv_destroy(), shader_spirv_destroy_compute_vk(), and vsir_program_scan().

◆ vkd3d_shader_free_scan_descriptor_info1()

static void vkd3d_shader_free_scan_descriptor_info1 ( struct vkd3d_shader_scan_descriptor_info1 * scan_descriptor_info )

static

Definition at line 1493 of file vkd3d_shader_main.c.

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

Referenced by vsir_program_compile(), and vsir_program_scan().

◆ vkd3d_shader_free_scan_signature_info()

void vkd3d_shader_free_scan_signature_info ( struct vkd3d_shader_scan_signature_info * info )

Free members of struct vkd3d_shader_scan_signature_info allocated by vkd3d_shader_scan().

This function may free members of vkd3d_shader_scan_signature_info, but does not free the structure itself.

Parameters

info	Scan information to free.

Since: 1.9

Definition at line 1775 of file vkd3d_shader_main.c.

{
    TRACE("info %p.\n", info);
 
    vkd3d_shader_free_shader_signature(&info->input);
    vkd3d_shader_free_shader_signature(&info->output);
    vkd3d_shader_free_shader_signature(&info->patch_constant);
}

Referenced by shader_spirv_destroy(), and vsir_program_scan().

◆ vkd3d_shader_free_shader_code()

void vkd3d_shader_free_shader_code ( struct vkd3d_shader_code * code )

Free shader code allocated by another vkd3d-shader function, such as vkd3d_shader_compile().

This function frees the vkd3d_shader_code::code member, but does not free the structure itself.

Parameters

code	Code to free.

Definition at line 1784 of file vkd3d_shader_main.c.

{
    TRACE("shader_code %p.\n", shader_code);
 
    vkd3d_free((void *)shader_code->code);
}

Referenced by compile_hlsl(), create_shader_stage(), create_uav_pipeline(), D3DCompile2(), d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), D3DDisassemble(), fx_4_parse_shader_initializer(), hlsl_compile_shader(), hlsl_emit_bytecode(), preprocess_shader(), shader_glsl_generate_vkd3d_shader(), shader_spirv_compile_shader(), shader_trace(), spirv_compiler_generate_spirv(), tpf_compile(), vkd3d_serialize_root_signature(), vkd3d_serialize_versioned_root_signature(), vkd3d_uav_clear_state_init(), and vsir_program_trace().

◆ vkd3d_shader_free_shader_signature()

void vkd3d_shader_free_shader_signature ( struct vkd3d_shader_signature * signature )

Free a structural representation of a shader input signature allocated by vkd3d_shader_parse_input_signature().

This function may free members of struct vkd3d_shader_signature, but does not free the structure itself.

Parameters

signature Signature description to free.

Definition at line 1907 of file vkd3d_shader_main.c.

{
    TRACE("signature %p.\n", signature);
 
    for (unsigned int i = 0; i < signature->element_count; ++i)
    {
        vkd3d_free((void *)signature->elements[i].semantic_name);
    }
    vkd3d_free(signature->elements);
    signature->elements = NULL;
}

Referenced by d3d11_input_layout_to_wined3d_declaration(), d3d12_pipeline_state_init_graphics(), and vkd3d_shader_free_scan_signature_info().

◆ vkd3d_shader_get_supported_source_types()

enum vkd3d_shader_source_type * vkd3d_shader_get_supported_source_types ( unsigned int * count )

Returns the source types supported, with any target type, by vkd3d_shader_compile(). Future versions of the library may introduce additional source types; callers should ignore unrecognised source types.

Use vkd3d_shader_get_supported_target_types() to determine which target types are supported for each source type.

Parameters

count Output location for the size, in elements, of the returned array.

Returns: Pointer to an array of source types supported by this version of vkd3d-shader. This array may be a pointer to static data in libvkd3d-shader; it should not be freed.

Definition at line 1937 of file vkd3d_shader_main.c.

{
    static const enum vkd3d_shader_source_type types[] =
    {
        VKD3D_SHADER_SOURCE_DXBC_TPF,
        VKD3D_SHADER_SOURCE_HLSL,
        VKD3D_SHADER_SOURCE_D3D_BYTECODE,
#ifdef VKD3D_SHADER_UNSUPPORTED_DXIL
        VKD3D_SHADER_SOURCE_DXBC_DXIL,
#endif
        VKD3D_SHADER_SOURCE_FX,
    };
 
    TRACE("count %p.\n", count);
 
    *count = ARRAY_SIZE(types);
    return types;
}

Referenced by vkd3d_shader_validate_compile_info().

◆ vkd3d_shader_get_supported_target_types()

enum vkd3d_shader_target_type * vkd3d_shader_get_supported_target_types	(	enum vkd3d_shader_source_type	source_type,
		unsigned int *	count
	)

Returns the target types supported, with the given source type, by vkd3d_shader_compile(). Future versions of the library may introduce additional target types; callers should ignore unrecognised target types.

Parameters

source_type	Source type for which to enumerate supported target types.
count	Output location for the size, in elements, of the returned array.

Returns: Pointer to an array of target types supported by this version of vkd3d-shader. This array may be a pointer to static data in libvkd3d-shader; it should not be freed.

Definition at line 1956 of file vkd3d_shader_main.c.

{
    static const enum vkd3d_shader_target_type dxbc_tpf_types[] =
    {
        VKD3D_SHADER_TARGET_SPIRV_BINARY,
#ifdef HAVE_SPIRV_TOOLS
        VKD3D_SHADER_TARGET_SPIRV_TEXT,
#endif
        VKD3D_SHADER_TARGET_D3D_ASM,
#ifdef VKD3D_SHADER_UNSUPPORTED_GLSL
        VKD3D_SHADER_TARGET_GLSL,
#endif
#ifdef VKD3D_SHADER_UNSUPPORTED_MSL
        VKD3D_SHADER_TARGET_MSL,
#endif
    };
 
    static const enum vkd3d_shader_target_type hlsl_types[] =
    {
        VKD3D_SHADER_TARGET_SPIRV_BINARY,
#ifdef HAVE_SPIRV_TOOLS
        VKD3D_SHADER_TARGET_SPIRV_TEXT,
#endif
        VKD3D_SHADER_TARGET_D3D_ASM,
        VKD3D_SHADER_TARGET_D3D_BYTECODE,
        VKD3D_SHADER_TARGET_DXBC_TPF,
        VKD3D_SHADER_TARGET_FX,
    };
 
    static const enum vkd3d_shader_target_type d3dbc_types[] =
    {
        VKD3D_SHADER_TARGET_SPIRV_BINARY,
#ifdef HAVE_SPIRV_TOOLS
        VKD3D_SHADER_TARGET_SPIRV_TEXT,
#endif
        VKD3D_SHADER_TARGET_D3D_ASM,
    };
 
#ifdef VKD3D_SHADER_UNSUPPORTED_DXIL
    static const enum vkd3d_shader_target_type dxbc_dxil_types[] =
    {
        VKD3D_SHADER_TARGET_SPIRV_BINARY,
# ifdef HAVE_SPIRV_TOOLS
        VKD3D_SHADER_TARGET_SPIRV_TEXT,
# endif
        VKD3D_SHADER_TARGET_D3D_ASM,
    };
#endif
 
    static const enum vkd3d_shader_target_type fx_types[] =
    {
        VKD3D_SHADER_TARGET_D3D_ASM,
    };
 
    TRACE("source_type %#x, count %p.\n", source_type, count);
 
    switch (source_type)
    {
        case VKD3D_SHADER_SOURCE_DXBC_TPF:
            *count = ARRAY_SIZE(dxbc_tpf_types);
            return dxbc_tpf_types;
 
        case VKD3D_SHADER_SOURCE_HLSL:
            *count = ARRAY_SIZE(hlsl_types);
            return hlsl_types;
 
        case VKD3D_SHADER_SOURCE_D3D_BYTECODE:
            *count = ARRAY_SIZE(d3dbc_types);
            return d3dbc_types;
 
#ifdef VKD3D_SHADER_UNSUPPORTED_DXIL
        case VKD3D_SHADER_SOURCE_DXBC_DXIL:
            *count = ARRAY_SIZE(dxbc_dxil_types);
            return dxbc_dxil_types;
#endif
 
        case VKD3D_SHADER_SOURCE_FX:
            *count = ARRAY_SIZE(fx_types);
            return fx_types;
 
        default:
            *count = 0;
            return NULL;
    }
}

Referenced by vkd3d_shader_validate_compile_info().

◆ vkd3d_shader_get_version()

const char * vkd3d_shader_get_version	(	unsigned int *	major,
		unsigned int *	minor
	)

Returns the current version of this library.

Parameters

major	Output location for the major version of this library.
minor	Output location for the minor version of this library.

Returns: A human-readable string describing the library name and version. This string is null-terminated and UTF-8 encoded. This may be a pointer to static data in libvkd3d-shader; it should not be freed.

Definition at line 1919 of file vkd3d_shader_main.c.

{
    int x, y;
 
    TRACE("major %p, minor %p.\n", major, minor);
 
    if (major || minor)
    {
        vkd3d_parse_version(PACKAGE_VERSION, &x, &y);
        if (major)
            *major = x;
        if (minor)
            *minor = y;
    }
 
    return "vkd3d-shader " PACKAGE_VERSION VKD3D_VCS_ID;
}

Referenced by msl_generator_generate(), shader_glsl_alloc(), vkd3d_glsl_generator_generate(), wined3d_spirv_shader_backend_init_vk(), write_sm1_uniforms(), and write_sm4_rdef().

◆ vkd3d_shader_init_config_flags()

uint64_t vkd3d_shader_init_config_flags ( void )

Definition at line 592 of file vkd3d_shader_main.c.

{
    uint64_t config_flags;
    const char *config;
 
    config = getenv("VKD3D_SHADER_CONFIG");
    config_flags = vkd3d_parse_debug_options(config, vkd3d_shader_config_options, ARRAY_SIZE(vkd3d_shader_config_options));
 
    if (config_flags)
        TRACE("VKD3D_SHADER_CONFIG='%s'.\n", config);
 
    return config_flags;
}

Referenced by hlsl_compile_shader(), hlsl_emit_bytecode(), vkd3d_shader_compile(), and vkd3d_shader_scan().

◆ vkd3d_shader_instruction_is_uav_atomic_op()

static bool vkd3d_shader_instruction_is_uav_atomic_op ( const struct vkd3d_shader_instruction * instruction )

static

Definition at line 976 of file vkd3d_shader_main.c.

{
    enum vkd3d_shader_opcode opcode = instruction->opcode;
 
    return (VKD3DSIH_ATOMIC_AND <= opcode && opcode <= VKD3DSIH_ATOMIC_XOR)
            || (VKD3DSIH_IMM_ATOMIC_ALLOC <= opcode && opcode <= VKD3DSIH_IMM_ATOMIC_XOR);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_instruction_is_uav_counter()

static bool vkd3d_shader_instruction_is_uav_counter ( const struct vkd3d_shader_instruction * instruction )

static

Definition at line 963 of file vkd3d_shader_main.c.

{
    enum vkd3d_shader_opcode opcode = instruction->opcode;
 
    return opcode == VKD3DSIH_IMM_ATOMIC_ALLOC || opcode == VKD3DSIH_IMM_ATOMIC_CONSUME;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_instruction_is_uav_read()

static bool vkd3d_shader_instruction_is_uav_read ( const struct vkd3d_shader_instruction * instruction )

static

Definition at line 946 of file vkd3d_shader_main.c.

{
    enum vkd3d_shader_opcode opcode = instruction->opcode;
 
    return (VKD3DSIH_ATOMIC_AND <= opcode && opcode <= VKD3DSIH_ATOMIC_XOR)
            || (VKD3DSIH_IMM_ATOMIC_ALLOC <= opcode && opcode <= VKD3DSIH_IMM_ATOMIC_XOR)
            || opcode == VKD3DSIH_LD_UAV_TYPED
            || (opcode == VKD3DSIH_LD_RAW && instruction->src[1].reg.type == VKD3DSPR_UAV)
            || (opcode == VKD3DSIH_LD_STRUCTURED && instruction->src[2].reg.type == VKD3DSPR_UAV);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_message_context_cleanup()

void vkd3d_shader_message_context_cleanup ( struct vkd3d_shader_message_context * context )

Definition at line 252 of file vkd3d_shader_main.c.

{
    vkd3d_string_buffer_cleanup(&context->messages);
}

Referenced by vkd3d_shader_compile(), vkd3d_shader_parse_dxbc(), vkd3d_shader_parse_input_signature(), vkd3d_shader_parse_root_signature(), vkd3d_shader_preprocess(), vkd3d_shader_scan(), and vkd3d_shader_serialize_root_signature().

◆ vkd3d_shader_message_context_copy_messages()

bool vkd3d_shader_message_context_copy_messages	(	struct vkd3d_shader_message_context *	context,
		char **	out
	)

Definition at line 263 of file vkd3d_shader_main.c.

{
    char *messages;
 
    if (!out)
        return true;
 
    *out = NULL;
 
    if (!context->messages.content_size)
        return true;
 
    if (!(messages = vkd3d_malloc(context->messages.content_size + 1)))
        return false;
    memcpy(messages, context->messages.buffer, context->messages.content_size + 1);
    *out = messages;
    return true;
}

Referenced by vkd3d_shader_compile(), vkd3d_shader_parse_dxbc(), vkd3d_shader_parse_input_signature(), vkd3d_shader_parse_root_signature(), vkd3d_shader_preprocess(), vkd3d_shader_scan(), and vkd3d_shader_serialize_root_signature().

◆ vkd3d_shader_message_context_init()

void vkd3d_shader_message_context_init	(	struct vkd3d_shader_message_context *	context,
		enum vkd3d_shader_log_level	log_level
	)

Definition at line 245 of file vkd3d_shader_main.c.

{
    context->log_level = log_level;
    vkd3d_string_buffer_init(&context->messages);
}

Referenced by vkd3d_shader_compile(), vkd3d_shader_parse_dxbc(), vkd3d_shader_parse_input_signature(), vkd3d_shader_parse_root_signature(), vkd3d_shader_preprocess(), vkd3d_shader_scan(), and vkd3d_shader_serialize_root_signature().

◆ vkd3d_shader_message_context_trace_messages_()

void vkd3d_shader_message_context_trace_messages_	(	const struct vkd3d_shader_message_context *	context,
		const char *	function
	)

Definition at line 257 of file vkd3d_shader_main.c.

{
    vkd3d_string_buffer_trace_(&context->messages, function);
}

◆ vkd3d_shader_parse_input_signature()

int vkd3d_shader_parse_input_signature	(	const struct vkd3d_shader_code *	dxbc,
		struct vkd3d_shader_signature *	signature,
		char **	messages
	)

Read the input signature of a compiled DXBC shader, returning a structural description which can be easily parsed by C code.

This function parses a compiled shader. To parse a standalone root signature, use vkd3d_shader_parse_root_signature().

This function only parses DXBC shaders, and only retrieves the input signature. To retrieve signatures from other shader types, or other signature types, use vkd3d_shader_scan() and struct vkd3d_shader_scan_signature_info. This function returns the same input signature that is returned in struct vkd3d_shader_scan_signature_info.

Parameters

dxbc	Compiled byte code, in DXBC format.
signature	Output location in which the parsed root signature will be stored. Members of signature may be allocated by vkd3d-shader. The signature should be freed with vkd3d_shader_free_shader_signature() when no longer needed. The signature may contain pointers into the input shader, and should only be accessed while the input shader remains valid.
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 1858 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_message_context message_context;
    struct shader_signature shader_signature;
    int ret;
 
    TRACE("dxbc {%p, %zu}, signature %p, messages %p.\n", dxbc->code, dxbc->size, signature, messages);
 
    if (messages)
        *messages = NULL;
    vkd3d_shader_message_context_init(&message_context, VKD3D_SHADER_LOG_INFO);
 
    ret = shader_parse_input_signature(dxbc, &message_context, &shader_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 (!vkd3d_shader_signature_from_shader_signature(signature, &shader_signature))
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
 
    shader_signature_cleanup(&shader_signature);
    return ret;
}

Referenced by d3d11_input_layout_to_wined3d_declaration(), and d3d12_pipeline_state_init_graphics().

◆ vkd3d_shader_parser_init()

void vkd3d_shader_parser_init	(	struct vkd3d_shader_parser *	parser,
		struct vsir_program *	program,
		struct vkd3d_shader_message_context *	message_context,
		const char *	source_name
	)

Definition at line 606 of file vkd3d_shader_main.c.

{
    parser->message_context = message_context;
    parser->location.source_name = source_name;
    parser->location.line = 1;
    parser->location.column = 0;
    parser->program = program;
}

Referenced by shader_sm1_init(), shader_sm4_init(), and sm6_parser_init().

◆ vkd3d_shader_preprocess()

int vkd3d_shader_preprocess	(	const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_code *	out,
		char **	messages
	)

Preprocess the given source code.

This function supports the following chained structures:

vkd3d_shader_preprocess_info

Parameters

compile_info	A chained structure containing compilation parameters.
out	A pointer to a vkd3d_shader_code structure in which the preprocessed code will be stored. The preprocessed shader 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 preprocessor. 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. The messages returned can be regulated with the log_level member of struct vkd3d_shader_compile_info. Regardless of the requested level, if this parameter is NULL, no compilation messages will be returned. If no messages are produced by the preprocessor, this parameter may receive NULL instead of a valid string pointer.

Returns: A member of vkd3d_result.

Since: 1.3

Definition at line 2043 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_message_context message_context;
    int ret;
 
    TRACE("compile_info %p, out %p, messages %p.\n", compile_info, out, messages);
 
    if (messages)
        *messages = NULL;
 
    if ((ret = vkd3d_shader_validate_compile_info(compile_info, false)) < 0)
        return ret;
 
    vkd3d_shader_message_context_init(&message_context, compile_info->log_level);
 
    ret = preproc_lexer_parse(compile_info, out, &message_context);
 
    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);
    return ret;
}

Referenced by preprocess_shader().

◆ vkd3d_shader_scan()

int vkd3d_shader_scan	(	const struct vkd3d_shader_compile_info *	compile_info,
		char **	messages
	)

Parse shader source code or byte code, returning various types of requested information.

The source_type member of compile_info must be set to the type of the shader.

The target_type member may be set to VKD3D_SHADER_TARGET_NONE, in which case vkd3d_shader_scan() will return information about the shader in isolation. Alternatively, it may be set to a valid compilation target for the shader, in which case vkd3d_shader_scan() will return information that reflects the interface for a shader as it will be compiled to that target. In this case other chained structures may be appended to compile_info as they would be passed to vkd3d_shader_compile(), and interpreted accordingly, such as vkd3d_shader_spirv_target_info.

(For a hypothetical example, suppose the source shader distinguishes float and integer texture data, but the target environment does not support integer textures. In this case vkd3d_shader_compile() might translate integer operations to float. Accordingly using VKD3D_SHADER_TARGET_NONE would accurately report whether the texture expects integer or float data, but using the relevant specific target type would report VKD3D_SHADER_RESOURCE_DATA_FLOAT.)

Currently this function supports the following code types:

VKD3D_SHADER_SOURCE_DXBC_TPF
VKD3D_SHADER_SOURCE_D3D_BYTECODE

Parameters

compile_info

A chained structure containing scan parameters.
The scanner supports the following chained structures:

vkd3d_shader_scan_descriptor_info
vkd3d_shader_scan_signature_info
vkd3d_shader_scan_combined_resource_sampler_info
Although the compile_info parameter is read-only, chained structures passed to this function need not be, and may serve as output parameters, depending on their structure type.

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.
The messages returned can be regulated with the log_level member of struct vkd3d_shader_compile_info. Regardless of the requested level, if this parameter is NULL, no compilation messages will be returned.
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 1595 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_message_context message_context;
    struct shader_dump_data dump_data;
    int ret;
 
    TRACE("compile_info %p, messages %p.\n", compile_info, messages);
 
    if (messages)
        *messages = NULL;
 
    if ((ret = vkd3d_shader_validate_compile_info(compile_info, false)) < 0)
        return ret;
 
    init_scan_signature_info(compile_info);
 
    vkd3d_shader_message_context_init(&message_context, compile_info->log_level);
 
    fill_shader_dump_data(compile_info, &dump_data);
    vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, true);
 
    if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL)
    {
        FIXME("HLSL support not implemented.\n");
        ret = VKD3D_ERROR_NOT_IMPLEMENTED;
    }
    else
    {
        uint64_t config_flags = vkd3d_shader_init_config_flags();
        struct vsir_program program;
 
        if (!(ret = vsir_parse(compile_info, config_flags, &message_context, &program)))
        {
            ret = vsir_program_scan(&program, compile_info, &message_context, NULL);
            vsir_program_cleanup(&program);
        }
    }
 
    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);
    return ret;
}

Referenced by shader_spirv_scan_shader(), and vkd3d_scan_dxbc().

◆ vkd3d_shader_scan_add_descriptor()

static struct vkd3d_shader_descriptor_info1 * vkd3d_shader_scan_add_descriptor	(	struct vkd3d_shader_scan_context *	context,
		enum vkd3d_shader_descriptor_type	type,
		const struct vkd3d_shader_register *	reg,
		const struct vkd3d_shader_register_range *	range,
		enum vkd3d_shader_resource_type	resource_type,
		enum vkd3d_shader_resource_data_type	resource_data_type
	)

static

Definition at line 990 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_scan_descriptor_info1 *info = context->scan_descriptor_info;
    struct vkd3d_shader_descriptor_info1 *d;
 
    if (!info)
        return NULL;
 
    if (!vkd3d_array_reserve((void **)&info->descriptors, &context->descriptors_size,
            info->descriptor_count + 1, sizeof(*info->descriptors)))
    {
        ERR("Failed to allocate descriptor info.\n");
        return NULL;
    }
 
    d = &info->descriptors[info->descriptor_count];
    memset(d, 0, sizeof(*d));
    d->type = type;
    d->register_id = reg->idx[0].offset;
    d->register_space = range->space;
    d->register_index = range->first;
    d->resource_type = resource_type;
    d->resource_data_type = resource_data_type;
    d->count = (range->last == ~0u) ? ~0u : range->last - range->first + 1;
    ++info->descriptor_count;
 
    return d;
}

Referenced by vkd3d_shader_scan_combined_sampler_declaration(), vkd3d_shader_scan_constant_buffer_declaration(), vkd3d_shader_scan_resource_declaration(), vkd3d_shader_scan_sampler_declaration(), and vsir_program_scan().

◆ vkd3d_shader_scan_add_uav_flag()

static void vkd3d_shader_scan_add_uav_flag	(	const struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_register *	reg,
		uint32_t	flag
	)

static

Definition at line 926 of file vkd3d_shader_main.c.

{
    unsigned int range_id = reg->idx[0].offset;
    unsigned int i;
 
    if (!context->scan_descriptor_info)
        return;
 
    for (i = 0; i < context->scan_descriptor_info->descriptor_count; ++i)
    {
        if (context->scan_descriptor_info->descriptors[i].type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
                && context->scan_descriptor_info->descriptors[i].register_id == range_id)
        {
            context->scan_descriptor_info->descriptors[i].flags |= flag;
            break;
        }
    }
}

Referenced by vkd3d_shader_scan_record_uav_atomic_op(), vkd3d_shader_scan_record_uav_counter(), and vkd3d_shader_scan_record_uav_read().

◆ vkd3d_shader_scan_combined_sampler_declaration()

static void vkd3d_shader_scan_combined_sampler_declaration	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_semantic *	semantic
	)

static

Definition at line 1048 of file vkd3d_shader_main.c.

{
    vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, &semantic->resource.reg.reg,
            &semantic->resource.range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT);
    vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SRV, &semantic->resource.reg.reg,
            &semantic->resource.range, semantic->resource_type, VKD3D_SHADER_RESOURCE_DATA_FLOAT);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_combined_sampler_usage()

static void vkd3d_shader_scan_combined_sampler_usage	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_register *	resource,
		const struct vkd3d_shader_register *	sampler
	)

static

Definition at line 1072 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_scan_combined_resource_sampler_info *info;
    struct vkd3d_shader_combined_resource_sampler_info *s;
    unsigned resource_space = 0, sampler_space = 0;
    unsigned int resource_idx, sampler_idx, i;
 
    if (!(info = context->combined_sampler_info))
        return;
 
    if (resource->type == VKD3DSPR_RESOURCE)
        resource_idx = resource->idx[1].offset;
    else
        resource_idx = resource->idx[0].offset;
 
    if (!sampler)
        sampler_idx = VKD3D_SHADER_DUMMY_SAMPLER_INDEX;
    else if (sampler->type == VKD3DSPR_SAMPLER)
        sampler_idx = sampler->idx[1].offset;
    else
        sampler_idx = sampler->idx[0].offset;
 
    if (vkd3d_shader_ver_ge(context->version, 5, 1))
    {
        const struct vkd3d_shader_descriptor_info1 *d;
        bool dynamic_resource, dynamic_sampler;
 
        if ((dynamic_resource = resource->idx[1].rel_addr))
            vkd3d_shader_scan_warning(context, VKD3D_SHADER_WARNING_VSIR_DYNAMIC_DESCRIPTOR_ARRAY,
                    "Resource descriptor array %u is being dynamically indexed, "
                    "not recording a combined resource-sampler pair.", resource->idx[0].offset);
        if ((dynamic_sampler = sampler && sampler->idx[1].rel_addr))
            vkd3d_shader_scan_warning(context, VKD3D_SHADER_WARNING_VSIR_DYNAMIC_DESCRIPTOR_ARRAY,
                    "Sampler descriptor array %u is being dynamically indexed, "
                    "not recording a combined resource-sampler pair.", sampler->idx[0].offset);
        if (dynamic_resource || dynamic_sampler)
            return;
 
        if ((d = find_descriptor(context->scan_descriptor_info,
                VKD3D_SHADER_DESCRIPTOR_TYPE_SRV, resource->idx[0].offset)))
            resource_space = d->register_space;
 
        if (sampler && (d = find_descriptor(context->scan_descriptor_info,
                VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, sampler->idx[0].offset)))
            sampler_space = d->register_space;
    }
 
    for (i = 0; i < info->combined_sampler_count; ++i)
    {
        s = &info->combined_samplers[i];
        if (s->resource_space == resource_space && s->resource_index == resource_idx
                && s->sampler_space == sampler_space && s->sampler_index == sampler_idx)
            return;
    }
 
    if (!vkd3d_array_reserve((void **)&info->combined_samplers, &context->combined_samplers_size,
            info->combined_sampler_count + 1, sizeof(*info->combined_samplers)))
    {
        ERR("Failed to allocate combined sampler info.\n");
        return;
    }
 
    s = &info->combined_samplers[info->combined_sampler_count++];
    s->resource_space = resource_space;
    s->resource_index = resource_idx;
    s->sampler_space = sampler_space;
    s->sampler_index = sampler_idx;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_constant_buffer_declaration()

static void vkd3d_shader_scan_constant_buffer_declaration	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_instruction *	instruction
	)

static

Definition at line 1022 of file vkd3d_shader_main.c.

{
    const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb;
    struct vkd3d_shader_descriptor_info1 *d;
 
    if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV,
            &cb->src.reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT)))
        return;
    d->buffer_size = cb->size;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_context_cleanup()

static void vkd3d_shader_scan_context_cleanup ( struct vkd3d_shader_scan_context * context )

static

Definition at line 857 of file vkd3d_shader_main.c.

{
    vkd3d_free(context->cf_info);
}

Referenced by vsir_program_scan().

◆ vkd3d_shader_scan_context_init()

static void vkd3d_shader_scan_context_init	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_version *	version,
		const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_scan_descriptor_info1 *	scan_descriptor_info,
		struct vkd3d_shader_scan_combined_resource_sampler_info *	combined_sampler_info,
		struct vkd3d_shader_message_context *	message_context
	)

static

Definition at line 830 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    memset(context, 0, sizeof(*context));
    context->version = version;
    context->scan_descriptor_info = scan_descriptor_info;
    context->message_context = message_context;
    context->location.source_name = compile_info->source_name;
    context->location.line = 2; /* Line 1 is the version token. */
    context->api_version = VKD3D_SHADER_API_VERSION_1_2;
    context->combined_sampler_info = combined_sampler_info;
 
    for (i = 0; i < compile_info->option_count; ++i)
    {
        const struct vkd3d_shader_compile_option *option = &compile_info->options[i];
 
        if (option->name == VKD3D_SHADER_COMPILE_OPTION_API_VERSION)
            context->api_version = option->value;
    }
}

Referenced by vsir_program_scan().

◆ vkd3d_shader_scan_find_innermost_breakable_cf_info()

static struct vkd3d_shader_cf_info * vkd3d_shader_scan_find_innermost_breakable_cf_info ( struct vkd3d_shader_scan_context * context )

static

Definition at line 893 of file vkd3d_shader_main.c.

{
    size_t count = context->cf_info_count;
    struct vkd3d_shader_cf_info *cf_info;
 
    while (count)
    {
        cf_info = &context->cf_info[--count];
        if (cf_info->type == VKD3D_SHADER_BLOCK_LOOP
                || cf_info->type == VKD3D_SHADER_BLOCK_SWITCH)
            return cf_info;
    }
 
    return NULL;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_find_innermost_loop_cf_info()

static struct vkd3d_shader_cf_info * vkd3d_shader_scan_find_innermost_loop_cf_info ( struct vkd3d_shader_scan_context * context )

static

Definition at line 910 of file vkd3d_shader_main.c.

{
    size_t count = context->cf_info_count;
    struct vkd3d_shader_cf_info *cf_info;
 
    while (count)
    {
        cf_info = &context->cf_info[--count];
        if (cf_info->type == VKD3D_SHADER_BLOCK_LOOP)
            return cf_info;
    }
 
    return NULL;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_get_current_cf_info()

static struct vkd3d_shader_cf_info * vkd3d_shader_scan_get_current_cf_info ( struct vkd3d_shader_scan_context * context )

static

Definition at line 862 of file vkd3d_shader_main.c.

{
    if (!context->cf_info_count)
        return NULL;
    return &context->cf_info[context->cf_info_count - 1];
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_instruction()

static int vkd3d_shader_scan_instruction	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_instruction *	instruction
	)

static

Definition at line 1224 of file vkd3d_shader_main.c.

{
    const struct vkd3d_shader_register *sampler_reg;
    struct vkd3d_shader_cf_info *cf_info;
    unsigned int i;
 
    context->location = instruction->location;
 
    switch (instruction->opcode)
    {
        case VKD3DSIH_DCL_CONSTANT_BUFFER:
            vkd3d_shader_scan_constant_buffer_declaration(context, instruction);
            break;
        case VKD3DSIH_DCL_SAMPLER:
            vkd3d_shader_scan_sampler_declaration(context, instruction);
            break;
        case VKD3DSIH_DCL:
            if (instruction->declaration.semantic.resource_type == VKD3D_SHADER_RESOURCE_NONE)
                break;
 
            if (instruction->declaration.semantic.resource.reg.reg.type == VKD3DSPR_COMBINED_SAMPLER)
            {
                vkd3d_shader_scan_combined_sampler_declaration(context, &instruction->declaration.semantic);
                break;
            }
            /* fall through */
        case VKD3DSIH_DCL_UAV_TYPED:
            vkd3d_shader_scan_typed_resource_declaration(context, instruction);
            break;
        case VKD3DSIH_DCL_RESOURCE_RAW:
        case VKD3DSIH_DCL_UAV_RAW:
            vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.raw_resource.resource,
                    VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0, 0, true, instruction->flags);
            break;
        case VKD3DSIH_DCL_RESOURCE_STRUCTURED:
        case VKD3DSIH_DCL_UAV_STRUCTURED:
            vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.structured_resource.resource,
                    VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0,
                    instruction->declaration.structured_resource.byte_stride, false, instruction->flags);
            break;
        case VKD3DSIH_IF:
        case VKD3DSIH_IFC:
            cf_info = vkd3d_shader_scan_push_cf_info(context);
            cf_info->type = VKD3D_SHADER_BLOCK_IF;
            cf_info->inside_block = true;
            break;
        case VKD3DSIH_ELSE:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context)) || cf_info->type != VKD3D_SHADER_BLOCK_IF)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘else’ instruction without corresponding ‘if’ block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            cf_info->inside_block = true;
            break;
        case VKD3DSIH_ENDIF:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context)) || cf_info->type != VKD3D_SHADER_BLOCK_IF)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘endif’ instruction without corresponding ‘if’ block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            vkd3d_shader_scan_pop_cf_info(context);
            break;
        case VKD3DSIH_LOOP:
            cf_info = vkd3d_shader_scan_push_cf_info(context);
            cf_info->type = VKD3D_SHADER_BLOCK_LOOP;
            cf_info->inside_block = true;
            break;
        case VKD3DSIH_ENDLOOP:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context)) || cf_info->type != VKD3D_SHADER_BLOCK_LOOP)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘endloop’ instruction without corresponding ‘loop’ block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            vkd3d_shader_scan_pop_cf_info(context);
            break;
        case VKD3DSIH_SWITCH:
            cf_info = vkd3d_shader_scan_push_cf_info(context);
            cf_info->type = VKD3D_SHADER_BLOCK_SWITCH;
            break;
        case VKD3DSIH_ENDSWITCH:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context))
                    || cf_info->type != VKD3D_SHADER_BLOCK_SWITCH || cf_info->inside_block)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘endswitch’ instruction without corresponding ‘switch’ block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            vkd3d_shader_scan_pop_cf_info(context);
            break;
        case VKD3DSIH_CASE:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context))
                    || cf_info->type != VKD3D_SHADER_BLOCK_SWITCH)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘case’ instruction outside switch block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            cf_info->inside_block = true;
            break;
        case VKD3DSIH_DEFAULT:
            if (!(cf_info = vkd3d_shader_scan_get_current_cf_info(context))
                    || cf_info->type != VKD3D_SHADER_BLOCK_SWITCH)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘default’ instruction outside switch block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            if (cf_info->has_default)
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered duplicate ‘default’ instruction inside the current switch block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            cf_info->inside_block = true;
            cf_info->has_default = true;
            break;
        case VKD3DSIH_BREAK:
            if (!(cf_info = vkd3d_shader_scan_find_innermost_breakable_cf_info(context)))
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘break’ instruction outside breakable block.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            cf_info->inside_block = false;
            break;
        case VKD3DSIH_BREAKP:
            if (!(cf_info = vkd3d_shader_scan_find_innermost_loop_cf_info(context)))
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘breakp’ instruction outside loop.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            break;
        case VKD3DSIH_CONTINUE:
            if (!(cf_info = vkd3d_shader_scan_find_innermost_loop_cf_info(context)))
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘continue’ instruction outside loop.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            cf_info->inside_block = false;
            break;
        case VKD3DSIH_CONTINUEP:
            if (!(cf_info = vkd3d_shader_scan_find_innermost_loop_cf_info(context)))
            {
                vkd3d_shader_scan_error(context, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF,
                        "Encountered ‘continue’ instruction outside loop.");
                return VKD3D_ERROR_INVALID_SHADER;
            }
            break;
        case VKD3DSIH_RET:
            if (context->cf_info_count)
                context->cf_info[context->cf_info_count - 1].inside_block = false;
            break;
        case VKD3DSIH_TEX:
            if (context->version->major == 1)
                sampler_reg = &instruction->dst[0].reg;
            else
                sampler_reg = &instruction->src[1].reg;
            vkd3d_shader_scan_combined_sampler_usage(context, sampler_reg, sampler_reg);
            break;
        case VKD3DSIH_TEXBEM:
        case VKD3DSIH_TEXBEML:
        case VKD3DSIH_TEXDP3TEX:
        case VKD3DSIH_TEXM3x2TEX:
        case VKD3DSIH_TEXM3x3SPEC:
        case VKD3DSIH_TEXM3x3TEX:
        case VKD3DSIH_TEXM3x3VSPEC:
        case VKD3DSIH_TEXREG2AR:
        case VKD3DSIH_TEXREG2GB:
        case VKD3DSIH_TEXREG2RGB:
            sampler_reg = &instruction->dst[0].reg;
            vkd3d_shader_scan_combined_sampler_usage(context, sampler_reg, sampler_reg);
            break;
        case VKD3DSIH_GATHER4:
        case VKD3DSIH_GATHER4_C:
        case VKD3DSIH_SAMPLE:
        case VKD3DSIH_SAMPLE_B:
        case VKD3DSIH_SAMPLE_C:
        case VKD3DSIH_SAMPLE_C_LZ:
        case VKD3DSIH_SAMPLE_GRAD:
        case VKD3DSIH_SAMPLE_LOD:
            vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, &instruction->src[2].reg);
            break;
        case VKD3DSIH_GATHER4_PO:
        case VKD3DSIH_GATHER4_PO_C:
            vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[2].reg, &instruction->src[3].reg);
            break;
        case VKD3DSIH_LD:
        case VKD3DSIH_LD2DMS:
            vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, NULL);
            break;
        case VKD3DSIH_BUFINFO:
        case VKD3DSIH_SAMPLE_INFO:
            if (instruction->src[0].reg.type == VKD3DSPR_RESOURCE)
                vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[0].reg, NULL);
            break;
        case VKD3DSIH_LD_RAW:
        case VKD3DSIH_RESINFO:
            if (instruction->src[1].reg.type == VKD3DSPR_RESOURCE)
                vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[1].reg, NULL);
            break;
        case VKD3DSIH_LD_STRUCTURED:
            if (instruction->src[2].reg.type == VKD3DSPR_RESOURCE)
                vkd3d_shader_scan_combined_sampler_usage(context, &instruction->src[2].reg, NULL);
            break;
        default:
            break;
    }
 
    if (vkd3d_shader_instruction_is_uav_read(instruction))
    {
        for (i = 0; i < instruction->dst_count; ++i)
        {
            if (instruction->dst[i].reg.type == VKD3DSPR_UAV)
                vkd3d_shader_scan_record_uav_read(context, &instruction->dst[i].reg);
        }
        for (i = 0; i < instruction->src_count; ++i)
        {
            if (instruction->src[i].reg.type == VKD3DSPR_UAV)
                vkd3d_shader_scan_record_uav_read(context, &instruction->src[i].reg);
        }
    }
 
    if (vkd3d_shader_instruction_is_uav_counter(instruction))
        vkd3d_shader_scan_record_uav_counter(context, &instruction->src[0].reg);
 
    if (vkd3d_shader_instruction_is_uav_atomic_op(instruction))
    {
        for (i = 0; i < instruction->dst_count; ++i)
        {
            if (instruction->dst[i].reg.type == VKD3DSPR_UAV)
                vkd3d_shader_scan_record_uav_atomic_op(context, &instruction->dst[i].reg);
        }
    }
 
    return VKD3D_OK;
}

Referenced by vsir_program_scan().

◆ vkd3d_shader_scan_pop_cf_info()

static void vkd3d_shader_scan_pop_cf_info ( struct vkd3d_shader_scan_context * context )

static

Definition at line 886 of file vkd3d_shader_main.c.

{
    VKD3D_ASSERT(context->cf_info_count);
 
    --context->cf_info_count;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_push_cf_info()

static struct vkd3d_shader_cf_info * vkd3d_shader_scan_push_cf_info ( struct vkd3d_shader_scan_context * context )

static

Definition at line 869 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_cf_info *cf_info;
 
    if (!vkd3d_array_reserve((void **)&context->cf_info, &context->cf_info_size,
            context->cf_info_count + 1, sizeof(*context->cf_info)))
    {
        ERR("Failed to allocate UAV range.\n");
        return false;
    }
 
    cf_info = &context->cf_info[context->cf_info_count++];
    memset(cf_info, 0, sizeof(*cf_info));
 
    return cf_info;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_record_uav_atomic_op()

static void vkd3d_shader_scan_record_uav_atomic_op	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_register *	reg
	)

static

Definition at line 984 of file vkd3d_shader_main.c.

{
    vkd3d_shader_scan_add_uav_flag(context, reg, VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_ATOMICS);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_record_uav_counter()

static void vkd3d_shader_scan_record_uav_counter	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_register *	reg
	)

static

Definition at line 970 of file vkd3d_shader_main.c.

{
    vkd3d_shader_scan_add_uav_flag(context, reg, VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_COUNTER);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_record_uav_read()

static void vkd3d_shader_scan_record_uav_read	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_register *	reg
	)

static

Definition at line 957 of file vkd3d_shader_main.c.

{
    vkd3d_shader_scan_add_uav_flag(context, reg, VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_READ);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_resource_declaration()

static void vkd3d_shader_scan_resource_declaration	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_resource *	resource,
		enum vkd3d_shader_resource_type	resource_type,
		enum vkd3d_shader_resource_data_type	resource_data_type,
		unsigned int	sample_count,
		unsigned int	structure_stride,
		bool	raw,
		uint32_t	flags
	)

static

Definition at line 1142 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_descriptor_info1 *d;
    enum vkd3d_shader_descriptor_type type;
 
    if (resource->reg.reg.type == VKD3DSPR_UAV)
        type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
    else
        type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV;
    if (!(d = vkd3d_shader_scan_add_descriptor(context, type, &resource->reg.reg,
            &resource->range, resource_type, resource_data_type)))
        return;
    d->sample_count = sample_count;
    d->structure_stride = structure_stride;
    if (raw)
        d->flags |= VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_RAW_BUFFER;
    if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV)
        d->uav_flags = flags;
}

Referenced by vkd3d_shader_scan_instruction(), and vkd3d_shader_scan_typed_resource_declaration().

◆ vkd3d_shader_scan_sampler_declaration()

static void vkd3d_shader_scan_sampler_declaration	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_instruction *	instruction
	)

static

Definition at line 1034 of file vkd3d_shader_main.c.

{
    const struct vkd3d_shader_sampler *sampler = &instruction->declaration.sampler;
    struct vkd3d_shader_descriptor_info1 *d;
 
    if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER,
            &sampler->src.reg, &sampler->range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT)))
        return;
 
    if (instruction->flags & VKD3DSI_SAMPLER_COMPARISON_MODE)
        d->flags |= VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_SAMPLER_COMPARISON_MODE;
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_scan_typed_resource_declaration()

static void vkd3d_shader_scan_typed_resource_declaration	(	struct vkd3d_shader_scan_context *	context,
		const struct vkd3d_shader_instruction *	instruction
	)

static

Definition at line 1165 of file vkd3d_shader_main.c.

{
    const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic;
    enum vkd3d_shader_resource_data_type resource_data_type;
 
    if (semantic->resource_data_type[0] != semantic->resource_data_type[1] ||
        semantic->resource_data_type[0] != semantic->resource_data_type[2] ||
        semantic->resource_data_type[0] != semantic->resource_data_type[3])
        FIXME("Resource data types are different (%d, %d, %d, %d).\n",
                semantic->resource_data_type[0],
                semantic->resource_data_type[1],
                semantic->resource_data_type[2],
                semantic->resource_data_type[3]);
 
    switch (semantic->resource_data_type[0])
    {
        case VKD3D_DATA_UNORM:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_UNORM;
            break;
        case VKD3D_DATA_SNORM:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_SNORM;
            break;
        case VKD3D_DATA_INT:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_INT;
            break;
        case VKD3D_DATA_UINT:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_UINT;
            break;
        case VKD3D_DATA_FLOAT:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
            break;
        case VKD3D_DATA_MIXED:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_MIXED;
            break;
        case VKD3D_DATA_DOUBLE:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_DOUBLE;
            break;
        case VKD3D_DATA_CONTINUED:
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_CONTINUED;
            break;
        default:
            ERR("Invalid resource data type %#x.\n", semantic->resource_data_type[0]);
            resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
            break;
    }
 
    if (context->api_version < VKD3D_SHADER_API_VERSION_1_3
            && resource_data_type >= VKD3D_SHADER_RESOURCE_DATA_MIXED)
    {
        ERR("Invalid resource data type %#x for API version %#x.\n",
                semantic->resource_data_type[0], context->api_version);
        resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
    }
 
    vkd3d_shader_scan_resource_declaration(context, &semantic->resource,
            semantic->resource_type, resource_data_type, semantic->sample_count, 0, false, instruction->flags);
}

Referenced by vkd3d_shader_scan_instruction().

◆ vkd3d_shader_set_log_callback()

void vkd3d_shader_set_log_callback ( PFN_vkd3d_log callback )

Set a callback to be called when vkd3d-shader outputs debug logging.

If NULL, or if this function has not been called, libvkd3d-shader will print all enabled log output to stderr.

Parameters

callback Callback function to set.

Since: 1.4

Definition at line 2068 of file vkd3d_shader_main.c.

{
    vkd3d_dbg_set_log_callback(callback);
}

Referenced by vkd3d_set_log_callback().

◆ vkd3d_shader_signature_from_shader_signature()

static bool vkd3d_shader_signature_from_shader_signature	(	struct vkd3d_shader_signature *	signature,
		const struct shader_signature *	src
	)

static

Definition at line 735 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    signature->element_count = src->element_count;
    if (!src->elements)
    {
        VKD3D_ASSERT(!signature->element_count);
        signature->elements = NULL;
        return true;
    }
 
    if (!(signature->elements = vkd3d_calloc(signature->element_count, sizeof(*signature->elements))))
        return false;
 
    for (i = 0; i < signature->element_count; ++i)
    {
        struct vkd3d_shader_signature_element *d = &signature->elements[i];
        struct signature_element *e = &src->elements[i];
 
        if (!(d->semantic_name = vkd3d_strdup(e->semantic_name)))
        {
            for (unsigned int j = 0; j < i; ++j)
            {
                vkd3d_free((void *)signature->elements[j].semantic_name);
            }
            vkd3d_free(signature->elements);
            return false;
        }
        d->semantic_index = e->semantic_index;
        d->stream_index = e->stream_index;
        d->sysval_semantic = e->sysval_semantic;
        d->component_type = e->component_type;
        d->register_index = e->register_index;
        if (e->register_count > 1)
            FIXME("Arrayed elements are not supported yet.\n");
        d->mask = e->mask;
        d->used_mask = e->used_mask;
        d->min_precision = e->min_precision;
    }
 
    return true;
}

Referenced by vkd3d_shader_parse_input_signature(), and vsir_program_scan().

◆ vkd3d_shader_trace_text_()

void vkd3d_shader_trace_text_	(	const char *	text,
		size_t	size,
		const char *	function
	)

Definition at line 169 of file vkd3d_shader_main.c.

{
    const char *p, *q, *end = text + size;
 
    if (!TRACE_ON())
        return;
 
    for (p = text; p < end; p = q)
    {
        if (!(q = memchr(p, '\n', end - p)))
            q = end;
        else
            ++q;
        vkd3d_dbg_printf(VKD3D_DBG_LEVEL_TRACE, function, "%.*s", (int)(q - p), p);
    }
}

Referenced by vkd3d_string_buffer_trace_().

◆ vkd3d_shader_validate_compile_info()

static int vkd3d_shader_validate_compile_info	(	const struct vkd3d_shader_compile_info *	compile_info,
		bool	validate_target_type
	)

static

Definition at line 638 of file vkd3d_shader_main.c.

{
    const enum vkd3d_shader_source_type *source_types;
    const enum vkd3d_shader_target_type *target_types;
    unsigned int count, i;
 
    if (compile_info->type != VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO)
    {
        WARN("Invalid structure type %#x.\n", compile_info->type);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    source_types = vkd3d_shader_get_supported_source_types(&count);
    for (i = 0; i < count; ++i)
    {
        if (source_types[i] == compile_info->source_type)
            break;
    }
    if (i == count)
    {
        WARN("Invalid shader source type %#x.\n", compile_info->source_type);
        return VKD3D_ERROR_INVALID_ARGUMENT;
    }
 
    if (validate_target_type)
    {
        target_types = vkd3d_shader_get_supported_target_types(compile_info->source_type, &count);
        for (i = 0; i < count; ++i)
        {
            if (target_types[i] == compile_info->target_type)
                break;
        }
        if (i == count)
        {
            WARN("Invalid shader target type %#x.\n", compile_info->target_type);
            return VKD3D_ERROR_INVALID_ARGUMENT;
        }
    }
 
    return VKD3D_OK;
}

Referenced by vkd3d_shader_compile(), vkd3d_shader_preprocess(), and vkd3d_shader_scan().

◆ vkd3d_shader_verror()

void vkd3d_shader_verror	(	struct vkd3d_shader_message_context *	context,
		const struct vkd3d_shader_location *	location,
		enum vkd3d_shader_error	error,
		const char *	format,
		va_list	args
	)

Definition at line 336 of file vkd3d_shader_main.c.

{
    if (context->log_level < VKD3D_SHADER_LOG_ERROR)
        return;
 
    if (location)
    {
        const char *source_name = location->source_name ? location->source_name : "<anonymous>";
 
        if (location->line)
            vkd3d_string_buffer_printf(&context->messages, "%s:%u:%u: E%04u: ",
                    source_name, location->line, location->column, error);
        else
            vkd3d_string_buffer_printf(&context->messages, "%s: E%04u: ", source_name, error);
    }
    else
    {
        vkd3d_string_buffer_printf(&context->messages, "E%04u: ", error);
    }
    vkd3d_string_buffer_vprintf(&context->messages, format, args);
    vkd3d_string_buffer_printf(&context->messages, "\n");
}

Referenced by hlsl_error(), VKD3D_PRINTF_FUNC(), and vkd3d_shader_error().

◆ vkd3d_shader_vnote()

void vkd3d_shader_vnote	(	struct vkd3d_shader_message_context *	context,
		const struct vkd3d_shader_location *	location,
		enum vkd3d_shader_log_level	level,
		const char *	format,
		va_list	args
	)

Definition at line 282 of file vkd3d_shader_main.c.

{
    if (context->log_level < level)
        return;
 
    if (location)
    {
        const char *source_name = location->source_name ? location->source_name : "<anonymous>";
 
        if (location->line)
            vkd3d_string_buffer_printf(&context->messages, "%s:%u:%u: ",
                    source_name, location->line, location->column);
        else
            vkd3d_string_buffer_printf(&context->messages, "%s: ", source_name);
    }
    vkd3d_string_buffer_vprintf(&context->messages, format, args);
    vkd3d_string_buffer_printf(&context->messages, "\n");
}

Referenced by hlsl_note().

◆ vkd3d_shader_vwarning()

void vkd3d_shader_vwarning	(	struct vkd3d_shader_message_context *	context,
		const struct vkd3d_shader_location *	location,
		enum vkd3d_shader_error	error,
		const char *	format,
		va_list	args
	)

Definition at line 302 of file vkd3d_shader_main.c.

{
    if (context->log_level < VKD3D_SHADER_LOG_WARNING)
        return;
 
    if (location)
    {
        const char *source_name = location->source_name ? location->source_name : "<anonymous>";
 
        if (location->line)
            vkd3d_string_buffer_printf(&context->messages, "%s:%u:%u: W%04u: ",
                    source_name, location->line, location->column, error);
        else
            vkd3d_string_buffer_printf(&context->messages, "%s: W%04u: ", source_name, error);
    }
    else
    {
        vkd3d_string_buffer_printf(&context->messages, "W%04u: ", error);
    }
    vkd3d_string_buffer_vprintf(&context->messages, format, args);
    vkd3d_string_buffer_printf(&context->messages, "\n");
}

Referenced by hlsl_warning(), and vkd3d_shader_warning().

◆ vkd3d_shader_warning()

void vkd3d_shader_warning	(	struct vkd3d_shader_message_context *	context,
		const struct vkd3d_shader_location *	location,
		enum vkd3d_shader_error	error,
		const char *	format,
			...
	)

Definition at line 326 of file vkd3d_shader_main.c.

{
    va_list args;
 
    va_start(args, format);
    vkd3d_shader_vwarning(context, location, error, format, args);
    va_end(args);
}

Referenced by sm6_parser_init().

◆ vkd3d_string_buffer_cache_cleanup()

void vkd3d_string_buffer_cache_cleanup ( struct vkd3d_string_buffer_cache * cache )

Definition at line 191 of file vkd3d_shader_main.c.

{
    unsigned int i;
 
    for (i = 0; i < cache->count; ++i)
    {
        vkd3d_string_buffer_cleanup(cache->buffers[i]);
        vkd3d_free(cache->buffers[i]);
    }
    vkd3d_free(cache->buffers);
    vkd3d_string_buffer_cache_init(cache);
}

Referenced by hlsl_ctx_cleanup(), msl_generator_cleanup(), msl_generator_init(), spirv_compiler_destroy(), and vkd3d_glsl_generator_cleanup().

◆ vkd3d_string_buffer_cache_init()

void vkd3d_string_buffer_cache_init ( struct vkd3d_string_buffer_cache * cache )

Definition at line 186 of file vkd3d_shader_main.c.

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

Referenced by hlsl_ctx_init(), msl_generator_init(), spirv_compiler_create(), vkd3d_glsl_generator_init(), and vkd3d_string_buffer_cache_cleanup().

◆ vkd3d_string_buffer_cleanup()

void vkd3d_string_buffer_cleanup ( struct vkd3d_string_buffer * buffer )

Definition at line 67 of file vkd3d_shader_main.c.

{
    vkd3d_free(buffer->buffer);
}

Referenced by d3d_asm_compile(), hlsl_dump_function(), hlsl_dump_var_default_values(), spirv_compiler_generate_spirv(), trace_signature(), vkd3d_shader_message_context_cleanup(), vkd3d_string_buffer_cache_cleanup(), and vsir_cfg_cleanup().

◆ vkd3d_string_buffer_clear()

void vkd3d_string_buffer_clear ( struct vkd3d_string_buffer * buffer )

Definition at line 72 of file vkd3d_shader_main.c.

{
    vkd3d_string_buffer_truncate(buffer, 0);
}

Referenced by declare_predefined_types(), trace_signature(), vkd3d_string_buffer_get(), vsir_cfg_compute_dominators(), vsir_cfg_compute_loops(), and vsir_cfg_sort_nodes().

◆ vkd3d_string_buffer_get()

struct vkd3d_string_buffer * vkd3d_string_buffer_get ( struct vkd3d_string_buffer_cache * cache )

Definition at line 204 of file vkd3d_shader_main.c.

{
    struct vkd3d_string_buffer *buffer;
 
    if (!cache->count)
    {
        if (!vkd3d_array_reserve((void **)&cache->buffers, &cache->capacity,
                cache->max_count + 1, sizeof(*cache->buffers)))
            return NULL;
        ++cache->max_count;
 
        if (!(buffer = vkd3d_malloc(sizeof(*buffer))))
            return NULL;
        vkd3d_string_buffer_init(buffer);
    }
    else
    {
        buffer = cache->buffers[--cache->count];
    }
    vkd3d_string_buffer_clear(buffer);
    return buffer;
}

Referenced by glsl_dst_init(), glsl_src_init(), hlsl_get_string_buffer(), msl_dst_init(), msl_generator_init(), msl_src_init(), shader_glsl_intrinsic(), shader_glsl_ld(), shader_glsl_load_uav_typed(), shader_glsl_print_src(), shader_glsl_sample(), shader_glsl_store_uav_typed(), vkd3d_glsl_generator_init(), and vkd3d_shader_register_range_string().

◆ vkd3d_string_buffer_init()

void vkd3d_string_buffer_init ( struct vkd3d_string_buffer * buffer )

Definition at line 58 of file vkd3d_shader_main.c.

{
    buffer->buffer_size = 16;
    buffer->content_size = 0;
    buffer->buffer = vkd3d_malloc(buffer->buffer_size);
    VKD3D_ASSERT(buffer->buffer);
    memset(buffer->buffer, 0, buffer->buffer_size);
}

Referenced by d3d_asm_compile(), fx_parse(), hlsl_dump_function(), hlsl_dump_var_default_values(), spirv_compiler_generate_spirv(), trace_signature(), VKD3D_PRINTF_FUNC(), vkd3d_shader_message_context_init(), vkd3d_string_buffer_get(), and vsir_cfg_init().

◆ vkd3d_string_buffer_print_f32()

int vkd3d_string_buffer_print_f32	(	struct vkd3d_string_buffer *	buffer,
		float	f
	)

Definition at line 134 of file vkd3d_shader_main.c.

{
    unsigned int idx = buffer->content_size + 1;
    int ret;
 
    if (!(ret = vkd3d_string_buffer_printf(buffer, "%.8e", f)) && isfinite(f))
    {
        if (signbit(f))
            ++idx;
        buffer->buffer[idx] = '.';
    }
 
    return ret;
}

Referenced by shader_print_float_literal().

◆ vkd3d_string_buffer_print_f64()

int vkd3d_string_buffer_print_f64	(	struct vkd3d_string_buffer *	buffer,
		double	d
	)

Definition at line 149 of file vkd3d_shader_main.c.

{
    unsigned int idx = buffer->content_size + 1;
    int ret;
 
    if (!(ret = vkd3d_string_buffer_printf(buffer, "%.16e", d)) && isfinite(d))
    {
        if (signbit(d))
            ++idx;
        buffer->buffer[idx] = '.';
    }
 
    return ret;
}

Referenced by shader_print_double_literal().

◆ vkd3d_string_buffer_printf()

int vkd3d_string_buffer_printf	(	struct vkd3d_string_buffer *	buffer,
		const char *	format,
			...
	)

Definition at line 122 of file vkd3d_shader_main.c.

{
    va_list args;
    int ret;
 
    va_start(args, format);
    ret = vkd3d_string_buffer_vprintf(buffer, format, args);
    va_end(args);
 
    return ret;
}

◆ vkd3d_string_buffer_release()

void vkd3d_string_buffer_release	(	struct vkd3d_string_buffer_cache *	cache,
		struct vkd3d_string_buffer *	buffer
	)

Definition at line 227 of file vkd3d_shader_main.c.

{
    if (!buffer)
        return;
    VKD3D_ASSERT(cache->count + 1 <= cache->max_count);
    cache->buffers[cache->count++] = buffer;
}

Referenced by glsl_dst_cleanup(), glsl_src_cleanup(), hlsl_release_string_buffer(), msl_dst_cleanup(), msl_generator_cleanup(), msl_src_cleanup(), shader_glsl_intrinsic(), shader_glsl_ld(), shader_glsl_load_uav_typed(), shader_glsl_print_src(), shader_glsl_sample(), shader_glsl_store_uav_typed(), spirv_compiler_get_descriptor_binding(), and vkd3d_glsl_generator_cleanup().

◆ vkd3d_string_buffer_resize()

static bool vkd3d_string_buffer_resize	(	struct vkd3d_string_buffer *	buffer,
		int	rc
	)

static

Definition at line 86 of file vkd3d_shader_main.c.

{
    unsigned int new_buffer_size = rc >= 0 ? buffer->content_size + rc + 1 : buffer->buffer_size * 2;
 
    if (!vkd3d_array_reserve((void **)&buffer->buffer, &buffer->buffer_size, new_buffer_size, 1))
    {
        ERR("Failed to grow buffer.\n");
        buffer->buffer[buffer->content_size] = '\0';
        return false;
    }
    return true;
}

Referenced by vkd3d_string_buffer_vprintf().

◆ vkd3d_string_buffer_trace_()

void vkd3d_string_buffer_trace_	(	const struct vkd3d_string_buffer *	buffer,
		const char *	function
	)

Definition at line 164 of file vkd3d_shader_main.c.

{
    vkd3d_shader_trace_text_(buffer->buffer, buffer->content_size, function);
}

Referenced by vkd3d_shader_message_context_trace_messages_().

◆ vkd3d_string_buffer_truncate()

void vkd3d_string_buffer_truncate	(	struct vkd3d_string_buffer *	buffer,
		size_t	size
	)

Definition at line 77 of file vkd3d_shader_main.c.

{
    if (size < buffer->content_size)
    {
        buffer->buffer[size] = '\0';
        buffer->content_size = size;
    }
}

Referenced by vkd3d_string_buffer_clear(), and vsir_cfg_structure_list_dump().

◆ vkd3d_string_buffer_vprintf()

int vkd3d_string_buffer_vprintf	(	struct vkd3d_string_buffer *	buffer,
		const char *	format,
		va_list	args
	)

Definition at line 99 of file vkd3d_shader_main.c.

{
    unsigned int rem;
    va_list a;
    int rc;
 
    for (;;)
    {
        rem = buffer->buffer_size - buffer->content_size;
        va_copy(a, args);
        rc = vsnprintf(&buffer->buffer[buffer->content_size], rem, format, a);
        va_end(a);
        if (rc >= 0 && (unsigned int)rc < rem)
        {
            buffer->content_size += rc;
            return 0;
        }
 
        if (!vkd3d_string_buffer_resize(buffer, rc))
            return -1;
    }
}

Referenced by hlsl_fixme(), hlsl_sprintf_alloc(), VKD3D_PRINTF_FUNC(), vkd3d_shader_verror(), vkd3d_shader_vnote(), vkd3d_shader_vwarning(), and vkd3d_string_buffer_printf().

◆ vsir_parse()

static enum vkd3d_result vsir_parse	(	const struct vkd3d_shader_compile_info *	compile_info,
		uint64_t	config_flags,
		struct vkd3d_shader_message_context *	message_context,
		struct vsir_program *	program
	)

static

Definition at line 681 of file vkd3d_shader_main.c.

{
    enum vkd3d_result ret;
 
    switch (compile_info->source_type)
    {
        case VKD3D_SHADER_SOURCE_D3D_BYTECODE:
            ret = d3dbc_parse(compile_info, config_flags, message_context, program);
            break;
 
        case VKD3D_SHADER_SOURCE_DXBC_TPF:
            ret = tpf_parse(compile_info, config_flags, message_context, program);
            break;
 
        case VKD3D_SHADER_SOURCE_DXBC_DXIL:
            ret = dxil_parse(compile_info, config_flags, message_context, program);
            break;
 
        default:
            ERR("Unsupported source type %#x.\n", compile_info->source_type);
            ret = VKD3D_ERROR_INVALID_ARGUMENT;
            break;
    }
 
    if (ret < 0)
    {
        WARN("Failed to parse shader.\n");
        return ret;
    }
 
    if ((ret = vsir_program_validate(program, config_flags, compile_info->source_name, message_context)) < 0)
    {
        WARN("Failed to validate shader after parsing, ret %d.\n", ret);
 
        if (TRACE_ON())
            vsir_program_trace(program);
 
        vsir_program_cleanup(program);
        return ret;
    }
 
    if (compile_info->target_type != VKD3D_SHADER_TARGET_NONE)
        ret = vsir_program_transform_early(program, config_flags, compile_info, message_context);
    return ret;
}

Referenced by vkd3d_shader_compile(), and vkd3d_shader_scan().

◆ vsir_program_compile()

int vsir_program_compile	(	struct vsir_program *	program,
		uint64_t	config_flags,
		const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_code *	out,
		struct vkd3d_shader_message_context *	message_context
	)

Definition at line 1640 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_scan_combined_resource_sampler_info combined_sampler_info;
    struct vkd3d_shader_scan_descriptor_info1 scan_descriptor_info;
    struct vkd3d_shader_compile_info scan_info;
    int ret;
 
    scan_info = *compile_info;
 
    switch (compile_info->target_type)
    {
        case VKD3D_SHADER_TARGET_D3D_ASM:
            ret = d3d_asm_compile(program, compile_info, out, VSIR_ASM_FLAG_NONE);
            break;
 
        case VKD3D_SHADER_TARGET_GLSL:
            combined_sampler_info.type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_COMBINED_RESOURCE_SAMPLER_INFO;
            combined_sampler_info.next = scan_info.next;
            scan_info.next = &combined_sampler_info;
            if ((ret = vsir_program_scan(program, &scan_info, message_context, &scan_descriptor_info)) < 0)
                return ret;
            ret = glsl_compile(program, config_flags, &scan_descriptor_info,
                    &combined_sampler_info, compile_info, out, message_context);
            vkd3d_shader_free_scan_combined_resource_sampler_info(&combined_sampler_info);
            vkd3d_shader_free_scan_descriptor_info1(&scan_descriptor_info);
            break;
 
        case VKD3D_SHADER_TARGET_SPIRV_BINARY:
        case VKD3D_SHADER_TARGET_SPIRV_TEXT:
            if ((ret = vsir_program_scan(program, &scan_info, message_context, &scan_descriptor_info)) < 0)
                return ret;
            ret = spirv_compile(program, config_flags, &scan_descriptor_info,
                    compile_info, out, message_context);
            vkd3d_shader_free_scan_descriptor_info1(&scan_descriptor_info);
            break;
 
        case VKD3D_SHADER_TARGET_MSL:
            if ((ret = vsir_program_scan(program, &scan_info, message_context, &scan_descriptor_info)) < 0)
                return ret;
            ret = msl_compile(program, config_flags, &scan_descriptor_info, compile_info, out, message_context);
            vkd3d_shader_free_scan_descriptor_info1(&scan_descriptor_info);
            break;
 
        default:
            /* Validation should prevent us from reaching this. */
            vkd3d_unreachable();
    }
 
    return ret;
}

Referenced by hlsl_compile_shader(), and vkd3d_shader_compile().

◆ vsir_program_scan()

static int vsir_program_scan	(	struct vsir_program *	program,
		const struct vkd3d_shader_compile_info *	compile_info,
		struct vkd3d_shader_message_context *	message_context,
		struct vkd3d_shader_scan_descriptor_info1 *	descriptor_info1
	)

static

Definition at line 1500 of file vkd3d_shader_main.c.

{
    struct vkd3d_shader_scan_combined_resource_sampler_info *combined_sampler_info;
    struct vkd3d_shader_scan_descriptor_info1 local_descriptor_info1 = {0};
    struct vkd3d_shader_scan_descriptor_info *descriptor_info;
    struct vkd3d_shader_scan_signature_info *signature_info;
    struct vkd3d_shader_instruction *instruction;
    struct vkd3d_shader_scan_context context;
    int ret = VKD3D_OK;
    unsigned int i;
 
    descriptor_info = vkd3d_find_struct(compile_info->next, SCAN_DESCRIPTOR_INFO);
    if (descriptor_info1)
    {
        descriptor_info1->descriptors = NULL;
        descriptor_info1->descriptor_count = 0;
    }
    else if (descriptor_info)
    {
        descriptor_info1 = &local_descriptor_info1;
    }
    signature_info = vkd3d_find_struct(compile_info->next, SCAN_SIGNATURE_INFO);
 
    if ((combined_sampler_info = vkd3d_find_struct(compile_info->next, SCAN_COMBINED_RESOURCE_SAMPLER_INFO)))
    {
        combined_sampler_info->combined_samplers = NULL;
        combined_sampler_info->combined_sampler_count = 0;
        if (!descriptor_info1)
            descriptor_info1 = &local_descriptor_info1;
    }
 
    vkd3d_shader_scan_context_init(&context, &program->shader_version, compile_info,
            descriptor_info1, combined_sampler_info, message_context);
 
    if (TRACE_ON())
        vsir_program_trace(program);
 
    for (i = 0; i < program->instructions.count; ++i)
    {
        instruction = &program->instructions.elements[i];
        if ((ret = vkd3d_shader_scan_instruction(&context, instruction)) < 0)
            break;
    }
 
    for (i = 0; i < ARRAY_SIZE(program->flat_constant_count); ++i)
    {
        struct vkd3d_shader_register_range range = {.space = 0, .first = i, .last = i};
        struct vkd3d_shader_register reg = {.idx[0].offset = i, .idx_count = 1};
        unsigned int size = program->flat_constant_count[i];
        struct vkd3d_shader_descriptor_info1 *d;
 
        if (size)
        {
            if ((d = vkd3d_shader_scan_add_descriptor(&context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV, &reg,
                    &range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT)))
                d->buffer_size = size * 16;
        }
    }
 
    if (!ret && signature_info)
    {
        if (!vkd3d_shader_signature_from_shader_signature(&signature_info->input, &program->input_signature)
                || !vkd3d_shader_signature_from_shader_signature(&signature_info->output,
                        &program->output_signature)
                || !vkd3d_shader_signature_from_shader_signature(&signature_info->patch_constant,
                        &program->patch_constant_signature))
        {
            ret = VKD3D_ERROR_OUT_OF_MEMORY;
        }
    }
 
    if (!ret && descriptor_info)
        ret = convert_descriptor_info(descriptor_info, descriptor_info1);
 
    if (ret < 0)
    {
        if (combined_sampler_info)
            vkd3d_shader_free_scan_combined_resource_sampler_info(combined_sampler_info);
        if (descriptor_info)
            vkd3d_shader_free_scan_descriptor_info(descriptor_info);
        if (descriptor_info1)
            vkd3d_shader_free_scan_descriptor_info1(descriptor_info1);
        if (signature_info)
            vkd3d_shader_free_scan_signature_info(signature_info);
    }
    else
    {
        vkd3d_shader_free_scan_descriptor_info1(&local_descriptor_info1);
    }
    vkd3d_shader_scan_context_cleanup(&context);
    return ret;
}

Referenced by vkd3d_shader_scan(), and vsir_program_compile().

Variable Documentation

◆ vkd3d_shader_config_options

const struct vkd3d_debug_option vkd3d_shader_config_options[]

static

Initial value:

=
{
    {"force_validation", VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION}, 
}

Definition at line 587 of file vkd3d_shader_main.c.

Referenced by vkd3d_shader_init_config_flags().

Classes

Functions

Variables

Function Documentation

◆ bytecode_align()

◆ bytecode_put_bytes()

◆ bytecode_put_bytes_unaligned()

◆ bytecode_reserve_bytes()

◆ bytecode_set_bytes()

◆ char_to_int()

◆ compile_hlsl()

◆ convert_descriptor_info()

◆ fill_shader_dump_data()

◆ find_descriptor()

◆ init_scan_signature_info()

◆ set_string()

◆ set_u32()

◆ shader_get_source_type_suffix()

◆ shader_get_target_type_suffix()

◆ shader_instruction_array_add_icb()

◆ shader_instruction_array_clone_dst_params()

◆ shader_instruction_array_clone_instruction()

◆ shader_instruction_array_clone_src_params()

◆ shader_instruction_array_destroy()

◆ shader_instruction_array_init()

◆ shader_instruction_array_insert_at()

◆ shader_instruction_array_reserve()

◆ shader_param_allocator_destroy()

◆ shader_param_allocator_get()

◆ shader_param_allocator_init()

◆ shader_param_allocator_node_create()

◆ shader_register_clone_relative_addresses()

◆ shader_signature_cleanup()

◆ vkd3d_parse_integer()

◆ VKD3D_PRINTF_FUNC()

◆ vkd3d_shader_build_varying_map()

◆ vkd3d_shader_code_from_string_buffer()

◆ vkd3d_shader_compile()

◆ vkd3d_shader_dump_shader()

◆ vkd3d_shader_error()

◆ vkd3d_shader_find_signature_element()

◆ vkd3d_shader_free_messages()

◆ vkd3d_shader_free_root_signature()

◆ vkd3d_shader_free_root_signature_v_1_0()

◆ vkd3d_shader_free_root_signature_v_1_1()

◆ vkd3d_shader_free_scan_combined_resource_sampler_info()

◆ vkd3d_shader_free_scan_descriptor_info()

◆ vkd3d_shader_free_scan_descriptor_info1()

◆ vkd3d_shader_free_scan_signature_info()

◆ vkd3d_shader_free_shader_code()

◆ vkd3d_shader_free_shader_signature()

◆ vkd3d_shader_get_supported_source_types()

◆ vkd3d_shader_get_supported_target_types()

◆ vkd3d_shader_get_version()

◆ vkd3d_shader_init_config_flags()

◆ vkd3d_shader_instruction_is_uav_atomic_op()

◆ vkd3d_shader_instruction_is_uav_counter()

◆ vkd3d_shader_instruction_is_uav_read()

◆ vkd3d_shader_message_context_cleanup()

◆ vkd3d_shader_message_context_copy_messages()

◆ vkd3d_shader_message_context_init()

◆ vkd3d_shader_message_context_trace_messages_()

◆ vkd3d_shader_parse_input_signature()

◆ vkd3d_shader_parser_init()

◆ vkd3d_shader_preprocess()

◆ vkd3d_shader_scan()

◆ vkd3d_shader_scan_add_descriptor()

◆ vkd3d_shader_scan_add_uav_flag()

◆ vkd3d_shader_scan_combined_sampler_declaration()

◆ vkd3d_shader_scan_combined_sampler_usage()

◆ vkd3d_shader_scan_constant_buffer_declaration()

◆ vkd3d_shader_scan_context_cleanup()

◆ vkd3d_shader_scan_context_init()

◆ vkd3d_shader_scan_find_innermost_breakable_cf_info()

◆ vkd3d_shader_scan_find_innermost_loop_cf_info()

◆ vkd3d_shader_scan_get_current_cf_info()

◆ vkd3d_shader_scan_instruction()

◆ vkd3d_shader_scan_pop_cf_info()

◆ vkd3d_shader_scan_push_cf_info()

◆ vkd3d_shader_scan_record_uav_atomic_op()