msl.c File Reference

#include "vkd3d_shader_private.h"

Include dependency graph for msl.c:

Go to the source code of this file.

Classes
struct	msl_src
struct	msl_dst
struct	msl_generator

Functions
static void	VKD3D_PRINTF_FUNC (3, 4)
static const char *	msl_get_prefix (enum vkd3d_shader_type type)
static void	msl_print_indent (struct vkd3d_string_buffer *buffer, unsigned int indent)
static void	msl_print_register_datatype (struct vkd3d_string_buffer *buffer, struct msl_generator *gen, enum vkd3d_data_type data_type)
static void	msl_print_register_name (struct vkd3d_string_buffer *buffer, struct msl_generator *gen, const struct vkd3d_shader_register *reg)
static void	msl_print_swizzle (struct vkd3d_string_buffer *buffer, uint32_t swizzle, uint32_t mask)
static void	msl_print_write_mask (struct vkd3d_string_buffer *buffer, uint32_t write_mask)
static void	msl_src_cleanup (struct msl_src *src, struct vkd3d_string_buffer_cache *cache)
static void	msl_src_init (struct msl_src *msl_src, struct msl_generator *gen, const struct vkd3d_shader_src_param *vsir_src, uint32_t mask)
static void	msl_dst_cleanup (struct msl_dst *dst, struct vkd3d_string_buffer_cache *cache)
static uint32_t	msl_dst_init (struct msl_dst *msl_dst, struct msl_generator *gen, const struct vkd3d_shader_instruction *ins, const struct vkd3d_shader_dst_param *vsir_dst)
static void	msl_unhandled (struct msl_generator *gen, const struct vkd3d_shader_instruction *ins)
static void	msl_mov (struct msl_generator *gen, const struct vkd3d_shader_instruction *ins)
static void	msl_ret (struct msl_generator *gen, const struct vkd3d_shader_instruction *ins)
static void	msl_handle_instruction (struct msl_generator *gen, const struct vkd3d_shader_instruction *ins)
static bool	msl_check_shader_visibility (const struct msl_generator *gen, enum vkd3d_shader_visibility visibility)
static bool	msl_get_cbv_binding (const struct msl_generator *gen, unsigned int register_space, unsigned int register_idx, unsigned int *binding_idx)
static void	msl_generate_cbv_declaration (struct msl_generator *gen, const struct vkd3d_shader_descriptor_info1 *cbv)
static void	msl_generate_descriptor_struct_declarations (struct msl_generator *gen)
static void	msl_generate_input_struct_declarations (struct msl_generator *gen)
static void	msl_generate_vertex_output_element_attribute (struct msl_generator *gen, const struct signature_element *e)
static void	msl_generate_pixel_output_element_attribute (struct msl_generator *gen, const struct signature_element *e)
static void	msl_generate_output_struct_declarations (struct msl_generator *gen)
static void	msl_generate_entrypoint_prologue (struct msl_generator *gen)
static void	msl_generate_entrypoint_epilogue (struct msl_generator *gen)
static void	msl_generate_entrypoint (struct msl_generator *gen)
static int	msl_generator_generate (struct msl_generator *gen, struct vkd3d_shader_code *out)
static void	msl_generator_cleanup (struct msl_generator *gen)
static int	msl_generator_init (struct msl_generator *gen, struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info, struct vkd3d_shader_message_context *message_context)
int	msl_compile (struct vsir_program *program, uint64_t config_flags, const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context)

Function Documentation

msl_check_shader_visibility()

static bool msl_check_shader_visibility ( const struct msl_generator *  gen, enum vkd3d_shader_visibility  visibility  )

static

Definition at line 335 of file msl.c.

{
    enum vkd3d_shader_type t = gen->program->shader_version.type;
 
    switch (visibility)
    {
        case VKD3D_SHADER_VISIBILITY_ALL:
            return true;
        case VKD3D_SHADER_VISIBILITY_VERTEX:
            return t == VKD3D_SHADER_TYPE_VERTEX;
        case VKD3D_SHADER_VISIBILITY_HULL:
            return t == VKD3D_SHADER_TYPE_HULL;
        case VKD3D_SHADER_VISIBILITY_DOMAIN:
            return t == VKD3D_SHADER_TYPE_DOMAIN;
        case VKD3D_SHADER_VISIBILITY_GEOMETRY:
            return t == VKD3D_SHADER_TYPE_GEOMETRY;
        case VKD3D_SHADER_VISIBILITY_PIXEL:
            return t == VKD3D_SHADER_TYPE_PIXEL;
        case VKD3D_SHADER_VISIBILITY_COMPUTE:
            return t == VKD3D_SHADER_TYPE_COMPUTE;
        default:
            WARN("Invalid shader visibility %#x.\n", visibility);
            return false;
    }
}

