ReactOS 0.4.17-dev-934-g091855f
spirv.c File Reference
#include "vkd3d_shader_private.h"
#include "wine/rbtree.h"
#include <stdarg.h>
#include <stdio.h>
#include "vulkan/spirv.h"
#include "vulkan/GLSL.std.450.h"
Include dependency graph for spirv.c:

Go to the source code of this file.

Classes

struct  vkd3d_spirv_stream
 
struct  vkd3d_spirv_chunk
 
struct  vkd3d_spirv_builder
 
struct  vkd3d_spirv_declaration
 
struct  vkd3d_spirv_resource_type
 
struct  vkd3d_symbol_register
 
struct  vkd3d_symbol_resource
 
struct  vkd3d_symbol_sampler
 
struct  vkd3d_symbol_combined_sampler
 
struct  vkd3d_symbol_descriptor_array
 
struct  vkd3d_symbol_register_data
 
struct  vkd3d_symbol_resource_data
 
struct  vkd3d_symbol_sampler_data
 
struct  vkd3d_descriptor_binding_address
 
struct  vkd3d_symbol_descriptor_array_data
 
struct  vkd3d_symbol
 
struct  vkd3d_push_constant_buffer_binding
 
struct  vkd3d_shader_phase
 
struct  vkd3d_shader_spec_constant
 
struct  vkd3d_hull_shader_variables
 
struct  ssa_register_info
 
struct  spirv_compiler
 
struct  spirv_compiler::vkd3d_shader_output_info
 
struct  vkd3d_spec_constant_info
 
struct  vkd3d_shader_register_info
 
struct  vkd3d_spirv_builtin
 
struct  vkd3d_descriptor_variable_info
 
struct  vkd3d_shader_image
 

Macros

#define VKD3D_SPIRV_VERSION_1_0   0x00010000
 
#define VKD3D_SPIRV_VERSION_1_3   0x00010300
 
#define VKD3D_SPIRV_GENERATOR_ID   18
 
#define VKD3D_SPIRV_GENERATOR_VERSION   14
 
#define VKD3D_SPIRV_GENERATOR_MAGIC   vkd3d_make_u32(VKD3D_SPIRV_GENERATOR_VERSION, VKD3D_SPIRV_GENERATOR_ID)
 
#define MAX_SPIRV_DECLARATION_PARAMETER_COUNT   7
 
#define VKD3D_IMAGE_FLAG_NONE   0x0
 
#define VKD3D_IMAGE_FLAG_DEPTH   0x1
 
#define VKD3D_IMAGE_FLAG_NO_LOAD   0x2
 
#define VKD3D_IMAGE_FLAG_SAMPLED   0x4
 

Typedefs

typedef uint32_t(* vkd3d_spirv_build_pfn) (struct vkd3d_spirv_builder *builder)
 
typedef uint32_t(* vkd3d_spirv_build1_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0)
 
typedef uint32_t(* vkd3d_spirv_build1v_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
 
typedef uint32_t(* vkd3d_spirv_build2_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, uint32_t operand1)
 
typedef uint32_t(* vkd3d_spirv_build7_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, uint32_t operand1, uint32_t operand2, uint32_t operand3, uint32_t operand4, uint32_t operand5, uint32_t operand6)
 
typedef uint32_t(* vkd3d_spirv_builtin_fixup_pfn) (struct spirv_compiler *compiler, uint32_t val_id)
 

Functions

static enum vkd3d_result vkd3d_spirv_binary_to_text (const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment, enum vkd3d_shader_compile_option_formatting_flags formatting, struct vkd3d_shader_code *out)
 
static void vkd3d_spirv_dump (const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment)
 
static bool vkd3d_spirv_validate (struct vkd3d_string_buffer *buffer, const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment)
 
enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed (enum vkd3d_shader_sysval_semantic sysval, unsigned int index)
 
static void vkd3d_spirv_stream_init (struct vkd3d_spirv_stream *stream)
 
static void vkd3d_spirv_stream_clear (struct vkd3d_spirv_stream *stream)
 
static void vkd3d_spirv_stream_free (struct vkd3d_spirv_stream *stream)
 
static void vkd3d_shader_code_from_spirv_stream (struct vkd3d_shader_code *code, struct vkd3d_spirv_stream *stream)
 
static size_t vkd3d_spirv_stream_current_location (struct vkd3d_spirv_stream *stream)
 
static void vkd3d_spirv_stream_insert (struct vkd3d_spirv_stream *stream, size_t location, const uint32_t *words, unsigned int word_count)
 
static bool vkd3d_spirv_stream_append (struct vkd3d_spirv_stream *dst_stream, const struct vkd3d_spirv_stream *src_stream)
 
static uint32_t vkd3d_spirv_alloc_id (struct vkd3d_spirv_builder *builder)
 
static bool vkd3d_spirv_capability_is_enabled (struct vkd3d_spirv_builder *builder, SpvCapability cap)
 
static void vkd3d_spirv_enable_capability (struct vkd3d_spirv_builder *builder, SpvCapability cap)
 
static uint32_t vkd3d_spirv_get_glsl_std450_instr_set (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_add_iface_variable (struct vkd3d_spirv_builder *builder, uint32_t id)
 
static void vkd3d_spirv_set_execution_model (struct vkd3d_spirv_builder *builder, SpvExecutionModel model)
 
static uint32_t vkd3d_spirv_opcode_word (SpvOp op, unsigned int word_count)
 
static void vkd3d_spirv_build_word (struct vkd3d_spirv_stream *stream, uint32_t word)
 
static unsigned int vkd3d_spirv_string_word_count (const char *str)
 
static void vkd3d_spirv_build_string (struct vkd3d_spirv_stream *stream, const char *str, unsigned int word_count)
 
static uint32_t vkd3d_spirv_build_once (struct vkd3d_spirv_builder *builder, uint32_t *id, vkd3d_spirv_build_pfn build_pfn)
 
static int vkd3d_spirv_declaration_compare (const void *key, const struct rb_entry *e)
 
static void vkd3d_spirv_declaration_free (struct rb_entry *entry, void *context)
 
static void vkd3d_spirv_insert_declaration (struct vkd3d_spirv_builder *builder, const struct vkd3d_spirv_declaration *declaration)
 
static uint32_t vkd3d_spirv_build_once1 (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, vkd3d_spirv_build1_pfn build_pfn)
 
static uint32_t vkd3d_spirv_build_once1v (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count, vkd3d_spirv_build1v_pfn build_pfn)
 
static uint32_t vkd3d_spirv_build_once2 (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, uint32_t operand1, vkd3d_spirv_build2_pfn build_pfn)
 
static uint32_t vkd3d_spirv_build_once7 (struct vkd3d_spirv_builder *builder, SpvOp op, const uint32_t *operands, vkd3d_spirv_build7_pfn build_pfn)
 
static void vkd3d_spirv_build_op (struct vkd3d_spirv_stream *stream, SpvOp op)
 
static void vkd3d_spirv_build_op1 (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand)
 
static void vkd3d_spirv_build_op1v (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
 
static void vkd3d_spirv_build_op2v (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, const uint32_t *operands, unsigned int operand_count)
 
static void vkd3d_spirv_build_op3v (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, uint32_t operand2, const uint32_t *operands, unsigned int operand_count)
 
static void vkd3d_spirv_build_op2 (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1)
 
static void vkd3d_spirv_build_op3 (struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, uint32_t operand2)
 
static uint32_t vkd3d_spirv_build_op_rv (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, const uint32_t *operands, unsigned int operand_count)
 
static uint32_t vkd3d_spirv_build_op_r (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op)
 
static uint32_t vkd3d_spirv_build_op_r1 (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0)
 
static uint32_t vkd3d_spirv_build_op_r2 (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_r1v (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
 
static uint32_t vkd3d_spirv_build_op_trv (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, const uint32_t *operands, unsigned int operand_count)
 
static uint32_t vkd3d_spirv_build_op_tr (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type)
 
static uint32_t vkd3d_spirv_build_op_tr1 (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0)
 
static uint32_t vkd3d_spirv_build_op_tr2 (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_tr3 (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1, uint32_t operand2)
 
static uint32_t vkd3d_spirv_build_op_tr1v (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
 
static uint32_t vkd3d_spirv_build_op_tr2v (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1, const uint32_t *operands, unsigned int operand_count)
 
static void vkd3d_spirv_begin_function_stream_insertion (struct vkd3d_spirv_builder *builder, size_t location)
 
static void vkd3d_spirv_end_function_stream_insertion (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_build_op_capability (struct vkd3d_spirv_stream *stream, SpvCapability cap)
 
static void vkd3d_spirv_build_op_extension (struct vkd3d_spirv_stream *stream, const char *name)
 
static void vkd3d_spirv_build_op_ext_inst_import (struct vkd3d_spirv_stream *stream, uint32_t result_id, const char *name)
 
static uint32_t vkd3d_spirv_build_op_ext_inst (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t inst_set, uint32_t inst_number, uint32_t *operands, unsigned int operand_count)
 
static void vkd3d_spirv_build_op_memory_model (struct vkd3d_spirv_stream *stream, SpvAddressingModel addressing_model, SpvMemoryModel memory_model)
 
static void vkd3d_spirv_build_op_entry_point (struct vkd3d_spirv_stream *stream, SpvExecutionModel model, uint32_t function_id, const char *name, uint32_t *interface_list, unsigned int interface_size)
 
static void vkd3d_spirv_build_op_execution_mode (struct vkd3d_spirv_stream *stream, uint32_t entry_point, SpvExecutionMode mode, const uint32_t *literals, unsigned int literal_count)
 
static void vkd3d_spirv_build_op_name (struct vkd3d_spirv_builder *builder, uint32_t id, const char *fmt,...)
 
static void vkd3d_spirv_build_op_member_name (struct vkd3d_spirv_builder *builder, uint32_t type_id, uint32_t member, const char *fmt,...)
 
static void vkd3d_spirv_build_op_decorate (struct vkd3d_spirv_builder *builder, uint32_t target_id, SpvDecoration decoration, uint32_t *literals, uint32_t literal_count)
 
static void vkd3d_spirv_build_op_decorate1 (struct vkd3d_spirv_builder *builder, uint32_t target_id, SpvDecoration decoration, uint32_t operand0)
 
static void vkd3d_spirv_build_op_member_decorate (struct vkd3d_spirv_builder *builder, uint32_t structure_type_id, uint32_t member_idx, SpvDecoration decoration, uint32_t *literals, uint32_t literal_count)
 
static void vkd3d_spirv_build_op_member_decorate1 (struct vkd3d_spirv_builder *builder, uint32_t structure_type_id, uint32_t member_idx, SpvDecoration decoration, uint32_t operand0)
 
static uint32_t vkd3d_spirv_build_op_type_void (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_get_op_type_void (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_type_bool (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_get_op_type_bool (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_type_float (struct vkd3d_spirv_builder *builder, uint32_t width)
 
static uint32_t vkd3d_spirv_get_op_type_float (struct vkd3d_spirv_builder *builder, uint32_t width)
 
static uint32_t vkd3d_spirv_build_op_type_int (struct vkd3d_spirv_builder *builder, uint32_t width, uint32_t signedness)
 
static uint32_t vkd3d_spirv_get_op_type_int (struct vkd3d_spirv_builder *builder, uint32_t width, uint32_t signedness)
 
static uint32_t vkd3d_spirv_build_op_type_vector (struct vkd3d_spirv_builder *builder, uint32_t component_type, uint32_t component_count)
 
static uint32_t vkd3d_spirv_get_op_type_vector (struct vkd3d_spirv_builder *builder, uint32_t component_type, uint32_t component_count)
 
static uint32_t vkd3d_spirv_build_op_type_array (struct vkd3d_spirv_builder *builder, uint32_t element_type, uint32_t length_id)
 
static uint32_t vkd3d_spirv_get_op_type_array (struct vkd3d_spirv_builder *builder, uint32_t element_type, uint32_t length_id)
 
static uint32_t vkd3d_spirv_build_op_type_runtime_array (struct vkd3d_spirv_builder *builder, uint32_t element_type)
 
static uint32_t vkd3d_spirv_get_op_type_runtime_array (struct vkd3d_spirv_builder *builder, uint32_t element_type)
 
static uint32_t vkd3d_spirv_build_op_type_struct (struct vkd3d_spirv_builder *builder, uint32_t *members, unsigned int member_count)
 
static uint32_t vkd3d_spirv_build_op_type_sampler (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_get_op_type_sampler (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_type_image (struct vkd3d_spirv_builder *builder, uint32_t sampled_type_id, uint32_t dim, uint32_t depth, uint32_t arrayed, uint32_t ms, uint32_t sampled, uint32_t format)
 
static uint32_t vkd3d_spirv_get_op_type_image (struct vkd3d_spirv_builder *builder, uint32_t sampled_type_id, SpvDim dim, uint32_t depth, uint32_t arrayed, uint32_t ms, uint32_t sampled, SpvImageFormat format)
 
static uint32_t vkd3d_spirv_build_op_type_sampled_image (struct vkd3d_spirv_builder *builder, uint32_t image_type_id)
 
static uint32_t vkd3d_spirv_get_op_type_sampled_image (struct vkd3d_spirv_builder *builder, uint32_t image_type_id)
 
static uint32_t vkd3d_spirv_build_op_type_function (struct vkd3d_spirv_builder *builder, uint32_t return_type, const uint32_t *param_types, unsigned int param_count)
 
static uint32_t vkd3d_spirv_get_op_type_function (struct vkd3d_spirv_builder *builder, uint32_t return_type, const uint32_t *param_types, unsigned int param_count)
 
static uint32_t vkd3d_spirv_build_op_type_pointer (struct vkd3d_spirv_builder *builder, uint32_t storage_class, uint32_t type_id)
 
static uint32_t vkd3d_spirv_get_op_type_pointer (struct vkd3d_spirv_builder *builder, uint32_t storage_class, uint32_t type_id)
 
static uint32_t vkd3d_spirv_build_op_constant_bool (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
 
static uint32_t vkd3d_spirv_get_op_constant_bool (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
 
static uint32_t vkd3d_spirv_build_op_constant (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
 
static uint32_t vkd3d_spirv_get_op_constant (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
 
static uint32_t vkd3d_spirv_build_op_constant64 (struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *values, unsigned int value_count)
 
static uint32_t vkd3d_spirv_get_op_constant64 (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint64_t value)
 
static uint32_t vkd3d_spirv_build_op_constant_null (struct vkd3d_spirv_builder *builder, uint32_t result_type)
 
static uint32_t vkd3d_spirv_get_op_constant_null (struct vkd3d_spirv_builder *builder, uint32_t result_type)
 
static uint32_t vkd3d_spirv_build_op_constant_composite (struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
 
static uint32_t vkd3d_spirv_build_op_spec_constant_composite (struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
 
static uint32_t vkd3d_spirv_get_op_constant_composite (struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
 
static uint32_t vkd3d_spirv_build_op_spec_constant (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
 
static uint32_t vkd3d_spirv_build_op_variable (struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, uint32_t type_id, uint32_t storage_class, uint32_t initializer)
 
static uint32_t vkd3d_spirv_build_op_function (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t result_id, uint32_t function_control, uint32_t function_type)
 
static uint32_t vkd3d_spirv_build_op_function_parameter (struct vkd3d_spirv_builder *builder, uint32_t result_type)
 
static void vkd3d_spirv_build_op_function_end (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_function_call (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t function_id, const uint32_t *arguments, unsigned int argument_count)
 
static uint32_t vkd3d_spirv_build_op_undef (struct vkd3d_spirv_builder *builder, uint32_t type_id)
 
static uint32_t vkd3d_spirv_get_op_undef (struct vkd3d_spirv_builder *builder, uint32_t type_id)
 
static uint32_t vkd3d_spirv_build_op_access_chain (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t *indexes, uint32_t index_count)
 
static uint32_t vkd3d_spirv_build_op_access_chain1 (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t index)
 
static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t *indexes, uint32_t index_count)
 
static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain1 (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t index)
 
static uint32_t vkd3d_spirv_build_op_vector_shuffle (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t vector1_id, uint32_t vector2_id, const uint32_t *components, uint32_t component_count)
 
static uint32_t vkd3d_spirv_build_op_composite_construct (struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
 
static uint32_t vkd3d_spirv_build_op_composite_extract (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t composite_id, const uint32_t *indexes, unsigned int index_count)
 
static uint32_t vkd3d_spirv_build_op_composite_extract1 (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t composite_id, uint32_t index)
 
static uint32_t vkd3d_spirv_build_op_composite_insert (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t object_id, uint32_t composite_id, const uint32_t *indexes, unsigned int index_count)
 
static uint32_t vkd3d_spirv_build_op_composite_insert1 (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t object_id, uint32_t composite_id, uint32_t index)
 
static uint32_t vkd3d_spirv_build_op_load (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t pointer_id, uint32_t memory_access)
 
static void vkd3d_spirv_build_op_store (struct vkd3d_spirv_builder *builder, uint32_t pointer_id, uint32_t object_id, uint32_t memory_access)
 
static void vkd3d_spirv_build_op_copy_memory (struct vkd3d_spirv_builder *builder, uint32_t target_id, uint32_t source_id, uint32_t memory_access)
 
static uint32_t vkd3d_spirv_build_op_select (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t condition_id, uint32_t object0_id, uint32_t object1_id)
 
static void vkd3d_spirv_build_op_kill (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_build_op_demote_to_helper_invocation (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_build_op_return (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_label (struct vkd3d_spirv_builder *builder, uint32_t label_id)
 
static void vkd3d_spirv_build_op_loop_merge (struct vkd3d_spirv_builder *builder, uint32_t merge_block, uint32_t continue_target, SpvLoopControlMask loop_control)
 
static void vkd3d_spirv_build_op_selection_merge (struct vkd3d_spirv_builder *builder, uint32_t merge_block, uint32_t selection_control)
 
static void vkd3d_spirv_build_op_branch (struct vkd3d_spirv_builder *builder, uint32_t label)
 
static void vkd3d_spirv_build_op_branch_conditional (struct vkd3d_spirv_builder *builder, uint32_t condition, uint32_t true_label, uint32_t false_label)
 
static void vkd3d_spirv_build_op_switch (struct vkd3d_spirv_builder *builder, uint32_t selector, uint32_t default_label, uint32_t *targets, unsigned int target_count)
 
static uint32_t vkd3d_spirv_build_op_iadd (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_imul (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_udiv (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_isub (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_fdiv (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_fnegate (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_snegate (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_and (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_shift_left_logical (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base, uint32_t shift)
 
static uint32_t vkd3d_spirv_build_op_shift_right_logical (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base, uint32_t shift)
 
static uint32_t vkd3d_spirv_build_op_logical_and (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_uless_than (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_uless_than_equal (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_is_inf (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_is_nan (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_logical_equal (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_logical_or (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
 
static uint32_t vkd3d_spirv_build_op_logical_not (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_convert_utof (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t unsigned_value)
 
static uint32_t vkd3d_spirv_build_op_bitcast (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_image_texel_pointer (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t sample_id)
 
static uint32_t vkd3d_spirv_build_op_sampled_image (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t sampler_id)
 
static uint32_t vkd3d_spirv_build_op_image (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id)
 
static uint32_t vkd3d_spirv_build_image_instruction (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, const uint32_t *operands, unsigned int operand_count, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_sample (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_sample_dref (struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t dref_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_gather (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t component_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_dref_gather (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t dref_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_fetch (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static uint32_t vkd3d_spirv_build_op_image_read (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
 
static void vkd3d_spirv_build_op_image_write (struct vkd3d_spirv_builder *builder, uint32_t image_id, uint32_t coordinate_id, uint32_t texel_id, uint32_t image_operands, const uint32_t *operands, unsigned int operand_count)
 
static uint32_t vkd3d_spirv_build_op_array_length (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t struct_id, uint32_t member_id)
 
static uint32_t vkd3d_spirv_build_op_image_query_size_lod (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t lod_id)
 
static uint32_t vkd3d_spirv_build_op_image_query_size (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
 
static uint32_t vkd3d_spirv_build_op_image_query_levels (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
 
static uint32_t vkd3d_spirv_build_op_image_query_samples (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
 
static uint32_t vkd3d_spirv_build_op_image_query_lod (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id)
 
static void vkd3d_spirv_build_op_emit_vertex (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_build_op_end_primitive (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_build_op_control_barrier (struct vkd3d_spirv_builder *builder, uint32_t execution_id, uint32_t memory_id, uint32_t memory_semantics_id)
 
static void vkd3d_spirv_build_op_memory_barrier (struct vkd3d_spirv_builder *builder, uint32_t memory_id, uint32_t memory_semantics_id)
 
static uint32_t vkd3d_spirv_build_op_scope_subgroup (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_get_op_scope_subgroup (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_swap (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t op_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_broadcast (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t index_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count (struct vkd3d_spirv_builder *builder, uint32_t result_type, SpvGroupOperation group_op, uint32_t val_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_elect (struct vkd3d_spirv_builder *builder)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t lane_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_shuffle (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t lane_id)
 
static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast_first (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_tr1 (struct vkd3d_spirv_builder *builder, enum GLSLstd450 op, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_fabs (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_sin (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_cos (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_max (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t y)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_umin (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t y)
 
static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp (struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t min, uint32_t max)
 
static uint32_t vkd3d_spirv_get_type_id (struct vkd3d_spirv_builder *builder, enum vkd3d_shader_component_type component_type, unsigned int component_count)
 
static uint32_t vkd3d_spirv_get_type_id_for_data_type (struct vkd3d_spirv_builder *builder, enum vkd3d_data_type data_type, unsigned int component_count)
 
static void vkd3d_spirv_builder_init (struct vkd3d_spirv_builder *builder, const char *entry_point)
 
static void vkd3d_spirv_builder_begin_main_function (struct vkd3d_spirv_builder *builder)
 
static void vkd3d_spirv_builder_free (struct vkd3d_spirv_builder *builder)
 
static bool vkd3d_spirv_compile_module (struct vkd3d_spirv_builder *builder, struct vkd3d_shader_code *spirv, const char *entry_point, enum vkd3d_shader_spirv_environment environment)
 
static const struct vkd3d_spirv_resource_type * vkd3d_get_spirv_resource_type (enum vkd3d_shader_resource_type resource_type)
 
static int vkd3d_symbol_compare (const void *key, const struct rb_entry *entry)
 
static void vkd3d_symbol_free (struct rb_entry *entry, void *context)
 
static void vkd3d_symbol_make_register (struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
 
static void vkd3d_symbol_make_io (struct vkd3d_symbol *symbol, enum vkd3d_shader_register_type type, unsigned int index)
 
static void vkd3d_symbol_set_register_info (struct vkd3d_symbol *symbol, uint32_t val_id, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, uint32_t write_mask)
 
static void vkd3d_symbol_make_resource (struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
 
static void vkd3d_symbol_make_sampler (struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
 
static void vkd3d_symbol_make_combined_sampler (struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *resource_reg, unsigned int sampler_space, unsigned int sampler_index)
 
static struct vkd3d_symbol * vkd3d_symbol_dup (const struct vkd3d_symbol *symbol)
 
static const char * debug_vkd3d_symbol (const struct vkd3d_symbol *symbol)
 
static bool is_in_default_phase (const struct spirv_compiler *compiler)
 
static bool is_in_control_point_phase (const struct spirv_compiler *compiler)
 
static bool is_in_fork_or_join_phase (const struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_initial_declarations (struct spirv_compiler *compiler)
 
static size_t spirv_compiler_get_current_function_location (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_main_prolog (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_io_declarations (struct spirv_compiler *compiler)
 
static const char * spirv_compiler_get_entry_point_name (const struct spirv_compiler *compiler)
 
static void spirv_compiler_destroy (struct spirv_compiler *compiler)
 
static struct spirv_compiler * spirv_compiler_create (const struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info, struct vkd3d_shader_message_context *message_context, uint64_t config_flags)
 
static bool spirv_compiler_use_storage_buffer (const struct spirv_compiler *compiler, const struct vkd3d_symbol_resource_data *resource)
 
static enum vkd3d_shader_spirv_environment spirv_compiler_get_target_environment (const struct spirv_compiler *compiler)
 
static bool spirv_compiler_is_opengl_target (const struct spirv_compiler *compiler)
 
static bool spirv_compiler_is_spirv_min_1_3_target (const struct spirv_compiler *compiler)
 
static bool spirv_compiler_is_target_extension_supported (const struct spirv_compiler *compiler, enum vkd3d_shader_spirv_extension extension)
 
static bool spirv_compiler_check_shader_visibility (const struct spirv_compiler *compiler, enum vkd3d_shader_visibility visibility)
 
static struct vkd3d_push_constant_buffer_binding * spirv_compiler_find_push_constant_buffer (const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
 
static bool spirv_compiler_has_combined_sampler_for_resource (const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
 
static bool spirv_compiler_has_combined_sampler_for_sampler (const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
 
static void VKD3D_PRINTF_FUNC (3, 4)
 
static struct vkd3d_string_buffer * vkd3d_shader_register_range_string (struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
 
static uint32_t spirv_compiler_get_label_id (struct spirv_compiler *compiler, unsigned int block_id)
 
static struct vkd3d_shader_descriptor_binding spirv_compiler_get_descriptor_binding (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, bool is_uav_counter, struct vkd3d_descriptor_binding_address *binding_address)
 
static void spirv_compiler_emit_descriptor_binding (struct spirv_compiler *compiler, uint32_t variable_id, const struct vkd3d_shader_descriptor_binding *binding)
 
static void spirv_compiler_decorate_nonuniform (struct spirv_compiler *compiler, uint32_t expression_id)
 
static const struct vkd3d_symbol * spirv_compiler_put_symbol (struct spirv_compiler *compiler, const struct vkd3d_symbol *symbol)
 
static uint32_t spirv_compiler_get_constant (struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint32_t *values)
 
static uint32_t spirv_compiler_get_constant64 (struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint64_t *values)
 
static uint32_t spirv_compiler_get_constant_uint (struct spirv_compiler *compiler, uint32_t value)
 
static uint32_t spirv_compiler_get_constant_float (struct spirv_compiler *compiler, float value)
 
static uint32_t spirv_compiler_get_constant_vector (struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t value)
 
static uint32_t spirv_compiler_get_constant_uint_vector (struct spirv_compiler *compiler, uint32_t value, unsigned int component_count)
 
static uint32_t spirv_compiler_get_constant_float_vector (struct spirv_compiler *compiler, float value, unsigned int component_count)
 
static uint32_t spirv_compiler_get_constant_double_vector (struct spirv_compiler *compiler, double value, unsigned int component_count)
 
static uint32_t spirv_compiler_get_constant_uint64_vector (struct spirv_compiler *compiler, uint64_t value, unsigned int component_count)
 
static uint32_t spirv_compiler_get_type_id_for_reg (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask)
 
static uint32_t spirv_compiler_get_type_id_for_dst (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
 
static bool spirv_compiler_get_register_name (char *buffer, unsigned int buffer_size, const struct vkd3d_shader_register *reg)
 
static void spirv_compiler_emit_register_debug_name (struct vkd3d_spirv_builder *builder, uint32_t id, const struct vkd3d_shader_register *reg)
 
static uint32_t spirv_compiler_emit_array_variable (struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, unsigned int component_count, const unsigned int *array_lengths, unsigned int length_count)
 
static uint32_t spirv_compiler_emit_variable (struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, unsigned int component_count)
 
static const struct vkd3d_spec_constant_info * get_spec_constant_info (enum vkd3d_shader_parameter_name name)
 
static uint32_t spirv_compiler_alloc_spec_constant_id (struct spirv_compiler *compiler, unsigned int count)
 
static uint32_t spirv_compiler_emit_spec_constant (struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, uint32_t spec_id, enum vkd3d_data_type type, unsigned int component_count)
 
static uint32_t spirv_compiler_get_spec_constant (struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, uint32_t spec_id, enum vkd3d_data_type type, unsigned int component_count)
 
static uint32_t spirv_compiler_get_buffer_parameter (struct spirv_compiler *compiler, const struct vkd3d_shader_parameter1 *parameter, enum vkd3d_data_type type, unsigned int component_count)
 
static uint32_t spirv_compiler_emit_shader_parameter (struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, enum vkd3d_data_type type, unsigned int component_count)
 
static uint32_t spirv_compiler_emit_construct_vector (struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t val_id, unsigned int val_component_idx, unsigned int val_component_count)
 
static uint32_t spirv_compiler_emit_load_src (struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src, uint32_t write_mask)
 
static uint32_t spirv_compiler_emit_register_addressing (struct spirv_compiler *compiler, const struct vkd3d_shader_register_index *reg_index)
 
static bool spirv_compiler_get_register_info (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, struct vkd3d_shader_register_info *register_info)
 
static bool spirv_compiler_enable_descriptor_indexing (struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_resource_type resource_type)
 
static uint32_t spirv_compiler_get_descriptor_index (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_symbol *array_symbol, unsigned int binding_base_idx, enum vkd3d_shader_resource_type resource_type)
 
static void spirv_compiler_emit_dereference_register (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, struct vkd3d_shader_register_info *register_info)
 
static uint32_t spirv_compiler_get_register_id (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg)
 
static bool vkd3d_swizzle_is_equal (uint32_t dst_write_mask, uint32_t swizzle, uint32_t write_mask)
 
static bool vkd3d_swizzle_is_scalar (uint32_t swizzle, const struct vkd3d_shader_register *reg)
 
static uint32_t spirv_compiler_emit_swizzle (struct spirv_compiler *compiler, uint32_t val_id, uint32_t val_write_mask, enum vkd3d_shader_component_type component_type, uint32_t swizzle, uint32_t write_mask)
 
static uint32_t spirv_compiler_emit_vector_shuffle (struct spirv_compiler *compiler, uint32_t vector1_id, uint32_t vector2_id, uint32_t swizzle, uint32_t write_mask, enum vkd3d_shader_component_type component_type, unsigned int component_count)
 
static uint32_t spirv_compiler_emit_int_to_bool (struct spirv_compiler *compiler, enum vkd3d_shader_conditional_op condition, enum vkd3d_data_type data_type, unsigned int component_count, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_bool_to_int (struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
 
static uint32_t spirv_compiler_emit_bool_to_int64 (struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
 
static uint32_t spirv_compiler_emit_bool_to_float (struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
 
static uint32_t spirv_compiler_emit_bool_to_double (struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
 
static uint32_t half_to_float (uint16_t value)
 
static uint32_t convert_raw_constant32 (enum vkd3d_data_type data_type, unsigned int uint_value)
 
static uint32_t spirv_compiler_emit_load_constant (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
 
static uint32_t spirv_compiler_emit_load_constant64 (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
 
static uint32_t spirv_compiler_emit_load_undef (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask)
 
static uint32_t spirv_compiler_emit_load_scalar (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask, const struct vkd3d_shader_register_info *reg_info)
 
static uint32_t spirv_compiler_emit_constant_array (struct spirv_compiler *compiler, const struct vkd3d_shader_immediate_constant_buffer *icb, uint32_t *type_id_out)
 
static const struct ssa_register_info * spirv_compiler_get_ssa_register_info (const struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg)
 
static void spirv_compiler_set_ssa_register_info (const struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_load_ssa_reg (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
 
static uint32_t spirv_compiler_emit_load_reg (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
 
static void spirv_compiler_emit_execution_mode (struct spirv_compiler *compiler, SpvExecutionMode mode, const uint32_t *literals, unsigned int literal_count)
 
static void spirv_compiler_emit_execution_mode1 (struct spirv_compiler *compiler, SpvExecutionMode mode, const uint32_t literal)
 
static uint32_t spirv_compiler_emit_abs (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_neg (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_src_modifier (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, enum vkd3d_shader_src_modifier modifier, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_load_src_with_type (struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src, uint32_t write_mask, enum vkd3d_shader_component_type component_type)
 
static void spirv_compiler_emit_store_scalar (struct spirv_compiler *compiler, uint32_t dst_id, uint32_t dst_write_mask, enum vkd3d_shader_component_type component_type, SpvStorageClass storage_class, uint32_t write_mask, uint32_t val_id)
 
static void spirv_compiler_emit_store (struct spirv_compiler *compiler, uint32_t dst_id, uint32_t dst_write_mask, enum vkd3d_shader_component_type component_type, SpvStorageClass storage_class, uint32_t write_mask, uint32_t val_id)
 
static void spirv_compiler_emit_store_reg (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
 
static uint32_t spirv_compiler_emit_sat (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
 
static void spirv_compiler_emit_store_dst (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id)
 
static void spirv_compiler_emit_store_dst_swizzled (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
 
static void spirv_compiler_emit_store_dst_components (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_component_type component_type, uint32_t *component_ids)
 
static void spirv_compiler_emit_store_dst_scalar (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
 
static void spirv_compiler_decorate_builtin (struct spirv_compiler *compiler, uint32_t target_id, SpvBuiltIn builtin)
 
static void spirv_compiler_emit_interpolation_decorations (struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, uint32_t id, enum vkd3d_shader_interpolation_mode mode)
 
static uint32_t spirv_compiler_emit_draw_parameter_fixup (struct spirv_compiler *compiler, uint32_t index_id, SpvBuiltIn base)
 
static uint32_t sv_vertex_id_fixup (struct spirv_compiler *compiler, uint32_t vertex_index_id)
 
static uint32_t sv_instance_id_fixup (struct spirv_compiler *compiler, uint32_t instance_index_id)
 
static uint32_t sv_front_face_fixup (struct spirv_compiler *compiler, uint32_t front_facing_id)
 
static uint32_t frag_coord_fixup (struct spirv_compiler *compiler, uint32_t frag_coord_id)
 
static void spirv_compiler_emit_register_execution_mode (struct spirv_compiler *compiler, enum vkd3d_shader_register_type type)
 
static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_sysval (const struct spirv_compiler *compiler, enum vkd3d_shader_sysval_semantic sysval)
 
static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_register (enum vkd3d_shader_register_type reg_type)
 
static const struct vkd3d_spirv_builtin * vkd3d_get_spirv_builtin (const struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_sysval_semantic sysval)
 
static uint32_t spirv_compiler_get_invocation_id (struct spirv_compiler *compiler)
 
static uint32_t spirv_compiler_emit_load_invocation_id (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_shader_phase_name (struct spirv_compiler *compiler, uint32_t id, const char *suffix)
 
static const struct vkd3d_shader_phase * spirv_compiler_get_current_shader_phase (struct spirv_compiler *compiler)
 
static void spirv_compiler_decorate_xfb_output (struct spirv_compiler *compiler, uint32_t id, unsigned int component_count, const struct signature_element *signature_element)
 
static uint32_t spirv_compiler_emit_builtin_variable_v (struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, SpvStorageClass storage_class, const unsigned int *array_sizes, unsigned int size_count)
 
static uint32_t spirv_compiler_emit_builtin_variable (struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, SpvStorageClass storage_class, unsigned int array_size)
 
static bool needs_private_io_variable (const struct vkd3d_spirv_builtin *builtin)
 
static unsigned int shader_signature_next_location (const struct shader_signature *signature)
 
static uint32_t spirv_compiler_emit_input (struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, unsigned int element_idx)
 
static void spirv_compiler_emit_input_register (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
 
static unsigned int get_shader_output_swizzle (const struct spirv_compiler *compiler, unsigned int register_idx)
 
static bool is_dual_source_blending (const struct spirv_compiler *compiler)
 
static void calculate_clip_or_cull_distance_mask (const struct signature_element *e, uint32_t *mask)
 
static void spirv_compiler_emit_shader_signature_outputs (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_output_register (struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
 
static uint32_t spirv_compiler_emit_shader_phase_builtin_variable (struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, const unsigned int *array_sizes, unsigned int size_count)
 
static void spirv_compiler_emit_output (struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, unsigned int element_idx)
 
static uint32_t spirv_compiler_get_output_array_index (struct spirv_compiler *compiler, const struct signature_element *e)
 
static void spirv_compiler_emit_store_shader_output (struct spirv_compiler *compiler, const struct shader_signature *signature, const struct signature_element *output, const struct vkd3d_shader_output_info *output_info, uint32_t output_index_id, uint32_t val_id, uint32_t write_mask)
 
static void spirv_compiler_emit_shader_epilogue_function (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_hull_shader_builtins (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_global_flags (struct spirv_compiler *compiler, enum vsir_global_flags flags)
 
static void spirv_compiler_emit_temps (struct spirv_compiler *compiler, uint32_t count)
 
static void spirv_compiler_allocate_ssa_register_ids (struct spirv_compiler *compiler, unsigned int count)
 
static void spirv_compiler_emit_dcl_indexable_temp (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_push_constant_buffers (struct spirv_compiler *compiler)
 
static const struct vkd3d_shader_descriptor_info1 * spirv_compiler_get_descriptor_info (struct spirv_compiler *compiler, enum vkd3d_shader_descriptor_type type, const struct vkd3d_shader_register_range *range)
 
static void spirv_compiler_decorate_descriptor (struct spirv_compiler *compiler, uint32_t var_id, bool write_only, bool coherent)
 
static uint32_t spirv_compiler_build_descriptor_variable (struct spirv_compiler *compiler, SpvStorageClass storage_class, uint32_t type_id, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, const struct vkd3d_shader_descriptor_info1 *descriptor, bool is_uav_counter, struct vkd3d_descriptor_variable_info *var_info)
 
static void spirv_compiler_emit_cbv_declaration (struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
 
static void spirv_compiler_emit_dcl_immediate_constant_buffer (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sampler_declaration (struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
 
static const struct vkd3d_spirv_resource_type * spirv_compiler_enable_resource_type (struct spirv_compiler *compiler, enum vkd3d_shader_resource_type resource_type, bool is_uav)
 
static SpvImageFormat image_format_for_image_read (enum vkd3d_shader_component_type data_type)
 
static uint32_t spirv_compiler_get_image_type_id (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_shader_component_type data_type, bool raw_structured)
 
static void spirv_compiler_emit_combined_sampler_declarations (struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource, const struct vkd3d_shader_register_range *resource_range, enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_component_type sampled_type, unsigned int structure_stride, bool raw, const struct vkd3d_spirv_resource_type *resource_type_info)
 
static void spirv_compiler_emit_resource_declaration (struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
 
static void spirv_compiler_emit_workgroup_memory (struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, unsigned int alignment, unsigned int size, unsigned int structure_stride, bool zero_init)
 
static void spirv_compiler_emit_dcl_tgsm_raw (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_tgsm_structured (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_input (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_output (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_stream (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_output_vertex_count (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_input_primitive (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_point_size (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_dcl_output_topology (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_gs_instances (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dcl_tessellator_domain (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_tessellator_output_primitive (struct spirv_compiler *compiler, enum vkd3d_shader_tessellator_output_primitive primitive)
 
static void spirv_compiler_emit_tessellator_partitioning (struct spirv_compiler *compiler, enum vkd3d_shader_tessellator_partitioning partitioning)
 
static void spirv_compiler_emit_thread_group_size (struct spirv_compiler *compiler, const struct vsir_thread_group_size *group_size)
 
static void spirv_compiler_emit_default_control_point_phase (struct spirv_compiler *compiler)
 
static void spirv_compiler_leave_shader_phase (struct spirv_compiler *compiler)
 
static void spirv_compiler_enter_shader_phase (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_initialise_block (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_barrier (struct spirv_compiler *compiler, SpvScope execution_scope, SpvScope memory_scope, SpvMemorySemanticsMask semantics)
 
static void spirv_compiler_emit_hull_shader_barrier (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_shader_epilogue_invocation (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_hull_shader_main (struct spirv_compiler *compiler)
 
static SpvOp spirv_compiler_map_alu_instruction (const struct vkd3d_shader_instruction *instruction)
 
static SpvOp spirv_compiler_map_logical_instruction (const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_bool_cast (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static enum vkd3d_result spirv_compiler_emit_alu_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_isfinite (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static enum GLSLstd450 spirv_compiler_map_ext_glsl_instruction (const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ext_glsl_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_mov (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_movc (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_swapc (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_dot (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_rcp (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sincos (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_imul (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_imad (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_int_div (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ftoi (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ftou (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_bitfield_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_f16tof32 (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_f32tof16 (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_comparison_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_orderedness_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_float_comparison_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t spirv_compiler_emit_conditional_branch (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction, uint32_t target_block_id)
 
static void spirv_compiler_end_invocation_interlock (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_return (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_retc (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t spirv_compiler_get_discard_function_id (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_discard_function (struct spirv_compiler *compiler)
 
static void spirv_compiler_emit_discard (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static bool spirv_compiler_init_blocks (struct spirv_compiler *compiler, unsigned int block_count)
 
static void spirv_compiler_emit_label (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_merge (struct spirv_compiler *compiler, uint32_t merge_block_id, uint32_t continue_block_id)
 
static void spirv_compiler_emit_branch (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_switch (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_deriv_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static const struct vkd3d_symbol * spirv_compiler_find_resource (struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource_reg)
 
static const struct vkd3d_symbol * spirv_compiler_find_combined_sampler (struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource_reg, const struct vkd3d_shader_register *sampler_reg)
 
static void spirv_compiler_prepare_image (struct spirv_compiler *compiler, struct vkd3d_shader_image *image, const struct vkd3d_shader_register *resource_reg, const struct vkd3d_shader_register *sampler_reg, unsigned int flags)
 
static uint32_t spirv_compiler_emit_texel_offset (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction, const struct vkd3d_spirv_resource_type *resource_type_info)
 
static void spirv_compiler_emit_ld (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_lod (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sample (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sample_c (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_gather4 (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t spirv_compiler_emit_raw_structured_addressing (struct spirv_compiler *compiler, uint32_t type_id, unsigned int stride, const struct vkd3d_shader_src_param *src0, uint32_t src0_mask, const struct vkd3d_shader_src_param *src1, uint32_t src1_mask)
 
static void spirv_compiler_emit_ld_raw_structured_srv_uav (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ld_tgsm (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ld_raw_structured (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_store_uav_raw_structured (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_store_tgsm (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_store_raw_structured (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_ld_uav_typed (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_store_uav_typed (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_uav_counter_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static SpvOp spirv_compiler_map_atomic_instruction (const struct vkd3d_shader_instruction *instruction)
 
static bool is_imm_atomic_instruction (enum vkd3d_shader_opcode opcode)
 
static void spirv_compiler_emit_atomic_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_bufinfo (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_resinfo (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t spirv_compiler_emit_query_sample_count (struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src)
 
static void spirv_compiler_emit_sample_info (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sample_position (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_eval_attrib (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_sync (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_emit_stream (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_cut_stream (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t map_quad_read_across_direction (enum vkd3d_shader_opcode opcode)
 
static void spirv_compiler_emit_quad_read_across (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_quad_read_lane_at (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static SpvOp map_wave_bool_op (enum vkd3d_shader_opcode opcode)
 
static void spirv_compiler_emit_wave_bool_op (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static uint32_t spirv_compiler_emit_group_nonuniform_ballot (struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src)
 
static void spirv_compiler_emit_wave_active_ballot (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static SpvOp map_wave_alu_op (enum vkd3d_shader_opcode opcode, bool is_float)
 
static void spirv_compiler_emit_wave_alu_op (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_wave_bit_count (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_wave_is_first_lane (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_wave_read_lane_at (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_wave_read_lane_first (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static int spirv_compiler_handle_instruction (struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
 
static void spirv_compiler_emit_descriptor_declarations (struct spirv_compiler *compiler)
 
static int spirv_compiler_generate_spirv (struct spirv_compiler *compiler, struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv)
 
int spirv_compile (struct vsir_program *program, uint64_t config_flags, const struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context)
 

Variables

static const struct vkd3d_spirv_resource_type vkd3d_spirv_resource_type_table []
 
static const struct vkd3d_spec_constant_info vkd3d_shader_parameters []
 
struct {
   enum vkd3d_data_type   type
 
   unsigned int   component_count
 
} parameter_data_type_map []
 
struct {
   enum vkd3d_shader_sysval_semantic   sysval
 
   struct vkd3d_spirv_builtin   builtin
 
   enum vkd3d_shader_spirv_environment   environment
 
} vkd3d_system_value_builtins []
 
static const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin
 
static const struct vkd3d_spirv_builtin vkd3d_output_point_size_builtin
 
struct {
   enum vkd3d_shader_register_type   reg_type
 
   struct vkd3d_spirv_builtin   builtin
 
} vkd3d_register_builtins []
 

Macro Definition Documentation

◆ MAX_SPIRV_DECLARATION_PARAMETER_COUNT

#define MAX_SPIRV_DECLARATION_PARAMETER_COUNT   7

Definition at line 552 of file spirv.c.

◆ VKD3D_IMAGE_FLAG_DEPTH

#define VKD3D_IMAGE_FLAG_DEPTH   0x1

Definition at line 8440 of file spirv.c.

◆ VKD3D_IMAGE_FLAG_NO_LOAD

#define VKD3D_IMAGE_FLAG_NO_LOAD   0x2

Definition at line 8441 of file spirv.c.

◆ VKD3D_IMAGE_FLAG_NONE

#define VKD3D_IMAGE_FLAG_NONE   0x0

Definition at line 8439 of file spirv.c.

◆ VKD3D_IMAGE_FLAG_SAMPLED

#define VKD3D_IMAGE_FLAG_SAMPLED   0x4

Definition at line 8442 of file spirv.c.

◆ VKD3D_SPIRV_GENERATOR_ID

#define VKD3D_SPIRV_GENERATOR_ID   18

Definition at line 252 of file spirv.c.

◆ VKD3D_SPIRV_GENERATOR_MAGIC

Definition at line 254 of file spirv.c.

◆ VKD3D_SPIRV_GENERATOR_VERSION

#define VKD3D_SPIRV_GENERATOR_VERSION   14

Definition at line 253 of file spirv.c.

◆ VKD3D_SPIRV_VERSION_1_0

#define VKD3D_SPIRV_VERSION_1_0   0x00010000

Definition at line 250 of file spirv.c.

◆ VKD3D_SPIRV_VERSION_1_3

#define VKD3D_SPIRV_VERSION_1_3   0x00010300

Definition at line 251 of file spirv.c.

Typedef Documentation

◆ vkd3d_spirv_build1_pfn

typedef uint32_t(* vkd3d_spirv_build1_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0)

Definition at line 534 of file spirv.c.

◆ vkd3d_spirv_build1v_pfn

typedef uint32_t(* vkd3d_spirv_build1v_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)

Definition at line 536 of file spirv.c.

◆ vkd3d_spirv_build2_pfn

typedef uint32_t(* vkd3d_spirv_build2_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, uint32_t operand1)

Definition at line 538 of file spirv.c.

◆ vkd3d_spirv_build7_pfn

typedef uint32_t(* vkd3d_spirv_build7_pfn) (struct vkd3d_spirv_builder *builder, uint32_t operand0, uint32_t operand1, uint32_t operand2, uint32_t operand3, uint32_t operand4, uint32_t operand5, uint32_t operand6)

Definition at line 540 of file spirv.c.

◆ vkd3d_spirv_build_pfn

typedef uint32_t(* vkd3d_spirv_build_pfn) (struct vkd3d_spirv_builder *builder)

Definition at line 533 of file spirv.c.

◆ vkd3d_spirv_builtin_fixup_pfn

typedef uint32_t(* vkd3d_spirv_builtin_fixup_pfn) (struct spirv_compiler *compiler, uint32_t val_id)

Definition at line 4763 of file spirv.c.

Function Documentation

◆ calculate_clip_or_cull_distance_mask()

static void calculate_clip_or_cull_distance_mask ( const struct signature_element *  e,
uint32_t *  mask 
)
static

Definition at line 5379 of file spirv.c.

5380{
5381 unsigned int write_mask;
5382
5383 if (e->semantic_index >= sizeof(*mask) * CHAR_BIT / VKD3D_VEC4_SIZE)
5384 {
5385 FIXME("Invalid semantic index %u for clip/cull distance.\n", e->semantic_index);
5386 return;
5387 }
5388
5389 write_mask = e->mask >> vsir_write_mask_get_component_idx(e->mask);
5390 *mask |= (write_mask & VKD3DSP_WRITEMASK_ALL) << (VKD3D_VEC4_SIZE * e->semantic_index);
5391}
#define FIXME(fmt,...)
Definition: precomp.h:53
#define CHAR_BIT
Definition: cabinet.h:45
GLenum GLint GLuint mask
Definition: glext.h:6028
#define e
Definition: ke_i.h:82
#define VKD3DSP_WRITEMASK_ALL
static unsigned int vsir_write_mask_get_component_idx(uint32_t write_mask)
#define VKD3D_VEC4_SIZE

Referenced by spirv_compiler_emit_shader_signature_outputs().

◆ convert_raw_constant32()

static uint32_t convert_raw_constant32 ( enum vkd3d_data_type  data_type,
unsigned int  uint_value 
)
static

Definition at line 3964 of file spirv.c.

3965{
3966 int16_t i;
3967
3968 /* TODO: native 16-bit support. */
3970 return uint_value;
3971
3973 return half_to_float(uint_value);
3974
3975 /* Values in DXIL have no signedness, so it is ambiguous whether 16-bit constants should or
3976 * should not be sign-extended when 16-bit execution is not supported. The AMD RX 580 Windows
3977 * driver has no 16-bit support, and sign-extends all 16-bit constant ints to 32 bits. These
3978 * results differ from SM 5. The RX 6750 XT supports 16-bit execution, so constants are not
3979 * extended, and results match SM 5. It seems best to replicate the sign-extension, and if
3980 * execution is 16-bit, the values will be truncated. */
3981 i = uint_value;
3982 return (int32_t)i;
3983}
INT32 int32_t
Definition: types.h:71
INT16 int16_t
Definition: types.h:70
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
enum wined3d_data_type data_type
Definition: glsl_shader.c:71
static uint32_t half_to_float(uint16_t value)
Definition: spirv.c:3922
@ VKD3D_DATA_HALF
@ VKD3D_DATA_UINT16

Referenced by spirv_compiler_emit_constant_array(), and spirv_compiler_emit_load_constant().

◆ debug_vkd3d_symbol()

static const char * debug_vkd3d_symbol ( const struct vkd3d_symbol *  symbol)
static

Definition at line 2362 of file spirv.c.

2363{
2364 switch (symbol->type)
2365 {
2366 case VKD3D_SYMBOL_REGISTER:
2367 return vkd3d_dbg_sprintf("register %#x, %u",
2368 symbol->key.reg.type, symbol->key.reg.idx);
2369 case VKD3D_SYMBOL_RESOURCE:
2370 return vkd3d_dbg_sprintf("resource %#x, %u",
2371 symbol->key.resource.type, symbol->key.resource.idx);
2372 case VKD3D_SYMBOL_SAMPLER:
2373 return vkd3d_dbg_sprintf("sampler %u",
2374 symbol->key.sampler.id);
2375 default:
2376 return vkd3d_dbg_sprintf("type %#x", symbol->type);
2377 }
2378}
struct vkd3d_symbol_sampler sampler
Definition: spirv.c:2239
enum vkd3d_symbol::@6011 type
union vkd3d_symbol::@6012 key
struct vkd3d_symbol_resource resource
Definition: spirv.c:2238
struct vkd3d_symbol_register reg
Definition: spirv.c:2237
const char * vkd3d_dbg_sprintf(const char *fmt,...) VKD3D_PRINTF_FUNC(1

Referenced by spirv_compiler_get_register_info(), and spirv_compiler_put_symbol().

◆ frag_coord_fixup()

static uint32_t frag_coord_fixup ( struct spirv_compiler *  compiler,
uint32_t  frag_coord_id 
)
static

Definition at line 4809 of file spirv.c.

4811{
4812 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4813 uint32_t type_id, w_id;
4814
4816 w_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, frag_coord_id, 3);
4817 w_id = vkd3d_spirv_build_op_fdiv(builder, type_id,
4818 spirv_compiler_get_constant_float(compiler, 1.0f), w_id);
4820 return vkd3d_spirv_build_op_composite_insert1(builder, type_id, w_id, frag_coord_id, 3);
4821}
UINT32 uint32_t
Definition: types.h:75
type_id
static uint32_t vkd3d_spirv_build_op_fdiv(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1489
static uint32_t vkd3d_spirv_build_op_composite_extract1(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t composite_id, uint32_t index)
Definition: spirv.c:1344
static uint32_t vkd3d_spirv_build_op_composite_insert1(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t object_id, uint32_t composite_id, uint32_t index)
Definition: spirv.c:1358
static uint32_t vkd3d_spirv_get_type_id(struct vkd3d_spirv_builder *builder, enum vkd3d_shader_component_type component_type, unsigned int component_count)
Definition: spirv.c:1910
static uint32_t spirv_compiler_get_constant_float(struct spirv_compiler *compiler, float value)
Definition: spirv.c:3119
struct vkd3d_spirv_builder spirv_builder
Definition: spirv.c:2414
@ VKD3D_SHADER_COMPONENT_FLOAT

◆ get_shader_output_swizzle()

static unsigned int get_shader_output_swizzle ( const struct spirv_compiler *  compiler,
unsigned int  register_idx 
)
static

Definition at line 5360 of file spirv.c.

5362{
5364
5365 if (!(info = compiler->spirv_target_info))
5367 if (register_idx >= info->output_swizzle_count)
5369 return info->output_swizzles[register_idx];
5370}
const struct vkd3d_shader_spirv_target_info * spirv_target_info
Definition: spirv.c:2440
#define VKD3D_SHADER_NO_SWIZZLE

Referenced by spirv_compiler_emit_output(), and spirv_compiler_emit_store_shader_output().

◆ get_spec_constant_info()

static const struct vkd3d_spec_constant_info * get_spec_constant_info ( enum vkd3d_shader_parameter_name  name)
static

Definition at line 3328 of file spirv.c.

3329{
3330 unsigned int i;
3331
3332 for (i = 0; i < ARRAY_SIZE(vkd3d_shader_parameters); ++i)
3333 {
3335 return &vkd3d_shader_parameters[i];
3336 }
3337
3338 FIXME("Unhandled parameter name %#x.\n", name);
3339 return NULL;
3340}
#define ARRAY_SIZE(A)
Definition: main.h:20
#define NULL
Definition: types.h:112
static const struct vkd3d_spec_constant_info vkd3d_shader_parameters[]
Definition: name.c:39

Referenced by spirv_compiler_emit_spec_constant().

◆ get_spirv_builtin_for_register()

static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_register ( enum vkd3d_shader_register_type  reg_type)
static

Definition at line 4972 of file spirv.c.

4974{
4975 unsigned int i;
4976
4977 for (i = 0; i < ARRAY_SIZE(vkd3d_register_builtins); ++i)
4978 {
4980 return &vkd3d_register_builtins[i].builtin;
4981 }
4982
4983 return NULL;
4984}
enum vkd3d_shader_register_type reg_type
Definition: spirv.c:4885
static const struct @6010 vkd3d_register_builtins[]

Referenced by spirv_compiler_emit_input_register(), spirv_compiler_emit_output_register(), and vkd3d_get_spirv_builtin().

◆ get_spirv_builtin_for_sysval()

static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_sysval ( const struct spirv_compiler *  compiler,
enum vkd3d_shader_sysval_semantic  sysval 
)
static

Definition at line 4945 of file spirv.c.

4947{
4949 unsigned int i;
4950
4952 return NULL;
4953
4954 /* In pixel shaders, SV_Position is mapped to SpvBuiltInFragCoord. */
4957
4959 for (i = 0; i < ARRAY_SIZE(vkd3d_system_value_builtins); ++i)
4960 {
4965 }
4966
4967 FIXME("Unhandled builtin (sysval %#x).\n", sysval);
4968
4969 return NULL;
4970}
enum vkd3d_shader_spirv_environment environment
Definition: spirv.c:4841
static enum vkd3d_shader_spirv_environment spirv_compiler_get_target_environment(const struct spirv_compiler *compiler)
Definition: spirv.c:2715
static const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin
Definition: spirv.c:4875
enum vkd3d_shader_sysval_semantic sysval
Definition: spirv.c:4839
struct vkd3d_spirv_builtin builtin
Definition: spirv.c:4840
static const struct @6009 vkd3d_system_value_builtins[]
enum vkd3d_shader_type shader_type
Definition: spirv.c:2432
@ VKD3D_SHADER_SV_TARGET
@ VKD3D_SHADER_SV_NONE
@ VKD3D_SHADER_SV_POSITION
vkd3d_shader_spirv_environment
@ VKD3D_SHADER_TYPE_PIXEL

Referenced by spirv_compiler_emit_input(), spirv_compiler_emit_shader_signature_outputs(), spirv_compiler_get_output_array_index(), and vkd3d_get_spirv_builtin().

◆ half_to_float()

static uint32_t half_to_float ( uint16_t  value)
static

Definition at line 3922 of file spirv.c.

3923{
3924 uint32_t s = (value & 0x8000u) << 16;
3925 uint32_t e = (value >> 10) & 0x1fu;
3926 uint32_t m = value & 0x3ffu;
3927
3928 if (!e)
3929 {
3930 if (!m)
3931 {
3932 /* Plus or minus zero */
3933 return s;
3934 }
3935 else
3936 {
3937 /* Denormalized number -- renormalize it */
3938
3939 while (!(m & 0x400u))
3940 {
3941 m <<= 1;
3942 --e;
3943 }
3944
3945 ++e;
3946 m &= ~0x400u;
3947 }
3948 }
3949 else if (e == 31u)
3950 {
3951 /* Positive or negative infinity for zero 'm'.
3952 * Nan for non-zero 'm' -- preserve sign and significand bits */
3953 return s | 0x7f800000u | (m << 13);
3954 }
3955
3956 /* Normalized number */
3957 e += 127u - 15u;
3958 m <<= 13;
3959
3960 /* Assemble s, e and m. */
3961 return s | (e << 23) | m;
3962}
GLdouble s
Definition: gl.h:2039
const GLfloat * m
Definition: glext.h:10848
Definition: pdh_main.c:64

Referenced by convert_raw_constant32().

◆ image_format_for_image_read()

static SpvImageFormat image_format_for_image_read ( enum vkd3d_shader_component_type  data_type)
static

Definition at line 6399 of file spirv.c.

6400{
6401 /* The following formats are supported by Direct3D 11 hardware for UAV
6402 * typed loads. A newer hardware may support more formats for UAV typed
6403 * loads (see StorageImageReadWithoutFormat SPIR-V capability).
6404 */
6405 switch (data_type)
6406 {
6408 return SpvImageFormatR32f;
6410 return SpvImageFormatR32i;
6412 return SpvImageFormatR32ui;
6413 default:
6414 FIXME("Unhandled type %#x.\n", data_type);
6415 return SpvImageFormatUnknown;
6416 }
6417}
@ SpvImageFormatUnknown
Definition: spirv.h:251
@ SpvImageFormatR32ui
Definition: spirv.h:284
@ SpvImageFormatR32i
Definition: spirv.h:275
@ SpvImageFormatR32f
Definition: spirv.h:254
@ VKD3D_SHADER_COMPONENT_INT
@ VKD3D_SHADER_COMPONENT_UINT

Referenced by spirv_compiler_get_image_type_id().

◆ is_dual_source_blending()

static bool is_dual_source_blending ( const struct spirv_compiler *  compiler)
static

Definition at line 5372 of file spirv.c.

5373{
5374 const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info;
5375
5376 return compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL && info && info->dual_source_blending;
5377}

Referenced by spirv_compiler_emit_output().

◆ is_imm_atomic_instruction()

static bool is_imm_atomic_instruction ( enum vkd3d_shader_opcode  opcode)
static

Definition at line 9377 of file spirv.c.

9378{
9379 return VKD3DSIH_IMM_ATOMIC_ALLOC <= opcode && opcode <= VKD3DSIH_IMM_ATOMIC_XOR;
9380}
@ VKD3DSIH_IMM_ATOMIC_XOR
@ VKD3DSIH_IMM_ATOMIC_ALLOC

Referenced by spirv_compiler_emit_atomic_instruction().

◆ is_in_control_point_phase()

static bool is_in_control_point_phase ( const struct spirv_compiler *  compiler)
static

◆ is_in_default_phase()

static bool is_in_default_phase ( const struct spirv_compiler *  compiler)
static

◆ is_in_fork_or_join_phase()

static bool is_in_fork_or_join_phase ( const struct spirv_compiler *  compiler)
static

◆ map_quad_read_across_direction()

static uint32_t map_quad_read_across_direction ( enum vkd3d_shader_opcode  opcode)
static

Definition at line 9937 of file spirv.c.

9938{
9939 switch (opcode)
9940 {
9942 return 0;
9944 return 1;
9946 return 2;
9947 default:
9949 }
9950}
#define vkd3d_unreachable()
Definition: vkd3d_common.h:119
@ VKD3DSIH_QUAD_READ_ACROSS_X
@ VKD3DSIH_QUAD_READ_ACROSS_D
@ VKD3DSIH_QUAD_READ_ACROSS_Y

Referenced by spirv_compiler_emit_quad_read_across().

◆ map_wave_alu_op()

static SpvOp map_wave_alu_op ( enum vkd3d_shader_opcode  opcode,
bool  is_float 
)
static

Definition at line 10054 of file spirv.c.

10055{
10056 switch (opcode)
10057 {
10080 default:
10082 }
10083}
static BOOL is_float(parse_buffer *buf)
Definition: parsing.c:520
@ SpvOpGroupNonUniformFMul
Definition: spirv.h:1520
@ SpvOpGroupNonUniformIMul
Definition: spirv.h:1519
@ SpvOpGroupNonUniformFMin
Definition: spirv.h:1523
@ SpvOpGroupNonUniformUMax
Definition: spirv.h:1525
@ SpvOpGroupNonUniformIAdd
Definition: spirv.h:1517
@ SpvOpGroupNonUniformFMax
Definition: spirv.h:1526
@ SpvOpGroupNonUniformFAdd
Definition: spirv.h:1518
@ SpvOpGroupNonUniformUMin
Definition: spirv.h:1522
@ SpvOpGroupNonUniformBitwiseAnd
Definition: spirv.h:1527
@ SpvOpGroupNonUniformSMin
Definition: spirv.h:1521
@ SpvOpGroupNonUniformSMax
Definition: spirv.h:1524
@ SpvOpGroupNonUniformBitwiseOr
Definition: spirv.h:1528
@ SpvOpGroupNonUniformBitwiseXor
Definition: spirv.h:1529
@ VKD3DSIH_WAVE_OP_IMAX
@ VKD3DSIH_WAVE_OP_MAX
@ VKD3DSIH_WAVE_OP_UMIN
@ VKD3DSIH_WAVE_ACTIVE_BIT_OR
@ VKD3DSIH_WAVE_OP_UMAX
@ VKD3DSIH_WAVE_ACTIVE_BIT_XOR
@ VKD3DSIH_WAVE_ACTIVE_BIT_AND
@ VKD3DSIH_WAVE_OP_MUL
@ VKD3DSIH_WAVE_OP_ADD
@ VKD3DSIH_WAVE_OP_IMIN
@ VKD3DSIH_WAVE_OP_MIN

Referenced by spirv_compiler_emit_wave_alu_op().

◆ map_wave_bool_op()

static SpvOp map_wave_bool_op ( enum vkd3d_shader_opcode  opcode)
static

Definition at line 9996 of file spirv.c.

9997{
9998 switch (opcode)
9999 {
10006 default:
10008 }
10009}
@ SpvOpGroupNonUniformAny
Definition: spirv.h:1503
@ SpvOpGroupNonUniformAll
Definition: spirv.h:1502
@ SpvOpGroupNonUniformAllEqual
Definition: spirv.h:1504
@ VKD3DSIH_WAVE_ACTIVE_ALL_EQUAL
@ VKD3DSIH_WAVE_ANY_TRUE
@ VKD3DSIH_WAVE_ALL_TRUE

Referenced by spirv_compiler_emit_wave_bool_op().

◆ needs_private_io_variable()

static bool needs_private_io_variable ( const struct vkd3d_spirv_builtin *  builtin)
static

Definition at line 5152 of file spirv.c.

5153{
5154 return builtin && builtin->fixup_pfn;
5155}

Referenced by spirv_compiler_emit_input(), and spirv_compiler_emit_output().

◆ shader_signature_next_location()

static unsigned int shader_signature_next_location ( const struct shader_signature *  signature)
static

Definition at line 5157 of file spirv.c.

5158{
5159 unsigned int i, max_row;
5160
5161 if (!signature)
5162 return 0;
5163
5164 for (i = 0, max_row = 0; i < signature->element_count; ++i)
5165 max_row = max(max_row, signature->elements[i].register_index + signature->elements[i].register_count);
5166 return max_row;
5167}
#define max(a, b)
Definition: svc.c:63

Referenced by spirv_compiler_emit_input(), and spirv_compiler_emit_output().

◆ spirv_compile()

int spirv_compile ( struct vsir_program *  program,
uint64_t  config_flags,
const struct vkd3d_shader_scan_descriptor_info1 *  scan_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 10835 of file spirv.c.

10839{
10841 int ret;
10842
10843 if (!(spirv_compiler = spirv_compiler_create(program, compile_info,
10845 {
10846 ERR("Failed to create SPIR-V compiler.\n");
10847 return VKD3D_ERROR;
10848 }
10849
10851
10853 return ret;
10854}
#define ERR(fmt,...)
Definition: precomp.h:57
return ret
Definition: mutex.c:147
GLuint program
Definition: glext.h:6723
static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv)
Definition: spirv.c:10665
static struct spirv_compiler * spirv_compiler_create(const struct vsir_program *program, const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_scan_descriptor_info1 *scan_descriptor_info, struct vkd3d_shader_message_context *message_context, uint64_t config_flags)
Definition: spirv.c:2554
static void spirv_compiler_destroy(struct spirv_compiler *compiler)
Definition: spirv.c:2527
uint64_t config_flags
Definition: spirv.c:2492
const struct vkd3d_shader_scan_descriptor_info1 * scan_descriptor_info
Definition: spirv.c:2465
struct vkd3d_shader_message_context * message_context
Definition: spirv.c:2417
@ VKD3D_ERROR
Definition: vkd3d_types.h:47
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

Referenced by vsir_program_compile().

◆ spirv_compiler_alloc_spec_constant_id()

static uint32_t spirv_compiler_alloc_spec_constant_id ( struct spirv_compiler *  compiler,
unsigned int  count 
)
static

Definition at line 3342 of file spirv.c.

3343{
3344 uint32_t ret;
3345
3346 if (!compiler->current_spec_constant_id)
3347 {
3348 unsigned int i, id = 0;
3349
3350 for (i = 0; i < compiler->program->parameter_count; ++i)
3351 {
3352 const struct vkd3d_shader_parameter1 *current = &compiler->program->parameters[i];
3353
3355 {
3356 switch (current->data_type)
3357 {
3359 id = max(current->u.specialization_constant.id + 4, id);
3360 break;
3361
3362 default:
3363 id = max(current->u.specialization_constant.id + 1, id);
3364 break;
3365 }
3366 }
3367 }
3368
3369 compiler->current_spec_constant_id = id;
3370 }
3371
3372 ret = compiler->current_spec_constant_id;
3373 compiler->current_spec_constant_id += count;
3374 return ret;
3375}
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint id
Definition: glext.h:5910
struct task_struct * current
Definition: linux.c:32
const struct vsir_program * program
Definition: spirv.c:2415
uint32_t current_spec_constant_id
Definition: spirv.c:2478
@ VKD3D_SHADER_PARAMETER_TYPE_SPECIALIZATION_CONSTANT
Definition: vkd3d_shader.h:487
@ VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4
Definition: vkd3d_shader.h:516

Referenced by spirv_compiler_emit_shader_parameter().

◆ spirv_compiler_allocate_ssa_register_ids()

static void spirv_compiler_allocate_ssa_register_ids ( struct spirv_compiler *  compiler,
unsigned int  count 
)
static

Definition at line 6012 of file spirv.c.

6013{
6014 VKD3D_ASSERT(!compiler->ssa_register_info);
6015 if (!(compiler->ssa_register_info = vkd3d_calloc(count, sizeof(*compiler->ssa_register_info))))
6016 {
6017 ERR("Failed to allocate SSA register value id array, count %u.\n", count);
6018 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY,
6019 "Failed to allocate SSA register value id array of count %u.", count);
6020 }
6021 compiler->ssa_register_count = count;
6022}
unsigned int ssa_register_count
Definition: spirv.c:2490
struct ssa_register_info * ssa_register_info
Definition: spirv.c:2489
#define VKD3D_ASSERT(cond)
Definition: vkd3d_common.h:49
static void * vkd3d_calloc(size_t count, size_t size)
Definition: vkd3d_memory.h:43
@ VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_build_descriptor_variable()

static uint32_t spirv_compiler_build_descriptor_variable ( struct spirv_compiler *  compiler,
SpvStorageClass  storage_class,
uint32_t  type_id,
const struct vkd3d_shader_register *  reg,
const struct vkd3d_shader_register_range *  range,
enum vkd3d_shader_resource_type  resource_type,
const struct vkd3d_shader_descriptor_info1 *  descriptor,
bool  is_uav_counter,
struct vkd3d_descriptor_variable_info *  var_info 
)
static

Definition at line 6193 of file spirv.c.

6198{
6199 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6200 struct vkd3d_descriptor_binding_address binding_address;
6202 uint32_t array_type_id, ptr_type_id, var_id;
6203 bool write_only = false, coherent = false;
6204 struct vkd3d_symbol symbol;
6205 struct rb_entry *entry;
6206
6208 resource_type, is_uav_counter, &binding_address);
6209 var_info->binding_base_idx = binding_address.binding_base_idx;
6210
6211 if (descriptor->type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV && !is_uav_counter)
6212 {
6214 /* ROVs are implicitly globally coherent. */
6216 }
6217
6218 if (binding.count == 1 && range->first == binding_address.binding_base_idx && range->last != ~0u
6219 && binding_address.push_constant_index == ~0u)
6220 {
6221 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
6222 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6223 ptr_type_id, storage_class, 0);
6224
6227 spirv_compiler_decorate_descriptor(compiler, var_id, write_only, coherent);
6228
6229 var_info->array_symbol = NULL;
6230 return var_id;
6231 }
6232
6234 array_type_id = vkd3d_spirv_get_op_type_runtime_array(builder, type_id);
6235 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, array_type_id);
6236
6237 /* Declare one array variable per Vulkan binding, and use it for
6238 * all array declarations which map to it. */
6239 symbol.type = VKD3D_SYMBOL_DESCRIPTOR_ARRAY;
6240 memset(&symbol.key, 0, sizeof(symbol.key));
6241 symbol.key.descriptor_array.ptr_type_id = ptr_type_id;
6242 symbol.key.descriptor_array.set = binding.set;
6243 symbol.key.descriptor_array.binding = binding.binding;
6244 symbol.key.descriptor_array.push_constant_index = binding_address.push_constant_index;
6245 symbol.key.descriptor_array.write_only = write_only;
6246 symbol.key.descriptor_array.coherent = coherent;
6247 if ((entry = rb_get(&compiler->symbol_table, &symbol)))
6248 {
6249 var_info->array_symbol = RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
6250 return var_info->array_symbol->id;
6251 }
6252
6253 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6254 ptr_type_id, storage_class, 0);
6257 spirv_compiler_decorate_descriptor(compiler, var_id, write_only, coherent);
6258
6259 symbol.id = var_id;
6260 symbol.descriptor_array = NULL;
6261 symbol.info.descriptor_array.storage_class = storage_class;
6262 symbol.info.descriptor_array.contained_type_id = type_id;
6263 var_info->array_symbol = spirv_compiler_put_symbol(compiler, &symbol);
6264
6265 return var_id;
6266}
range
Definition: d3dx9_private.h:58
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
static int reg
Definition: i386-dis.c:1290
uint32_t entry
Definition: isohybrid.c:63
static RPC_BINDING_HANDLE binding
Definition: server.c:166
descriptor
Definition: scsi.h:3997
#define RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:26
static struct rb_entry * rb_get(const struct rb_tree *tree, const void *key)
Definition: rbtree.h:192
#define memset(x, y, z)
Definition: compat.h:39
static void spirv_compiler_emit_descriptor_binding(struct spirv_compiler *compiler, uint32_t variable_id, const struct vkd3d_shader_descriptor_binding *binding)
Definition: spirv.c:3010
static uint32_t vkd3d_spirv_get_op_type_runtime_array(struct vkd3d_spirv_builder *builder, uint32_t element_type)
Definition: spirv.c:1086
static void spirv_compiler_emit_register_debug_name(struct vkd3d_spirv_builder *builder, uint32_t id, const struct vkd3d_shader_register *reg)
Definition: spirv.c:3278
static void vkd3d_spirv_enable_capability(struct vkd3d_spirv_builder *builder, SpvCapability cap)
Definition: spirv.c:438
static void spirv_compiler_decorate_descriptor(struct spirv_compiler *compiler, uint32_t var_id, bool write_only, bool coherent)
Definition: spirv.c:6182
static uint32_t vkd3d_spirv_get_op_type_pointer(struct vkd3d_spirv_builder *builder, uint32_t storage_class, uint32_t type_id)
Definition: spirv.c:1163
static uint32_t vkd3d_spirv_build_op_variable(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, uint32_t type_id, uint32_t storage_class, uint32_t initializer)
Definition: spirv.c:1252
static struct vkd3d_shader_descriptor_binding spirv_compiler_get_descriptor_binding(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, bool is_uav_counter, struct vkd3d_descriptor_binding_address *binding_address)
Definition: spirv.c:2898
static const struct vkd3d_symbol * spirv_compiler_put_symbol(struct spirv_compiler *compiler, const struct vkd3d_symbol *symbol)
Definition: spirv.c:3028
@ SpvCapabilityRuntimeDescriptorArrayEXT
Definition: spirv.h:997
Definition: rbtree.h:30
struct rb_tree symbol_table
Definition: spirv.c:2426
struct vkd3d_spirv_stream global_stream
Definition: spirv.c:401
@ VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_READ
@ VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
Definition: vkd3d_shader.h:430
@ VKD3DSUF_GLOBALLY_COHERENT
@ VKD3DSUF_RASTERISER_ORDERED_VIEW
storage_class
Definition: widltypes.h:246

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_resource_declaration(), and spirv_compiler_emit_sampler_declaration().

◆ spirv_compiler_check_shader_visibility()

static bool spirv_compiler_check_shader_visibility ( const struct spirv_compiler *  compiler,
enum vkd3d_shader_visibility  visibility 
)
static

Definition at line 2748 of file spirv.c.

2750{
2751 switch (visibility)
2752 {
2754 return true;
2756 return compiler->shader_type == VKD3D_SHADER_TYPE_VERTEX;
2758 return compiler->shader_type == VKD3D_SHADER_TYPE_HULL;
2760 return compiler->shader_type == VKD3D_SHADER_TYPE_DOMAIN;
2762 return compiler->shader_type == VKD3D_SHADER_TYPE_GEOMETRY;
2764 return compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL;
2766 return compiler->shader_type == VKD3D_SHADER_TYPE_COMPUTE;
2767 default:
2768 ERR("Invalid shader visibility %#x.\n", visibility);
2769 return false;
2770 }
2771}
@ VKD3D_SHADER_VISIBILITY_DOMAIN
Definition: vkd3d_shader.h:391
@ VKD3D_SHADER_VISIBILITY_COMPUTE
Definition: vkd3d_shader.h:398
@ VKD3D_SHADER_VISIBILITY_PIXEL
Definition: vkd3d_shader.h:395
@ VKD3D_SHADER_VISIBILITY_ALL
Definition: vkd3d_shader.h:385
@ VKD3D_SHADER_VISIBILITY_GEOMETRY
Definition: vkd3d_shader.h:393
@ VKD3D_SHADER_VISIBILITY_VERTEX
Definition: vkd3d_shader.h:387
@ VKD3D_SHADER_VISIBILITY_HULL
Definition: vkd3d_shader.h:389
@ VKD3D_SHADER_TYPE_VERTEX
@ VKD3D_SHADER_TYPE_HULL
@ VKD3D_SHADER_TYPE_GEOMETRY
@ VKD3D_SHADER_TYPE_COMPUTE
@ VKD3D_SHADER_TYPE_DOMAIN

Referenced by spirv_compiler_emit_combined_sampler_declarations(), spirv_compiler_find_push_constant_buffer(), spirv_compiler_get_descriptor_binding(), spirv_compiler_has_combined_sampler_for_resource(), and spirv_compiler_has_combined_sampler_for_sampler().

◆ spirv_compiler_create()

static struct spirv_compiler * spirv_compiler_create ( const struct vsir_program *  program,
const struct vkd3d_shader_compile_info *  compile_info,
const struct vkd3d_shader_scan_descriptor_info1 *  scan_descriptor_info,
struct vkd3d_shader_message_context *  message_context,
uint64_t  config_flags 
)
static

Definition at line 2554 of file spirv.c.

2558{
2559 const struct vkd3d_shader_interface_info *shader_interface;
2560 const struct vkd3d_shader_descriptor_offset_info *offset_info;
2561 const struct vkd3d_shader_spirv_target_info *target_info;
2562 struct spirv_compiler *compiler;
2563 unsigned int i;
2564
2565 if (!(compiler = vkd3d_malloc(sizeof(*compiler))))
2566 return NULL;
2567
2568 memset(compiler, 0, sizeof(*compiler));
2569 compiler->message_context = message_context;
2570 compiler->location.source_name = compile_info->source_name;
2571 compiler->config_flags = config_flags;
2572
2573 if ((target_info = vkd3d_find_struct(compile_info->next, SPIRV_TARGET_INFO)))
2574 {
2575 switch (target_info->environment)
2576 {
2580 break;
2581 default:
2582 WARN("Invalid target environment %#x.\n", target_info->environment);
2583 vkd3d_free(compiler);
2584 return NULL;
2585 }
2586
2587 compiler->spirv_target_info = target_info;
2588 }
2589
2591
2594 compiler->write_tess_geom_point_size = true;
2596
2597 for (i = 0; i < compile_info->option_count; ++i)
2598 {
2599 const struct vkd3d_shader_compile_option *option = &compile_info->options[i];
2600
2601 switch (option->name)
2602 {
2604 compiler->strip_debug = !!option->value;
2605 break;
2606
2609 compiler->ssbo_uavs = false;
2611 compiler->ssbo_uavs = true;
2612 else
2613 WARN("Ignoring unrecognised value %#x for option %#x.\n", option->value, option->name);
2614 break;
2615
2617 compiler->formatting = option->value;
2618 break;
2619
2621 compiler->api_version = option->value;
2622 break;
2623
2626 compiler->uav_read_without_format = false;
2628 compiler->uav_read_without_format = true;
2629 else
2630 WARN("Ignoring unrecognised value %#x for option %#x.\n", option->value, option->name);
2631 break;
2632
2634 compiler->write_tess_geom_point_size = option->value;
2635 break;
2636
2642 else
2643 WARN("Ignoring unrecognised value %#x for option %#x.\n", option->value, option->name);
2644 break;
2645
2647 compiler->features = option->value;
2648 break;
2649
2650 default:
2651 WARN("Ignoring unrecognised option %#x with value %#x.\n", option->name, option->value);
2652 break;
2653 }
2654 }
2655
2656 /* Explicit enabling of float64 was not required for API versions <= 1.10. */
2659
2661
2662 compiler->shader_type = program->shader_version.type;
2663
2664 if ((shader_interface = vkd3d_find_struct(compile_info->next, INTERFACE_INFO)))
2665 {
2666 compiler->xfb_info = vkd3d_find_struct(compile_info->next, TRANSFORM_FEEDBACK_INFO);
2667
2668 compiler->shader_interface = *shader_interface;
2669 if (shader_interface->push_constant_buffer_count)
2670 {
2671 if (!(compiler->push_constants = vkd3d_calloc(shader_interface->push_constant_buffer_count,
2672 sizeof(*compiler->push_constants))))
2673 {
2674 spirv_compiler_destroy(compiler);
2675 return NULL;
2676 }
2677 for (i = 0; i < shader_interface->push_constant_buffer_count; ++i)
2678 compiler->push_constants[i].pc = shader_interface->push_constant_buffers[i];
2679 }
2680
2681 if ((offset_info = vkd3d_find_struct(shader_interface->next, DESCRIPTOR_OFFSET_INFO)))
2682 {
2683 compiler->offset_info = *offset_info;
2684 if (compiler->offset_info.descriptor_table_count && !(compiler->descriptor_offset_ids = vkd3d_calloc(
2685 compiler->offset_info.descriptor_table_count, sizeof(*compiler->descriptor_offset_ids))))
2686 {
2687 spirv_compiler_destroy(compiler);
2688 return NULL;
2689 }
2690 }
2691 }
2692
2693 if (compiler->shader_type == VKD3D_SHADER_TYPE_VERTEX)
2694 compiler->emit_point_size = true;
2695 else if (compiler->shader_type != VKD3D_SHADER_TYPE_GEOMETRY)
2696 compiler->emit_point_size = compiler->xfb_info && compiler->xfb_info->element_count;
2697
2698 compiler->scan_descriptor_info = scan_descriptor_info;
2699
2700 compiler->phase = VKD3DSIH_INVALID;
2701
2703
2705
2706 return compiler;
2707}
#define WARN(fmt,...)
Definition: precomp.h:61
static void rb_init(struct rb_tree *tree, rb_compare_func_t compare)
Definition: rbtree.h:173
static const char * spirv_compiler_get_entry_point_name(const struct spirv_compiler *compiler)
Definition: spirv.c:2520
static int vkd3d_symbol_compare(const void *key, const struct rb_entry *entry)
Definition: spirv.c:2257
static void vkd3d_spirv_builder_init(struct vkd3d_spirv_builder *builder, const char *entry_point)
Definition: spirv.c:1974
static void spirv_compiler_emit_initial_declarations(struct spirv_compiler *compiler)
Definition: spirv.c:5870
@ SpvExecutionModeOriginLowerLeft
Definition: spirv.h:128
@ SpvExecutionModeOriginUpperLeft
Definition: spirv.h:127
Definition: getopt.h:109
WCHAR * name
Definition: getopt.h:110
enum vkd3d_shader_compile_option_feature_flags features
Definition: spirv.c:2483
bool uav_read_without_format
Definition: spirv.c:2423
const struct vkd3d_shader_transform_feedback_info * xfb_info
Definition: spirv.c:2451
SpvExecutionMode fragment_coordinate_origin
Definition: spirv.c:2424
enum vkd3d_shader_api_version api_version
Definition: spirv.c:2484
struct vkd3d_push_constant_buffer_binding * push_constants
Definition: spirv.c:2439
bool strip_debug
Definition: spirv.c:2421
struct vkd3d_shader_descriptor_offset_info offset_info
Definition: spirv.c:2435
uint32_t * descriptor_offset_ids
Definition: spirv.c:2438
enum vkd3d_shader_compile_option_formatting_flags formatting
Definition: spirv.c:2482
bool emit_point_size
Definition: spirv.c:2471
struct vkd3d_shader_location location
Definition: spirv.c:2418
bool ssbo_uavs
Definition: spirv.c:2422
struct vkd3d_shader_interface_info shader_interface
Definition: spirv.c:2434
bool write_tess_geom_point_size
Definition: spirv.c:2485
struct vkd3d_string_buffer_cache string_buffers
Definition: spirv.c:2487
const struct vkd3d_shader_compile_option * options
const struct vkd3d_shader_push_constant_buffer * push_constant_buffers
unsigned int push_constant_buffer_count
enum vkd3d_shader_spirv_environment environment
static void vkd3d_free(void *ptr)
Definition: vkd3d_memory.h:52
static void * vkd3d_malloc(size_t size)
Definition: vkd3d_memory.h:28
@ VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV
Definition: vkd3d_shader.h:281
@ VKD3D_SHADER_COMPILE_OPTION_API_VERSION
Definition: vkd3d_shader.h:279
@ VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE
Definition: vkd3d_shader.h:293
@ VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV
Definition: vkd3d_shader.h:275
@ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN
Definition: vkd3d_shader.h:320
@ VKD3D_SHADER_COMPILE_OPTION_FEATURE
Definition: vkd3d_shader.h:330
@ VKD3D_SHADER_COMPILE_OPTION_STRIP_DEBUG
Definition: vkd3d_shader.h:273
@ VKD3D_SHADER_COMPILE_OPTION_FORMATTING
Definition: vkd3d_shader.h:277
@ VKD3D_SHADER_COMPILE_OPTION_FORMATTING_HEADER
Definition: vkd3d_shader.h:158
@ VKD3D_SHADER_COMPILE_OPTION_FORMATTING_INDENT
Definition: vkd3d_shader.h:156
@ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_LOWER_LEFT
Definition: vkd3d_shader.h:221
@ VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_UPPER_LEFT
Definition: vkd3d_shader.h:218
@ VKD3D_SHADER_API_VERSION_1_10
Definition: vkd3d_shader.h:55
@ VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_UNKNOWN
Definition: vkd3d_shader.h:147
@ VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_R32
Definition: vkd3d_shader.h:142
@ VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_0
@ VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5
@ VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_1
@ VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLOAT64
Definition: vkd3d_shader.h:236
@ VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV_STORAGE_TEXEL_BUFFER
Definition: vkd3d_shader.h:128
@ VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV_STORAGE_BUFFER
Definition: vkd3d_shader.h:130
void vkd3d_string_buffer_cache_init(struct vkd3d_string_buffer_cache *cache)
#define vkd3d_find_struct(c, t)

Referenced by spirv_compile().

◆ spirv_compiler_decorate_builtin()

static void spirv_compiler_decorate_builtin ( struct spirv_compiler *  compiler,
uint32_t  target_id,
SpvBuiltIn  builtin 
)
static

Definition at line 4636 of file spirv.c.

4638{
4639 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4640
4641 switch (builtin)
4642 {
4644 if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL)
4646 break;
4649 break;
4650 case SpvBuiltInLayer:
4651 switch (compiler->shader_type)
4652 {
4656 break;
4657
4662 {
4663 FIXME("The target environment does not support decoration Layer.\n");
4664 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
4665 "Cannot use SV_RenderTargetArrayIndex. "
4666 "The target environment does not support decoration Layer.");
4667 }
4669 break;
4670
4671 default:
4672 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_SHADER,
4673 "Invalid use of SV_RenderTargetArrayIndex.");
4674 break;
4675 }
4676 break;
4678 switch (compiler->shader_type)
4679 {
4683 break;
4684
4689 {
4690 FIXME("The target environment does not support decoration ViewportIndex.\n");
4691 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
4692 "Cannot use SV_ViewportArrayIndex. "
4693 "The target environment does not support decoration ViewportIndex.");
4694 }
4696 break;
4697
4698 default:
4699 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_SHADER,
4700 "Invalid use of SV_ViewportArrayIndex.");
4701 break;
4702 }
4703 break;
4704 case SpvBuiltInSampleId:
4706 break;
4709 break;
4712 break;
4716 break;
4717 default:
4718 break;
4719 }
4720
4722}
static void vkd3d_spirv_build_op_decorate1(struct vkd3d_spirv_builder *builder, uint32_t target_id, SpvDecoration decoration, uint32_t operand0)
Definition: spirv.c:988
static bool spirv_compiler_is_target_extension_supported(const struct spirv_compiler *compiler, enum vkd3d_shader_spirv_extension extension)
Definition: spirv.c:2733
static void spirv_compiler_emit_execution_mode(struct spirv_compiler *compiler, SpvExecutionMode mode, const uint32_t *literals, unsigned int literal_count)
Definition: spirv.c:4325
@ SpvBuiltInCullDistance
Definition: spirv.h:564
@ SpvBuiltInFragDepth
Definition: spirv.h:581
@ SpvBuiltInClipDistance
Definition: spirv.h:563
@ SpvBuiltInSampleId
Definition: spirv.h:578
@ SpvBuiltInViewportIndex
Definition: spirv.h:570
@ SpvBuiltInSubgroupSize
Definition: spirv.h:594
@ SpvBuiltInLayer
Definition: spirv.h:569
@ SpvBuiltInSubgroupLocalInvocationId
Definition: spirv.h:599
@ SpvBuiltInPrimitiveId
Definition: spirv.h:567
@ SpvDecorationBuiltIn
Definition: spirv.h:457
@ SpvExecutionModeDepthReplacing
Definition: spirv.h:132
@ SpvCapabilityMultiViewport
Definition: spirv.h:925
@ SpvCapabilityGeometry
Definition: spirv.h:872
@ SpvCapabilityCullDistance
Definition: spirv.h:901
@ SpvCapabilityClipDistance
Definition: spirv.h:900
@ SpvCapabilitySampleRateShading
Definition: spirv.h:903
@ SpvCapabilityShaderViewportIndexLayerEXT
Definition: spirv.h:980
@ SpvCapabilityGroupNonUniform
Definition: spirv.h:929
@ VKD3D_SHADER_SPIRV_EXTENSION_EXT_VIEWPORT_INDEX_LAYER
@ VKD3D_SHADER_ERROR_SPV_INVALID_SHADER
@ VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE

Referenced by spirv_compiler_emit_builtin_variable_v(), and spirv_compiler_emit_draw_parameter_fixup().

◆ spirv_compiler_decorate_descriptor()

static void spirv_compiler_decorate_descriptor ( struct spirv_compiler *  compiler,
uint32_t  var_id,
bool  write_only,
bool  coherent 
)
static

Definition at line 6182 of file spirv.c.

6184{
6185 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6186
6187 if (write_only)
6189 if (coherent)
6191}
static void vkd3d_spirv_build_op_decorate(struct vkd3d_spirv_builder *builder, uint32_t target_id, SpvDecoration decoration, uint32_t *literals, uint32_t literal_count)
Definition: spirv.c:980
@ SpvDecorationNonReadable
Definition: spirv.h:470
@ SpvDecorationCoherent
Definition: spirv.h:468

Referenced by spirv_compiler_build_descriptor_variable().

◆ spirv_compiler_decorate_nonuniform()

static void spirv_compiler_decorate_nonuniform ( struct spirv_compiler *  compiler,
uint32_t  expression_id 
)
static

Definition at line 3019 of file spirv.c.

3021{
3022 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3023
3026}
@ SpvDecorationNonUniformEXT
Definition: spirv.h:506
@ SpvCapabilityShaderNonUniformEXT
Definition: spirv.h:995

Referenced by spirv_compiler_emit_dereference_register(), and spirv_compiler_prepare_image().

◆ spirv_compiler_decorate_xfb_output()

static void spirv_compiler_decorate_xfb_output ( struct spirv_compiler *  compiler,
uint32_t  id,
unsigned int  component_count,
const struct signature_element *  signature_element 
)
static

Definition at line 5060 of file spirv.c.

5062{
5063 const struct vkd3d_shader_transform_feedback_info *xfb_info = compiler->xfb_info;
5064 const struct vkd3d_shader_transform_feedback_element *xfb_element;
5065 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5066 unsigned int offset, stride, i;
5067
5068 if (!xfb_info)
5069 return;
5070
5071 offset = 0;
5072 xfb_element = NULL;
5073 for (i = 0; i < xfb_info->element_count; ++i)
5074 {
5075 const struct vkd3d_shader_transform_feedback_element *e = &xfb_info->elements[i];
5076
5077 if (e->stream_index == signature_element->stream_index
5079 && e->semantic_index == signature_element->semantic_index)
5080 {
5081 xfb_element = e;
5082 break;
5083 }
5084 }
5085
5086 if (!xfb_element)
5087 return;
5088
5089 for (i = 0; xfb_element != &xfb_info->elements[i]; ++i)
5090 if (xfb_info->elements[i].output_slot == xfb_element->output_slot)
5091 offset += 4 * xfb_info->elements[i].component_count;
5092
5093 if (xfb_element->component_index || xfb_element->component_count > component_count)
5094 {
5095 FIXME("Unhandled component range %u, %u.\n", xfb_element->component_index, xfb_element->component_count);
5096 return;
5097 }
5098
5099 if (xfb_element->output_slot < xfb_info->buffer_stride_count)
5100 {
5101 stride = xfb_info->buffer_strides[xfb_element->output_slot];
5102 }
5103 else
5104 {
5105 stride = 0;
5106 for (i = 0; i < xfb_info->element_count; ++i)
5107 {
5108 const struct vkd3d_shader_transform_feedback_element *e = &xfb_info->elements[i];
5109
5110 if (e->stream_index == xfb_element->stream_index && e->output_slot == xfb_element->output_slot)
5111 stride += 4 * e->component_count;
5112 }
5113 }
5114
5118}
GLsizei stride
Definition: glext.h:5848
GLintptr offset
Definition: glext.h:5920
unsigned int component_count
Definition: spirv.c:3449
@ SpvDecorationOffset
Definition: spirv.h:480
@ SpvDecorationXfbBuffer
Definition: spirv.h:481
@ SpvDecorationXfbStride
Definition: spirv.h:482
const struct vkd3d_shader_transform_feedback_element * elements
static int ascii_strcasecmp(const char *a, const char *b)
Definition: vkd3d_common.h:437

Referenced by spirv_compiler_emit_output().

◆ spirv_compiler_destroy()

static void spirv_compiler_destroy ( struct spirv_compiler *  compiler)
static

Definition at line 2527 of file spirv.c.

2528{
2529 vkd3d_free(compiler->output_info);
2530
2531 vkd3d_free(compiler->push_constants);
2533
2535
2537
2539
2540 vkd3d_free(compiler->spec_constants);
2541
2543
2547
2548 vkd3d_free(compiler->ssa_register_info);
2549 vkd3d_free(compiler->block_label_ids);
2550
2551 vkd3d_free(compiler);
2552}
static void rb_destroy(struct rb_tree *tree, rb_traverse_func_t *callback, void *context)
Definition: rbtree.h:185
static void vkd3d_symbol_free(struct rb_entry *entry, void *context)
Definition: spirv.c:2268
static void vkd3d_spirv_builder_free(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:2004
struct shader_signature output_signature
Definition: spirv.c:2449
struct spirv_compiler::@6014 * spirv_parameter_info
struct shader_signature patch_constant_signature
Definition: spirv.c:2450
struct shader_signature input_signature
Definition: spirv.c:2448
struct spirv_compiler::vkd3d_shader_output_info * output_info
uint32_t * block_label_ids
Definition: spirv.c:2494
struct vkd3d_shader_spec_constant * spec_constants
Definition: spirv.c:2480
void shader_signature_cleanup(struct shader_signature *signature)
void vkd3d_string_buffer_cache_cleanup(struct vkd3d_string_buffer_cache *cache)

Referenced by spirv_compile(), and spirv_compiler_create().

◆ spirv_compiler_emit_abs()

static uint32_t spirv_compiler_emit_abs ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4340 of file spirv.c.

4342{
4343 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4345
4346 type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
4347 if (data_type_is_floating_point(reg->data_type))
4348 return vkd3d_spirv_build_op_glsl_std450_fabs(builder, type_id, val_id);
4349
4350 FIXME("Unhandled data type %#x.\n", reg->data_type);
4351 return val_id;
4352}
static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask)
Definition: spirv.c:3161
static uint32_t vkd3d_spirv_build_op_glsl_std450_fabs(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1865
static bool data_type_is_floating_point(enum vkd3d_data_type data_type)

Referenced by spirv_compiler_emit_src_modifier().

◆ spirv_compiler_emit_alu_instruction()

static enum vkd3d_result spirv_compiler_emit_alu_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7236 of file spirv.c.

7238{
7239 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7240 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7241 const struct vkd3d_shader_src_param *src = instruction->src;
7243 uint32_t type_id, val_id;
7244 SpvOp op = SpvOpMax;
7245 unsigned int i;
7246
7247 if (src->reg.data_type == VKD3D_DATA_UINT64 && instruction->opcode == VKD3DSIH_COUNTBITS)
7248 {
7249 /* At least some drivers support this anyway, but if validation is enabled it will fail. */
7250 FIXME("Unsupported 64-bit source for bit count.\n");
7251 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED,
7252 "64-bit source for bit count is not supported.");
7254 }
7255
7256 if (src->reg.data_type == VKD3D_DATA_BOOL)
7257 {
7258 if (dst->reg.data_type == VKD3D_DATA_BOOL)
7259 {
7260 /* VSIR supports logic ops AND/OR/XOR on bool values. */
7262 }
7265 {
7266 /* VSIR supports cast from bool to signed/unsigned integer types and floating point types,
7267 * where bool is treated as a 1-bit integer and a signed 'true' value converts to -1. */
7269 return VKD3D_OK;
7270 }
7271 }
7272 else
7273 {
7275 }
7276
7277 if (op == SpvOpMax)
7278 {
7279 ERR("Unexpected instruction %#x.\n", instruction->opcode);
7280 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER,
7281 "Encountered invalid/unhandled instruction handler %#x.", instruction->opcode);
7283 }
7284
7285 VKD3D_ASSERT(instruction->dst_count == 1);
7287
7289
7290 for (i = 0; i < instruction->src_count; ++i)
7291 src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], dst->write_mask);
7292
7293 /* The SPIR-V specification states, "The resulting value is undefined if
7294 * Shift is greater than or equal to the bit width of the components of
7295 * Base." Direct3D applies only the lowest 5 bits of the shift.
7296 *
7297 * Microsoft fxc will compile immediate constants larger than 5 bits.
7298 * Fixing up the constants would be more elegant, but the simplest way is
7299 * to let this handle constants too. */
7302 {
7305 src_ids[1] = vkd3d_spirv_build_op_and(builder, type_id, src_ids[1], mask_id);
7306 }
7307
7308 val_id = vkd3d_spirv_build_op_trv(builder, &builder->function_stream, op, type_id,
7309 src_ids, instruction->src_count);
7310 if (instruction->flags & VKD3DSI_PRECISE_XYZW)
7312
7313 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7314 return VKD3D_OK;
7315}
UINT op
Definition: effect.c:235
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
static uint32_t spirv_compiler_get_type_id_for_dst(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
Definition: spirv.c:3171
static SpvOp spirv_compiler_map_alu_instruction(const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7133
static uint32_t spirv_compiler_emit_load_src(struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src, uint32_t write_mask)
Definition: spirv.c:4393
static uint32_t vkd3d_spirv_build_op_trv(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:791
static uint32_t spirv_compiler_get_constant_vector(struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t value)
Definition: spirv.c:3125
static SpvOp spirv_compiler_map_logical_instruction(const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7184
static uint32_t vkd3d_spirv_build_op_and(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1510
static void spirv_compiler_emit_bool_cast(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7199
static void spirv_compiler_emit_store_dst(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id)
Definition: spirv.c:4552
enum SpvOp_ SpvOp
@ SpvDecorationNoContraction
Definition: spirv.h:487
@ SpvOpMax
Definition: spirv.h:1852
struct shader_reg * src
struct shader_reg dst
struct vkd3d_spirv_stream function_stream
Definition: spirv.c:402
#define VKD3DSI_PRECISE_XYZW
static unsigned int vsir_write_mask_component_count(uint32_t write_mask)
@ VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED
@ VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER
#define SPIRV_MAX_SRC_COUNT
@ VKD3D_DATA_UINT64
@ VKD3D_DATA_BOOL
@ VKD3DSIH_UTOU
@ VKD3DSIH_ISHL
@ VKD3DSIH_ISHR
@ VKD3DSIH_COUNTBITS
@ VKD3DSIH_UTOF
@ VKD3DSIH_USHR
@ VKD3DSIH_ITOI
@ VKD3DSIH_ITOF
#define VKD3DSI_SHIFT_UNMASKED
@ VKD3D_ERROR_INVALID_SHADER
Definition: vkd3d_types.h:53
@ VKD3D_OK
Definition: vkd3d_types.h:43

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_array_variable()

static uint32_t spirv_compiler_emit_array_variable ( struct spirv_compiler *  compiler,
struct vkd3d_spirv_stream *  stream,
SpvStorageClass  storage_class,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count,
const unsigned int *  array_lengths,
unsigned int  length_count 
)
static

Definition at line 3286 of file spirv.c.

3290{
3291 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3292 uint32_t type_id, length_id, ptr_type_id;
3293 unsigned int i;
3294
3296 for (i = 0; i < length_count; ++i)
3297 {
3298 if (!array_lengths[i])
3299 continue;
3300 length_id = spirv_compiler_get_constant_uint(compiler, array_lengths[i]);
3301 type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
3302 }
3303
3304 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
3305 return vkd3d_spirv_build_op_variable(builder, stream, ptr_type_id, storage_class, 0);
3306}
component_type
static uint32_t vkd3d_spirv_get_op_type_array(struct vkd3d_spirv_builder *builder, uint32_t element_type, uint32_t length_id)
Definition: spirv.c:1074
static uint32_t spirv_compiler_get_constant_uint(struct spirv_compiler *compiler, uint32_t value)
Definition: spirv.c:3113
Definition: parse.h:23

Referenced by spirv_compiler_emit_builtin_variable_v(), spirv_compiler_emit_input(), spirv_compiler_emit_output(), and spirv_compiler_emit_variable().

◆ spirv_compiler_emit_atomic_instruction()

static void spirv_compiler_emit_atomic_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9382 of file spirv.c.

9384{
9385 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9386 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9387 const struct vkd3d_shader_src_param *src = instruction->src;
9388 const struct vkd3d_symbol *resource_symbol = NULL;
9389 uint32_t ptr_type_id, type_id, val_id, result_id;
9391 const struct vkd3d_shader_dst_param *resource;
9392 uint32_t coordinate_id, sample_id, pointer_id;
9394 SpvMemorySemanticsMask memory_semantic;
9396 unsigned int structure_stride;
9397 uint32_t coordinate_mask;
9398 uint32_t operands[6];
9399 unsigned int i = 0;
9400 SpvScope scope;
9401 bool raw;
9402 SpvOp op;
9403
9405
9407 if (op == SpvOpMax)
9408 {
9409 ERR("Unexpected instruction %#x.\n", instruction->opcode);
9410 return;
9411 }
9412
9413 if (resource->reg.type == VKD3DSPR_GROUPSHAREDMEM)
9414 {
9415 scope = SpvScopeWorkgroup;
9416 coordinate_mask = 1u;
9417 if (!spirv_compiler_get_register_info(compiler, &resource->reg, &reg_info))
9418 return;
9419 structure_stride = reg_info.structure_stride;
9421 }
9422 else
9423 {
9424 scope = SpvScopeDevice;
9425 resource_symbol = spirv_compiler_find_resource(compiler, &resource->reg);
9426
9427 if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
9428 {
9429 coordinate_mask = VKD3DSP_WRITEMASK_0;
9430 structure_stride = resource_symbol->info.resource.structure_stride;
9431 raw = resource_symbol->info.resource.raw;
9432 }
9433 else
9434 {
9436 coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1;
9437 structure_stride = image.structure_stride;
9438 raw = image.raw;
9439 }
9440 }
9441
9443 if (structure_stride || raw)
9444 {
9446 coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
9449 }
9450 else
9451 {
9453 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], coordinate_mask);
9454 }
9455
9456 if (resource->reg.type == VKD3DSPR_GROUPSHAREDMEM)
9457 {
9459 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
9460 pointer_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, reg_info.id, coordinate_id);
9461 }
9462 else
9463 {
9464 if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
9465 {
9466 component_type = resource_symbol->info.resource.sampled_type;
9469 operands[0] = spirv_compiler_get_constant_uint(compiler, 0);
9470 operands[1] = coordinate_id;
9471 pointer_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, resource_symbol->id, operands, 2);
9472 }
9473 else
9474 {
9475 component_type = image.sampled_type;
9476 type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, 1);
9478 sample_id = spirv_compiler_get_constant_uint(compiler, 0);
9479 pointer_id = vkd3d_spirv_build_op_image_texel_pointer(builder,
9480 ptr_type_id, image.id, coordinate_id, sample_id);
9481 }
9482 }
9483
9485
9486 if (instruction->flags & VKD3DARF_VOLATILE)
9487 {
9488 WARN("Ignoring 'volatile' attribute.\n");
9489 spirv_compiler_warning(compiler, VKD3D_SHADER_WARNING_SPV_IGNORING_FLAG,
9490 "Ignoring the 'volatile' attribute flag for atomic instruction %#x.", instruction->opcode);
9491 }
9492
9493 memory_semantic = (instruction->flags & VKD3DARF_SEQ_CST)
9496
9497 operands[i++] = pointer_id;
9498 operands[i++] = spirv_compiler_get_constant_uint(compiler, scope);
9499 operands[i++] = spirv_compiler_get_constant_uint(compiler, memory_semantic);
9500 if (instruction->src_count >= 3)
9501 {
9502 operands[i++] = spirv_compiler_get_constant_uint(compiler, memory_semantic);
9504 }
9505 operands[i++] = val_id;
9506 result_id = vkd3d_spirv_build_op_trv(builder, &builder->function_stream,
9507 op, type_id, operands, i);
9508
9510 spirv_compiler_emit_store_dst(compiler, dst, result_id);
9511}
#define resource
Definition: kernel32.h:9
static uint32_t vkd3d_spirv_build_op_access_chain(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t *indexes, uint32_t index_count)
Definition: spirv.c:1296
static bool spirv_compiler_get_register_info(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, struct vkd3d_shader_register_info *register_info)
Definition: spirv.c:3555
static uint32_t vkd3d_spirv_build_op_image_texel_pointer(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t sample_id)
Definition: spirv.c:1598
static uint32_t vkd3d_spirv_build_op_access_chain1(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t index)
Definition: spirv.c:1303
static bool is_imm_atomic_instruction(enum vkd3d_shader_opcode opcode)
Definition: spirv.c:9377
static void spirv_compiler_prepare_image(struct spirv_compiler *compiler, struct vkd3d_shader_image *image, const struct vkd3d_shader_register *resource_reg, const struct vkd3d_shader_register *sampler_reg, unsigned int flags)
Definition: spirv.c:8490
static bool spirv_compiler_use_storage_buffer(const struct spirv_compiler *compiler, const struct vkd3d_symbol_resource_data *resource)
Definition: spirv.c:2709
static const struct vkd3d_symbol * spirv_compiler_find_resource(struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource_reg)
Definition: spirv.c:8444
#define VKD3D_IMAGE_FLAG_NO_LOAD
Definition: spirv.c:8441
static uint32_t spirv_compiler_emit_load_src_with_type(struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src, uint32_t write_mask, enum vkd3d_shader_component_type component_type)
Definition: spirv.c:4402
static uint32_t spirv_compiler_emit_raw_structured_addressing(struct spirv_compiler *compiler, uint32_t type_id, unsigned int stride, const struct vkd3d_shader_src_param *src0, uint32_t src0_mask, const struct vkd3d_shader_src_param *src1, uint32_t src1_mask)
Definition: spirv.c:8869
static SpvOp spirv_compiler_map_atomic_instruction(const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9337
@ SpvStorageClassImage
Definition: spirv.h:202
@ SpvStorageClassUniform
Definition: spirv.h:193
@ SpvScopeDevice
Definition: spirv.h:831
@ SpvScopeWorkgroup
Definition: spirv.h:832
enum SpvScope_ SpvScope
enum SpvMemorySemanticsMask_ SpvMemorySemanticsMask
@ SpvMemorySemanticsSequentiallyConsistentMask
Definition: spirv.h:783
@ SpvMemorySemanticsMaskNone
Definition: spirv.h:779
Definition: image.c:84
unsigned int structure_stride
Definition: spirv.c:8435
uint32_t id
Definition: spirv.c:2244
union vkd3d_symbol::@6013 info
vkd3d_shader_component_type
@ VKD3DSPR_GROUPSHAREDMEM
@ VKD3DARF_SEQ_CST
@ VKD3DARF_VOLATILE
@ VKD3D_SHADER_WARNING_SPV_IGNORING_FLAG
#define VKD3DSP_WRITEMASK_0
#define VKD3DSP_WRITEMASK_1

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_barrier()

static void spirv_compiler_emit_barrier ( struct spirv_compiler *  compiler,
SpvScope  execution_scope,
SpvScope  memory_scope,
SpvMemorySemanticsMask  semantics 
)
static

Definition at line 7060 of file spirv.c.

7062{
7063 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7064 uint32_t execution_id, memory_id, semantics_id;
7065
7066 memory_id = spirv_compiler_get_constant_uint(compiler, memory_scope);
7067 semantics_id = spirv_compiler_get_constant_uint(compiler, semantics);
7068
7069 if (execution_scope != SpvScopeMax)
7070 {
7071 execution_id = spirv_compiler_get_constant_uint(compiler, execution_scope);
7072 vkd3d_spirv_build_op_control_barrier(builder, execution_id, memory_id, semantics_id);
7073 }
7074 else
7075 {
7076 vkd3d_spirv_build_op_memory_barrier(builder, memory_id, semantics_id);
7077 }
7078}
static void vkd3d_spirv_build_op_memory_barrier(struct vkd3d_spirv_builder *builder, uint32_t memory_id, uint32_t memory_semantics_id)
Definition: spirv.c:1778
static void vkd3d_spirv_build_op_control_barrier(struct vkd3d_spirv_builder *builder, uint32_t execution_id, uint32_t memory_id, uint32_t memory_semantics_id)
Definition: spirv.c:1771
@ SpvScopeMax
Definition: spirv.h:838

Referenced by spirv_compiler_emit_hull_shader_barrier(), and spirv_compiler_emit_sync().

◆ spirv_compiler_emit_bitfield_instruction()

static void spirv_compiler_emit_bitfield_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7878 of file spirv.c.

7880{
7881 uint32_t src_ids[4], constituents[VKD3D_VEC4_SIZE], type_id, mask_id, size_id, max_count_id;
7882 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7883 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7884 const struct vkd3d_shader_src_param *src = instruction->src;
7886 unsigned int i, j, k, src_count, size;
7887 uint32_t write_mask;
7888 SpvOp op;
7889
7890 src_count = instruction->src_count;
7891 VKD3D_ASSERT(2 <= src_count && src_count <= ARRAY_SIZE(src_ids));
7892
7895 size = (src[src_count - 1].reg.data_type == VKD3D_DATA_UINT64) ? 0x40 : 0x20;
7896 mask_id = spirv_compiler_get_constant_uint(compiler, size - 1);
7897 size_id = spirv_compiler_get_constant_uint(compiler, size);
7898
7899 switch (instruction->opcode)
7900 {
7901 case VKD3DSIH_BFI: op = SpvOpBitFieldInsert; break;
7902 case VKD3DSIH_IBFE: op = SpvOpBitFieldSExtract; break;
7903 case VKD3DSIH_UBFE: op = SpvOpBitFieldUExtract; break;
7904 default:
7905 ERR("Unexpected instruction %#x.\n", instruction->opcode);
7906 return;
7907 }
7908
7909 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
7910 for (i = 0, k = 0; i < VKD3D_VEC4_SIZE; ++i)
7911 {
7912 if (!(write_mask = dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
7913 continue;
7914
7915 for (j = 0; j < src_count; ++j)
7916 {
7917 src_ids[src_count - j - 1] = spirv_compiler_emit_load_src_with_type(compiler,
7918 &src[j], write_mask, component_type);
7919 }
7920
7921 /* In SPIR-V, the last two operands are Offset and Count. */
7922 for (j = src_count - 2; j < src_count; ++j)
7923 {
7924 src_ids[j] = vkd3d_spirv_build_op_and(builder, type_id, src_ids[j], mask_id);
7925 }
7926 max_count_id = vkd3d_spirv_build_op_isub(builder, type_id, size_id, src_ids[src_count - 2]);
7927 src_ids[src_count - 1] = vkd3d_spirv_build_op_glsl_std450_umin(builder, type_id,
7928 src_ids[src_count - 1], max_count_id);
7929
7930 constituents[k++] = vkd3d_spirv_build_op_trv(builder, &builder->function_stream,
7931 op, type_id, src_ids, src_count);
7932 }
7933
7935}
GLsizeiptr size
Definition: glext.h:5919
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
int k
Definition: mpi.c:3369
static uint32_t vkd3d_spirv_build_op_isub(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1482
static uint32_t vkd3d_spirv_build_op_glsl_std450_umin(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t y)
Definition: spirv.c:1892
static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_component_type component_type, uint32_t *component_ids)
Definition: spirv.c:4591
@ SpvOpBitFieldUExtract
Definition: spirv.h:1384
@ SpvOpBitFieldInsert
Definition: spirv.h:1382
@ SpvOpBitFieldSExtract
Definition: spirv.h:1383
static enum vkd3d_shader_component_type vkd3d_component_type_from_data_type(enum vkd3d_data_type data_type)
@ VKD3DSIH_BFI
@ VKD3DSIH_UBFE
@ VKD3DSIH_IBFE

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_bool_cast()

static void spirv_compiler_emit_bool_cast ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7199 of file spirv.c.

7201{
7202 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7203 const struct vkd3d_shader_src_param *src = instruction->src;
7204 uint32_t val_id;
7205
7206 VKD3D_ASSERT(src->reg.data_type == VKD3D_DATA_BOOL && dst->reg.data_type != VKD3D_DATA_BOOL);
7207
7208 val_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
7209 if (dst->reg.data_type == VKD3D_DATA_HALF || dst->reg.data_type == VKD3D_DATA_FLOAT)
7210 {
7211 val_id = spirv_compiler_emit_bool_to_float(compiler, 1, val_id, instruction->opcode == VKD3DSIH_ITOF);
7212 }
7213 else if (dst->reg.data_type == VKD3D_DATA_DOUBLE)
7214 {
7215 /* ITOD is not supported. Frontends which emit bool casts must use ITOF for double. */
7216 val_id = spirv_compiler_emit_bool_to_double(compiler, 1, val_id, instruction->opcode == VKD3DSIH_ITOF);
7217 }
7218 else if (dst->reg.data_type == VKD3D_DATA_UINT16 || dst->reg.data_type == VKD3D_DATA_UINT)
7219 {
7220 val_id = spirv_compiler_emit_bool_to_int(compiler, 1, val_id, instruction->opcode == VKD3DSIH_ITOI);
7221 }
7222 else if (dst->reg.data_type == VKD3D_DATA_UINT64)
7223 {
7224 val_id = spirv_compiler_emit_bool_to_int64(compiler, 1, val_id, instruction->opcode == VKD3DSIH_ITOI);
7225 }
7226 else
7227 {
7228 WARN("Unhandled data type %u.\n", dst->reg.data_type);
7229 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_TYPE,
7230 "Register data type %u is unhandled.", dst->reg.data_type);
7231 }
7232
7233 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7234}
static uint32_t spirv_compiler_emit_bool_to_double(struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
Definition: spirv.c:3909
static uint32_t spirv_compiler_emit_bool_to_int64(struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
Definition: spirv.c:3884
static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
Definition: spirv.c:3872
static uint32_t spirv_compiler_emit_bool_to_float(struct spirv_compiler *compiler, unsigned int component_count, uint32_t val_id, bool signedness)
Definition: spirv.c:3897
@ VKD3D_SHADER_ERROR_SPV_INVALID_TYPE
@ VKD3D_DATA_DOUBLE
@ VKD3D_DATA_UINT
@ VKD3D_DATA_FLOAT

Referenced by spirv_compiler_emit_alu_instruction().

◆ spirv_compiler_emit_bool_to_double()

static uint32_t spirv_compiler_emit_bool_to_double ( struct spirv_compiler *  compiler,
unsigned int  component_count,
uint32_t  val_id,
bool  signedness 
)
static

Definition at line 3909 of file spirv.c.

3911{
3912 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3913 uint32_t type_id, true_id, false_id;
3914
3915 true_id = spirv_compiler_get_constant_double_vector(compiler, signedness ? -1.0 : 1.0, component_count);
3918 return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id);
3919}
static uint32_t vkd3d_spirv_build_op_select(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t condition_id, uint32_t object0_id, uint32_t object1_id)
Definition: spirv.c:1397
static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler *compiler, double value, unsigned int component_count)
Definition: spirv.c:3146
@ VKD3D_SHADER_COMPONENT_DOUBLE

Referenced by spirv_compiler_emit_bool_cast().

◆ spirv_compiler_emit_bool_to_float()

static uint32_t spirv_compiler_emit_bool_to_float ( struct spirv_compiler *  compiler,
unsigned int  component_count,
uint32_t  val_id,
bool  signedness 
)
static

Definition at line 3897 of file spirv.c.

3899{
3900 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3901 uint32_t type_id, true_id, false_id;
3902
3903 true_id = spirv_compiler_get_constant_float_vector(compiler, signedness ? -1.0f : 1.0f, component_count);
3906 return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id);
3907}
static uint32_t spirv_compiler_get_constant_float_vector(struct spirv_compiler *compiler, float value, unsigned int component_count)
Definition: spirv.c:3138

Referenced by spirv_compiler_emit_bool_cast(), and spirv_compiler_emit_float_comparison_instruction().

◆ spirv_compiler_emit_bool_to_int()

static uint32_t spirv_compiler_emit_bool_to_int ( struct spirv_compiler *  compiler,
unsigned int  component_count,
uint32_t  val_id,
bool  signedness 
)
static

Definition at line 3872 of file spirv.c.

3874{
3875 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3876 uint32_t type_id, true_id, false_id;
3877
3878 true_id = spirv_compiler_get_constant_uint_vector(compiler, signedness ? 0xffffffff : 1, component_count);
3881 return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id);
3882}
static uint32_t spirv_compiler_get_constant_uint_vector(struct spirv_compiler *compiler, uint32_t value, unsigned int component_count)
Definition: spirv.c:3132

Referenced by spirv_compiler_emit_bool_cast(), spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_store_reg(), and sv_front_face_fixup().

◆ spirv_compiler_emit_bool_to_int64()

static uint32_t spirv_compiler_emit_bool_to_int64 ( struct spirv_compiler *  compiler,
unsigned int  component_count,
uint32_t  val_id,
bool  signedness 
)
static

Definition at line 3884 of file spirv.c.

3886{
3887 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3888 uint32_t type_id, true_id, false_id;
3889
3890 true_id = spirv_compiler_get_constant_uint64_vector(compiler, signedness ? UINT64_MAX : 1,
3894 return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id);
3895}
#define UINT64_MAX
Definition: stdint.h:86
static uint32_t spirv_compiler_get_constant_uint64_vector(struct spirv_compiler *compiler, uint64_t value, unsigned int component_count)
Definition: spirv.c:3154
@ VKD3D_SHADER_COMPONENT_UINT64

Referenced by spirv_compiler_emit_bool_cast().

◆ spirv_compiler_emit_branch()

static void spirv_compiler_emit_branch ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8289 of file spirv.c.

8291{
8292 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8293 const struct vkd3d_shader_src_param *src = instruction->src;
8294 uint32_t condition_id;
8295
8297 {
8298 if (instruction->src_count > 1)
8299 {
8300 /* Loop merge only. Must have a merge block and a continue block. */
8301 if (instruction->src_count == 3)
8302 spirv_compiler_emit_merge(compiler, src[1].reg.idx[0].offset, src[2].reg.idx[0].offset);
8303 else
8304 ERR("Invalid branch with %u sources.\n", instruction->src_count);
8305 }
8306 vkd3d_spirv_build_op_branch(builder, spirv_compiler_get_label_id(compiler, src[0].reg.idx[0].offset));
8307 return;
8308 }
8309
8310 if (!vkd3d_swizzle_is_scalar(src->swizzle, &src->reg))
8311 {
8312 WARN("Unexpected src swizzle %#x.\n", src->swizzle);
8313 spirv_compiler_warning(compiler, VKD3D_SHADER_WARNING_SPV_INVALID_SWIZZLE,
8314 "The swizzle for a branch condition value is not scalar.");
8315 }
8316
8317 condition_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
8318 if (src[0].reg.data_type != VKD3D_DATA_BOOL)
8319 condition_id = spirv_compiler_emit_int_to_bool(compiler,
8320 VKD3D_SHADER_CONDITIONAL_OP_NZ, src[0].reg.data_type, 1, condition_id);
8321 /* Emit the merge immediately before the branch instruction. */
8322 if (instruction->src_count >= 4)
8323 spirv_compiler_emit_merge(compiler, src[3].reg.idx[0].offset,
8324 (instruction->src_count > 4) ? src[4].reg.idx[0].offset : 0);
8325 else
8326 ERR("Invalid branch with %u sources.\n", instruction->src_count);
8327 vkd3d_spirv_build_op_branch_conditional(builder, condition_id,
8328 spirv_compiler_get_label_id(compiler, src[1].reg.idx[0].offset),
8329 spirv_compiler_get_label_id(compiler, src[2].reg.idx[0].offset));
8330}
static void spirv_compiler_emit_merge(struct spirv_compiler *compiler, uint32_t merge_block_id, uint32_t continue_block_id)
Definition: spirv.c:8269
static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, enum vkd3d_shader_conditional_op condition, enum vkd3d_data_type data_type, unsigned int component_count, uint32_t val_id)
Definition: spirv.c:3854
static void vkd3d_spirv_build_op_branch_conditional(struct vkd3d_spirv_builder *builder, uint32_t condition, uint32_t true_label, uint32_t false_label)
Definition: spirv.c:1447
static uint32_t spirv_compiler_get_label_id(struct spirv_compiler *compiler, unsigned int block_id)
Definition: spirv.c:2890
static bool vkd3d_swizzle_is_scalar(uint32_t swizzle, const struct vkd3d_shader_register *reg)
Definition: spirv.c:3769
static void vkd3d_spirv_build_op_branch(struct vkd3d_spirv_builder *builder, uint32_t label)
Definition: spirv.c:1441
@ VKD3D_SHADER_WARNING_SPV_INVALID_SWIZZLE
@ VKD3D_SHADER_CONDITIONAL_OP_NZ
static bool vsir_register_is_label(const struct vkd3d_shader_register *reg)

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_bufinfo()

static void spirv_compiler_emit_bufinfo ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9513 of file spirv.c.

9515{
9516 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9517 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9518 const struct vkd3d_shader_src_param *src = instruction->src;
9519 const struct vkd3d_symbol *resource_symbol;
9520 uint32_t type_id, val_id, stride_id;
9522 uint32_t constituents[2];
9523 unsigned int write_mask;
9524
9525 if (compiler->ssbo_uavs && src->reg.type == VKD3DSPR_UAV)
9526 {
9527 resource_symbol = spirv_compiler_find_resource(compiler, &src->reg);
9528
9530 val_id = vkd3d_spirv_build_op_array_length(builder, type_id, resource_symbol->id, 0);
9531 write_mask = VKD3DSP_WRITEMASK_0;
9532 }
9533 else
9534 {
9536
9538
9540 val_id = vkd3d_spirv_build_op_image_query_size(builder, type_id, image.image_id);
9541 write_mask = VKD3DSP_WRITEMASK_0;
9542 }
9543
9544 if (image.structure_stride)
9545 {
9546 stride_id = spirv_compiler_get_constant_uint(compiler, image.structure_stride);
9547 constituents[0] = vkd3d_spirv_build_op_udiv(builder, type_id, val_id, stride_id);
9548 constituents[1] = stride_id;
9551 type_id, constituents, ARRAY_SIZE(constituents));
9552 write_mask |= VKD3DSP_WRITEMASK_1;
9553 }
9554 else if (image.raw)
9555 {
9557 val_id, spirv_compiler_get_constant_uint(compiler, 2));
9558 }
9559
9560 val_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask,
9561 VKD3D_SHADER_COMPONENT_UINT, src->swizzle, dst->write_mask);
9562 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9563}
static uint32_t vkd3d_spirv_build_op_image_query_size(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
Definition: spirv.c:1733
static uint32_t vkd3d_spirv_build_op_array_length(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t struct_id, uint32_t member_id)
Definition: spirv.c:1719
static uint32_t vkd3d_spirv_build_op_shift_left_logical(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base, uint32_t shift)
Definition: spirv.c:1517
static uint32_t vkd3d_spirv_build_op_udiv(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1475
static uint32_t vkd3d_spirv_build_op_composite_construct(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
Definition: spirv.c:1330
static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler, uint32_t val_id, uint32_t val_write_mask, enum vkd3d_shader_component_type component_type, uint32_t swizzle, uint32_t write_mask)
Definition: spirv.c:3783
#define VKD3D_IMAGE_FLAG_NONE
Definition: spirv.c:8439
@ SpvCapabilityImageQuery
Definition: spirv.h:918
@ VKD3DSPR_UAV

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_builtin_variable()

static uint32_t spirv_compiler_emit_builtin_variable ( struct spirv_compiler *  compiler,
const struct vkd3d_spirv_builtin *  builtin,
SpvStorageClass  storage_class,
unsigned int  array_size 
)
static

Definition at line 5146 of file spirv.c.

5148{
5150}
static UINT array_size
Definition: msctf.cpp:39
static uint32_t spirv_compiler_emit_builtin_variable_v(struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, SpvStorageClass storage_class, const unsigned int *array_sizes, unsigned int size_count)
Definition: spirv.c:5120

Referenced by spirv_compiler_emit_input_register(), spirv_compiler_emit_output_register(), spirv_compiler_emit_point_size(), and spirv_compiler_emit_shader_signature_outputs().

◆ spirv_compiler_emit_builtin_variable_v()

static uint32_t spirv_compiler_emit_builtin_variable_v ( struct spirv_compiler *  compiler,
const struct vkd3d_spirv_builtin *  builtin,
SpvStorageClass  storage_class,
const unsigned int *  array_sizes,
unsigned int  size_count 
)
static

Definition at line 5120 of file spirv.c.

5123{
5124 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5125 unsigned int sizes[2];
5126 uint32_t id;
5127
5128 VKD3D_ASSERT(size_count <= ARRAY_SIZE(sizes));
5129 memcpy(sizes, array_sizes, size_count * sizeof(sizes[0]));
5130 array_sizes = sizes;
5131 sizes[0] = max(sizes[0], builtin->spirv_array_size);
5132
5134 builtin->component_type, builtin->component_count, array_sizes, size_count);
5135 vkd3d_spirv_add_iface_variable(builder, id);
5136 spirv_compiler_decorate_builtin(compiler, id, builtin->spirv_builtin);
5137
5139 && builtin->component_type != VKD3D_SHADER_COMPONENT_FLOAT
5140 && builtin->component_type != VKD3D_SHADER_COMPONENT_BOOL)
5142
5143 return id;
5144}
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const struct @662 sizes[]
static void spirv_compiler_decorate_builtin(struct spirv_compiler *compiler, uint32_t target_id, SpvBuiltIn builtin)
Definition: spirv.c:4636
static uint32_t spirv_compiler_emit_array_variable(struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, unsigned int component_count, const unsigned int *array_lengths, unsigned int length_count)
Definition: spirv.c:3286
static void vkd3d_spirv_add_iface_variable(struct vkd3d_spirv_builder *builder, uint32_t id)
Definition: spirv.c:464
@ SpvStorageClassInput
Definition: spirv.h:192
@ SpvDecorationFlat
Definition: spirv.h:459
@ VKD3D_SHADER_COMPONENT_BOOL

Referenced by spirv_compiler_emit_builtin_variable(), spirv_compiler_emit_input(), spirv_compiler_emit_output(), and spirv_compiler_emit_shader_phase_builtin_variable().

◆ spirv_compiler_emit_cbv_declaration()

static void spirv_compiler_emit_cbv_declaration ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range,
const struct vkd3d_shader_descriptor_info1 *  descriptor 
)
static

Definition at line 6268 of file spirv.c.

6270{
6271 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6272 uint32_t vec4_id, array_type_id, length_id, struct_id, var_id;
6274 unsigned int size_in_bytes = descriptor->buffer_size;
6275 struct vkd3d_push_constant_buffer_binding *push_cb;
6278 struct vkd3d_symbol reg_symbol;
6279 unsigned int size;
6280
6282 reg.idx[0].offset = descriptor->register_id;
6283 reg.idx[1].offset = range->first;
6284 reg.idx[2].offset = range->last;
6285
6286 size = align(size_in_bytes, VKD3D_VEC4_SIZE * sizeof(uint32_t));
6287 size /= VKD3D_VEC4_SIZE * sizeof(uint32_t);
6288
6289 if ((push_cb = spirv_compiler_find_push_constant_buffer(compiler, range)))
6290 {
6291 /* Push constant buffers are handled in
6292 * spirv_compiler_emit_push_constant_buffers().
6293 */
6294 push_cb->reg = reg;
6295 push_cb->size = size;
6296 if (size_in_bytes > push_cb->pc.size)
6297 {
6298 WARN("Constant buffer size %u exceeds push constant size %u.\n",
6299 size_in_bytes, push_cb->pc.size);
6300 }
6301 return;
6302 }
6303
6305 length_id = spirv_compiler_get_constant_uint(compiler, size);
6306 array_type_id = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id);
6307 vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 16);
6308
6309 struct_id = vkd3d_spirv_build_op_type_struct(builder, &array_type_id, 1);
6310 vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0);
6312 vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", size);
6313
6314 var_id = spirv_compiler_build_descriptor_variable(compiler, storage_class, struct_id,
6316
6317 vkd3d_symbol_make_register(&reg_symbol, &reg);
6318 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
6320 reg_symbol.descriptor_array = var_info.array_symbol;
6321 reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx;
6322 spirv_compiler_put_symbol(compiler, &reg_symbol);
6323}
void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, enum vkd3d_data_type data_type, unsigned int idx_count)
Definition: ir.c:164
#define uint32_t
Definition: nsiface.idl:61
static uint32_t spirv_compiler_build_descriptor_variable(struct spirv_compiler *compiler, SpvStorageClass storage_class, uint32_t type_id, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, const struct vkd3d_shader_descriptor_info1 *descriptor, bool is_uav_counter, struct vkd3d_descriptor_variable_info *var_info)
Definition: spirv.c:6193
static uint32_t vkd3d_spirv_build_op_type_array(struct vkd3d_spirv_builder *builder, uint32_t element_type, uint32_t length_id)
Definition: spirv.c:1067
static void vkd3d_symbol_set_register_info(struct vkd3d_symbol *symbol, uint32_t val_id, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, uint32_t write_mask)
Definition: spirv.c:2309
static struct vkd3d_push_constant_buffer_binding * spirv_compiler_find_push_constant_buffer(const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
Definition: spirv.c:2773
static void vkd3d_spirv_build_op_name(struct vkd3d_spirv_builder *builder, uint32_t id, const char *fmt,...)
Definition: spirv.c:941
static uint32_t vkd3d_spirv_build_op_type_struct(struct vkd3d_spirv_builder *builder, uint32_t *members, unsigned int member_count)
Definition: spirv.c:1092
static void vkd3d_symbol_make_register(struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
Definition: spirv.c:2275
static void vkd3d_spirv_build_op_member_decorate1(struct vkd3d_spirv_builder *builder, uint32_t structure_type_id, uint32_t member_idx, SpvDecoration decoration, uint32_t operand0)
Definition: spirv.c:1002
@ SpvDecorationArrayStride
Definition: spirv.h:452
@ SpvDecorationBlock
Definition: spirv.h:448
enum SpvStorageClass_ SpvStorageClass
struct vkd3d_shader_register reg
Definition: spirv.c:2382
struct vkd3d_shader_push_constant_buffer pc
Definition: spirv.c:2383
@ VKD3D_SHADER_RESOURCE_BUFFER
@ VKD3DSPR_CONSTBUFFER
static size_t align(size_t addr, size_t alignment)

Referenced by spirv_compiler_emit_descriptor_declarations().

◆ spirv_compiler_emit_combined_sampler_declarations()

static void spirv_compiler_emit_combined_sampler_declarations ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  resource,
const struct vkd3d_shader_register_range *  resource_range,
enum vkd3d_shader_resource_type  resource_type,
enum vkd3d_shader_component_type  sampled_type,
unsigned int  structure_stride,
bool  raw,
const struct vkd3d_spirv_resource_type *  resource_type_info 
)
static

Definition at line 6449 of file spirv.c.

6453{
6454 const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
6456 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6458 uint32_t image_type_id, type_id, ptr_type_id, var_id;
6459 enum vkd3d_shader_binding_flag resource_type_flag;
6460 struct vkd3d_symbol symbol;
6461 unsigned int i;
6462
6463 resource_type_flag = resource_type == VKD3D_SHADER_RESOURCE_BUFFER
6465
6466 for (i = 0; i < shader_interface->combined_sampler_count; ++i)
6467 {
6468 current = &shader_interface->combined_samplers[i];
6469
6470 if (current->resource_space != resource_range->space || current->resource_index != resource_range->first)
6471 continue;
6472
6473 if (!(current->flags & resource_type_flag))
6474 continue;
6475
6476 if (!spirv_compiler_check_shader_visibility(compiler, current->shader_visibility))
6477 continue;
6478
6479 if (current->binding.count != 1)
6480 {
6481 FIXME("Descriptor arrays are not supported.\n");
6482 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING,
6483 "Combined descriptor binding for resource %u, space %u, "
6484 "and sampler %u, space %u has unsupported ‘count’ %u.",
6485 resource_range->first, resource_range->space, current->sampler_index,
6486 current->sampler_space, current->binding.count);
6487 }
6488
6489 image_type_id = spirv_compiler_get_image_type_id(compiler, resource, resource_range,
6490 resource_type_info, sampled_type, structure_stride || raw);
6491 type_id = vkd3d_spirv_get_op_type_sampled_image(builder, image_type_id);
6492
6493 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
6494 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6495 ptr_type_id, storage_class, 0);
6496
6497 spirv_compiler_emit_descriptor_binding(compiler, var_id, &current->binding);
6498
6499 if (current->sampler_index == VKD3D_SHADER_DUMMY_SAMPLER_INDEX)
6500 vkd3d_spirv_build_op_name(builder, var_id, "t%u_%u_dummy_sampler", resource_range->space,
6501 resource_range->first);
6502 else
6503 vkd3d_spirv_build_op_name(builder, var_id, "t%u_%u_s%u_%u", resource_range->space, resource_range->first,
6504 current->sampler_space, current->sampler_index);
6505
6507 current->sampler_index == VKD3D_SHADER_DUMMY_SAMPLER_INDEX ? 0 : current->sampler_space,
6508 current->sampler_index);
6509 symbol.id = var_id;
6510 symbol.descriptor_array = NULL;
6511 symbol.info.resource.range = *resource_range;
6512 symbol.info.resource.sampled_type = sampled_type;
6513 symbol.info.resource.type_id = image_type_id;
6514 symbol.info.resource.resource_type_info = resource_type_info;
6515 symbol.info.resource.structure_stride = structure_stride;
6516 symbol.info.resource.raw = raw;
6517 symbol.info.resource.uav_counter_id = 0;
6518 symbol.info.resource.uav_counter_array = NULL;
6519 symbol.info.resource.uav_counter_base_idx = 0;
6520 spirv_compiler_put_symbol(compiler, &symbol);
6521 }
6522}
static const struct @335 resource_type_info[]
static void vkd3d_symbol_make_combined_sampler(struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *resource_reg, unsigned int sampler_space, unsigned int sampler_index)
Definition: spirv.c:2341
static uint32_t vkd3d_spirv_get_op_type_sampled_image(struct vkd3d_spirv_builder *builder, uint32_t image_type_id)
Definition: spirv.c:1135
static uint32_t spirv_compiler_get_image_type_id(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_shader_component_type data_type, bool raw_structured)
Definition: spirv.c:6419
static bool spirv_compiler_check_shader_visibility(const struct spirv_compiler *compiler, enum vkd3d_shader_visibility visibility)
Definition: spirv.c:2748
@ SpvStorageClassUniformConstant
Definition: spirv.h:191
unsigned int combined_sampler_count
const struct vkd3d_shader_combined_resource_sampler * combined_samplers
#define VKD3D_SHADER_DUMMY_SAMPLER_INDEX
Definition: vkd3d_shader.h:964
vkd3d_shader_binding_flag
Definition: vkd3d_shader.h:467
@ VKD3D_SHADER_BINDING_FLAG_IMAGE
Definition: vkd3d_shader.h:469
@ VKD3D_SHADER_BINDING_FLAG_BUFFER
Definition: vkd3d_shader.h:468
@ VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING

Referenced by spirv_compiler_emit_resource_declaration().

◆ spirv_compiler_emit_comparison_instruction()

static void spirv_compiler_emit_comparison_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8006 of file spirv.c.

8008{
8009 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8010 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8011 const struct vkd3d_shader_src_param *src = instruction->src;
8012 uint32_t src0_id, src1_id, type_id, result_id;
8013 unsigned int component_count;
8014 SpvOp op;
8015
8016 switch (instruction->opcode)
8017 {
8018 case VKD3DSIH_DEQO:
8019 case VKD3DSIH_EQO: op = SpvOpFOrdEqual; break;
8020 case VKD3DSIH_EQU: op = SpvOpFUnordEqual; break;
8021 case VKD3DSIH_DGEO:
8024 case VKD3DSIH_IEQ: op = SpvOpIEqual; break;
8025 case VKD3DSIH_IGE: op = SpvOpSGreaterThanEqual; break;
8026 case VKD3DSIH_ILT: op = SpvOpSLessThan; break;
8027 case VKD3DSIH_INE: op = SpvOpINotEqual; break;
8028 case VKD3DSIH_DLT:
8029 case VKD3DSIH_LTO: op = SpvOpFOrdLessThan; break;
8030 case VKD3DSIH_LTU: op = SpvOpFUnordLessThan; break;
8031 case VKD3DSIH_NEO: op = SpvOpFOrdNotEqual; break;
8032 case VKD3DSIH_DNE:
8033 case VKD3DSIH_NEU: op = SpvOpFUnordNotEqual; break;
8034 case VKD3DSIH_UGE: op = SpvOpUGreaterThanEqual; break;
8035 case VKD3DSIH_ULT: op = SpvOpULessThan; break;
8036 default:
8037 ERR("Unexpected instruction %#x.\n", instruction->opcode);
8038 return;
8039 }
8040
8042
8043 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
8044 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
8045
8047 result_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
8048 op, type_id, src0_id, src1_id);
8049
8050 if (dst->reg.data_type != VKD3D_DATA_BOOL)
8051 result_id = spirv_compiler_emit_bool_to_int(compiler, component_count, result_id, true);
8052 spirv_compiler_emit_store_reg(compiler, &dst->reg, dst->write_mask, result_id);
8053}
static uint32_t vkd3d_spirv_build_op_tr2(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:813
static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4487
@ SpvOpFOrdLessThan
Definition: spirv.h:1367
@ SpvOpFUnordNotEqual
Definition: spirv.h:1366
@ SpvOpFOrdGreaterThanEqual
Definition: spirv.h:1373
@ SpvOpFUnordEqual
Definition: spirv.h:1364
@ SpvOpFUnordGreaterThanEqual
Definition: spirv.h:1374
@ SpvOpFOrdEqual
Definition: spirv.h:1363
@ SpvOpULessThan
Definition: spirv.h:1359
@ SpvOpSGreaterThanEqual
Definition: spirv.h:1358
@ SpvOpIEqual
Definition: spirv.h:1353
@ SpvOpSLessThan
Definition: spirv.h:1360
@ SpvOpFOrdNotEqual
Definition: spirv.h:1365
@ SpvOpFUnordLessThan
Definition: spirv.h:1368
@ SpvOpUGreaterThanEqual
Definition: spirv.h:1357
@ SpvOpINotEqual
Definition: spirv.h:1354
@ VKD3DSIH_GEU
@ VKD3DSIH_NEO
@ VKD3DSIH_UGE
@ VKD3DSIH_IEQ
@ VKD3DSIH_DNE
@ VKD3DSIH_NEU
@ VKD3DSIH_LTU
@ VKD3DSIH_DEQO
@ VKD3DSIH_EQO
@ VKD3DSIH_LTO
@ VKD3DSIH_INE
@ VKD3DSIH_DLT
@ VKD3DSIH_ULT
@ VKD3DSIH_DGEO
@ VKD3DSIH_ILT
@ VKD3DSIH_EQU
@ VKD3DSIH_GEO
@ VKD3DSIH_IGE

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_conditional_branch()

static uint32_t spirv_compiler_emit_conditional_branch ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction,
uint32_t  target_block_id 
)
static

Definition at line 8105 of file spirv.c.

8107{
8108 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8109 const struct vkd3d_shader_src_param *src = instruction->src;
8110 uint32_t condition_id, merge_block_id;
8111
8112 condition_id = spirv_compiler_emit_load_src(compiler, src, VKD3DSP_WRITEMASK_0);
8113 condition_id = spirv_compiler_emit_int_to_bool(compiler, instruction->flags, src->reg.data_type, 1, condition_id);
8114
8115 merge_block_id = vkd3d_spirv_alloc_id(builder);
8116
8118 vkd3d_spirv_build_op_branch_conditional(builder, condition_id, target_block_id, merge_block_id);
8119
8120 return merge_block_id;
8121}
static void vkd3d_spirv_build_op_selection_merge(struct vkd3d_spirv_builder *builder, uint32_t merge_block, uint32_t selection_control)
Definition: spirv.c:1434
static uint32_t vkd3d_spirv_alloc_id(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:418
@ SpvSelectionControlMaskNone
Definition: spirv.h:692

Referenced by spirv_compiler_emit_retc().

◆ spirv_compiler_emit_constant_array()

static uint32_t spirv_compiler_emit_constant_array ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_immediate_constant_buffer *  icb,
uint32_t *  type_id_out 
)
static

Definition at line 4114 of file spirv.c.

4116{
4117 uint32_t *elements, elem_type_id, length_id, type_id, const_id;
4118 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4120 unsigned int i, element_count, component_count;
4121
4123
4127 length_id = spirv_compiler_get_constant_uint(compiler, element_count);
4128 type_id = vkd3d_spirv_get_op_type_array(builder, elem_type_id, length_id);
4129
4130 if (type_id_out)
4131 *type_id_out = type_id;
4132
4133 if (icb->is_null)
4134 {
4135 /* All values are null. Workgroup memory initialisers require OpConstantNull. */
4137 }
4138
4139 if (!(elements = vkd3d_calloc(element_count, sizeof(*elements))))
4140 {
4141 ERR("Failed to allocate %u elements.", element_count);
4142 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY,
4143 "Failed to allocate %u constant array elements.", element_count);
4144 return 0;
4145 }
4146
4147 switch (icb->data_type)
4148 {
4149 case VKD3D_DATA_HALF:
4150 case VKD3D_DATA_UINT16:
4151 /* Scalar only. */
4152 for (i = 0; i < element_count; ++i)
4153 elements[i] = vkd3d_spirv_get_op_constant(builder, elem_type_id,
4154 convert_raw_constant32(icb->data_type, icb->data[i]));
4155 break;
4156 case VKD3D_DATA_FLOAT:
4157 case VKD3D_DATA_INT:
4158 case VKD3D_DATA_UINT:
4159 for (i = 0; i < element_count; ++i)
4161 &icb->data[component_count * i]);
4162 break;
4163 case VKD3D_DATA_DOUBLE:
4164 case VKD3D_DATA_UINT64:
4165 {
4166 uint64_t *data = (uint64_t *)icb->data;
4167 for (i = 0; i < element_count; ++i)
4169 &data[component_count * i]);
4170 break;
4171 }
4172 default:
4173 FIXME("Unhandled data type %u.\n", icb->data_type);
4174 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_TYPE,
4175 "Immediate constant buffer data type %u is unhandled.", icb->data_type);
4176 break;
4177 }
4178
4179 const_id = vkd3d_spirv_build_op_constant_composite(builder, type_id, elements, element_count);
4180 vkd3d_free(elements);
4181 return const_id;
4182}
UINT64 uint64_t
Definition: types.h:77
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static ULONG ** element_count
Definition: exception.c:124
for(i=0;i< sizeof(testsuite)/sizeof(testsuite[0]);++i) ok(call_test(testsuite[i].func)
static uint32_t convert_raw_constant32(enum vkd3d_data_type data_type, unsigned int uint_value)
Definition: spirv.c:3964
static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint32_t *values)
Definition: spirv.c:3043
static uint32_t vkd3d_spirv_build_op_constant_composite(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
Definition: spirv.c:1224
static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint64_t *values)
Definition: spirv.c:3084
static uint32_t vkd3d_spirv_get_type_id_for_data_type(struct vkd3d_spirv_builder *builder, enum vkd3d_data_type data_type, unsigned int component_count)
Definition: spirv.c:1965
static uint32_t vkd3d_spirv_get_op_constant_null(struct vkd3d_spirv_builder *builder, uint32_t result_type)
Definition: spirv.c:1219
static uint32_t vkd3d_spirv_get_op_constant(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
Definition: spirv.c:1192
@ VKD3D_DATA_INT

Referenced by spirv_compiler_emit_dcl_immediate_constant_buffer(), and spirv_compiler_emit_dcl_indexable_temp().

◆ spirv_compiler_emit_construct_vector()

static uint32_t spirv_compiler_emit_construct_vector ( struct spirv_compiler *  compiler,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count,
uint32_t  val_id,
unsigned int  val_component_idx,
unsigned int  val_component_count 
)
static

Definition at line 3491 of file spirv.c.

3494{
3495 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3497 uint32_t type_id, result_id;
3498 unsigned int i;
3499
3500 VKD3D_ASSERT(val_component_idx < val_component_count);
3501
3503 if (val_component_count == 1)
3504 {
3505 for (i = 0; i < component_count; ++i)
3506 components[i] = val_id;
3507 result_id = vkd3d_spirv_build_op_composite_construct(builder,
3509 }
3510 else
3511 {
3512 for (i = 0; i < component_count; ++i)
3513 components[i] = val_component_idx;
3514 result_id = vkd3d_spirv_build_op_vector_shuffle(builder,
3515 type_id, val_id, val_id, components, component_count);
3516 }
3517 return result_id;
3518}
GLenum GLenum GLuint components
Definition: glext.h:9620
static uint32_t vkd3d_spirv_build_op_vector_shuffle(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t vector1_id, uint32_t vector2_id, const uint32_t *components, uint32_t component_count)
Definition: spirv.c:1322

Referenced by spirv_compiler_emit_dot(), and spirv_compiler_emit_store_uav_raw_structured().

◆ spirv_compiler_emit_cut_stream()

static void spirv_compiler_emit_cut_stream ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9917 of file spirv.c.

9919{
9920 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9921 unsigned int stream_idx;
9922
9924 stream_idx = instruction->src[0].reg.idx[0].offset;
9925 else
9926 stream_idx = 0;
9927
9928 if (stream_idx)
9929 {
9930 FIXME("Multiple streams are not supported yet.\n");
9931 return;
9932 }
9933
9935}
static void vkd3d_spirv_build_op_end_primitive(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1766
@ VKD3DSIH_CUT_STREAM

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_gs_instances()

static void spirv_compiler_emit_dcl_gs_instances ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6819 of file spirv.c.

6821{
6822 compiler->spirv_builder.invocation_count = instruction->declaration.count;
6823}

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_immediate_constant_buffer()

static void spirv_compiler_emit_dcl_immediate_constant_buffer ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6325 of file spirv.c.

6327{
6328 const struct vkd3d_shader_immediate_constant_buffer *icb = instruction->declaration.icb;
6329 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6330 uint32_t type_id, const_id, ptr_type_id, icb_id;
6332 struct vkd3d_symbol reg_symbol;
6333
6334 const_id = spirv_compiler_emit_constant_array(compiler, icb, &type_id);
6336 icb_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6337 ptr_type_id, SpvStorageClassPrivate, const_id);
6338 vkd3d_spirv_build_op_name(builder, icb_id, "icb");
6339
6340 /* Set an index count of 2 so vkd3d_symbol_make_register() uses idx[0] as a buffer id. */
6342 reg.idx[0].offset = icb->register_idx;
6343 vkd3d_symbol_make_register(&reg_symbol, &reg);
6347 spirv_compiler_put_symbol(compiler, &reg_symbol);
6348}
static uint32_t spirv_compiler_emit_constant_array(struct spirv_compiler *compiler, const struct vkd3d_shader_immediate_constant_buffer *icb, uint32_t *type_id_out)
Definition: spirv.c:4114
@ SpvStorageClassPrivate
Definition: spirv.h:197
@ VKD3DSPR_IMMCONSTBUFFER
static unsigned int vkd3d_write_mask_from_component_count(unsigned int component_count)

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_indexable_temp()

static void spirv_compiler_emit_dcl_indexable_temp ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6024 of file spirv.c.

6026{
6027 const struct vkd3d_shader_indexable_temp *temp = &instruction->declaration.indexable_temp;
6028 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6029 uint32_t id, type_id, length_id, ptr_type_id, init_id = 0;
6032 struct vkd3d_symbol reg_symbol;
6034 size_t function_location;
6035
6036 /* Indexable temps may be used by more than one function in hull shaders, and
6037 * declarations generally should not occur within VSIR code blocks unless function
6038 * scope is specified, e.g. DXIL alloca. */
6040
6042 reg.idx[0].offset = temp->register_idx;
6043
6044 /* Alignment is supported only in the Kernel execution model and is an optimisation only. */
6045 if (temp->alignment)
6046 TRACE("Ignoring alignment %u.\n", temp->alignment);
6047
6048 function_location = spirv_compiler_get_current_function_location(compiler);
6049 vkd3d_spirv_begin_function_stream_insertion(builder, function_location);
6050
6052 type_id = vkd3d_spirv_get_type_id(builder, component_type, temp->component_count);
6053 length_id = spirv_compiler_get_constant_uint(compiler, temp->register_size);
6054 type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
6055 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
6056 if (temp->initialiser)
6057 init_id = spirv_compiler_emit_constant_array(compiler, temp->initialiser, NULL);
6058 id = vkd3d_spirv_build_op_variable(builder, &builder->function_stream, ptr_type_id, storage_class, init_id);
6059
6061
6063
6064 vkd3d_symbol_make_register(&reg_symbol, &reg);
6067 spirv_compiler_put_symbol(compiler, &reg_symbol);
6068}
static calc_node_t temp
Definition: rpn_ieee.c:38
#define TRACE(s)
Definition: solgame.cpp:4
static void vkd3d_spirv_end_function_stream_insertion(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:869
static size_t spirv_compiler_get_current_function_location(struct spirv_compiler *compiler)
Definition: spirv.c:5914
static void vkd3d_spirv_begin_function_stream_insertion(struct vkd3d_spirv_builder *builder, size_t location)
Definition: spirv.c:856
@ SpvStorageClassFunction
Definition: spirv.h:198
@ VKD3DSPR_IDXTEMP

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_input()

static void spirv_compiler_emit_dcl_input ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6702 of file spirv.c.

6704{
6705 const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst;
6706
6707 /* INPUT and PATCHCONST are handled in spirv_compiler_emit_io_declarations().
6708 * OUTPOINTID is handled in spirv_compiler_emit_hull_shader_builtins(). */
6709 if (dst->reg.type != VKD3DSPR_INPUT && dst->reg.type != VKD3DSPR_PATCHCONST
6710 && dst->reg.type != VKD3DSPR_OUTPOINTID)
6712}
static void spirv_compiler_emit_input_register(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
Definition: spirv.c:5325
@ VKD3DSPR_OUTPOINTID
@ VKD3DSPR_PATCHCONST
@ VKD3DSPR_INPUT

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_input_primitive()

static void spirv_compiler_emit_dcl_input_primitive ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6739 of file spirv.c.

6741{
6742 enum vkd3d_primitive_type primitive_type = instruction->declaration.primitive_type.type;
6744
6745 switch (primitive_type)
6746 {
6747 case VKD3D_PT_POINTLIST:
6749 break;
6750 case VKD3D_PT_LINELIST:
6752 break;
6755 break;
6758 break;
6761 break;
6762 default:
6763 FIXME("Unhandled primitive type %#x.\n", primitive_type);
6764 return;
6765 }
6766
6768}
GLenum mode
Definition: glext.h:6217
@ SpvExecutionModeInputPoints
Definition: spirv.h:138
@ SpvExecutionModeTriangles
Definition: spirv.h:141
@ SpvExecutionModeInputTrianglesAdjacency
Definition: spirv.h:142
@ SpvExecutionModeInputLinesAdjacency
Definition: spirv.h:140
@ SpvExecutionModeInputLines
Definition: spirv.h:139
enum SpvExecutionMode_ SpvExecutionMode
vkd3d_primitive_type
@ VKD3D_PT_TRIANGLELIST
@ VKD3D_PT_TRIANGLELIST_ADJ
@ VKD3D_PT_LINELIST_ADJ
@ VKD3D_PT_POINTLIST
@ VKD3D_PT_LINELIST

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_output()

static void spirv_compiler_emit_dcl_output ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6714 of file spirv.c.

6716{
6717 const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst;
6718
6719 if (dst->reg.type != VKD3DSPR_OUTPUT && dst->reg.type != VKD3DSPR_PATCHCONST)
6721}
static void spirv_compiler_emit_output_register(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst)
Definition: spirv.c:5461
@ VKD3DSPR_OUTPUT

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_output_topology()

static void spirv_compiler_emit_dcl_output_topology ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6793 of file spirv.c.

6795{
6796 enum vkd3d_primitive_type primitive_type = instruction->declaration.primitive_type.type;
6798
6799 switch (primitive_type)
6800 {
6801 case VKD3D_PT_POINTLIST:
6803 compiler->emit_point_size = true;
6804 break;
6805 case VKD3D_PT_LINESTRIP:
6807 break;
6810 break;
6811 default:
6812 ERR("Unexpected primitive type %#x.\n", primitive_type);
6813 return;
6814 }
6815
6817}
@ SpvExecutionModeOutputPoints
Definition: spirv.h:146
@ SpvExecutionModeOutputLineStrip
Definition: spirv.h:147
@ SpvExecutionModeOutputTriangleStrip
Definition: spirv.h:148
@ VKD3D_PT_TRIANGLESTRIP
@ VKD3D_PT_LINESTRIP

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_stream()

static void spirv_compiler_emit_dcl_stream ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6723 of file spirv.c.

6725{
6726 unsigned int stream_idx = instruction->src[0].reg.idx[0].offset;
6727
6728 if (stream_idx)
6729 FIXME("Multiple streams are not supported yet.\n");
6730}

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_tessellator_domain()

static void spirv_compiler_emit_dcl_tessellator_domain ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6825 of file spirv.c.

6827{
6828 enum vkd3d_tessellator_domain domain = instruction->declaration.tessellator_domain;
6830
6832 return;
6833
6834 switch (domain)
6835 {
6838 break;
6841 break;
6844 break;
6845 default:
6846 FIXME("Invalid tessellator domain %#x.\n", domain);
6847 return;
6848 }
6849
6851}
static bool spirv_compiler_is_opengl_target(const struct spirv_compiler *compiler)
Definition: spirv.c:2723
@ SpvExecutionModeIsolines
Definition: spirv.h:144
@ SpvExecutionModeQuads
Definition: spirv.h:143
Definition: cookie.c:42
vkd3d_tessellator_domain
@ VKD3D_TESSELLATOR_DOMAIN_TRIANGLE
@ VKD3D_TESSELLATOR_DOMAIN_LINE
@ VKD3D_TESSELLATOR_DOMAIN_QUAD

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_tgsm_raw()

static void spirv_compiler_emit_dcl_tgsm_raw ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6685 of file spirv.c.

6687{
6688 const struct vkd3d_shader_tgsm_raw *tgsm_raw = &instruction->declaration.tgsm_raw;
6689 spirv_compiler_emit_workgroup_memory(compiler, &tgsm_raw->reg.reg, tgsm_raw->alignment,
6690 tgsm_raw->byte_count / 4, 0, tgsm_raw->zero_init);
6691}
static void spirv_compiler_emit_workgroup_memory(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, unsigned int alignment, unsigned int size, unsigned int structure_stride, bool zero_init)
Definition: spirv.c:6654
struct vkd3d_shader_dst_param reg

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_dcl_tgsm_structured()

static void spirv_compiler_emit_dcl_tgsm_structured ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6693 of file spirv.c.

6695{
6696 const struct vkd3d_shader_tgsm_structured *tgsm_structured = &instruction->declaration.tgsm_structured;
6697 unsigned int stride = tgsm_structured->byte_stride / 4;
6698 spirv_compiler_emit_workgroup_memory(compiler, &tgsm_structured->reg.reg, tgsm_structured->alignment,
6699 tgsm_structured->structure_count * stride, stride, tgsm_structured->zero_init);
6700}
struct vkd3d_shader_dst_param reg

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_default_control_point_phase()

static void spirv_compiler_emit_default_control_point_phase ( struct spirv_compiler *  compiler)
static

Definition at line 7003 of file spirv.c.

7004{
7005 const struct shader_signature *output_signature = &compiler->output_signature;
7006 const struct shader_signature *input_signature = &compiler->input_signature;
7007 uint32_t type_id, output_ptr_type_id, input_id, dst_id, invocation_id;
7008 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7010 struct vkd3d_shader_src_param invocation;
7011 struct vkd3d_shader_register input_reg;
7012 unsigned int component_count;
7013 unsigned int i;
7014
7017 invocation_id = spirv_compiler_emit_load_invocation_id(compiler);
7018
7019 memset(&invocation, 0, sizeof(invocation));
7021 invocation.swizzle = VKD3D_SHADER_NO_SWIZZLE;
7022
7024 input_reg.idx[0].offset = 0;
7025 input_reg.idx[0].rel_addr = &invocation;
7026 input_reg.idx[1].offset = 0;
7027 input_id = spirv_compiler_get_register_id(compiler, &input_reg);
7028
7029 VKD3D_ASSERT(input_signature->element_count == output_signature->element_count);
7030 for (i = 0; i < output_signature->element_count; ++i)
7031 {
7032 const struct signature_element *output = &output_signature->elements[i];
7033 const struct signature_element *input = &input_signature->elements[i];
7034 struct vkd3d_shader_register_info output_reg_info;
7035 struct vkd3d_shader_register output_reg;
7036
7037 VKD3D_ASSERT(input->mask == output->mask);
7038 VKD3D_ASSERT(input->component_type == output->component_type);
7039
7040 input_reg.idx[1].offset = i;
7041 input_id = spirv_compiler_get_register_id(compiler, &input_reg);
7042
7044 output_reg.idx[0].offset = i;
7045 spirv_compiler_get_register_info(compiler, &output_reg, &output_reg_info);
7046
7050 output_ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id);
7051
7052 dst_id = vkd3d_spirv_build_op_access_chain1(builder, output_ptr_type_id, output_reg_info.id, invocation_id);
7053
7055 }
7056
7058}
GLenum GLenum GLenum input
Definition: glext.h:9031
static void spirv_compiler_initialise_block(struct spirv_compiler *compiler)
Definition: spirv.c:6977
static void vkd3d_spirv_build_op_return(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1414
static void vkd3d_spirv_build_op_copy_memory(struct vkd3d_spirv_builder *builder, uint32_t target_id, uint32_t source_id, uint32_t memory_access)
Definition: spirv.c:1386
static uint32_t spirv_compiler_emit_load_invocation_id(struct spirv_compiler *compiler)
Definition: spirv.c:5014
static uint32_t vkd3d_spirv_build_op_label(struct vkd3d_spirv_builder *builder, uint32_t label_id)
Definition: spirv.c:1419
static uint32_t spirv_compiler_get_register_id(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg)
Definition: spirv.c:3748
@ SpvStorageClassOutput
Definition: spirv.h:194
@ SpvMemoryAccessMaskNone
Definition: spirv.h:815
struct signature_element * elements
enum vkd3d_shader_component_type component_type

Referenced by spirv_compiler_leave_shader_phase().

◆ spirv_compiler_emit_dereference_register()

static void spirv_compiler_emit_dereference_register ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
struct vkd3d_shader_register_info *  register_info 
)
static

Definition at line 3686 of file spirv.c.

3688{
3689 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3690 unsigned int component_count, index_count = 0;
3691 uint32_t type_id, ptr_type_id;
3692 uint32_t indexes[3];
3693
3694 if (reg->type == VKD3DSPR_CONSTBUFFER)
3695 {
3696 VKD3D_ASSERT(!reg->idx[0].rel_addr);
3697 if (register_info->descriptor_array)
3698 indexes[index_count++] = spirv_compiler_get_descriptor_index(compiler, reg,
3699 register_info->descriptor_array, register_info->binding_base_idx, VKD3D_SHADER_RESOURCE_BUFFER);
3700 indexes[index_count++] = spirv_compiler_get_constant_uint(compiler, register_info->member_idx);
3701 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[2]);
3702 }
3703 else if (reg->type == VKD3DSPR_IMMCONSTBUFFER)
3704 {
3705 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[reg->idx_count - 1]);
3706 }
3707 else if (reg->type == VKD3DSPR_IDXTEMP)
3708 {
3709 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[1]);
3710 }
3711 else if (register_info->is_aggregate)
3712 {
3713 /* Indices for these are swapped compared to the generated SPIR-V. */
3714 if (reg->idx_count > 2)
3715 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[1]);
3716 if (reg->idx_count > 1)
3717 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[0]);
3718 if (!index_count)
3719 /* A register sysval which is an array in SPIR-V, e.g. SAMPLEMASK. */
3720 indexes[index_count++] = spirv_compiler_get_constant_uint(compiler, 0);
3721 }
3722 else
3723 {
3724 if (reg->idx_count && reg->idx[reg->idx_count - 1].rel_addr)
3725 FIXME("Relative addressing not implemented.\n");
3726
3727 /* Handle arrayed registers, e.g. v[3][0]. */
3728 if (reg->idx_count > 1 && !vsir_register_is_descriptor(reg))
3729 indexes[index_count++] = spirv_compiler_emit_register_addressing(compiler, &reg->idx[0]);
3730 }
3731
3732 /* Alignment is supported only in the Kernel execution model and is an optimisation only. */
3733 if (reg->alignment)
3734 TRACE("Ignoring alignment %u.\n", reg->alignment);
3735
3736 if (index_count)
3737 {
3740 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, register_info->storage_class, type_id);
3741 register_info->id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id,
3742 register_info->id, indexes, index_count);
3743 if (reg->non_uniform)
3744 spirv_compiler_decorate_nonuniform(compiler, register_info->id);
3745 }
3746}
static uint32_t spirv_compiler_get_descriptor_index(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_symbol *array_symbol, unsigned int binding_base_idx, enum vkd3d_shader_resource_type resource_type)
Definition: spirv.c:3638
static void spirv_compiler_decorate_nonuniform(struct spirv_compiler *compiler, uint32_t expression_id)
Definition: spirv.c:3019
static uint32_t spirv_compiler_emit_register_addressing(struct spirv_compiler *compiler, const struct vkd3d_shader_register_index *reg_index)
Definition: spirv.c:3523
const struct vkd3d_symbol * descriptor_array
Definition: spirv.c:3545
unsigned int write_mask
Definition: spirv.c:3548
unsigned int binding_base_idx
Definition: spirv.c:3551
enum vkd3d_shader_component_type component_type
Definition: spirv.c:3547
SpvStorageClass storage_class
Definition: spirv.c:3546
static bool vsir_register_is_descriptor(const struct vkd3d_shader_register *reg)

Referenced by spirv_compiler_emit_load_reg(), spirv_compiler_emit_store_reg(), and spirv_compiler_get_register_id().

◆ spirv_compiler_emit_deriv_instruction()

static void spirv_compiler_emit_deriv_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8373 of file spirv.c.

8375{
8376 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8377 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8378 const struct vkd3d_shader_src_param *src = instruction->src;
8379 const struct instruction_info *info;
8380 uint32_t type_id, src_id, val_id;
8381 unsigned int i;
8382
8383 static const struct instruction_info
8384 {
8385 enum vkd3d_shader_opcode opcode;
8386 SpvOp op;
8387 bool needs_derivative_control;
8388 }
8389 deriv_instructions[] =
8390 {
8397 };
8398
8399 info = NULL;
8400 for (i = 0; i < ARRAY_SIZE(deriv_instructions); ++i)
8401 {
8402 if (deriv_instructions[i].opcode == instruction->opcode)
8403 {
8404 info = &deriv_instructions[i];
8405 break;
8406 }
8407 }
8408 if (!info)
8409 {
8410 ERR("Unexpected instruction %#x.\n", instruction->opcode);
8411 return;
8412 }
8413
8414 if (info->needs_derivative_control)
8416
8417 VKD3D_ASSERT(instruction->dst_count == 1);
8418 VKD3D_ASSERT(instruction->src_count == 1);
8419
8421 src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
8422 val_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, info->op, type_id, src_id);
8423 spirv_compiler_emit_store_dst(compiler, dst, val_id);
8424}
static uint32_t vkd3d_spirv_build_op_tr1(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0)
Definition: spirv.c:806
@ SpvCapabilityDerivativeControl
Definition: spirv.h:919
@ SpvOpDPdyCoarse
Definition: spirv.h:1394
@ SpvOpDPdx
Definition: spirv.h:1387
@ SpvOpDPdxFine
Definition: spirv.h:1390
@ SpvOpDPdyFine
Definition: spirv.h:1391
@ SpvOpDPdy
Definition: spirv.h:1388
@ SpvOpDPdxCoarse
Definition: spirv.h:1393
vkd3d_shader_opcode
@ VKD3DSIH_DSX_COARSE
@ VKD3DSIH_DSY_FINE
@ VKD3DSIH_DSY_COARSE
@ VKD3DSIH_DSY
@ VKD3DSIH_DSX_FINE
@ VKD3DSIH_DSX

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_descriptor_binding()

static void spirv_compiler_emit_descriptor_binding ( struct spirv_compiler *  compiler,
uint32_t  variable_id,
const struct vkd3d_shader_descriptor_binding *  binding 
)
static

Definition at line 3010 of file spirv.c.

3012{
3013 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3014
3016 vkd3d_spirv_build_op_decorate1(builder, variable_id, SpvDecorationBinding, binding->binding);
3017}
@ SpvDecorationBinding
Definition: spirv.h:478
@ SpvDecorationDescriptorSet
Definition: spirv.h:479

Referenced by spirv_compiler_build_descriptor_variable(), and spirv_compiler_emit_combined_sampler_declarations().

◆ spirv_compiler_emit_descriptor_declarations()

static void spirv_compiler_emit_descriptor_declarations ( struct spirv_compiler *  compiler)
static

Definition at line 10628 of file spirv.c.

10629{
10630 unsigned int i;
10631
10632 for (i = 0; i < compiler->scan_descriptor_info->descriptor_count; ++i)
10633 {
10634 const struct vkd3d_shader_descriptor_info1 *descriptor = &compiler->scan_descriptor_info->descriptors[i];
10636
10637 range.first = descriptor->register_index;
10638 if (descriptor->count == ~0u)
10639 range.last = ~0u;
10640 else
10641 range.last = descriptor->register_index + descriptor->count - 1;
10642 range.space = descriptor->register_space;
10643
10644 switch (descriptor->type)
10645 {
10648 break;
10649
10652 break;
10653
10657 break;
10658
10659 default:
10661 }
10662 }
10663}
static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
Definition: spirv.c:6524
static void spirv_compiler_emit_sampler_declaration(struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
Definition: spirv.c:6350
static void spirv_compiler_emit_cbv_declaration(struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_descriptor_info1 *descriptor)
Definition: spirv.c:6268
@ VKD3D_SHADER_DESCRIPTOR_TYPE_CBV
Definition: vkd3d_shader.h:435
@ VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER
Definition: vkd3d_shader.h:440
@ VKD3D_SHADER_DESCRIPTOR_TYPE_SRV
Definition: vkd3d_shader.h:425

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_discard()

static void spirv_compiler_emit_discard ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8220 of file spirv.c.

8222{
8223 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8224 const struct vkd3d_shader_src_param *src = instruction->src;
8225 uint32_t condition_id, void_id;
8226
8227 /* discard is not a block terminator in VSIR, and emitting it as such in SPIR-V would cause
8228 * a mismatch between the VSIR structure and the SPIR-V one, which would cause problems if
8229 * structurisation is necessary. Therefore we emit it as a function call. */
8230 condition_id = spirv_compiler_emit_load_src(compiler, src, VKD3DSP_WRITEMASK_0);
8231 if (src->reg.data_type != VKD3D_DATA_BOOL)
8232 condition_id = spirv_compiler_emit_int_to_bool(compiler,
8233 instruction->flags, src->reg.data_type, 1, condition_id);
8235 condition_id = vkd3d_spirv_build_op_logical_not(builder, vkd3d_spirv_get_op_type_bool(builder), condition_id);
8236 void_id = vkd3d_spirv_get_op_type_void(builder);
8238 &condition_id, 1);
8239}
static uint32_t vkd3d_spirv_build_op_logical_not(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1578
static uint32_t spirv_compiler_get_discard_function_id(struct spirv_compiler *compiler)
Definition: spirv.c:8169
static uint32_t vkd3d_spirv_get_op_type_void(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1013
static uint32_t vkd3d_spirv_get_op_type_bool(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1023
static uint32_t vkd3d_spirv_build_op_function_call(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t function_id, const uint32_t *arguments, unsigned int argument_count)
Definition: spirv.c:1279
@ VKD3D_SHADER_CONDITIONAL_OP_Z

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_discard_function()

static void spirv_compiler_emit_discard_function ( struct spirv_compiler *  compiler)
static

Definition at line 8179 of file spirv.c.

8180{
8181 uint32_t void_id, bool_id, function_type_id, condition_id, target_block_id, merge_block_id;
8182 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8183
8184 vkd3d_spirv_build_op_name(builder, compiler->discard_function_id, "discard");
8185
8186 void_id = vkd3d_spirv_get_op_type_void(builder);
8187 bool_id = vkd3d_spirv_get_op_type_bool(builder);
8188 function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, &bool_id, 1);
8189
8190 vkd3d_spirv_build_op_function(builder, void_id, compiler->discard_function_id,
8191 SpvFunctionControlMaskNone, function_type_id);
8192 condition_id = vkd3d_spirv_build_op_function_parameter(builder, bool_id);
8193
8195
8196 target_block_id = vkd3d_spirv_alloc_id(builder);
8197 merge_block_id = vkd3d_spirv_alloc_id(builder);
8199 vkd3d_spirv_build_op_branch_conditional(builder, condition_id, target_block_id, merge_block_id);
8200
8201 vkd3d_spirv_build_op_label(builder, target_block_id);
8202
8205 {
8208 vkd3d_spirv_build_op_branch(builder, merge_block_id);
8209 }
8210 else
8211 {
8213 }
8214
8215 vkd3d_spirv_build_op_label(builder, merge_block_id);
8218}
static uint32_t vkd3d_spirv_build_op_function(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t result_id, uint32_t function_control, uint32_t function_type)
Definition: spirv.c:1259
static void vkd3d_spirv_build_op_demote_to_helper_invocation(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1409
static uint32_t vkd3d_spirv_get_op_type_function(struct vkd3d_spirv_builder *builder, uint32_t return_type, const uint32_t *param_types, unsigned int param_count)
Definition: spirv.c:1149
static void vkd3d_spirv_build_op_kill(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1404
static void vkd3d_spirv_build_op_function_end(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1274
static uint32_t vkd3d_spirv_build_op_function_parameter(struct vkd3d_spirv_builder *builder, uint32_t result_type)
Definition: spirv.c:1267
@ SpvCapabilityDemoteToHelperInvocationEXT
Definition: spirv.h:1034
@ SpvFunctionControlMaskNone
Definition: spirv.h:749
uint32_t discard_function_id
Definition: spirv.c:2461
@ VKD3D_SHADER_SPIRV_EXTENSION_EXT_DEMOTE_TO_HELPER_INVOCATION

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_dot()

static void spirv_compiler_emit_dot ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7576 of file spirv.c.

7578{
7579 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7580 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7581 const struct vkd3d_shader_src_param *src = instruction->src;
7583 uint32_t type_id, val_id, src_ids[2];
7584 unsigned int component_count, i;
7585 uint32_t write_mask;
7586
7589
7591 write_mask = VKD3DSP_WRITEMASK_ALL;
7592 else if (instruction->opcode == VKD3DSIH_DP3)
7594 else
7596
7597 VKD3D_ASSERT(instruction->src_count == ARRAY_SIZE(src_ids));
7598 for (i = 0; i < ARRAY_SIZE(src_ids); ++i)
7599 src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], write_mask);
7600
7602
7603 val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
7604 SpvOpDot, type_id, src_ids[0], src_ids[1]);
7605 if (component_count > 1)
7606 {
7607 val_id = spirv_compiler_emit_construct_vector(compiler,
7608 component_type, component_count, val_id, 0, 1);
7609 }
7610 if (instruction->flags & VKD3DSI_PRECISE_XYZW)
7612
7613 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7614}
static uint32_t spirv_compiler_emit_construct_vector(struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t val_id, unsigned int val_component_idx, unsigned int val_component_count)
Definition: spirv.c:3491
@ SpvOpDot
Definition: spirv.h:1332
@ VKD3DSIH_DP4
@ VKD3DSIH_DP3
#define VKD3DSP_WRITEMASK_2

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_draw_parameter_fixup()

static uint32_t spirv_compiler_emit_draw_parameter_fixup ( struct spirv_compiler *  compiler,
uint32_t  index_id,
SpvBuiltIn  base 
)
static

Definition at line 4766 of file spirv.c.

4768{
4769 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4770 uint32_t base_var_id, base_id, type_id;
4771
4773
4774 base_var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream,
4776 vkd3d_spirv_add_iface_variable(builder, base_var_id);
4777 spirv_compiler_decorate_builtin(compiler, base_var_id, base);
4778
4780 base_id = vkd3d_spirv_build_op_load(builder,
4781 type_id, base_var_id, SpvMemoryAccessMaskNone);
4782
4783 return vkd3d_spirv_build_op_isub(builder, type_id, index_id, base_id);
4784}
static uint32_t vkd3d_spirv_build_op_load(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t pointer_id, uint32_t memory_access)
Definition: spirv.c:1364
static uint32_t spirv_compiler_emit_variable(struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, enum vkd3d_shader_component_type component_type, unsigned int component_count)
Definition: spirv.c:3308
@ SpvCapabilityDrawParameters
Definition: spirv.h:942

Referenced by sv_instance_id_fixup(), and sv_vertex_id_fixup().

◆ spirv_compiler_emit_emit_stream()

static void spirv_compiler_emit_emit_stream ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9896 of file spirv.c.

9898{
9899 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9900 unsigned int stream_idx;
9901
9903 stream_idx = instruction->src[0].reg.idx[0].offset;
9904 else
9905 stream_idx = 0;
9906
9907 if (stream_idx)
9908 {
9909 FIXME("Multiple streams are not supported yet.\n");
9910 return;
9911 }
9912
9915}
static void vkd3d_spirv_build_op_emit_vertex(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1761
static void spirv_compiler_emit_shader_epilogue_invocation(struct spirv_compiler *compiler)
Definition: spirv.c:7086
@ VKD3DSIH_EMIT_STREAM

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_eval_attrib()

static void spirv_compiler_emit_eval_attrib ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9789 of file spirv.c.

9791{
9792 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9793 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9794 const struct vkd3d_shader_src_param *src = instruction->src;
9795 const struct vkd3d_shader_register *input = &src[0].reg;
9796 uint32_t instr_set_id, type_id, val_id, src_ids[2];
9797 struct vkd3d_shader_register_info register_info;
9798 unsigned int src_count = 0;
9799 enum GLSLstd450 op;
9800
9801 if (!spirv_compiler_get_register_info(compiler, input, &register_info))
9802 return;
9803
9804 if (register_info.storage_class != SpvStorageClassInput)
9805 {
9806 FIXME("Not supported for storage class %#x.\n", register_info.storage_class);
9807 return;
9808 }
9809
9811
9812 src_ids[src_count++] = register_info.id;
9813
9815 {
9817 }
9818 else
9819 {
9822 src_ids[src_count++] = spirv_compiler_emit_load_src(compiler, &src[1], VKD3DSP_WRITEMASK_0);
9823 }
9824
9826 vsir_write_mask_component_count(register_info.write_mask));
9827
9828 instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
9829 val_id = vkd3d_spirv_build_op_ext_inst(builder, type_id, instr_set_id, op, src_ids, src_count);
9830
9831 val_id = spirv_compiler_emit_swizzle(compiler, val_id, register_info.write_mask,
9832 VKD3D_SHADER_COMPONENT_FLOAT, src[0].swizzle, dst->write_mask);
9833
9834 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9835}
GLSLstd450
Definition: GLSL.std.450.h:33
@ GLSLstd450InterpolateAtCentroid
Definition: GLSL.std.450.h:120
@ GLSLstd450InterpolateAtSample
Definition: GLSL.std.450.h:121
static uint32_t vkd3d_spirv_build_op_ext_inst(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t inst_set, uint32_t inst_number, uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:908
static uint32_t vkd3d_spirv_get_glsl_std450_instr_set(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:456
@ SpvCapabilityInterpolationFunction
Definition: spirv.h:920
@ VKD3DSIH_EVAL_CENTROID
@ VKD3DSIH_EVAL_SAMPLE_INDEX

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_execution_mode()

static void spirv_compiler_emit_execution_mode ( struct spirv_compiler *  compiler,
SpvExecutionMode  mode,
const uint32_t *  literals,
unsigned int  literal_count 
)
static

◆ spirv_compiler_emit_execution_mode1()

static void spirv_compiler_emit_execution_mode1 ( struct spirv_compiler *  compiler,
SpvExecutionMode  mode,
const uint32_t  literal 
)
static

Definition at line 4334 of file spirv.c.

4336{
4337 spirv_compiler_emit_execution_mode(compiler, mode, &literal, 1);
4338}

Referenced by spirv_compiler_emit_output_vertex_count().

◆ spirv_compiler_emit_ext_glsl_instruction()

static void spirv_compiler_emit_ext_glsl_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7386 of file spirv.c.

7388{
7389 uint32_t instr_set_id, type_id, val_id, rev_val_id, uint_max_id, condition_id;
7390 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7391 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7392 const struct vkd3d_shader_src_param *src = instruction->src;
7394 unsigned int i, component_count;
7395 enum GLSLstd450 glsl_inst;
7396
7399 {
7400 /* At least some drivers support this anyway, but if validation is enabled it will fail. */
7401 FIXME("Unsupported 64-bit source for handler %#x.\n", instruction->opcode);
7402 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED,
7403 "64-bit source for handler %#x is not supported.", instruction->opcode);
7404 return;
7405 }
7406
7408 if (glsl_inst == GLSLstd450Bad)
7409 {
7410 ERR("Unexpected instruction %#x.\n", instruction->opcode);
7411 return;
7412 }
7413
7414 instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
7415
7416 VKD3D_ASSERT(instruction->dst_count == 1);
7418
7420
7421 for (i = 0; i < instruction->src_count; ++i)
7422 src_id[i] = spirv_compiler_emit_load_src(compiler, &src[i], dst->write_mask);
7423
7424 val_id = vkd3d_spirv_build_op_ext_inst(builder, type_id,
7425 instr_set_id, glsl_inst, src_id, instruction->src_count);
7426
7429 {
7430 /* In D3D bits are numbered from the most significant bit. */
7433 condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, SpvOpIEqual,
7435 rev_val_id = vkd3d_spirv_build_op_isub(builder, type_id,
7437 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, val_id, rev_val_id);
7438 }
7439
7440 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7441}
@ GLSLstd450Bad
Definition: GLSL.std.450.h:34
#define UINT32_MAX
Definition: stdint.h:85
static enum GLSLstd450 spirv_compiler_map_ext_glsl_instruction(const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7334
@ VKD3DSIH_FIRSTBIT_HI
@ VKD3DSIH_FIRSTBIT_LO
@ VKD3DSIH_FIRSTBIT_SHI

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_f16tof32()

static void spirv_compiler_emit_f16tof32 ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7937 of file spirv.c.

7939{
7940 uint32_t instr_set_id, type_id, scalar_type_id, src_id, result_id;
7941 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7942 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7943 const struct vkd3d_shader_src_param *src = instruction->src;
7945 uint32_t write_mask;
7946 unsigned int i, j;
7947
7948 instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
7950 scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 1);
7951
7952 /* FIXME: Consider a single UnpackHalf2x16 instruction per 2 components. */
7953 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
7954 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
7955 {
7956 if (!(write_mask = dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
7957 continue;
7958
7959 src_id = spirv_compiler_emit_load_src(compiler, src, write_mask);
7960 result_id = vkd3d_spirv_build_op_ext_inst(builder, type_id,
7961 instr_set_id, GLSLstd450UnpackHalf2x16, &src_id, 1);
7963 scalar_type_id, result_id, 0);
7964 }
7965
7968}
@ GLSLstd450UnpackHalf2x16
Definition: GLSL.std.450.h:103

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_f32tof16()

static void spirv_compiler_emit_f32tof16 ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7970 of file spirv.c.

7972{
7973 uint32_t instr_set_id, type_id, scalar_type_id, src_id, zero_id, constituents[2];
7974 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7975 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7976 const struct vkd3d_shader_src_param *src = instruction->src;
7978 uint32_t write_mask;
7979 unsigned int i, j;
7980
7981 instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
7983 scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
7984 zero_id = spirv_compiler_get_constant_float(compiler, 0.0f);
7985
7986 /* FIXME: Consider a single PackHalf2x16 instruction per 2 components. */
7987 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
7988 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
7989 {
7990 if (!(write_mask = dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
7991 continue;
7992
7993 src_id = spirv_compiler_emit_load_src(compiler, src, write_mask);
7994 constituents[0] = src_id;
7995 constituents[1] = zero_id;
7997 type_id, constituents, ARRAY_SIZE(constituents));
7998 components[j++] = vkd3d_spirv_build_op_ext_inst(builder, scalar_type_id,
7999 instr_set_id, GLSLstd450PackHalf2x16, &src_id, 1);
8000 }
8001
8004}
@ GLSLstd450PackHalf2x16
Definition: GLSL.std.450.h:99

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_float_comparison_instruction()

static void spirv_compiler_emit_float_comparison_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8075 of file spirv.c.

8077{
8078 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8079 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8080 const struct vkd3d_shader_src_param *src = instruction->src;
8081 uint32_t src0_id, src1_id, type_id, result_id;
8082 unsigned int component_count;
8083 SpvOp op;
8084
8085 switch (instruction->opcode)
8086 {
8087 case VKD3DSIH_SLT: op = SpvOpFOrdLessThan; break;
8089 default:
8091 }
8092
8094
8095 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
8096 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
8097
8099 result_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, src0_id, src1_id);
8100
8101 result_id = spirv_compiler_emit_bool_to_float(compiler, component_count, result_id, false);
8102 spirv_compiler_emit_store_reg(compiler, &dst->reg, dst->write_mask, result_id);
8103}
@ VKD3DSIH_SGE
@ VKD3DSIH_SLT

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_ftoi()

static void spirv_compiler_emit_ftoi ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7778 of file spirv.c.

7780{
7781 uint32_t src_id, int_min_id, int_max_id, zero_id, float_max_id, condition_id, val_id;
7782 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7783 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7784 const struct vkd3d_shader_src_param *src = instruction->src;
7785 uint32_t src_type_id, dst_type_id, condition_type_id;
7787 unsigned int component_count;
7788
7789 VKD3D_ASSERT(instruction->dst_count == 1);
7790 VKD3D_ASSERT(instruction->src_count == 1);
7791
7792 /* OpConvertFToI has undefined results if the result cannot be represented
7793 * as a signed integer, but Direct3D expects the result to saturate,
7794 * and for NaN to yield zero. */
7795
7797 src_type_id = spirv_compiler_get_type_id_for_reg(compiler, &src->reg, dst->write_mask);
7798 dst_type_id = spirv_compiler_get_type_id_for_dst(compiler, dst);
7799 src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
7800
7801 if (src->reg.data_type == VKD3D_DATA_DOUBLE)
7802 {
7803 int_min_id = spirv_compiler_get_constant_double_vector(compiler, -2147483648.0, component_count);
7804 float_max_id = spirv_compiler_get_constant_double_vector(compiler, 2147483648.0, component_count);
7805 }
7806 else
7807 {
7808 int_min_id = spirv_compiler_get_constant_float_vector(compiler, -2147483648.0f, component_count);
7809 float_max_id = spirv_compiler_get_constant_float_vector(compiler, 2147483648.0f, component_count);
7810 }
7811
7812 val_id = vkd3d_spirv_build_op_glsl_std450_max(builder, src_type_id, src_id, int_min_id);
7813
7814 /* VSIR allows the destination of a signed conversion to be unsigned. */
7816
7819 condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
7820 SpvOpFOrdGreaterThanEqual, condition_type_id, val_id, float_max_id);
7821
7822 val_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpConvertFToS, dst_type_id, val_id);
7823 val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, int_max_id, val_id);
7824
7826 condition_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpIsNan, condition_type_id, src_id);
7827 val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, zero_id, val_id);
7828
7829 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7830}
#define INT_MAX
Definition: limits.h:26
static uint32_t vkd3d_spirv_build_op_glsl_std450_max(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t y)
Definition: spirv.c:1883
@ SpvOpConvertFToS
Definition: spirv.h:1295
@ SpvOpIsNan
Definition: spirv.h:1339

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_ftou()

static void spirv_compiler_emit_ftou ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7832 of file spirv.c.

7834{
7835 uint32_t src_id, zero_id, uint_max_id, float_max_id, condition_id, val_id;
7836 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7837 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7838 const struct vkd3d_shader_src_param *src = instruction->src;
7839 uint32_t src_type_id, dst_type_id, condition_type_id;
7840 unsigned int component_count;
7841
7842 VKD3D_ASSERT(instruction->dst_count == 1);
7843 VKD3D_ASSERT(instruction->src_count == 1);
7844
7845 /* OpConvertFToU has undefined results if the result cannot be represented
7846 * as an unsigned integer, but Direct3D expects the result to saturate,
7847 * and for NaN to yield zero. */
7848
7850 src_type_id = spirv_compiler_get_type_id_for_reg(compiler, &src->reg, dst->write_mask);
7851 dst_type_id = spirv_compiler_get_type_id_for_dst(compiler, dst);
7852 src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
7853
7854 if (src->reg.data_type == VKD3D_DATA_DOUBLE)
7855 {
7857 float_max_id = spirv_compiler_get_constant_double_vector(compiler, 4294967296.0, component_count);
7858 }
7859 else
7860 {
7862 float_max_id = spirv_compiler_get_constant_float_vector(compiler, 4294967296.0f, component_count);
7863 }
7864
7865 val_id = vkd3d_spirv_build_op_glsl_std450_max(builder, src_type_id, src_id, zero_id);
7866
7869 condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
7870 SpvOpFOrdGreaterThanEqual, condition_type_id, val_id, float_max_id);
7871
7872 val_id = vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpConvertFToU, dst_type_id, val_id);
7873 val_id = vkd3d_spirv_build_op_select(builder, dst_type_id, condition_id, uint_max_id, val_id);
7874
7875 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7876}
#define UINT_MAX
Definition: limits.h:27
@ SpvOpConvertFToU
Definition: spirv.h:1294

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_gather4()

static void spirv_compiler_emit_gather4 ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8795 of file spirv.c.

8797{
8799 uint32_t sampled_type_id, coordinate_id, component_id, dref_id, val_id;
8800 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8801 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8802 const struct vkd3d_shader_src_param *src = instruction->src;
8803 unsigned int image_flags = VKD3D_IMAGE_FLAG_SAMPLED;
8804 unsigned int component_count, component_idx;
8805 SpvImageOperandsMask operands_mask = 0;
8806 unsigned int image_operand_count = 0;
8808 uint32_t image_operands[1];
8809 uint32_t coordinate_mask;
8810 bool extended_offset;
8811
8814 image_flags |= VKD3D_IMAGE_FLAG_DEPTH;
8815
8816 extended_offset = instruction->opcode == VKD3DSIH_GATHER4_PO
8818
8819 addr = &src[0];
8820 offset = extended_offset ? &src[1] : NULL;
8821 resource = &src[1 + extended_offset];
8822 sampler = &src[2 + extended_offset];
8823
8825 &resource->reg, &sampler->reg, image_flags);
8826
8827 if (offset)
8828 {
8829 component_count = image.resource_type_info->coordinate_component_count - image.resource_type_info->arrayed;
8830 VKD3D_ASSERT(image.resource_type_info->dim != SpvDimCube);
8832 operands_mask |= SpvImageOperandsOffsetMask;
8833 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8834 offset, (1u << component_count) - 1);
8835 }
8837 {
8838 operands_mask |= SpvImageOperandsConstOffsetMask;
8839 image_operands[image_operand_count++] = spirv_compiler_emit_texel_offset(compiler,
8840 instruction, image.resource_type_info);
8841 }
8842
8843 sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE);
8844 coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1;
8845 coordinate_id = spirv_compiler_emit_load_src(compiler, addr, coordinate_mask);
8846 if (image_flags & VKD3D_IMAGE_FLAG_DEPTH)
8847 {
8848 dref_id = spirv_compiler_emit_load_src(compiler,
8849 &src[3 + extended_offset], VKD3DSP_WRITEMASK_0);
8850 val_id = vkd3d_spirv_build_op_image_dref_gather(builder, sampled_type_id,
8851 image.sampled_image_id, coordinate_id, dref_id,
8852 operands_mask, image_operands, image_operand_count);
8853 }
8854 else
8855 {
8856 component_idx = vsir_swizzle_get_component(sampler->swizzle, 0);
8857 /* Nvidia driver requires signed integer type. */
8858 component_id = spirv_compiler_get_constant(compiler,
8859 VKD3D_SHADER_COMPONENT_INT, 1, &component_idx);
8860 val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id,
8861 image.sampled_image_id, coordinate_id, component_id,
8862 operands_mask, image_operands, image_operand_count);
8863 }
8864
8866 dst, val_id, image.sampled_type, resource->swizzle);
8867}
GLuint sampler
Definition: glext.h:7283
GLenum const GLvoid * addr
Definition: glext.h:9621
static uint32_t vkd3d_spirv_build_op_image_gather(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t component_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1672
#define VKD3D_IMAGE_FLAG_DEPTH
Definition: spirv.c:8440
static void spirv_compiler_emit_store_dst_swizzled(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
Definition: spirv.c:4577
#define VKD3D_IMAGE_FLAG_SAMPLED
Definition: spirv.c:8442
static uint32_t vkd3d_spirv_build_op_image_dref_gather(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t dref_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1681
static uint32_t spirv_compiler_emit_texel_offset(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction, const struct vkd3d_spirv_resource_type *resource_type_info)
Definition: spirv.c:8594
@ SpvDimCube
Definition: spirv.h:228
enum SpvImageOperandsMask_ SpvImageOperandsMask
@ SpvImageOperandsOffsetMask
Definition: spirv.h:371
@ SpvImageOperandsConstOffsetMask
Definition: spirv.h:370
@ SpvCapabilityImageGatherExtended
Definition: spirv.h:894
static bool vkd3d_shader_instruction_has_texel_offset(const struct vkd3d_shader_instruction *ins)
static unsigned int vsir_swizzle_get_component(uint32_t swizzle, unsigned int idx)
@ VKD3DSIH_GATHER4_PO_C
@ VKD3DSIH_GATHER4_PO
@ VKD3DSIH_GATHER4_C

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_global_flags()

static void spirv_compiler_emit_global_flags ( struct spirv_compiler *  compiler,
enum vsir_global_flags  flags 
)
static

Definition at line 5925 of file spirv.c.

5926{
5928 {
5930 flags &= ~VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL;
5931 }
5932
5934 {
5936 {
5938 }
5939 else
5940 {
5941 WARN("Unsupported 64-bit float ops.\n");
5942 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
5943 "The target environment does not support 64-bit floating point.");
5944 }
5946 }
5947
5949 {
5951 {
5953 }
5954 else
5955 {
5956 WARN("Unsupported 64-bit integer ops.\n");
5957 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
5958 "The target environment does not support 64-bit integers.");
5959 }
5960 flags &= ~VKD3DSGF_ENABLE_INT64;
5961 }
5962
5964 {
5966 {
5967 WARN("Unsupported wave ops.\n");
5968 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
5969 "The target environment does not support wave ops.");
5970 }
5971 else if (!spirv_compiler_is_spirv_min_1_3_target(compiler))
5972 {
5973 WARN("Wave ops enabled but environment does not support SPIR-V 1.3 or greater.\n");
5974 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
5975 "The target environment uses wave ops but does not support SPIR-V 1.3 or greater.");
5976 }
5977 flags &= ~VKD3DSGF_ENABLE_WAVE_INTRINSICS;
5978 }
5979
5981 FIXME("Unhandled global flags %#"PRIx64".\n", (uint64_t)flags);
5982 else if (flags)
5983 WARN("Unhandled global flags %#"PRIx64".\n", (uint64_t)flags);
5984}
#define PRIx64
Definition: inttypes.h:29
GLbitfield flags
Definition: glext.h:7161
static bool spirv_compiler_is_spirv_min_1_3_target(const struct spirv_compiler *compiler)
Definition: spirv.c:2728
@ SpvExecutionModeEarlyFragmentTests
Definition: spirv.h:129
@ SpvCapabilityInt64
Definition: spirv.h:881
@ SpvCapabilityFloat64
Definition: spirv.h:880
@ VKD3D_SHADER_COMPILE_OPTION_FEATURE_WAVE_OPS
Definition: vkd3d_shader.h:245
@ VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64
Definition: vkd3d_shader.h:232
@ VKD3DSGF_ENABLE_WAVE_INTRINSICS
@ VKD3DSGF_ENABLE_INT64
@ VKD3DSGF_REFACTORING_ALLOWED
@ VKD3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS
@ VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL
@ VKD3DSGF_ENABLE_DOUBLE_PRECISION_FLOAT_OPS
@ VKD3DSGF_ENABLE_11_1_DOUBLE_EXTENSIONS

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_group_nonuniform_ballot()

static uint32_t spirv_compiler_emit_group_nonuniform_ballot ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_src_param *  src 
)
static

Definition at line 10031 of file spirv.c.

10033{
10034 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10035 uint32_t type_id, val_id;
10036
10039 val_id = vkd3d_spirv_build_op_group_nonuniform_ballot(builder, type_id, val_id);
10040
10041 return val_id;
10042}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id)
Definition: spirv.c:1811

Referenced by spirv_compiler_emit_wave_active_ballot(), and spirv_compiler_emit_wave_bit_count().

◆ spirv_compiler_emit_hull_shader_barrier()

static void spirv_compiler_emit_hull_shader_barrier ( struct spirv_compiler *  compiler)
static

Definition at line 7080 of file spirv.c.

7081{
7084}
static void spirv_compiler_emit_barrier(struct spirv_compiler *compiler, SpvScope execution_scope, SpvScope memory_scope, SpvMemorySemanticsMask semantics)
Definition: spirv.c:7060
@ SpvScopeInvocation
Definition: spirv.h:834

Referenced by spirv_compiler_emit_hull_shader_main().

◆ spirv_compiler_emit_hull_shader_builtins()

static void spirv_compiler_emit_hull_shader_builtins ( struct spirv_compiler *  compiler)
static

Definition at line 5860 of file spirv.c.

5861{
5863
5864 memset(&dst, 0, sizeof(dst));
5866 dst.write_mask = VKD3DSP_WRITEMASK_0;
5868}

Referenced by spirv_compiler_emit_initial_declarations().

◆ spirv_compiler_emit_hull_shader_main()

static void spirv_compiler_emit_hull_shader_main ( struct spirv_compiler *  compiler)
static

Definition at line 7106 of file spirv.c.

7107{
7108 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7109 uint32_t void_id;
7110
7111 /* If a patch constant function used descriptor indexing the offsets must be reloaded. */
7112 memset(compiler->descriptor_offset_ids, 0, compiler->offset_info.descriptor_table_count
7113 * sizeof(*compiler->descriptor_offset_ids));
7116
7117 void_id = vkd3d_spirv_get_op_type_void(builder);
7118
7119 vkd3d_spirv_build_op_function_call(builder, void_id, compiler->control_point_phase.function_id, NULL, 0);
7120
7121 if (compiler->use_vocp)
7123
7124 /* TODO: only call the patch constant function for invocation 0. The simplest way
7125 * is to avoid use of private variables there, otherwise we would need a separate
7126 * patch constant epilogue also only called from invocation 0. */
7127 vkd3d_spirv_build_op_function_call(builder, void_id, compiler->patch_constant_phase.function_id, NULL, 0);
7131}
static void spirv_compiler_emit_hull_shader_barrier(struct spirv_compiler *compiler)
Definition: spirv.c:7080
static void vkd3d_spirv_builder_begin_main_function(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1993
struct vkd3d_shader_phase control_point_phase
Definition: spirv.c:2475
bool use_vocp
Definition: spirv.c:2469
struct vkd3d_shader_phase patch_constant_phase
Definition: spirv.c:2476

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_imad()

static void spirv_compiler_emit_imad ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7696 of file spirv.c.

7698{
7699 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7700 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7701 const struct vkd3d_shader_src_param *src = instruction->src;
7702 uint32_t type_id, val_id, src_ids[3];
7703 unsigned int i, component_count;
7704
7707
7708 for (i = 0; i < ARRAY_SIZE(src_ids); ++i)
7709 src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], dst->write_mask);
7710
7711 val_id = vkd3d_spirv_build_op_imul(builder, type_id, src_ids[0], src_ids[1]);
7712 val_id = vkd3d_spirv_build_op_iadd(builder, type_id, val_id, src_ids[2]);
7713
7714 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7715}
static uint32_t vkd3d_spirv_build_op_iadd(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1461
static uint32_t vkd3d_spirv_build_op_imul(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1468

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_imul()

static void spirv_compiler_emit_imul ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7672 of file spirv.c.

7674{
7675 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7676 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7677 const struct vkd3d_shader_src_param *src = instruction->src;
7678 uint32_t type_id, val_id, src0_id, src1_id;
7679
7680 if (dst[0].reg.type != VKD3DSPR_NULL)
7681 FIXME("Extended multiplies not implemented.\n"); /* SpvOpSMulExtended/SpvOpUMulExtended */
7682
7683 if (dst[1].reg.type == VKD3DSPR_NULL)
7684 return;
7685
7687
7688 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst[1].write_mask);
7689 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst[1].write_mask);
7690
7691 val_id = vkd3d_spirv_build_op_imul(builder, type_id, src0_id, src1_id);
7692
7693 spirv_compiler_emit_store_dst(compiler, &dst[1], val_id);
7694}
@ VKD3DSPR_NULL

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_initial_declarations()

static void spirv_compiler_emit_initial_declarations ( struct spirv_compiler *  compiler)
static

Definition at line 5870 of file spirv.c.

5871{
5872 const struct vkd3d_shader_transform_feedback_info *xfb_info = compiler->xfb_info;
5873 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5874
5875 switch (compiler->shader_type)
5876 {
5879 break;
5883 break;
5886 break;
5889 builder->invocation_count = 1;
5890 break;
5894 break;
5897 break;
5898 default:
5899 ERR("Invalid shader type %#x.\n", compiler->shader_type);
5900 }
5901
5902 if (xfb_info && xfb_info->element_count)
5903 {
5906 }
5907
5908 if (compiler->shader_type != VKD3D_SHADER_TYPE_HULL)
5909 {
5911 }
5912}
static void vkd3d_spirv_set_execution_model(struct vkd3d_spirv_builder *builder, SpvExecutionModel model)
Definition: spirv.c:474
static void spirv_compiler_emit_hull_shader_builtins(struct spirv_compiler *compiler)
Definition: spirv.c:5860
@ SpvExecutionModeXfb
Definition: spirv.h:131
@ SpvCapabilityTransformFeedback
Definition: spirv.h:921
@ SpvExecutionModelGeometry
Definition: spirv.h:80
@ SpvExecutionModelGLCompute
Definition: spirv.h:82
@ SpvExecutionModelTessellationControl
Definition: spirv.h:78
@ SpvExecutionModelTessellationEvaluation
Definition: spirv.h:79
@ SpvExecutionModelFragment
Definition: spirv.h:81
@ SpvExecutionModelVertex
Definition: spirv.h:77
uint32_t invocation_count
Definition: spirv.c:387

Referenced by spirv_compiler_create().

◆ spirv_compiler_emit_input()

static uint32_t spirv_compiler_emit_input ( struct spirv_compiler *  compiler,
enum vkd3d_shader_register_type  reg_type,
unsigned int  element_idx 
)
static

Definition at line 5169 of file spirv.c.

5171{
5172 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5173 unsigned int component_idx, input_component_count;
5175 const struct shader_signature *shader_signature;
5177 const struct vkd3d_spirv_builtin *builtin;
5179 uint32_t write_mask, reg_write_mask;
5180 struct vkd3d_symbol *symbol = NULL;
5181 uint32_t val_id, input_id, var_id;
5182 uint32_t type_id, float_type_id;
5183 struct vkd3d_symbol reg_symbol;
5185 struct rb_entry *entry = NULL;
5186 bool use_private_var = false;
5187 unsigned int array_sizes[2];
5188
5190 ? &compiler->patch_constant_signature : &compiler->input_signature;
5191
5194 /* The Vulkan spec does not explicitly forbid passing varyings from the
5195 * TCS to the TES via builtins. However, Mesa doesn't seem to handle it
5196 * well, and we don't actually need them to be in builtins. */
5199
5201
5202 array_sizes[0] = signature_element->register_count;
5203 array_sizes[1] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->input_control_point_count);
5206 {
5207 array_sizes[0] = 0;
5208 }
5209
5210 write_mask = signature_element->mask;
5211
5212 if (builtin)
5213 {
5214 component_type = builtin->component_type;
5215 input_component_count = builtin->component_count;
5216 component_idx = 0;
5217 }
5218 else
5219 {
5221 input_component_count = vsir_write_mask_component_count(signature_element->mask);
5223 }
5224
5226 {
5227 use_private_var = true;
5228 reg_write_mask = write_mask;
5229 }
5230 else
5231 {
5232 component_idx = vsir_write_mask_get_component_idx(write_mask);
5233 reg_write_mask = write_mask >> component_idx;
5234 }
5235
5237
5238 vkd3d_symbol_make_io(&reg_symbol, reg_type, element_idx);
5239
5240 if ((entry = rb_get(&compiler->symbol_table, &reg_symbol)))
5241 {
5242 /* Except for vicp there should be one declaration per signature element. Sources of
5243 * duplicate declarations are: a single register split into multiple declarations having
5244 * different components, which should have been merged, and declarations in one phase
5245 * being repeated in another (i.e. vcp/vocp), which should have been deleted. */
5247 FIXME("Duplicate input definition found.\n");
5248 symbol = RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
5249 return symbol->id;
5250 }
5251
5252 if (builtin)
5253 {
5254 input_id = spirv_compiler_emit_builtin_variable_v(compiler, builtin, storage_class, array_sizes, 2);
5257 }
5258 else
5259 {
5261
5262 input_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
5263 storage_class, component_type, input_component_count, array_sizes, 2);
5264 vkd3d_spirv_add_iface_variable(builder, input_id);
5266 {
5269 }
5271 if (component_idx)
5272 vkd3d_spirv_build_op_decorate1(builder, input_id, SpvDecorationComponent, component_idx);
5273
5276 }
5277
5278 var_id = input_id;
5279 if (use_private_var)
5280 {
5282 var_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
5284 }
5285
5286 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
5287 use_private_var ? VKD3D_SHADER_COMPONENT_FLOAT : component_type,
5288 use_private_var ? VKD3DSP_WRITEMASK_ALL : reg_write_mask);
5289 reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1];
5290 VKD3D_ASSERT(!builtin || !builtin->spirv_array_size || use_private_var || array_sizes[0] || array_sizes[1]);
5291 spirv_compiler_put_symbol(compiler, &reg_symbol);
5292
5293 vkd3d_spirv_build_op_name(builder, var_id, reg_type == VKD3DSPR_PATCHCONST ? "vpc%u" : "v%u", element_idx);
5294
5295 if (use_private_var)
5296 {
5297 struct vkd3d_shader_register dst_reg;
5298
5300 dst_reg.idx[0].offset = element_idx;
5301
5302 type_id = vkd3d_spirv_get_type_id(builder, component_type, input_component_count);
5303
5304 val_id = vkd3d_spirv_build_op_load(builder, type_id, input_id, SpvMemoryAccessMaskNone);
5305
5306 if (builtin && builtin->fixup_pfn)
5307 val_id = builtin->fixup_pfn(compiler, val_id);
5308
5310 {
5311 float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, input_component_count);
5312 val_id = vkd3d_spirv_build_op_bitcast(builder, float_type_id, val_id);
5313 }
5314
5315 val_id = spirv_compiler_emit_swizzle(compiler, val_id,
5316 vkd3d_write_mask_from_component_count(input_component_count),
5318
5319 spirv_compiler_emit_store_reg(compiler, &dst_reg, signature_element->mask, val_id);
5320 }
5321
5322 return input_id;
5323}
static bool is_in_fork_or_join_phase(const struct spirv_compiler *compiler)
Definition: spirv.c:2510
static uint32_t vkd3d_spirv_build_op_bitcast(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1591
static unsigned int shader_signature_next_location(const struct shader_signature *signature)
Definition: spirv.c:5157
static bool needs_private_io_variable(const struct vkd3d_spirv_builtin *builtin)
Definition: spirv.c:5152
static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_sysval(const struct spirv_compiler *compiler, enum vkd3d_shader_sysval_semantic sysval)
Definition: spirv.c:4945
static void spirv_compiler_emit_interpolation_decorations(struct spirv_compiler *compiler, enum vkd3d_shader_component_type component_type, uint32_t id, enum vkd3d_shader_interpolation_mode mode)
Definition: spirv.c:4724
static void vkd3d_symbol_make_io(struct vkd3d_symbol *symbol, enum vkd3d_shader_register_type type, unsigned int index)
Definition: spirv.c:2300
@ SpvDecorationComponent
Definition: spirv.h:476
@ SpvDecorationLocation
Definition: spirv.h:475
@ SpvDecorationPatch
Definition: spirv.h:460
enum vkd3d_shader_sysval_semantic sysval_semantic
enum vkd3d_shader_interpolation_mode interpolation_mode
unsigned int input_control_point_count
Definition: spirv.c:2466
vkd3d_shader_sysval_semantic
static bool vsir_sysval_semantic_is_clip_cull(enum vkd3d_shader_sysval_semantic sysval_semantic)
static bool vsir_sysval_semantic_is_tess_factor(enum vkd3d_shader_sysval_semantic sysval_semantic)

Referenced by spirv_compiler_emit_io_declarations().

◆ spirv_compiler_emit_input_register()

static void spirv_compiler_emit_input_register ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst 
)
static

Definition at line 5325 of file spirv.c.

5327{
5328 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5329 const struct vkd3d_shader_register *reg = &dst->reg;
5330 const struct vkd3d_spirv_builtin *builtin;
5331 struct vkd3d_symbol reg_symbol;
5332 struct rb_entry *entry;
5333 uint32_t write_mask;
5334 uint32_t input_id;
5335
5336 VKD3D_ASSERT(!reg->idx_count || !reg->idx[0].rel_addr);
5337 VKD3D_ASSERT(reg->idx_count < 2);
5338
5340 {
5341 FIXME("Unhandled register %#x.\n", reg->type);
5342 return;
5343 }
5344
5345 /* vPrim may be declared in multiple hull shader phases. */
5346 vkd3d_symbol_make_register(&reg_symbol, reg);
5347 if ((entry = rb_get(&compiler->symbol_table, &reg_symbol)))
5348 return;
5349
5351
5352 write_mask = vkd3d_write_mask_from_component_count(builtin->component_count);
5353 vkd3d_symbol_set_register_info(&reg_symbol, input_id,
5354 SpvStorageClassInput, builtin->component_type, write_mask);
5355 reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size;
5356 spirv_compiler_put_symbol(compiler, &reg_symbol);
5357 spirv_compiler_emit_register_debug_name(builder, input_id, reg);
5358}
static const struct vkd3d_spirv_builtin * get_spirv_builtin_for_register(enum vkd3d_shader_register_type reg_type)
Definition: spirv.c:4972
static uint32_t spirv_compiler_emit_builtin_variable(struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, SpvStorageClass storage_class, unsigned int array_size)
Definition: spirv.c:5146

Referenced by spirv_compiler_emit_dcl_input(), spirv_compiler_emit_hull_shader_builtins(), and spirv_compiler_emit_io_declarations().

◆ spirv_compiler_emit_int_div()

static void spirv_compiler_emit_int_div ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7717 of file spirv.c.

7719{
7720 uint32_t type_id, val_id, src0_id, src1_id, condition_id, uint_max_id;
7721 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7722 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7723 const struct vkd3d_shader_src_param *src = instruction->src;
7724 unsigned int component_count = 0;
7725 SpvOp div_op, mod_op;
7726
7729
7730 if (dst[0].reg.type != VKD3DSPR_NULL)
7731 {
7734
7735 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst[0].write_mask);
7736 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst[0].write_mask);
7737
7738 condition_id = spirv_compiler_emit_int_to_bool(compiler,
7739 VKD3D_SHADER_CONDITIONAL_OP_NZ, src[1].reg.data_type, component_count, src1_id);
7740 if (dst[0].reg.data_type == VKD3D_DATA_UINT64)
7742 else
7743 uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count);
7744
7745 val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, div_op, type_id, src0_id, src1_id);
7746 /* The SPIR-V spec says: "The resulting value is undefined if Operand 2 is 0." */
7747 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, val_id, uint_max_id);
7748
7749 spirv_compiler_emit_store_dst(compiler, &dst[0], val_id);
7750 }
7751
7752 if (dst[1].reg.type != VKD3DSPR_NULL)
7753 {
7754 if (!component_count || dst[0].write_mask != dst[1].write_mask)
7755 {
7758
7759 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst[1].write_mask);
7760 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst[1].write_mask);
7761
7762 condition_id = spirv_compiler_emit_int_to_bool(compiler,
7763 VKD3D_SHADER_CONDITIONAL_OP_NZ, src[1].reg.data_type, component_count, src1_id);
7764 if (dst[1].reg.data_type == VKD3D_DATA_UINT64)
7766 else
7767 uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count);
7768 }
7769
7770 val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, mod_op, type_id, src0_id, src1_id);
7771 /* The SPIR-V spec says: "The resulting value is undefined if Operand 2 is 0." */
7772 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, val_id, uint_max_id);
7773
7774 spirv_compiler_emit_store_dst(compiler, &dst[1], val_id);
7775 }
7776}
@ SpvOpSRem
Definition: spirv.h:1322
@ SpvOpSDiv
Definition: spirv.h:1319
@ SpvOpUMod
Definition: spirv.h:1321
@ SpvOpUDiv
Definition: spirv.h:1318
@ VKD3DSIH_IDIV

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_int_to_bool()

◆ spirv_compiler_emit_interpolation_decorations()

static void spirv_compiler_emit_interpolation_decorations ( struct spirv_compiler *  compiler,
enum vkd3d_shader_component_type  component_type,
uint32_t  id,
enum vkd3d_shader_interpolation_mode  mode 
)
static

Definition at line 4724 of file spirv.c.

4726{
4727 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4728
4729 switch (mode)
4730 {
4731 case VKD3DSIM_NONE:
4732 /* VUID-StandaloneSpirv-Flat-04744: integer or double types must be
4733 * decorated 'Flat' for fragment shaders. */
4735 break;
4736 /* fall through */
4737 case VKD3DSIM_CONSTANT:
4739 break;
4740 case VKD3DSIM_LINEAR:
4741 break;
4744 break;
4747 break;
4751 break;
4756 break;
4757 default:
4758 FIXME("Unhandled interpolation mode %#x.\n", mode);
4759 break;
4760 }
4761}
@ SpvDecorationSample
Definition: spirv.h:462
@ SpvDecorationNoPerspective
Definition: spirv.h:458
@ SpvDecorationCentroid
Definition: spirv.h:461
@ VKD3DSIM_CONSTANT
@ VKD3DSIM_NONE
@ VKD3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE
@ VKD3DSIM_LINEAR_CENTROID
@ VKD3DSIM_LINEAR
@ VKD3DSIM_LINEAR_NOPERSPECTIVE
@ VKD3DSIM_LINEAR_SAMPLE

Referenced by spirv_compiler_emit_input().

◆ spirv_compiler_emit_io_declarations()

static void spirv_compiler_emit_io_declarations ( struct spirv_compiler *  compiler)
static

Definition at line 10587 of file spirv.c.

10588{
10589 for (unsigned int i = 0; i < compiler->input_signature.element_count; ++i)
10591
10592 for (unsigned int i = 0; i < compiler->output_signature.element_count; ++i)
10593 {
10594 /* PS outputs other than TARGET have dedicated registers and therefore
10595 * go through spirv_compiler_emit_dcl_output() for now. */
10596 if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL
10597 && compiler->output_signature.elements[i].sysval_semantic != VKD3D_SHADER_SV_TARGET)
10598 continue;
10600 }
10601
10602 for (unsigned int i = 0; i < compiler->patch_constant_signature.element_count; ++i)
10603 {
10604 if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
10606 else
10608 }
10609
10610 if (compiler->program->has_point_size)
10611 {
10613
10615 dst.reg.idx[0].offset = VSIR_RASTOUT_POINT_SIZE;
10617 }
10618
10619 if (compiler->program->has_point_coord)
10620 {
10622
10625 }
10626}
void vsir_dst_param_init(struct vkd3d_shader_dst_param *param, enum vkd3d_shader_register_type reg_type, enum vkd3d_data_type data_type, unsigned int idx_count)
Definition: ir.c:272
static void spirv_compiler_emit_output(struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, unsigned int element_idx)
Definition: spirv.c:5521
static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, unsigned int element_idx)
Definition: spirv.c:5169
@ VKD3DSPR_POINT_COORD
@ VKD3DSPR_RASTOUT
@ VSIR_RASTOUT_POINT_SIZE

Referenced by spirv_compiler_initialise_block().

◆ spirv_compiler_emit_isfinite()

static void spirv_compiler_emit_isfinite ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7317 of file spirv.c.

7319{
7320 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7321 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7322 const struct vkd3d_shader_src_param *src = instruction->src;
7323 uint32_t type_id, src_id, isinf_id, isnan_id, val_id;
7324
7326 src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
7327 /* OpIsFinite is only available in Kernel mode. */
7328 isinf_id = vkd3d_spirv_build_op_is_inf(builder, type_id, src_id);
7329 isnan_id = vkd3d_spirv_build_op_is_nan(builder, type_id, src_id);
7330 val_id = vkd3d_spirv_build_op_logical_equal(builder, type_id, isinf_id, isnan_id);
7331 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7332}
static uint32_t vkd3d_spirv_build_op_is_inf(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1552
static uint32_t vkd3d_spirv_build_op_is_nan(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1558
static uint32_t vkd3d_spirv_build_op_logical_equal(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1564

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_label()

static void spirv_compiler_emit_label ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8251 of file spirv.c.

8253{
8254 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8255 const struct vkd3d_shader_src_param *src = instruction->src;
8256 unsigned int block_id = src->reg.idx[0].offset;
8257 uint32_t label_id;
8258
8259 label_id = spirv_compiler_get_label_id(compiler, block_id);
8260 vkd3d_spirv_build_op_label(builder, label_id);
8261
8262 --block_id;
8263 if (block_id < compiler->block_name_count && compiler->block_names[block_id])
8264 vkd3d_spirv_build_op_name(builder, label_id, compiler->block_names[block_id]);
8265
8267}
const char ** block_names
Definition: spirv.c:2496

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_ld()

static void spirv_compiler_emit_ld ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8607 of file spirv.c.

8609{
8610 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8611 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8612 const struct vkd3d_shader_src_param *src = instruction->src;
8613 uint32_t type_id, coordinate_id, val_id;
8614 SpvImageOperandsMask operands_mask = 0;
8615 unsigned int image_operand_count = 0;
8617 uint32_t image_operands[2];
8618 uint32_t coordinate_mask;
8619 bool multisample;
8620
8621 multisample = instruction->opcode == VKD3DSIH_LD2DMS;
8622
8624
8625 type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE);
8626 coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1;
8627 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], coordinate_mask);
8628 if (image.resource_type_info->resource_type != VKD3D_SHADER_RESOURCE_BUFFER && !multisample)
8629 {
8630 operands_mask |= SpvImageOperandsLodMask;
8631 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8633 }
8635 {
8636 operands_mask |= SpvImageOperandsConstOffsetMask;
8637 image_operands[image_operand_count++] = spirv_compiler_emit_texel_offset(compiler,
8638 instruction, image.resource_type_info);
8639 }
8640 if (multisample && image.resource_type_info->ms)
8641 {
8642 operands_mask |= SpvImageOperandsSampleMask;
8643 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8645 }
8646 VKD3D_ASSERT(image_operand_count <= ARRAY_SIZE(image_operands));
8647 val_id = vkd3d_spirv_build_op_image_fetch(builder, type_id,
8648 image.image_id, coordinate_id, operands_mask, image_operands, image_operand_count);
8649
8651 dst, val_id, image.sampled_type, src[1].swizzle);
8652}
static uint32_t vkd3d_spirv_build_op_image_fetch(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1690
@ SpvImageOperandsSampleMask
Definition: spirv.h:373
@ SpvImageOperandsLodMask
Definition: spirv.h:368
#define VKD3DSP_WRITEMASK_3
@ VKD3DSIH_LD2DMS

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_ld_raw_structured()

static void spirv_compiler_emit_ld_raw_structured ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9026 of file spirv.c.

9028{
9029 enum vkd3d_shader_register_type reg_type = instruction->src[instruction->src_count - 1].reg.type;
9030 switch (reg_type)
9031 {
9032 case VKD3DSPR_RESOURCE:
9033 case VKD3DSPR_UAV:
9035 break;
9038 break;
9039 default:
9040 ERR("Unexpected register type %#x.\n", reg_type);
9041 }
9042}
static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8986
static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8898
vkd3d_shader_register_type
@ VKD3DSPR_RESOURCE

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_ld_raw_structured_srv_uav()

static void spirv_compiler_emit_ld_raw_structured_srv_uav ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8898 of file spirv.c.

8900{
8901 uint32_t coordinate_id, type_id, val_id, texel_type_id, ptr_type_id, ptr_id;
8902 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8903 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8904 const struct vkd3d_shader_src_param *src = instruction->src;
8905 const struct vkd3d_shader_src_param *resource;
8906 const struct vkd3d_symbol *resource_symbol;
8907 uint32_t base_coordinate_id, component_idx;
8908 uint32_t constituents[VKD3D_VEC4_SIZE];
8910 bool storage_buffer_uav = false;
8911 uint32_t indices[2];
8912 unsigned int i, j;
8913 SpvOp op;
8914
8915 resource = &src[instruction->src_count - 1];
8916
8917 if (resource->reg.type == VKD3DSPR_UAV)
8918 {
8919 resource_symbol = spirv_compiler_find_resource(compiler, &resource->reg);
8920 storage_buffer_uav = spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource);
8921 }
8922
8923 if (storage_buffer_uav)
8924 {
8925 texel_type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
8926 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, texel_type_id);
8927
8929 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
8930 type_id, resource_symbol->info.resource.structure_stride,
8932
8933 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
8934 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
8935 {
8936 if (!(dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
8937 continue;
8938
8939 component_idx = vsir_swizzle_get_component(resource->swizzle, i);
8940 coordinate_id = base_coordinate_id;
8941 if (component_idx)
8942 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
8943 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
8944 indices[0] = spirv_compiler_get_constant_uint(compiler, 0);
8945 indices[1] = coordinate_id;
8946
8947 ptr_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, resource_symbol->id, indices, 2);
8948 constituents[j++] = vkd3d_spirv_build_op_load(builder, texel_type_id, ptr_id, SpvMemoryAccessMaskNone);
8949 }
8950 }
8951 else
8952 {
8953 if (resource->reg.type == VKD3DSPR_RESOURCE)
8955 else
8957
8959
8961 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
8962 type_id, image.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
8963
8964 texel_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE);
8965 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
8966 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
8967 {
8968 if (!(dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
8969 continue;
8970
8971 component_idx = vsir_swizzle_get_component(resource->swizzle, i);
8972 coordinate_id = base_coordinate_id;
8973 if (component_idx)
8974 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
8975 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
8976
8977 val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
8978 op, texel_type_id, image.image_id, coordinate_id);
8979 constituents[j++] = vkd3d_spirv_build_op_composite_extract1(builder,
8980 type_id, val_id, 0);
8981 }
8982 }
8984}
GLuint GLuint GLsizei GLenum const GLvoid * indices
Definition: gl.h:1545
@ SpvOpImageFetch
Definition: spirv.h:1281
@ SpvOpImageRead
Definition: spirv.h:1284

Referenced by spirv_compiler_emit_ld_raw_structured().

◆ spirv_compiler_emit_ld_tgsm()

static void spirv_compiler_emit_ld_tgsm ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8986 of file spirv.c.

8988{
8989 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8990 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8991 const struct vkd3d_shader_src_param *src = instruction->src;
8992 uint32_t coordinate_id, type_id, ptr_type_id, ptr_id;
8993 const struct vkd3d_shader_src_param *resource;
8995 uint32_t base_coordinate_id, component_idx;
8996 uint32_t constituents[VKD3D_VEC4_SIZE];
8997 unsigned int i, j;
8998
8999 resource = &src[instruction->src_count - 1];
9000 if (!spirv_compiler_get_register_info(compiler, &resource->reg, &reg_info))
9001 return;
9002
9004 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
9005 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
9006 type_id, reg_info.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
9007
9008 VKD3D_ASSERT(dst->write_mask & VKD3DSP_WRITEMASK_ALL);
9009 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
9010 {
9011 if (!(dst->write_mask & (VKD3DSP_WRITEMASK_0 << i)))
9012 continue;
9013
9014 component_idx = vsir_swizzle_get_component(resource->swizzle, i);
9015 coordinate_id = base_coordinate_id;
9016 if (component_idx)
9017 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
9018 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
9019
9020 ptr_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, reg_info.id, coordinate_id);
9021 constituents[j++] = vkd3d_spirv_build_op_load(builder, type_id, ptr_id, SpvMemoryAccessMaskNone);
9022 }
9024}

Referenced by spirv_compiler_emit_ld_raw_structured().

◆ spirv_compiler_emit_ld_uav_typed()

static void spirv_compiler_emit_ld_uav_typed ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9178 of file spirv.c.

9180{
9181 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9182 uint32_t coordinate_id, type_id, val_id, ptr_type_id, ptr_id;
9183 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9184 const struct vkd3d_shader_src_param *src = instruction->src;
9185 const struct vkd3d_symbol *resource_symbol;
9187 uint32_t coordinate_mask;
9188 uint32_t indices[2];
9189
9190 resource_symbol = spirv_compiler_find_resource(compiler, &src[1].reg);
9191
9192 if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
9193 {
9194 type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
9196 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
9197 indices[0] = spirv_compiler_get_constant_uint(compiler, 0);
9198 indices[1] = coordinate_id;
9199
9200 ptr_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, resource_symbol->id, indices, 2);
9201 val_id = vkd3d_spirv_build_op_load(builder, type_id, ptr_id, SpvMemoryAccessMaskNone);
9202
9204 resource_symbol->info.resource.sampled_type, src[1].swizzle);
9205 }
9206 else
9207 {
9209 type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE);
9210 coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1;
9211 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], coordinate_mask);
9212
9213 val_id = vkd3d_spirv_build_op_image_read(builder, type_id,
9214 image.image_id, coordinate_id, SpvImageOperandsMaskNone, NULL, 0);
9215
9217 dst, val_id, image.sampled_type, src[1].swizzle);
9218 }
9219}
static uint32_t vkd3d_spirv_build_op_image_read(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1699
@ SpvImageOperandsMaskNone
Definition: spirv.h:366

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_load_constant()

static uint32_t spirv_compiler_emit_load_constant ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  swizzle,
uint32_t  write_mask 
)
static

Definition at line 3985 of file spirv.c.

3987{
3988 unsigned int component_count = vsir_write_mask_component_count(write_mask);
3990 unsigned int i, j;
3991
3993
3994 if (reg->dimension == VSIR_DIMENSION_SCALAR)
3995 {
3996 for (i = 0; i < component_count; ++i)
3997 values[i] = convert_raw_constant32(reg->data_type, reg->u.immconst_u32[0]);
3998 }
3999 else
4000 {
4001 for (i = 0, j = 0; i < VKD3D_VEC4_SIZE; ++i)
4002 {
4003 if (write_mask & (VKD3DSP_WRITEMASK_0 << i))
4004 values[j++] = convert_raw_constant32(reg->data_type,
4005 reg->u.immconst_u32[vsir_swizzle_get_component(swizzle, i)]);
4006 }
4007 }
4008
4009 return spirv_compiler_get_constant(compiler,
4011}
GLuint GLenum swizzle
Definition: glext.h:9511
GLboolean GLenum GLenum GLvoid * values
Definition: glext.h:5666
@ VKD3DSPR_IMMCONST
@ VSIR_DIMENSION_SCALAR

Referenced by spirv_compiler_emit_load_reg().

◆ spirv_compiler_emit_load_constant64()

static uint32_t spirv_compiler_emit_load_constant64 ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  swizzle,
uint32_t  write_mask 
)
static

Definition at line 4013 of file spirv.c.

4015{
4016 unsigned int component_count = vsir_write_mask_component_count(write_mask);
4018 unsigned int i, j;
4019
4021
4022 if (reg->dimension == VSIR_DIMENSION_SCALAR)
4023 {
4024 for (i = 0; i < component_count; ++i)
4025 values[i] = *reg->u.immconst_u64;
4026 }
4027 else
4028 {
4029 for (i = 0, j = 0; i < VKD3D_DVEC2_SIZE; ++i)
4030 {
4031 if (write_mask & (VKD3DSP_WRITEMASK_0 << i))
4032 values[j++] = reg->u.immconst_u64[vsir_swizzle_get_component(swizzle, i)];
4033 }
4034 }
4035
4036 return spirv_compiler_get_constant64(compiler,
4038}
@ VKD3DSPR_IMMCONST64
#define VKD3D_DVEC2_SIZE

Referenced by spirv_compiler_emit_load_reg().

◆ spirv_compiler_emit_load_invocation_id()

static uint32_t spirv_compiler_emit_load_invocation_id ( struct spirv_compiler *  compiler)
static

Definition at line 5014 of file spirv.c.

5015{
5016 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5018
5019 id = spirv_compiler_get_invocation_id(compiler);
5022}
static uint32_t spirv_compiler_get_invocation_id(struct spirv_compiler *compiler)
Definition: spirv.c:5004

Referenced by spirv_compiler_emit_default_control_point_phase(), and spirv_compiler_emit_shader_epilogue_function().

◆ spirv_compiler_emit_load_reg()

static uint32_t spirv_compiler_emit_load_reg ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  swizzle,
uint32_t  write_mask 
)
static

Definition at line 4247 of file spirv.c.

4249{
4250 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4253 unsigned int component_count;
4254 uint32_t type_id, val_id;
4255 uint32_t val_write_mask;
4256
4257 if (reg->type == VKD3DSPR_IMMCONST)
4259 else if (reg->type == VKD3DSPR_IMMCONST64)
4261 else if (reg->type == VKD3DSPR_UNDEF)
4263 else if (reg->type == VKD3DSPR_PARAMETER)
4264 return spirv_compiler_emit_shader_parameter(compiler, reg->idx[0].offset,
4265 reg->data_type, reg->dimension == VSIR_DIMENSION_VEC4 ? 4 : 1);
4266
4269
4270 if (reg->type == VKD3DSPR_SSA)
4272
4274 {
4276 return vkd3d_spirv_get_op_undef(builder, type_id);
4277 }
4279
4280 val_write_mask = (data_type_is_64_bit(reg->data_type) && !component_type_is_64_bit(reg_info.component_type))
4282
4283 /* Intermediate value (no storage class). */
4284 if (reg_info.storage_class == SpvStorageClassMax)
4285 {
4286 val_id = reg_info.id;
4287 }
4288 else if (vsir_write_mask_component_count(val_write_mask) == 1)
4289 {
4291 }
4292 else
4293 {
4295 reg_info.component_type, vsir_write_mask_component_count(reg_info.write_mask));
4297 }
4298
4300 val_id = spirv_compiler_emit_swizzle(compiler,
4301 val_id, reg_info.write_mask, reg_info.component_type, swizzle, val_write_mask);
4302
4303 if (component_type != reg_info.component_type)
4304 {
4306 {
4307 if (reg_info.component_type != VKD3D_SHADER_COMPONENT_UINT)
4308 {
4310 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4311 }
4314 }
4315 else
4316 {
4318 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4319 }
4320 }
4321
4322 return val_id;
4323}
static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
Definition: spirv.c:4013
static uint32_t spirv_compiler_emit_load_ssa_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
Definition: spirv.c:4201
static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask, const struct vkd3d_shader_register_info *reg_info)
Definition: spirv.c:4053
static void spirv_compiler_emit_dereference_register(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, struct vkd3d_shader_register_info *register_info)
Definition: spirv.c:3686
static uint32_t spirv_compiler_emit_load_undef(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask)
Definition: spirv.c:4040
static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
Definition: spirv.c:3985
static uint32_t vkd3d_spirv_get_op_undef(struct vkd3d_spirv_builder *builder, uint32_t type_id)
Definition: spirv.c:1291
static uint32_t spirv_compiler_emit_shader_parameter(struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, enum vkd3d_data_type type, unsigned int component_count)
Definition: spirv.c:3458
@ SpvStorageClassMax
Definition: spirv.h:221
static bool data_type_is_64_bit(enum vkd3d_data_type data_type)
@ VKD3DSPR_PARAMETER
@ VKD3DSPR_UNDEF
@ VKD3DSPR_SSA
static bool component_type_is_64_bit(enum vkd3d_shader_component_type component_type)
@ VSIR_DIMENSION_VEC4
static uint32_t vsir_write_mask_32_from_64(uint32_t write_mask64)
static uint32_t vsir_swizzle_32_from_64(uint32_t swizzle64)

Referenced by spirv_compiler_emit_load_src().

◆ spirv_compiler_emit_load_scalar()

static uint32_t spirv_compiler_emit_load_scalar ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  swizzle,
uint32_t  write_mask,
const struct vkd3d_shader_register_info *  reg_info 
)
static

Definition at line 4053 of file spirv.c.

4056{
4057 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4058 uint32_t type_id, ptr_type_id, index, reg_id, val_id;
4059 unsigned int component_idx, reg_component_count;
4061 uint32_t skipped_component_mask;
4062
4065
4066 component_idx = vsir_write_mask_get_component_idx(write_mask);
4067 component_idx = vsir_swizzle_get_component(swizzle, component_idx);
4068 skipped_component_mask = ~reg_info->write_mask & ((VKD3DSP_WRITEMASK_0 << component_idx) - 1);
4069 if (skipped_component_mask)
4070 component_idx -= vsir_write_mask_component_count(skipped_component_mask);
4072
4073 reg_component_count = vsir_write_mask_component_count(reg_info->write_mask);
4074
4075 if (component_idx >= vsir_write_mask_component_count(reg_info->write_mask))
4076 {
4077 ERR("Invalid component_idx %u for register %#x, %u (write_mask %#x).\n",
4078 component_idx, reg->type, reg->idx[0].offset, reg_info->write_mask);
4079 }
4080
4081 type_id = vkd3d_spirv_get_type_id(builder, reg_info->component_type, 1);
4082 reg_id = reg_info->id;
4083 if (reg_component_count != 1)
4084 {
4085 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info->storage_class, type_id);
4086 index = spirv_compiler_get_constant_uint(compiler, component_idx);
4087 reg_id = vkd3d_spirv_build_op_in_bounds_access_chain1(builder, ptr_type_id, reg_id, index);
4088 }
4089
4090 val_id = vkd3d_spirv_build_op_load(builder, type_id, reg_id, SpvMemoryAccessMaskNone);
4091
4092 if (component_type != reg_info->component_type)
4093 {
4095 {
4096 if (reg_info->component_type != VKD3D_SHADER_COMPONENT_UINT)
4097 {
4099 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4100 }
4102 VKD3D_DATA_UINT, 1, val_id);
4103 }
4104 else
4105 {
4107 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4108 }
4109 }
4110
4111 return val_id;
4112}
#define index(s, c)
Definition: various.h:29
GLuint index
Definition: glext.h:6031
static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain1(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t index)
Definition: spirv.c:1316
static bool register_is_constant_or_undef(const struct vkd3d_shader_register *reg)

Referenced by spirv_compiler_emit_load_reg().

◆ spirv_compiler_emit_load_src()

static uint32_t spirv_compiler_emit_load_src ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_src_param *  src,
uint32_t  write_mask 
)
static

Definition at line 4393 of file spirv.c.

4395{
4396 uint32_t val_id;
4397
4398 val_id = spirv_compiler_emit_load_reg(compiler, &src->reg, src->swizzle, write_mask);
4399 return spirv_compiler_emit_src_modifier(compiler, &src->reg, write_mask, src->modifiers, val_id);
4400}
static uint32_t spirv_compiler_emit_src_modifier(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, enum vkd3d_shader_src_modifier modifier, uint32_t val_id)
Definition: spirv.c:4370
static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask)
Definition: spirv.c:4247

Referenced by spirv_compiler_emit_alu_instruction(), spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bool_cast(), spirv_compiler_emit_branch(), spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_conditional_branch(), spirv_compiler_emit_deriv_instruction(), spirv_compiler_emit_discard(), spirv_compiler_emit_dot(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_ext_glsl_instruction(), spirv_compiler_emit_f16tof32(), spirv_compiler_emit_f32tof16(), spirv_compiler_emit_float_comparison_instruction(), spirv_compiler_emit_ftoi(), spirv_compiler_emit_ftou(), spirv_compiler_emit_gather4(), spirv_compiler_emit_group_nonuniform_ballot(), spirv_compiler_emit_imad(), spirv_compiler_emit_imul(), spirv_compiler_emit_int_div(), spirv_compiler_emit_isfinite(), spirv_compiler_emit_ld(), spirv_compiler_emit_ld_uav_typed(), spirv_compiler_emit_load_src_with_type(), spirv_compiler_emit_lod(), spirv_compiler_emit_mov(), spirv_compiler_emit_movc(), spirv_compiler_emit_orderedness_instruction(), spirv_compiler_emit_quad_read_across(), spirv_compiler_emit_quad_read_lane_at(), spirv_compiler_emit_raw_structured_addressing(), spirv_compiler_emit_rcp(), spirv_compiler_emit_register_addressing(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_sample(), spirv_compiler_emit_sample_c(), spirv_compiler_emit_sample_position(), spirv_compiler_emit_sincos(), spirv_compiler_emit_store_tgsm(), spirv_compiler_emit_store_uav_raw_structured(), spirv_compiler_emit_store_uav_typed(), spirv_compiler_emit_swapc(), spirv_compiler_emit_switch(), spirv_compiler_emit_wave_alu_op(), spirv_compiler_emit_wave_bool_op(), spirv_compiler_emit_wave_read_lane_at(), and spirv_compiler_emit_wave_read_lane_first().

◆ spirv_compiler_emit_load_src_with_type()

static uint32_t spirv_compiler_emit_load_src_with_type ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_src_param *  src,
uint32_t  write_mask,
enum vkd3d_shader_component_type  component_type 
)
static

Definition at line 4402 of file spirv.c.

4404{
4405 struct vkd3d_shader_src_param src_param = *src;
4406
4408 return spirv_compiler_emit_load_src(compiler, &src_param, write_mask);
4409}
struct vkd3d_shader_register reg
static enum vkd3d_data_type vkd3d_data_type_from_component_type(enum vkd3d_shader_component_type component_type)

Referenced by spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bitfield_instruction(), and spirv_compiler_emit_store_uav_typed().

◆ spirv_compiler_emit_load_ssa_reg()

static uint32_t spirv_compiler_emit_load_ssa_reg ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
enum vkd3d_shader_component_type  component_type,
uint32_t  swizzle 
)
static

Definition at line 4201 of file spirv.c.

4204{
4205 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4206 enum vkd3d_shader_component_type reg_component_type;
4207 const struct ssa_register_info *ssa;
4208 unsigned int component_idx;
4209 uint32_t type_id, val_id;
4210
4212 val_id = ssa->id;
4213 if (!val_id)
4214 {
4215 /* Should only be from a missing instruction implementation. */
4216 VKD3D_ASSERT(compiler->failed);
4217 return 0;
4218 }
4220
4221 reg_component_type = vkd3d_component_type_from_data_type(ssa->data_type);
4222
4223 if (reg->dimension == VSIR_DIMENSION_SCALAR)
4224 {
4225 if (component_type != reg_component_type)
4226 {
4228 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4229 }
4230
4231 return val_id;
4232 }
4233
4234 if (component_type != reg_component_type)
4235 {
4236 /* Required for resource loads with sampled type int, because DXIL has no signedness.
4237 * Only 128-bit vector sizes are used. */
4239 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4240 }
4241
4243 component_idx = vsir_swizzle_get_component(swizzle, 0);
4244 return vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx);
4245}
static const struct ssa_register_info * spirv_compiler_get_ssa_register_info(const struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg)
Definition: spirv.c:4184
bool failed
Definition: spirv.c:2419
enum vkd3d_data_type data_type
Definition: spirv.c:2408
uint32_t id
Definition: spirv.c:2409

Referenced by spirv_compiler_emit_load_reg().

◆ spirv_compiler_emit_load_undef()

static uint32_t spirv_compiler_emit_load_undef ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask 
)
static

Definition at line 4040 of file spirv.c.

4042{
4043 unsigned int component_count = vsir_write_mask_component_count(write_mask);
4044 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4046
4048
4050 return vkd3d_spirv_get_op_undef(builder, type_id);
4051}

Referenced by spirv_compiler_emit_load_reg().

◆ spirv_compiler_emit_lod()

static void spirv_compiler_emit_lod ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8654 of file spirv.c.

8656{
8657 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8658 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8659 const struct vkd3d_shader_src_param *src = instruction->src;
8660 const struct vkd3d_shader_src_param *resource, *sampler;
8661 uint32_t type_id, coordinate_id, val_id;
8663
8665
8666 resource = &src[1];
8667 sampler = &src[2];
8670
8672 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL);
8673 val_id = vkd3d_spirv_build_op_image_query_lod(builder,
8674 type_id, image.sampled_image_id, coordinate_id);
8675
8677 dst, val_id, image.sampled_type, resource->swizzle);
8678}
static uint32_t vkd3d_spirv_build_op_image_query_lod(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id)
Definition: spirv.c:1754

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_main_prolog()

static void spirv_compiler_emit_main_prolog ( struct spirv_compiler *  compiler)
static

Definition at line 10183 of file spirv.c.

10184{
10186
10187 if (compiler->emit_point_size)
10189
10190 /* Maybe in the future we can try to shrink the size of the interlocked
10191 * section. */
10192 if (compiler->use_invocation_interlock)
10194}
static void vkd3d_spirv_build_op(struct vkd3d_spirv_stream *stream, SpvOp op)
Definition: spirv.c:695
static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *compiler)
Definition: spirv.c:6070
static void spirv_compiler_emit_point_size(struct spirv_compiler *compiler)
Definition: spirv.c:6770
@ SpvOpBeginInvocationInterlockEXT
Definition: spirv.h:1599
bool use_invocation_interlock
Definition: spirv.c:2470

Referenced by spirv_compiler_initialise_block().

◆ spirv_compiler_emit_merge()

static void spirv_compiler_emit_merge ( struct spirv_compiler *  compiler,
uint32_t  merge_block_id,
uint32_t  continue_block_id 
)
static

Definition at line 8269 of file spirv.c.

8271{
8272 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8273
8274 if (!merge_block_id)
8275 return;
8276
8277 merge_block_id = spirv_compiler_get_label_id(compiler, merge_block_id);
8278 if (!continue_block_id)
8279 {
8281 }
8282 else
8283 {
8284 continue_block_id = spirv_compiler_get_label_id(compiler, continue_block_id);
8285 vkd3d_spirv_build_op_loop_merge(builder, merge_block_id, continue_block_id, SpvLoopControlMaskNone);
8286 }
8287}
static void vkd3d_spirv_build_op_loop_merge(struct vkd3d_spirv_builder *builder, uint32_t merge_block, uint32_t continue_target, SpvLoopControlMask loop_control)
Definition: spirv.c:1427
@ SpvLoopControlMaskNone
Definition: spirv.h:719

Referenced by spirv_compiler_emit_branch(), and spirv_compiler_emit_switch().

◆ spirv_compiler_emit_mov()

static void spirv_compiler_emit_mov ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7443 of file spirv.c.

7445{
7446 uint32_t val_id, dst_val_id, type_id, dst_id, src_id, write_mask32, swizzle32;
7447 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7448 struct vkd3d_shader_register_info dst_reg_info, src_reg_info;
7449 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7450 const struct vkd3d_shader_src_param *src = instruction->src;
7451 unsigned int i, component_count, write_mask;
7453
7454 if (register_is_constant_or_undef(&src->reg) || src->reg.type == VKD3DSPR_SSA || dst->reg.type == VKD3DSPR_SSA
7455 || src->reg.type == VKD3DSPR_PARAMETER || dst->modifiers || src->modifiers)
7456 goto general_implementation;
7457
7458 spirv_compiler_get_register_info(compiler, &dst->reg, &dst_reg_info);
7459 spirv_compiler_get_register_info(compiler, &src->reg, &src_reg_info);
7460
7461 if (dst_reg_info.component_type != src_reg_info.component_type
7462 || dst_reg_info.write_mask != src_reg_info.write_mask)
7463 goto general_implementation;
7464
7465 if (vkd3d_swizzle_is_equal(dst_reg_info.write_mask, src->swizzle, src_reg_info.write_mask))
7466 {
7467 dst_id = spirv_compiler_get_register_id(compiler, &dst->reg);
7468 src_id = spirv_compiler_get_register_id(compiler, &src->reg);
7469
7471 return;
7472 }
7473
7474 write_mask32 = data_type_is_64_bit(dst->reg.data_type) ? vsir_write_mask_32_from_64(dst->write_mask) : dst->write_mask;
7475 swizzle32 = data_type_is_64_bit(src->reg.data_type) ? vsir_swizzle_32_from_64(src->swizzle) : src->swizzle;
7478 && dst_reg_info.write_mask == VKD3DSP_WRITEMASK_ALL)
7479 {
7480 dst_id = spirv_compiler_get_register_id(compiler, &dst->reg);
7481 src_id = spirv_compiler_get_register_id(compiler, &src->reg);
7482
7483 type_id = vkd3d_spirv_get_type_id(builder, dst_reg_info.component_type, VKD3D_VEC4_SIZE);
7484 val_id = vkd3d_spirv_build_op_load(builder, type_id, src_id, SpvMemoryAccessMaskNone);
7485 dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);
7486
7487 for (i = 0; i < ARRAY_SIZE(components); ++i)
7488 {
7489 if (write_mask32 & (VKD3DSP_WRITEMASK_0 << i))
7491 else
7492 components[i] = i;
7493 }
7494
7495 val_id = vkd3d_spirv_build_op_vector_shuffle(builder,
7496 type_id, dst_val_id, val_id, components, VKD3D_VEC4_SIZE);
7497
7498 vkd3d_spirv_build_op_store(builder, dst_id, val_id, SpvMemoryAccessMaskNone);
7499 return;
7500 }
7501
7502general_implementation:
7503 write_mask = dst->write_mask;
7504 if (src->reg.type == VKD3DSPR_IMMCONST64 && !data_type_is_64_bit(dst->reg.data_type))
7505 write_mask = vsir_write_mask_64_from_32(write_mask);
7506 else if (!data_type_is_64_bit(src->reg.data_type) && data_type_is_64_bit(dst->reg.data_type))
7507 write_mask = vsir_write_mask_32_from_64(write_mask);
7508
7509 val_id = spirv_compiler_emit_load_src(compiler, src, write_mask);
7510 if (dst->reg.data_type != src->reg.data_type)
7511 {
7513 dst->reg.data_type, vsir_write_mask_component_count(dst->write_mask)), val_id);
7514 }
7515 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7516}
static bool vkd3d_swizzle_is_equal(uint32_t dst_write_mask, uint32_t swizzle, uint32_t write_mask)
Definition: spirv.c:3764
static void vkd3d_spirv_build_op_store(struct vkd3d_spirv_builder *builder, uint32_t pointer_id, uint32_t object_id, uint32_t memory_access)
Definition: spirv.c:1375
static uint32_t vsir_write_mask_64_from_32(uint32_t write_mask32)

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_movc()

static void spirv_compiler_emit_movc ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7518 of file spirv.c.

7520{
7521 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7522 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7523 const struct vkd3d_shader_src_param *src = instruction->src;
7524 uint32_t condition_id, src1_id, src2_id, type_id, val_id;
7525 unsigned int component_count;
7526
7527 condition_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
7528 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
7529 src2_id = spirv_compiler_emit_load_src(compiler, &src[2], dst->write_mask);
7530
7533
7534 if (src[0].reg.data_type != VKD3D_DATA_BOOL)
7535 {
7537 condition_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, SpvOpFOrdGreaterThanEqual,
7540 else
7541 condition_id = spirv_compiler_emit_int_to_bool(compiler,
7542 VKD3D_SHADER_CONDITIONAL_OP_NZ, src[0].reg.data_type, component_count, condition_id);
7543 }
7544 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src1_id, src2_id);
7545
7546 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7547}
@ VKD3DSIH_CMP

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_neg()

static uint32_t spirv_compiler_emit_neg ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4354 of file spirv.c.

4356{
4357 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4359
4360 type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
4361 if (data_type_is_floating_point(reg->data_type))
4362 return vkd3d_spirv_build_op_fnegate(builder, type_id, val_id);
4363 else if (data_type_is_integer(reg->data_type))
4364 return vkd3d_spirv_build_op_snegate(builder, type_id, val_id);
4365
4366 FIXME("Unhandled data type %#x.\n", reg->data_type);
4367 return val_id;
4368}
static uint32_t vkd3d_spirv_build_op_fnegate(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1496
static uint32_t vkd3d_spirv_build_op_snegate(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1503
static bool data_type_is_integer(enum vkd3d_data_type data_type)

Referenced by spirv_compiler_emit_src_modifier().

◆ spirv_compiler_emit_orderedness_instruction()

static void spirv_compiler_emit_orderedness_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8055 of file spirv.c.

8057{
8058 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8059 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8060 const struct vkd3d_shader_src_param *src = instruction->src;
8061 uint32_t type_id, src0_id, src1_id, val_id;
8062
8064 src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
8065 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
8066 /* OpOrdered and OpUnordered are only available in Kernel mode. */
8067 src0_id = vkd3d_spirv_build_op_is_nan(builder, type_id, src0_id);
8068 src1_id = vkd3d_spirv_build_op_is_nan(builder, type_id, src1_id);
8069 val_id = vkd3d_spirv_build_op_logical_or(builder, type_id, src0_id, src1_id);
8071 val_id = vkd3d_spirv_build_op_logical_not(builder, type_id, val_id);
8072 spirv_compiler_emit_store_dst(compiler, dst, val_id);
8073}
static uint32_t vkd3d_spirv_build_op_logical_or(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1571
@ VKD3DSIH_ORD

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_output()

static void spirv_compiler_emit_output ( struct spirv_compiler *  compiler,
enum vkd3d_shader_register_type  reg_type,
unsigned int  element_idx 
)
static

Definition at line 5521 of file spirv.c.

5523{
5524 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5525 unsigned int component_idx, output_component_count;
5528 const struct shader_signature *shader_signature;
5529 const struct vkd3d_spirv_builtin *builtin;
5531 uint32_t write_mask;
5532 bool use_private_variable = false;
5533 struct vkd3d_symbol reg_symbol;
5535 unsigned int array_sizes[2];
5536 bool is_patch_constant;
5537 uint32_t id, var_id;
5538
5539 is_patch_constant = (reg_type == VKD3DSPR_PATCHCONST);
5540
5541 shader_signature = is_patch_constant ? &compiler->patch_constant_signature : &compiler->output_signature;
5542
5545 /* Don't use builtins for TCS -> TES varyings. See spirv_compiler_emit_input(). */
5546 if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL && !is_patch_constant)
5548 array_sizes[0] = signature_element->register_count;
5549 array_sizes[1] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->output_control_point_count);
5551 array_sizes[0] = 0;
5552
5554
5555 write_mask = signature_element->mask;
5556
5557 component_idx = vsir_write_mask_get_component_idx(write_mask);
5558 output_component_count = vsir_write_mask_component_count(write_mask);
5559 if (builtin)
5560 {
5561 component_type = builtin->component_type;
5562 if (!builtin->spirv_array_size)
5563 output_component_count = builtin->component_count;
5564 }
5565 else
5566 {
5568 }
5569
5571
5573 use_private_variable = true;
5574
5575 if (!is_patch_constant
5577 || (compiler->output_info[element_idx].id && compiler->output_info[element_idx].array_element_mask)))
5578 {
5579 use_private_variable = true;
5580 }
5581
5582 vkd3d_symbol_make_io(&reg_symbol, reg_type, element_idx);
5583
5584 if (rb_get(&compiler->symbol_table, &reg_symbol))
5585 {
5586 /* See spirv_compiler_emit_input() for possible causes. */
5587 FIXME("Duplicate output definition found.\n");
5588 return;
5589 }
5590
5591 if (!is_patch_constant && compiler->output_info[element_idx].id)
5592 {
5593 id = compiler->output_info[element_idx].id;
5594 }
5595 else if (builtin)
5596 {
5598 id = spirv_compiler_emit_shader_phase_builtin_variable(compiler, builtin, array_sizes, 2);
5599 else
5600 id = spirv_compiler_emit_builtin_variable_v(compiler, builtin, storage_class, array_sizes, 2);
5601
5603 }
5605 {
5607 id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
5608 storage_class, component_type, output_component_count, array_sizes, 2);
5609 }
5610 else
5611 {
5613
5614 if (is_patch_constant)
5616 else if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL
5619
5620 id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream,
5621 storage_class, component_type, output_component_count, array_sizes, 2);
5622 vkd3d_spirv_add_iface_variable(builder, id);
5623
5624 if (is_dual_source_blending(compiler) && location < 2)
5625 {
5628 }
5629 else
5630 {
5632 }
5633
5634 if (component_idx)
5635 vkd3d_spirv_build_op_decorate1(builder, id, SpvDecorationComponent, component_idx);
5636 }
5637
5638 if (is_patch_constant)
5640
5641 spirv_compiler_decorate_xfb_output(compiler, id, output_component_count, signature_element);
5642
5643 if (!is_patch_constant)
5644 {
5645 compiler->output_info[element_idx].id = id;
5646 compiler->output_info[element_idx].component_type = component_type;
5647 }
5648
5649 var_id = id;
5650 if (use_private_variable)
5651 {
5653 var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream,
5655 }
5656
5657 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
5658 use_private_variable ? VKD3D_SHADER_COMPONENT_FLOAT : component_type,
5659 use_private_variable ? VKD3DSP_WRITEMASK_ALL : write_mask);
5660 reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1];
5661 VKD3D_ASSERT(!builtin || !builtin->spirv_array_size || use_private_variable || array_sizes[0] || array_sizes[1]);
5662
5663 spirv_compiler_put_symbol(compiler, &reg_symbol);
5664
5665 vkd3d_spirv_build_op_name(builder, var_id, reg_type == VKD3DSPR_PATCHCONST ? "vpc%u" : "o%u", element_idx);
5666
5667 if (use_private_variable)
5668 {
5669 compiler->private_output_variable[element_idx] = var_id;
5670 compiler->private_output_variable_write_mask[element_idx] |= write_mask >> component_idx;
5671 if (!compiler->epilogue_function_id)
5672 compiler->epilogue_function_id = vkd3d_spirv_alloc_id(builder);
5673 }
5674}
static void spirv_compiler_emit_register_execution_mode(struct spirv_compiler *compiler, enum vkd3d_shader_register_type type)
Definition: spirv.c:4917
static void spirv_compiler_decorate_xfb_output(struct spirv_compiler *compiler, uint32_t id, unsigned int component_count, const struct signature_element *signature_element)
Definition: spirv.c:5060
static uint32_t spirv_compiler_emit_shader_phase_builtin_variable(struct spirv_compiler *compiler, const struct vkd3d_spirv_builtin *builtin, const unsigned int *array_sizes, unsigned int size_count)
Definition: spirv.c:5496
static const struct vkd3d_shader_phase * spirv_compiler_get_current_shader_phase(struct spirv_compiler *compiler)
Definition: spirv.c:5051
static unsigned int get_shader_output_swizzle(const struct spirv_compiler *compiler, unsigned int register_idx)
Definition: spirv.c:5360
static bool is_dual_source_blending(const struct spirv_compiler *compiler)
Definition: spirv.c:5372
static const struct vkd3d_spirv_builtin * vkd3d_get_spirv_builtin(const struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_sysval_semantic sysval)
Definition: spirv.c:4986
@ SpvDecorationIndex
Definition: spirv.h:477
unsigned int output_control_point_count
Definition: spirv.c:2467
uint32_t epilogue_function_id
Definition: spirv.c:2460
uint32_t private_output_variable[MAX_REG_OUTPUT+1]
Definition: spirv.c:2458
uint32_t private_output_variable_write_mask[MAX_REG_OUTPUT+1]
Definition: spirv.c:2459
#define SIGNATURE_TARGET_LOCATION_UNUSED

Referenced by spirv_compiler_emit_io_declarations().

◆ spirv_compiler_emit_output_register()

static void spirv_compiler_emit_output_register ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst 
)
static

Definition at line 5461 of file spirv.c.

5463{
5464 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5465 const struct vkd3d_shader_register *reg = &dst->reg;
5466 const struct vkd3d_spirv_builtin *builtin;
5467 struct vkd3d_symbol reg_symbol;
5468 uint32_t write_mask;
5469 uint32_t output_id;
5470
5471 VKD3D_ASSERT(!reg->idx_count || !reg->idx[0].rel_addr);
5472 VKD3D_ASSERT(reg->idx_count < 2);
5473
5474 if (reg->type == VKD3DSPR_RASTOUT && reg->idx[0].offset == VSIR_RASTOUT_POINT_SIZE)
5475 {
5477 }
5478 else if (!(builtin = get_spirv_builtin_for_register(reg->type)))
5479 {
5480 FIXME("Unhandled register %#x.\n", reg->type);
5481 return;
5482 }
5483
5485
5486 vkd3d_symbol_make_register(&reg_symbol, reg);
5487 write_mask = vkd3d_write_mask_from_component_count(builtin->component_count);
5488 vkd3d_symbol_set_register_info(&reg_symbol, output_id,
5489 SpvStorageClassOutput, builtin->component_type, write_mask);
5490 reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size;
5491 spirv_compiler_put_symbol(compiler, &reg_symbol);
5493 spirv_compiler_emit_register_debug_name(builder, output_id, reg);
5494}
static const struct vkd3d_spirv_builtin vkd3d_output_point_size_builtin
Definition: spirv.c:4879

Referenced by spirv_compiler_emit_dcl_output(), and spirv_compiler_emit_io_declarations().

◆ spirv_compiler_emit_output_vertex_count()

static void spirv_compiler_emit_output_vertex_count ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6732 of file spirv.c.

6734{
6736 SpvExecutionModeOutputVertices, instruction->declaration.count);
6737}
static void spirv_compiler_emit_execution_mode1(struct spirv_compiler *compiler, SpvExecutionMode mode, const uint32_t literal)
Definition: spirv.c:4334
@ SpvExecutionModeOutputVertices
Definition: spirv.h:145

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_point_size()

static void spirv_compiler_emit_point_size ( struct spirv_compiler *  compiler)
static

Definition at line 6770 of file spirv.c.

6771{
6772 if (compiler->program->has_point_size)
6773 return;
6774
6775 /* Set the point size. Point sprites are not supported in d3d10+, but
6776 * point primitives can still be used with e.g. stream output. Vulkan
6777 * requires the point size to always be explicitly defined when outputting
6778 * points.
6779 *
6780 * If shaderTessellationAndGeometryPointSize is disabled, we must not write
6781 * PointSize for tessellation and geometry shaders. In that case the point
6782 * size defaults to 1.0. */
6784 || compiler->write_tess_geom_point_size)
6785 {
6790 }
6791}

Referenced by spirv_compiler_emit_main_prolog().

◆ spirv_compiler_emit_push_constant_buffers()

static void spirv_compiler_emit_push_constant_buffers ( struct spirv_compiler *  compiler)
static

Definition at line 6070 of file spirv.c.

6071{
6072 unsigned int i, j, count, reg_idx, descriptor_offsets_member_idx = 0;
6074 uint32_t vec4_id, length_id, struct_id, pointer_type_id, var_id;
6075 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6076 struct vkd3d_symbol reg_symbol;
6077 uint32_t *member_ids;
6078
6079 count = !!compiler->offset_info.descriptor_table_count;
6080 for (i = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
6081 {
6082 const struct vkd3d_push_constant_buffer_binding *cb = &compiler->push_constants[i];
6083
6084 if (cb->reg.type)
6085 ++count;
6086 }
6087 if (!count)
6088 return;
6089
6090 if (!(member_ids = vkd3d_calloc(count, sizeof(*member_ids))))
6091 return;
6092
6094
6095 for (i = 0, j = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
6096 {
6097 const struct vkd3d_push_constant_buffer_binding *cb = &compiler->push_constants[i];
6098 if (!cb->reg.type)
6099 continue;
6100
6101 length_id = spirv_compiler_get_constant_uint(compiler, cb->size);
6102 member_ids[j] = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id);
6104
6105 ++j;
6106 }
6107
6108 if (compiler->offset_info.descriptor_table_count)
6109 {
6111 length_id = spirv_compiler_get_constant_uint(compiler, compiler->offset_info.descriptor_table_count);
6112 member_ids[j] = vkd3d_spirv_build_op_type_array(builder, type_id, length_id);
6114 descriptor_offsets_member_idx = j;
6116 VKD3D_ASSERT(j == count - 1);
6117 }
6118
6119 struct_id = vkd3d_spirv_build_op_type_struct(builder, member_ids, count);
6120 vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0);
6121 vkd3d_spirv_build_op_name(builder, struct_id, "push_cb_struct");
6122 vkd3d_free(member_ids);
6123
6124 pointer_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, struct_id);
6125 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6126 pointer_type_id, storage_class, 0);
6127 compiler->push_constants_var_id = var_id;
6128 vkd3d_spirv_build_op_name(builder, var_id, "push_cb");
6129
6130 for (i = 0, j = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
6131 {
6132 const struct vkd3d_push_constant_buffer_binding *cb = &compiler->push_constants[i];
6133 if (!cb->reg.type)
6134 continue;
6135
6136 reg_idx = cb->reg.idx[0].offset;
6137 vkd3d_spirv_build_op_member_decorate1(builder, struct_id, j,
6138 SpvDecorationOffset, cb->pc.offset);
6139 vkd3d_spirv_build_op_member_name(builder, struct_id, j, "cb%u", reg_idx);
6140
6141 vkd3d_symbol_make_register(&reg_symbol, &cb->reg);
6142 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
6144 reg_symbol.info.reg.member_idx = j;
6145 spirv_compiler_put_symbol(compiler, &reg_symbol);
6146
6147 ++j;
6148 }
6149 if (compiler->offset_info.descriptor_table_count)
6150 {
6151 vkd3d_spirv_build_op_member_decorate1(builder, struct_id, descriptor_offsets_member_idx,
6152 SpvDecorationOffset, compiler->offset_info.descriptor_table_offset);
6153 }
6154}
static MonoProfilerRuntimeShutdownBeginCallback cb
Definition: metahost.c:118
static void vkd3d_spirv_build_op_member_name(struct vkd3d_spirv_builder *builder, uint32_t type_id, uint32_t member, const char *fmt,...)
Definition: spirv.c:960
@ SpvStorageClassPushConstant
Definition: spirv.h:200
uint32_t descriptor_offsets_member_id
Definition: spirv.c:2436
uint32_t push_constants_var_id
Definition: spirv.c:2437

Referenced by spirv_compiler_emit_main_prolog().

◆ spirv_compiler_emit_quad_read_across()

static void spirv_compiler_emit_quad_read_across ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9952 of file spirv.c.

9954{
9955 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9956 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9957 const struct vkd3d_shader_src_param *src = instruction->src;
9958 uint32_t type_id, direction_type_id, direction_id, val_id;
9959
9960 type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type,
9962 direction_type_id = vkd3d_spirv_get_type_id_for_data_type(builder, VKD3D_DATA_UINT, 1);
9963 val_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
9965 direction_id = vkd3d_spirv_get_op_constant(builder, direction_type_id, direction_id);
9966 val_id = vkd3d_spirv_build_op_group_nonuniform_quad_swap(builder, type_id, val_id, direction_id);
9967
9968 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9969}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_swap(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t op_id)
Definition: spirv.c:1795
static uint32_t map_quad_read_across_direction(enum vkd3d_shader_opcode opcode)
Definition: spirv.c:9937

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_quad_read_lane_at()

static void spirv_compiler_emit_quad_read_lane_at ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9971 of file spirv.c.

9973{
9974 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9975 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9976 const struct vkd3d_shader_src_param *src = instruction->src;
9977 uint32_t type_id, val_id, lane_id;
9978
9980 {
9981 FIXME("Unsupported non-constant quad read lane index.\n");
9982 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_NOT_IMPLEMENTED,
9983 "Non-constant quad read lane indices are not supported.");
9984 return;
9985 }
9986
9987 type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type,
9989 val_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
9990 lane_id = spirv_compiler_emit_load_src(compiler, &src[1], VKD3DSP_WRITEMASK_0);
9991 val_id = vkd3d_spirv_build_op_group_nonuniform_quad_broadcast(builder, type_id, val_id, lane_id);
9992
9993 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9994}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_broadcast(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t index_id)
Definition: spirv.c:1803

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_query_sample_count()

static uint32_t spirv_compiler_emit_query_sample_count ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_src_param *  src 
)
static

Definition at line 9632 of file spirv.c.

9634{
9635 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9637 uint32_t type_id, val_id;
9638
9639 if (src->reg.type == VKD3DSPR_RASTERIZER)
9640 {
9641 val_id = spirv_compiler_emit_shader_parameter(compiler,
9643 }
9644 else
9645 {
9647
9650 val_id = vkd3d_spirv_build_op_image_query_samples(builder, type_id, image.image_id);
9651 }
9652
9653 return val_id;
9654}
static uint32_t vkd3d_spirv_build_op_image_query_samples(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
Definition: spirv.c:1747
@ VKD3D_SHADER_PARAMETER_NAME_RASTERIZER_SAMPLE_COUNT
Definition: vkd3d_shader.h:540
@ VKD3DSPR_RASTERIZER

Referenced by spirv_compiler_emit_sample_info(), and spirv_compiler_emit_sample_position().

◆ spirv_compiler_emit_raw_structured_addressing()

static uint32_t spirv_compiler_emit_raw_structured_addressing ( struct spirv_compiler *  compiler,
uint32_t  type_id,
unsigned int  stride,
const struct vkd3d_shader_src_param *  src0,
uint32_t  src0_mask,
const struct vkd3d_shader_src_param *  src1,
uint32_t  src1_mask 
)
static

Definition at line 8869 of file spirv.c.

8873{
8874 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8875 const struct vkd3d_shader_src_param *offset;
8876 uint32_t structure_id = 0, offset_id;
8877 uint32_t offset_write_mask;
8878
8879 if (stride)
8880 {
8881 structure_id = spirv_compiler_emit_load_src(compiler, src0, src0_mask);
8882 structure_id = vkd3d_spirv_build_op_imul(builder, type_id,
8883 structure_id, spirv_compiler_get_constant_uint(compiler, stride));
8884 }
8885 offset = stride ? src1 : src0;
8886 offset_write_mask = stride ? src1_mask : src0_mask;
8887
8888 offset_id = spirv_compiler_emit_load_src(compiler, offset, offset_write_mask);
8890 offset_id, spirv_compiler_get_constant_uint(compiler, 2));
8891
8892 if (structure_id)
8893 return vkd3d_spirv_build_op_iadd(builder, type_id, structure_id, offset_id);
8894 else
8895 return offset_id;
8896}
static uint32_t vkd3d_spirv_build_op_shift_right_logical(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base, uint32_t shift)
Definition: spirv.c:1524

Referenced by spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_ld_tgsm(), spirv_compiler_emit_store_tgsm(), and spirv_compiler_emit_store_uav_raw_structured().

◆ spirv_compiler_emit_rcp()

static void spirv_compiler_emit_rcp ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7616 of file spirv.c.

7618{
7619 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7620 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7621 const struct vkd3d_shader_src_param *src = instruction->src;
7622 uint32_t type_id, src_id, val_id, div_id;
7623 unsigned int component_count;
7624
7627
7628 src_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
7629 if (src->reg.data_type == VKD3D_DATA_DOUBLE)
7631 else
7633 val_id = vkd3d_spirv_build_op_fdiv(builder, type_id, div_id, src_id);
7634 spirv_compiler_emit_store_dst(compiler, dst, val_id);
7635}

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_register_addressing()

static uint32_t spirv_compiler_emit_register_addressing ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_index *  reg_index 
)
static

Definition at line 3523 of file spirv.c.

3525{
3526 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3527 uint32_t type_id, addr_id;
3528
3529 if (!reg_index->rel_addr)
3530 return spirv_compiler_get_constant_uint(compiler, reg_index->offset);
3531
3532 addr_id = spirv_compiler_emit_load_src(compiler, reg_index->rel_addr, VKD3DSP_WRITEMASK_0);
3533 if (reg_index->offset)
3534 {
3536 addr_id = vkd3d_spirv_build_op_iadd(builder, type_id,
3537 addr_id, spirv_compiler_get_constant_uint(compiler, reg_index->offset));
3538 }
3539 return addr_id;
3540}
struct vkd3d_shader_src_param * rel_addr

Referenced by spirv_compiler_emit_dereference_register(), and spirv_compiler_get_descriptor_index().

◆ spirv_compiler_emit_register_debug_name()

static void spirv_compiler_emit_register_debug_name ( struct vkd3d_spirv_builder *  builder,
uint32_t  id,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 3278 of file spirv.c.

3280{
3281 char debug_name[256];
3282 if (spirv_compiler_get_register_name(debug_name, ARRAY_SIZE(debug_name), reg))
3283 vkd3d_spirv_build_op_name(builder, id, "%s", debug_name);
3284}
static bool spirv_compiler_get_register_name(char *buffer, unsigned int buffer_size, const struct vkd3d_shader_register *reg)
Definition: spirv.c:3177

Referenced by spirv_compiler_build_descriptor_variable(), spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_input_register(), spirv_compiler_emit_output_register(), and spirv_compiler_emit_workgroup_memory().

◆ spirv_compiler_emit_register_execution_mode()

static void spirv_compiler_emit_register_execution_mode ( struct spirv_compiler *  compiler,
enum vkd3d_shader_register_type  type 
)
static

Definition at line 4917 of file spirv.c.

4919{
4920 switch (type)
4921 {
4924 break;
4927 break;
4931 {
4932 FIXME("The target environment does not support stencil export.\n");
4933 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
4934 "Cannot export stencil reference value. "
4935 "The target environment does not support stencil export.");
4936 }
4939 break;
4940 default:
4941 return;
4942 }
4943}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
@ SpvExecutionModeStencilRefReplacingEXT
Definition: spirv.h:165
@ SpvExecutionModeDepthLess
Definition: spirv.h:134
@ SpvExecutionModeDepthGreater
Definition: spirv.h:133
@ SpvCapabilityStencilExportEXT
Definition: spirv.h:974
@ VKD3D_SHADER_SPIRV_EXTENSION_EXT_STENCIL_EXPORT
@ VKD3DSPR_DEPTHOUTGE
@ VKD3DSPR_DEPTHOUTLE
@ VKD3DSPR_OUTSTENCILREF

Referenced by spirv_compiler_emit_output(), and spirv_compiler_emit_output_register().

◆ spirv_compiler_emit_resinfo()

static void spirv_compiler_emit_resinfo ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9565 of file spirv.c.

9567{
9568 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9569 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9570 const struct vkd3d_shader_src_param *src = instruction->src;
9571 uint32_t type_id, lod_id, val_id, miplevel_count_id;
9573 uint32_t constituents[VKD3D_VEC4_SIZE];
9574 unsigned int i, size_component_count;
9576 bool supports_mipmaps;
9577
9579
9581 size_component_count = image.resource_type_info->coordinate_component_count;
9582 if (image.resource_type_info->dim == SpvDimCube)
9583 --size_component_count;
9584 type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, size_component_count);
9585
9586 supports_mipmaps = src[1].reg.type != VKD3DSPR_UAV && !image.resource_type_info->ms;
9587 if (supports_mipmaps)
9588 {
9589 lod_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
9590 val_id = vkd3d_spirv_build_op_image_query_size_lod(builder, type_id, image.image_id, lod_id);
9592 miplevel_count_id = vkd3d_spirv_build_op_image_query_levels(builder, type_id, image.image_id);
9593 }
9594 else
9595 {
9596 val_id = vkd3d_spirv_build_op_image_query_size(builder, type_id, image.image_id);
9597 /* For UAVs the returned miplevel count is always 1. */
9598 miplevel_count_id = spirv_compiler_get_constant_uint(compiler, 1);
9599 }
9600
9601 constituents[0] = val_id;
9602 for (i = 0; i < 3 - size_component_count; ++i)
9603 constituents[i + 1] = spirv_compiler_get_constant_uint(compiler, 0);
9604 constituents[i + 1] = miplevel_count_id;
9607 type_id, constituents, i + 2);
9608
9610
9612 if (instruction->flags == VKD3DSI_RESINFO_UINT)
9613 {
9614 /* SSA registers must match the specified result type. */
9615 if (!register_is_ssa(&dst->reg))
9616 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
9617 else
9619 }
9620 else
9621 {
9622 if (instruction->flags)
9623 FIXME("Unhandled flags %#x.\n", instruction->flags);
9624 val_id = vkd3d_spirv_build_op_convert_utof(builder, type_id, val_id);
9625 }
9626 val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL,
9627 component_type, src[1].swizzle, dst->write_mask);
9628
9629 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9630}
static uint32_t vkd3d_spirv_build_op_image_query_levels(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id)
Definition: spirv.c:1740
static uint32_t vkd3d_spirv_build_op_convert_utof(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t unsigned_value)
Definition: spirv.c:1584
static uint32_t vkd3d_spirv_build_op_image_query_size_lod(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t lod_id)
Definition: spirv.c:1726
#define VKD3DSI_RESINFO_UINT
static bool register_is_ssa(const struct vkd3d_shader_register *reg)

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_resource_declaration()

static void spirv_compiler_emit_resource_declaration ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range,
const struct vkd3d_shader_descriptor_info1 *  descriptor 
)
static

Definition at line 6524 of file spirv.c.

6526{
6528 enum vkd3d_shader_resource_type resource_type = descriptor->resource_type;
6529 struct vkd3d_descriptor_variable_info var_info, counter_var_info = {0};
6530 bool is_uav = descriptor->type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
6531 unsigned int structure_stride = descriptor->structure_stride / 4;
6532 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6534 uint32_t counter_type_id, type_id, var_id, counter_var_id = 0;
6536 unsigned int sample_count = descriptor->sample_count;
6537 enum vkd3d_shader_component_type sampled_type;
6538 struct vkd3d_symbol resource_symbol;
6540
6542 reg.idx[0].offset = descriptor->register_id;
6543
6544 if (resource_type == VKD3D_SHADER_RESOURCE_TEXTURE_2DMS && sample_count == 1)
6545 resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D;
6546 else if (resource_type == VKD3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY && sample_count == 1)
6548
6550 resource_type, is_uav)))
6551 {
6552 FIXME("Unrecognized resource type.\n");
6553 return;
6554 }
6555
6556 sampled_type = vkd3d_component_type_from_resource_data_type(descriptor->resource_data_type);
6557
6559 {
6561 resource_type, sampled_type, structure_stride, raw, resource_type_info);
6562 return;
6563 }
6564
6565 if (compiler->ssbo_uavs && is_uav && resource_type == VKD3D_SHADER_RESOURCE_BUFFER)
6566 {
6567 uint32_t array_type_id, struct_id;
6568
6569 type_id = vkd3d_spirv_get_type_id(builder, sampled_type, 1);
6570
6571 array_type_id = vkd3d_spirv_get_op_type_runtime_array(builder, type_id);
6572 vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 4);
6573
6574 struct_id = vkd3d_spirv_build_op_type_struct(builder, &array_type_id, 1);
6577
6578 type_id = struct_id;
6580 }
6581 else
6582 {
6584 resource_type_info, sampled_type, structure_stride || raw);
6585 }
6586
6588 type_id, &reg, range, resource_type, descriptor, false, &var_info);
6589
6590 if (is_uav)
6591 {
6593 {
6594 if (compiler->shader_type != VKD3D_SHADER_TYPE_PIXEL)
6595 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
6596 "Rasteriser-ordered views are only supported in fragment shaders.");
6599 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE,
6600 "Cannot enable fragment shader interlock. "
6601 "The target environment does not support fragment shader interlock.");
6602 else
6603 compiler->use_invocation_interlock = true;
6604 }
6605
6607 {
6608 VKD3D_ASSERT(structure_stride); /* counters are valid only for structured buffers */
6609
6610 counter_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1);
6611 if (spirv_compiler_is_opengl_target(compiler))
6612 {
6615 type_id = counter_type_id;
6616 }
6617 else if (compiler->ssbo_uavs)
6618 {
6619 uint32_t length_id, array_type_id, struct_id;
6620
6621 length_id = spirv_compiler_get_constant_uint(compiler, 1);
6622 array_type_id = vkd3d_spirv_build_op_type_array(builder, counter_type_id, length_id);
6623 vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 4);
6624
6625 struct_id = vkd3d_spirv_build_op_type_struct(builder, &array_type_id, 1);
6628
6630 type_id = struct_id;
6631 }
6632
6634 type_id, &reg, range, resource_type, descriptor, true, &counter_var_info);
6635 }
6636 }
6637
6638 vkd3d_symbol_make_resource(&resource_symbol, &reg);
6639 resource_symbol.id = var_id;
6640 resource_symbol.descriptor_array = var_info.array_symbol;
6641 resource_symbol.info.resource.range = *range;
6642 resource_symbol.info.resource.sampled_type = sampled_type;
6643 resource_symbol.info.resource.type_id = type_id;
6644 resource_symbol.info.resource.resource_type_info = resource_type_info;
6645 resource_symbol.info.resource.structure_stride = structure_stride;
6646 resource_symbol.info.resource.raw = raw;
6647 resource_symbol.info.resource.binding_base_idx = var_info.binding_base_idx;
6648 resource_symbol.info.resource.uav_counter_id = counter_var_id;
6649 resource_symbol.info.resource.uav_counter_array = counter_var_info.array_symbol;
6650 resource_symbol.info.resource.uav_counter_base_idx = counter_var_info.binding_base_idx;
6651 spirv_compiler_put_symbol(compiler, &resource_symbol);
6652}
static const struct vkd3d_spirv_resource_type * spirv_compiler_enable_resource_type(struct spirv_compiler *compiler, enum vkd3d_shader_resource_type resource_type, bool is_uav)
Definition: spirv.c:6382
static bool spirv_compiler_has_combined_sampler_for_resource(const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
Definition: spirv.c:2797
static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource, const struct vkd3d_shader_register_range *resource_range, enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_component_type sampled_type, unsigned int structure_stride, bool raw, const struct vkd3d_spirv_resource_type *resource_type_info)
Definition: spirv.c:6449
static void vkd3d_symbol_make_resource(struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
Definition: spirv.c:2324
@ SpvStorageClassAtomicCounter
Definition: spirv.h:201
@ SpvDecorationBufferBlock
Definition: spirv.h:449
@ SpvCapabilityAtomicStorage
Definition: spirv.h:890
const struct vkd3d_symbol * array_symbol
Definition: spirv.c:6178
unsigned int binding_base_idx
Definition: spirv.c:6179
@ VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_RAW_BUFFER
@ VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_COUNTER
@ VKD3D_SHADER_SPIRV_EXTENSION_EXT_FRAGMENT_SHADER_INTERLOCK
vkd3d_shader_resource_type
@ VKD3D_SHADER_RESOURCE_TEXTURE_2DARRAY
@ VKD3D_SHADER_RESOURCE_TEXTURE_2DMS
@ VKD3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY
@ VKD3D_SHADER_RESOURCE_TEXTURE_2D
static enum vkd3d_shader_component_type vkd3d_component_type_from_resource_data_type(enum vkd3d_shader_resource_data_type data_type)

Referenced by spirv_compiler_emit_descriptor_declarations().

◆ spirv_compiler_emit_retc()

static void spirv_compiler_emit_retc ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8155 of file spirv.c.

8157{
8158 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8159 uint32_t target_id, merge_block_id;
8160
8161 target_id = vkd3d_spirv_alloc_id(builder);
8162 merge_block_id = spirv_compiler_emit_conditional_branch(compiler, instruction, target_id);
8163
8164 vkd3d_spirv_build_op_label(builder, target_id);
8166 vkd3d_spirv_build_op_label(builder, merge_block_id);
8167}
static uint32_t spirv_compiler_emit_conditional_branch(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction, uint32_t target_block_id)
Definition: spirv.c:8105
static void spirv_compiler_emit_return(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8140

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_return()

static void spirv_compiler_emit_return ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8140 of file spirv.c.

8142{
8143 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8144
8145 if (compiler->use_invocation_interlock)
8147
8148 if (compiler->shader_type != VKD3D_SHADER_TYPE_GEOMETRY && (is_in_default_phase(compiler)
8149 || is_in_control_point_phase(compiler)))
8151
8153}
static void spirv_compiler_end_invocation_interlock(struct spirv_compiler *compiler)
Definition: spirv.c:8123
static bool is_in_default_phase(const struct spirv_compiler *compiler)
Definition: spirv.c:2500
static bool is_in_control_point_phase(const struct spirv_compiler *compiler)
Definition: spirv.c:2505

Referenced by spirv_compiler_emit_retc(), and spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_sample()

static void spirv_compiler_emit_sample ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8680 of file spirv.c.

8682{
8683 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8684 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8685 const struct vkd3d_shader_src_param *src = instruction->src;
8686 const struct vkd3d_shader_src_param *resource, *sampler;
8687 unsigned int image_operand_count = 0, component_count;
8688 uint32_t sampled_type_id, coordinate_id, val_id;
8689 SpvImageOperandsMask operands_mask = 0;
8691 uint32_t image_operands[3];
8692 uint32_t coordinate_mask;
8693 SpvOp op;
8694
8695 resource = &src[1];
8696 sampler = &src[2];
8699
8700 switch (instruction->opcode)
8701 {
8702 case VKD3DSIH_SAMPLE:
8704 break;
8705 case VKD3DSIH_SAMPLE_B:
8707 operands_mask |= SpvImageOperandsBiasMask;
8708 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8710 break;
8713 operands_mask |= SpvImageOperandsGradMask;
8714 component_count = image.resource_type_info->coordinate_component_count - image.resource_type_info->arrayed;
8715 coordinate_mask = (1u << component_count) - 1;
8716 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8717 &src[3], coordinate_mask);
8718 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8719 &src[4], coordinate_mask);
8720 break;
8723 operands_mask |= SpvImageOperandsLodMask;
8724 image_operands[image_operand_count++] = spirv_compiler_emit_load_src(compiler,
8726 break;
8727 default:
8728 ERR("Unexpected instruction %#x.\n", instruction->opcode);
8729 return;
8730 }
8731
8733 {
8734 operands_mask |= SpvImageOperandsConstOffsetMask;
8735 image_operands[image_operand_count++] = spirv_compiler_emit_texel_offset(compiler,
8736 instruction, image.resource_type_info);
8737 }
8738
8739 sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE);
8740 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL);
8741 VKD3D_ASSERT(image_operand_count <= ARRAY_SIZE(image_operands));
8742 val_id = vkd3d_spirv_build_op_image_sample(builder, op, sampled_type_id,
8743 image.sampled_image_id, coordinate_id, operands_mask, image_operands, image_operand_count);
8744
8746 dst, val_id, image.sampled_type, resource->swizzle);
8747}
static uint32_t vkd3d_spirv_build_op_image_sample(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1642
@ SpvImageOperandsBiasMask
Definition: spirv.h:367
@ SpvImageOperandsGradMask
Definition: spirv.h:369
@ SpvOpImageSampleExplicitLod
Definition: spirv.h:1274
@ SpvOpImageSampleImplicitLod
Definition: spirv.h:1273
@ VKD3DSIH_SAMPLE
@ VKD3DSIH_SAMPLE_LOD
@ VKD3DSIH_SAMPLE_B
@ VKD3DSIH_SAMPLE_GRAD

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_sample_c()

static void spirv_compiler_emit_sample_c ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8749 of file spirv.c.

8751{
8752 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8753 const struct vkd3d_shader_dst_param *dst = instruction->dst;
8754 const struct vkd3d_shader_src_param *src = instruction->src;
8755 uint32_t sampled_type_id, coordinate_id, dref_id, val_id;
8756 SpvImageOperandsMask operands_mask = 0;
8757 unsigned int image_operand_count = 0;
8759 uint32_t image_operands[2];
8760 SpvOp op;
8761
8763 {
8765 operands_mask |= SpvImageOperandsLodMask;
8766 image_operands[image_operand_count++]
8767 = spirv_compiler_get_constant_float(compiler, 0.0f);
8768 }
8769 else
8770 {
8772 }
8773
8776
8778 {
8779 operands_mask |= SpvImageOperandsConstOffsetMask;
8780 image_operands[image_operand_count++] = spirv_compiler_emit_texel_offset(compiler,
8781 instruction, image.resource_type_info);
8782 }
8783
8784 sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, 1);
8785 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL);
8786 dref_id = spirv_compiler_emit_load_src(compiler, &src[3], VKD3DSP_WRITEMASK_0);
8787 val_id = vkd3d_spirv_build_op_image_sample_dref(builder, op, sampled_type_id,
8788 image.sampled_image_id, coordinate_id, dref_id, operands_mask,
8789 image_operands, image_operand_count);
8790
8792 dst, val_id, image.sampled_type, src[1].swizzle);
8793}
static uint32_t vkd3d_spirv_build_op_image_sample_dref(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t dref_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1657
static void spirv_compiler_emit_store_dst_scalar(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, enum vkd3d_shader_component_type component_type, uint32_t swizzle)
Definition: spirv.c:4617
@ SpvOpImageSampleDrefImplicitLod
Definition: spirv.h:1275
@ SpvOpImageSampleDrefExplicitLod
Definition: spirv.h:1276
@ VKD3DSIH_SAMPLE_C_LZ

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_sample_info()

static void spirv_compiler_emit_sample_info ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9656 of file spirv.c.

9658{
9659 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9660 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9661 const struct vkd3d_shader_src_param *src = instruction->src;
9662 uint32_t constituents[VKD3D_VEC4_SIZE];
9663 uint32_t type_id, val_id;
9664 unsigned int i;
9665
9666 val_id = spirv_compiler_emit_query_sample_count(compiler, src);
9667
9668 constituents[0] = val_id;
9669 for (i = 1; i < VKD3D_VEC4_SIZE; ++i)
9670 constituents[i] = spirv_compiler_get_constant_uint(compiler, 0);
9672 val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, constituents, VKD3D_VEC4_SIZE);
9673
9676 {
9677 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
9678 }
9679 else
9680 {
9681 if (instruction->flags)
9682 FIXME("Unhandled flags %#x.\n", instruction->flags);
9683 val_id = vkd3d_spirv_build_op_convert_utof(builder, type_id, val_id);
9684 }
9685
9686 val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL,
9687 VKD3D_SHADER_COMPONENT_FLOAT, src->swizzle, dst->write_mask);
9688
9689 spirv_compiler_emit_store_dst(compiler, dst, val_id);
9690}
static uint32_t spirv_compiler_emit_query_sample_count(struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src)
Definition: spirv.c:9632
#define VKD3DSI_SAMPLE_INFO_UINT

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_sample_position()

static void spirv_compiler_emit_sample_position ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9693 of file spirv.c.

9695{
9696 /* Standard sample locations from the Vulkan spec. */
9697 static const float standard_sample_positions[][2] =
9698 {
9699 /* 1 sample */
9700 { 0.0 / 16.0, 0.0 / 16.0},
9701 /* 2 samples */
9702 { 4.0 / 16.0, 4.0 / 16.0},
9703 {-4.0 / 16.0, -4.0 / 16.0},
9704 /* 4 samples */
9705 {-2.0 / 16.0, -6.0 / 16.0},
9706 { 6.0 / 16.0, -2.0 / 16.0},
9707 {-6.0 / 16.0, 2.0 / 16.0},
9708 { 2.0 / 16.0, 6.0 / 16.0},
9709 /* 8 samples */
9710 { 1.0 / 16.0, -3.0 / 16.0},
9711 {-1.0 / 16.0, 3.0 / 16.0},
9712 { 5.0 / 16.0, 1.0 / 16.0},
9713 {-3.0 / 16.0, -5.0 / 16.0},
9714 {-5.0 / 16.0, 5.0 / 16.0},
9715 {-7.0 / 16.0, -1.0 / 16.0},
9716 { 3.0 / 16.0, 7.0 / 16.0},
9717 { 7.0 / 16.0, -7.0 / 16.0},
9718 /* 16 samples */
9719 { 1.0 / 16.0, 1.0 / 16.0},
9720 {-1.0 / 16.0, -3.0 / 16.0},
9721 {-3.0 / 16.0, 2.0 / 16.0},
9722 { 4.0 / 16.0, -1.0 / 16.0},
9723 {-5.0 / 16.0, -2.0 / 16.0},
9724 { 2.0 / 16.0, 5.0 / 16.0},
9725 { 5.0 / 16.0, 3.0 / 16.0},
9726 { 3.0 / 16.0, -5.0 / 16.0},
9727 {-2.0 / 16.0, 6.0 / 16.0},
9728 { 0.0 / 16.0, -7.0 / 16.0},
9729 {-4.0 / 16.0, -6.0 / 16.0},
9730 {-6.0 / 16.0, 4.0 / 16.0},
9731 {-8.0 / 16.0, 0.0 / 16.0},
9732 { 7.0 / 16.0, -4.0 / 16.0},
9733 { 6.0 / 16.0, 7.0 / 16.0},
9734 {-7.0 / 16.0, -8.0 / 16.0},
9735 };
9736 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9737 uint32_t constituents[ARRAY_SIZE(standard_sample_positions)];
9738 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9739 uint32_t array_type_id, length_id, index_id, id;
9740 uint32_t sample_count_id, sample_index_id;
9741 uint32_t type_id, bool_id, ptr_type_id;
9742 unsigned int i;
9743
9744 sample_count_id = spirv_compiler_emit_query_sample_count(compiler, &instruction->src[0]);
9745 sample_index_id = spirv_compiler_emit_load_src(compiler, &instruction->src[1], VKD3DSP_WRITEMASK_0);
9746
9748 index_id = vkd3d_spirv_build_op_iadd(builder, type_id, sample_count_id, sample_index_id);
9749 index_id = vkd3d_spirv_build_op_isub(builder,
9750 type_id, index_id, spirv_compiler_get_constant_uint(compiler, 1));
9751
9752 /* Validate sample index. */
9754 id = vkd3d_spirv_build_op_logical_and(builder, bool_id,
9755 vkd3d_spirv_build_op_uless_than(builder, bool_id, sample_index_id, sample_count_id),
9757 bool_id, sample_index_id, spirv_compiler_get_constant_uint(compiler, 16)));
9758 index_id = vkd3d_spirv_build_op_select(builder, type_id,
9759 id, index_id, spirv_compiler_get_constant_uint(compiler, 0));
9760
9762 if (!(id = compiler->sample_positions_id))
9763 {
9764 length_id = spirv_compiler_get_constant_uint(compiler, ARRAY_SIZE(standard_sample_positions));
9765 array_type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
9766
9767 for (i = 0; i < ARRAY_SIZE(standard_sample_positions); ++ i)
9768 {
9769 constituents[i] = spirv_compiler_get_constant(compiler,
9770 VKD3D_SHADER_COMPONENT_FLOAT, 2, (const uint32_t *)standard_sample_positions[i]);
9771 }
9772
9773 id = vkd3d_spirv_build_op_constant_composite(builder, array_type_id, constituents, ARRAY_SIZE(constituents));
9774 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, array_type_id);
9775 id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream, ptr_type_id, SpvStorageClassPrivate, id);
9776 vkd3d_spirv_build_op_name(builder, id, "sample_pos");
9777 compiler->sample_positions_id = id;
9778 }
9779
9781 id = vkd3d_spirv_build_op_in_bounds_access_chain1(builder, ptr_type_id, id, index_id);
9783
9785 VKD3D_SHADER_COMPONENT_FLOAT, instruction->src[0].swizzle, dst->write_mask);
9786 spirv_compiler_emit_store_dst(compiler, dst, id);
9787}
static uint32_t vkd3d_spirv_build_op_uless_than(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1538
static uint32_t vkd3d_spirv_build_op_logical_and(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1531
static uint32_t vkd3d_spirv_build_op_uless_than_equal(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:1545
uint32_t sample_positions_id
Definition: spirv.c:2430

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_sampler_declaration()

static void spirv_compiler_emit_sampler_declaration ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range,
const struct vkd3d_shader_descriptor_info1 *  descriptor 
)
static

Definition at line 6350 of file spirv.c.

6352{
6354 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6357 struct vkd3d_symbol reg_symbol;
6358 uint32_t type_id, var_id;
6359
6361 reg.idx[0].offset = descriptor->register_id;
6362
6363 vkd3d_symbol_make_sampler(&reg_symbol, &reg);
6364 reg_symbol.info.sampler.range = *range;
6365 spirv_compiler_put_symbol(compiler, &reg_symbol);
6366
6368 return;
6369
6373
6374 vkd3d_symbol_make_register(&reg_symbol, &reg);
6375 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
6377 reg_symbol.descriptor_array = var_info.array_symbol;
6378 reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx;
6379 spirv_compiler_put_symbol(compiler, &reg_symbol);
6380}
static bool spirv_compiler_has_combined_sampler_for_sampler(const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
Definition: spirv.c:2825
static void vkd3d_symbol_make_sampler(struct vkd3d_symbol *symbol, const struct vkd3d_shader_register *reg)
Definition: spirv.c:2333
static uint32_t vkd3d_spirv_get_op_type_sampler(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1104
@ VKD3D_SHADER_RESOURCE_NONE
@ VKD3DSPR_SAMPLER

Referenced by spirv_compiler_emit_descriptor_declarations().

◆ spirv_compiler_emit_sat()

static uint32_t spirv_compiler_emit_sat ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4526 of file spirv.c.

4528{
4529 unsigned int component_count = vsir_write_mask_component_count(write_mask);
4530 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4531 uint32_t type_id, zero_id, one_id;
4532
4533 if (reg->data_type == VKD3D_DATA_DOUBLE)
4534 {
4537 }
4538 else
4539 {
4542 }
4543
4544 type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask);
4545 if (data_type_is_floating_point(reg->data_type))
4546 return vkd3d_spirv_build_op_glsl_std450_nclamp(builder, type_id, val_id, zero_id, one_id);
4547
4548 FIXME("Unhandled data type %#x.\n", reg->data_type);
4549 return val_id;
4550}
static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t x, uint32_t min, uint32_t max)
Definition: spirv.c:1901

Referenced by spirv_compiler_emit_store_dst().

◆ spirv_compiler_emit_shader_epilogue_function()

static void spirv_compiler_emit_shader_epilogue_function ( struct spirv_compiler *  compiler)
static

Definition at line 5789 of file spirv.c.

5790{
5791 uint32_t param_type_id[MAX_REG_OUTPUT + 1], param_id[MAX_REG_OUTPUT + 1] = {0};
5792 uint32_t void_id, type_id, ptr_type_id, function_type_id, function_id;
5793 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5794 const struct shader_signature *signature;
5795 uint32_t output_index_id = 0;
5796 bool is_patch_constant;
5797 unsigned int i, count;
5798
5800 STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_type_id));
5802
5803 is_patch_constant = is_in_fork_or_join_phase(compiler);
5804
5805 signature = is_patch_constant ? &compiler->patch_constant_signature : &compiler->output_signature;
5806
5808
5809 void_id = vkd3d_spirv_get_op_type_void(builder);
5812 for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
5813 {
5814 if (compiler->private_output_variable[i])
5815 param_type_id[count++] = ptr_type_id;
5816 }
5817 function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, param_type_id, count);
5818
5819 vkd3d_spirv_build_op_function(builder, void_id, function_id,
5820 SpvFunctionControlMaskNone, function_type_id);
5821
5822 for (i = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
5823 {
5824 if (compiler->private_output_variable[i])
5825 param_id[i] = vkd3d_spirv_build_op_function_parameter(builder, ptr_type_id);
5826 }
5827
5829
5830 for (i = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
5831 {
5832 if (compiler->private_output_variable[i])
5833 param_id[i] = vkd3d_spirv_build_op_load(builder, type_id, param_id[i], SpvMemoryAccessMaskNone);
5834 }
5835
5836 if (is_in_control_point_phase(compiler))
5837 output_index_id = spirv_compiler_emit_load_invocation_id(compiler);
5838
5839 for (i = 0; i < signature->element_count; ++i)
5840 {
5841 if (!compiler->output_info[i].id)
5842 continue;
5843
5844 if (!param_id[i])
5845 continue;
5846
5848 &signature->elements[i], &compiler->output_info[i], output_index_id,
5849 param_id[i], compiler->private_output_variable_write_mask[i]);
5850 }
5851
5854
5855 memset(compiler->private_output_variable, 0, sizeof(compiler->private_output_variable));
5857 compiler->epilogue_function_id = 0;
5858}
static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compiler, const struct shader_signature *signature, const struct signature_element *output, const struct vkd3d_shader_output_info *output_info, uint32_t output_index_id, uint32_t val_id, uint32_t write_mask)
Definition: spirv.c:5694
#define STATIC_ASSERT(e)
Definition: vkd3d_common.h:47
#define MAX_REG_OUTPUT

Referenced by spirv_compiler_generate_spirv(), and spirv_compiler_leave_shader_phase().

◆ spirv_compiler_emit_shader_epilogue_invocation()

static void spirv_compiler_emit_shader_epilogue_invocation ( struct spirv_compiler *  compiler)
static

Definition at line 7086 of file spirv.c.

7087{
7088 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7089 uint32_t arguments[MAX_REG_OUTPUT];
7090 uint32_t void_id, function_id;
7091 unsigned int i, count;
7092
7093 if ((function_id = compiler->epilogue_function_id))
7094 {
7095 void_id = vkd3d_spirv_get_op_type_void(builder);
7096 for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i)
7097 {
7098 if (compiler->private_output_variable[i])
7099 arguments[count++] = compiler->private_output_variable[i];
7100 }
7101
7102 vkd3d_spirv_build_op_function_call(builder, void_id, function_id, arguments, count);
7103 }
7104}

Referenced by spirv_compiler_emit_emit_stream(), spirv_compiler_emit_hull_shader_main(), and spirv_compiler_emit_return().

◆ spirv_compiler_emit_shader_parameter()

static uint32_t spirv_compiler_emit_shader_parameter ( struct spirv_compiler *  compiler,
enum vkd3d_shader_parameter_name  name,
enum vkd3d_data_type  type,
unsigned int  component_count 
)
static

Definition at line 3458 of file spirv.c.

3460{
3461 const struct vkd3d_shader_parameter1 *parameter;
3462
3463 if (!(parameter = vsir_program_get_parameter(compiler->program, name)))
3464 {
3465 WARN("Unresolved shader parameter %#x.\n", name);
3466 goto default_parameter;
3467 }
3468
3469 if (parameter_data_type_map[parameter->data_type].type != type
3470 || parameter_data_type_map[parameter->data_type].component_count != component_count)
3471 ERR("Expected type %#x, count %u for parameter %#x, got %#x.\n",
3472 type, component_count, name, parameter->data_type);
3473
3476 component_count, (const uint32_t *)&parameter->u.immediate_constant);
3477
3479 return spirv_compiler_get_spec_constant(compiler, name,
3481 if (parameter->type == VKD3D_SHADER_PARAMETER_TYPE_BUFFER)
3482 return spirv_compiler_get_buffer_parameter(compiler, parameter, type, component_count);
3483
3484 FIXME("Unhandled parameter type %#x.\n", parameter->type);
3485
3486default_parameter:
3487 return spirv_compiler_get_spec_constant(compiler,
3489}
const struct vkd3d_shader_parameter1 * vsir_program_get_parameter(const struct vsir_program *program, enum vkd3d_shader_parameter_name name)
Definition: ir.c:120
static uint32_t spirv_compiler_get_buffer_parameter(struct spirv_compiler *compiler, const struct vkd3d_shader_parameter1 *parameter, enum vkd3d_data_type type, unsigned int component_count)
Definition: spirv.c:3431
static uint32_t spirv_compiler_alloc_spec_constant_id(struct spirv_compiler *compiler, unsigned int count)
Definition: spirv.c:3342
static uint32_t spirv_compiler_get_spec_constant(struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, uint32_t spec_id, enum vkd3d_data_type type, unsigned int component_count)
Definition: spirv.c:3416
static const struct @6008 parameter_data_type_map[]
enum vkd3d_shader_parameter_type type
Definition: vkd3d_shader.h:875
struct vkd3d_shader_parameter_immediate_constant1 immediate_constant
Definition: vkd3d_shader.h:887
struct vkd3d_shader_parameter_specialization_constant specialization_constant
Definition: vkd3d_shader.h:892
enum vkd3d_shader_parameter_data_type data_type
Definition: vkd3d_shader.h:880
union vkd3d_shader_parameter1::@5986 u
@ VKD3D_SHADER_PARAMETER_TYPE_BUFFER
Definition: vkd3d_shader.h:494
@ VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT
Definition: vkd3d_shader.h:482

Referenced by spirv_compiler_emit_load_reg(), and spirv_compiler_emit_query_sample_count().

◆ spirv_compiler_emit_shader_phase_builtin_variable()

static uint32_t spirv_compiler_emit_shader_phase_builtin_variable ( struct spirv_compiler *  compiler,
const struct vkd3d_spirv_builtin *  builtin,
const unsigned int *  array_sizes,
unsigned int  size_count 
)
static

Definition at line 5496 of file spirv.c.

5498{
5499 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5500 uint32_t *variable_id, id;
5501
5502 variable_id = NULL;
5503
5504 if (builtin->spirv_builtin == SpvBuiltInTessLevelOuter)
5505 variable_id = &compiler->hs.tess_level_outer_id;
5506 else if (builtin->spirv_builtin == SpvBuiltInTessLevelInner)
5507 variable_id = &compiler->hs.tess_level_inner_id;
5508
5509 if (variable_id && *variable_id)
5510 return *variable_id;
5511
5512 id = spirv_compiler_emit_builtin_variable_v(compiler, builtin, SpvStorageClassOutput, array_sizes, size_count);
5513 if (is_in_fork_or_join_phase(compiler))
5515
5516 if (variable_id)
5517 *variable_id = id;
5518 return id;
5519}
@ SpvBuiltInTessLevelOuter
Definition: spirv.h:571
@ SpvBuiltInTessLevelInner
Definition: spirv.h:572
struct vkd3d_hull_shader_variables hs
Definition: spirv.c:2429

Referenced by spirv_compiler_emit_output().

◆ spirv_compiler_emit_shader_phase_name()

static void spirv_compiler_emit_shader_phase_name ( struct spirv_compiler *  compiler,
uint32_t  id,
const char *  suffix 
)
static

Definition at line 5024 of file spirv.c.

5026{
5027 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5028 const char *name;
5029
5030 if (!suffix)
5031 suffix = "";
5032
5033 switch (compiler->phase)
5034 {
5036 name = "control";
5037 break;
5039 name = "fork";
5040 break;
5042 name = "join";
5043 break;
5044 default:
5045 ERR("Invalid phase type %#x.\n", compiler->phase);
5046 return;
5047 }
5048 vkd3d_spirv_build_op_name(builder, id, "%s%s", name, suffix);
5049}

Referenced by spirv_compiler_enter_shader_phase(), and spirv_compiler_leave_shader_phase().

◆ spirv_compiler_emit_shader_signature_outputs()

static void spirv_compiler_emit_shader_signature_outputs ( struct spirv_compiler *  compiler)
static

Definition at line 5394 of file spirv.c.

5395{
5396 const struct shader_signature *output_signature = &compiler->output_signature;
5397 uint32_t clip_distance_mask = 0, clip_distance_id = 0;
5398 uint32_t cull_distance_mask = 0, cull_distance_id = 0;
5399 const struct vkd3d_spirv_builtin *builtin;
5400 unsigned int i, count;
5401
5402 for (i = 0; i < output_signature->element_count; ++i)
5403 {
5404 const struct signature_element *e = &output_signature->elements[i];
5405
5406 switch (e->sysval_semantic)
5407 {
5409 calculate_clip_or_cull_distance_mask(e, &clip_distance_mask);
5410 break;
5411
5413 calculate_clip_or_cull_distance_mask(e, &cull_distance_mask);
5414 break;
5415
5416 default:
5417 break;
5418 }
5419 }
5420
5421 if (clip_distance_mask)
5422 {
5423 count = vkd3d_popcount(clip_distance_mask);
5425 clip_distance_id = spirv_compiler_emit_builtin_variable(compiler,
5427 }
5428
5429 if (cull_distance_mask)
5430 {
5431 count = vkd3d_popcount(cull_distance_mask);
5433 cull_distance_id = spirv_compiler_emit_builtin_variable(compiler,
5435 }
5436
5437 for (i = 0; i < output_signature->element_count; ++i)
5438 {
5439 const struct signature_element *e = &output_signature->elements[i];
5440
5441 switch (e->sysval_semantic)
5442 {
5444 compiler->output_info[i].id = clip_distance_id;
5445 compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT;
5446 compiler->output_info[i].array_element_mask = clip_distance_mask;
5447 break;
5448
5450 compiler->output_info[i].id = cull_distance_id;
5451 compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT;
5452 compiler->output_info[i].array_element_mask = cull_distance_mask;
5453 break;
5454
5455 default:
5456 break;
5457 }
5458 }
5459}
static void calculate_clip_or_cull_distance_mask(const struct signature_element *e, uint32_t *mask)
Definition: spirv.c:5379
static unsigned int vkd3d_popcount(unsigned int v)
Definition: vkd3d_common.h:280
@ VKD3D_SHADER_SV_CULL_DISTANCE
@ VKD3D_SHADER_SV_CLIP_DISTANCE

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_sincos()

static void spirv_compiler_emit_sincos ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7637 of file spirv.c.

7639{
7640 const struct vkd3d_shader_dst_param *dst_sin = &instruction->dst[0];
7641 const struct vkd3d_shader_dst_param *dst_cos = &instruction->dst[1];
7642 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7643 const struct vkd3d_shader_src_param *src = instruction->src;
7644 uint32_t type_id, src_id, sin_id = 0, cos_id = 0;
7645
7646 if (dst_sin->reg.type != VKD3DSPR_NULL)
7647 {
7648 type_id = spirv_compiler_get_type_id_for_dst(compiler, dst_sin);
7649 src_id = spirv_compiler_emit_load_src(compiler, src, dst_sin->write_mask);
7650
7651 sin_id = vkd3d_spirv_build_op_glsl_std450_sin(builder, type_id, src_id);
7652 }
7653
7654 if (dst_cos->reg.type != VKD3DSPR_NULL)
7655 {
7656 if (dst_sin->reg.type == VKD3DSPR_NULL || dst_cos->write_mask != dst_sin->write_mask)
7657 {
7658 type_id = spirv_compiler_get_type_id_for_dst(compiler, dst_cos);
7659 src_id = spirv_compiler_emit_load_src(compiler, src, dst_cos->write_mask);
7660 }
7661
7662 cos_id = vkd3d_spirv_build_op_glsl_std450_cos(builder, type_id, src_id);
7663 }
7664
7665 if (sin_id)
7666 spirv_compiler_emit_store_dst(compiler, dst_sin, sin_id);
7667
7668 if (cos_id)
7669 spirv_compiler_emit_store_dst(compiler, dst_cos, cos_id);
7670}
static uint32_t vkd3d_spirv_build_op_glsl_std450_cos(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1877
static uint32_t vkd3d_spirv_build_op_glsl_std450_sin(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1871
struct vkd3d_shader_register reg

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_spec_constant()

static uint32_t spirv_compiler_emit_spec_constant ( struct spirv_compiler *  compiler,
enum vkd3d_shader_parameter_name  name,
uint32_t  spec_id,
enum vkd3d_data_type  type,
unsigned int  component_count 
)
static

Definition at line 3377 of file spirv.c.

3380{
3381 uint32_t scalar_type_id, vector_type_id, id, default_value, components[4];
3382 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3383 const struct vkd3d_spec_constant_info *info;
3384
3386 default_value = info ? info->default_value : 0;
3387
3390
3391 for (unsigned int i = 0; i < component_count; ++i)
3392 {
3393 components[i] = vkd3d_spirv_build_op_spec_constant(builder, scalar_type_id, default_value);
3395 }
3396
3397 if (component_count == 1)
3398 id = components[0];
3399 else
3401
3402 if (info)
3403 vkd3d_spirv_build_op_name(builder, id, "%s", info->debug_name);
3404
3405 if (vkd3d_array_reserve((void **)&compiler->spec_constants, &compiler->spec_constants_size,
3406 compiler->spec_constant_count + 1, sizeof(*compiler->spec_constants)))
3407 {
3409 constant->name = name;
3410 constant->id = id;
3411 }
3412
3413 return id;
3414}
static const struct vkd3d_spec_constant_info * get_spec_constant_info(enum vkd3d_shader_parameter_name name)
Definition: spirv.c:3328
static uint32_t vkd3d_spirv_build_op_spec_constant(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
Definition: spirv.c:1245
static uint32_t vkd3d_spirv_build_op_spec_constant_composite(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
Definition: spirv.c:1231
@ SpvDecorationSpecId
Definition: spirv.h:447
size_t spec_constants_size
Definition: spirv.c:2481
unsigned int spec_constant_count
Definition: spirv.c:2479
enum vkd3d_shader_parameter_name name
Definition: spirv.c:2395
uint32_t default_value
Definition: spirv.c:3319
bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size)
Definition: memory.c:22

Referenced by spirv_compiler_get_spec_constant().

◆ spirv_compiler_emit_src_modifier()

static uint32_t spirv_compiler_emit_src_modifier ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask,
enum vkd3d_shader_src_modifier  modifier,
uint32_t  val_id 
)
static

Definition at line 4370 of file spirv.c.

4373{
4374 switch (modifier)
4375 {
4376 case VKD3DSPSM_NONE:
4377 break;
4378 case VKD3DSPSM_NEG:
4379 return spirv_compiler_emit_neg(compiler, reg, write_mask, val_id);
4380 case VKD3DSPSM_ABS:
4381 return spirv_compiler_emit_abs(compiler, reg, write_mask, val_id);
4382 case VKD3DSPSM_ABSNEG:
4383 val_id = spirv_compiler_emit_abs(compiler, reg, write_mask, val_id);
4384 return spirv_compiler_emit_neg(compiler, reg, write_mask, val_id);
4385 default:
4386 FIXME("Unhandled src modifier %#x.\n", modifier);
4387 break;
4388 }
4389
4390 return val_id;
4391}
static uint32_t spirv_compiler_emit_neg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4354
static uint32_t spirv_compiler_emit_abs(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4340
@ VKD3DSPSM_ABS
@ VKD3DSPSM_NONE
@ VKD3DSPSM_NEG
@ VKD3DSPSM_ABSNEG

Referenced by spirv_compiler_emit_load_src().

◆ spirv_compiler_emit_store()

static void spirv_compiler_emit_store ( struct spirv_compiler *  compiler,
uint32_t  dst_id,
uint32_t  dst_write_mask,
enum vkd3d_shader_component_type  component_type,
SpvStorageClass  storage_class,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4432 of file spirv.c.

4435{
4436 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4437 unsigned int component_count, dst_component_count;
4439 unsigned int i, src_idx, dst_idx;
4440 uint32_t type_id, dst_val_id;
4441
4442 VKD3D_ASSERT(write_mask);
4443
4445 dst_component_count = vsir_write_mask_component_count(dst_write_mask);
4446
4447 if (dst_component_count == 1 && component_count != 1)
4448 {
4450 val_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id,
4451 vsir_write_mask_get_component_idx(dst_write_mask));
4452 write_mask &= dst_write_mask;
4453 component_count = 1;
4454 }
4455
4456 if (component_count == 1)
4457 {
4458 return spirv_compiler_emit_store_scalar(compiler,
4459 dst_id, dst_write_mask, component_type, storage_class, write_mask, val_id);
4460 }
4461
4462 if (dst_component_count != component_count)
4463 {
4464 type_id = vkd3d_spirv_get_type_id(builder, component_type, dst_component_count);
4465 dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);
4466
4468
4469 for (i = 0, src_idx = 0, dst_idx = 0; dst_idx < VKD3D_VEC4_SIZE; ++dst_idx)
4470 {
4471 if (write_mask & (VKD3DSP_WRITEMASK_0 << dst_idx))
4472 components[i] = dst_component_count + src_idx++;
4473 else
4474 components[i] = i;
4475
4476 if (dst_write_mask & (VKD3DSP_WRITEMASK_0 << dst_idx))
4477 ++i;
4478 }
4479
4480 val_id = vkd3d_spirv_build_op_vector_shuffle(builder,
4481 type_id, dst_val_id, val_id, components, dst_component_count);
4482 }
4483
4484 vkd3d_spirv_build_op_store(builder, dst_id, val_id, SpvMemoryAccessMaskNone);
4485}
static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler, uint32_t dst_id, uint32_t dst_write_mask, enum vkd3d_shader_component_type component_type, SpvStorageClass storage_class, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4411

Referenced by spirv_compiler_emit_store_reg(), and spirv_compiler_emit_store_shader_output().

◆ spirv_compiler_emit_store_dst()

static void spirv_compiler_emit_store_dst ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst,
uint32_t  val_id 
)
static

Definition at line 4552 of file spirv.c.

4554{
4555 uint32_t modifiers = dst->modifiers;
4556
4557 /* It is always legitimate to ignore _pp. */
4558 modifiers &= ~VKD3DSPDM_PARTIALPRECISION;
4559
4560 if (modifiers & VKD3DSPDM_SATURATE)
4561 {
4562 val_id = spirv_compiler_emit_sat(compiler, &dst->reg, dst->write_mask, val_id);
4563 modifiers &= ~VKD3DSPDM_SATURATE;
4564 }
4565
4566 if (dst->modifiers & VKD3DSPDM_MSAMPCENTROID)
4567 {
4568 FIXME("Ignoring _centroid modifier.\n");
4569 modifiers &= ~VKD3DSPDM_MSAMPCENTROID;
4570 }
4571
4572 VKD3D_ASSERT(!modifiers);
4573
4574 spirv_compiler_emit_store_reg(compiler, &dst->reg, dst->write_mask, val_id);
4575}
static uint32_t spirv_compiler_emit_sat(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4526
@ VKD3DSPDM_SATURATE
@ VKD3DSPDM_MSAMPCENTROID

Referenced by spirv_compiler_emit_alu_instruction(), spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bool_cast(), spirv_compiler_emit_bufinfo(), spirv_compiler_emit_deriv_instruction(), spirv_compiler_emit_dot(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_ext_glsl_instruction(), spirv_compiler_emit_ftoi(), spirv_compiler_emit_ftou(), spirv_compiler_emit_imad(), spirv_compiler_emit_imul(), spirv_compiler_emit_int_div(), spirv_compiler_emit_isfinite(), spirv_compiler_emit_mov(), spirv_compiler_emit_movc(), spirv_compiler_emit_orderedness_instruction(), spirv_compiler_emit_quad_read_across(), spirv_compiler_emit_quad_read_lane_at(), spirv_compiler_emit_rcp(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_sample_info(), spirv_compiler_emit_sample_position(), spirv_compiler_emit_sincos(), spirv_compiler_emit_store_dst_components(), spirv_compiler_emit_store_dst_swizzled(), spirv_compiler_emit_swapc(), spirv_compiler_emit_uav_counter_instruction(), spirv_compiler_emit_wave_active_ballot(), spirv_compiler_emit_wave_alu_op(), spirv_compiler_emit_wave_bit_count(), spirv_compiler_emit_wave_bool_op(), spirv_compiler_emit_wave_is_first_lane(), spirv_compiler_emit_wave_read_lane_at(), and spirv_compiler_emit_wave_read_lane_first().

◆ spirv_compiler_emit_store_dst_components()

static void spirv_compiler_emit_store_dst_components ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst,
enum vkd3d_shader_component_type  component_type,
uint32_t *  component_ids 
)
static

Definition at line 4591 of file spirv.c.

4594{
4595 unsigned int component_count = vsir_write_mask_component_count(dst->write_mask);
4596 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4597 uint32_t type_id, dst_type_id, val_id;
4598
4600 if (component_count > 1)
4601 {
4603 type_id, component_ids, component_count);
4604 }
4605 else
4606 {
4607 val_id = *component_ids;
4608 }
4609
4610 dst_type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type, component_count);
4611 if (dst_type_id != type_id)
4612 val_id = vkd3d_spirv_build_op_bitcast(builder, dst_type_id, val_id);
4613
4614 spirv_compiler_emit_store_dst(compiler, dst, val_id);
4615}

Referenced by spirv_compiler_emit_bitfield_instruction(), spirv_compiler_emit_f16tof32(), spirv_compiler_emit_f32tof16(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_ld_tgsm(), and spirv_compiler_emit_store_dst_scalar().

◆ spirv_compiler_emit_store_dst_scalar()

static void spirv_compiler_emit_store_dst_scalar ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst,
uint32_t  val_id,
enum vkd3d_shader_component_type  component_type,
uint32_t  swizzle 
)
static

Definition at line 4617 of file spirv.c.

4620{
4621 unsigned int component_count = vsir_write_mask_component_count(dst->write_mask);
4622 uint32_t component_ids[VKD3D_VEC4_SIZE];
4623 unsigned int component_idx, i;
4624
4625 component_idx = vsir_write_mask_get_component_idx(dst->write_mask);
4626 for (i = 0; i < component_count; ++i)
4627 {
4628 if (vsir_swizzle_get_component(swizzle, component_idx + i))
4629 ERR("Invalid swizzle %#x for scalar value, write mask %#x.\n", swizzle, dst->write_mask);
4630
4631 component_ids[i] = val_id;
4632 }
4634}

Referenced by spirv_compiler_emit_sample_c().

◆ spirv_compiler_emit_store_dst_swizzled()

static void spirv_compiler_emit_store_dst_swizzled ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_dst_param *  dst,
uint32_t  val_id,
enum vkd3d_shader_component_type  component_type,
uint32_t  swizzle 
)
static

Definition at line 4577 of file spirv.c.

4580{
4581 struct vkd3d_shader_dst_param typed_dst = *dst;
4582 val_id = spirv_compiler_emit_swizzle(compiler,
4583 val_id, VKD3DSP_WRITEMASK_ALL, component_type, swizzle, dst->write_mask);
4584 /* XXX: The register data type could be fixed by the shader parser. For SM5
4585 * shaders the data types are stored in instructions modifiers.
4586 */
4588 spirv_compiler_emit_store_dst(compiler, &typed_dst, val_id);
4589}

Referenced by spirv_compiler_emit_gather4(), spirv_compiler_emit_ld(), spirv_compiler_emit_ld_uav_typed(), spirv_compiler_emit_lod(), and spirv_compiler_emit_sample().

◆ spirv_compiler_emit_store_raw_structured()

static void spirv_compiler_emit_store_raw_structured ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9161 of file spirv.c.

9163{
9165 switch (reg_type)
9166 {
9167 case VKD3DSPR_UAV:
9169 break;
9172 break;
9173 default:
9174 ERR("Unexpected register type %#x.\n", reg_type);
9175 }
9176}
static void spirv_compiler_emit_store_tgsm(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9121
static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9044

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_store_reg()

static void spirv_compiler_emit_store_reg ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4487 of file spirv.c.

4489{
4490 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4493 uint32_t src_write_mask = write_mask;
4495
4497
4498 if (reg->type == VKD3DSPR_SSA)
4499 {
4500 spirv_compiler_set_ssa_register_info(compiler, reg, val_id);
4501 return;
4502 }
4503
4505 return;
4507
4509 if (component_type != reg_info.component_type)
4510 {
4511 if (data_type_is_64_bit(reg->data_type))
4512 src_write_mask = vsir_write_mask_32_from_64(write_mask);
4514 val_id = spirv_compiler_emit_bool_to_int(compiler,
4515 vsir_write_mask_component_count(src_write_mask), val_id, false);
4516 type_id = vkd3d_spirv_get_type_id(builder, reg_info.component_type,
4517 vsir_write_mask_component_count(src_write_mask));
4518 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
4519 component_type = reg_info.component_type;
4520 }
4521
4523 reg_info.id, reg_info.write_mask, component_type, reg_info.storage_class, src_write_mask, val_id);
4524}
static void spirv_compiler_set_ssa_register_info(const struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t val_id)
Definition: spirv.c:4192
static void spirv_compiler_emit_store(struct spirv_compiler *compiler, uint32_t dst_id, uint32_t dst_write_mask, enum vkd3d_shader_component_type component_type, SpvStorageClass storage_class, uint32_t write_mask, uint32_t val_id)
Definition: spirv.c:4432

Referenced by spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_float_comparison_instruction(), spirv_compiler_emit_input(), and spirv_compiler_emit_store_dst().

◆ spirv_compiler_emit_store_scalar()

static void spirv_compiler_emit_store_scalar ( struct spirv_compiler *  compiler,
uint32_t  dst_id,
uint32_t  dst_write_mask,
enum vkd3d_shader_component_type  component_type,
SpvStorageClass  storage_class,
uint32_t  write_mask,
uint32_t  val_id 
)
static

Definition at line 4411 of file spirv.c.

4414{
4415 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
4416 uint32_t type_id, ptr_type_id, index;
4417 unsigned int component_idx;
4418
4419 if (vsir_write_mask_component_count(dst_write_mask) > 1)
4420 {
4422 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id);
4423 component_idx = vsir_write_mask_get_component_idx(write_mask);
4424 component_idx -= vsir_write_mask_get_component_idx(dst_write_mask);
4425 index = spirv_compiler_get_constant_uint(compiler, component_idx);
4426 dst_id = vkd3d_spirv_build_op_in_bounds_access_chain1(builder, ptr_type_id, dst_id, index);
4427 }
4428
4429 vkd3d_spirv_build_op_store(builder, dst_id, val_id, SpvMemoryAccessMaskNone);
4430}

Referenced by spirv_compiler_emit_store().

◆ spirv_compiler_emit_store_shader_output()

static void spirv_compiler_emit_store_shader_output ( struct spirv_compiler *  compiler,
const struct shader_signature *  signature,
const struct signature_element *  output,
const struct vkd3d_shader_output_info *  output_info,
uint32_t  output_index_id,
uint32_t  val_id,
uint32_t  write_mask 
)
static

Definition at line 5694 of file spirv.c.

5698{
5699 uint32_t dst_write_mask, use_mask, uninit_mask, swizzle, mask;
5700 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5701 uint32_t type_id, zero_id, ptr_type_id, chain_id, object_id;
5702 const struct signature_element *element;
5703 unsigned int i, index, array_idx;
5704 uint32_t output_id;
5705
5706 dst_write_mask = output->mask;
5707 use_mask = output->used_mask;
5708 if (!output->sysval_semantic)
5709 {
5710 for (i = 0; i < signature->element_count; ++i)
5711 {
5712 element = &signature->elements[i];
5713 if (element->register_index != output->register_index)
5714 continue;
5715 if (element->sysval_semantic)
5716 continue;
5717 dst_write_mask |= element->mask;
5718 use_mask |= element->used_mask;
5719 }
5720 }
5722 dst_write_mask >>= index;
5723 use_mask >>= index;
5724 write_mask &= dst_write_mask;
5725
5726 if (!write_mask)
5727 return;
5728
5729 if (output_info->component_type != VKD3D_SHADER_COMPONENT_FLOAT)
5730 {
5731 type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, VKD3D_VEC4_SIZE);
5732 val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);
5733 }
5734
5736 uninit_mask = dst_write_mask & ~use_mask;
5737 if (uninit_mask)
5738 {
5739 /* Set values to 0 for not initialized shader output components. */
5740 write_mask |= uninit_mask;
5741 zero_id = spirv_compiler_get_constant_vector(compiler,
5742 output_info->component_type, VKD3D_VEC4_SIZE, 0);
5743 val_id = spirv_compiler_emit_vector_shuffle(compiler,
5744 zero_id, val_id, swizzle, uninit_mask, output_info->component_type,
5746 }
5747 else
5748 {
5749 val_id = spirv_compiler_emit_swizzle(compiler,
5750 val_id, VKD3DSP_WRITEMASK_ALL, output_info->component_type, swizzle, write_mask);
5751 }
5752
5753 output_id = output_info->id;
5754 if (output_index_id)
5755 {
5757 output_info->component_type, vsir_write_mask_component_count(dst_write_mask));
5759 output_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, output_id, output_index_id);
5760 }
5761
5762 if (!output_info->array_element_mask)
5763 {
5765 output_id, dst_write_mask, output_info->component_type, SpvStorageClassOutput, write_mask, val_id);
5766 return;
5767 }
5768
5769 type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, 1);
5771 mask = output_info->array_element_mask;
5772 array_idx = spirv_compiler_get_output_array_index(compiler, output);
5773 mask &= (1u << (array_idx * VKD3D_VEC4_SIZE)) - 1;
5774 for (i = 0, index = vkd3d_popcount(mask); i < VKD3D_VEC4_SIZE; ++i)
5775 {
5776 if (!(write_mask & (VKD3DSP_WRITEMASK_0 << i)))
5777 continue;
5778
5779 chain_id = vkd3d_spirv_build_op_access_chain1(builder,
5780 ptr_type_id, output_id, spirv_compiler_get_constant_uint(compiler, index));
5781 object_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask,
5782 output_info->component_type, VKD3D_SHADER_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i);
5784 output_info->component_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id);
5785 ++index;
5786 }
5787}
static uint32_t spirv_compiler_get_output_array_index(struct spirv_compiler *compiler, const struct signature_element *e)
Definition: spirv.c:5676
static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compiler, uint32_t vector1_id, uint32_t vector2_id, uint32_t swizzle, uint32_t write_mask, enum vkd3d_shader_component_type component_type, unsigned int component_count)
Definition: spirv.c:3830

Referenced by spirv_compiler_emit_shader_epilogue_function().

◆ spirv_compiler_emit_store_tgsm()

static void spirv_compiler_emit_store_tgsm ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9121 of file spirv.c.

9123{
9124 uint32_t coordinate_id, type_id, val_id, ptr_type_id, ptr_id, data_id;
9125 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9126 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9127 const struct vkd3d_shader_src_param *src = instruction->src;
9128 uint32_t base_coordinate_id, component_idx;
9131 unsigned int component_count;
9132
9133 if (!spirv_compiler_get_register_info(compiler, &dst->reg, &reg_info))
9134 return;
9135
9137 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id);
9138 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
9139 type_id, reg_info.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
9140
9141 data = src[instruction->src_count - 1];
9142 data.reg.data_type = VKD3D_DATA_UINT;
9143 val_id = spirv_compiler_emit_load_src(compiler, &data, dst->write_mask);
9144
9146 for (component_idx = 0; component_idx < component_count; ++component_idx)
9147 {
9148 data_id = component_count > 1 ?
9149 vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx) : val_id;
9150
9151 coordinate_id = base_coordinate_id;
9152 if (component_idx)
9153 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
9154 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
9155
9156 ptr_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, reg_info.id, coordinate_id);
9157 vkd3d_spirv_build_op_store(builder, ptr_id, data_id, SpvMemoryAccessMaskNone);
9158 }
9159}

Referenced by spirv_compiler_emit_store_raw_structured().

◆ spirv_compiler_emit_store_uav_raw_structured()

static void spirv_compiler_emit_store_uav_raw_structured ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9044 of file spirv.c.

9046{
9047 uint32_t coordinate_id, type_id, val_id, data_id, ptr_type_id, ptr_id;
9048 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9049 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9050 const struct vkd3d_shader_src_param *src = instruction->src;
9051 const struct vkd3d_symbol *resource_symbol;
9052 uint32_t base_coordinate_id, component_idx;
9053 const struct vkd3d_shader_src_param *data;
9055 unsigned int component_count;
9056 uint32_t indices[2];
9057
9058 resource_symbol = spirv_compiler_find_resource(compiler, &dst->reg);
9059
9060 if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
9061 {
9062 type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
9064
9066 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
9067 type_id, resource_symbol->info.resource.structure_stride,
9069
9070 data = &src[instruction->src_count - 1];
9071 VKD3D_ASSERT(data->reg.data_type == VKD3D_DATA_UINT);
9072 val_id = spirv_compiler_emit_load_src(compiler, data, dst->write_mask);
9073
9075 for (component_idx = 0; component_idx < component_count; ++component_idx)
9076 {
9077 data_id = component_count > 1 ?
9078 vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx) : val_id;
9079
9080 coordinate_id = base_coordinate_id;
9081 if (component_idx)
9082 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
9083 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
9084 indices[0] = spirv_compiler_get_constant_uint(compiler, 0);
9085 indices[1] = coordinate_id;
9086
9087 ptr_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, resource_symbol->id, indices, 2);
9088 vkd3d_spirv_build_op_store(builder, ptr_id, data_id, SpvMemoryAccessMaskNone);
9089 }
9090 }
9091 else
9092 {
9095 base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler,
9096 type_id, image.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
9097
9098 data = &src[instruction->src_count - 1];
9099 VKD3D_ASSERT(data->reg.data_type == VKD3D_DATA_UINT);
9100 val_id = spirv_compiler_emit_load_src(compiler, data, dst->write_mask);
9101
9103 for (component_idx = 0; component_idx < component_count; ++component_idx)
9104 {
9105 /* Mesa Vulkan drivers require the texel parameter to be a vector. */
9107 VKD3D_VEC4_SIZE, val_id, component_idx, component_count);
9108
9109 coordinate_id = base_coordinate_id;
9110 if (component_idx)
9111 coordinate_id = vkd3d_spirv_build_op_iadd(builder, type_id,
9112 coordinate_id, spirv_compiler_get_constant_uint(compiler, component_idx));
9113
9114 vkd3d_spirv_build_op_image_write(builder, image.image_id, coordinate_id,
9115 data_id, SpvImageOperandsMaskNone, NULL, 0);
9116 }
9117 }
9118
9119}
static void vkd3d_spirv_build_op_image_write(struct vkd3d_spirv_builder *builder, uint32_t image_id, uint32_t coordinate_id, uint32_t texel_id, uint32_t image_operands, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:1708

Referenced by spirv_compiler_emit_store_raw_structured().

◆ spirv_compiler_emit_store_uav_typed()

static void spirv_compiler_emit_store_uav_typed ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9221 of file spirv.c.

9223{
9224 uint32_t coordinate_id, texel_id, type_id, val_id, ptr_type_id, ptr_id;
9225 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9226 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9227 const struct vkd3d_shader_src_param *src = instruction->src;
9228 const struct vkd3d_symbol *resource_symbol;
9230 uint32_t coordinate_mask;
9231 uint32_t indices[2];
9232
9233 resource_symbol = spirv_compiler_find_resource(compiler, &dst->reg);
9234
9235 if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource))
9236 {
9237 type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1);
9239 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
9240 indices[0] = spirv_compiler_get_constant_uint(compiler, 0);
9241 indices[1] = coordinate_id;
9242
9243 val_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1],
9244 VKD3DSP_WRITEMASK_0, resource_symbol->info.resource.sampled_type);
9245 ptr_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, resource_symbol->id, indices, 2);
9246 vkd3d_spirv_build_op_store(builder, ptr_id, val_id, SpvMemoryAccessMaskNone);
9247 }
9248 else
9249 {
9251
9253 coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1;
9254 coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], coordinate_mask);
9255 texel_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1], dst->write_mask, image.sampled_type);
9256
9257 vkd3d_spirv_build_op_image_write(builder, image.image_id, coordinate_id, texel_id,
9259 }
9260}
@ SpvCapabilityStorageImageWriteWithoutFormat
Definition: spirv.h:924

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_swapc()

static void spirv_compiler_emit_swapc ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 7549 of file spirv.c.

7551{
7552 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
7553 const struct vkd3d_shader_dst_param *dst = instruction->dst;
7554 const struct vkd3d_shader_src_param *src = instruction->src;
7555 uint32_t condition_id, src1_id, src2_id, type_id, val_id;
7556 unsigned int component_count;
7557
7558 VKD3D_ASSERT(dst[0].write_mask == dst[1].write_mask);
7559
7560 condition_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
7561 src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
7562 src2_id = spirv_compiler_emit_load_src(compiler, &src[2], dst->write_mask);
7563
7566
7567 condition_id = spirv_compiler_emit_int_to_bool(compiler,
7568 VKD3D_SHADER_CONDITIONAL_OP_NZ, src[0].reg.data_type, component_count, condition_id);
7569
7570 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src2_id, src1_id);
7571 spirv_compiler_emit_store_dst(compiler, &dst[0], val_id);
7572 val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src1_id, src2_id);
7573 spirv_compiler_emit_store_dst(compiler, &dst[1], val_id);
7574}

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_switch()

static void spirv_compiler_emit_switch ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 8332 of file spirv.c.

8334{
8335 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8336 const struct vkd3d_shader_src_param *src = instruction->src;
8337 uint32_t val_id, default_id;
8338 unsigned int i, word_count;
8339 uint32_t *cases;
8340
8342 {
8343 WARN("Unexpected src swizzle %#x.\n", src[0].swizzle);
8344 spirv_compiler_warning(compiler, VKD3D_SHADER_WARNING_SPV_INVALID_SWIZZLE,
8345 "The swizzle for a switch value is not scalar.");
8346 }
8347
8348 word_count = instruction->src_count - 3;
8349 if (!(cases = vkd3d_calloc(word_count, sizeof(*cases))))
8350 {
8351 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_OUT_OF_MEMORY,
8352 "Failed to allocate %u words for switch cases.", word_count);
8353 return;
8354 }
8355
8356 val_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0);
8357 default_id = spirv_compiler_get_label_id(compiler, src[1].reg.idx[0].offset);
8358 /* No instructions may occur between the merge and the switch. */
8359 spirv_compiler_emit_merge(compiler, src[2].reg.idx[0].offset, 0);
8360
8361 src = &src[3];
8362 for (i = 0; i < word_count; i += 2)
8363 {
8364 cases[i] = src[i].reg.u.immconst_u32[0];
8365 cases[i + 1] = spirv_compiler_get_label_id(compiler, src[i + 1].reg.idx[0].offset);
8366 }
8367
8368 vkd3d_spirv_build_op_switch(builder, val_id, default_id, cases, word_count / 2u);
8369
8370 vkd3d_free(cases);
8371}
static void vkd3d_spirv_build_op_switch(struct vkd3d_spirv_builder *builder, uint32_t selector, uint32_t default_label, uint32_t *targets, unsigned int target_count)
Definition: spirv.c:1454

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_swizzle()

static uint32_t spirv_compiler_emit_swizzle ( struct spirv_compiler *  compiler,
uint32_t  val_id,
uint32_t  val_write_mask,
enum vkd3d_shader_component_type  component_type,
uint32_t  swizzle,
uint32_t  write_mask 
)
static

Definition at line 3783 of file spirv.c.

3786{
3787 unsigned int i, component_idx, component_count, val_component_count;
3788 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3790
3792 val_component_count = vsir_write_mask_component_count(val_write_mask);
3793
3794 if (component_count == val_component_count
3795 && (component_count == 1 || vkd3d_swizzle_is_equal(val_write_mask, swizzle, write_mask)))
3796 return val_id;
3797
3799
3800 if (component_count == 1)
3801 {
3802 component_idx = vsir_write_mask_get_component_idx(write_mask);
3803 component_idx = vsir_swizzle_get_component(swizzle, component_idx);
3804 component_idx -= vsir_write_mask_get_component_idx(val_write_mask);
3805 return vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, component_idx);
3806 }
3807
3808 if (val_component_count == 1)
3809 {
3810 for (i = 0, component_idx = 0; i < VKD3D_VEC4_SIZE; ++i)
3811 {
3812 if (write_mask & (VKD3DSP_WRITEMASK_0 << i))
3813 {
3815 components[component_idx++] = val_id;
3816 }
3817 }
3819 }
3820
3821 for (i = 0, component_idx = 0; i < VKD3D_VEC4_SIZE; ++i)
3822 {
3823 if (write_mask & (VKD3DSP_WRITEMASK_0 << i))
3824 components[component_idx++] = vsir_swizzle_get_component(swizzle, i);
3825 }
3827 type_id, val_id, val_id, components, component_count);
3828}

Referenced by spirv_compiler_emit_bufinfo(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_input(), spirv_compiler_emit_load_reg(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_sample_info(), spirv_compiler_emit_sample_position(), spirv_compiler_emit_store_dst_swizzled(), and spirv_compiler_emit_store_shader_output().

◆ spirv_compiler_emit_sync()

static void spirv_compiler_emit_sync ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9843 of file spirv.c.

9845{
9846 unsigned int memory_semantics = SpvMemorySemanticsAcquireReleaseMask;
9847 SpvScope execution_scope = SpvScopeMax;
9848 SpvScope memory_scope = SpvScopeDevice;
9849 uint32_t flags = instruction->flags;
9850
9852 {
9853 memory_scope = SpvScopeWorkgroup;
9854 memory_semantics |= SpvMemorySemanticsWorkgroupMemoryMask;
9855 flags &= ~VKD3DSSF_GROUP_SHARED_MEMORY;
9856 }
9857
9859 {
9860 execution_scope = SpvScopeWorkgroup;
9861 flags &= ~VKD3DSSF_THREAD_GROUP;
9862 }
9863
9865 {
9866 bool group_uav = flags & VKD3DSSF_THREAD_GROUP_UAV;
9867 bool global_uav = flags & VKD3DSSF_GLOBAL_UAV;
9868
9869 if (group_uav && global_uav)
9870 {
9871 WARN("Invalid UAV sync flag combination; assuming global.\n");
9872 spirv_compiler_warning(compiler, VKD3D_SHADER_WARNING_SPV_INVALID_UAV_FLAGS,
9873 "The flags for a UAV sync instruction are contradictory; assuming global sync.");
9874 }
9875 memory_scope = global_uav ? SpvScopeDevice : SpvScopeWorkgroup;
9878 }
9879
9880 if (flags)
9881 {
9882 FIXME("Unhandled sync flags %#x.\n", flags);
9883 memory_scope = SpvScopeDevice;
9884 execution_scope = SpvScopeWorkgroup;
9885 memory_semantics |= SpvMemorySemanticsUniformMemoryMask
9891 }
9892
9893 spirv_compiler_emit_barrier(compiler, execution_scope, memory_scope, memory_semantics);
9894}
@ SpvMemorySemanticsWorkgroupMemoryMask
Definition: spirv.h:786
@ SpvMemorySemanticsUniformMemoryMask
Definition: spirv.h:784
@ SpvMemorySemanticsAtomicCounterMemoryMask
Definition: spirv.h:788
@ SpvMemorySemanticsCrossWorkgroupMemoryMask
Definition: spirv.h:787
@ SpvMemorySemanticsImageMemoryMask
Definition: spirv.h:789
@ SpvMemorySemanticsSubgroupMemoryMask
Definition: spirv.h:785
@ SpvMemorySemanticsAcquireReleaseMask
Definition: spirv.h:782
@ VKD3D_SHADER_WARNING_SPV_INVALID_UAV_FLAGS
@ VKD3DSSF_GLOBAL_UAV
@ VKD3DSSF_GROUP_SHARED_MEMORY
@ VKD3DSSF_THREAD_GROUP
@ VKD3DSSF_THREAD_GROUP_UAV

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_temps()

static void spirv_compiler_emit_temps ( struct spirv_compiler *  compiler,
uint32_t  count 
)
static

Definition at line 5986 of file spirv.c.

5987{
5988 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5989 size_t function_location;
5990 unsigned int i;
5991 uint32_t id;
5992
5993 function_location = spirv_compiler_get_current_function_location(compiler);
5994 vkd3d_spirv_begin_function_stream_insertion(builder, function_location);
5995
5996 VKD3D_ASSERT(!compiler->temp_count);
5997 compiler->temp_count = count;
5998 for (i = 0; i < compiler->temp_count; ++i)
5999 {
6000 id = spirv_compiler_emit_variable(compiler, &builder->global_stream,
6002 if (!i)
6003 compiler->temp_id = id;
6004 VKD3D_ASSERT(id == compiler->temp_id + i);
6005
6006 vkd3d_spirv_build_op_name(builder, id, "r%u", i);
6007 }
6008
6010}
uint32_t temp_id
Definition: spirv.c:2427
unsigned int temp_count
Definition: spirv.c:2428

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_tessellator_output_primitive()

static void spirv_compiler_emit_tessellator_output_primitive ( struct spirv_compiler *  compiler,
enum vkd3d_shader_tessellator_output_primitive  primitive 
)
static

Definition at line 6853 of file spirv.c.

6855{
6857
6859 return;
6860
6861 switch (primitive)
6862 {
6865 break;
6867 return;
6870 break;
6873 break;
6874 default:
6875 FIXME("Invalid tessellator output primitive %#x.\n", primitive);
6876 return;
6877 }
6878
6880}
@ SpvExecutionModeVertexOrderCw
Definition: spirv.h:124
@ SpvExecutionModePointMode
Definition: spirv.h:130
@ SpvExecutionModeVertexOrderCcw
Definition: spirv.h:125
@ VKD3D_SHADER_TESSELLATOR_OUTPUT_TRIANGLE_CW
@ VKD3D_SHADER_TESSELLATOR_OUTPUT_POINT
@ VKD3D_SHADER_TESSELLATOR_OUTPUT_TRIANGLE_CCW
@ VKD3D_SHADER_TESSELLATOR_OUTPUT_LINE

Referenced by spirv_compiler_generate_spirv(), and spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_tessellator_partitioning()

static void spirv_compiler_emit_tessellator_partitioning ( struct spirv_compiler *  compiler,
enum vkd3d_shader_tessellator_partitioning  partitioning 
)
static

Definition at line 6882 of file spirv.c.

6884{
6886
6888 return;
6889
6890 switch (partitioning)
6891 {
6895 break;
6898 break;
6901 break;
6902 default:
6903 FIXME("Invalid tessellator partitioning %#x.\n", partitioning);
6904 return;
6905 }
6906
6908}
@ SpvExecutionModeSpacingEqual
Definition: spirv.h:121
@ SpvExecutionModeSpacingFractionalEven
Definition: spirv.h:122
@ SpvExecutionModeSpacingFractionalOdd
Definition: spirv.h:123
@ VKD3D_SHADER_TESSELLATOR_PARTITIONING_INTEGER
@ VKD3D_SHADER_TESSELLATOR_PARTITIONING_POW2
@ VKD3D_SHADER_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD
@ VKD3D_SHADER_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN

Referenced by spirv_compiler_generate_spirv(), and spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_texel_offset()

static uint32_t spirv_compiler_emit_texel_offset ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction,
const struct vkd3d_spirv_resource_type *  resource_type_info 
)
static

Definition at line 8594 of file spirv.c.

8597{
8598 unsigned int component_count = resource_type_info->coordinate_component_count - resource_type_info->arrayed;
8599 const struct vkd3d_shader_texel_offset *offset = &instruction->texel_offset;
8600 int32_t data[4] = {offset->u, offset->v, offset->w, 0};
8601
8603 return spirv_compiler_get_constant(compiler,
8605}

Referenced by spirv_compiler_emit_gather4(), spirv_compiler_emit_ld(), spirv_compiler_emit_sample(), and spirv_compiler_emit_sample_c().

◆ spirv_compiler_emit_thread_group_size()

static void spirv_compiler_emit_thread_group_size ( struct spirv_compiler *  compiler,
const struct vsir_thread_group_size *  group_size 
)
static

Definition at line 6910 of file spirv.c.

6912{
6913 const uint32_t local_size[] = {group_size->x, group_size->y, group_size->z};
6914
6916 SpvExecutionModeLocalSize, local_size, ARRAY_SIZE(local_size));
6917}
@ SpvExecutionModeLocalSize
Definition: spirv.h:136

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_emit_uav_counter_instruction()

static void spirv_compiler_emit_uav_counter_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 9262 of file spirv.c.

9264{
9265 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
9266 const struct vkd3d_shader_dst_param *dst = instruction->dst;
9267 const struct vkd3d_shader_src_param *src = instruction->src;
9268 unsigned int memory_semantics = SpvMemorySemanticsMaskNone;
9269 uint32_t ptr_type_id, type_id, counter_id, result_id;
9270 uint32_t coordinate_id, sample_id, pointer_id;
9271 const struct vkd3d_symbol *resource_symbol;
9272 uint32_t operands[3];
9273 SpvOp op;
9274
9277
9278 resource_symbol = spirv_compiler_find_resource(compiler, &src->reg);
9279 counter_id = resource_symbol->info.resource.uav_counter_id;
9280 VKD3D_ASSERT(counter_id);
9281
9283
9284 if (resource_symbol->info.resource.uav_counter_array)
9285 {
9286 const struct vkd3d_symbol_descriptor_array_data *array_data;
9287 uint32_t index_id;
9288
9289 index_id = spirv_compiler_get_descriptor_index(compiler, &src->reg,
9290 resource_symbol->info.resource.uav_counter_array,
9291 resource_symbol->info.resource.uav_counter_base_idx,
9292 resource_symbol->info.resource.resource_type_info->resource_type);
9293
9294 array_data = &resource_symbol->info.resource.uav_counter_array->info.descriptor_array;
9295 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, array_data->storage_class,
9296 array_data->contained_type_id);
9297
9298 counter_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, counter_id, &index_id, 1);
9299 }
9300
9301 if (spirv_compiler_is_opengl_target(compiler))
9302 {
9303 pointer_id = counter_id;
9305 }
9306 else if (compiler->ssbo_uavs)
9307 {
9309 coordinate_id = spirv_compiler_get_constant_uint(compiler, 0);
9310 operands[0] = spirv_compiler_get_constant_uint(compiler, 0);
9311 operands[1] = coordinate_id;
9312 pointer_id = vkd3d_spirv_build_op_access_chain(builder,
9313 ptr_type_id, counter_id, operands, 2);
9314 }
9315 else
9316 {
9318 coordinate_id = sample_id = spirv_compiler_get_constant_uint(compiler, 0);
9319 pointer_id = vkd3d_spirv_build_op_image_texel_pointer(builder,
9320 ptr_type_id, counter_id, coordinate_id, sample_id);
9321 }
9322
9323 operands[0] = pointer_id;
9324 operands[1] = spirv_compiler_get_constant_uint(compiler, SpvScopeDevice);
9325 operands[2] = spirv_compiler_get_constant_uint(compiler, memory_semantics);
9326 result_id = vkd3d_spirv_build_op_trv(builder, &builder->function_stream,
9327 op, type_id, operands, ARRAY_SIZE(operands));
9329 {
9330 /* SpvOpAtomicIDecrement returns the original value. */
9331 result_id = vkd3d_spirv_build_op_isub(builder, type_id, result_id,
9333 }
9334 spirv_compiler_emit_store_dst(compiler, dst, result_id);
9335}
@ SpvOpAtomicIDecrement
Definition: spirv.h:1408
@ SpvOpAtomicIIncrement
Definition: spirv.h:1407
SpvStorageClass storage_class
Definition: spirv.c:2218

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_variable()

static uint32_t spirv_compiler_emit_variable ( struct spirv_compiler *  compiler,
struct vkd3d_spirv_stream *  stream,
SpvStorageClass  storage_class,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count 
)
static

◆ spirv_compiler_emit_vector_shuffle()

static uint32_t spirv_compiler_emit_vector_shuffle ( struct spirv_compiler *  compiler,
uint32_t  vector1_id,
uint32_t  vector2_id,
uint32_t  swizzle,
uint32_t  write_mask,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count 
)
static

Definition at line 3830 of file spirv.c.

3833{
3834 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3837 unsigned int i;
3838
3840
3841 for (i = 0; i < component_count; ++i)
3842 {
3843 if (write_mask & (VKD3DSP_WRITEMASK_0 << i))
3845 else
3847 }
3848
3851 type_id, vector1_id, vector2_id, components, component_count);
3852}

Referenced by spirv_compiler_emit_store_shader_output().

◆ spirv_compiler_emit_wave_active_ballot()

static void spirv_compiler_emit_wave_active_ballot ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10044 of file spirv.c.

10046{
10047 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10048 uint32_t val_id;
10049
10051 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10052}
static uint32_t spirv_compiler_emit_group_nonuniform_ballot(struct spirv_compiler *compiler, const struct vkd3d_shader_src_param *src)
Definition: spirv.c:10031

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_alu_op()

static void spirv_compiler_emit_wave_alu_op ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10085 of file spirv.c.

10087{
10088 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10089 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10090 const struct vkd3d_shader_src_param *src = instruction->src;
10091 uint32_t type_id, val_id;
10092 SpvOp op;
10093
10095
10096 type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type,
10098 val_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
10099
10101 val_id = vkd3d_spirv_build_op_tr3(builder, &builder->function_stream, op, type_id,
10104 val_id);
10105
10106 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10107}
static uint32_t vkd3d_spirv_get_op_scope_subgroup(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1790
static SpvOp map_wave_alu_op(enum vkd3d_shader_opcode opcode, bool is_float)
Definition: spirv.c:10054
static uint32_t vkd3d_spirv_build_op_tr3(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1, uint32_t operand2)
Definition: spirv.c:822
@ SpvCapabilityGroupNonUniformArithmetic
Definition: spirv.h:931
@ SpvGroupOperationReduce
Definition: spirv.h:842
@ SpvGroupOperationExclusiveScan
Definition: spirv.h:844
#define VKD3DSI_WAVE_PREFIX

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_bit_count()

static void spirv_compiler_emit_wave_bit_count ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10109 of file spirv.c.

10111{
10112 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10113 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10114 SpvGroupOperation group_op;
10115 uint32_t type_id, val_id;
10116
10119
10122 val_id = vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count(builder, type_id, group_op, val_id);
10123
10124 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10125}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count(struct vkd3d_spirv_builder *builder, uint32_t result_type, SpvGroupOperation group_op, uint32_t val_id)
Definition: spirv.c:1819
enum SpvGroupOperation_ SpvGroupOperation
@ VKD3DSIH_WAVE_PREFIX_BIT_COUNT

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_bool_op()

static void spirv_compiler_emit_wave_bool_op ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10011 of file spirv.c.

10013{
10014 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10015 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10016 const struct vkd3d_shader_src_param *src = instruction->src;
10017 uint32_t type_id, val_id;
10018 SpvOp op;
10019
10021
10024 val_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
10025 val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op,
10026 type_id, vkd3d_spirv_get_op_scope_subgroup(builder), val_id);
10027
10028 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10029}
static SpvOp map_wave_bool_op(enum vkd3d_shader_opcode opcode)
Definition: spirv.c:9996
@ SpvCapabilityGroupNonUniformVote
Definition: spirv.h:930

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_is_first_lane()

static void spirv_compiler_emit_wave_is_first_lane ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10127 of file spirv.c.

10129{
10130 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10131 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10132 uint32_t val_id;
10133
10135 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10136}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_elect(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1827

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_read_lane_at()

static void spirv_compiler_emit_wave_read_lane_at ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10138 of file spirv.c.

10140{
10141 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10142 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10143 const struct vkd3d_shader_src_param *src = instruction->src;
10144 uint32_t type_id, lane_id, val_id;
10145
10146 type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type,
10148 val_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask);
10149 lane_id = spirv_compiler_emit_load_src(compiler, &src[1], VKD3DSP_WRITEMASK_0);
10150
10151 /* TODO: detect values loaded from a const buffer? */
10153 {
10154 /* Uniform lane_id only. */
10155 val_id = vkd3d_spirv_build_op_group_nonuniform_broadcast(builder, type_id, val_id, lane_id);
10156 }
10157 else
10158 {
10159 /* WaveReadLaneAt supports non-uniform lane ids, so if lane_id is not constant it may not be uniform. */
10160 val_id = vkd3d_spirv_build_op_group_nonuniform_shuffle(builder, type_id, val_id, lane_id);
10161 }
10162
10163 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10164}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_shuffle(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t lane_id)
Definition: spirv.c:1842
static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id, uint32_t lane_id)
Definition: spirv.c:1834

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_wave_read_lane_first()

static void spirv_compiler_emit_wave_read_lane_first ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10166 of file spirv.c.

10168{
10169 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10170 const struct vkd3d_shader_dst_param *dst = instruction->dst;
10171 const struct vkd3d_shader_src_param *src = instruction->src;
10172 uint32_t type_id, val_id;
10173
10174 type_id = vkd3d_spirv_get_type_id_for_data_type(builder, dst->reg.data_type,
10176 val_id = spirv_compiler_emit_load_src(compiler, src, dst->write_mask);
10178
10179 spirv_compiler_emit_store_dst(compiler, dst, val_id);
10180}
static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast_first(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t val_id)
Definition: spirv.c:1850

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_emit_workgroup_memory()

static void spirv_compiler_emit_workgroup_memory ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
unsigned int  alignment,
unsigned int  size,
unsigned int  structure_stride,
bool  zero_init 
)
static

Definition at line 6654 of file spirv.c.

6657{
6658 uint32_t type_id, array_type_id, length_id, pointer_type_id, var_id, init_id;
6659 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6661 struct vkd3d_symbol reg_symbol;
6662
6663 /* Alignment is supported only in the Kernel execution model. */
6664 if (alignment)
6665 TRACE("Ignoring alignment %u.\n", alignment);
6666
6668 length_id = spirv_compiler_get_constant_uint(compiler, size);
6669 array_type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
6670
6671 pointer_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, array_type_id);
6672 init_id = zero_init ? vkd3d_spirv_get_op_constant_null(builder, array_type_id) : 0;
6673 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
6674 pointer_type_id, storage_class, init_id);
6675
6677
6678 vkd3d_symbol_make_register(&reg_symbol, reg);
6679 vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class,
6681 reg_symbol.info.reg.structure_stride = structure_stride;
6682 spirv_compiler_put_symbol(compiler, &reg_symbol);
6683}
_Check_return_ _Ret_maybenull_ _In_ size_t alignment
Definition: align.cpp:48
@ SpvStorageClassWorkgroup
Definition: spirv.h:195

Referenced by spirv_compiler_emit_dcl_tgsm_raw(), and spirv_compiler_emit_dcl_tgsm_structured().

◆ spirv_compiler_enable_descriptor_indexing()

static bool spirv_compiler_enable_descriptor_indexing ( struct spirv_compiler *  compiler,
enum vkd3d_shader_register_type  reg_type,
enum vkd3d_shader_resource_type  resource_type 
)
static

Definition at line 3601 of file spirv.c.

3603{
3604 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3605
3608 return false;
3609
3610 switch (reg_type)
3611 {
3614 break;
3615 case VKD3DSPR_RESOURCE:
3619 break;
3620 case VKD3DSPR_UAV:
3621 if (resource_type == VKD3D_SHADER_RESOURCE_BUFFER)
3622 vkd3d_spirv_enable_capability(builder, compiler->ssbo_uavs
3625 else
3627 break;
3628 case VKD3DSPR_SAMPLER:
3629 break;
3630 default:
3631 ERR("Unhandled register type %#x.\n", reg_type);
3632 break;
3633 }
3634
3635 return true;
3636}
@ SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT
Definition: spirv.h:1003
@ SpvCapabilityStorageImageArrayDynamicIndexing
Definition: spirv.h:899
@ SpvCapabilityStorageBufferArrayDynamicIndexing
Definition: spirv.h:898
@ SpvCapabilityUniformBufferArrayDynamicIndexing
Definition: spirv.h:896
@ SpvCapabilitySampledImageArrayDynamicIndexing
Definition: spirv.h:897
@ SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT
Definition: spirv.h:1001
@ VKD3D_SHADER_SPIRV_EXTENSION_EXT_DESCRIPTOR_INDEXING

Referenced by spirv_compiler_get_descriptor_index().

◆ spirv_compiler_enable_resource_type()

static const struct vkd3d_spirv_resource_type * spirv_compiler_enable_resource_type ( struct spirv_compiler *  compiler,
enum vkd3d_shader_resource_type  resource_type,
bool  is_uav 
)
static

Definition at line 6382 of file spirv.c.

6384{
6385 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6387
6389 return NULL;
6390
6391 if (resource_type_info->capability)
6393 if (is_uav && resource_type_info->uav_capability)
6394 vkd3d_spirv_enable_capability(builder, resource_type_info->uav_capability);
6395
6396 return resource_type_info;
6397}
static const struct vkd3d_spirv_resource_type * vkd3d_get_spirv_resource_type(enum vkd3d_shader_resource_type resource_type)
Definition: spirv.c:2128
enum vkd3d_shader_resource_type resource_type
Definition: spirv.c:2100

Referenced by spirv_compiler_emit_resource_declaration().

◆ spirv_compiler_end_invocation_interlock()

static void spirv_compiler_end_invocation_interlock ( struct spirv_compiler *  compiler)
static

Definition at line 8123 of file spirv.c.

8124{
8125 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8126
8128 {
8131 }
8132 else
8133 {
8136 }
8138}
static bool vkd3d_spirv_capability_is_enabled(struct vkd3d_spirv_builder *builder, SpvCapability cap)
Definition: spirv.c:423
@ SpvExecutionModePixelInterlockOrderedEXT
Definition: spirv.h:171
@ SpvExecutionModeSampleInterlockOrderedEXT
Definition: spirv.h:173
@ SpvCapabilityFragmentShaderSampleInterlockEXT
Definition: spirv.h:1029
@ SpvCapabilityFragmentShaderPixelInterlockEXT
Definition: spirv.h:1032
@ SpvOpEndInvocationInterlockEXT
Definition: spirv.h:1600

Referenced by spirv_compiler_emit_return().

◆ spirv_compiler_enter_shader_phase()

static void spirv_compiler_enter_shader_phase ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 6945 of file spirv.c.

6947{
6948 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6949 uint32_t function_id, void_id, function_type_id;
6950 struct vkd3d_shader_phase *phase;
6951
6952 VKD3D_ASSERT(compiler->phase != instruction->opcode);
6953
6954 if (!is_in_default_phase(compiler))
6956
6958
6959 void_id = vkd3d_spirv_get_op_type_void(builder);
6960 function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, NULL, 0);
6962 SpvFunctionControlMaskNone, function_type_id);
6963
6964 compiler->phase = instruction->opcode;
6966
6968 ? &compiler->control_point_phase : &compiler->patch_constant_phase;
6969 phase->function_id = function_id;
6970 /* The insertion location must be set after the label is emitted. */
6971 phase->function_location = 0;
6972
6975}
if(dx< 0)
Definition: linetemp.h:194
static void spirv_compiler_emit_shader_phase_name(struct spirv_compiler *compiler, uint32_t id, const char *suffix)
Definition: spirv.c:5024
static void spirv_compiler_leave_shader_phase(struct spirv_compiler *compiler)
Definition: spirv.c:6921
bool emit_default_control_point_phase
Definition: spirv.c:2474
size_t function_location
Definition: spirv.c:2390
uint32_t function_id
Definition: spirv.c:2389

Referenced by spirv_compiler_handle_instruction().

◆ spirv_compiler_find_combined_sampler()

static const struct vkd3d_symbol * spirv_compiler_find_combined_sampler ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  resource_reg,
const struct vkd3d_shader_register *  sampler_reg 
)
static

Definition at line 8456 of file spirv.c.

8458{
8459 const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
8460 unsigned int sampler_space, sampler_index;
8461 struct vkd3d_symbol key;
8462 struct rb_entry *entry;
8463
8464 if (!shader_interface->combined_sampler_count)
8465 return NULL;
8466
8467 if (sampler_reg)
8468 {
8469 const struct vkd3d_symbol *sampler_symbol;
8470
8471 vkd3d_symbol_make_sampler(&key, sampler_reg);
8472 if (!(entry = rb_get(&compiler->symbol_table, &key)))
8473 return NULL;
8474 sampler_symbol = RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
8475 sampler_space = sampler_symbol->info.sampler.range.space;
8476 sampler_index = sampler_symbol->info.sampler.range.first;
8477 }
8478 else
8479 {
8480 sampler_space = 0;
8481 sampler_index = VKD3D_SHADER_DUMMY_SAMPLER_INDEX;
8482 }
8483
8484 vkd3d_symbol_make_combined_sampler(&key, resource_reg, sampler_space, sampler_index);
8485 if ((entry = rb_get(&compiler->symbol_table, &key)))
8486 return RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
8487 return NULL;
8488}
Definition: copy.c:22

Referenced by spirv_compiler_prepare_image().

◆ spirv_compiler_find_push_constant_buffer()

static struct vkd3d_push_constant_buffer_binding * spirv_compiler_find_push_constant_buffer ( const struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range 
)
static

Definition at line 2773 of file spirv.c.

2775{
2776 unsigned int register_space = range->space;
2777 unsigned int reg_idx = range->first;
2778 unsigned int i;
2779
2780 if (range->first != range->last)
2781 return NULL;
2782
2783 for (i = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
2784 {
2786
2787 if (!spirv_compiler_check_shader_visibility(compiler, current->pc.shader_visibility))
2788 continue;
2789
2790 if (current->pc.register_space == register_space && current->pc.register_index == reg_idx)
2791 return current;
2792 }
2793
2794 return NULL;
2795}

Referenced by spirv_compiler_emit_cbv_declaration().

◆ spirv_compiler_find_resource()

◆ spirv_compiler_generate_spirv()

static int spirv_compiler_generate_spirv ( struct spirv_compiler *  compiler,
struct vsir_program *  program,
const struct vkd3d_shader_compile_info *  compile_info,
struct vkd3d_shader_code *  spirv 
)
static

Definition at line 10665 of file spirv.c.

10667{
10668 const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info;
10670 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
10671 struct vkd3d_shader_instruction_array instructions;
10674 unsigned int i, max_element_count;
10675
10677 compile_info, compiler->message_context)) < 0)
10678 return result;
10679
10680 VKD3D_ASSERT(program->normalisation_level == VSIR_FULLY_NORMALISED_IO);
10681
10682 max_element_count = max(program->output_signature.element_count, program->patch_constant_signature.element_count);
10683 if (!(compiler->output_info = vkd3d_calloc(max_element_count, sizeof(*compiler->output_info))))
10685
10686 if (program->temp_count)
10687 spirv_compiler_emit_temps(compiler, program->temp_count);
10688 if (program->ssa_count)
10690 if (compiler->shader_type == VKD3D_SHADER_TYPE_COMPUTE)
10691 spirv_compiler_emit_thread_group_size(compiler, &program->thread_group_size);
10692 spirv_compiler_emit_global_flags(compiler, program->global_flags);
10693
10695
10696 compiler->spirv_parameter_info = vkd3d_calloc(program->parameter_count, sizeof(*compiler->spirv_parameter_info));
10697 for (i = 0; i < program->parameter_count; ++i)
10698 {
10699 const struct vkd3d_shader_parameter1 *parameter = &program->parameters[i];
10700
10701 if (parameter->type == VKD3D_SHADER_PARAMETER_TYPE_BUFFER)
10702 {
10703 uint32_t type_id, struct_id, ptr_type_id, var_id;
10704
10707 parameter_data_type_map[parameter->data_type].component_count);
10708
10709 struct_id = vkd3d_spirv_build_op_type_struct(builder, &type_id, 1);
10710 vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0);
10711 vkd3d_spirv_build_op_member_decorate1(builder, struct_id, 0,
10712 SpvDecorationOffset, parameter->u.buffer.offset);
10713
10714 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, struct_id);
10715 var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
10716 ptr_type_id, SpvStorageClassUniform, 0);
10717
10718 vkd3d_spirv_build_op_decorate1(builder, var_id, SpvDecorationDescriptorSet, parameter->u.buffer.set);
10719 vkd3d_spirv_build_op_decorate1(builder, var_id, SpvDecorationBinding, parameter->u.buffer.binding);
10720
10721 compiler->spirv_parameter_info[i].buffer_id = var_id;
10722 }
10723 }
10724
10725 if (program->block_count && !spirv_compiler_init_blocks(compiler, program->block_count))
10727
10728 compiler->program = program;
10729
10730 instructions = program->instructions;
10731 memset(&program->instructions, 0, sizeof(program->instructions));
10732
10733 compiler->input_signature = program->input_signature;
10734 compiler->output_signature = program->output_signature;
10735 compiler->patch_constant_signature = program->patch_constant_signature;
10736 memset(&program->input_signature, 0, sizeof(program->input_signature));
10737 memset(&program->output_signature, 0, sizeof(program->output_signature));
10738 memset(&program->patch_constant_signature, 0, sizeof(program->patch_constant_signature));
10739 compiler->use_vocp = program->use_vocp;
10740 compiler->block_names = program->block_names;
10741 compiler->block_name_count = program->block_name_count;
10742
10743 compiler->input_control_point_count = program->input_control_point_count;
10744 compiler->output_control_point_count = program->output_control_point_count;
10745
10746 if (compiler->shader_type != VKD3D_SHADER_TYPE_HULL)
10748
10749 for (i = 0; i < instructions.count && result >= 0; ++i)
10750 {
10751 result = spirv_compiler_handle_instruction(compiler, &instructions.elements[i]);
10752 }
10753
10754 shader_instruction_array_destroy(&instructions);
10755
10756 if (result < 0)
10757 return result;
10758
10759 if (!is_in_default_phase(compiler))
10761 else
10763
10764 if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
10766
10767 if (compiler->shader_type == VKD3D_SHADER_TYPE_DOMAIN)
10768 {
10769 if (info && (ds_info = vkd3d_find_struct(compile_info->next, SPIRV_DOMAIN_SHADER_TARGET_INFO)))
10770 {
10773 }
10774 else if (spirv_compiler_is_opengl_target(compiler))
10775 {
10776 ERR("vkd3d_shader_spirv_domain_shader_target_info is required for "
10777 "OpenGL tessellation evaluation shader.\n");
10778 }
10779 }
10780
10781 if (compiler->discard_function_id)
10783
10784 if (compiler->epilogue_function_id)
10785 {
10786 vkd3d_spirv_build_op_name(builder, compiler->epilogue_function_id, "epilogue");
10788 }
10789
10790 if (compiler->strip_debug)
10792
10795 return VKD3D_ERROR;
10796
10798 {
10800
10801 if (TRACE_ON())
10803
10806 {
10807 FIXME("Failed to validate SPIR-V binary.\n");
10808 vkd3d_shader_trace_text(buffer.buffer, buffer.content_size);
10809
10811 {
10812 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_SHADER,
10813 "Execution generated an invalid shader, failing compilation:\n%s",
10814 buffer.buffer);
10815 }
10816 }
10818 }
10819
10820 if (compiler->failed)
10822
10823 if (compile_info->target_type == VKD3D_SHADER_TARGET_SPIRV_TEXT)
10824 {
10825 struct vkd3d_shader_code text;
10827 return VKD3D_ERROR;
10829 *spirv = text;
10830 }
10831
10832 return VKD3D_OK;
10833}
#define TRACE_ON(x)
Definition: compat.h:75
const WCHAR * text
Definition: package.c:1826
GLuint buffer
Definition: glext.h:5915
GLuint64EXT * result
Definition: glext.h:11304
enum vkd3d_result vsir_program_transform(struct vsir_program *program, uint64_t config_flags, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_message_context *message_context)
Definition: ir.c:8324
static void spirv_compiler_emit_discard_function(struct spirv_compiler *compiler)
Definition: spirv.c:8179
static void spirv_compiler_emit_hull_shader_main(struct spirv_compiler *compiler)
Definition: spirv.c:7106
static bool spirv_compiler_init_blocks(struct spirv_compiler *compiler, unsigned int block_count)
Definition: spirv.c:8241
static void spirv_compiler_allocate_ssa_register_ids(struct spirv_compiler *compiler, unsigned int count)
Definition: spirv.c:6012
static bool vkd3d_spirv_compile_module(struct vkd3d_spirv_builder *builder, struct vkd3d_shader_code *spirv, const char *entry_point, enum vkd3d_shader_spirv_environment environment)
Definition: spirv.c:2021
static void vkd3d_spirv_stream_clear(struct vkd3d_spirv_stream *stream)
Definition: spirv.c:283
static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler *compiler)
Definition: spirv.c:5789
static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10196
static void spirv_compiler_emit_descriptor_declarations(struct spirv_compiler *compiler)
Definition: spirv.c:10628
static void vkd3d_spirv_dump(const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment)
Definition: spirv.c:189
static void spirv_compiler_emit_shader_signature_outputs(struct spirv_compiler *compiler)
Definition: spirv.c:5394
static void spirv_compiler_emit_temps(struct spirv_compiler *compiler, uint32_t count)
Definition: spirv.c:5986
static void spirv_compiler_emit_global_flags(struct spirv_compiler *compiler, enum vsir_global_flags flags)
Definition: spirv.c:5925
static enum vkd3d_result vkd3d_spirv_binary_to_text(const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment, enum vkd3d_shader_compile_option_formatting_flags formatting, struct vkd3d_shader_code *out)
Definition: spirv.c:183
static void spirv_compiler_emit_tessellator_partitioning(struct spirv_compiler *compiler, enum vkd3d_shader_tessellator_partitioning partitioning)
Definition: spirv.c:6882
static void spirv_compiler_emit_tessellator_output_primitive(struct spirv_compiler *compiler, enum vkd3d_shader_tessellator_output_primitive primitive)
Definition: spirv.c:6853
static void spirv_compiler_emit_thread_group_size(struct spirv_compiler *compiler, const struct vsir_thread_group_size *group_size)
Definition: spirv.c:6910
static bool vkd3d_spirv_validate(struct vkd3d_string_buffer *buffer, const struct vkd3d_shader_code *spirv, enum vkd3d_shader_spirv_environment environment)
Definition: spirv.c:191
size_t block_name_count
Definition: spirv.c:2497
enum vkd3d_shader_target_type target_type
struct vkd3d_shader_parameter_buffer buffer
Definition: vkd3d_shader.h:897
enum vkd3d_shader_tessellator_output_primitive output_primitive
enum vkd3d_shader_tessellator_partitioning partitioning
struct vkd3d_spirv_stream debug_stream
Definition: spirv.c:399
VKD3D_SHADER_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code)
@ VKD3D_SHADER_TARGET_SPIRV_TEXT
void vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer)
void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer)
void shader_instruction_array_destroy(struct vkd3d_shader_instruction_array *instructions)
#define vkd3d_shader_trace_text(text, size)
@ VSIR_FULLY_NORMALISED_IO
@ VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION
vkd3d_result
Definition: vkd3d_types.h:41
@ VKD3D_ERROR_OUT_OF_MEMORY
Definition: vkd3d_types.h:49

Referenced by spirv_compile().

◆ spirv_compiler_get_buffer_parameter()

static uint32_t spirv_compiler_get_buffer_parameter ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_parameter1 *  parameter,
enum vkd3d_data_type  type,
unsigned int  component_count 
)
static

Definition at line 3431 of file spirv.c.

3433{
3434 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3435 unsigned int index = parameter - compiler->program->parameters;
3436 uint32_t type_id, ptr_id, ptr_type_id;
3437
3440 ptr_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id,
3441 compiler->spirv_parameter_info[index].buffer_id,
3444}

Referenced by spirv_compiler_emit_shader_parameter().

◆ spirv_compiler_get_constant()

static uint32_t spirv_compiler_get_constant ( struct spirv_compiler *  compiler,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count,
const uint32_t *  values 
)
static

Definition at line 3043 of file spirv.c.

3045{
3046 uint32_t type_id, scalar_type_id, component_ids[VKD3D_VEC4_SIZE];
3047 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3048 unsigned int i;
3049
3052
3053 switch (component_type)
3054 {
3058 break;
3060 if (component_count == 1)
3062 FIXME("Unsupported vector of bool.\n");
3063 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_TYPE,
3064 "Vectors of bool type are not supported.");
3065 return vkd3d_spirv_get_op_undef(builder, type_id);
3066 default:
3067 FIXME("Unhandled component_type %#x.\n", component_type);
3068 return vkd3d_spirv_get_op_undef(builder, type_id);
3069 }
3070
3071 if (component_count == 1)
3072 {
3073 return vkd3d_spirv_get_op_constant(builder, type_id, *values);
3074 }
3075 else
3076 {
3077 scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
3078 for (i = 0; i < component_count; ++i)
3079 component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, values[i]);
3080 return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
3081 }
3082}
static uint32_t vkd3d_spirv_get_op_constant_bool(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
Definition: spirv.c:1177
static uint32_t vkd3d_spirv_get_op_constant_composite(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *constituents, unsigned int constituent_count)
Definition: spirv.c:1238

Referenced by spirv_compiler_emit_constant_array(), spirv_compiler_emit_gather4(), spirv_compiler_emit_load_constant(), spirv_compiler_emit_sample_position(), spirv_compiler_emit_shader_parameter(), spirv_compiler_emit_texel_offset(), spirv_compiler_get_constant_float(), spirv_compiler_get_constant_float_vector(), spirv_compiler_get_constant_uint(), and spirv_compiler_get_constant_vector().

◆ spirv_compiler_get_constant64()

static uint32_t spirv_compiler_get_constant64 ( struct spirv_compiler *  compiler,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count,
const uint64_t *  values 
)
static

Definition at line 3084 of file spirv.c.

3086{
3087 uint32_t type_id, scalar_type_id, component_ids[VKD3D_DVEC2_SIZE];
3088 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3089 unsigned int i;
3090
3093
3095 {
3096 FIXME("Unhandled component_type %#x.\n", component_type);
3097 return vkd3d_spirv_get_op_undef(builder, type_id);
3098 }
3099
3100 if (component_count == 1)
3101 {
3102 return vkd3d_spirv_get_op_constant64(builder, type_id, *values);
3103 }
3104 else
3105 {
3106 scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
3107 for (i = 0; i < component_count; ++i)
3108 component_ids[i] = vkd3d_spirv_get_op_constant64(builder, scalar_type_id, values[i]);
3109 return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count);
3110 }
3111}
static uint32_t vkd3d_spirv_get_op_constant64(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint64_t value)
Definition: spirv.c:1207

Referenced by spirv_compiler_emit_constant_array(), spirv_compiler_emit_load_constant64(), spirv_compiler_get_constant_double_vector(), and spirv_compiler_get_constant_uint64_vector().

◆ spirv_compiler_get_constant_double_vector()

static uint32_t spirv_compiler_get_constant_double_vector ( struct spirv_compiler *  compiler,
double  value,
unsigned int  component_count 
)
static

◆ spirv_compiler_get_constant_float()

static uint32_t spirv_compiler_get_constant_float ( struct spirv_compiler *  compiler,
float  value 
)
static

◆ spirv_compiler_get_constant_float_vector()

static uint32_t spirv_compiler_get_constant_float_vector ( struct spirv_compiler *  compiler,
float  value,
unsigned int  component_count 
)
static

◆ spirv_compiler_get_constant_uint()

◆ spirv_compiler_get_constant_uint64_vector()

static uint32_t spirv_compiler_get_constant_uint64_vector ( struct spirv_compiler *  compiler,
uint64_t  value,
unsigned int  component_count 
)
static

◆ spirv_compiler_get_constant_uint_vector()

static uint32_t spirv_compiler_get_constant_uint_vector ( struct spirv_compiler *  compiler,
uint32_t  value,
unsigned int  component_count 
)
static

◆ spirv_compiler_get_constant_vector()

static uint32_t spirv_compiler_get_constant_vector ( struct spirv_compiler *  compiler,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count,
uint32_t  value 
)
static

◆ spirv_compiler_get_current_function_location()

static size_t spirv_compiler_get_current_function_location ( struct spirv_compiler *  compiler)
static

Definition at line 5914 of file spirv.c.

5915{
5916 const struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
5917 const struct vkd3d_shader_phase *phase;
5918
5919 if ((phase = spirv_compiler_get_current_shader_phase(compiler)))
5920 return phase->function_location;
5921
5922 return builder->main_function_location;
5923}
size_t main_function_location
Definition: spirv.c:410

Referenced by spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_temps(), and spirv_compiler_get_descriptor_index().

◆ spirv_compiler_get_current_shader_phase()

static const struct vkd3d_shader_phase * spirv_compiler_get_current_shader_phase ( struct spirv_compiler *  compiler)
static

Definition at line 5051 of file spirv.c.

5053{
5054 if (is_in_default_phase(compiler))
5055 return NULL;
5056
5057 return is_in_control_point_phase(compiler) ? &compiler->control_point_phase : &compiler->patch_constant_phase;
5058}

Referenced by spirv_compiler_emit_output(), and spirv_compiler_get_current_function_location().

◆ spirv_compiler_get_descriptor_binding()

static struct vkd3d_shader_descriptor_binding spirv_compiler_get_descriptor_binding ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
const struct vkd3d_shader_register_range *  range,
enum vkd3d_shader_resource_type  resource_type,
bool  is_uav_counter,
struct vkd3d_descriptor_binding_address *  binding_address 
)
static

Definition at line 2898 of file spirv.c.

2902{
2903 const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
2904 unsigned int register_last = (range->last == ~0u) ? range->first : range->last;
2905 const struct vkd3d_shader_descriptor_offset *binding_offsets;
2906 enum vkd3d_shader_descriptor_type descriptor_type;
2907 enum vkd3d_shader_binding_flag resource_type_flag;
2909 unsigned int i;
2910
2911 if (reg->type == VKD3DSPR_CONSTBUFFER)
2912 descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_CBV;
2913 else if (reg->type == VKD3DSPR_RESOURCE)
2914 descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV;
2915 else if (reg->type == VKD3DSPR_UAV)
2916 descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
2917 else if (reg->type == VKD3DSPR_SAMPLER)
2918 descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER;
2919 else
2920 {
2921 FIXME("Unhandled register type %#x.\n", reg->type);
2922 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_REGISTER_TYPE,
2923 "Encountered invalid/unhandled register type %#x.", reg->type);
2924 goto done;
2925 }
2926
2927 resource_type_flag = resource_type == VKD3D_SHADER_RESOURCE_BUFFER
2929
2930 if (is_uav_counter)
2931 {
2933 binding_offsets = compiler->offset_info.uav_counter_offsets;
2934 for (i = 0; i < shader_interface->uav_counter_count; ++i)
2935 {
2936 const struct vkd3d_shader_uav_counter_binding *current = &shader_interface->uav_counters[i];
2937
2938 if (!spirv_compiler_check_shader_visibility(compiler, current->shader_visibility))
2939 continue;
2940
2941 if (current->register_space != range->space || current->register_index > range->first
2942 || current->binding.count <= register_last - current->register_index)
2943 continue;
2944
2945 if (current->offset)
2946 {
2947 FIXME("Atomic counter offsets are not supported yet.\n");
2948 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING,
2949 "Descriptor binding for UAV counter %u, space %u has unsupported ‘offset’ %u.",
2950 range->first, range->space, current->offset);
2951 }
2952
2953 binding_address->binding_base_idx = current->register_index
2954 - (binding_offsets ? binding_offsets[i].static_offset : 0);
2955 binding_address->push_constant_index = binding_offsets ? binding_offsets[i].dynamic_offset_index : ~0u;
2956 return current->binding;
2957 }
2958 if (shader_interface->uav_counter_count)
2959 {
2960 FIXME("Could not find descriptor binding for UAV counter %u, space %u.\n", range->first, range->space);
2961 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_BINDING_NOT_FOUND,
2962 "Could not find descriptor binding for UAV counter %u, space %u.", range->first, range->space);
2963 }
2964 }
2965 else
2966 {
2967 binding_offsets = compiler->offset_info.binding_offsets;
2968 for (i = 0; i < shader_interface->binding_count; ++i)
2969 {
2970 const struct vkd3d_shader_resource_binding *current = &shader_interface->bindings[i];
2971
2972 if (!(current->flags & resource_type_flag))
2973 continue;
2974
2975 if (!spirv_compiler_check_shader_visibility(compiler, current->shader_visibility))
2976 continue;
2977
2978 if (current->type != descriptor_type || current->register_space != range->space
2979 || current->register_index > range->first
2980 || current->binding.count <= register_last - current->register_index)
2981 continue;
2982
2983 binding_address->binding_base_idx = current->register_index
2984 - (binding_offsets ? binding_offsets[i].static_offset : 0);
2985 binding_address->push_constant_index = binding_offsets ? binding_offsets[i].dynamic_offset_index : ~0u;
2986 return current->binding;
2987 }
2988 if (shader_interface->binding_count)
2989 {
2991 const char *range_str = buffer ? buffer->buffer : "";
2992 FIXME("Could not find descriptor binding for type %#x, space %u, registers %s, shader type %#x.\n",
2993 descriptor_type, range->space, range_str, compiler->shader_type);
2994 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_BINDING_NOT_FOUND,
2995 "Could not find descriptor binding for type %#x, space %u, registers %s, shader type %#x.",
2996 descriptor_type, range->space, range_str, compiler->shader_type);
2998 }
2999 }
3000
3001done:
3002 binding_address->binding_base_idx = range->first;
3003 binding_address->push_constant_index = ~0u;
3004 binding.set = 0;
3005 binding.count = 1;
3006 binding.binding = compiler->binding_idx++;
3007 return binding;
3008}
static struct vkd3d_string_buffer * vkd3d_shader_register_range_string(struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range)
Definition: spirv.c:2874
uint32_t binding_idx
Definition: spirv.c:2463
unsigned int push_constant_index
Definition: spirv.c:2213
const struct vkd3d_shader_resource_binding * bindings
const struct vkd3d_shader_uav_counter_binding * uav_counters
vkd3d_shader_descriptor_type
Definition: vkd3d_shader.h:420
void vkd3d_string_buffer_release(struct vkd3d_string_buffer_cache *cache, struct vkd3d_string_buffer *buffer)
@ VKD3D_SHADER_ERROR_SPV_INVALID_REGISTER_TYPE
@ VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_BINDING_NOT_FOUND

Referenced by spirv_compiler_build_descriptor_variable().

◆ spirv_compiler_get_descriptor_index()

static uint32_t spirv_compiler_get_descriptor_index ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
const struct vkd3d_symbol *  array_symbol,
unsigned int  binding_base_idx,
enum vkd3d_shader_resource_type  resource_type 
)
static

Definition at line 3638 of file spirv.c.

3641{
3642 const struct vkd3d_symbol_descriptor_array *array_key = &array_symbol->key.descriptor_array;
3643 struct vkd3d_shader_register_index index = reg->idx[1];
3644 unsigned int push_constant_index;
3645 uint32_t index_id;
3646
3647 if ((push_constant_index = array_key->push_constant_index) != ~0u || index.rel_addr)
3648 {
3649 if (!spirv_compiler_enable_descriptor_indexing(compiler, reg->type, resource_type))
3650 {
3651 FIXME("The target environment does not support descriptor indexing.\n");
3652 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_IDX_UNSUPPORTED,
3653 "Cannot dynamically index a descriptor array of type %#x, id %u. "
3654 "The target environment does not support descriptor indexing.", reg->type, reg->idx[0].offset);
3655 }
3656 }
3657
3658 index.offset -= binding_base_idx;
3659 index_id = spirv_compiler_emit_register_addressing(compiler, &index);
3660
3661 if (push_constant_index != ~0u)
3662 {
3663 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3664 uint32_t type_id, ptr_type_id, ptr_id, offset_id, index_ids[2];
3665
3667 if (!(offset_id = compiler->descriptor_offset_ids[push_constant_index]))
3668 {
3669 index_ids[0] = compiler->descriptor_offsets_member_id;
3670 index_ids[1] = spirv_compiler_get_constant_uint(compiler, push_constant_index);
3674 ptr_id = vkd3d_spirv_build_op_in_bounds_access_chain(builder, ptr_type_id,
3675 compiler->push_constants_var_id, index_ids, 2);
3676 offset_id = vkd3d_spirv_build_op_load(builder, type_id, ptr_id, SpvMemoryAccessMaskNone);
3678 compiler->descriptor_offset_ids[push_constant_index] = offset_id;
3679 }
3680 index_id = vkd3d_spirv_build_op_iadd(builder, type_id, index_id, offset_id);
3681 }
3682
3683 return index_id;
3684}
static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t base_id, uint32_t *indexes, uint32_t index_count)
Definition: spirv.c:1309
static bool spirv_compiler_enable_descriptor_indexing(struct spirv_compiler *compiler, enum vkd3d_shader_register_type reg_type, enum vkd3d_shader_resource_type resource_type)
Definition: spirv.c:3601
unsigned int push_constant_index
Definition: spirv.c:2175
struct vkd3d_symbol_descriptor_array descriptor_array
Definition: spirv.c:2241
@ VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_IDX_UNSUPPORTED

Referenced by spirv_compiler_emit_dereference_register(), spirv_compiler_emit_uav_counter_instruction(), and spirv_compiler_prepare_image().

◆ spirv_compiler_get_descriptor_info()

static const struct vkd3d_shader_descriptor_info1 * spirv_compiler_get_descriptor_info ( struct spirv_compiler *  compiler,
enum vkd3d_shader_descriptor_type  type,
const struct vkd3d_shader_register_range *  range 
)
static

Definition at line 6156 of file spirv.c.

6159{
6160 const struct vkd3d_shader_scan_descriptor_info1 *descriptor_info = compiler->scan_descriptor_info;
6161 unsigned int register_last = (range->last == ~0u) ? range->first : range->last;
6162 const struct vkd3d_shader_descriptor_info1 *d;
6163 unsigned int i;
6164
6165 for (i = 0; i < descriptor_info->descriptor_count; ++i)
6166 {
6167 d = &descriptor_info->descriptors[i];
6168 if (d->type == type && d->register_space == range->space && d->register_index <= range->first
6169 && (d->count == ~0u || d->count > register_last - d->register_index))
6170 return d;
6171 }
6172
6173 return NULL;
6174}
#define d
Definition: ke_i.h:81
struct vkd3d_shader_descriptor_info1 * descriptors

Referenced by spirv_compiler_get_image_type_id().

◆ spirv_compiler_get_discard_function_id()

static uint32_t spirv_compiler_get_discard_function_id ( struct spirv_compiler *  compiler)
static

Definition at line 8169 of file spirv.c.

8170{
8171 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8172
8173 if (!compiler->discard_function_id)
8174 compiler->discard_function_id = vkd3d_spirv_alloc_id(builder);
8175
8176 return compiler->discard_function_id;
8177}

Referenced by spirv_compiler_emit_discard().

◆ spirv_compiler_get_entry_point_name()

static const char * spirv_compiler_get_entry_point_name ( const struct spirv_compiler *  compiler)
static

Definition at line 2520 of file spirv.c.

2521{
2522 const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info;
2523
2524 return info && info->entry_point ? info->entry_point : "main";
2525}

Referenced by spirv_compiler_create(), and spirv_compiler_generate_spirv().

◆ spirv_compiler_get_image_type_id()

static uint32_t spirv_compiler_get_image_type_id ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
const struct vkd3d_shader_register_range *  range,
const struct vkd3d_spirv_resource_type *  resource_type_info,
enum vkd3d_shader_component_type  data_type,
bool  raw_structured 
)
static

Definition at line 6419 of file spirv.c.

6423{
6424 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6425 const struct vkd3d_shader_descriptor_info1 *d;
6426 bool uav_read, uav_atomics;
6427 uint32_t sampled_type_id;
6429
6431 if (reg->type == VKD3DSPR_UAV)
6432 {
6435 uav_read = !!(d->flags & VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_READ);
6436 uav_atomics = !!(d->flags & VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_ATOMICS);
6437 if (raw_structured || uav_atomics || (uav_read && !compiler->uav_read_without_format))
6439 else if (uav_read)
6441 }
6442
6443 sampled_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
6444 return vkd3d_spirv_get_op_type_image(builder, sampled_type_id, resource_type_info->dim,
6445 2, resource_type_info->arrayed, resource_type_info->ms,
6446 reg->type == VKD3DSPR_UAV ? 2 : 1, format);
6447}
static SpvImageFormat image_format_for_image_read(enum vkd3d_shader_component_type data_type)
Definition: spirv.c:6399
static uint32_t vkd3d_spirv_get_op_type_image(struct vkd3d_spirv_builder *builder, uint32_t sampled_type_id, SpvDim dim, uint32_t depth, uint32_t arrayed, uint32_t ms, uint32_t sampled, SpvImageFormat format)
Definition: spirv.c:1119
static const struct vkd3d_shader_descriptor_info1 * spirv_compiler_get_descriptor_info(struct spirv_compiler *compiler, enum vkd3d_shader_descriptor_type type, const struct vkd3d_shader_register_range *range)
Definition: spirv.c:6156
enum SpvImageFormat_ SpvImageFormat
@ SpvCapabilityStorageImageReadWithoutFormat
Definition: spirv.h:923
@ VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_ATOMICS

Referenced by spirv_compiler_emit_combined_sampler_declarations(), spirv_compiler_emit_resource_declaration(), and spirv_compiler_prepare_image().

◆ spirv_compiler_get_invocation_id()

static uint32_t spirv_compiler_get_invocation_id ( struct spirv_compiler *  compiler)
static

Definition at line 5004 of file spirv.c.

5005{
5006 struct vkd3d_shader_register r;
5007
5009
5011 return spirv_compiler_get_register_id(compiler, &r);
5012}
GLdouble GLdouble GLdouble r
Definition: gl.h:2055

Referenced by spirv_compiler_emit_load_invocation_id().

◆ spirv_compiler_get_label_id()

static uint32_t spirv_compiler_get_label_id ( struct spirv_compiler *  compiler,
unsigned int  block_id 
)
static

Definition at line 2890 of file spirv.c.

2891{
2892 --block_id;
2893 if (!compiler->block_label_ids[block_id])
2894 compiler->block_label_ids[block_id] = vkd3d_spirv_alloc_id(&compiler->spirv_builder);
2895 return compiler->block_label_ids[block_id];
2896}

Referenced by spirv_compiler_emit_branch(), spirv_compiler_emit_label(), spirv_compiler_emit_merge(), and spirv_compiler_emit_switch().

◆ spirv_compiler_get_output_array_index()

static uint32_t spirv_compiler_get_output_array_index ( struct spirv_compiler *  compiler,
const struct signature_element *  e 
)
static

Definition at line 5676 of file spirv.c.

5678{
5679 enum vkd3d_shader_sysval_semantic sysval = e->sysval_semantic;
5680 const struct vkd3d_spirv_builtin *builtin;
5681
5683
5684 switch (sysval)
5685 {
5688 return builtin->member_idx;
5689 default:
5690 return e->semantic_index;
5691 }
5692}
@ VKD3D_SHADER_SV_TESS_FACTOR_LINEDET
@ VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN

Referenced by spirv_compiler_emit_store_shader_output().

◆ spirv_compiler_get_register_id()

static uint32_t spirv_compiler_get_register_id ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 3748 of file spirv.c.

3750{
3751 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
3752 struct vkd3d_shader_register_info register_info;
3753
3754 if (spirv_compiler_get_register_info(compiler, reg, &register_info))
3755 {
3756 spirv_compiler_emit_dereference_register(compiler, reg, &register_info);
3757 return register_info.id;
3758 }
3759
3760 return spirv_compiler_emit_variable(compiler, &builder->global_stream,
3762}

Referenced by spirv_compiler_emit_default_control_point_phase(), spirv_compiler_emit_mov(), and spirv_compiler_get_invocation_id().

◆ spirv_compiler_get_register_info()

static bool spirv_compiler_get_register_info ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
struct vkd3d_shader_register_info *  register_info 
)
static

Definition at line 3555 of file spirv.c.

3557{
3558 struct vkd3d_symbol reg_symbol, *symbol;
3559 struct rb_entry *entry;
3560
3562
3563 if (reg->type == VKD3DSPR_TEMP)
3564 {
3565 VKD3D_ASSERT(reg->idx[0].offset < compiler->temp_count);
3566 register_info->id = compiler->temp_id + reg->idx[0].offset;
3567 register_info->storage_class = SpvStorageClassPrivate;
3568 register_info->descriptor_array = NULL;
3569 register_info->member_idx = 0;
3571 register_info->write_mask = VKD3DSP_WRITEMASK_ALL;
3572 register_info->structure_stride = 0;
3573 register_info->binding_base_idx = 0;
3574 register_info->is_aggregate = false;
3575 return true;
3576 }
3577
3578 vkd3d_symbol_make_register(&reg_symbol, reg);
3579 if (!(entry = rb_get(&compiler->symbol_table, &reg_symbol)))
3580 {
3581 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_REGISTER_TYPE,
3582 "Unrecognized register (%s).\n", debug_vkd3d_symbol(&reg_symbol));
3583 memset(register_info, 0, sizeof(*register_info));
3584 return false;
3585 }
3586
3587 symbol = RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
3588 register_info->id = symbol->id;
3589 register_info->descriptor_array = symbol->descriptor_array;
3590 register_info->storage_class = symbol->info.reg.storage_class;
3591 register_info->member_idx = symbol->info.reg.member_idx;
3592 register_info->component_type = symbol->info.reg.component_type;
3593 register_info->write_mask = symbol->info.reg.write_mask;
3594 register_info->structure_stride = symbol->info.reg.structure_stride;
3595 register_info->binding_base_idx = symbol->info.reg.binding_base_idx;
3596 register_info->is_aggregate = symbol->info.reg.is_aggregate;
3597
3598 return true;
3599}
static const char * debug_vkd3d_symbol(const struct vkd3d_symbol *symbol)
Definition: spirv.c:2362
unsigned int structure_stride
Definition: spirv.c:3550
@ VKD3DSPR_TEMP

Referenced by spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_default_control_point_phase(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_ld_tgsm(), spirv_compiler_emit_load_reg(), spirv_compiler_emit_mov(), spirv_compiler_emit_store_reg(), spirv_compiler_emit_store_tgsm(), spirv_compiler_get_register_id(), and spirv_compiler_prepare_image().

◆ spirv_compiler_get_register_name()

static bool spirv_compiler_get_register_name ( char *  buffer,
unsigned int  buffer_size,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 3177 of file spirv.c.

3179{
3180 unsigned int idx;
3181
3182 idx = reg->idx_count ? reg->idx[reg->idx_count - 1].offset : 0;
3183 switch (reg->type)
3184 {
3185 case VKD3DSPR_RESOURCE:
3186 snprintf(buffer, buffer_size, "t%u", reg->idx[0].offset);
3187 break;
3188 case VKD3DSPR_UAV:
3189 snprintf(buffer, buffer_size, "u%u", reg->idx[0].offset);
3190 break;
3191 case VKD3DSPR_SAMPLER:
3192 snprintf(buffer, buffer_size, "s%u", reg->idx[0].offset);
3193 break;
3195 snprintf(buffer, buffer_size, "cb%u_%u", reg->idx[0].offset, reg->idx[1].offset);
3196 break;
3197 case VKD3DSPR_RASTOUT:
3199 {
3200 snprintf(buffer, buffer_size, "oPts");
3201 break;
3202 }
3203 FIXME("Unhandled rastout register %#x.\n", idx);
3204 return false;
3205 case VKD3DSPR_INPUT:
3206 snprintf(buffer, buffer_size, "v%u", idx);
3207 break;
3208 case VKD3DSPR_OUTPUT:
3209 snprintf(buffer, buffer_size, "o%u", idx);
3210 break;
3211 case VKD3DSPR_COLOROUT:
3212 snprintf(buffer, buffer_size, "oC%u", idx);
3213 break;
3214 case VKD3DSPR_DEPTHOUT:
3217 snprintf(buffer, buffer_size, "oDepth");
3218 break;
3219 case VKD3DSPR_GSINSTID:
3220 snprintf(buffer, buffer_size, "vGSInstanceID");
3221 break;
3223 snprintf(buffer, buffer_size, "vpc%u", idx);
3224 break;
3225 case VKD3DSPR_TESSCOORD:
3226 snprintf(buffer, buffer_size, "vDomainLocation");
3227 break;
3228 case VKD3DSPR_THREADID:
3229 snprintf(buffer, buffer_size, "vThreadID");
3230 break;
3232 snprintf(buffer, buffer_size, "vThreadIDInGroup");
3233 break;
3235 snprintf(buffer, buffer_size, "vThreadIDInGroupFlattened");
3236 break;
3238 snprintf(buffer, buffer_size, "vThreadGroupID");
3239 break;
3241 snprintf(buffer, buffer_size, "g%u", reg->idx[0].offset);
3242 break;
3243 case VKD3DSPR_IDXTEMP:
3244 snprintf(buffer, buffer_size, "x%u", idx);
3245 break;
3246 case VKD3DSPR_COVERAGE:
3247 snprintf(buffer, buffer_size, "vCoverage");
3248 break;
3250 snprintf(buffer, buffer_size, "oMask");
3251 break;
3253 case VKD3DSPR_PRIMID:
3254 /* SPIRV-Tools disassembler generates names for SPIR-V built-ins. */
3255 return false;
3257 snprintf(buffer, buffer_size, "oStencilRef");
3258 break;
3260 snprintf(buffer, buffer_size, "vWaveLaneCount");
3261 break;
3263 snprintf(buffer, buffer_size, "vWaveLaneIndex");
3264 break;
3266 snprintf(buffer, buffer_size, "vPointCoord");
3267 break;
3268 default:
3269 FIXME("Unhandled register %#x.\n", reg->type);
3270 snprintf(buffer, buffer_size, "unrecognized_%#x", reg->type);
3271 return false;
3272 }
3273
3274 return true;
3275}
unsigned int idx
Definition: utils.c:40
wchar_t const *const size_t const buffer_size
Definition: stat.cpp:95
@ VKD3DSPR_PRIMID
@ VKD3DSPR_SAMPLEMASK
@ VKD3DSPR_GSINSTID
@ VKD3DSPR_COLOROUT
@ VKD3DSPR_DEPTHOUT
@ VKD3DSPR_WAVELANECOUNT
@ VKD3DSPR_TESSCOORD
@ VKD3DSPR_COVERAGE
@ VKD3DSPR_THREADGROUPID
@ VKD3DSPR_LOCALTHREADINDEX
@ VKD3DSPR_THREADID
@ VKD3DSPR_LOCALTHREADID
@ VKD3DSPR_WAVELANEINDEX
#define snprintf
Definition: wintirpc.h:48

Referenced by spirv_compiler_emit_register_debug_name().

◆ spirv_compiler_get_spec_constant()

static uint32_t spirv_compiler_get_spec_constant ( struct spirv_compiler *  compiler,
enum vkd3d_shader_parameter_name  name,
uint32_t  spec_id,
enum vkd3d_data_type  type,
unsigned int  component_count 
)
static

Definition at line 3416 of file spirv.c.

3419{
3420 unsigned int i;
3421
3422 for (i = 0; i < compiler->spec_constant_count; ++i)
3423 {
3424 if (compiler->spec_constants[i].name == name)
3425 return compiler->spec_constants[i].id;
3426 }
3427
3428 return spirv_compiler_emit_spec_constant(compiler, name, spec_id, type, component_count);
3429}
static uint32_t spirv_compiler_emit_spec_constant(struct spirv_compiler *compiler, enum vkd3d_shader_parameter_name name, uint32_t spec_id, enum vkd3d_data_type type, unsigned int component_count)
Definition: spirv.c:3377

Referenced by spirv_compiler_emit_shader_parameter().

◆ spirv_compiler_get_ssa_register_info()

static const struct ssa_register_info * spirv_compiler_get_ssa_register_info ( const struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 4184 of file spirv.c.

4186{
4187 VKD3D_ASSERT(reg->idx[0].offset < compiler->ssa_register_count);
4188 VKD3D_ASSERT(reg->idx_count == 1);
4189 return &compiler->ssa_register_info[reg->idx[0].offset];
4190}

Referenced by spirv_compiler_emit_load_ssa_reg().

◆ spirv_compiler_get_target_environment()

static enum vkd3d_shader_spirv_environment spirv_compiler_get_target_environment ( const struct spirv_compiler *  compiler)
static

◆ spirv_compiler_get_type_id_for_dst()

◆ spirv_compiler_get_type_id_for_reg()

static uint32_t spirv_compiler_get_type_id_for_reg ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  write_mask 
)
static

◆ spirv_compiler_handle_instruction()

static int spirv_compiler_handle_instruction ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_instruction *  instruction 
)
static

Definition at line 10196 of file spirv.c.

10198{
10199 int ret = VKD3D_OK;
10200
10201 compiler->location = instruction->location;
10202
10203 switch (instruction->opcode)
10204 {
10207 break;
10210 break;
10213 break;
10216 break;
10218 case VKD3DSIH_DCL_INPUT:
10220 break;
10223 break;
10226 break;
10229 break;
10232 break;
10235 break;
10238 break;
10241 break;
10244 break;
10247 instruction->declaration.tessellator_output_primitive);
10248 break;
10251 instruction->declaration.tessellator_partitioning);
10252 break;
10257 break;
10258 case VKD3DSIH_DMOV:
10259 case VKD3DSIH_MOV:
10261 break;
10262 case VKD3DSIH_DMOVC:
10263 case VKD3DSIH_MOVC:
10264 case VKD3DSIH_CMP:
10266 break;
10267 case VKD3DSIH_SWAPC:
10269 break;
10270 case VKD3DSIH_ADD:
10271 case VKD3DSIH_AND:
10272 case VKD3DSIH_BFREV:
10273 case VKD3DSIH_COUNTBITS:
10274 case VKD3DSIH_DADD:
10275 case VKD3DSIH_DDIV:
10276 case VKD3DSIH_DIV:
10277 case VKD3DSIH_DMUL:
10278 case VKD3DSIH_DTOF:
10279 case VKD3DSIH_FREM:
10280 case VKD3DSIH_FTOD:
10281 case VKD3DSIH_IADD:
10282 case VKD3DSIH_INEG:
10283 case VKD3DSIH_ISHL:
10284 case VKD3DSIH_ISHR:
10285 case VKD3DSIH_ISINF:
10286 case VKD3DSIH_ISNAN:
10287 case VKD3DSIH_ITOD:
10288 case VKD3DSIH_ITOF:
10289 case VKD3DSIH_ITOI:
10290 case VKD3DSIH_MUL:
10291 case VKD3DSIH_NOT:
10292 case VKD3DSIH_OR:
10293 case VKD3DSIH_USHR:
10294 case VKD3DSIH_UTOD:
10295 case VKD3DSIH_UTOF:
10296 case VKD3DSIH_UTOU:
10297 case VKD3DSIH_XOR:
10299 break;
10300 case VKD3DSIH_ISFINITE:
10302 break;
10303 case VKD3DSIH_ABS:
10304 case VKD3DSIH_ACOS:
10305 case VKD3DSIH_ASIN:
10306 case VKD3DSIH_ATAN:
10307 case VKD3DSIH_HCOS:
10308 case VKD3DSIH_HSIN:
10309 case VKD3DSIH_HTAN:
10310 case VKD3DSIH_DFMA:
10311 case VKD3DSIH_DMAX:
10312 case VKD3DSIH_DMIN:
10313 case VKD3DSIH_EXP:
10317 case VKD3DSIH_FRC:
10318 case VKD3DSIH_IMAX:
10319 case VKD3DSIH_IMIN:
10320 case VKD3DSIH_LOG:
10321 case VKD3DSIH_MAD:
10322 case VKD3DSIH_MAX:
10323 case VKD3DSIH_MIN:
10324 case VKD3DSIH_ROUND_NE:
10325 case VKD3DSIH_ROUND_NI:
10326 case VKD3DSIH_ROUND_PI:
10327 case VKD3DSIH_ROUND_Z:
10328 case VKD3DSIH_RSQ:
10329 case VKD3DSIH_SQRT:
10330 case VKD3DSIH_TAN:
10331 case VKD3DSIH_UMAX:
10332 case VKD3DSIH_UMIN:
10334 break;
10335 case VKD3DSIH_DP4:
10336 case VKD3DSIH_DP3:
10337 case VKD3DSIH_DP2:
10339 break;
10340 case VKD3DSIH_DRCP:
10341 case VKD3DSIH_RCP:
10343 break;
10344 case VKD3DSIH_SINCOS:
10346 break;
10347 case VKD3DSIH_IMUL:
10348 case VKD3DSIH_UMUL:
10350 break;
10351 case VKD3DSIH_IMAD:
10353 break;
10354 case VKD3DSIH_IDIV:
10355 case VKD3DSIH_UDIV:
10357 break;
10358 case VKD3DSIH_DTOI:
10359 case VKD3DSIH_FTOI:
10361 break;
10362 case VKD3DSIH_DTOU:
10363 case VKD3DSIH_FTOU:
10365 break;
10366 case VKD3DSIH_DEQO:
10367 case VKD3DSIH_DGEO:
10368 case VKD3DSIH_DLT:
10369 case VKD3DSIH_DNE:
10370 case VKD3DSIH_EQO:
10371 case VKD3DSIH_EQU:
10372 case VKD3DSIH_GEO:
10373 case VKD3DSIH_GEU:
10374 case VKD3DSIH_IEQ:
10375 case VKD3DSIH_IGE:
10376 case VKD3DSIH_ILT:
10377 case VKD3DSIH_INE:
10378 case VKD3DSIH_LTO:
10379 case VKD3DSIH_LTU:
10380 case VKD3DSIH_NEO:
10381 case VKD3DSIH_NEU:
10382 case VKD3DSIH_UGE:
10383 case VKD3DSIH_ULT:
10385 break;
10386 case VKD3DSIH_ORD:
10387 case VKD3DSIH_UNO:
10389 break;
10390 case VKD3DSIH_SLT:
10391 case VKD3DSIH_SGE:
10393 break;
10394 case VKD3DSIH_BFI:
10395 case VKD3DSIH_IBFE:
10396 case VKD3DSIH_UBFE:
10398 break;
10399 case VKD3DSIH_F16TOF32:
10401 break;
10402 case VKD3DSIH_F32TOF16:
10404 break;
10405 case VKD3DSIH_RET:
10407 break;
10408 case VKD3DSIH_RETP:
10410 break;
10411 case VKD3DSIH_DISCARD:
10413 break;
10414 case VKD3DSIH_LABEL:
10416 break;
10417 case VKD3DSIH_BRANCH:
10419 break;
10422 break;
10423 case VKD3DSIH_DSX:
10425 case VKD3DSIH_DSX_FINE:
10426 case VKD3DSIH_DSY:
10428 case VKD3DSIH_DSY_FINE:
10430 break;
10431 case VKD3DSIH_LD2DMS:
10432 case VKD3DSIH_LD:
10434 break;
10435 case VKD3DSIH_LOD:
10437 break;
10438 case VKD3DSIH_SAMPLE:
10439 case VKD3DSIH_SAMPLE_B:
10443 break;
10444 case VKD3DSIH_SAMPLE_C:
10447 break;
10448 case VKD3DSIH_GATHER4:
10449 case VKD3DSIH_GATHER4_C:
10453 break;
10454 case VKD3DSIH_LD_RAW:
10457 break;
10458 case VKD3DSIH_STORE_RAW:
10461 break;
10464 break;
10467 break;
10471 break;
10477 case VKD3DSIH_ATOMIC_OR:
10492 break;
10493 case VKD3DSIH_BUFINFO:
10495 break;
10496 case VKD3DSIH_RESINFO:
10498 break;
10501 break;
10504 break;
10508 break;
10509 case VKD3DSIH_SYNC:
10511 break;
10512 case VKD3DSIH_EMIT:
10515 break;
10516 case VKD3DSIH_CUT:
10519 break;
10524 break;
10527 break;
10532 break;
10535 break;
10548 break;
10552 break;
10555 break;
10558 break;
10561 break;
10573 case VKD3DSIH_HS_DECLS:
10574 case VKD3DSIH_NOP:
10575 /* nothing to do */
10576 break;
10577 default:
10578 FIXME("Unhandled instruction %#x.\n", instruction->opcode);
10579 spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER,
10580 "Encountered invalid/unhandled instruction handler %#x.", instruction->opcode);
10581 break;
10582 }
10583
10584 return ret;
10585}
static void spirv_compiler_emit_int_div(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7717
static enum vkd3d_result spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7236
static void spirv_compiler_emit_ld(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8607
static void spirv_compiler_emit_branch(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8289
static void spirv_compiler_emit_dcl_gs_instances(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6819
static void spirv_compiler_emit_label(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8251
static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7878
static void spirv_compiler_emit_imul(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7672
static void spirv_compiler_emit_store_raw_structured(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9161
static void spirv_compiler_emit_deriv_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8373
static void spirv_compiler_emit_gather4(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8795
static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9693
static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9382
static void spirv_compiler_emit_ftoi(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7778
static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9565
static void spirv_compiler_emit_ld_raw_structured(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9026
static void spirv_compiler_emit_sincos(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7637
static void spirv_compiler_emit_wave_active_ballot(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10044
static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7937
static void spirv_compiler_emit_output_vertex_count(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6732
static void spirv_compiler_emit_dcl_tgsm_raw(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6685
static void spirv_compiler_emit_swapc(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7549
static void spirv_compiler_emit_dcl_input_primitive(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6739
static void spirv_compiler_enter_shader_phase(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6945
static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6325
static void spirv_compiler_emit_wave_read_lane_at(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10138
static void spirv_compiler_emit_eval_attrib(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9789
static void spirv_compiler_emit_wave_read_lane_first(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10166
static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9513
static void spirv_compiler_emit_ftou(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7832
static void spirv_compiler_emit_quad_read_across(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9952
static void spirv_compiler_emit_uav_counter_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9262
static void spirv_compiler_emit_dot(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7576
static void spirv_compiler_emit_isfinite(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7317
static void spirv_compiler_emit_sample_info(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9656
static void spirv_compiler_emit_quad_read_lane_at(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9971
static void spirv_compiler_emit_wave_bit_count(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10109
static void spirv_compiler_emit_store_uav_typed(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9221
static void spirv_compiler_emit_sync(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9843
static void spirv_compiler_emit_wave_alu_op(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10085
static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6024
static void spirv_compiler_emit_cut_stream(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9917
static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8006
static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7970
static void spirv_compiler_emit_discard(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8220
static void spirv_compiler_emit_dcl_input(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6702
static void spirv_compiler_emit_wave_bool_op(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10011
static void spirv_compiler_emit_dcl_output(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6714
static void spirv_compiler_emit_dcl_tessellator_domain(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6825
static void spirv_compiler_emit_wave_is_first_lane(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:10127
static void spirv_compiler_emit_switch(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8332
static void spirv_compiler_emit_movc(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7518
static void spirv_compiler_emit_ext_glsl_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7386
static void spirv_compiler_emit_float_comparison_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8075
static void spirv_compiler_emit_imad(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7696
static void spirv_compiler_emit_lod(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8654
static void spirv_compiler_emit_emit_stream(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9896
static void spirv_compiler_emit_retc(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8155
static void spirv_compiler_emit_dcl_stream(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6723
static void spirv_compiler_emit_rcp(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7616
static void spirv_compiler_emit_sample_c(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8749
static void spirv_compiler_emit_mov(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:7443
static void spirv_compiler_emit_dcl_tgsm_structured(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6693
static void spirv_compiler_emit_orderedness_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8055
static void spirv_compiler_emit_ld_uav_typed(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:9178
static void spirv_compiler_emit_dcl_output_topology(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:6793
static void spirv_compiler_emit_sample(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction)
Definition: spirv.c:8680
@ VKD3DSIH_NOP
@ VKD3DSIH_RESINFO
@ VKD3DSIH_DP2
@ VKD3DSIH_IMAD
@ VKD3DSIH_F16TOF32
@ VKD3DSIH_UMUL
@ VKD3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER
@ VKD3DSIH_AND
@ VKD3DSIH_QUAD_READ_LANE_AT
@ VKD3DSIH_IMM_ATOMIC_UMAX
@ VKD3DSIH_DMOV
@ VKD3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE
@ VKD3DSIH_WAVE_READ_LANE_AT
@ VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT
@ VKD3DSIH_IMUL
@ VKD3DSIH_SAMPLE_INFO
@ VKD3DSIH_HSIN
@ VKD3DSIH_ROUND_PI
@ VKD3DSIH_RETP
@ VKD3DSIH_DCL_INPUT_PS
@ VKD3DSIH_ATOMIC_OR
@ VKD3DSIH_IADD
@ VKD3DSIH_ISINF
@ VKD3DSIH_DCL_INPUT_PRIMITIVE
@ VKD3DSIH_DRCP
@ VKD3DSIH_DIV
@ VKD3DSIH_STORE_UAV_TYPED
@ VKD3DSIH_WAVE_IS_FIRST_LANE
@ VKD3DSIH_DTOI
@ VKD3DSIH_UNO
@ VKD3DSIH_DTOF
@ VKD3DSIH_DCL_OUTPUT
@ VKD3DSIH_LD_UAV_TYPED
@ VKD3DSIH_XOR
@ VKD3DSIH_DCL_GS_INSTANCES
@ VKD3DSIH_UMAX
@ VKD3DSIH_LD_STRUCTURED
@ VKD3DSIH_DCL_OUTPUT_SIV
@ VKD3DSIH_SAMPLE_C
@ VKD3DSIH_ATOMIC_XOR
@ VKD3DSIH_DCL_RESOURCE_RAW
@ VKD3DSIH_FTOD
@ VKD3DSIH_DCL_VERTICES_OUT
@ VKD3DSIH_ISNAN
@ VKD3DSIH_DADD
@ VKD3DSIH_DCL_INPUT_SGV
@ VKD3DSIH_ROUND_NE
@ VKD3DSIH_DCL_OUTPUT_TOPOLOGY
@ VKD3DSIH_IMM_ATOMIC_CONSUME
@ VKD3DSIH_ACOS
@ VKD3DSIH_MUL
@ VKD3DSIH_DCL_UAV_RAW
@ VKD3DSIH_EXP
@ VKD3DSIH_DISCARD
@ VKD3DSIH_SWAPC
@ VKD3DSIH_BFREV
@ VKD3DSIH_HS_DECLS
@ VKD3DSIH_DFMA
@ VKD3DSIH_ATOMIC_UMIN
@ VKD3DSIH_ATOMIC_AND
@ VKD3DSIH_MIN
@ VKD3DSIH_RCP
@ VKD3DSIH_SAMPLE_POS
@ VKD3DSIH_HTAN
@ VKD3DSIH_UDIV
@ VKD3DSIH_RSQ
@ VKD3DSIH_UTOD
@ VKD3DSIH_LOD
@ VKD3DSIH_DCL_HS_MAX_TESSFACTOR
@ VKD3DSIH_IMAX
@ VKD3DSIH_FTOI
@ VKD3DSIH_TAN
@ VKD3DSIH_DCL_UAV_STRUCTURED
@ VKD3DSIH_DCL_INPUT
@ VKD3DSIH_LOG
@ VKD3DSIH_ROUND_NI
@ VKD3DSIH_DMAX
@ VKD3DSIH_DCL_INPUT_PS_SIV
@ VKD3DSIH_IMM_ATOMIC_IADD
@ VKD3DSIH_IMM_ATOMIC_EXCH
@ VKD3DSIH_DCL_TGSM_RAW
@ VKD3DSIH_SYNC
@ VKD3DSIH_ATOMIC_IADD
@ VKD3DSIH_ATOMIC_CMP_STORE
@ VKD3DSIH_LD_RAW
@ VKD3DSIH_ATOMIC_UMAX
@ VKD3DSIH_IMM_ATOMIC_IMIN
@ VKD3DSIH_DCL_STREAM
@ VKD3DSIH_F32TOF16
@ VKD3DSIH_IMM_ATOMIC_IMAX
@ VKD3DSIH_NOT
@ VKD3DSIH_MAD
@ VKD3DSIH_IMM_ATOMIC_AND
@ VKD3DSIH_ATAN
@ VKD3DSIH_DMIN
@ VKD3DSIH_WAVE_ACTIVE_BALLOT
@ VKD3DSIH_ADD
@ VKD3DSIH_DCL_TGSM_STRUCTURED
@ VKD3DSIH_DCL_RESOURCE_STRUCTURED
@ VKD3DSIH_DCL_INPUT_SIV
@ VKD3DSIH_MOVC
@ VKD3DSIH_WAVE_READ_LANE_FIRST
@ VKD3DSIH_ASIN
@ VKD3DSIH_MOV
@ VKD3DSIH_DTOU
@ VKD3DSIH_DMOVC
@ VKD3DSIH_MAX
@ VKD3DSIH_ISFINITE
@ VKD3DSIH_IMIN
@ VKD3DSIH_STORE_RAW
@ VKD3DSIH_SWITCH_MONOLITHIC
@ VKD3DSIH_BUFINFO
@ VKD3DSIH_FTOU
@ VKD3DSIH_IMM_ATOMIC_OR
@ VKD3DSIH_OR
@ VKD3DSIH_DCL_TESSELLATOR_DOMAIN
@ VKD3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT
@ VKD3DSIH_STORE_STRUCTURED
@ VKD3DSIH_CUT
@ VKD3DSIH_FRC
@ VKD3DSIH_ITOD
@ VKD3DSIH_IMM_ATOMIC_UMIN
@ VKD3DSIH_DCL_INPUT_PS_SGV
@ VKD3DSIH_EMIT
@ VKD3DSIH_LD
@ VKD3DSIH_DCL_INDEXABLE_TEMP
@ VKD3DSIH_FREM
@ VKD3DSIH_LABEL
@ VKD3DSIH_INEG
@ VKD3DSIH_IMM_ATOMIC_CMP_EXCH
@ VKD3DSIH_ROUND_Z
@ VKD3DSIH_SINCOS
@ VKD3DSIH_UMIN
@ VKD3DSIH_ATOMIC_IMIN
@ VKD3DSIH_RET
@ VKD3DSIH_BRANCH
@ VKD3DSIH_GATHER4
@ VKD3DSIH_ABS
@ VKD3DSIH_SQRT
@ VKD3DSIH_DMUL
@ VKD3DSIH_WAVE_ALL_BIT_COUNT
@ VKD3DSIH_ATOMIC_IMAX
@ VKD3DSIH_HCOS
@ VKD3DSIH_DDIV
@ VKD3DSIH_DCL_TESSELLATOR_PARTITIONING

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_has_combined_sampler_for_resource()

static bool spirv_compiler_has_combined_sampler_for_resource ( const struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range 
)
static

Definition at line 2797 of file spirv.c.

2799{
2800 const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
2801 const struct vkd3d_shader_combined_resource_sampler *combined_sampler;
2802 unsigned int i;
2803
2804 if (!shader_interface->combined_sampler_count)
2805 return false;
2806
2807 if (range->last != range->first)
2808 return false;
2809
2810 for (i = 0; i < shader_interface->combined_sampler_count; ++i)
2811 {
2812 combined_sampler = &shader_interface->combined_samplers[i];
2813
2814 if (!spirv_compiler_check_shader_visibility(compiler, combined_sampler->shader_visibility))
2815 continue;
2816
2817 if ((combined_sampler->resource_space == range->space
2818 && combined_sampler->resource_index == range->first))
2819 return true;
2820 }
2821
2822 return false;
2823}
enum vkd3d_shader_visibility shader_visibility
Definition: vkd3d_shader.h:989

Referenced by spirv_compiler_emit_resource_declaration().

◆ spirv_compiler_has_combined_sampler_for_sampler()

static bool spirv_compiler_has_combined_sampler_for_sampler ( const struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range 
)
static

Definition at line 2825 of file spirv.c.

2827{
2828 const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface;
2829 const struct vkd3d_shader_combined_resource_sampler *combined_sampler;
2830 unsigned int i;
2831
2832 if (!shader_interface->combined_sampler_count)
2833 return false;
2834
2835 if (range->last != range->first)
2836 return false;
2837
2838 for (i = 0; i < shader_interface->combined_sampler_count; ++i)
2839 {
2840 combined_sampler = &shader_interface->combined_samplers[i];
2841
2842 if (!spirv_compiler_check_shader_visibility(compiler, combined_sampler->shader_visibility))
2843 continue;
2844
2845 if (combined_sampler->sampler_space == range->space
2846 && combined_sampler->sampler_index == range->first)
2847 return true;
2848 }
2849
2850 return false;
2851}

Referenced by spirv_compiler_emit_sampler_declaration().

◆ spirv_compiler_init_blocks()

static bool spirv_compiler_init_blocks ( struct spirv_compiler *  compiler,
unsigned int  block_count 
)
static

Definition at line 8241 of file spirv.c.

8242{
8243 compiler->block_count = block_count;
8244
8245 if (!(compiler->block_label_ids = vkd3d_calloc(block_count, sizeof(*compiler->block_label_ids))))
8246 return false;
8247
8248 return true;
8249}
unsigned int block_count
Definition: spirv.c:2495

Referenced by spirv_compiler_generate_spirv().

◆ spirv_compiler_initialise_block()

static void spirv_compiler_initialise_block ( struct spirv_compiler *  compiler)
static

Definition at line 6977 of file spirv.c.

6978{
6979 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6980
6981 /* Insertion locations must point immediately after the function's initial label. */
6982 if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
6983 {
6984 struct vkd3d_shader_phase *phase = (compiler->phase == VKD3DSIH_HS_CONTROL_POINT_PHASE)
6985 ? &compiler->control_point_phase : &compiler->patch_constant_phase;
6986 if (!phase->function_location)
6988 }
6989 else if (!builder->main_function_location)
6990 {
6992 }
6993
6994 /* I/O declarations can result in emission of fixups, which must occur after the initial label. */
6995 if (!compiler->prolog_emitted)
6996 {
6999 compiler->prolog_emitted = true;
7000 }
7001}
static void spirv_compiler_emit_main_prolog(struct spirv_compiler *compiler)
Definition: spirv.c:10183
static size_t vkd3d_spirv_stream_current_location(struct vkd3d_spirv_stream *stream)
Definition: spirv.c:312
static void spirv_compiler_emit_io_declarations(struct spirv_compiler *compiler)
Definition: spirv.c:10587
bool prolog_emitted
Definition: spirv.c:2447

Referenced by spirv_compiler_emit_default_control_point_phase(), and spirv_compiler_emit_label().

◆ spirv_compiler_is_opengl_target()

◆ spirv_compiler_is_spirv_min_1_3_target()

static bool spirv_compiler_is_spirv_min_1_3_target ( const struct spirv_compiler *  compiler)
static

Definition at line 2728 of file spirv.c.

Referenced by spirv_compiler_emit_global_flags().

◆ spirv_compiler_is_target_extension_supported()

static bool spirv_compiler_is_target_extension_supported ( const struct spirv_compiler *  compiler,
enum vkd3d_shader_spirv_extension  extension 
)
static

Definition at line 2733 of file spirv.c.

2735{
2736 const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info;
2737 unsigned int i;
2738
2739 for (i = 0; info && i < info->extension_count; ++i)
2740 {
2741 if (info->extensions[i] == extension)
2742 return true;
2743 }
2744
2745 return false;
2746}

Referenced by spirv_compiler_decorate_builtin(), spirv_compiler_emit_discard_function(), spirv_compiler_emit_register_execution_mode(), spirv_compiler_emit_resource_declaration(), and spirv_compiler_enable_descriptor_indexing().

◆ spirv_compiler_leave_shader_phase()

static void spirv_compiler_leave_shader_phase ( struct spirv_compiler *  compiler)
static

Definition at line 6921 of file spirv.c.

6922{
6923 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
6924
6927
6929
6930 if (is_in_control_point_phase(compiler))
6931 {
6932 if (compiler->epilogue_function_id)
6933 {
6934 spirv_compiler_emit_shader_phase_name(compiler, compiler->epilogue_function_id, "_epilogue");
6936 }
6937
6938 /* Fork and join phases share output registers (patch constants).
6939 * Control point phase has separate output registers. */
6940 memset(compiler->private_output_variable, 0, sizeof(compiler->private_output_variable));
6942 }
6943}
static void spirv_compiler_emit_default_control_point_phase(struct spirv_compiler *compiler)
Definition: spirv.c:7003

Referenced by spirv_compiler_enter_shader_phase(), and spirv_compiler_generate_spirv().

◆ spirv_compiler_map_alu_instruction()

static SpvOp spirv_compiler_map_alu_instruction ( const struct vkd3d_shader_instruction *  instruction)
static

Definition at line 7133 of file spirv.c.

7134{
7135 static const struct
7136 {
7137 enum vkd3d_shader_opcode opcode;
7138 SpvOp spirv_op;
7139 }
7140 alu_ops[] =
7141 {
7172 };
7173 unsigned int i;
7174
7175 for (i = 0; i < ARRAY_SIZE(alu_ops); ++i)
7176 {
7177 if (alu_ops[i].opcode == instruction->opcode)
7178 return alu_ops[i].spirv_op;
7179 }
7180
7181 return SpvOpMax;
7182}
@ SpvOpShiftRightLogical
Definition: spirv.h:1375
@ SpvOpSNegate
Definition: spirv.h:1310
@ SpvOpFRem
Definition: spirv.h:1324
@ SpvOpUConvert
Definition: spirv.h:1298
@ SpvOpIsInf
Definition: spirv.h:1340
@ SpvOpFDiv
Definition: spirv.h:1320
@ SpvOpShiftLeftLogical
Definition: spirv.h:1377
@ SpvOpBitReverse
Definition: spirv.h:1385
@ SpvOpConvertUToF
Definition: spirv.h:1297
@ SpvOpConvertSToF
Definition: spirv.h:1296
@ SpvOpSConvert
Definition: spirv.h:1299
@ SpvOpBitwiseOr
Definition: spirv.h:1378
@ SpvOpBitwiseXor
Definition: spirv.h:1379
@ SpvOpFConvert
Definition: spirv.h:1300
@ SpvOpFAdd
Definition: spirv.h:1313
@ SpvOpShiftRightArithmetic
Definition: spirv.h:1376
@ SpvOpFMul
Definition: spirv.h:1317
@ SpvOpIAdd
Definition: spirv.h:1312
@ SpvOpBitwiseAnd
Definition: spirv.h:1380
@ SpvOpBitCount
Definition: spirv.h:1386
@ SpvOpNot
Definition: spirv.h:1381

Referenced by spirv_compiler_emit_alu_instruction().

◆ spirv_compiler_map_atomic_instruction()

static SpvOp spirv_compiler_map_atomic_instruction ( const struct vkd3d_shader_instruction *  instruction)
static

Definition at line 9337 of file spirv.c.

9338{
9339 static const struct
9340 {
9341 enum vkd3d_shader_opcode opcode;
9342 SpvOp spirv_op;
9343 }
9344 atomic_ops[] =
9345 {
9365 };
9366 unsigned int i;
9367
9368 for (i = 0; i < ARRAY_SIZE(atomic_ops); ++i)
9369 {
9370 if (atomic_ops[i].opcode == instruction->opcode)
9371 return atomic_ops[i].spirv_op;
9372 }
9373
9374 return SpvOpMax;
9375}
@ SpvOpAtomicExchange
Definition: spirv.h:1404
@ SpvOpAtomicSMax
Definition: spirv.h:1413
@ SpvOpAtomicUMax
Definition: spirv.h:1414
@ SpvOpAtomicSMin
Definition: spirv.h:1411
@ SpvOpAtomicAnd
Definition: spirv.h:1415
@ SpvOpAtomicIAdd
Definition: spirv.h:1409
@ SpvOpAtomicUMin
Definition: spirv.h:1412
@ SpvOpAtomicOr
Definition: spirv.h:1416
@ SpvOpAtomicCompareExchange
Definition: spirv.h:1405
@ SpvOpAtomicXor
Definition: spirv.h:1417

Referenced by spirv_compiler_emit_atomic_instruction().

◆ spirv_compiler_map_ext_glsl_instruction()

static enum GLSLstd450 spirv_compiler_map_ext_glsl_instruction ( const struct vkd3d_shader_instruction *  instruction)
static

Definition at line 7334 of file spirv.c.

7336{
7337 static const struct
7338 {
7339 enum vkd3d_shader_opcode opcode;
7340 enum GLSLstd450 glsl_inst;
7341 }
7342 glsl_insts[] =
7343 {
7374 };
7375 unsigned int i;
7376
7377 for (i = 0; i < ARRAY_SIZE(glsl_insts); ++i)
7378 {
7379 if (glsl_insts[i].opcode == instruction->opcode)
7380 return glsl_insts[i].glsl_inst;
7381 }
7382
7383 return GLSLstd450Bad;
7384}
@ GLSLstd450FAbs
Definition: GLSL.std.450.h:39
@ GLSLstd450Sqrt
Definition: GLSL.std.450.h:68
@ GLSLstd450NMin
Definition: GLSL.std.450.h:124
@ GLSLstd450Asin
Definition: GLSL.std.450.h:52
@ GLSLstd450RoundEven
Definition: GLSL.std.450.h:37
@ GLSLstd450FindSMsb
Definition: GLSL.std.450.h:117
@ GLSLstd450Floor
Definition: GLSL.std.450.h:43
@ GLSLstd450Log2
Definition: GLSL.std.450.h:67
@ GLSLstd450FindUMsb
Definition: GLSL.std.450.h:118
@ GLSLstd450FindILsb
Definition: GLSL.std.450.h:116
@ GLSLstd450Acos
Definition: GLSL.std.450.h:53
@ GLSLstd450UMax
Definition: GLSL.std.450.h:80
@ GLSLstd450InverseSqrt
Definition: GLSL.std.450.h:69
@ GLSLstd450Fma
Definition: GLSL.std.450.h:90
@ GLSLstd450Cosh
Definition: GLSL.std.450.h:56
@ GLSLstd450Exp2
Definition: GLSL.std.450.h:66
@ GLSLstd450SMax
Definition: GLSL.std.450.h:81
@ GLSLstd450Fract
Definition: GLSL.std.450.h:45
@ GLSLstd450NMax
Definition: GLSL.std.450.h:125
@ GLSLstd450Trunc
Definition: GLSL.std.450.h:38
@ GLSLstd450Tanh
Definition: GLSL.std.450.h:57
@ GLSLstd450Atan
Definition: GLSL.std.450.h:54
@ GLSLstd450Tan
Definition: GLSL.std.450.h:51
@ GLSLstd450UMin
Definition: GLSL.std.450.h:77
@ GLSLstd450Ceil
Definition: GLSL.std.450.h:44
@ GLSLstd450SMin
Definition: GLSL.std.450.h:78
@ GLSLstd450Sinh
Definition: GLSL.std.450.h:55

Referenced by spirv_compiler_emit_ext_glsl_instruction().

◆ spirv_compiler_map_logical_instruction()

static SpvOp spirv_compiler_map_logical_instruction ( const struct vkd3d_shader_instruction *  instruction)
static

Definition at line 7184 of file spirv.c.

7185{
7186 switch (instruction->opcode)
7187 {
7188 case VKD3DSIH_AND:
7189 return SpvOpLogicalAnd;
7190 case VKD3DSIH_OR:
7191 return SpvOpLogicalOr;
7192 case VKD3DSIH_XOR:
7193 return SpvOpLogicalNotEqual;
7194 default:
7195 return SpvOpMax;
7196 }
7197}
@ SpvOpLogicalNotEqual
Definition: spirv.h:1348
@ SpvOpLogicalOr
Definition: spirv.h:1349
@ SpvOpLogicalAnd
Definition: spirv.h:1350

Referenced by spirv_compiler_emit_alu_instruction().

◆ spirv_compiler_prepare_image()

static void spirv_compiler_prepare_image ( struct spirv_compiler *  compiler,
struct vkd3d_shader_image *  image,
const struct vkd3d_shader_register *  resource_reg,
const struct vkd3d_shader_register *  sampler_reg,
unsigned int  flags 
)
static

Definition at line 8490 of file spirv.c.

8493{
8494 struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
8495 uint32_t sampler_var_id, sampler_id, sampled_image_type_id;
8496 const struct vkd3d_symbol *symbol = NULL;
8497 bool load, sampled;
8498
8500 sampled = flags & VKD3D_IMAGE_FLAG_SAMPLED;
8501
8502 if (resource_reg->type == VKD3DSPR_RESOURCE)
8503 symbol = spirv_compiler_find_combined_sampler(compiler, resource_reg, sampler_reg);
8504 if (!symbol)
8505 symbol = spirv_compiler_find_resource(compiler, resource_reg);
8506
8507 if (symbol->descriptor_array)
8508 {
8509 const struct vkd3d_symbol_descriptor_array_data *array_data = &symbol->descriptor_array->info.descriptor_array;
8510 uint32_t ptr_type_id, index_id;
8511
8512 index_id = spirv_compiler_get_descriptor_index(compiler, resource_reg, symbol->descriptor_array,
8513 symbol->info.resource.binding_base_idx, symbol->info.resource.resource_type_info->resource_type);
8514
8515 ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, array_data->storage_class,
8516 array_data->contained_type_id);
8517 image->image_type_id = array_data->contained_type_id;
8518
8519 image->id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, symbol->id, &index_id, 1);
8520 }
8521 else
8522 {
8523 image->id = symbol->id;
8524 image->image_type_id = symbol->info.resource.type_id;
8525 }
8526 image->sampled_type = symbol->info.resource.sampled_type;
8527 image->resource_type_info = symbol->info.resource.resource_type_info;
8528 image->structure_stride = symbol->info.resource.structure_stride;
8529 image->raw = symbol->info.resource.raw;
8530
8531 if (symbol->type == VKD3D_SYMBOL_COMBINED_SAMPLER)
8532 {
8533 sampled_image_type_id = vkd3d_spirv_get_op_type_sampled_image(builder, image->image_type_id);
8534 image->sampled_image_id = vkd3d_spirv_build_op_load(builder,
8535 sampled_image_type_id, image->id, SpvMemoryAccessMaskNone);
8536 image->image_id = !sampled ? vkd3d_spirv_build_op_image(builder,
8537 image->image_type_id, image->sampled_image_id) : 0;
8538 return;
8539 }
8540
8541 if (load)
8542 {
8543 image->image_id = vkd3d_spirv_build_op_load(builder, image->image_type_id, image->id, SpvMemoryAccessMaskNone);
8544 if (resource_reg->non_uniform)
8545 spirv_compiler_decorate_nonuniform(compiler, image->image_id);
8546 }
8547 else
8548 {
8549 image->image_id = 0;
8550 }
8551
8552 image->image_type_id = spirv_compiler_get_image_type_id(compiler, resource_reg,
8553 &symbol->info.resource.range, image->resource_type_info,
8554 image->sampled_type, image->structure_stride || image->raw);
8555
8556 if (sampled)
8557 {
8558 struct vkd3d_shader_register_info register_info;
8559
8560 VKD3D_ASSERT(image->image_id);
8561 VKD3D_ASSERT(sampler_reg);
8562
8563 if (!spirv_compiler_get_register_info(compiler, sampler_reg, &register_info))
8564 ERR("Failed to get sampler register info.\n");
8565 sampler_var_id = register_info.id;
8566 if (register_info.descriptor_array)
8567 {
8568 const struct vkd3d_symbol_descriptor_array_data *array_data
8569 = &register_info.descriptor_array->info.descriptor_array;
8570 uint32_t ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder,
8571 register_info.storage_class, array_data->contained_type_id);
8572 uint32_t array_idx = spirv_compiler_get_descriptor_index(compiler, sampler_reg,
8573 register_info.descriptor_array, register_info.binding_base_idx, VKD3D_SHADER_RESOURCE_NONE);
8574 sampler_var_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, register_info.id, &array_idx, 1);
8575 }
8576
8577 sampler_id = vkd3d_spirv_build_op_load(builder,
8579 if (sampler_reg->non_uniform)
8580 spirv_compiler_decorate_nonuniform(compiler, sampler_id);
8581
8582 sampled_image_type_id = vkd3d_spirv_get_op_type_sampled_image(builder, image->image_type_id);
8583 image->sampled_image_id = vkd3d_spirv_build_op_sampled_image(builder,
8584 sampled_image_type_id, image->image_id, sampler_id);
8585 if (resource_reg->non_uniform)
8586 spirv_compiler_decorate_nonuniform(compiler, image->sampled_image_id);
8587 }
8588 else
8589 {
8590 image->sampled_image_id = 0;
8591 }
8592}
int load
Definition: msacm.c:1365
static uint32_t vkd3d_spirv_build_op_sampled_image(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t sampler_id)
Definition: spirv.c:1605
static uint32_t vkd3d_spirv_build_op_image(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t sampled_image_id)
Definition: spirv.c:1612
static const struct vkd3d_symbol * spirv_compiler_find_combined_sampler(struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource_reg, const struct vkd3d_shader_register *sampler_reg)
Definition: spirv.c:8456
enum vkd3d_shader_register_type type

Referenced by spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bufinfo(), spirv_compiler_emit_gather4(), spirv_compiler_emit_ld(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_ld_uav_typed(), spirv_compiler_emit_lod(), spirv_compiler_emit_query_sample_count(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_sample(), spirv_compiler_emit_sample_c(), spirv_compiler_emit_store_uav_raw_structured(), and spirv_compiler_emit_store_uav_typed().

◆ spirv_compiler_put_symbol()

static const struct vkd3d_symbol * spirv_compiler_put_symbol ( struct spirv_compiler *  compiler,
const struct vkd3d_symbol *  symbol 
)
static

Definition at line 3028 of file spirv.c.

3030{
3031 struct vkd3d_symbol *s;
3032
3033 s = vkd3d_symbol_dup(symbol);
3034 if (rb_put(&compiler->symbol_table, s, &s->entry) == -1)
3035 {
3036 ERR("Failed to insert symbol entry (%s).\n", debug_vkd3d_symbol(symbol));
3037 vkd3d_free(s);
3038 return NULL;
3039 }
3040 return s;
3041}
static int rb_put(struct rb_tree *tree, const void *key, struct rb_entry *entry)
Definition: rbtree.h:204
static struct vkd3d_symbol * vkd3d_symbol_dup(const struct vkd3d_symbol *symbol)
Definition: spirv.c:2352

Referenced by spirv_compiler_build_descriptor_variable(), spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_combined_sampler_declarations(), spirv_compiler_emit_dcl_immediate_constant_buffer(), spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_input(), spirv_compiler_emit_input_register(), spirv_compiler_emit_output(), spirv_compiler_emit_output_register(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_resource_declaration(), spirv_compiler_emit_sampler_declaration(), and spirv_compiler_emit_workgroup_memory().

◆ spirv_compiler_set_ssa_register_info()

static void spirv_compiler_set_ssa_register_info ( const struct spirv_compiler *  compiler,
const struct vkd3d_shader_register *  reg,
uint32_t  val_id 
)
static

Definition at line 4192 of file spirv.c.

4194{
4195 unsigned int i = reg->idx[0].offset;
4196 VKD3D_ASSERT(i < compiler->ssa_register_count);
4197 compiler->ssa_register_info[i].data_type = reg->data_type;
4198 compiler->ssa_register_info[i].id = val_id;
4199}

Referenced by spirv_compiler_emit_store_reg().

◆ spirv_compiler_use_storage_buffer()

static bool spirv_compiler_use_storage_buffer ( const struct spirv_compiler *  compiler,
const struct vkd3d_symbol_resource_data *  resource 
)
static

◆ sv_front_face_fixup()

static uint32_t sv_front_face_fixup ( struct spirv_compiler *  compiler,
uint32_t  front_facing_id 
)
static

Definition at line 4802 of file spirv.c.

4804{
4805 return spirv_compiler_emit_bool_to_int(compiler, 1, front_facing_id, true);
4806}

◆ sv_instance_id_fixup()

static uint32_t sv_instance_id_fixup ( struct spirv_compiler *  compiler,
uint32_t  instance_index_id 
)
static

Definition at line 4795 of file spirv.c.

4797{
4799 instance_index_id, SpvBuiltInBaseInstance);
4800}
static uint32_t spirv_compiler_emit_draw_parameter_fixup(struct spirv_compiler *compiler, uint32_t index_id, SpvBuiltIn base)
Definition: spirv.c:4766
@ SpvBuiltInBaseInstance
Definition: spirv.h:613

◆ sv_vertex_id_fixup()

static uint32_t sv_vertex_id_fixup ( struct spirv_compiler *  compiler,
uint32_t  vertex_index_id 
)
static

Definition at line 4787 of file spirv.c.

4789{
4791 vertex_index_id, SpvBuiltInBaseVertex);
4792}
@ SpvBuiltInBaseVertex
Definition: spirv.h:612

◆ vkd3d_get_spirv_builtin()

static const struct vkd3d_spirv_builtin * vkd3d_get_spirv_builtin ( const struct spirv_compiler *  compiler,
enum vkd3d_shader_register_type  reg_type,
enum vkd3d_shader_sysval_semantic  sysval 
)
static

Definition at line 4986 of file spirv.c.

4988{
4989 const struct vkd3d_spirv_builtin *builtin;
4990
4991 if ((builtin = get_spirv_builtin_for_sysval(compiler, sysval)))
4992 return builtin;
4994 return builtin;
4995
4998 {
4999 FIXME("Unhandled builtin (register type %#x, sysval %#x).\n", reg_type, sysval);
5000 }
5001 return NULL;
5002}

Referenced by spirv_compiler_emit_output().

◆ vkd3d_get_spirv_resource_type()

static const struct vkd3d_spirv_resource_type * vkd3d_get_spirv_resource_type ( enum vkd3d_shader_resource_type  resource_type)
static

Definition at line 2128 of file spirv.c.

2130{
2131 unsigned int i;
2132
2134 {
2136
2137 if (current->resource_type == resource_type)
2138 return current;
2139 }
2140
2141 FIXME("Unhandled resource type %#x.\n", resource_type);
2142 return NULL;
2143}
static const struct vkd3d_spirv_resource_type vkd3d_spirv_resource_type_table[]

Referenced by spirv_compiler_enable_resource_type().

◆ VKD3D_PRINTF_FUNC()

static void VKD3D_PRINTF_FUNC ( 3  ,
4   
)
static

Definition at line 2853 of file spirv.c.

2855{
2856 va_list args;
2857
2859 vkd3d_shader_verror(compiler->message_context, &compiler->location, error, format, args);
2860 va_end(args);
2861 compiler->failed = true;
2862}
#define va_end(v)
Definition: stdarg.h:28
#define va_start(v, l)
Definition: stdarg.h:26
char * va_list
Definition: vadefs.h:50
#define error(str)
Definition: mkdosfs.c:1605
#define args
Definition: format.c:66
Definition: match.c:390
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)

◆ vkd3d_shader_code_from_spirv_stream()

static void vkd3d_shader_code_from_spirv_stream ( struct vkd3d_shader_code *  code,
struct vkd3d_spirv_stream *  stream 
)
static

Definition at line 302 of file spirv.c.

303{
304 code->code = stream->words;
305 code->size = stream->word_count * sizeof(*stream->words);
306
307 stream->words = NULL;
308 stream->capacity = 0;
309 stream->word_count = 0;
310}
Definition: inflate.c:139

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_shader_register_range_string()

static struct vkd3d_string_buffer * vkd3d_shader_register_range_string ( struct spirv_compiler *  compiler,
const struct vkd3d_shader_register_range *  range 
)
static

Definition at line 2874 of file spirv.c.

2876{
2878
2879 if (!buffer)
2880 return NULL;
2881
2882 if (range->last != ~0u)
2883 vkd3d_string_buffer_printf(buffer, "[%u:%u]", range->first, range->last);
2884 else
2885 vkd3d_string_buffer_printf(buffer, "[%u:*]", range->first);
2886
2887 return buffer;
2888}
struct vkd3d_string_buffer * vkd3d_string_buffer_get(struct vkd3d_string_buffer_cache *cache)
int vkd3d_string_buffer_printf(struct vkd3d_string_buffer *buffer, const char *format,...)

Referenced by spirv_compiler_get_descriptor_binding().

◆ vkd3d_siv_from_sysval_indexed()

enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed ( enum vkd3d_shader_sysval_semantic  sysval,
unsigned int  index 
)

Definition at line 199 of file spirv.c.

201{
202 switch (sysval)
203 {
211 return VKD3D_SIV_NONE;
213 return VKD3D_SIV_POSITION;
241 return VKD3D_SIV_VERTEX_ID;
244 default:
245 FIXME("Unhandled sysval %#x, index %u.\n", sysval, index);
246 return VKD3D_SIV_NONE;
247 }
248}
@ VKD3D_SHADER_SV_VERTEX_ID
@ VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX
@ VKD3D_SHADER_SV_DEPTH_LESS_EQUAL
@ VKD3D_SHADER_SV_PRIMITIVE_ID
@ VKD3D_SHADER_SV_COVERAGE
@ VKD3D_SHADER_SV_DEPTH
@ VKD3D_SHADER_SV_TESS_FACTOR_TRIEDGE
@ VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE
@ VKD3D_SHADER_SV_IS_FRONT_FACE
@ VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX
@ VKD3D_SHADER_SV_TESS_FACTOR_QUADINT
@ VKD3D_SHADER_SV_TESS_FACTOR_TRIINT
@ VKD3D_SHADER_SV_DEPTH_GREATER_EQUAL
@ VKD3D_SHADER_SV_INSTANCE_ID
@ VKD3D_SHADER_SV_SAMPLE_INDEX
@ VKD3D_SHADER_SV_STENCIL_REF
@ VKD3D_SIV_TRIANGLE_U_TESS_FACTOR
@ VKD3D_SIV_CULL_DISTANCE
@ VKD3D_SIV_IS_FRONT_FACE
@ VKD3D_SIV_LINE_DETAIL_TESS_FACTOR
@ VKD3D_SIV_PRIMITIVE_ID
@ VKD3D_SIV_VERTEX_ID
@ VKD3D_SIV_INSTANCE_ID
@ VKD3D_SIV_QUAD_U0_TESS_FACTOR
@ VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR
@ VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR
@ VKD3D_SIV_NONE
@ VKD3D_SIV_SAMPLE_INDEX
@ VKD3D_SIV_POSITION
@ VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX
@ VKD3D_SIV_LINE_DENSITY_TESS_FACTOR
@ VKD3D_SIV_CLIP_DISTANCE
@ VKD3D_SIV_VIEWPORT_ARRAY_INDEX

Referenced by sm4_generate_vsir_instr_dcl_semantic(), and vkd3d_siv_from_sysval().

◆ vkd3d_spirv_add_iface_variable()

static void vkd3d_spirv_add_iface_variable ( struct vkd3d_spirv_builder *  builder,
uint32_t  id 
)
static

Definition at line 464 of file spirv.c.

466{
467 if (!vkd3d_array_reserve((void **)&builder->iface, &builder->iface_capacity,
468 builder->iface_element_count + 1, sizeof(*builder->iface)))
469 return;
470
471 builder->iface[builder->iface_element_count++] = id;
472}
uint32_t * iface
Definition: spirv.c:413
size_t iface_element_count
Definition: spirv.c:415
size_t iface_capacity
Definition: spirv.c:414

Referenced by spirv_compiler_emit_builtin_variable_v(), spirv_compiler_emit_draw_parameter_fixup(), spirv_compiler_emit_input(), and spirv_compiler_emit_output().

◆ vkd3d_spirv_alloc_id()

◆ vkd3d_spirv_begin_function_stream_insertion()

static void vkd3d_spirv_begin_function_stream_insertion ( struct vkd3d_spirv_builder *  builder,
size_t  location 
)
static

Definition at line 856 of file spirv.c.

858{
859 VKD3D_ASSERT(builder->insertion_location == ~(size_t)0);
860
862 return;
863
864 builder->original_function_stream = builder->function_stream;
865 builder->function_stream = builder->insertion_stream;
866 builder->insertion_location = location;
867}
#define location(file, line)
Definition: kmtest.h:18
size_t insertion_location
Definition: spirv.c:408
struct vkd3d_spirv_stream insertion_stream
Definition: spirv.c:407
struct vkd3d_spirv_stream original_function_stream
Definition: spirv.c:406

Referenced by spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_temps(), and spirv_compiler_get_descriptor_index().

◆ vkd3d_spirv_binary_to_text()

static enum vkd3d_result vkd3d_spirv_binary_to_text ( const struct vkd3d_shader_code *  spirv,
enum vkd3d_shader_spirv_environment  environment,
enum vkd3d_shader_compile_option_formatting_flags  formatting,
struct vkd3d_shader_code *  out 
)
static

Definition at line 183 of file spirv.c.

186{
187 return VKD3D_ERROR;
188}

Referenced by spirv_compiler_generate_spirv().

◆ vkd3d_spirv_build_image_instruction()

static uint32_t vkd3d_spirv_build_image_instruction ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  result_type,
const uint32_t *  operands,
unsigned int  operand_count,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1619 of file spirv.c.

1622{
1623 unsigned int index = 0, i;
1624 uint32_t w[10];
1625
1626 VKD3D_ASSERT(operand_count <= ARRAY_SIZE(w));
1627 for (i = 0; i < operand_count; ++i)
1628 w[index++] = operands[i];
1629
1630 if (image_operands_mask)
1631 {
1632 VKD3D_ASSERT(index + 1 + image_operand_count <= ARRAY_SIZE(w));
1633 w[index++] = image_operands_mask;
1634 for (i = 0; i < image_operand_count; ++i)
1635 w[index++] = image_operands[i];
1636 }
1637
1638 return vkd3d_spirv_build_op_trv(builder, &builder->function_stream,
1639 op, result_type, w, index);
1640}
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102

Referenced by vkd3d_spirv_build_op_image_dref_gather(), vkd3d_spirv_build_op_image_fetch(), vkd3d_spirv_build_op_image_gather(), vkd3d_spirv_build_op_image_read(), vkd3d_spirv_build_op_image_sample(), and vkd3d_spirv_build_op_image_sample_dref().

◆ vkd3d_spirv_build_once()

static uint32_t vkd3d_spirv_build_once ( struct vkd3d_spirv_builder *  builder,
uint32_t *  id,
vkd3d_spirv_build_pfn  build_pfn 
)
static

Definition at line 544 of file spirv.c.

546{
547 if (!(*id))
548 *id = build_pfn(builder);
549 return *id;
550}

Referenced by vkd3d_spirv_get_op_scope_subgroup(), vkd3d_spirv_get_op_type_bool(), vkd3d_spirv_get_op_type_sampler(), and vkd3d_spirv_get_op_type_void().

◆ vkd3d_spirv_build_once1()

static uint32_t vkd3d_spirv_build_once1 ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  operand0,
vkd3d_spirv_build1_pfn  build_pfn 
)
static

Definition at line 602 of file spirv.c.

604{
606 struct rb_entry *entry;
607
608 declaration.op = op;
609 declaration.parameter_count = 1;
610 declaration.parameters[0] = operand0;
611
612 if ((entry = rb_get(&builder->declarations, &declaration)))
614
615 declaration.id = build_pfn(builder, operand0);
617 return declaration.id;
618}
static void vkd3d_spirv_insert_declaration(struct vkd3d_spirv_builder *builder, const struct vkd3d_spirv_declaration *declaration)
Definition: spirv.c:585
struct rb_tree declarations
Definition: spirv.c:392

Referenced by vkd3d_spirv_get_op_constant_null(), vkd3d_spirv_get_op_type_float(), vkd3d_spirv_get_op_type_runtime_array(), vkd3d_spirv_get_op_type_sampled_image(), and vkd3d_spirv_get_op_undef().

◆ vkd3d_spirv_build_once1v()

static uint32_t vkd3d_spirv_build_once1v ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  operand0,
const uint32_t *  operands,
unsigned int  operand_count,
vkd3d_spirv_build1v_pfn  build_pfn 
)
static

Definition at line 620 of file spirv.c.

623{
625 unsigned int i, param_idx = 0;
626 struct rb_entry *entry;
627
628 if (operand_count >= ARRAY_SIZE(declaration.parameters))
629 {
630 WARN("Unsupported parameter count %u (opcode %#x).\n", operand_count + 1, op);
631 return build_pfn(builder, operand0, operands, operand_count);
632 }
633
634 declaration.op = op;
635 declaration.parameters[param_idx++] = operand0;
636 for (i = 0; i < operand_count; ++i)
637 declaration.parameters[param_idx++] = operands[i];
638 declaration.parameter_count = param_idx;
639
640 if ((entry = rb_get(&builder->declarations, &declaration)))
642
643 declaration.id = build_pfn(builder, operand0, operands, operand_count);
645 return declaration.id;
646}

Referenced by vkd3d_spirv_get_op_constant64(), vkd3d_spirv_get_op_constant_composite(), and vkd3d_spirv_get_op_type_function().

◆ vkd3d_spirv_build_once2()

static uint32_t vkd3d_spirv_build_once2 ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1,
vkd3d_spirv_build2_pfn  build_pfn 
)
static

Definition at line 648 of file spirv.c.

650{
652 struct rb_entry *entry;
653
654 declaration.op = op;
655 declaration.parameter_count = 2;
656 declaration.parameters[0] = operand0;
657 declaration.parameters[1] = operand1;
658
659 if ((entry = rb_get(&builder->declarations, &declaration)))
661
662 declaration.id = build_pfn(builder, operand0, operand1);
664 return declaration.id;
665}

Referenced by vkd3d_spirv_get_op_constant(), vkd3d_spirv_get_op_constant_bool(), vkd3d_spirv_get_op_type_array(), vkd3d_spirv_get_op_type_int(), vkd3d_spirv_get_op_type_pointer(), and vkd3d_spirv_get_op_type_vector().

◆ vkd3d_spirv_build_once7()

static uint32_t vkd3d_spirv_build_once7 ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
const uint32_t *  operands,
vkd3d_spirv_build7_pfn  build_pfn 
)
static

Definition at line 667 of file spirv.c.

669{
671 struct rb_entry *entry;
672
673 declaration.op = op;
674 declaration.parameter_count = 7;
675 memcpy(&declaration.parameters, operands, declaration.parameter_count * sizeof(*operands));
676
677 if ((entry = rb_get(&builder->declarations, &declaration)))
679
680 declaration.id = build_pfn(builder, operands[0], operands[1], operands[2],
681 operands[3], operands[4], operands[5], operands[6]);
683 return declaration.id;
684}

Referenced by vkd3d_spirv_get_op_type_image().

◆ vkd3d_spirv_build_op()

static void vkd3d_spirv_build_op ( struct vkd3d_spirv_stream *  stream,
SpvOp  op 
)
static

◆ vkd3d_spirv_build_op1()

static void vkd3d_spirv_build_op1 ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand 
)
static

◆ vkd3d_spirv_build_op1v()

static void vkd3d_spirv_build_op1v ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 707 of file spirv.c.

709{
710 unsigned int i;
713 for (i = 0; i < operand_count; ++i)
714 vkd3d_spirv_build_word(stream, operands[i]);
715}

Referenced by vkd3d_spirv_build_op_rv().

◆ vkd3d_spirv_build_op2()

static void vkd3d_spirv_build_op2 ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 742 of file spirv.c.

744{
745 return vkd3d_spirv_build_op2v(stream, op, operand0, operand1, NULL, 0);
746}
static void vkd3d_spirv_build_op2v(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:717

Referenced by vkd3d_spirv_build_op_copy_memory(), vkd3d_spirv_build_op_memory_barrier(), vkd3d_spirv_build_op_memory_model(), vkd3d_spirv_build_op_selection_merge(), and vkd3d_spirv_build_op_store().

◆ vkd3d_spirv_build_op2v()

static void vkd3d_spirv_build_op2v ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

◆ vkd3d_spirv_build_op3()

static void vkd3d_spirv_build_op3 ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1,
uint32_t  operand2 
)
static

◆ vkd3d_spirv_build_op3v()

static void vkd3d_spirv_build_op3v ( struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1,
uint32_t  operand2,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 729 of file spirv.c.

732{
733 unsigned int i;
738 for (i = 0; i < operand_count; ++i)
739 vkd3d_spirv_build_word(stream, operands[i]);
740}

Referenced by vkd3d_spirv_build_op_function(), vkd3d_spirv_build_op_member_decorate(), and vkd3d_spirv_build_op_tr1v().

◆ vkd3d_spirv_build_op_access_chain()

static uint32_t vkd3d_spirv_build_op_access_chain ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base_id,
uint32_t *  indexes,
uint32_t  index_count 
)
static

Definition at line 1296 of file spirv.c.

1298{
1299 return vkd3d_spirv_build_op_tr1v(builder, &builder->function_stream,
1300 SpvOpAccessChain, result_type, base_id, indexes, index_count);
1301}
static uint32_t vkd3d_spirv_build_op_tr1v(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:831
@ SpvOpAccessChain
Definition: spirv.h:1253

Referenced by spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_dereference_register(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_ld_uav_typed(), spirv_compiler_emit_store_uav_raw_structured(), spirv_compiler_emit_store_uav_typed(), spirv_compiler_emit_uav_counter_instruction(), spirv_compiler_prepare_image(), and vkd3d_spirv_build_op_access_chain1().

◆ vkd3d_spirv_build_op_access_chain1()

static uint32_t vkd3d_spirv_build_op_access_chain1 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base_id,
uint32_t  index 
)
static

◆ vkd3d_spirv_build_op_and()

static uint32_t vkd3d_spirv_build_op_and ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1510 of file spirv.c.

1512{
1513 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1514 SpvOpBitwiseAnd, result_type, operand0, operand1);
1515}

Referenced by spirv_compiler_emit_alu_instruction(), and spirv_compiler_emit_bitfield_instruction().

◆ vkd3d_spirv_build_op_array_length()

static uint32_t vkd3d_spirv_build_op_array_length ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  struct_id,
uint32_t  member_id 
)
static

Definition at line 1719 of file spirv.c.

1721{
1722 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1723 SpvOpArrayLength, result_type, struct_id, member_id);
1724}
@ SpvOpArrayLength
Definition: spirv.h:1256

Referenced by spirv_compiler_emit_bufinfo().

◆ vkd3d_spirv_build_op_bitcast()

◆ vkd3d_spirv_build_op_branch()

static void vkd3d_spirv_build_op_branch ( struct vkd3d_spirv_builder *  builder,
uint32_t  label 
)
static

Definition at line 1441 of file spirv.c.

1442{
1444}
static const WCHAR label[]
Definition: itemdlg.c:1608
static void vkd3d_spirv_build_op1(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand)
Definition: spirv.c:700
@ SpvOpBranch
Definition: spirv.h:1422

Referenced by spirv_compiler_emit_branch(), and spirv_compiler_emit_discard_function().

◆ vkd3d_spirv_build_op_branch_conditional()

static void vkd3d_spirv_build_op_branch_conditional ( struct vkd3d_spirv_builder *  builder,
uint32_t  condition,
uint32_t  true_label,
uint32_t  false_label 
)
static

Definition at line 1447 of file spirv.c.

1449{
1451 condition, true_label, false_label);
1452}
static void vkd3d_spirv_build_op3(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, uint32_t operand2)
Definition: spirv.c:748
@ SpvOpBranchConditional
Definition: spirv.h:1423

Referenced by spirv_compiler_emit_branch(), spirv_compiler_emit_conditional_branch(), and spirv_compiler_emit_discard_function().

◆ vkd3d_spirv_build_op_capability()

static void vkd3d_spirv_build_op_capability ( struct vkd3d_spirv_stream *  stream,
SpvCapability  cap 
)
static

Definition at line 885 of file spirv.c.

887{
889}
GLenum cap
Definition: glext.h:9639
@ SpvOpCapability
Definition: spirv.h:1210

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_composite_construct()

static uint32_t vkd3d_spirv_build_op_composite_construct ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
const uint32_t *  constituents,
unsigned int  constituent_count 
)
static

◆ vkd3d_spirv_build_op_composite_extract()

static uint32_t vkd3d_spirv_build_op_composite_extract ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  composite_id,
const uint32_t *  indexes,
unsigned int  index_count 
)
static

Definition at line 1337 of file spirv.c.

1339{
1341 result_type, composite_id, indexes, index_count);
1342}
@ SpvOpCompositeExtract
Definition: spirv.h:1268

Referenced by vkd3d_spirv_build_op_composite_extract1().

◆ vkd3d_spirv_build_op_composite_extract1()

static uint32_t vkd3d_spirv_build_op_composite_extract1 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  composite_id,
uint32_t  index 
)
static

Definition at line 1344 of file spirv.c.

1346{
1347 return vkd3d_spirv_build_op_composite_extract(builder, result_type, composite_id, &index, 1);
1348}
static uint32_t vkd3d_spirv_build_op_composite_extract(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t composite_id, const uint32_t *indexes, unsigned int index_count)
Definition: spirv.c:1337

Referenced by frag_coord_fixup(), spirv_compiler_emit_f16tof32(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_load_ssa_reg(), spirv_compiler_emit_store(), spirv_compiler_emit_store_tgsm(), spirv_compiler_emit_store_uav_raw_structured(), and spirv_compiler_emit_swizzle().

◆ vkd3d_spirv_build_op_composite_insert()

static uint32_t vkd3d_spirv_build_op_composite_insert ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  object_id,
uint32_t  composite_id,
const uint32_t *  indexes,
unsigned int  index_count 
)
static

Definition at line 1350 of file spirv.c.

1353{
1355 result_type, object_id, composite_id, indexes, index_count);
1356}
static uint32_t vkd3d_spirv_build_op_tr2v(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type, uint32_t operand0, uint32_t operand1, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:840
@ SpvOpCompositeInsert
Definition: spirv.h:1269

Referenced by vkd3d_spirv_build_op_composite_insert1().

◆ vkd3d_spirv_build_op_composite_insert1()

static uint32_t vkd3d_spirv_build_op_composite_insert1 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  object_id,
uint32_t  composite_id,
uint32_t  index 
)
static

Definition at line 1358 of file spirv.c.

1360{
1361 return vkd3d_spirv_build_op_composite_insert(builder, result_type, object_id, composite_id, &index, 1);
1362}
static uint32_t vkd3d_spirv_build_op_composite_insert(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t object_id, uint32_t composite_id, const uint32_t *indexes, unsigned int index_count)
Definition: spirv.c:1350

Referenced by frag_coord_fixup().

◆ vkd3d_spirv_build_op_constant()

static uint32_t vkd3d_spirv_build_op_constant ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  value 
)
static

Definition at line 1185 of file spirv.c.

1187{
1188 return vkd3d_spirv_build_op_tr1(builder, &builder->global_stream,
1189 SpvOpConstant, result_type, value);
1190}
@ SpvOpConstant
Definition: spirv.h:1234

Referenced by vkd3d_spirv_get_op_constant().

◆ vkd3d_spirv_build_op_constant64()

static uint32_t vkd3d_spirv_build_op_constant64 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
const uint32_t *  values,
unsigned int  value_count 
)
static

Definition at line 1199 of file spirv.c.

1201{
1202 VKD3D_ASSERT(value_count == 2);
1203 return vkd3d_spirv_build_op_trv(builder, &builder->global_stream,
1204 SpvOpConstant, result_type, values, value_count);
1205}

Referenced by vkd3d_spirv_get_op_constant64().

◆ vkd3d_spirv_build_op_constant_bool()

static uint32_t vkd3d_spirv_build_op_constant_bool ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  value 
)
static

Definition at line 1170 of file spirv.c.

1172{
1173 return vkd3d_spirv_build_op_tr(builder, &builder->global_stream,
1174 value ? SpvOpConstantTrue : SpvOpConstantFalse, result_type);
1175}
static uint32_t vkd3d_spirv_build_op_tr(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t result_type)
Definition: spirv.c:800
@ SpvOpConstantFalse
Definition: spirv.h:1233
@ SpvOpConstantTrue
Definition: spirv.h:1232

Referenced by vkd3d_spirv_get_op_constant_bool().

◆ vkd3d_spirv_build_op_constant_composite()

static uint32_t vkd3d_spirv_build_op_constant_composite ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
const uint32_t *  constituents,
unsigned int  constituent_count 
)
static

Definition at line 1224 of file spirv.c.

1226{
1227 return vkd3d_spirv_build_op_trv(builder, &builder->global_stream,
1228 SpvOpConstantComposite, result_type, constituents, constituent_count);
1229}
@ SpvOpConstantComposite
Definition: spirv.h:1235

Referenced by spirv_compiler_emit_constant_array(), spirv_compiler_emit_sample_position(), and vkd3d_spirv_get_op_constant_composite().

◆ vkd3d_spirv_build_op_constant_null()

static uint32_t vkd3d_spirv_build_op_constant_null ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type 
)
static

Definition at line 1214 of file spirv.c.

1215{
1216 return vkd3d_spirv_build_op_tr(builder, &builder->global_stream, SpvOpConstantNull, result_type);
1217}
@ SpvOpConstantNull
Definition: spirv.h:1237

Referenced by vkd3d_spirv_get_op_constant_null().

◆ vkd3d_spirv_build_op_control_barrier()

static void vkd3d_spirv_build_op_control_barrier ( struct vkd3d_spirv_builder *  builder,
uint32_t  execution_id,
uint32_t  memory_id,
uint32_t  memory_semantics_id 
)
static

Definition at line 1771 of file spirv.c.

1773{
1775 SpvOpControlBarrier, execution_id, memory_id, memory_semantics_id);
1776}
@ SpvOpControlBarrier
Definition: spirv.h:1400

Referenced by spirv_compiler_emit_barrier().

◆ vkd3d_spirv_build_op_convert_utof()

static uint32_t vkd3d_spirv_build_op_convert_utof ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  unsigned_value 
)
static

Definition at line 1584 of file spirv.c.

1586{
1587 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1588 SpvOpConvertUToF, result_type, unsigned_value);
1589}

Referenced by spirv_compiler_emit_resinfo(), and spirv_compiler_emit_sample_info().

◆ vkd3d_spirv_build_op_copy_memory()

static void vkd3d_spirv_build_op_copy_memory ( struct vkd3d_spirv_builder *  builder,
uint32_t  target_id,
uint32_t  source_id,
uint32_t  memory_access 
)
static

Definition at line 1386 of file spirv.c.

1388{
1389 if (!memory_access)
1391 target_id, source_id);
1392 else
1394 target_id, source_id, memory_access);
1395}
static int source_id
Definition: solundo.cpp:15
static void vkd3d_spirv_build_op2(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:742
@ SpvOpCopyMemory
Definition: spirv.h:1251

Referenced by spirv_compiler_emit_default_control_point_phase(), and spirv_compiler_emit_mov().

◆ vkd3d_spirv_build_op_decorate()

◆ vkd3d_spirv_build_op_decorate1()

◆ vkd3d_spirv_build_op_demote_to_helper_invocation()

static void vkd3d_spirv_build_op_demote_to_helper_invocation ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1409 of file spirv.c.

1410{
1412}
@ SpvOpDemoteToHelperInvocationEXT
Definition: spirv.h:1602

Referenced by spirv_compiler_emit_discard_function().

◆ vkd3d_spirv_build_op_emit_vertex()

static void vkd3d_spirv_build_op_emit_vertex ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1761 of file spirv.c.

1762{
1764}
@ SpvOpEmitVertex
Definition: spirv.h:1396

Referenced by spirv_compiler_emit_emit_stream().

◆ vkd3d_spirv_build_op_end_primitive()

static void vkd3d_spirv_build_op_end_primitive ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1766 of file spirv.c.

1767{
1769}
@ SpvOpEndPrimitive
Definition: spirv.h:1397

Referenced by spirv_compiler_emit_cut_stream().

◆ vkd3d_spirv_build_op_entry_point()

static void vkd3d_spirv_build_op_entry_point ( struct vkd3d_spirv_stream *  stream,
SpvExecutionModel  model,
uint32_t  function_id,
const char *  name,
uint32_t *  interface_list,
unsigned int  interface_size 
)
static

Definition at line 922 of file spirv.c.

925{
926 unsigned int i, name_size = vkd3d_spirv_string_word_count(name);
927 vkd3d_spirv_build_word(stream, vkd3d_spirv_opcode_word(SpvOpEntryPoint, 3 + name_size + interface_size));
929 vkd3d_spirv_build_word(stream, function_id);
931 for (i = 0; i < interface_size; ++i)
933}
static struct regsvr_interface const interface_list[]
Definition: regsvr.c:477
static unsigned int vkd3d_spirv_string_word_count(const char *str)
Definition: spirv.c:513
static void vkd3d_spirv_build_string(struct vkd3d_spirv_stream *stream, const char *str, unsigned int word_count)
Definition: spirv.c:518
@ SpvOpEntryPoint
Definition: spirv.h:1208

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_execution_mode()

static void vkd3d_spirv_build_op_execution_mode ( struct vkd3d_spirv_stream *  stream,
uint32_t  entry_point,
SpvExecutionMode  mode,
const uint32_t *  literals,
unsigned int  literal_count 
)
static

Definition at line 935 of file spirv.c.

937{
938 vkd3d_spirv_build_op2v(stream, SpvOpExecutionMode, entry_point, mode, literals, literal_count);
939}
@ SpvOpExecutionMode
Definition: spirv.h:1209

Referenced by spirv_compiler_emit_execution_mode(), and vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_ext_inst()

static uint32_t vkd3d_spirv_build_op_ext_inst ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  inst_set,
uint32_t  inst_number,
uint32_t *  operands,
unsigned int  operand_count 
)
static

◆ vkd3d_spirv_build_op_ext_inst_import()

static void vkd3d_spirv_build_op_ext_inst_import ( struct vkd3d_spirv_stream *  stream,
uint32_t  result_id,
const char *  name 
)
static

Definition at line 899 of file spirv.c.

901{
902 unsigned int name_size = vkd3d_spirv_string_word_count(name);
904 vkd3d_spirv_build_word(stream, result_id);
906}
@ SpvOpExtInstImport
Definition: spirv.h:1205

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_extension()

static void vkd3d_spirv_build_op_extension ( struct vkd3d_spirv_stream *  stream,
const char *  name 
)
static

Definition at line 891 of file spirv.c.

893{
894 unsigned int name_size = vkd3d_spirv_string_word_count(name);
897}
@ SpvOpExtension
Definition: spirv.h:1204

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_fdiv()

static uint32_t vkd3d_spirv_build_op_fdiv ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1489 of file spirv.c.

1491{
1492 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1493 SpvOpFDiv, result_type, operand0, operand1);
1494}

Referenced by frag_coord_fixup(), and spirv_compiler_emit_rcp().

◆ vkd3d_spirv_build_op_fnegate()

static uint32_t vkd3d_spirv_build_op_fnegate ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1496 of file spirv.c.

1498{
1499 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1500 SpvOpFNegate, result_type, operand);
1501}
@ SpvOpFNegate
Definition: spirv.h:1311

Referenced by spirv_compiler_emit_neg().

◆ vkd3d_spirv_build_op_function()

static uint32_t vkd3d_spirv_build_op_function ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  result_id,
uint32_t  function_control,
uint32_t  function_type 
)
static

Definition at line 1259 of file spirv.c.

1261{
1263 SpvOpFunction, result_type, result_id, function_control, &function_type, 1);
1264 return result_id;
1265}
static void vkd3d_spirv_build_op3v(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1, uint32_t operand2, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:729
@ SpvOpFunction
Definition: spirv.h:1243

Referenced by spirv_compiler_emit_discard_function(), spirv_compiler_emit_shader_epilogue_function(), spirv_compiler_enter_shader_phase(), and vkd3d_spirv_builder_begin_main_function().

◆ vkd3d_spirv_build_op_function_call()

static uint32_t vkd3d_spirv_build_op_function_call ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  function_id,
const uint32_t *  arguments,
unsigned int  argument_count 
)
static

Definition at line 1279 of file spirv.c.

1281{
1282 return vkd3d_spirv_build_op_tr1v(builder, &builder->function_stream,
1283 SpvOpFunctionCall, result_type, function_id, arguments, argument_count);
1284}
@ SpvOpFunctionCall
Definition: spirv.h:1246

Referenced by spirv_compiler_emit_discard(), spirv_compiler_emit_hull_shader_main(), and spirv_compiler_emit_shader_epilogue_invocation().

◆ vkd3d_spirv_build_op_function_end()

◆ vkd3d_spirv_build_op_function_parameter()

static uint32_t vkd3d_spirv_build_op_function_parameter ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type 
)
static

Definition at line 1267 of file spirv.c.

1269{
1270 return vkd3d_spirv_build_op_tr(builder, &builder->function_stream,
1271 SpvOpFunctionParameter, result_type);
1272}
@ SpvOpFunctionParameter
Definition: spirv.h:1244

Referenced by spirv_compiler_emit_discard_function(), and spirv_compiler_emit_shader_epilogue_function().

◆ vkd3d_spirv_build_op_glsl_std450_cos()

static uint32_t vkd3d_spirv_build_op_glsl_std450_cos ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1877 of file spirv.c.

1879{
1880 return vkd3d_spirv_build_op_glsl_std450_tr1(builder, GLSLstd450Cos, result_type, operand);
1881}
@ GLSLstd450Cos
Definition: GLSL.std.450.h:50
static uint32_t vkd3d_spirv_build_op_glsl_std450_tr1(struct vkd3d_spirv_builder *builder, enum GLSLstd450 op, uint32_t result_type, uint32_t operand)
Definition: spirv.c:1858

Referenced by spirv_compiler_emit_sincos().

◆ vkd3d_spirv_build_op_glsl_std450_fabs()

static uint32_t vkd3d_spirv_build_op_glsl_std450_fabs ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1865 of file spirv.c.

1867{
1868 return vkd3d_spirv_build_op_glsl_std450_tr1(builder, GLSLstd450FAbs, result_type, operand);
1869}

Referenced by spirv_compiler_emit_abs().

◆ vkd3d_spirv_build_op_glsl_std450_max()

static uint32_t vkd3d_spirv_build_op_glsl_std450_max ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  x,
uint32_t  y 
)
static

Definition at line 1883 of file spirv.c.

1885{
1886 uint32_t glsl_std450_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
1887 uint32_t operands[] = {x, y};
1888 return vkd3d_spirv_build_op_ext_inst(builder, result_type, glsl_std450_id,
1889 GLSLstd450NMax, operands, ARRAY_SIZE(operands));
1890}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548

Referenced by spirv_compiler_emit_ftoi(), and spirv_compiler_emit_ftou().

◆ vkd3d_spirv_build_op_glsl_std450_nclamp()

static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  x,
uint32_t  min,
uint32_t  max 
)
static

Definition at line 1901 of file spirv.c.

1903{
1904 uint32_t glsl_std450_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
1905 uint32_t operands[] = {x, min, max};
1906 return vkd3d_spirv_build_op_ext_inst(builder, result_type, glsl_std450_id,
1907 GLSLstd450NClamp, operands, ARRAY_SIZE(operands));
1908}
@ GLSLstd450NClamp
Definition: GLSL.std.450.h:126
#define min(a, b)
Definition: monoChain.cc:55

Referenced by spirv_compiler_emit_sat().

◆ vkd3d_spirv_build_op_glsl_std450_sin()

static uint32_t vkd3d_spirv_build_op_glsl_std450_sin ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1871 of file spirv.c.

1873{
1874 return vkd3d_spirv_build_op_glsl_std450_tr1(builder, GLSLstd450Sin, result_type, operand);
1875}
@ GLSLstd450Sin
Definition: GLSL.std.450.h:49

Referenced by spirv_compiler_emit_sincos().

◆ vkd3d_spirv_build_op_glsl_std450_tr1()

static uint32_t vkd3d_spirv_build_op_glsl_std450_tr1 ( struct vkd3d_spirv_builder *  builder,
enum GLSLstd450  op,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1858 of file spirv.c.

1860{
1862 return vkd3d_spirv_build_op_ext_inst(builder, result_type, id, op, &operand, 1);
1863}

Referenced by vkd3d_spirv_build_op_glsl_std450_cos(), vkd3d_spirv_build_op_glsl_std450_fabs(), and vkd3d_spirv_build_op_glsl_std450_sin().

◆ vkd3d_spirv_build_op_glsl_std450_umin()

static uint32_t vkd3d_spirv_build_op_glsl_std450_umin ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  x,
uint32_t  y 
)
static

Definition at line 1892 of file spirv.c.

1894{
1895 uint32_t glsl_std450_id = vkd3d_spirv_get_glsl_std450_instr_set(builder);
1896 uint32_t operands[] = {x, y};
1897 return vkd3d_spirv_build_op_ext_inst(builder, result_type, glsl_std450_id,
1898 GLSLstd450UMin, operands, ARRAY_SIZE(operands));
1899}

Referenced by spirv_compiler_emit_bitfield_instruction().

◆ vkd3d_spirv_build_op_group_nonuniform_ballot()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id 
)
static

Definition at line 1811 of file spirv.c.

1813{
1816 result_type, vkd3d_spirv_get_op_scope_subgroup(builder), val_id);
1817}
@ SpvCapabilityGroupNonUniformBallot
Definition: spirv.h:932
@ SpvOpGroupNonUniformBallot
Definition: spirv.h:1507

Referenced by spirv_compiler_emit_group_nonuniform_ballot().

◆ vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
SpvGroupOperation  group_op,
uint32_t  val_id 
)
static

Definition at line 1819 of file spirv.c.

1821{
1824 result_type, vkd3d_spirv_get_op_scope_subgroup(builder), group_op, val_id);
1825}
@ SpvOpGroupNonUniformBallotBitCount
Definition: spirv.h:1510

Referenced by spirv_compiler_emit_wave_bit_count().

◆ vkd3d_spirv_build_op_group_nonuniform_broadcast()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id,
uint32_t  lane_id 
)
static

Definition at line 1834 of file spirv.c.

1836{
1838 return vkd3d_spirv_build_op_tr3(builder, &builder->function_stream, SpvOpGroupNonUniformBroadcast, result_type,
1839 vkd3d_spirv_get_op_scope_subgroup(builder), val_id, lane_id);
1840}
@ SpvOpGroupNonUniformBroadcast
Definition: spirv.h:1505

Referenced by spirv_compiler_emit_wave_read_lane_at().

◆ vkd3d_spirv_build_op_group_nonuniform_broadcast_first()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_broadcast_first ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id 
)
static

Definition at line 1850 of file spirv.c.

1852{
1855 result_type, vkd3d_spirv_get_op_scope_subgroup(builder), val_id);
1856}
@ SpvOpGroupNonUniformBroadcastFirst
Definition: spirv.h:1506

Referenced by spirv_compiler_emit_wave_read_lane_first().

◆ vkd3d_spirv_build_op_group_nonuniform_elect()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_elect ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1827 of file spirv.c.

Referenced by spirv_compiler_emit_wave_is_first_lane().

◆ vkd3d_spirv_build_op_group_nonuniform_quad_broadcast()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_broadcast ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id,
uint32_t  index_id 
)
static

Definition at line 1803 of file spirv.c.

1805{
1807 return vkd3d_spirv_build_op_tr3(builder, &builder->function_stream, SpvOpGroupNonUniformQuadBroadcast, result_type,
1808 vkd3d_spirv_get_op_scope_subgroup(builder), val_id, index_id);
1809}
@ SpvCapabilityGroupNonUniformQuad
Definition: spirv.h:936
@ SpvOpGroupNonUniformQuadBroadcast
Definition: spirv.h:1533

Referenced by spirv_compiler_emit_quad_read_lane_at().

◆ vkd3d_spirv_build_op_group_nonuniform_quad_swap()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_quad_swap ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id,
uint32_t  op_id 
)
static

Definition at line 1795 of file spirv.c.

1797{
1799 return vkd3d_spirv_build_op_tr3(builder, &builder->function_stream, SpvOpGroupNonUniformQuadSwap, result_type,
1800 vkd3d_spirv_get_op_scope_subgroup(builder), val_id, op_id);
1801}
@ SpvOpGroupNonUniformQuadSwap
Definition: spirv.h:1534

Referenced by spirv_compiler_emit_quad_read_across().

◆ vkd3d_spirv_build_op_group_nonuniform_shuffle()

static uint32_t vkd3d_spirv_build_op_group_nonuniform_shuffle ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  val_id,
uint32_t  lane_id 
)
static

Definition at line 1842 of file spirv.c.

1844{
1846 return vkd3d_spirv_build_op_tr3(builder, &builder->function_stream, SpvOpGroupNonUniformShuffle, result_type,
1847 vkd3d_spirv_get_op_scope_subgroup(builder), val_id, lane_id);
1848}
@ SpvCapabilityGroupNonUniformShuffle
Definition: spirv.h:933
@ SpvOpGroupNonUniformShuffle
Definition: spirv.h:1513

Referenced by spirv_compiler_emit_wave_read_lane_at().

◆ vkd3d_spirv_build_op_iadd()

◆ vkd3d_spirv_build_op_image()

static uint32_t vkd3d_spirv_build_op_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  sampled_image_id 
)
static

Definition at line 1612 of file spirv.c.

1614{
1615 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1616 SpvOpImage, result_type, sampled_image_id);
1617}
@ SpvOpImage
Definition: spirv.h:1286

Referenced by spirv_compiler_prepare_image().

◆ vkd3d_spirv_build_op_image_dref_gather()

static uint32_t vkd3d_spirv_build_op_image_dref_gather ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  sampled_image_id,
uint32_t  coordinate_id,
uint32_t  dref_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1681 of file spirv.c.

1684{
1685 const uint32_t operands[] = {sampled_image_id, coordinate_id, dref_id};
1686 return vkd3d_spirv_build_image_instruction(builder, SpvOpImageDrefGather, result_type,
1687 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1688}
static uint32_t vkd3d_spirv_build_image_instruction(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t result_type, const uint32_t *operands, unsigned int operand_count, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count)
Definition: spirv.c:1619
@ SpvOpImageDrefGather
Definition: spirv.h:1283

Referenced by spirv_compiler_emit_gather4().

◆ vkd3d_spirv_build_op_image_fetch()

static uint32_t vkd3d_spirv_build_op_image_fetch ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  coordinate_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1690 of file spirv.c.

1693{
1694 const uint32_t operands[] = {image_id, coordinate_id};
1695 return vkd3d_spirv_build_image_instruction(builder, SpvOpImageFetch, result_type,
1696 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1697}

Referenced by spirv_compiler_emit_ld().

◆ vkd3d_spirv_build_op_image_gather()

static uint32_t vkd3d_spirv_build_op_image_gather ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  sampled_image_id,
uint32_t  coordinate_id,
uint32_t  component_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1672 of file spirv.c.

1675{
1676 const uint32_t operands[] = {sampled_image_id, coordinate_id, component_id};
1677 return vkd3d_spirv_build_image_instruction(builder, SpvOpImageGather, result_type,
1678 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1679}
@ SpvOpImageGather
Definition: spirv.h:1282

Referenced by spirv_compiler_emit_gather4().

◆ vkd3d_spirv_build_op_image_query_levels()

static uint32_t vkd3d_spirv_build_op_image_query_levels ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id 
)
static

Definition at line 1740 of file spirv.c.

1742{
1743 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1744 SpvOpImageQueryLevels, result_type, image_id);
1745}
@ SpvOpImageQueryLevels
Definition: spirv.h:1292

Referenced by spirv_compiler_emit_resinfo().

◆ vkd3d_spirv_build_op_image_query_lod()

static uint32_t vkd3d_spirv_build_op_image_query_lod ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  coordinate_id 
)
static

Definition at line 1754 of file spirv.c.

1756{
1757 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1758 SpvOpImageQueryLod, result_type, image_id, coordinate_id);
1759}
@ SpvOpImageQueryLod
Definition: spirv.h:1291

Referenced by spirv_compiler_emit_lod().

◆ vkd3d_spirv_build_op_image_query_samples()

static uint32_t vkd3d_spirv_build_op_image_query_samples ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id 
)
static

Definition at line 1747 of file spirv.c.

1749{
1750 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1751 SpvOpImageQuerySamples, result_type, image_id);
1752}
@ SpvOpImageQuerySamples
Definition: spirv.h:1293

Referenced by spirv_compiler_emit_query_sample_count().

◆ vkd3d_spirv_build_op_image_query_size()

static uint32_t vkd3d_spirv_build_op_image_query_size ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id 
)
static

Definition at line 1733 of file spirv.c.

1735{
1736 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1737 SpvOpImageQuerySize, result_type, image_id);
1738}
@ SpvOpImageQuerySize
Definition: spirv.h:1290

Referenced by spirv_compiler_emit_bufinfo(), and spirv_compiler_emit_resinfo().

◆ vkd3d_spirv_build_op_image_query_size_lod()

static uint32_t vkd3d_spirv_build_op_image_query_size_lod ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  lod_id 
)
static

Definition at line 1726 of file spirv.c.

1728{
1729 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1730 SpvOpImageQuerySizeLod, result_type, image_id, lod_id);
1731}
@ SpvOpImageQuerySizeLod
Definition: spirv.h:1289

Referenced by spirv_compiler_emit_resinfo().

◆ vkd3d_spirv_build_op_image_read()

static uint32_t vkd3d_spirv_build_op_image_read ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  coordinate_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1699 of file spirv.c.

1702{
1703 const uint32_t operands[] = {image_id, coordinate_id};
1704 return vkd3d_spirv_build_image_instruction(builder, SpvOpImageRead, result_type,
1705 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1706}

Referenced by spirv_compiler_emit_ld_uav_typed().

◆ vkd3d_spirv_build_op_image_sample()

static uint32_t vkd3d_spirv_build_op_image_sample ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  result_type,
uint32_t  sampled_image_id,
uint32_t  coordinate_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1642 of file spirv.c.

1645{
1646 const uint32_t operands[] = {sampled_image_id, coordinate_id};
1647
1650 else
1652
1653 return vkd3d_spirv_build_image_instruction(builder, op, result_type,
1654 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1655}

Referenced by spirv_compiler_emit_sample().

◆ vkd3d_spirv_build_op_image_sample_dref()

static uint32_t vkd3d_spirv_build_op_image_sample_dref ( struct vkd3d_spirv_builder *  builder,
SpvOp  op,
uint32_t  result_type,
uint32_t  sampled_image_id,
uint32_t  coordinate_id,
uint32_t  dref_id,
uint32_t  image_operands_mask,
const uint32_t *  image_operands,
unsigned int  image_operand_count 
)
static

Definition at line 1657 of file spirv.c.

1660{
1661 const uint32_t operands[] = {sampled_image_id, coordinate_id, dref_id};
1662
1665 else
1667
1668 return vkd3d_spirv_build_image_instruction(builder, op, result_type,
1669 operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count);
1670}

Referenced by spirv_compiler_emit_sample_c().

◆ vkd3d_spirv_build_op_image_texel_pointer()

static uint32_t vkd3d_spirv_build_op_image_texel_pointer ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  coordinate_id,
uint32_t  sample_id 
)
static

Definition at line 1598 of file spirv.c.

1600{
1601 return vkd3d_spirv_build_op_tr3(builder, &builder->function_stream,
1602 SpvOpImageTexelPointer, result_type, image_id, coordinate_id, sample_id);
1603}
@ SpvOpImageTexelPointer
Definition: spirv.h:1248

Referenced by spirv_compiler_emit_atomic_instruction(), and spirv_compiler_emit_uav_counter_instruction().

◆ vkd3d_spirv_build_op_image_write()

static void vkd3d_spirv_build_op_image_write ( struct vkd3d_spirv_builder *  builder,
uint32_t  image_id,
uint32_t  coordinate_id,
uint32_t  texel_id,
uint32_t  image_operands,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 1708 of file spirv.c.

1711{
1712 if (image_operands)
1713 FIXME("Image operands not supported.\n");
1714
1716 image_id, coordinate_id, texel_id);
1717}
@ SpvOpImageWrite
Definition: spirv.h:1285

Referenced by spirv_compiler_emit_store_uav_raw_structured(), and spirv_compiler_emit_store_uav_typed().

◆ vkd3d_spirv_build_op_imul()

static uint32_t vkd3d_spirv_build_op_imul ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1468 of file spirv.c.

1470{
1471 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1472 SpvOpIMul, result_type, operand0, operand1);
1473}
@ SpvOpIMul
Definition: spirv.h:1316

Referenced by spirv_compiler_emit_imad(), spirv_compiler_emit_imul(), and spirv_compiler_emit_raw_structured_addressing().

◆ vkd3d_spirv_build_op_in_bounds_access_chain()

static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base_id,
uint32_t *  indexes,
uint32_t  index_count 
)
static

Definition at line 1309 of file spirv.c.

1311{
1312 return vkd3d_spirv_build_op_tr1v(builder, &builder->function_stream,
1313 SpvOpInBoundsAccessChain, result_type, base_id, indexes, index_count);
1314}
@ SpvOpInBoundsAccessChain
Definition: spirv.h:1254

Referenced by spirv_compiler_get_descriptor_index(), and vkd3d_spirv_build_op_in_bounds_access_chain1().

◆ vkd3d_spirv_build_op_in_bounds_access_chain1()

static uint32_t vkd3d_spirv_build_op_in_bounds_access_chain1 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base_id,
uint32_t  index 
)
static

Definition at line 1316 of file spirv.c.

1318{
1319 return vkd3d_spirv_build_op_in_bounds_access_chain(builder, result_type, base_id, &index, 1);
1320}

Referenced by spirv_compiler_emit_load_scalar(), spirv_compiler_emit_sample_position(), and spirv_compiler_emit_store_scalar().

◆ vkd3d_spirv_build_op_is_inf()

static uint32_t vkd3d_spirv_build_op_is_inf ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1552 of file spirv.c.

1554{
1555 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpIsInf, result_type, operand);
1556}

Referenced by spirv_compiler_emit_isfinite().

◆ vkd3d_spirv_build_op_is_nan()

static uint32_t vkd3d_spirv_build_op_is_nan ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1558 of file spirv.c.

1560{
1561 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpIsNan, result_type, operand);
1562}

Referenced by spirv_compiler_emit_isfinite(), and spirv_compiler_emit_orderedness_instruction().

◆ vkd3d_spirv_build_op_isub()

static uint32_t vkd3d_spirv_build_op_isub ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

◆ vkd3d_spirv_build_op_kill()

static void vkd3d_spirv_build_op_kill ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1404 of file spirv.c.

1405{
1407}
@ SpvOpKill
Definition: spirv.h:1425

Referenced by spirv_compiler_emit_discard_function().

◆ vkd3d_spirv_build_op_label()

◆ vkd3d_spirv_build_op_load()

◆ vkd3d_spirv_build_op_logical_and()

static uint32_t vkd3d_spirv_build_op_logical_and ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1531 of file spirv.c.

1533{
1534 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1535 SpvOpLogicalAnd, result_type, operand0, operand1);
1536}

Referenced by spirv_compiler_emit_sample_position().

◆ vkd3d_spirv_build_op_logical_equal()

static uint32_t vkd3d_spirv_build_op_logical_equal ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1564 of file spirv.c.

1566{
1567 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1568 SpvOpLogicalEqual, result_type, operand0, operand1);
1569}
@ SpvOpLogicalEqual
Definition: spirv.h:1347

Referenced by spirv_compiler_emit_isfinite().

◆ vkd3d_spirv_build_op_logical_not()

static uint32_t vkd3d_spirv_build_op_logical_not ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1578 of file spirv.c.

1580{
1581 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream, SpvOpLogicalNot, result_type, operand);
1582}
@ SpvOpLogicalNot
Definition: spirv.h:1351

Referenced by spirv_compiler_emit_discard(), and spirv_compiler_emit_orderedness_instruction().

◆ vkd3d_spirv_build_op_logical_or()

static uint32_t vkd3d_spirv_build_op_logical_or ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1571 of file spirv.c.

1573{
1574 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1575 SpvOpLogicalOr, result_type, operand0, operand1);
1576}

Referenced by spirv_compiler_emit_orderedness_instruction().

◆ vkd3d_spirv_build_op_loop_merge()

static void vkd3d_spirv_build_op_loop_merge ( struct vkd3d_spirv_builder *  builder,
uint32_t  merge_block,
uint32_t  continue_target,
SpvLoopControlMask  loop_control 
)
static

Definition at line 1427 of file spirv.c.

1429{
1431 merge_block, continue_target, loop_control);
1432}
@ SpvOpLoopMerge
Definition: spirv.h:1419

Referenced by spirv_compiler_emit_merge().

◆ vkd3d_spirv_build_op_member_decorate()

static void vkd3d_spirv_build_op_member_decorate ( struct vkd3d_spirv_builder *  builder,
uint32_t  structure_type_id,
uint32_t  member_idx,
SpvDecoration  decoration,
uint32_t *  literals,
uint32_t  literal_count 
)
static

Definition at line 994 of file spirv.c.

997{
999 structure_type_id, member_idx, decoration, literals, literal_count);
1000}
@ SpvOpMemberDecorate
Definition: spirv.h:1260

Referenced by vkd3d_spirv_build_op_member_decorate1().

◆ vkd3d_spirv_build_op_member_decorate1()

static void vkd3d_spirv_build_op_member_decorate1 ( struct vkd3d_spirv_builder *  builder,
uint32_t  structure_type_id,
uint32_t  member_idx,
SpvDecoration  decoration,
uint32_t  operand0 
)
static

Definition at line 1002 of file spirv.c.

1004{
1005 vkd3d_spirv_build_op_member_decorate(builder, structure_type_id, member_idx, decoration, &operand0, 1);
1006}
static void vkd3d_spirv_build_op_member_decorate(struct vkd3d_spirv_builder *builder, uint32_t structure_type_id, uint32_t member_idx, SpvDecoration decoration, uint32_t *literals, uint32_t literal_count)
Definition: spirv.c:994

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_resource_declaration(), and spirv_compiler_generate_spirv().

◆ vkd3d_spirv_build_op_member_name()

static void vkd3d_spirv_build_op_member_name ( struct vkd3d_spirv_builder *  builder,
uint32_t  type_id,
uint32_t  member,
const char *  fmt,
  ... 
)
static

Definition at line 960 of file spirv.c.

962{
963 struct vkd3d_spirv_stream *stream = &builder->debug_stream;
964 unsigned int name_size;
965 char name[1024];
967
968 va_start(args, fmt);
970 name[ARRAY_SIZE(name) - 1] = '\0';
971 va_end(args);
972
978}
#define vsnprintf
Definition: acwin.h:108
@ SpvOpMemberName
Definition: spirv.h:1201
Definition: dsound.c:943

Referenced by spirv_compiler_emit_push_constant_buffers().

◆ vkd3d_spirv_build_op_memory_barrier()

static void vkd3d_spirv_build_op_memory_barrier ( struct vkd3d_spirv_builder *  builder,
uint32_t  memory_id,
uint32_t  memory_semantics_id 
)
static

Definition at line 1778 of file spirv.c.

1780{
1782 SpvOpMemoryBarrier, memory_id, memory_semantics_id);
1783}
@ SpvOpMemoryBarrier
Definition: spirv.h:1401

Referenced by spirv_compiler_emit_barrier().

◆ vkd3d_spirv_build_op_memory_model()

static void vkd3d_spirv_build_op_memory_model ( struct vkd3d_spirv_stream *  stream,
SpvAddressingModel  addressing_model,
SpvMemoryModel  memory_model 
)
static

Definition at line 916 of file spirv.c.

918{
919 vkd3d_spirv_build_op2(stream, SpvOpMemoryModel, addressing_model, memory_model);
920}
@ SpvOpMemoryModel
Definition: spirv.h:1207

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_build_op_name()

◆ vkd3d_spirv_build_op_r()

static uint32_t vkd3d_spirv_build_op_r ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op 
)
static

Definition at line 763 of file spirv.c.

765{
766 return vkd3d_spirv_build_op_rv(builder, stream, op, NULL, 0);
767}
static uint32_t vkd3d_spirv_build_op_rv(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:754

Referenced by vkd3d_spirv_build_op_type_bool(), vkd3d_spirv_build_op_type_sampler(), and vkd3d_spirv_build_op_type_void().

◆ vkd3d_spirv_build_op_r1()

static uint32_t vkd3d_spirv_build_op_r1 ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0 
)
static

Definition at line 769 of file spirv.c.

771{
772 return vkd3d_spirv_build_op_rv(builder, stream, op, &operand0, 1);
773}

Referenced by vkd3d_spirv_build_op_type_float(), vkd3d_spirv_build_op_type_runtime_array(), and vkd3d_spirv_build_op_type_sampled_image().

◆ vkd3d_spirv_build_op_r1v()

static uint32_t vkd3d_spirv_build_op_r1v ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 782 of file spirv.c.

785{
786 uint32_t result_id = vkd3d_spirv_alloc_id(builder);
787 vkd3d_spirv_build_op2v(stream, op, result_id, operand0, operands, operand_count);
788 return result_id;
789}

Referenced by vkd3d_spirv_build_op_type_function().

◆ vkd3d_spirv_build_op_r2()

static uint32_t vkd3d_spirv_build_op_r2 ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 775 of file spirv.c.

777{
778 uint32_t operands[] = {operand0, operand1};
779 return vkd3d_spirv_build_op_rv(builder, stream, op, operands, ARRAY_SIZE(operands));
780}

Referenced by vkd3d_spirv_build_op_type_array(), vkd3d_spirv_build_op_type_int(), vkd3d_spirv_build_op_type_pointer(), and vkd3d_spirv_build_op_type_vector().

◆ vkd3d_spirv_build_op_return()

◆ vkd3d_spirv_build_op_rv()

static uint32_t vkd3d_spirv_build_op_rv ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 754 of file spirv.c.

757{
758 uint32_t result_id = vkd3d_spirv_alloc_id(builder);
759 vkd3d_spirv_build_op1v(stream, op, result_id, operands, operand_count);
760 return result_id;
761}
static void vkd3d_spirv_build_op1v(struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:707

Referenced by vkd3d_spirv_build_op_r(), vkd3d_spirv_build_op_r1(), vkd3d_spirv_build_op_r2(), vkd3d_spirv_build_op_type_image(), and vkd3d_spirv_build_op_type_struct().

◆ vkd3d_spirv_build_op_sampled_image()

static uint32_t vkd3d_spirv_build_op_sampled_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  image_id,
uint32_t  sampler_id 
)
static

Definition at line 1605 of file spirv.c.

1607{
1608 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1609 SpvOpSampledImage, result_type, image_id, sampler_id);
1610}
@ SpvOpSampledImage
Definition: spirv.h:1272

Referenced by spirv_compiler_prepare_image().

◆ vkd3d_spirv_build_op_scope_subgroup()

static uint32_t vkd3d_spirv_build_op_scope_subgroup ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1785 of file spirv.c.

1786{
1788}
static uint32_t vkd3d_spirv_get_op_type_int(struct vkd3d_spirv_builder *builder, uint32_t width, uint32_t signedness)
Definition: spirv.c:1046
@ SpvScopeSubgroup
Definition: spirv.h:833

Referenced by vkd3d_spirv_get_op_scope_subgroup().

◆ vkd3d_spirv_build_op_select()

◆ vkd3d_spirv_build_op_selection_merge()

static void vkd3d_spirv_build_op_selection_merge ( struct vkd3d_spirv_builder *  builder,
uint32_t  merge_block,
uint32_t  selection_control 
)
static

Definition at line 1434 of file spirv.c.

1436{
1438 merge_block, selection_control);
1439}
@ SpvOpSelectionMerge
Definition: spirv.h:1420

Referenced by spirv_compiler_emit_conditional_branch(), spirv_compiler_emit_discard_function(), and spirv_compiler_emit_merge().

◆ vkd3d_spirv_build_op_shift_left_logical()

static uint32_t vkd3d_spirv_build_op_shift_left_logical ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base,
uint32_t  shift 
)
static

Definition at line 1517 of file spirv.c.

1519{
1520 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1521 SpvOpShiftLeftLogical, result_type, base, shift);
1522}
#define shift
Definition: input.c:3280

Referenced by spirv_compiler_emit_bufinfo().

◆ vkd3d_spirv_build_op_shift_right_logical()

static uint32_t vkd3d_spirv_build_op_shift_right_logical ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  base,
uint32_t  shift 
)
static

Definition at line 1524 of file spirv.c.

1526{
1527 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1528 SpvOpShiftRightLogical, result_type, base, shift);
1529}

Referenced by spirv_compiler_emit_raw_structured_addressing().

◆ vkd3d_spirv_build_op_snegate()

static uint32_t vkd3d_spirv_build_op_snegate ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand 
)
static

Definition at line 1503 of file spirv.c.

1505{
1506 return vkd3d_spirv_build_op_tr1(builder, &builder->function_stream,
1507 SpvOpSNegate, result_type, operand);
1508}

Referenced by spirv_compiler_emit_neg().

◆ vkd3d_spirv_build_op_spec_constant()

static uint32_t vkd3d_spirv_build_op_spec_constant ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  value 
)
static

Definition at line 1245 of file spirv.c.

1247{
1248 return vkd3d_spirv_build_op_tr1(builder, &builder->global_stream,
1249 SpvOpSpecConstant, result_type, value);
1250}
@ SpvOpSpecConstant
Definition: spirv.h:1240

Referenced by spirv_compiler_emit_spec_constant().

◆ vkd3d_spirv_build_op_spec_constant_composite()

static uint32_t vkd3d_spirv_build_op_spec_constant_composite ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
const uint32_t *  constituents,
unsigned int  constituent_count 
)
static

Definition at line 1231 of file spirv.c.

1233{
1234 return vkd3d_spirv_build_op_trv(builder, &builder->global_stream,
1235 SpvOpSpecConstantComposite, result_type, constituents, constituent_count);
1236}
@ SpvOpSpecConstantComposite
Definition: spirv.h:1241

Referenced by spirv_compiler_emit_spec_constant().

◆ vkd3d_spirv_build_op_store()

static void vkd3d_spirv_build_op_store ( struct vkd3d_spirv_builder *  builder,
uint32_t  pointer_id,
uint32_t  object_id,
uint32_t  memory_access 
)
static

Definition at line 1375 of file spirv.c.

1377{
1378 if (!memory_access)
1380 pointer_id, object_id);
1381 else
1383 pointer_id, object_id, memory_access);
1384}
@ SpvOpStore
Definition: spirv.h:1250

Referenced by spirv_compiler_emit_mov(), spirv_compiler_emit_point_size(), spirv_compiler_emit_store(), spirv_compiler_emit_store_scalar(), spirv_compiler_emit_store_tgsm(), spirv_compiler_emit_store_uav_raw_structured(), and spirv_compiler_emit_store_uav_typed().

◆ vkd3d_spirv_build_op_switch()

static void vkd3d_spirv_build_op_switch ( struct vkd3d_spirv_builder *  builder,
uint32_t  selector,
uint32_t  default_label,
uint32_t *  targets,
unsigned int  target_count 
)
static

Definition at line 1454 of file spirv.c.

1456{
1458 selector, default_label, targets, 2 * target_count);
1459}
@ SpvOpSwitch
Definition: spirv.h:1424

Referenced by spirv_compiler_emit_switch().

◆ vkd3d_spirv_build_op_tr()

static uint32_t vkd3d_spirv_build_op_tr ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  result_type 
)
static

◆ vkd3d_spirv_build_op_tr1()

◆ vkd3d_spirv_build_op_tr1v()

static uint32_t vkd3d_spirv_build_op_tr1v ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  result_type,
uint32_t  operand0,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 831 of file spirv.c.

834{
835 uint32_t result_id = vkd3d_spirv_alloc_id(builder);
836 vkd3d_spirv_build_op3v(stream, op, result_type, result_id, operand0, operands, operand_count);
837 return result_id;
838}

Referenced by vkd3d_spirv_build_op_access_chain(), vkd3d_spirv_build_op_composite_extract(), vkd3d_spirv_build_op_function_call(), vkd3d_spirv_build_op_in_bounds_access_chain(), and vkd3d_spirv_build_op_variable().

◆ vkd3d_spirv_build_op_tr2()

static uint32_t vkd3d_spirv_build_op_tr2 ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

◆ vkd3d_spirv_build_op_tr2v()

static uint32_t vkd3d_spirv_build_op_tr2v ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_spirv_stream *  stream,
SpvOp  op,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1,
const uint32_t *  operands,
unsigned int  operand_count 
)
static

Definition at line 840 of file spirv.c.

843{
844 uint32_t result_id = vkd3d_spirv_alloc_id(builder);
845 unsigned int i;
847 vkd3d_spirv_build_word(stream, result_type);
848 vkd3d_spirv_build_word(stream, result_id);
851 for (i = 0; i < operand_count; ++i)
852 vkd3d_spirv_build_word(stream, operands[i]);
853 return result_id;
854}

Referenced by vkd3d_spirv_build_op_composite_insert(), vkd3d_spirv_build_op_ext_inst(), and vkd3d_spirv_build_op_vector_shuffle().

◆ vkd3d_spirv_build_op_tr3()

◆ vkd3d_spirv_build_op_trv()

◆ vkd3d_spirv_build_op_type_array()

static uint32_t vkd3d_spirv_build_op_type_array ( struct vkd3d_spirv_builder *  builder,
uint32_t  element_type,
uint32_t  length_id 
)
static

Definition at line 1067 of file spirv.c.

1069{
1070 return vkd3d_spirv_build_op_r2(builder, &builder->global_stream,
1071 SpvOpTypeArray, element_type, length_id);
1072}
static uint32_t vkd3d_spirv_build_op_r2(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, uint32_t operand1)
Definition: spirv.c:775
@ SpvOpTypeArray
Definition: spirv.h:1220

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_resource_declaration(), and vkd3d_spirv_get_op_type_array().

◆ vkd3d_spirv_build_op_type_bool()

static uint32_t vkd3d_spirv_build_op_type_bool ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1018 of file spirv.c.

1019{
1020 return vkd3d_spirv_build_op_r(builder, &builder->global_stream, SpvOpTypeBool);
1021}
static uint32_t vkd3d_spirv_build_op_r(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op)
Definition: spirv.c:763
@ SpvOpTypeBool
Definition: spirv.h:1212

Referenced by vkd3d_spirv_get_op_type_bool().

◆ vkd3d_spirv_build_op_type_float()

static uint32_t vkd3d_spirv_build_op_type_float ( struct vkd3d_spirv_builder *  builder,
uint32_t  width 
)
static

Definition at line 1028 of file spirv.c.

1030{
1031 return vkd3d_spirv_build_op_r1(builder, &builder->global_stream, SpvOpTypeFloat, width);
1032}
GLint GLint GLsizei width
Definition: gl.h:1546
static uint32_t vkd3d_spirv_build_op_r1(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0)
Definition: spirv.c:769
@ SpvOpTypeFloat
Definition: spirv.h:1214

Referenced by vkd3d_spirv_get_op_type_float().

◆ vkd3d_spirv_build_op_type_function()

static uint32_t vkd3d_spirv_build_op_type_function ( struct vkd3d_spirv_builder *  builder,
uint32_t  return_type,
const uint32_t *  param_types,
unsigned int  param_count 
)
static

Definition at line 1142 of file spirv.c.

1144{
1145 return vkd3d_spirv_build_op_r1v(builder, &builder->global_stream,
1146 SpvOpTypeFunction, return_type, param_types, param_count);
1147}
static uint32_t vkd3d_spirv_build_op_r1v(struct vkd3d_spirv_builder *builder, struct vkd3d_spirv_stream *stream, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count)
Definition: spirv.c:782
@ SpvOpTypeFunction
Definition: spirv.h:1225

Referenced by vkd3d_spirv_get_op_type_function().

◆ vkd3d_spirv_build_op_type_image()

static uint32_t vkd3d_spirv_build_op_type_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  sampled_type_id,
uint32_t  dim,
uint32_t  depth,
uint32_t  arrayed,
uint32_t  ms,
uint32_t  sampled,
uint32_t  format 
)
static

Definition at line 1110 of file spirv.c.

1113{
1114 uint32_t operands[] = {sampled_type_id, dim, depth, arrayed, ms, sampled, format};
1115 return vkd3d_spirv_build_op_rv(builder, &builder->global_stream,
1116 SpvOpTypeImage, operands, ARRAY_SIZE(operands));
1117}
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
@ SpvOpTypeImage
Definition: spirv.h:1217

Referenced by vkd3d_spirv_get_op_type_image().

◆ vkd3d_spirv_build_op_type_int()

static uint32_t vkd3d_spirv_build_op_type_int ( struct vkd3d_spirv_builder *  builder,
uint32_t  width,
uint32_t  signedness 
)
static

Definition at line 1040 of file spirv.c.

1042{
1043 return vkd3d_spirv_build_op_r2(builder, &builder->global_stream, SpvOpTypeInt, width, signedness);
1044}
@ SpvOpTypeInt
Definition: spirv.h:1213

Referenced by vkd3d_spirv_get_op_type_int().

◆ vkd3d_spirv_build_op_type_pointer()

static uint32_t vkd3d_spirv_build_op_type_pointer ( struct vkd3d_spirv_builder *  builder,
uint32_t  storage_class,
uint32_t  type_id 
)
static

Definition at line 1156 of file spirv.c.

1158{
1159 return vkd3d_spirv_build_op_r2(builder, &builder->global_stream,
1161}
@ SpvOpTypePointer
Definition: spirv.h:1224

Referenced by vkd3d_spirv_get_op_type_pointer().

◆ vkd3d_spirv_build_op_type_runtime_array()

static uint32_t vkd3d_spirv_build_op_type_runtime_array ( struct vkd3d_spirv_builder *  builder,
uint32_t  element_type 
)
static

Definition at line 1081 of file spirv.c.

1082{
1083 return vkd3d_spirv_build_op_r1(builder, &builder->global_stream, SpvOpTypeRuntimeArray, element_type);
1084}
@ SpvOpTypeRuntimeArray
Definition: spirv.h:1221

Referenced by vkd3d_spirv_get_op_type_runtime_array().

◆ vkd3d_spirv_build_op_type_sampled_image()

static uint32_t vkd3d_spirv_build_op_type_sampled_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  image_type_id 
)
static

Definition at line 1128 of file spirv.c.

1130{
1131 return vkd3d_spirv_build_op_r1(builder, &builder->global_stream,
1132 SpvOpTypeSampledImage, image_type_id);
1133}
@ SpvOpTypeSampledImage
Definition: spirv.h:1219

Referenced by vkd3d_spirv_get_op_type_sampled_image().

◆ vkd3d_spirv_build_op_type_sampler()

static uint32_t vkd3d_spirv_build_op_type_sampler ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1099 of file spirv.c.

1100{
1101 return vkd3d_spirv_build_op_r(builder, &builder->global_stream, SpvOpTypeSampler);
1102}
@ SpvOpTypeSampler
Definition: spirv.h:1218

Referenced by vkd3d_spirv_get_op_type_sampler().

◆ vkd3d_spirv_build_op_type_struct()

static uint32_t vkd3d_spirv_build_op_type_struct ( struct vkd3d_spirv_builder *  builder,
uint32_t *  members,
unsigned int  member_count 
)
static

Definition at line 1092 of file spirv.c.

1094{
1095 return vkd3d_spirv_build_op_rv(builder, &builder->global_stream,
1096 SpvOpTypeStruct, members, member_count);
1097}
@ SpvOpTypeStruct
Definition: spirv.h:1222

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_resource_declaration(), and spirv_compiler_generate_spirv().

◆ vkd3d_spirv_build_op_type_vector()

static uint32_t vkd3d_spirv_build_op_type_vector ( struct vkd3d_spirv_builder *  builder,
uint32_t  component_type,
uint32_t  component_count 
)
static

Definition at line 1053 of file spirv.c.

1055{
1056 return vkd3d_spirv_build_op_r2(builder, &builder->global_stream,
1058}
@ SpvOpTypeVector
Definition: spirv.h:1215

Referenced by vkd3d_spirv_get_op_type_vector().

◆ vkd3d_spirv_build_op_type_void()

static uint32_t vkd3d_spirv_build_op_type_void ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1008 of file spirv.c.

1009{
1010 return vkd3d_spirv_build_op_r(builder, &builder->global_stream, SpvOpTypeVoid);
1011}
@ SpvOpTypeVoid
Definition: spirv.h:1211

Referenced by vkd3d_spirv_get_op_type_void().

◆ vkd3d_spirv_build_op_udiv()

static uint32_t vkd3d_spirv_build_op_udiv ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1475 of file spirv.c.

1477{
1478 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1479 SpvOpUDiv, result_type, operand0, operand1);
1480}

Referenced by spirv_compiler_emit_bufinfo().

◆ vkd3d_spirv_build_op_uless_than()

static uint32_t vkd3d_spirv_build_op_uless_than ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1538 of file spirv.c.

1540{
1541 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1542 SpvOpULessThan, result_type, operand0, operand1);
1543}

Referenced by spirv_compiler_emit_sample_position().

◆ vkd3d_spirv_build_op_uless_than_equal()

static uint32_t vkd3d_spirv_build_op_uless_than_equal ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  operand0,
uint32_t  operand1 
)
static

Definition at line 1545 of file spirv.c.

1547{
1548 return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream,
1549 SpvOpULessThanEqual, result_type, operand0, operand1);
1550}
@ SpvOpULessThanEqual
Definition: spirv.h:1361

Referenced by spirv_compiler_emit_sample_position().

◆ vkd3d_spirv_build_op_undef()

static uint32_t vkd3d_spirv_build_op_undef ( struct vkd3d_spirv_builder *  builder,
uint32_t  type_id 
)
static

Definition at line 1286 of file spirv.c.

1287{
1288 return vkd3d_spirv_build_op_tr(builder, &builder->global_stream, SpvOpUndef, type_id);
1289}
@ SpvOpUndef
Definition: spirv.h:1196

Referenced by vkd3d_spirv_get_op_undef().

◆ vkd3d_spirv_build_op_variable()

◆ vkd3d_spirv_build_op_vector_shuffle()

static uint32_t vkd3d_spirv_build_op_vector_shuffle ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  vector1_id,
uint32_t  vector2_id,
const uint32_t *  components,
uint32_t  component_count 
)
static

Definition at line 1322 of file spirv.c.

1325{
1327 result_type, vector1_id, vector2_id, components, component_count);
1328}
@ SpvOpVectorShuffle
Definition: spirv.h:1266

Referenced by spirv_compiler_emit_construct_vector(), spirv_compiler_emit_mov(), spirv_compiler_emit_store(), spirv_compiler_emit_swizzle(), and spirv_compiler_emit_vector_shuffle().

◆ vkd3d_spirv_build_string()

static void vkd3d_spirv_build_string ( struct vkd3d_spirv_stream *  stream,
const char *  str,
unsigned int  word_count 
)
static

Definition at line 518 of file spirv.c.

520{
521 unsigned int word_idx, i;
522 const char *ptr = str;
523
524 for (word_idx = 0; word_idx < word_count; ++word_idx)
525 {
526 uint32_t word = 0;
527 for (i = 0; i < sizeof(uint32_t) && *ptr; ++i)
528 word |= (uint32_t)*ptr++ << (8 * i);
530 }
531}
const WCHAR * word
Definition: lex.c:36
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * str

Referenced by vkd3d_spirv_build_op_entry_point(), vkd3d_spirv_build_op_ext_inst_import(), vkd3d_spirv_build_op_extension(), vkd3d_spirv_build_op_member_name(), and vkd3d_spirv_build_op_name().

◆ vkd3d_spirv_build_word()

◆ vkd3d_spirv_builder_begin_main_function()

static void vkd3d_spirv_builder_begin_main_function ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1993 of file spirv.c.

1994{
1995 uint32_t void_id, function_type_id;
1996
1997 void_id = vkd3d_spirv_get_op_type_void(builder);
1998 function_type_id = vkd3d_spirv_get_op_type_function(builder, void_id, NULL, 0);
1999
2000 vkd3d_spirv_build_op_function(builder, void_id,
2001 builder->main_function_id, SpvFunctionControlMaskNone, function_type_id);
2002}

Referenced by spirv_compiler_emit_hull_shader_main(), and spirv_compiler_emit_initial_declarations().

◆ vkd3d_spirv_builder_free()

static void vkd3d_spirv_builder_free ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 2004 of file spirv.c.

2005{
2011
2013
2014 vkd3d_free(builder->capabilities);
2015
2017
2018 vkd3d_free(builder->iface);
2019}
static void vkd3d_spirv_stream_free(struct vkd3d_spirv_stream *stream)
Definition: spirv.c:295
static void vkd3d_spirv_declaration_free(struct rb_entry *entry, void *context)
Definition: spirv.c:578
SpvCapability * capabilities
Definition: spirv.c:383

Referenced by spirv_compiler_destroy().

◆ vkd3d_spirv_builder_init()

static void vkd3d_spirv_builder_init ( struct vkd3d_spirv_builder *  builder,
const char *  entry_point 
)
static

Definition at line 1974 of file spirv.c.

1975{
1981
1983 builder->insertion_location = ~(size_t)0;
1984
1985 builder->current_id = 1;
1986
1988
1989 builder->main_function_id = vkd3d_spirv_alloc_id(builder);
1990 vkd3d_spirv_build_op_name(builder, builder->main_function_id, "%s", entry_point);
1991}
unsigned int size_t
Definition: corecrt.h:203
static int vkd3d_spirv_declaration_compare(const void *key, const struct rb_entry *e)
Definition: spirv.c:564
static void vkd3d_spirv_stream_init(struct vkd3d_spirv_stream *stream)
Definition: spirv.c:265

Referenced by spirv_compiler_create().

◆ vkd3d_spirv_capability_is_enabled()

static bool vkd3d_spirv_capability_is_enabled ( struct vkd3d_spirv_builder *  builder,
SpvCapability  cap 
)
static

Definition at line 423 of file spirv.c.

425{
426 size_t i;
427
428 if (cap < sizeof(builder->capability_mask) * CHAR_BIT)
429 return (builder->capability_mask >> cap) & 1;
430
431 for (i = 0; i < builder->capabilities_count; ++i)
432 if (builder->capabilities[i] == cap)
433 return true;
434
435 return false;
436}
size_t capabilities_count
Definition: spirv.c:385
uint64_t capability_mask
Definition: spirv.c:382

Referenced by spirv_compiler_end_invocation_interlock(), vkd3d_spirv_compile_module(), and vkd3d_spirv_enable_capability().

◆ vkd3d_spirv_compile_module()

static bool vkd3d_spirv_compile_module ( struct vkd3d_spirv_builder *  builder,
struct vkd3d_shader_code *  spirv,
const char *  entry_point,
enum vkd3d_shader_spirv_environment  environment 
)
static

Definition at line 2021 of file spirv.c.

2023{
2024 uint64_t capability_mask = builder->capability_mask;
2026 unsigned int i;
2027
2029
2034 vkd3d_spirv_build_word(&stream, builder->current_id); /* bound */
2035 vkd3d_spirv_build_word(&stream, 0); /* schema, reserved */
2036
2037 /* capabilities */
2038 for (i = 0; capability_mask; ++i)
2039 {
2040 if (capability_mask & 1)
2042 capability_mask >>= 1;
2043 }
2044 for (i = 0; i < builder->capabilities_count; ++i)
2046
2047 /* extensions */
2049 vkd3d_spirv_build_op_extension(&stream, "SPV_KHR_shader_draw_parameters");
2051 vkd3d_spirv_build_op_extension(&stream, "SPV_EXT_demote_to_helper_invocation");
2060 vkd3d_spirv_build_op_extension(&stream, "SPV_EXT_descriptor_indexing");
2063 vkd3d_spirv_build_op_extension(&stream, "SPV_EXT_fragment_shader_interlock");
2065 vkd3d_spirv_build_op_extension(&stream, "SPV_EXT_shader_stencil_export");
2067 vkd3d_spirv_build_op_extension(&stream, "SPV_EXT_shader_viewport_index_layer");
2068
2069 if (builder->ext_instr_set_glsl_450)
2071
2072 /* entry point declarations */
2075 entry_point, builder->iface, builder->iface_element_count);
2076
2077 /* execution mode declarations */
2078 if (builder->invocation_count)
2081
2087 {
2089 return false;
2090 }
2091
2094
2095 return true;
2096}
static void vkd3d_spirv_build_op_capability(struct vkd3d_spirv_stream *stream, SpvCapability cap)
Definition: spirv.c:885
#define VKD3D_SPIRV_VERSION_1_0
Definition: spirv.c:250
static void vkd3d_spirv_build_op_entry_point(struct vkd3d_spirv_stream *stream, SpvExecutionModel model, uint32_t function_id, const char *name, uint32_t *interface_list, unsigned int interface_size)
Definition: spirv.c:922
static void vkd3d_shader_code_from_spirv_stream(struct vkd3d_shader_code *code, struct vkd3d_spirv_stream *stream)
Definition: spirv.c:302
static void vkd3d_spirv_build_op_ext_inst_import(struct vkd3d_spirv_stream *stream, uint32_t result_id, const char *name)
Definition: spirv.c:899
#define VKD3D_SPIRV_GENERATOR_MAGIC
Definition: spirv.c:254
#define VKD3D_SPIRV_VERSION_1_3
Definition: spirv.c:251
static void vkd3d_spirv_build_op_memory_model(struct vkd3d_spirv_stream *stream, SpvAddressingModel addressing_model, SpvMemoryModel memory_model)
Definition: spirv.c:916
static bool vkd3d_spirv_stream_append(struct vkd3d_spirv_stream *dst_stream, const struct vkd3d_spirv_stream *src_stream)
Definition: spirv.c:341
static void vkd3d_spirv_build_op_extension(struct vkd3d_spirv_stream *stream, const char *name)
Definition: spirv.c:891
@ SpvMemoryModelGLSL450
Definition: spirv.h:112
static const unsigned int SpvMagicNumber
Definition: spirv.h:59
@ SpvExecutionModeInvocations
Definition: spirv.h:120
@ SpvAddressingModelLogical
Definition: spirv.h:102
SpvExecutionModel execution_model
Definition: spirv.c:388
uint32_t ext_instr_set_glsl_450
Definition: spirv.c:386

Referenced by spirv_compiler_generate_spirv().

◆ vkd3d_spirv_declaration_compare()

static int vkd3d_spirv_declaration_compare ( const void *  key,
const struct rb_entry *  e 
)
static

Definition at line 564 of file spirv.c.

565{
566 const struct vkd3d_spirv_declaration *a = key;
568 int ret;
569
570 if ((ret = vkd3d_u32_compare(a->op, b->op)))
571 return ret;
572 if ((ret = vkd3d_u32_compare(a->parameter_count, b->parameter_count)))
573 return ret;
574 VKD3D_ASSERT(a->parameter_count <= ARRAY_SIZE(a->parameters));
575 return memcmp(&a->parameters, &b->parameters, a->parameter_count * sizeof(*a->parameters));
576}
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2807
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
static int vkd3d_u32_compare(uint32_t x, uint32_t y)
Definition: vkd3d_common.h:386

Referenced by vkd3d_spirv_builder_init().

◆ vkd3d_spirv_declaration_free()

static void vkd3d_spirv_declaration_free ( struct rb_entry *  entry,
void *  context 
)
static

Definition at line 578 of file spirv.c.

Referenced by vkd3d_spirv_builder_free().

◆ vkd3d_spirv_dump()

static void vkd3d_spirv_dump ( const struct vkd3d_shader_code *  spirv,
enum vkd3d_shader_spirv_environment  environment 
)
static

Definition at line 189 of file spirv.c.

190 {}

Referenced by spirv_compiler_generate_spirv().

◆ vkd3d_spirv_enable_capability()

static void vkd3d_spirv_enable_capability ( struct vkd3d_spirv_builder *  builder,
SpvCapability  cap 
)
static

Definition at line 438 of file spirv.c.

440{
441 if (cap < sizeof(builder->capability_mask) * CHAR_BIT)
442 {
443 builder->capability_mask |= 1ull << cap;
444 return;
445 }
446
448 return;
449
450 vkd3d_array_reserve((void **)&builder->capabilities, &builder->capabilities_size,
451 builder->capabilities_count + 1, sizeof(*builder->capabilities));
452
453 builder->capabilities[builder->capabilities_count++] = cap;
454}
#define cap
Definition: glfuncs.h:226
size_t capabilities_size
Definition: spirv.c:384

Referenced by spirv_compiler_build_descriptor_variable(), spirv_compiler_decorate_builtin(), spirv_compiler_decorate_nonuniform(), spirv_compiler_emit_bufinfo(), spirv_compiler_emit_deriv_instruction(), spirv_compiler_emit_discard_function(), spirv_compiler_emit_draw_parameter_fixup(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_gather4(), spirv_compiler_emit_global_flags(), spirv_compiler_emit_initial_declarations(), spirv_compiler_emit_interpolation_decorations(), spirv_compiler_emit_lod(), spirv_compiler_emit_query_sample_count(), spirv_compiler_emit_register_execution_mode(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_resource_declaration(), spirv_compiler_emit_store_uav_typed(), spirv_compiler_emit_wave_alu_op(), spirv_compiler_emit_wave_bool_op(), spirv_compiler_enable_descriptor_indexing(), spirv_compiler_enable_resource_type(), spirv_compiler_end_invocation_interlock(), spirv_compiler_get_image_type_id(), vkd3d_spirv_build_op_group_nonuniform_ballot(), vkd3d_spirv_build_op_group_nonuniform_ballot_bit_count(), vkd3d_spirv_build_op_group_nonuniform_broadcast(), vkd3d_spirv_build_op_group_nonuniform_broadcast_first(), vkd3d_spirv_build_op_group_nonuniform_elect(), vkd3d_spirv_build_op_group_nonuniform_quad_broadcast(), vkd3d_spirv_build_op_group_nonuniform_quad_swap(), vkd3d_spirv_build_op_group_nonuniform_shuffle(), and vkd3d_spirv_set_execution_model().

◆ vkd3d_spirv_end_function_stream_insertion()

static void vkd3d_spirv_end_function_stream_insertion ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 869 of file spirv.c.

870{
871 struct vkd3d_spirv_stream *insertion_stream = &builder->insertion_stream;
872
873 if (builder->insertion_location == ~(size_t)0)
874 return;
875
876 builder->insertion_stream = builder->function_stream;
877 builder->function_stream = builder->original_function_stream;
878
880 insertion_stream->words, insertion_stream->word_count);
881 vkd3d_spirv_stream_clear(insertion_stream);
882 builder->insertion_location = ~(size_t)0;
883}
static void vkd3d_spirv_stream_insert(struct vkd3d_spirv_stream *stream, size_t location, const uint32_t *words, unsigned int word_count)
Definition: spirv.c:317
uint32_t * words
Definition: spirv.c:258
size_t word_count
Definition: spirv.c:260

Referenced by spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_temps(), and spirv_compiler_get_descriptor_index().

◆ vkd3d_spirv_get_glsl_std450_instr_set()

◆ vkd3d_spirv_get_op_constant()

static uint32_t vkd3d_spirv_get_op_constant ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  value 
)
static

Definition at line 1192 of file spirv.c.

1194{
1195 return vkd3d_spirv_build_once2(builder, SpvOpConstant, result_type, value,
1197}
static uint32_t vkd3d_spirv_build_op_constant(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
Definition: spirv.c:1185
static uint32_t vkd3d_spirv_build_once2(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, uint32_t operand1, vkd3d_spirv_build2_pfn build_pfn)
Definition: spirv.c:648

Referenced by spirv_compiler_emit_constant_array(), spirv_compiler_emit_quad_read_across(), spirv_compiler_get_constant(), and vkd3d_spirv_build_op_scope_subgroup().

◆ vkd3d_spirv_get_op_constant64()

static uint32_t vkd3d_spirv_get_op_constant64 ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint64_t  value 
)
static

Definition at line 1207 of file spirv.c.

1209{
1210 return vkd3d_spirv_build_once1v(builder, SpvOpConstant, result_type,
1212}
static uint32_t vkd3d_spirv_build_once1v(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, const uint32_t *operands, unsigned int operand_count, vkd3d_spirv_build1v_pfn build_pfn)
Definition: spirv.c:620
static uint32_t vkd3d_spirv_build_op_constant64(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *values, unsigned int value_count)
Definition: spirv.c:1199

Referenced by spirv_compiler_get_constant64().

◆ vkd3d_spirv_get_op_constant_bool()

static uint32_t vkd3d_spirv_get_op_constant_bool ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
uint32_t  value 
)
static

Definition at line 1177 of file spirv.c.

1179{
1182}
static uint32_t vkd3d_spirv_build_op_constant_bool(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t value)
Definition: spirv.c:1170

Referenced by spirv_compiler_get_constant().

◆ vkd3d_spirv_get_op_constant_composite()

static uint32_t vkd3d_spirv_get_op_constant_composite ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type,
const uint32_t *  constituents,
unsigned int  constituent_count 
)
static

Definition at line 1238 of file spirv.c.

1240{
1241 return vkd3d_spirv_build_once1v(builder, SpvOpConstantComposite, result_type,
1242 constituents, constituent_count, vkd3d_spirv_build_op_constant_composite);
1243}

Referenced by spirv_compiler_get_constant(), and spirv_compiler_get_constant64().

◆ vkd3d_spirv_get_op_constant_null()

static uint32_t vkd3d_spirv_get_op_constant_null ( struct vkd3d_spirv_builder *  builder,
uint32_t  result_type 
)
static

Definition at line 1219 of file spirv.c.

1220{
1222}
static uint32_t vkd3d_spirv_build_op_constant_null(struct vkd3d_spirv_builder *builder, uint32_t result_type)
Definition: spirv.c:1214
static uint32_t vkd3d_spirv_build_once1(struct vkd3d_spirv_builder *builder, SpvOp op, uint32_t operand0, vkd3d_spirv_build1_pfn build_pfn)
Definition: spirv.c:602

Referenced by spirv_compiler_emit_constant_array(), and spirv_compiler_emit_workgroup_memory().

◆ vkd3d_spirv_get_op_scope_subgroup()

◆ vkd3d_spirv_get_op_type_array()

static uint32_t vkd3d_spirv_get_op_type_array ( struct vkd3d_spirv_builder *  builder,
uint32_t  element_type,
uint32_t  length_id 
)
static

◆ vkd3d_spirv_get_op_type_bool()

static uint32_t vkd3d_spirv_get_op_type_bool ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1023 of file spirv.c.

1024{
1026}
static uint32_t vkd3d_spirv_build_op_type_bool(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1018
uint32_t type_bool_id
Definition: spirv.c:394

Referenced by spirv_compiler_emit_discard(), spirv_compiler_emit_discard_function(), spirv_compiler_emit_wave_bool_op(), vkd3d_spirv_build_op_group_nonuniform_elect(), and vkd3d_spirv_get_type_id().

◆ vkd3d_spirv_get_op_type_float()

static uint32_t vkd3d_spirv_get_op_type_float ( struct vkd3d_spirv_builder *  builder,
uint32_t  width 
)
static

Definition at line 1034 of file spirv.c.

1036{
1038}
static uint32_t vkd3d_spirv_build_op_type_float(struct vkd3d_spirv_builder *builder, uint32_t width)
Definition: spirv.c:1028

Referenced by vkd3d_spirv_get_type_id().

◆ vkd3d_spirv_get_op_type_function()

static uint32_t vkd3d_spirv_get_op_type_function ( struct vkd3d_spirv_builder *  builder,
uint32_t  return_type,
const uint32_t *  param_types,
unsigned int  param_count 
)
static

Definition at line 1149 of file spirv.c.

1151{
1152 return vkd3d_spirv_build_once1v(builder, SpvOpTypeFunction, return_type,
1153 param_types, param_count, vkd3d_spirv_build_op_type_function);
1154}
static uint32_t vkd3d_spirv_build_op_type_function(struct vkd3d_spirv_builder *builder, uint32_t return_type, const uint32_t *param_types, unsigned int param_count)
Definition: spirv.c:1142

Referenced by spirv_compiler_emit_discard_function(), spirv_compiler_emit_shader_epilogue_function(), spirv_compiler_enter_shader_phase(), and vkd3d_spirv_builder_begin_main_function().

◆ vkd3d_spirv_get_op_type_image()

static uint32_t vkd3d_spirv_get_op_type_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  sampled_type_id,
SpvDim  dim,
uint32_t  depth,
uint32_t  arrayed,
uint32_t  ms,
uint32_t  sampled,
SpvImageFormat  format 
)
static

Definition at line 1119 of file spirv.c.

1122{
1123 uint32_t operands[] = {sampled_type_id, dim, depth, arrayed, ms, sampled, format};
1124 return vkd3d_spirv_build_once7(builder, SpvOpTypeImage, operands,
1126}
static uint32_t vkd3d_spirv_build_op_type_image(struct vkd3d_spirv_builder *builder, uint32_t sampled_type_id, uint32_t dim, uint32_t depth, uint32_t arrayed, uint32_t ms, uint32_t sampled, uint32_t format)
Definition: spirv.c:1110
static uint32_t vkd3d_spirv_build_once7(struct vkd3d_spirv_builder *builder, SpvOp op, const uint32_t *operands, vkd3d_spirv_build7_pfn build_pfn)
Definition: spirv.c:667

Referenced by spirv_compiler_get_image_type_id().

◆ vkd3d_spirv_get_op_type_int()

static uint32_t vkd3d_spirv_get_op_type_int ( struct vkd3d_spirv_builder *  builder,
uint32_t  width,
uint32_t  signedness 
)
static

Definition at line 1046 of file spirv.c.

1048{
1049 return vkd3d_spirv_build_once2(builder, SpvOpTypeInt, width, signedness,
1051}
static uint32_t vkd3d_spirv_build_op_type_int(struct vkd3d_spirv_builder *builder, uint32_t width, uint32_t signedness)
Definition: spirv.c:1040

Referenced by vkd3d_spirv_build_op_scope_subgroup(), and vkd3d_spirv_get_type_id().

◆ vkd3d_spirv_get_op_type_pointer()

static uint32_t vkd3d_spirv_get_op_type_pointer ( struct vkd3d_spirv_builder *  builder,
uint32_t  storage_class,
uint32_t  type_id 
)
static

◆ vkd3d_spirv_get_op_type_runtime_array()

static uint32_t vkd3d_spirv_get_op_type_runtime_array ( struct vkd3d_spirv_builder *  builder,
uint32_t  element_type 
)
static

Definition at line 1086 of file spirv.c.

1087{
1090}
static uint32_t vkd3d_spirv_build_op_type_runtime_array(struct vkd3d_spirv_builder *builder, uint32_t element_type)
Definition: spirv.c:1081

Referenced by spirv_compiler_build_descriptor_variable(), and spirv_compiler_emit_resource_declaration().

◆ vkd3d_spirv_get_op_type_sampled_image()

static uint32_t vkd3d_spirv_get_op_type_sampled_image ( struct vkd3d_spirv_builder *  builder,
uint32_t  image_type_id 
)
static

Definition at line 1135 of file spirv.c.

1137{
1138 return vkd3d_spirv_build_once1(builder, SpvOpTypeSampledImage, image_type_id,
1140}
static uint32_t vkd3d_spirv_build_op_type_sampled_image(struct vkd3d_spirv_builder *builder, uint32_t image_type_id)
Definition: spirv.c:1128

Referenced by spirv_compiler_emit_combined_sampler_declarations(), and spirv_compiler_prepare_image().

◆ vkd3d_spirv_get_op_type_sampler()

static uint32_t vkd3d_spirv_get_op_type_sampler ( struct vkd3d_spirv_builder *  builder)
static

Definition at line 1104 of file spirv.c.

1105{
1107}
static uint32_t vkd3d_spirv_build_op_type_sampler(struct vkd3d_spirv_builder *builder)
Definition: spirv.c:1099
uint32_t type_sampler_id
Definition: spirv.c:393

Referenced by spirv_compiler_emit_sampler_declaration(), and spirv_compiler_prepare_image().

◆ vkd3d_spirv_get_op_type_vector()

static uint32_t vkd3d_spirv_get_op_type_vector ( struct vkd3d_spirv_builder *  builder,
uint32_t  component_type,
uint32_t  component_count 
)
static

Definition at line 1060 of file spirv.c.

1062{
1065}
static uint32_t vkd3d_spirv_build_op_type_vector(struct vkd3d_spirv_builder *builder, uint32_t component_type, uint32_t component_count)
Definition: spirv.c:1053

Referenced by vkd3d_spirv_get_type_id().

◆ vkd3d_spirv_get_op_type_void()

◆ vkd3d_spirv_get_op_undef()

static uint32_t vkd3d_spirv_get_op_undef ( struct vkd3d_spirv_builder *  builder,
uint32_t  type_id 
)
static

Definition at line 1291 of file spirv.c.

1292{
1294}
static uint32_t vkd3d_spirv_build_op_undef(struct vkd3d_spirv_builder *builder, uint32_t type_id)
Definition: spirv.c:1286

Referenced by spirv_compiler_emit_load_reg(), spirv_compiler_emit_load_undef(), spirv_compiler_get_constant(), and spirv_compiler_get_constant64().

◆ vkd3d_spirv_get_type_id()

static uint32_t vkd3d_spirv_get_type_id ( struct vkd3d_spirv_builder *  builder,
enum vkd3d_shader_component_type  component_type,
unsigned int  component_count 
)
static

Definition at line 1910 of file spirv.c.

1912{
1913 uint32_t scalar_id, type_id;
1914
1917 {
1918 ERR("Invalid component count %u.\n", component_count);
1919 return 0;
1920 }
1921
1923 return type_id;
1924
1925 if (component_count == 1)
1926 {
1927 switch (component_type)
1928 {
1931 break;
1934 break;
1938 break;
1941 break;
1944 break;
1946 type_id = vkd3d_spirv_get_op_type_int(builder, 64, 0);
1947 break;
1948 default:
1949 FIXME("Unhandled component type %#x.\n", component_type);
1950 return 0;
1951 }
1952 }
1953 else
1954 {
1956 scalar_id = vkd3d_spirv_get_type_id(builder, component_type, 1);
1958 }
1959
1961
1962 return type_id;
1963}
static uint32_t vkd3d_spirv_get_op_type_vector(struct vkd3d_spirv_builder *builder, uint32_t component_type, uint32_t component_count)
Definition: spirv.c:1060
static uint32_t vkd3d_spirv_get_op_type_float(struct vkd3d_spirv_builder *builder, uint32_t width)
Definition: spirv.c:1034
uint32_t numeric_type_ids[VKD3D_SHADER_COMPONENT_TYPE_COUNT][VKD3D_VEC4_SIZE]
Definition: spirv.c:397
@ VKD3D_SHADER_COMPONENT_VOID
#define VKD3D_SHADER_COMPONENT_TYPE_COUNT

Referenced by frag_coord_fixup(), spirv_compiler_emit_array_variable(), spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bitfield_instruction(), spirv_compiler_emit_bool_to_double(), spirv_compiler_emit_bool_to_float(), spirv_compiler_emit_bool_to_int(), spirv_compiler_emit_bool_to_int64(), spirv_compiler_emit_bufinfo(), spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_construct_vector(), spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_default_control_point_phase(), spirv_compiler_emit_dereference_register(), spirv_compiler_emit_dot(), spirv_compiler_emit_draw_parameter_fixup(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_ext_glsl_instruction(), spirv_compiler_emit_f16tof32(), spirv_compiler_emit_f32tof16(), spirv_compiler_emit_float_comparison_instruction(), spirv_compiler_emit_ftoi(), spirv_compiler_emit_ftou(), spirv_compiler_emit_gather4(), spirv_compiler_emit_group_nonuniform_ballot(), spirv_compiler_emit_input(), spirv_compiler_emit_int_to_bool(), spirv_compiler_emit_ld(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_ld_tgsm(), spirv_compiler_emit_ld_uav_typed(), spirv_compiler_emit_load_invocation_id(), spirv_compiler_emit_load_reg(), spirv_compiler_emit_load_scalar(), spirv_compiler_emit_load_ssa_reg(), spirv_compiler_emit_lod(), spirv_compiler_emit_mov(), spirv_compiler_emit_movc(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_query_sample_count(), spirv_compiler_emit_register_addressing(), spirv_compiler_emit_resinfo(), spirv_compiler_emit_resource_declaration(), spirv_compiler_emit_sample(), spirv_compiler_emit_sample_c(), spirv_compiler_emit_sample_info(), spirv_compiler_emit_sample_position(), spirv_compiler_emit_shader_epilogue_function(), spirv_compiler_emit_spec_constant(), spirv_compiler_emit_store(), spirv_compiler_emit_store_dst_components(), spirv_compiler_emit_store_reg(), spirv_compiler_emit_store_scalar(), spirv_compiler_emit_store_shader_output(), spirv_compiler_emit_store_tgsm(), spirv_compiler_emit_store_uav_raw_structured(), spirv_compiler_emit_store_uav_typed(), spirv_compiler_emit_swapc(), spirv_compiler_emit_swizzle(), spirv_compiler_emit_uav_counter_instruction(), spirv_compiler_emit_vector_shuffle(), spirv_compiler_emit_wave_bit_count(), spirv_compiler_emit_workgroup_memory(), spirv_compiler_generate_spirv(), spirv_compiler_get_buffer_parameter(), spirv_compiler_get_constant(), spirv_compiler_get_constant64(), spirv_compiler_get_descriptor_index(), spirv_compiler_get_image_type_id(), spirv_compiler_get_type_id_for_reg(), vkd3d_spirv_get_type_id(), and vkd3d_spirv_get_type_id_for_data_type().

◆ vkd3d_spirv_get_type_id_for_data_type()

◆ vkd3d_spirv_insert_declaration()

static void vkd3d_spirv_insert_declaration ( struct vkd3d_spirv_builder *  builder,
const struct vkd3d_spirv_declaration *  declaration 
)
static

Definition at line 585 of file spirv.c.

587{
589
590 VKD3D_ASSERT(declaration->parameter_count <= ARRAY_SIZE(declaration->parameters));
591
592 if (!(d = vkd3d_malloc(sizeof(*d))))
593 return;
594 memcpy(d, declaration, sizeof(*d));
595 if (rb_put(&builder->declarations, d, &d->entry) == -1)
596 {
597 ERR("Failed to insert declaration entry.\n");
598 vkd3d_free(d);
599 }
600}
struct list entry
Definition: wpp.c:51

Referenced by vkd3d_spirv_build_once1(), vkd3d_spirv_build_once1v(), vkd3d_spirv_build_once2(), and vkd3d_spirv_build_once7().

◆ vkd3d_spirv_opcode_word()

static uint32_t vkd3d_spirv_opcode_word ( SpvOp  op,
unsigned int  word_count 
)
static

◆ vkd3d_spirv_set_execution_model()

static void vkd3d_spirv_set_execution_model ( struct vkd3d_spirv_builder *  builder,
SpvExecutionModel  model 
)
static

Definition at line 474 of file spirv.c.

476{
477 builder->execution_model = model;
478
479 switch (model)
480 {
485 break;
489 break;
492 break;
493 default:
494 ERR("Unhandled execution model %#x.\n", model);
495 }
496}
@ SpvCapabilityShader
Definition: spirv.h:871
@ SpvCapabilityTessellation
Definition: spirv.h:873

Referenced by spirv_compiler_emit_initial_declarations().

◆ vkd3d_spirv_stream_append()

static bool vkd3d_spirv_stream_append ( struct vkd3d_spirv_stream *  dst_stream,
const struct vkd3d_spirv_stream *  src_stream 
)
static

Definition at line 341 of file spirv.c.

343{
344 size_t word_count, src_word_count = src_stream->word_count;
345 struct vkd3d_spirv_chunk *chunk;
346 size_t src_location = 0;
347
349
351 src_word_count += chunk->word_count;
352
353 if (!vkd3d_array_reserve((void **)&dst_stream->words, &dst_stream->capacity,
354 dst_stream->word_count + src_word_count, sizeof(*dst_stream->words)))
355 return false;
356
357 VKD3D_ASSERT(dst_stream->word_count + src_word_count <= dst_stream->capacity);
359 {
360 VKD3D_ASSERT(src_location <= chunk->location);
361 word_count = chunk->location - src_location;
362 memcpy(&dst_stream->words[dst_stream->word_count], &src_stream->words[src_location],
363 word_count * sizeof(*src_stream->words));
364 dst_stream->word_count += word_count;
365 src_location += word_count;
366 VKD3D_ASSERT(src_location == chunk->location);
367
368 memcpy(&dst_stream->words[dst_stream->word_count], chunk->words,
369 chunk->word_count * sizeof(*chunk->words));
370 dst_stream->word_count += chunk->word_count;
371 }
372
373 word_count = src_stream->word_count - src_location;
374 memcpy(&dst_stream->words[dst_stream->word_count], &src_stream->words[src_location],
375 word_count * sizeof(*src_stream->words));
376 dst_stream->word_count += word_count;
377 return true;
378}
static int list_empty(struct list_entry *head)
Definition: list.h:58
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:236
size_t word_count
Definition: spirv.c:279
struct list inserted_chunks
Definition: spirv.c:262
size_t capacity
Definition: spirv.c:259

Referenced by vkd3d_spirv_compile_module().

◆ vkd3d_spirv_stream_clear()

static void vkd3d_spirv_stream_clear ( struct vkd3d_spirv_stream *  stream)
static

Definition at line 283 of file spirv.c.

284{
285 struct vkd3d_spirv_chunk *c1, *c2;
286
287 stream->word_count = 0;
288
289 LIST_FOR_EACH_ENTRY_SAFE(c1, c2, &stream->inserted_chunks, struct vkd3d_spirv_chunk, entry)
290 vkd3d_free(c1);
291
292 list_init(&stream->inserted_chunks);
293}
static void list_init(struct list_entry *head)
Definition: list.h:51
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:242

Referenced by spirv_compiler_generate_spirv(), vkd3d_spirv_end_function_stream_insertion(), and vkd3d_spirv_stream_free().

◆ vkd3d_spirv_stream_current_location()

static size_t vkd3d_spirv_stream_current_location ( struct vkd3d_spirv_stream *  stream)
static

Definition at line 312 of file spirv.c.

313{
314 return stream->word_count;
315}

Referenced by spirv_compiler_initialise_block(), and vkd3d_spirv_begin_function_stream_insertion().

◆ vkd3d_spirv_stream_free()

static void vkd3d_spirv_stream_free ( struct vkd3d_spirv_stream *  stream)
static

Definition at line 295 of file spirv.c.

296{
297 vkd3d_free(stream->words);
298
300}

Referenced by vkd3d_spirv_builder_free(), and vkd3d_spirv_compile_module().

◆ vkd3d_spirv_stream_init()

static void vkd3d_spirv_stream_init ( struct vkd3d_spirv_stream *  stream)
static

Definition at line 265 of file spirv.c.

266{
267 stream->capacity = 256;
268 if (!(stream->words = vkd3d_calloc(stream->capacity, sizeof(*stream->words))))
269 stream->capacity = 0;
270 stream->word_count = 0;
271
272 list_init(&stream->inserted_chunks);
273}

Referenced by vkd3d_spirv_builder_init(), and vkd3d_spirv_compile_module().

◆ vkd3d_spirv_stream_insert()

static void vkd3d_spirv_stream_insert ( struct vkd3d_spirv_stream *  stream,
size_t  location,
const uint32_t *  words,
unsigned int  word_count 
)
static

Definition at line 317 of file spirv.c.

319{
321
323 return;
324
325 chunk->location = location;
326 chunk->word_count = word_count;
327 memcpy(chunk->words, words, word_count * sizeof(*words));
328
329 LIST_FOR_EACH_ENTRY(current, &stream->inserted_chunks, struct vkd3d_spirv_chunk, entry)
330 {
331 if (current->location > location)
332 {
333 list_add_before(&current->entry, &chunk->entry);
334 return;
335 }
336 }
337
338 list_add_tail(&stream->inserted_chunks, &chunk->entry);
339}
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
#define offsetof(TYPE, MEMBER)
__WINE_SERVER_LIST_INLINE void list_add_before(struct list *elem, struct list *to_add)
Definition: list.h:89
uint32_t words[]
Definition: spirv.c:280

Referenced by vkd3d_spirv_end_function_stream_insertion().

◆ vkd3d_spirv_string_word_count()

static unsigned int vkd3d_spirv_string_word_count ( const char *  str)
static

Definition at line 513 of file spirv.c.

514{
515 return align(strlen(str) + 1, sizeof(uint32_t)) / sizeof(uint32_t);
516}
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597

Referenced by vkd3d_spirv_build_op_entry_point(), vkd3d_spirv_build_op_ext_inst_import(), vkd3d_spirv_build_op_extension(), vkd3d_spirv_build_op_member_name(), and vkd3d_spirv_build_op_name().

◆ vkd3d_spirv_validate()

static bool vkd3d_spirv_validate ( struct vkd3d_string_buffer *  buffer,
const struct vkd3d_shader_code *  spirv,
enum vkd3d_shader_spirv_environment  environment 
)
static

Definition at line 191 of file spirv.c.

193{
194 return true;
195}

Referenced by spirv_compiler_generate_spirv().

◆ vkd3d_swizzle_is_equal()

static bool vkd3d_swizzle_is_equal ( uint32_t  dst_write_mask,
uint32_t  swizzle,
uint32_t  write_mask 
)
static

Definition at line 3764 of file spirv.c.

3765{
3766 return vkd3d_compact_swizzle(VKD3D_SHADER_NO_SWIZZLE, dst_write_mask) == vkd3d_compact_swizzle(swizzle, write_mask);
3767}
static unsigned int vkd3d_compact_swizzle(uint32_t swizzle, uint32_t write_mask)

Referenced by spirv_compiler_emit_mov(), and spirv_compiler_emit_swizzle().

◆ vkd3d_swizzle_is_scalar()

static bool vkd3d_swizzle_is_scalar ( uint32_t  swizzle,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 3769 of file spirv.c.

3770{
3771 unsigned int component_idx = vsir_swizzle_get_component(swizzle, 0);
3772
3773 if (vsir_swizzle_get_component(swizzle, 1) != component_idx)
3774 return false;
3775
3776 if (data_type_is_64_bit(reg->data_type))
3777 return true;
3778
3779 return vsir_swizzle_get_component(swizzle, 2) == component_idx
3780 && vsir_swizzle_get_component(swizzle, 3) == component_idx;
3781}

Referenced by spirv_compiler_emit_branch(), spirv_compiler_emit_load_ssa_reg(), and spirv_compiler_emit_switch().

◆ vkd3d_symbol_compare()

static int vkd3d_symbol_compare ( const void *  key,
const struct rb_entry *  entry 
)
static

Definition at line 2257 of file spirv.c.

2258{
2259 const struct vkd3d_symbol *a = key;
2260 const struct vkd3d_symbol *b = RB_ENTRY_VALUE(entry, const struct vkd3d_symbol, entry);
2261 int ret;
2262
2263 if ((ret = vkd3d_u32_compare(a->type, b->type)))
2264 return ret;
2265 return memcmp(&a->key, &b->key, sizeof(a->key));
2266}

Referenced by spirv_compiler_create().

◆ vkd3d_symbol_dup()

static struct vkd3d_symbol * vkd3d_symbol_dup ( const struct vkd3d_symbol *  symbol)
static

Definition at line 2352 of file spirv.c.

2353{
2354 struct vkd3d_symbol *s;
2355
2356 if (!(s = vkd3d_malloc(sizeof(*s))))
2357 return NULL;
2358
2359 return memcpy(s, symbol, sizeof(*s));
2360}

Referenced by spirv_compiler_put_symbol().

◆ vkd3d_symbol_free()

static void vkd3d_symbol_free ( struct rb_entry *  entry,
void *  context 
)
static

Definition at line 2268 of file spirv.c.

2269{
2271
2272 vkd3d_free(s);
2273}

Referenced by spirv_compiler_destroy().

◆ vkd3d_symbol_make_combined_sampler()

static void vkd3d_symbol_make_combined_sampler ( struct vkd3d_symbol *  symbol,
const struct vkd3d_shader_register *  resource_reg,
unsigned int  sampler_space,
unsigned int  sampler_index 
)
static

Definition at line 2341 of file spirv.c.

2343{
2344 symbol->type = VKD3D_SYMBOL_COMBINED_SAMPLER;
2345 memset(&symbol->key, 0, sizeof(symbol->key));
2346 symbol->key.combined_sampler.resource_type = resource_reg->type;
2347 symbol->key.combined_sampler.resource_id = resource_reg->idx[0].offset;
2348 symbol->key.combined_sampler.sampler_space = sampler_space;
2349 symbol->key.combined_sampler.sampler_index = sampler_index;
2350}
struct vkd3d_shader_register_index idx[3]
struct vkd3d_symbol_combined_sampler combined_sampler
Definition: spirv.c:2240

Referenced by spirv_compiler_emit_combined_sampler_declarations(), and spirv_compiler_find_combined_sampler().

◆ vkd3d_symbol_make_io()

static void vkd3d_symbol_make_io ( struct vkd3d_symbol *  symbol,
enum vkd3d_shader_register_type  type,
unsigned int  index 
)
static

Definition at line 2300 of file spirv.c.

2302{
2303 symbol->type = VKD3D_SYMBOL_REGISTER;
2304 memset(&symbol->key, 0, sizeof(symbol->key));
2305 symbol->key.reg.type = type;
2306 symbol->key.reg.idx = index;
2307}
enum vkd3d_data_type type
Definition: spirv.c:3448

Referenced by spirv_compiler_emit_input(), and spirv_compiler_emit_output().

◆ vkd3d_symbol_make_register()

static void vkd3d_symbol_make_register ( struct vkd3d_symbol *  symbol,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 2275 of file spirv.c.

2277{
2278 symbol->type = VKD3D_SYMBOL_REGISTER;
2279 memset(&symbol->key, 0, sizeof(symbol->key));
2280 symbol->key.reg.type = reg->type;
2281
2282 switch (reg->type)
2283 {
2284 case VKD3DSPR_INPUT:
2285 case VKD3DSPR_OUTPUT:
2287 symbol->key.reg.idx = reg->idx_count ? reg->idx[reg->idx_count - 1].offset : ~0u;
2288 VKD3D_ASSERT(!reg->idx_count || symbol->key.reg.idx != ~0u);
2289 break;
2290
2292 symbol->key.reg.idx = reg->idx_count > 1 ? reg->idx[0].offset : 0;
2293 break;
2294
2295 default:
2296 symbol->key.reg.idx = reg->idx_count ? reg->idx[0].offset : ~0u;
2297 }
2298}

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_dcl_immediate_constant_buffer(), spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_input_register(), spirv_compiler_emit_output_register(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_sampler_declaration(), spirv_compiler_emit_workgroup_memory(), and spirv_compiler_get_register_info().

◆ vkd3d_symbol_make_resource()

static void vkd3d_symbol_make_resource ( struct vkd3d_symbol *  symbol,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 2324 of file spirv.c.

2326{
2327 symbol->type = VKD3D_SYMBOL_RESOURCE;
2328 memset(&symbol->key, 0, sizeof(symbol->key));
2329 symbol->key.resource.type = reg->type;
2330 symbol->key.resource.idx = reg->idx[0].offset;
2331}

Referenced by spirv_compiler_emit_resource_declaration(), and spirv_compiler_find_resource().

◆ vkd3d_symbol_make_sampler()

static void vkd3d_symbol_make_sampler ( struct vkd3d_symbol *  symbol,
const struct vkd3d_shader_register *  reg 
)
static

Definition at line 2333 of file spirv.c.

2335{
2336 symbol->type = VKD3D_SYMBOL_SAMPLER;
2337 memset(&symbol->key, 0, sizeof(symbol->key));
2338 symbol->key.sampler.id = reg->idx[0].offset;
2339}

Referenced by spirv_compiler_emit_sampler_declaration(), and spirv_compiler_find_combined_sampler().

◆ vkd3d_symbol_set_register_info()

static void vkd3d_symbol_set_register_info ( struct vkd3d_symbol *  symbol,
uint32_t  val_id,
SpvStorageClass  storage_class,
enum vkd3d_shader_component_type  component_type,
uint32_t  write_mask 
)
static

Definition at line 2309 of file spirv.c.

2312{
2313 symbol->id = val_id;
2314 symbol->descriptor_array = NULL;
2315 symbol->info.reg.storage_class = storage_class;
2316 symbol->info.reg.member_idx = 0;
2317 symbol->info.reg.component_type = component_type;
2318 symbol->info.reg.write_mask = write_mask;
2319 symbol->info.reg.structure_stride = 0;
2320 symbol->info.reg.binding_base_idx = 0;
2321 symbol->info.reg.is_aggregate = false;
2322}

Referenced by spirv_compiler_emit_cbv_declaration(), spirv_compiler_emit_dcl_immediate_constant_buffer(), spirv_compiler_emit_dcl_indexable_temp(), spirv_compiler_emit_input(), spirv_compiler_emit_input_register(), spirv_compiler_emit_output(), spirv_compiler_emit_output_register(), spirv_compiler_emit_push_constant_buffers(), spirv_compiler_emit_sampler_declaration(), and spirv_compiler_emit_workgroup_memory().

Variable Documentation

◆ builtin

◆ component_count

unsigned int component_count

Definition at line 3449 of file spirv.c.

Referenced by spirv_compiler_decorate_xfb_output(), spirv_compiler_emit_array_variable(), spirv_compiler_emit_bool_to_double(), spirv_compiler_emit_bool_to_float(), spirv_compiler_emit_bool_to_int(), spirv_compiler_emit_bool_to_int64(), spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_constant_array(), spirv_compiler_emit_construct_vector(), spirv_compiler_emit_default_control_point_phase(), spirv_compiler_emit_dereference_register(), spirv_compiler_emit_dot(), spirv_compiler_emit_ext_glsl_instruction(), spirv_compiler_emit_float_comparison_instruction(), spirv_compiler_emit_ftoi(), spirv_compiler_emit_ftou(), spirv_compiler_emit_gather4(), spirv_compiler_emit_imad(), spirv_compiler_emit_int_div(), spirv_compiler_emit_int_to_bool(), spirv_compiler_emit_load_constant(), spirv_compiler_emit_load_constant64(), spirv_compiler_emit_load_reg(), spirv_compiler_emit_load_undef(), spirv_compiler_emit_mov(), spirv_compiler_emit_movc(), spirv_compiler_emit_rcp(), spirv_compiler_emit_sample(), spirv_compiler_emit_sat(), spirv_compiler_emit_shader_parameter(), spirv_compiler_emit_spec_constant(), spirv_compiler_emit_store(), spirv_compiler_emit_store_dst_components(), spirv_compiler_emit_store_dst_scalar(), spirv_compiler_emit_store_tgsm(), spirv_compiler_emit_store_uav_raw_structured(), spirv_compiler_emit_swapc(), spirv_compiler_emit_swizzle(), spirv_compiler_emit_texel_offset(), spirv_compiler_emit_variable(), spirv_compiler_emit_vector_shuffle(), spirv_compiler_get_buffer_parameter(), spirv_compiler_get_constant(), spirv_compiler_get_constant64(), spirv_compiler_get_constant_double_vector(), spirv_compiler_get_constant_float_vector(), spirv_compiler_get_constant_uint64_vector(), spirv_compiler_get_constant_uint_vector(), spirv_compiler_get_constant_vector(), spirv_compiler_get_spec_constant(), vkd3d_spirv_build_op_type_vector(), vkd3d_spirv_build_op_vector_shuffle(), vkd3d_spirv_get_op_type_vector(), vkd3d_spirv_get_type_id(), and vkd3d_spirv_get_type_id_for_data_type().

◆ environment

◆ 

◆ reg_type

◆ sysval

◆ type

Definition at line 3448 of file spirv.c.

Referenced by vkd3d_symbol_make_io().

◆ vkd3d_output_point_size_builtin

const struct vkd3d_spirv_builtin vkd3d_output_point_size_builtin
static
Initial value:

Definition at line 4879 of file spirv.c.

Referenced by spirv_compiler_emit_output_register(), and spirv_compiler_emit_point_size().

◆ vkd3d_pixel_shader_position_builtin

const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin
static
Initial value:
=
{
}
static uint32_t frag_coord_fixup(struct spirv_compiler *compiler, uint32_t frag_coord_id)
Definition: spirv.c:4809
@ SpvBuiltInFragCoord
Definition: spirv.h:575

Definition at line 4875 of file spirv.c.

Referenced by get_spirv_builtin_for_sysval().

◆ 

const struct { ... } vkd3d_register_builtins[]
Initial value:
=
{
}
@ SpvBuiltInGlobalInvocationId
Definition: spirv.h:587
@ SpvBuiltInLocalInvocationIndex
Definition: spirv.h:588
@ SpvBuiltInLocalInvocationId
Definition: spirv.h:586
@ SpvBuiltInWorkgroupId
Definition: spirv.h:585
@ SpvBuiltInSampleMask
Definition: spirv.h:580
@ SpvBuiltInPointCoord
Definition: spirv.h:576
@ SpvBuiltInInvocationId
Definition: spirv.h:568
@ SpvBuiltInFragStencilRefEXT
Definition: spirv.h:626
@ SpvBuiltInTessCoord
Definition: spirv.h:573

Referenced by get_spirv_builtin_for_register().

◆ vkd3d_shader_parameters

const struct vkd3d_spec_constant_info vkd3d_shader_parameters[]
static
Initial value:
=
{
}
@ VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_REF
Definition: vkd3d_shader.h:575

Referenced by get_spec_constant_info().

◆ vkd3d_spirv_resource_type_table

const struct vkd3d_spirv_resource_type vkd3d_spirv_resource_type_table[]
static
Initial value:
=
{
}
@ SpvDim3D
Definition: spirv.h:227
@ SpvDim2D
Definition: spirv.h:226
@ SpvDim1D
Definition: spirv.h:225
@ SpvDimBuffer
Definition: spirv.h:230
@ SpvCapabilitySampled1D
Definition: spirv.h:911
@ SpvCapabilitySampledBuffer
Definition: spirv.h:914
@ SpvCapabilityImage1D
Definition: spirv.h:912
@ SpvCapabilitySampledCubeArray
Definition: spirv.h:913
@ SpvCapabilityImageBuffer
Definition: spirv.h:915
@ SpvCapabilityImageCubeArray
Definition: spirv.h:902
@ VKD3D_SHADER_RESOURCE_TEXTURE_3D
@ VKD3D_SHADER_RESOURCE_TEXTURE_1DARRAY
@ VKD3D_SHADER_RESOURCE_TEXTURE_CUBE
@ VKD3D_SHADER_RESOURCE_TEXTURE_1D
@ VKD3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY

Referenced by vkd3d_get_spirv_resource_type().

◆ 

const struct { ... } vkd3d_system_value_builtins[]