Referenced by msl_get_cbv_binding().

msl_compile()

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

Definition at line 879 of file msl.c.

{
    struct msl_generator generator;
    int ret;
 
    if ((ret = vsir_program_transform(program, config_flags, compile_info, message_context)) < 0)
        return ret;
 
    VKD3D_ASSERT(program->normalisation_level == VSIR_FULLY_NORMALISED_IO);
 
    if ((ret = msl_generator_init(&generator, program, compile_info, descriptor_info, message_context)) < 0)
        return ret;
    ret = msl_generator_generate(&generator, out);
    msl_generator_cleanup(&generator);
 
    return ret;
}

Referenced by vsir_program_compile().

msl_dst_cleanup()

static void msl_dst_cleanup ( struct msl_dst *  dst, struct vkd3d_string_buffer_cache *  cache  )

static

Definition at line 233 of file msl.c.

{
    vkd3d_string_buffer_release(cache, dst->mask);
    vkd3d_string_buffer_release(cache, dst->register_name);
}

Referenced by msl_mov().

msl_dst_init()

static uint32_t msl_dst_init ( struct msl_dst *  msl_dst, struct msl_generator *  gen, const struct vkd3d_shader_instruction *  ins, const struct vkd3d_shader_dst_param *  vsir_dst  )

static

Definition at line 239 of file msl.c.

{
    uint32_t write_mask = vsir_dst->write_mask;
 
    if (ins->flags & VKD3DSI_PRECISE_XYZW)
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled 'precise' modifier.");
    if (vsir_dst->reg.non_uniform)
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled 'non-uniform' modifier.");
 
    msl_dst->vsir = vsir_dst;
    msl_dst->register_name = vkd3d_string_buffer_get(&gen->string_buffers);
    msl_dst->mask = vkd3d_string_buffer_get(&gen->string_buffers);
 
    msl_print_register_name(msl_dst->register_name, gen, &vsir_dst->reg);
    msl_print_write_mask(msl_dst->mask, write_mask);
 
    return write_mask;
}

Referenced by msl_mov().

msl_generate_cbv_declaration()

static void msl_generate_cbv_declaration ( struct msl_generator *  gen, const struct vkd3d_shader_descriptor_info1 *  cbv  )

static

Definition at line 393 of file msl.c.

{
    const struct vkd3d_shader_descriptor_binding *binding;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    unsigned int binding_idx;
    size_t size;
 
    if (cbv->count != 1)
    {
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_BINDING_NOT_FOUND,
                "Constant buffer %u has unsupported descriptor array size %u.", cbv->register_id, cbv->count);
        return;
    }
 
    if (!msl_get_cbv_binding(gen, cbv->register_space, cbv->register_index, &binding_idx))
    {
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_BINDING_NOT_FOUND,
                "No descriptor binding specified for constant buffer %u.", cbv->register_id);
        return;
    }
 
    binding = &gen->interface_info->bindings[binding_idx].binding;
 
    if (binding->set != 0)
    {
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_BINDING_NOT_FOUND,
                "Unsupported binding set %u specified for constant buffer %u.", binding->set, cbv->register_id);
        return;
    }
 
    if (binding->count != 1)
    {
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_BINDING_NOT_FOUND,
                "Unsupported binding count %u specified for constant buffer %u.", binding->count, cbv->register_id);
        return;
    }
 
    size = align(cbv->buffer_size, VKD3D_VEC4_SIZE * sizeof(uint32_t));
    size /= VKD3D_VEC4_SIZE * sizeof(uint32_t);
 
    vkd3d_string_buffer_printf(buffer,
            "constant vkd3d_vec4 *cb_%u [[id(%u)]];", cbv->register_id, binding->binding);
};

Referenced by msl_generate_descriptor_struct_declarations().

msl_generate_descriptor_struct_declarations()

static void msl_generate_descriptor_struct_declarations ( struct msl_generator *  gen )

static

Definition at line 438 of file msl.c.

{
    const struct vkd3d_shader_scan_descriptor_info1 *info = gen->descriptor_info;
    const struct vkd3d_shader_descriptor_info1 *descriptor;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    unsigned int i;
 
    if (!info->descriptor_count)
        return;
 
    vkd3d_string_buffer_printf(buffer, "struct vkd3d_%s_descriptors\n{\n", gen->prefix);
 
    for (i = 0; i < info->descriptor_count; ++i)
    {
        descriptor = &info->descriptors[i];
 
        msl_print_indent(buffer, 1);
        switch (descriptor->type)
        {
            case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV:
                msl_generate_cbv_declaration(gen, descriptor);
                break;
 
            default:
                vkd3d_string_buffer_printf(buffer, "/* <unhandled descriptor type %#x> */", descriptor->type);
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled descriptor type %#x.", descriptor->type);
                break;
        }
        vkd3d_string_buffer_printf(buffer, "\n");
    }
 
    vkd3d_string_buffer_printf(buffer, "};\n\n");
}

Referenced by msl_generator_generate().

msl_generate_entrypoint()

static void msl_generate_entrypoint ( struct msl_generator *  gen )

static

Definition at line 737 of file msl.c.

{
    enum vkd3d_shader_type type = gen->program->shader_version.type;
 
    switch (type)
    {
        case VKD3D_SHADER_TYPE_VERTEX:
            vkd3d_string_buffer_printf(gen->buffer, "vertex ");
            break;
        case VKD3D_SHADER_TYPE_PIXEL:
            vkd3d_string_buffer_printf(gen->buffer, "fragment ");
            break;
        default:
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled shader type %#x.", type);
            return;
    }
 
    vkd3d_string_buffer_printf(gen->buffer, "vkd3d_%s_out shader_entry(\n", gen->prefix);
 
    if (gen->descriptor_info->descriptor_count)
    {
        msl_print_indent(gen->buffer, 2);
        /* TODO: Configurable argument buffer binding location. */
        vkd3d_string_buffer_printf(gen->buffer,
                "constant vkd3d_%s_descriptors& descriptors [[buffer(0)]],\n", gen->prefix);
    }
 
    msl_print_indent(gen->buffer, 2);
    vkd3d_string_buffer_printf(gen->buffer, "vkd3d_%s_in input [[stage_in]])\n{\n", gen->prefix);
 
    /* TODO: declare #maximum_register + 1 */
    vkd3d_string_buffer_printf(gen->buffer, "    vkd3d_vec4 %s_in[%u];\n", gen->prefix, 32);
    vkd3d_string_buffer_printf(gen->buffer, "    vkd3d_vec4 %s_out[%u];\n", gen->prefix, 32);
    vkd3d_string_buffer_printf(gen->buffer, "    vkd3d_%s_out output;\n", gen->prefix);
 
    msl_generate_entrypoint_prologue(gen);
 
    vkd3d_string_buffer_printf(gen->buffer, "    %s_main(%s_in, %s_out", gen->prefix, gen->prefix, gen->prefix);
    if (gen->descriptor_info->descriptor_count)
        vkd3d_string_buffer_printf(gen->buffer, ", descriptors");
    vkd3d_string_buffer_printf(gen->buffer, ");\n");
 
    msl_generate_entrypoint_epilogue(gen);
 
    vkd3d_string_buffer_printf(gen->buffer, "    return output;\n}\n");
}

Referenced by msl_generator_generate().

msl_generate_entrypoint_epilogue()

static void msl_generate_entrypoint_epilogue ( struct msl_generator *  gen )

static

Definition at line 703 of file msl.c.

{
    const struct shader_signature *signature = &gen->program->output_signature;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    const struct signature_element *e;
    unsigned int i;
 
    for (i = 0; i < signature->element_count; ++i)
    {
        e = &signature->elements[i];
 
        if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
            continue;
 
        switch (e->sysval_semantic)
        {
            case VKD3D_SHADER_SV_NONE:
            case VKD3D_SHADER_SV_TARGET:
            case VKD3D_SHADER_SV_POSITION:
                vkd3d_string_buffer_printf(buffer, "    output.shader_out_%u", i);
                msl_print_write_mask(buffer, e->mask);
                vkd3d_string_buffer_printf(buffer, " = %s_out[%u]", gen->prefix, e->register_index);
                msl_print_register_datatype(buffer, gen, vkd3d_data_type_from_component_type(e->component_type));
                msl_print_write_mask(buffer, e->mask);
                break;
            default:
                vkd3d_string_buffer_printf(buffer, "    <unhandled sysval %#x>", e->sysval_semantic);
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled system value %#x input.", e->sysval_semantic);
        }
        vkd3d_string_buffer_printf(buffer, ";\n");
    }
}

Referenced by msl_generate_entrypoint().

msl_generate_entrypoint_prologue()

static void msl_generate_entrypoint_prologue ( struct msl_generator *  gen )

static

Definition at line 671 of file msl.c.

{
    const struct shader_signature *signature = &gen->program->input_signature;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    const struct signature_element *e;
    unsigned int i;
 
    for (i = 0; i < signature->element_count; ++i)
    {
        e = &signature->elements[i];
 
        if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
            continue;
 
        vkd3d_string_buffer_printf(buffer, "    %s_in[%u]", gen->prefix, e->register_index);
        if (e->sysval_semantic == VKD3D_SHADER_SV_NONE)
        {
            msl_print_register_datatype(buffer, gen, vkd3d_data_type_from_component_type(e->component_type));
            msl_print_write_mask(buffer, e->mask);
            vkd3d_string_buffer_printf(buffer, " = input.shader_in_%u", i);
            msl_print_write_mask(buffer, e->mask);
        }
        else
        {
            vkd3d_string_buffer_printf(buffer, " = <unhandled sysval %#x>", e->sysval_semantic);
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled system value %#x input.", e->sysval_semantic);
        }
        vkd3d_string_buffer_printf(buffer, ";\n");
    }
}

Referenced by msl_generate_entrypoint().

msl_generate_input_struct_declarations()

static void msl_generate_input_struct_declarations ( struct msl_generator *  gen )

static

Definition at line 473 of file msl.c.

{
    const struct shader_signature *signature = &gen->program->input_signature;
    enum vkd3d_shader_type type = gen->program->shader_version.type;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    const struct signature_element *e;
    unsigned int i;
 
    vkd3d_string_buffer_printf(buffer, "struct vkd3d_%s_in\n{\n", gen->prefix);
 
    for (i = 0; i < signature->element_count; ++i)
    {
        e = &signature->elements[i];
 
        if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
            continue;
 
        if (e->sysval_semantic)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled system value %#x.", e->sysval_semantic);
            continue;
        }
 
        if (e->min_precision != VKD3D_SHADER_MINIMUM_PRECISION_NONE)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled minimum precision %#x.", e->min_precision);
            continue;
        }
 
        if (e->interpolation_mode != VKD3DSIM_NONE)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled interpolation mode %#x.", e->interpolation_mode);
            continue;
        }
 
        if(e->register_count > 1)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled register count %u.", e->register_count);
            continue;
        }
 
        msl_print_indent(gen->buffer, 1);
 
        switch(e->component_type)
        {
            case VKD3D_SHADER_COMPONENT_FLOAT:
                vkd3d_string_buffer_printf(buffer, "float4 ");
                break;
            case VKD3D_SHADER_COMPONENT_INT:
                vkd3d_string_buffer_printf(buffer, "int4 ");
                break;
            case VKD3D_SHADER_COMPONENT_UINT:
                vkd3d_string_buffer_printf(buffer, "uint4 ");
                break;
            default:
                vkd3d_string_buffer_printf(buffer, "<unhandled component type %#x> ", e->component_type);
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled component type %#x.", e->component_type);
                break;
        }
 
        vkd3d_string_buffer_printf(buffer, "shader_in_%u ", i);
 
        switch (type)
        {
            case VKD3D_SHADER_TYPE_VERTEX:
                vkd3d_string_buffer_printf(gen->buffer, "[[attribute(%u)]]", e->target_location);
                break;
            case VKD3D_SHADER_TYPE_PIXEL:
                vkd3d_string_buffer_printf(gen->buffer, "[[user(locn%u)]]", e->target_location);
                break;
            default:
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled shader type %#x.", type);
                break;
        }
 
        vkd3d_string_buffer_printf(buffer, ";\n");
    }
 
    vkd3d_string_buffer_printf(buffer, "};\n\n");
}

Referenced by msl_generator_generate().

msl_generate_output_struct_declarations()

static void msl_generate_output_struct_declarations ( struct msl_generator *  gen )

static

Definition at line 591 of file msl.c.

{
    const struct shader_signature *signature = &gen->program->output_signature;
    enum vkd3d_shader_type type = gen->program->shader_version.type;
    struct vkd3d_string_buffer *buffer = gen->buffer;
    const struct signature_element *e;
    unsigned int i;
 
    vkd3d_string_buffer_printf(buffer, "struct vkd3d_%s_out\n{\n", gen->prefix);
 
    for (i = 0; i < signature->element_count; ++i)
    {
        e = &signature->elements[i];
 
        if (e->target_location == SIGNATURE_TARGET_LOCATION_UNUSED)
            continue;
 
        if (e->min_precision != VKD3D_SHADER_MINIMUM_PRECISION_NONE)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled minimum precision %#x.", e->min_precision);
            continue;
        }
 
        if (e->interpolation_mode != VKD3DSIM_NONE)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled interpolation mode %#x.", e->interpolation_mode);
            continue;
        }
 
        if(e->register_count > 1)
        {
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled register count %u.", e->register_count);
            continue;
        }
 
        msl_print_indent(gen->buffer, 1);
 
        switch(e->component_type)
        {
            case VKD3D_SHADER_COMPONENT_FLOAT:
                vkd3d_string_buffer_printf(buffer, "float4 ");
                break;
            case VKD3D_SHADER_COMPONENT_INT:
                vkd3d_string_buffer_printf(buffer, "int4 ");
                break;
            case VKD3D_SHADER_COMPONENT_UINT:
                vkd3d_string_buffer_printf(buffer, "uint4 ");
                break;
            default:
                vkd3d_string_buffer_printf(buffer, "<unhandled component type %#x> ", e->component_type);
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled component type %#x.", e->component_type);
                break;
        }
 
        vkd3d_string_buffer_printf(buffer, "shader_out_%u ", i);
 
        switch (type)
        {
            case VKD3D_SHADER_TYPE_VERTEX:
                msl_generate_vertex_output_element_attribute(gen, e);
                break;
            case VKD3D_SHADER_TYPE_PIXEL:
                msl_generate_pixel_output_element_attribute(gen, e);
                break;
            default:
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled shader type %#x.", type);
                break;
        }
 
        vkd3d_string_buffer_printf(buffer, ";\n");
    }
 
    vkd3d_string_buffer_printf(buffer, "};\n\n");
}

Referenced by msl_generator_generate().

msl_generate_pixel_output_element_attribute()

static void msl_generate_pixel_output_element_attribute ( struct msl_generator *  gen, const struct signature_element *  e  )

static

Definition at line 577 of file msl.c.

{
    switch (e->sysval_semantic)
    {
        case VKD3D_SHADER_SV_TARGET:
            vkd3d_string_buffer_printf(gen->buffer, "[[color(%u)]]", e->target_location);
            break;
        default:
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled pixel shader system value %#x.", e->sysval_semantic);
            break;
    }
}

Referenced by msl_generate_output_struct_declarations().

msl_generate_vertex_output_element_attribute()

static void msl_generate_vertex_output_element_attribute ( struct msl_generator *  gen, const struct signature_element *  e  )

static

Definition at line 560 of file msl.c.

{
    switch (e->sysval_semantic)
    {
        case VKD3D_SHADER_SV_POSITION:
            vkd3d_string_buffer_printf(gen->buffer, "[[position]]");
            break;
        case VKD3D_SHADER_SV_NONE:
            vkd3d_string_buffer_printf(gen->buffer, "[[user(locn%u)]]", e->target_location);
            break;
        default:
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled vertex shader system value %#x.", e->sysval_semantic);
            break;
    }
}

Referenced by msl_generate_output_struct_declarations().

msl_generator_cleanup()

static void msl_generator_cleanup ( struct msl_generator *  gen )

static

Definition at line 845 of file msl.c.

{
    vkd3d_string_buffer_release(&gen->string_buffers, gen->buffer);
    vkd3d_string_buffer_cache_cleanup(&gen->string_buffers);
}

Referenced by msl_compile().

msl_generator_generate()

static int msl_generator_generate ( struct msl_generator *  gen, struct vkd3d_shader_code *  out  )

static

Definition at line 785 of file msl.c.

{
    const struct vkd3d_shader_instruction_array *instructions = &gen->program->instructions;
    unsigned int i;
 
    MESSAGE("Generating a MSL shader. This is unsupported; you get to keep all the pieces if it breaks.\n");
 
    vkd3d_string_buffer_printf(gen->buffer, "/* Generated by %s. */\n\n", vkd3d_shader_get_version(NULL, NULL));
 
    if (gen->program->global_flags)
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled global flags %#"PRIx64".", (uint64_t)gen->program->global_flags);
 
    vkd3d_string_buffer_printf(gen->buffer, "union vkd3d_vec4\n{\n");
    vkd3d_string_buffer_printf(gen->buffer, "    uint4 u;\n");
    vkd3d_string_buffer_printf(gen->buffer, "    int4 i;\n");
    vkd3d_string_buffer_printf(gen->buffer, "    float4 f;\n};\n\n");
 
    msl_generate_descriptor_struct_declarations(gen);
    msl_generate_input_struct_declarations(gen);
    msl_generate_output_struct_declarations(gen);
 
    vkd3d_string_buffer_printf(gen->buffer,
            "void %s_main(thread vkd3d_vec4 *v, "
            "thread vkd3d_vec4 *o",
            gen->prefix);
    if (gen->descriptor_info->descriptor_count)
        vkd3d_string_buffer_printf(gen->buffer, ", constant vkd3d_%s_descriptors& descriptors", gen->prefix);
    vkd3d_string_buffer_printf(gen->buffer, ")\n{\n");
 
    ++gen->indent;
 
    if (gen->program->temp_count)
    {
        msl_print_indent(gen->buffer, gen->indent);
        vkd3d_string_buffer_printf(gen->buffer, "vkd3d_vec4 r[%u];\n\n", gen->program->temp_count);
    }
 
    for (i = 0; i < instructions->count; ++i)
    {
        msl_handle_instruction(gen, &instructions->elements[i]);
    }
 
    --gen->indent;
 
    vkd3d_string_buffer_printf(gen->buffer, "}\n\n");
 
    msl_generate_entrypoint(gen);
 
    if (TRACE_ON())
        vkd3d_string_buffer_trace(gen->buffer);
 
    if (gen->failed)
        return VKD3D_ERROR_INVALID_SHADER;
 
    vkd3d_shader_code_from_string_buffer(out, gen->buffer);
 
    return VKD3D_OK;
}

Referenced by msl_compile().

msl_generator_init()

static int msl_generator_init ( struct msl_generator *  gen, struct vsir_program *  program, const struct vkd3d_shader_compile_info *  compile_info, const struct vkd3d_shader_scan_descriptor_info1 *  descriptor_info, struct vkd3d_shader_message_context *  message_context  )

static

Definition at line 851 of file msl.c.

{
    enum vkd3d_shader_type type = program->shader_version.type;
 
    memset(gen, 0, sizeof(*gen));
    gen->program = program;
    vkd3d_string_buffer_cache_init(&gen->string_buffers);
    if (!(gen->buffer = vkd3d_string_buffer_get(&gen->string_buffers)))
    {
        vkd3d_string_buffer_cache_cleanup(&gen->string_buffers);
        return VKD3D_ERROR_OUT_OF_MEMORY;
    }
    gen->message_context = message_context;
    if (!(gen->prefix = msl_get_prefix(type)))
    {
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled shader type %#x.", type);
        return VKD3D_ERROR_INVALID_SHADER;
    }
    gen->interface_info = vkd3d_find_struct(compile_info->next, INTERFACE_INFO);
    gen->descriptor_info = descriptor_info;
 
    return VKD3D_OK;
}

Referenced by msl_compile().

msl_get_cbv_binding()

static bool msl_get_cbv_binding ( const struct msl_generator *  gen, unsigned int  register_space, unsigned int  register_idx, unsigned int *  binding_idx  )

static

Definition at line 362 of file msl.c.

{
    const struct vkd3d_shader_interface_info *interface_info = gen->interface_info;
    const struct vkd3d_shader_resource_binding *binding;
    unsigned int i;
 
    if (!interface_info)
        return false;
 
    for (i = 0; i < interface_info->binding_count; ++i)
    {
        binding = &interface_info->bindings[i];
 
        if (binding->type != VKD3D_SHADER_DESCRIPTOR_TYPE_CBV)
            continue;
        if (binding->register_space != register_space)
            continue;
        if (binding->register_index != register_idx)
            continue;
        if (!msl_check_shader_visibility(gen, binding->shader_visibility))
            continue;
        if (!(binding->flags & VKD3D_SHADER_BINDING_FLAG_BUFFER))
            continue;
        *binding_idx = i;
        return true;
    }
 
    return false;
}

Referenced by msl_generate_cbv_declaration().

msl_get_prefix()

static const char * msl_get_prefix ( enum vkd3d_shader_type  type )

static

Definition at line 59 of file msl.c.

{
    switch (type)
    {
        case VKD3D_SHADER_TYPE_VERTEX:
            return "vs";
        case VKD3D_SHADER_TYPE_HULL:
            return "hs";
        case VKD3D_SHADER_TYPE_DOMAIN:
            return "ds";
        case VKD3D_SHADER_TYPE_GEOMETRY:
            return "gs";
        case VKD3D_SHADER_TYPE_PIXEL:
            return "ps";
        case VKD3D_SHADER_TYPE_COMPUTE:
            return "cs";
        default:
            return NULL;
    }
}

Referenced by msl_generator_init().

msl_handle_instruction()

static void msl_handle_instruction ( struct msl_generator *  gen, const struct vkd3d_shader_instruction *  ins  )

static

Definition at line 312 of file msl.c.

{
    gen->location = ins->location;
 
    switch (ins->opcode)
    {
        case VKD3DSIH_DCL_INPUT:
        case VKD3DSIH_DCL_OUTPUT:
        case VKD3DSIH_DCL_OUTPUT_SIV:
        case VKD3DSIH_NOP:
            break;
        case VKD3DSIH_MOV:
            msl_mov(gen, ins);
            break;
        case VKD3DSIH_RET:
            msl_ret(gen, ins);
            break;
        default:
            msl_unhandled(gen, ins);
            break;
    }
}

Referenced by msl_generator_generate().

msl_mov()

static void msl_mov ( struct msl_generator *  gen, const struct vkd3d_shader_instruction *  ins  )

static

Definition at line 291 of file msl.c.

{
    struct msl_src src;
    struct msl_dst dst;
    uint32_t mask;
 
    mask = msl_dst_init(&dst, gen, ins, &ins->dst[0]);
    msl_src_init(&src, gen, &ins->src[0], mask);
 
    msl_print_assignment(gen, &dst, "%s", src.str->buffer);
 
    msl_src_cleanup(&src, &gen->string_buffers);
    msl_dst_cleanup(&dst, &gen->string_buffers);
}

Referenced by msl_handle_instruction().

msl_print_indent()

static void msl_print_indent ( struct vkd3d_string_buffer *  buffer, unsigned int  indent  )

static

Definition at line 80 of file msl.c.

{
    vkd3d_string_buffer_printf(buffer, "%*s", 4 * indent, "");
}

Referenced by msl_generate_descriptor_struct_declarations(), msl_generate_entrypoint(), msl_generate_input_struct_declarations(), msl_generate_output_struct_declarations(), msl_generator_generate(), msl_ret(), and msl_unhandled().

msl_print_register_datatype()

static void msl_print_register_datatype ( struct vkd3d_string_buffer *  buffer, struct msl_generator *  gen, enum vkd3d_data_type  data_type  )

static

Definition at line 85 of file msl.c.

{
    vkd3d_string_buffer_printf(buffer, ".");
    switch (data_type)
    {
        case VKD3D_DATA_FLOAT:
            vkd3d_string_buffer_printf(buffer, "f");
            break;
        case VKD3D_DATA_INT:
            vkd3d_string_buffer_printf(buffer, "i");
            break;
        case VKD3D_DATA_UINT:
            vkd3d_string_buffer_printf(buffer, "u");
            break;
        default:
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled register datatype %#x.", data_type);
            vkd3d_string_buffer_printf(buffer, "<unrecognised register datatype %#x>", data_type);
            break;
    }
}

Referenced by msl_generate_entrypoint_epilogue(), msl_generate_entrypoint_prologue(), and msl_print_register_name().

msl_print_register_name()

static void msl_print_register_name ( struct vkd3d_string_buffer *  buffer, struct msl_generator *  gen, const struct vkd3d_shader_register *  reg  )

static

Definition at line 108 of file msl.c.

{
    switch (reg->type)
    {
        case VKD3DSPR_TEMP:
            vkd3d_string_buffer_printf(buffer, "r[%u]", reg->idx[0].offset);
            msl_print_register_datatype(buffer, gen, reg->data_type);
            break;
 
        case VKD3DSPR_INPUT:
            if (reg->idx_count != 1)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled input register index count %u.", reg->idx_count);
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            if (reg->idx[0].rel_addr)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled input register indirect addressing.");
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            vkd3d_string_buffer_printf(buffer, "v[%u]", reg->idx[0].offset);
            msl_print_register_datatype(buffer, gen, reg->data_type);
            break;
 
        case VKD3DSPR_OUTPUT:
            if (reg->idx_count != 1)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled output register index count %u.", reg->idx_count);
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            if (reg->idx[0].rel_addr)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled output register indirect addressing.");
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            vkd3d_string_buffer_printf(buffer, "o[%u]", reg->idx[0].offset);
            msl_print_register_datatype(buffer, gen, reg->data_type);
            break;
 
        case VKD3DSPR_CONSTBUFFER:
            if (reg->idx_count != 3)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled constant buffer register index count %u.", reg->idx_count);
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            if (reg->idx[0].rel_addr || reg->idx[2].rel_addr)
            {
                msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                        "Internal compiler error: Unhandled constant buffer register indirect addressing.");
                vkd3d_string_buffer_printf(buffer, "<unhandled register %#x>", reg->type);
                break;
            }
            vkd3d_string_buffer_printf(buffer, "descriptors.cb_%u[%u]", reg->idx[0].offset, reg->idx[2].offset);
            msl_print_register_datatype(buffer, gen, reg->data_type);
            break;
 
        default:
            msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                    "Internal compiler error: Unhandled register type %#x.", reg->type);
            vkd3d_string_buffer_printf(buffer, "<unrecognised register %#x>", reg->type);
            break;
    }
}

Referenced by msl_dst_init(), and msl_src_init().

msl_print_swizzle()

static void msl_print_swizzle ( struct vkd3d_string_buffer *  buffer, uint32_t  swizzle, uint32_t  mask  )

static

Definition at line 183 of file msl.c.

{
    const char swizzle_chars[] = "xyzw";
    unsigned int i;
 
    vkd3d_string_buffer_printf(buffer, ".");
    for (i = 0; i < VKD3D_VEC4_SIZE; ++i)
    {
        if (mask & (VKD3DSP_WRITEMASK_0 << i))
            vkd3d_string_buffer_printf(buffer, "%c", swizzle_chars[vsir_swizzle_get_component(swizzle, i)]);
    }
}

Referenced by msl_src_init().

msl_print_write_mask()

static void msl_print_write_mask ( struct vkd3d_string_buffer *  buffer, uint32_t  write_mask  )

static

Definition at line 196 of file msl.c.

{
    vkd3d_string_buffer_printf(buffer, ".");
    if (write_mask & VKD3DSP_WRITEMASK_0)
        vkd3d_string_buffer_printf(buffer, "x");
    if (write_mask & VKD3DSP_WRITEMASK_1)
        vkd3d_string_buffer_printf(buffer, "y");
    if (write_mask & VKD3DSP_WRITEMASK_2)
        vkd3d_string_buffer_printf(buffer, "z");
    if (write_mask & VKD3DSP_WRITEMASK_3)
        vkd3d_string_buffer_printf(buffer, "w");
}

Referenced by msl_dst_init(), msl_generate_entrypoint_epilogue(), and msl_generate_entrypoint_prologue().

msl_ret()

static void msl_ret ( struct msl_generator *  gen, const struct vkd3d_shader_instruction *  ins  )

static

Definition at line 306 of file msl.c.

{
    msl_print_indent(gen->buffer, gen->indent);
    vkd3d_string_buffer_printf(gen->buffer, "return;\n");
}

Referenced by msl_handle_instruction().

msl_src_cleanup()

static void msl_src_cleanup ( struct msl_src *  src, struct vkd3d_string_buffer_cache *  cache  )

static

Definition at line 209 of file msl.c.

{
    vkd3d_string_buffer_release(cache, src->str);
}

Referenced by msl_mov().

msl_src_init()

static void msl_src_init ( struct msl_src *  msl_src, struct msl_generator *  gen, const struct vkd3d_shader_src_param *  vsir_src, uint32_t  mask  )

static

Definition at line 214 of file msl.c.

{
    const struct vkd3d_shader_register *reg = &vsir_src->reg;
 
    msl_src->str = vkd3d_string_buffer_get(&gen->string_buffers);
 
    if (reg->non_uniform)
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled 'non-uniform' modifier.");
    if (vsir_src->modifiers)
        msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
                "Internal compiler error: Unhandled source modifier(s) %#x.", vsir_src->modifiers);
 
    msl_print_register_name(msl_src->str, gen, reg);
    if (reg->dimension == VSIR_DIMENSION_VEC4)
        msl_print_swizzle(msl_src->str, vsir_src->swizzle, mask);
}

Referenced by msl_mov().

msl_unhandled()

static void msl_unhandled ( struct msl_generator *  gen, const struct vkd3d_shader_instruction *  ins  )

static

Definition at line 283 of file msl.c.

{
    msl_print_indent(gen->buffer, gen->indent);
    vkd3d_string_buffer_printf(gen->buffer, "/* <unhandled instruction %#x> */\n", ins->opcode);
    msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
            "Internal compiler error: Unhandled instruction %#x.", ins->opcode);
}

Referenced by msl_handle_instruction().

VKD3D_PRINTF_FUNC()

static void VKD3D_PRINTF_FUNC ( 3  , 4    )

static

Definition at line 48 of file msl.c.

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