#include "vkd3d_shader_private.h"
#include "wine/rbtree.h"
#include "d3dcommon.h"
#include "d3dx9shader.h"

Include dependency graph for hlsl.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	hlsl_type

struct	hlsl_semantic

struct	hlsl_struct_field

struct	hlsl_reg

struct	hlsl_ir_node

struct	hlsl_block

struct	hlsl_src

struct	hlsl_attribute

struct	hlsl_reg_reservation

union	hlsl_constant_value_component

struct	hlsl_ir_var

struct	hlsl_ir_var::hlsl_default_value

struct	hlsl_state_block_entry

struct	hlsl_state_block

struct	hlsl_func_parameters

struct	hlsl_ir_function

struct	hlsl_ir_function_decl

struct	hlsl_ir_call

struct	hlsl_ir_if

struct	hlsl_ir_loop

struct	hlsl_ir_switch_case

struct	hlsl_ir_switch

struct	hlsl_ir_expr

struct	hlsl_ir_jump

struct	hlsl_ir_swizzle

struct	hlsl_ir_index

struct	hlsl_deref

struct	hlsl_ir_load

struct	hlsl_ir_resource_load

struct	hlsl_ir_resource_store

struct	hlsl_ir_store

struct	hlsl_ir_constant

struct	hlsl_ir_constant::hlsl_constant_value

struct	hlsl_ir_string_constant

struct	hlsl_ir_compile

struct	hlsl_ir_sampler_state

struct	hlsl_ir_stateblock_constant

struct	hlsl_ir_vsir_instruction_ref

struct	hlsl_scope

struct	hlsl_profile_info

struct	hlsl_vec4

struct	hlsl_buffer

struct	hlsl_ctx

struct	hlsl_ctx::hlsl_constant_defs

struct	hlsl_ctx::hlsl_constant_defs::hlsl_constant_register

struct	hlsl_resource_load_params

Macros
#define	HLSL_SWIZZLE_X (0u)

#define	HLSL_SWIZZLE_Y (1u)

#define	HLSL_SWIZZLE_Z (2u)

#define	HLSL_SWIZZLE_W (3u)

#define	HLSL_SWIZZLE(x, y, z, w)

#define	HLSL_SWIZZLE_MASK (0x3u)

#define	HLSL_SWIZZLE_SHIFT(idx) (2u * (idx))

#define	HLSL_STORAGE_EXTERN 0x00000001

#define	HLSL_STORAGE_NOINTERPOLATION 0x00000002

#define	HLSL_MODIFIER_PRECISE 0x00000004

#define	HLSL_STORAGE_SHARED 0x00000008

#define	HLSL_STORAGE_GROUPSHARED 0x00000010

#define	HLSL_STORAGE_STATIC 0x00000020

#define	HLSL_STORAGE_UNIFORM 0x00000040

#define	HLSL_MODIFIER_VOLATILE 0x00000080

#define	HLSL_MODIFIER_CONST 0x00000100

#define	HLSL_MODIFIER_ROW_MAJOR 0x00000200

#define	HLSL_MODIFIER_COLUMN_MAJOR 0x00000400

#define	HLSL_STORAGE_IN 0x00000800

#define	HLSL_STORAGE_OUT 0x00001000

#define	HLSL_MODIFIER_INLINE 0x00002000

#define	HLSL_STORAGE_CENTROID 0x00004000

#define	HLSL_STORAGE_NOPERSPECTIVE 0x00008000

#define	HLSL_STORAGE_LINEAR 0x00010000

#define	HLSL_MODIFIER_SINGLE 0x00020000

#define	HLSL_MODIFIER_EXPORT 0x00040000

#define	HLSL_STORAGE_ANNOTATION 0x00080000

#define	HLSL_MODIFIER_UNORM 0x00100000

#define	HLSL_MODIFIER_SNORM 0x00200000

#define	HLSL_TYPE_MODIFIERS_MASK

#define	HLSL_INTERPOLATION_MODIFIERS_MASK

#define	HLSL_MODIFIERS_MAJORITY_MASK (HLSL_MODIFIER_ROW_MAJOR \| HLSL_MODIFIER_COLUMN_MAJOR)

#define	HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT 0

#define	HLSL_MAX_OPERANDS 3

Enumerations
enum	hlsl_type_class { HLSL_CLASS_SCALAR , HLSL_CLASS_VECTOR , HLSL_CLASS_MATRIX , HLSL_CLASS_LAST_NUMERIC = HLSL_CLASS_MATRIX , HLSL_CLASS_STRUCT , HLSL_CLASS_ARRAY , HLSL_CLASS_DEPTH_STENCIL_STATE , HLSL_CLASS_DEPTH_STENCIL_VIEW , HLSL_CLASS_EFFECT_GROUP , HLSL_CLASS_PASS , HLSL_CLASS_PIXEL_SHADER , HLSL_CLASS_RASTERIZER_STATE , HLSL_CLASS_RENDER_TARGET_VIEW , HLSL_CLASS_SAMPLER , HLSL_CLASS_STRING , HLSL_CLASS_TECHNIQUE , HLSL_CLASS_TEXTURE , HLSL_CLASS_UAV , HLSL_CLASS_VERTEX_SHADER , HLSL_CLASS_COMPUTE_SHADER , HLSL_CLASS_DOMAIN_SHADER , HLSL_CLASS_HULL_SHADER , HLSL_CLASS_GEOMETRY_SHADER , HLSL_CLASS_CONSTANT_BUFFER , HLSL_CLASS_BLEND_STATE , HLSL_CLASS_VOID , HLSL_CLASS_NULL , HLSL_CLASS_ERROR }

enum	hlsl_base_type { HLSL_TYPE_FLOAT , HLSL_TYPE_HALF , HLSL_TYPE_DOUBLE , HLSL_TYPE_INT , HLSL_TYPE_UINT , HLSL_TYPE_BOOL , HLSL_TYPE_LAST_SCALAR = HLSL_TYPE_BOOL }

enum	hlsl_sampler_dim { HLSL_SAMPLER_DIM_GENERIC = 0 , HLSL_SAMPLER_DIM_COMPARISON , HLSL_SAMPLER_DIM_1D , HLSL_SAMPLER_DIM_2D , HLSL_SAMPLER_DIM_3D , HLSL_SAMPLER_DIM_CUBE , HLSL_SAMPLER_DIM_LAST_SAMPLER = HLSL_SAMPLER_DIM_CUBE , HLSL_SAMPLER_DIM_1DARRAY , HLSL_SAMPLER_DIM_2DARRAY , HLSL_SAMPLER_DIM_2DMS , HLSL_SAMPLER_DIM_2DMSARRAY , HLSL_SAMPLER_DIM_CUBEARRAY , HLSL_SAMPLER_DIM_BUFFER , HLSL_SAMPLER_DIM_STRUCTURED_BUFFER , HLSL_SAMPLER_DIM_RAW_BUFFER , HLSL_SAMPLER_DIM_MAX = HLSL_SAMPLER_DIM_RAW_BUFFER }

enum	hlsl_regset { HLSL_REGSET_SAMPLERS , HLSL_REGSET_TEXTURES , HLSL_REGSET_UAVS , HLSL_REGSET_LAST_OBJECT = HLSL_REGSET_UAVS , HLSL_REGSET_NUMERIC , HLSL_REGSET_LAST = HLSL_REGSET_NUMERIC }

enum	hlsl_ir_node_type { HLSL_IR_CALL , HLSL_IR_CONSTANT , HLSL_IR_EXPR , HLSL_IR_IF , HLSL_IR_INDEX , HLSL_IR_LOAD , HLSL_IR_LOOP , HLSL_IR_JUMP , HLSL_IR_RESOURCE_LOAD , HLSL_IR_RESOURCE_STORE , HLSL_IR_STRING_CONSTANT , HLSL_IR_STORE , HLSL_IR_SWIZZLE , HLSL_IR_SWITCH , HLSL_IR_COMPILE , HLSL_IR_SAMPLER_STATE , HLSL_IR_STATEBLOCK_CONSTANT , HLSL_IR_VSIR_INSTRUCTION_REF }

enum	hlsl_ir_loop_unroll_type { HLSL_IR_LOOP_UNROLL , HLSL_IR_LOOP_FORCE_UNROLL , HLSL_IR_LOOP_FORCE_LOOP }

enum	hlsl_ir_expr_op { HLSL_OP0_ERROR , HLSL_OP0_VOID , HLSL_OP0_RASTERIZER_SAMPLE_COUNT , HLSL_OP1_ABS , HLSL_OP1_BIT_NOT , HLSL_OP1_CAST , HLSL_OP1_CEIL , HLSL_OP1_COS , HLSL_OP1_COS_REDUCED , HLSL_OP1_DSX , HLSL_OP1_DSX_COARSE , HLSL_OP1_DSX_FINE , HLSL_OP1_DSY , HLSL_OP1_DSY_COARSE , HLSL_OP1_DSY_FINE , HLSL_OP1_EXP2 , HLSL_OP1_F16TOF32 , HLSL_OP1_F32TOF16 , HLSL_OP1_FLOOR , HLSL_OP1_FRACT , HLSL_OP1_LOG2 , HLSL_OP1_LOGIC_NOT , HLSL_OP1_NEG , HLSL_OP1_NRM , HLSL_OP1_RCP , HLSL_OP1_REINTERPRET , HLSL_OP1_ROUND , HLSL_OP1_RSQ , HLSL_OP1_SAT , HLSL_OP1_SIGN , HLSL_OP1_SIN , HLSL_OP1_SIN_REDUCED , HLSL_OP1_SQRT , HLSL_OP1_TRUNC , HLSL_OP2_ADD , HLSL_OP2_BIT_AND , HLSL_OP2_BIT_OR , HLSL_OP2_BIT_XOR , HLSL_OP2_CRS , HLSL_OP2_DIV , HLSL_OP2_DOT , HLSL_OP2_EQUAL , HLSL_OP2_GEQUAL , HLSL_OP2_LESS , HLSL_OP2_LOGIC_AND , HLSL_OP2_LOGIC_OR , HLSL_OP2_LSHIFT , HLSL_OP2_MAX , HLSL_OP2_MIN , HLSL_OP2_MOD , HLSL_OP2_MUL , HLSL_OP2_NEQUAL , HLSL_OP2_RSHIFT , HLSL_OP2_SLT , HLSL_OP3_DP2ADD , HLSL_OP3_CMP , HLSL_OP3_TERNARY , HLSL_OP3_MAD }

enum	hlsl_ir_jump_type { HLSL_IR_JUMP_BREAK , HLSL_IR_JUMP_CONTINUE , HLSL_IR_JUMP_DISCARD_NEG , HLSL_IR_JUMP_DISCARD_NZ , HLSL_IR_JUMP_RETURN , HLSL_IR_JUMP_UNRESOLVED_CONTINUE }

enum	hlsl_resource_load_type { HLSL_RESOURCE_LOAD , HLSL_RESOURCE_SAMPLE , HLSL_RESOURCE_SAMPLE_CMP , HLSL_RESOURCE_SAMPLE_CMP_LZ , HLSL_RESOURCE_SAMPLE_LOD , HLSL_RESOURCE_SAMPLE_LOD_BIAS , HLSL_RESOURCE_SAMPLE_GRAD , HLSL_RESOURCE_SAMPLE_PROJ , HLSL_RESOURCE_GATHER_RED , HLSL_RESOURCE_GATHER_GREEN , HLSL_RESOURCE_GATHER_BLUE , HLSL_RESOURCE_GATHER_ALPHA , HLSL_RESOURCE_SAMPLE_INFO , HLSL_RESOURCE_RESINFO }

enum	hlsl_buffer_type { HLSL_BUFFER_CONSTANT , HLSL_BUFFER_TEXTURE }

Functions
static unsigned int	hlsl_swizzle_get_component (uint32_t swizzle, unsigned int idx)

static uint32_t	vsir_swizzle_from_hlsl (uint32_t swizzle)

static bool	hlsl_deref_is_lowered (const struct hlsl_deref *deref)

static bool	hlsl_version_ge (const struct hlsl_ctx *ctx, unsigned int major, unsigned int minor)

static bool	hlsl_version_lt (const struct hlsl_ctx *ctx, unsigned int major, unsigned int minor)

static struct hlsl_ir_call *	hlsl_ir_call (const struct hlsl_ir_node *node)

static struct hlsl_ir_constant *	hlsl_ir_constant (const struct hlsl_ir_node *node)

static struct hlsl_ir_string_constant *	hlsl_ir_string_constant (const struct hlsl_ir_node *node)

static struct hlsl_ir_expr *	hlsl_ir_expr (const struct hlsl_ir_node *node)

static struct hlsl_ir_if *	hlsl_ir_if (const struct hlsl_ir_node *node)

static struct hlsl_ir_jump *	hlsl_ir_jump (const struct hlsl_ir_node *node)

static struct hlsl_ir_load *	hlsl_ir_load (const struct hlsl_ir_node *node)

static struct hlsl_ir_loop *	hlsl_ir_loop (const struct hlsl_ir_node *node)

static struct hlsl_ir_resource_load *	hlsl_ir_resource_load (const struct hlsl_ir_node *node)

static struct hlsl_ir_resource_store *	hlsl_ir_resource_store (const struct hlsl_ir_node *node)

static struct hlsl_ir_store *	hlsl_ir_store (const struct hlsl_ir_node *node)

static struct hlsl_ir_swizzle *	hlsl_ir_swizzle (const struct hlsl_ir_node *node)

static struct hlsl_ir_index *	hlsl_ir_index (const struct hlsl_ir_node *node)

static struct hlsl_ir_switch *	hlsl_ir_switch (const struct hlsl_ir_node *node)

static struct hlsl_ir_compile *	hlsl_ir_compile (const struct hlsl_ir_node *node)

static struct hlsl_ir_sampler_state *	hlsl_ir_sampler_state (const struct hlsl_ir_node *node)

static struct hlsl_ir_stateblock_constant *	hlsl_ir_stateblock_constant (const struct hlsl_ir_node *node)

static struct hlsl_ir_vsir_instruction_ref *	hlsl_ir_vsir_instruction_ref (const struct hlsl_ir_node *node)

static void	hlsl_block_init (struct hlsl_block *block)

static void	hlsl_block_add_instr (struct hlsl_block block, struct hlsl_ir_node instr)

static void	hlsl_block_add_block (struct hlsl_block block, struct hlsl_block add)

static void	hlsl_src_from_node (struct hlsl_src src, struct hlsl_ir_node node)

static void	hlsl_src_remove (struct hlsl_src *src)

static void *	hlsl_alloc (struct hlsl_ctx *ctx, size_t size)

static void *	hlsl_calloc (struct hlsl_ctx *ctx, size_t count, size_t size)

static void *	hlsl_realloc (struct hlsl_ctx ctx, void ptr, size_t size)

static char *	hlsl_strdup (struct hlsl_ctx ctx, const char string)

static bool	hlsl_array_reserve (struct hlsl_ctx ctx, void elements, size_t capacity, size_t element_count, size_t element_size)

static struct vkd3d_string_buffer *	hlsl_get_string_buffer (struct hlsl_ctx *ctx)

static void	hlsl_release_string_buffer (struct hlsl_ctx ctx, struct vkd3d_string_buffer buffer)

static struct hlsl_type *	hlsl_get_scalar_type (const struct hlsl_ctx *ctx, enum hlsl_base_type base_type)

static struct hlsl_type *	hlsl_get_vector_type (const struct hlsl_ctx *ctx, enum hlsl_base_type base_type, unsigned int dimx)

static struct hlsl_type *	hlsl_get_matrix_type (const struct hlsl_ctx *ctx, enum hlsl_base_type base_type, unsigned int dimx, unsigned int dimy)

static struct hlsl_type *	hlsl_get_numeric_type (const struct hlsl_ctx *ctx, enum hlsl_type_class type, enum hlsl_base_type base_type, unsigned int dimx, unsigned int dimy)

static bool	hlsl_is_numeric_type (const struct hlsl_type *type)

static unsigned int	hlsl_sampler_dim_count (enum hlsl_sampler_dim dim)

static bool	hlsl_var_has_buffer_offset_register_reservation (struct hlsl_ctx ctx, const struct hlsl_ir_var var)

char *	hlsl_sprintf_alloc (struct hlsl_ctx ctx, const char fmt,...) VKD3D_PRINTF_FUNC(2

char const char *	debug_hlsl_expr_op (enum hlsl_ir_expr_op op)

const char *	debug_hlsl_type (struct hlsl_ctx ctx, const struct hlsl_type type)

const char *	debug_hlsl_writemask (unsigned int writemask)

const char *	debug_hlsl_swizzle (unsigned int swizzle, unsigned int count)

struct vkd3d_string_buffer *	hlsl_type_to_string (struct hlsl_ctx ctx, const struct hlsl_type type)

struct vkd3d_string_buffer *	hlsl_component_to_string (struct hlsl_ctx ctx, const struct hlsl_ir_var var, unsigned int index)

struct vkd3d_string_buffer *	hlsl_modifiers_to_string (struct hlsl_ctx *ctx, unsigned int modifiers)

const char *	hlsl_node_type_to_string (enum hlsl_ir_node_type type)

struct hlsl_ir_node *	hlsl_add_conditional (struct hlsl_ctx ctx, struct hlsl_block block, struct hlsl_ir_node condition, struct hlsl_ir_node if_true, struct hlsl_ir_node *if_false)

void	hlsl_add_function (struct hlsl_ctx ctx, char name, struct hlsl_ir_function_decl *decl)

bool	hlsl_add_var (struct hlsl_ctx ctx, struct hlsl_ir_var decl, bool local_var)

void	hlsl_block_cleanup (struct hlsl_block *block)

bool	hlsl_clone_block (struct hlsl_ctx ctx, struct hlsl_block dst_block, const struct hlsl_block *src_block)

void	hlsl_dump_function (struct hlsl_ctx ctx, const struct hlsl_ir_function_decl func)

void	hlsl_dump_var_default_values (const struct hlsl_ir_var *var)

bool	hlsl_state_block_add_entry (struct hlsl_state_block state_block, struct hlsl_state_block_entry entry)

bool	hlsl_validate_state_block_entry (struct hlsl_ctx ctx, struct hlsl_state_block_entry entry, const struct vkd3d_shader_location *loc)

struct hlsl_state_block_entry *	clone_stateblock_entry (struct hlsl_ctx ctx, const struct hlsl_state_block_entry src, const char *name, bool lhs_has_index, unsigned int lhs_index, bool single_arg, unsigned int arg_index)

void	hlsl_lower_index_loads (struct hlsl_ctx ctx, struct hlsl_block body)

void	hlsl_run_const_passes (struct hlsl_ctx ctx, struct hlsl_block body)

int	hlsl_emit_bytecode (struct hlsl_ctx ctx, struct hlsl_ir_function_decl entry_func, enum vkd3d_shader_target_type target_type, struct vkd3d_shader_code *out)

int	hlsl_emit_effect_binary (struct hlsl_ctx ctx, struct vkd3d_shader_code out)

bool	hlsl_init_deref_from_index_chain (struct hlsl_ctx ctx, struct hlsl_deref deref, struct hlsl_ir_node *chain)

bool	hlsl_copy_deref (struct hlsl_ctx ctx, struct hlsl_deref deref, const struct hlsl_deref *other)

void	hlsl_cleanup_deref (struct hlsl_deref *deref)

void	hlsl_cleanup_semantic (struct hlsl_semantic *semantic)

bool	hlsl_clone_semantic (struct hlsl_ctx ctx, struct hlsl_semantic dst, const struct hlsl_semantic *src)

void	hlsl_cleanup_ir_switch_cases (struct list *cases)

void	hlsl_free_ir_switch_case (struct hlsl_ir_switch_case *c)

void	hlsl_replace_node (struct hlsl_ir_node old, struct hlsl_ir_node new)

void	hlsl_free_attribute (struct hlsl_attribute *attr)

void	hlsl_free_instr (struct hlsl_ir_node *node)

void	hlsl_free_instr_list (struct list *list)

void	hlsl_free_state_block (struct hlsl_state_block *state_block)

void	hlsl_free_state_block_entry (struct hlsl_state_block_entry *state_block_entry)

void	hlsl_free_type (struct hlsl_type *type)

void	hlsl_free_var (struct hlsl_ir_var *decl)

struct hlsl_ir_function *	hlsl_get_function (struct hlsl_ctx ctx, const char name)

struct hlsl_ir_function_decl *	hlsl_get_first_func_decl (struct hlsl_ctx ctx, const char name)

struct hlsl_ir_function_decl *	hlsl_get_func_decl (struct hlsl_ctx ctx, const char name, const struct hlsl_func_parameters *parameters)

const struct hlsl_profile_info *	hlsl_get_target_info (const char *target)

struct hlsl_type *	hlsl_get_type (struct hlsl_scope scope, const char name, bool recursive, bool case_insensitive)

struct hlsl_ir_var *	hlsl_get_var (struct hlsl_scope scope, const char name)

struct hlsl_type *	hlsl_get_element_type_from_path_index (struct hlsl_ctx ctx, const struct hlsl_type type, struct hlsl_ir_node *idx)

const char *	hlsl_jump_type_to_string (enum hlsl_ir_jump_type type)

struct hlsl_type *	hlsl_new_array_type (struct hlsl_ctx ctx, struct hlsl_type basic_type, unsigned int array_size)

struct hlsl_ir_node *	hlsl_new_binary_expr (struct hlsl_ctx ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node arg1, struct hlsl_ir_node *arg2)

struct hlsl_ir_node *	hlsl_new_bool_constant (struct hlsl_ctx ctx, bool b, const struct vkd3d_shader_location loc)

struct hlsl_buffer *	hlsl_new_buffer (struct hlsl_ctx ctx, enum hlsl_buffer_type type, const char name, uint32_t modifiers, const struct hlsl_reg_reservation reservation, struct hlsl_scope annotations, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_call (struct hlsl_ctx ctx, struct hlsl_ir_function_decl decl, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_cast (struct hlsl_ctx ctx, struct hlsl_ir_node node, struct hlsl_type type, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_constant (struct hlsl_ctx ctx, struct hlsl_type type, const struct hlsl_constant_value value, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_copy (struct hlsl_ctx ctx, struct hlsl_ir_node node)

struct hlsl_ir_node *	hlsl_new_expr (struct hlsl_ctx ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node operands[HLSL_MAX_OPERANDS], struct hlsl_type data_type, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_float_constant (struct hlsl_ctx ctx, float f, const struct vkd3d_shader_location loc)

struct hlsl_ir_function_decl *	hlsl_new_func_decl (struct hlsl_ctx ctx, struct hlsl_type return_type, const struct hlsl_func_parameters parameters, const struct hlsl_semantic semantic, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_if (struct hlsl_ctx ctx, struct hlsl_ir_node condition, struct hlsl_block then_block, struct hlsl_block else_block, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_int_constant (struct hlsl_ctx ctx, int32_t n, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_jump (struct hlsl_ctx ctx, enum hlsl_ir_jump_type type, struct hlsl_ir_node condition, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_ternary_expr (struct hlsl_ctx ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node arg1, struct hlsl_ir_node arg2, struct hlsl_ir_node arg3)

void	hlsl_init_simple_deref_from_var (struct hlsl_deref deref, struct hlsl_ir_var var)

struct hlsl_ir_load *	hlsl_new_var_load (struct hlsl_ctx ctx, struct hlsl_ir_var var, const struct vkd3d_shader_location *loc)

struct hlsl_ir_load *	hlsl_new_load_index (struct hlsl_ctx ctx, const struct hlsl_deref deref, struct hlsl_ir_node idx, const struct vkd3d_shader_location loc)

struct hlsl_ir_load *	hlsl_new_load_parent (struct hlsl_ctx ctx, const struct hlsl_deref deref, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_load_component (struct hlsl_ctx ctx, struct hlsl_block block, const struct hlsl_deref deref, unsigned int comp, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_add_load_component (struct hlsl_ctx ctx, struct hlsl_block block, struct hlsl_ir_node var_instr, unsigned int comp, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_simple_store (struct hlsl_ctx ctx, struct hlsl_ir_var lhs, struct hlsl_ir_node *rhs)

struct hlsl_ir_node *	hlsl_new_store_index (struct hlsl_ctx ctx, const struct hlsl_deref lhs, struct hlsl_ir_node idx, struct hlsl_ir_node rhs, unsigned int writemask, const struct vkd3d_shader_location *loc)

bool	hlsl_new_store_component (struct hlsl_ctx ctx, struct hlsl_block block, const struct hlsl_deref lhs, unsigned int comp, struct hlsl_ir_node rhs)

bool	hlsl_index_is_noncontiguous (struct hlsl_ir_index *index)

bool	hlsl_index_is_resource_access (struct hlsl_ir_index *index)

bool	hlsl_index_chain_has_resource_access (struct hlsl_ir_index *index)

struct hlsl_ir_node *	hlsl_new_compile (struct hlsl_ctx ctx, enum hlsl_compile_type compile_type, const char profile_name, struct hlsl_ir_node *args, unsigned int args_count, struct hlsl_block args_instrs, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_index (struct hlsl_ctx ctx, struct hlsl_ir_node val, struct hlsl_ir_node idx, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_loop (struct hlsl_ctx ctx, struct hlsl_block block, enum hlsl_ir_loop_unroll_type unroll_type, unsigned int unroll_limit, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_resource_load (struct hlsl_ctx ctx, const struct hlsl_resource_load_params params, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_resource_store (struct hlsl_ctx ctx, const struct hlsl_deref resource, struct hlsl_ir_node coords, struct hlsl_ir_node value, const struct vkd3d_shader_location *loc)

struct hlsl_type *	hlsl_new_struct_type (struct hlsl_ctx ctx, const char name, struct hlsl_struct_field *fields, size_t field_count)

struct hlsl_ir_node *	hlsl_new_swizzle (struct hlsl_ctx ctx, uint32_t s, unsigned int components, struct hlsl_ir_node val, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_sampler_state (struct hlsl_ctx ctx, const struct hlsl_state_block state_block, struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_stateblock_constant (struct hlsl_ctx ctx, const char name, struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_string_constant (struct hlsl_ctx ctx, const char str, const struct vkd3d_shader_location *loc)

struct hlsl_ir_var *	hlsl_new_synthetic_var (struct hlsl_ctx ctx, const char template, struct hlsl_type type, const struct vkd3d_shader_location loc)

struct hlsl_ir_var *	hlsl_new_synthetic_var_named (struct hlsl_ctx ctx, const char name, struct hlsl_type type, const struct vkd3d_shader_location loc, bool dummy_scope)

struct hlsl_type *	hlsl_new_texture_type (struct hlsl_ctx ctx, enum hlsl_sampler_dim dim, struct hlsl_type format, unsigned int sample_count)

struct hlsl_type *	hlsl_new_uav_type (struct hlsl_ctx ctx, enum hlsl_sampler_dim dim, struct hlsl_type format, bool rasteriser_ordered)

struct hlsl_type *	hlsl_new_cb_type (struct hlsl_ctx ctx, struct hlsl_type format)

struct hlsl_ir_node *	hlsl_new_uint_constant (struct hlsl_ctx ctx, unsigned int n, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_null_constant (struct hlsl_ctx ctx, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_unary_expr (struct hlsl_ctx ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node arg, const struct vkd3d_shader_location *loc)

struct hlsl_ir_var *	hlsl_new_var (struct hlsl_ctx ctx, const char name, struct hlsl_type type, const struct vkd3d_shader_location loc, const struct hlsl_semantic semantic, uint32_t modifiers, const struct hlsl_reg_reservation reg_reservation)

struct hlsl_ir_switch_case *	hlsl_new_switch_case (struct hlsl_ctx ctx, unsigned int value, bool is_default, struct hlsl_block body, const struct vkd3d_shader_location *loc)

struct hlsl_ir_node *	hlsl_new_switch (struct hlsl_ctx ctx, struct hlsl_ir_node selector, struct list cases, const struct vkd3d_shader_location loc)

struct hlsl_ir_node *	hlsl_new_vsir_instruction_ref (struct hlsl_ctx ctx, unsigned int vsir_instr_idx, struct hlsl_type type, const struct hlsl_reg reg, const struct vkd3d_shader_location loc)

void	hlsl_error (struct hlsl_ctx ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_error error, const char *fmt,...) VKD3D_PRINTF_FUNC(4

void void	hlsl_fixme (struct hlsl_ctx ctx, const struct vkd3d_shader_location loc, const char *fmt,...) VKD3D_PRINTF_FUNC(3

void void void	hlsl_warning (struct hlsl_ctx ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_error error, const char *fmt,...) VKD3D_PRINTF_FUNC(4

void void void void	hlsl_note (struct hlsl_ctx ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_log_level level, const char *fmt,...) VKD3D_PRINTF_FUNC(4

void void void void void	hlsl_push_scope (struct hlsl_ctx *ctx)

void	hlsl_pop_scope (struct hlsl_ctx *ctx)

bool	hlsl_scope_add_type (struct hlsl_scope scope, struct hlsl_type type)

struct hlsl_type *	hlsl_type_clone (struct hlsl_ctx ctx, struct hlsl_type old, unsigned int default_majority, uint32_t modifiers)

unsigned int	hlsl_type_component_count (const struct hlsl_type *type)

unsigned int	hlsl_type_get_array_element_reg_size (const struct hlsl_type *type, enum hlsl_regset regset)

struct hlsl_type *	hlsl_type_get_component_type (struct hlsl_ctx ctx, struct hlsl_type type, unsigned int index)

unsigned int	hlsl_type_get_component_offset (struct hlsl_ctx ctx, struct hlsl_type type, unsigned int index, enum hlsl_regset *regset)

bool	hlsl_type_is_row_major (const struct hlsl_type *type)

unsigned int	hlsl_type_minor_size (const struct hlsl_type *type)

unsigned int	hlsl_type_major_size (const struct hlsl_type *type)

unsigned int	hlsl_type_element_count (const struct hlsl_type *type)

bool	hlsl_type_is_resource (const struct hlsl_type *type)

bool	hlsl_type_is_shader (const struct hlsl_type *type)

unsigned int	hlsl_type_get_sm4_offset (const struct hlsl_type *type, unsigned int offset)

bool	hlsl_types_are_equal (const struct hlsl_type t1, const struct hlsl_type t2)

void	hlsl_calculate_buffer_offsets (struct hlsl_ctx *ctx)

const struct hlsl_type *	hlsl_get_multiarray_element_type (const struct hlsl_type *type)

unsigned int	hlsl_get_multiarray_size (const struct hlsl_type *type)

uint32_t	hlsl_combine_swizzles (uint32_t first, uint32_t second, unsigned int dim)

unsigned int	hlsl_combine_writemasks (unsigned int first, unsigned int second)

uint32_t	hlsl_map_swizzle (uint32_t swizzle, unsigned int writemask)

uint32_t	hlsl_swizzle_from_writemask (unsigned int writemask)

struct hlsl_type *	hlsl_deref_get_type (struct hlsl_ctx ctx, const struct hlsl_deref deref)

enum hlsl_regset	hlsl_deref_get_regset (struct hlsl_ctx ctx, const struct hlsl_deref deref)

bool	hlsl_component_index_range_from_deref (struct hlsl_ctx ctx, const struct hlsl_deref deref, unsigned int start, unsigned int count)

bool	hlsl_regset_index_from_deref (struct hlsl_ctx ctx, const struct hlsl_deref deref, enum hlsl_regset regset, unsigned int *index)

bool	hlsl_offset_from_deref (struct hlsl_ctx ctx, const struct hlsl_deref deref, unsigned int *offset)

unsigned int	hlsl_offset_from_deref_safe (struct hlsl_ctx ctx, const struct hlsl_deref deref)

struct hlsl_reg	hlsl_reg_from_deref (struct hlsl_ctx ctx, const struct hlsl_deref deref)

bool	hlsl_copy_propagation_execute (struct hlsl_ctx ctx, struct hlsl_block block)

bool	hlsl_fold_constant_exprs (struct hlsl_ctx ctx, struct hlsl_ir_node instr, void *context)

bool	hlsl_fold_constant_identities (struct hlsl_ctx ctx, struct hlsl_ir_node instr, void *context)

bool	hlsl_fold_constant_swizzles (struct hlsl_ctx ctx, struct hlsl_ir_node instr, void *context)

bool	hlsl_transform_ir (struct hlsl_ctx ctx, bool(func)(struct hlsl_ctx ctx, struct hlsl_ir_node , void ), struct hlsl_block block, void *context)

D3DXPARAMETER_CLASS	hlsl_sm1_class (const struct hlsl_type *type)

D3DXPARAMETER_TYPE	hlsl_sm1_base_type (const struct hlsl_type *type)

void	write_sm1_uniforms (struct hlsl_ctx ctx, struct vkd3d_bytecode_buffer buffer)

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

int	tpf_compile (struct vsir_program program, uint64_t config_flags, struct vkd3d_shader_code out, struct vkd3d_shader_message_context message_context, struct hlsl_ctx ctx, struct hlsl_ir_function_decl *entry_func)

enum vkd3d_shader_interpolation_mode	sm4_get_interpolation_mode (struct hlsl_type *type, unsigned int storage_modifiers)

struct hlsl_ir_function_decl *	hlsl_compile_internal_function (struct hlsl_ctx ctx, const char name, const char *hlsl)

int	hlsl_lexer_compile (struct hlsl_ctx ctx, const struct vkd3d_shader_code hlsl)

Macro Definition Documentation

◆ HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT

#define HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT 0

Definition at line 429 of file hlsl.h.

◆ HLSL_INTERPOLATION_MODIFIERS_MASK

#define HLSL_INTERPOLATION_MODIFIERS_MASK

Value:

(HLSL_STORAGE_NOINTERPOLATION | HLSL_STORAGE_CENTROID | \

HLSL_STORAGE_NOPERSPECTIVE | HLSL_STORAGE_LINEAR)

HLSL_STORAGE_CENTROID

#define HLSL_STORAGE_CENTROID

Definition: hlsl.h:411

HLSL_STORAGE_LINEAR

#define HLSL_STORAGE_LINEAR

Definition: hlsl.h:413

HLSL_STORAGE_NOINTERPOLATION

#define HLSL_STORAGE_NOINTERPOLATION

Definition: hlsl.h:398

HLSL_STORAGE_NOPERSPECTIVE

#define HLSL_STORAGE_NOPERSPECTIVE

Definition: hlsl.h:412

Definition at line 424 of file hlsl.h.

◆ HLSL_MAX_OPERANDS

#define HLSL_MAX_OPERANDS 3

Definition at line 750 of file hlsl.h.

◆ HLSL_MODIFIER_COLUMN_MAJOR

#define HLSL_MODIFIER_COLUMN_MAJOR 0x00000400

Definition at line 407 of file hlsl.h.

◆ HLSL_MODIFIER_CONST

#define HLSL_MODIFIER_CONST 0x00000100

Definition at line 405 of file hlsl.h.

◆ HLSL_MODIFIER_EXPORT

#define HLSL_MODIFIER_EXPORT 0x00040000

Definition at line 415 of file hlsl.h.

◆ HLSL_MODIFIER_INLINE

#define HLSL_MODIFIER_INLINE 0x00002000

Definition at line 410 of file hlsl.h.

◆ HLSL_MODIFIER_PRECISE

#define HLSL_MODIFIER_PRECISE 0x00000004

Definition at line 399 of file hlsl.h.

◆ HLSL_MODIFIER_ROW_MAJOR

#define HLSL_MODIFIER_ROW_MAJOR 0x00000200

Definition at line 406 of file hlsl.h.

◆ HLSL_MODIFIER_SINGLE

#define HLSL_MODIFIER_SINGLE 0x00020000

Definition at line 414 of file hlsl.h.

◆ HLSL_MODIFIER_SNORM

#define HLSL_MODIFIER_SNORM 0x00200000

Definition at line 418 of file hlsl.h.

◆ HLSL_MODIFIER_UNORM

#define HLSL_MODIFIER_UNORM 0x00100000

Definition at line 417 of file hlsl.h.

◆ HLSL_MODIFIER_VOLATILE

#define HLSL_MODIFIER_VOLATILE 0x00000080

Definition at line 404 of file hlsl.h.

◆ HLSL_MODIFIERS_MAJORITY_MASK

#define HLSL_MODIFIERS_MAJORITY_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)

Definition at line 427 of file hlsl.h.

◆ HLSL_STORAGE_ANNOTATION

#define HLSL_STORAGE_ANNOTATION 0x00080000

Definition at line 416 of file hlsl.h.

◆ HLSL_STORAGE_CENTROID

#define HLSL_STORAGE_CENTROID 0x00004000

Definition at line 411 of file hlsl.h.

◆ HLSL_STORAGE_EXTERN

#define HLSL_STORAGE_EXTERN 0x00000001

Definition at line 397 of file hlsl.h.

◆ HLSL_STORAGE_GROUPSHARED

#define HLSL_STORAGE_GROUPSHARED 0x00000010

Definition at line 401 of file hlsl.h.

◆ HLSL_STORAGE_IN

#define HLSL_STORAGE_IN 0x00000800

Definition at line 408 of file hlsl.h.

◆ HLSL_STORAGE_LINEAR

#define HLSL_STORAGE_LINEAR 0x00010000

Definition at line 413 of file hlsl.h.

◆ HLSL_STORAGE_NOINTERPOLATION

#define HLSL_STORAGE_NOINTERPOLATION 0x00000002

Definition at line 398 of file hlsl.h.

◆ HLSL_STORAGE_NOPERSPECTIVE

#define HLSL_STORAGE_NOPERSPECTIVE 0x00008000

Definition at line 412 of file hlsl.h.

◆ HLSL_STORAGE_OUT

#define HLSL_STORAGE_OUT 0x00001000

Definition at line 409 of file hlsl.h.

◆ HLSL_STORAGE_SHARED

#define HLSL_STORAGE_SHARED 0x00000008

Definition at line 400 of file hlsl.h.

◆ HLSL_STORAGE_STATIC

#define HLSL_STORAGE_STATIC 0x00000020

Definition at line 402 of file hlsl.h.

◆ HLSL_STORAGE_UNIFORM

#define HLSL_STORAGE_UNIFORM 0x00000040

Definition at line 403 of file hlsl.h.

◆ HLSL_SWIZZLE

#define HLSL_SWIZZLE	(	x,
		y,
		z,
		w
	)

Value:

        (((HLSL_SWIZZLE_ ## x) << 0) \
        | ((HLSL_SWIZZLE_ ## y) << 2) \
        | ((HLSL_SWIZZLE_ ## z) << 4) \
        | ((HLSL_SWIZZLE_ ## w) << 6))

Definition at line 59 of file hlsl.h.

◆ HLSL_SWIZZLE_MASK

#define HLSL_SWIZZLE_MASK (0x3u)

Definition at line 65 of file hlsl.h.

◆ HLSL_SWIZZLE_SHIFT

#define HLSL_SWIZZLE_SHIFT ( idx ) (2u * (idx))

Definition at line 66 of file hlsl.h.

◆ HLSL_SWIZZLE_W

#define HLSL_SWIZZLE_W (3u)

Definition at line 57 of file hlsl.h.

◆ HLSL_SWIZZLE_X

#define HLSL_SWIZZLE_X (0u)

Definition at line 54 of file hlsl.h.

◆ HLSL_SWIZZLE_Y

#define HLSL_SWIZZLE_Y (1u)

Definition at line 55 of file hlsl.h.

◆ HLSL_SWIZZLE_Z

#define HLSL_SWIZZLE_Z (2u)

Definition at line 56 of file hlsl.h.

◆ HLSL_TYPE_MODIFIERS_MASK

#define HLSL_TYPE_MODIFIERS_MASK

Value:

                                      (HLSL_MODIFIER_PRECISE | HLSL_MODIFIER_VOLATILE | \
                                      HLSL_MODIFIER_CONST | HLSL_MODIFIER_ROW_MAJOR | \
                                      HLSL_MODIFIER_COLUMN_MAJOR | HLSL_MODIFIER_UNORM | HLSL_MODIFIER_SNORM)

Definition at line 420 of file hlsl.h.

Enumeration Type Documentation

◆ hlsl_base_type

enum hlsl_base_type

Enumerator
HLSL_TYPE_FLOAT
HLSL_TYPE_HALF
HLSL_TYPE_DOUBLE
HLSL_TYPE_INT
HLSL_TYPE_UINT
HLSL_TYPE_BOOL
HLSL_TYPE_LAST_SCALAR

Definition at line 113 of file hlsl.h.

{
    HLSL_TYPE_FLOAT,
    HLSL_TYPE_HALF,
    HLSL_TYPE_DOUBLE,
    HLSL_TYPE_INT,
    HLSL_TYPE_UINT,
    HLSL_TYPE_BOOL,
    HLSL_TYPE_LAST_SCALAR = HLSL_TYPE_BOOL,
};

◆ hlsl_buffer_type

enum hlsl_buffer_type

Enumerator
HLSL_BUFFER_CONSTANT
HLSL_BUFFER_TEXTURE

Definition at line 983 of file hlsl.h.

{
    HLSL_BUFFER_CONSTANT,
    HLSL_BUFFER_TEXTURE,
};

◆ hlsl_ir_expr_op

enum hlsl_ir_expr_op

Enumerator
HLSL_OP0_ERROR
HLSL_OP0_VOID
HLSL_OP0_RASTERIZER_SAMPLE_COUNT
HLSL_OP1_ABS
HLSL_OP1_BIT_NOT
HLSL_OP1_CAST
HLSL_OP1_CEIL
HLSL_OP1_COS
HLSL_OP1_COS_REDUCED
HLSL_OP1_DSX
HLSL_OP1_DSX_COARSE
HLSL_OP1_DSX_FINE
HLSL_OP1_DSY
HLSL_OP1_DSY_COARSE
HLSL_OP1_DSY_FINE
HLSL_OP1_EXP2
HLSL_OP1_F16TOF32
HLSL_OP1_F32TOF16
HLSL_OP1_FLOOR
HLSL_OP1_FRACT
HLSL_OP1_LOG2
HLSL_OP1_LOGIC_NOT
HLSL_OP1_NEG
HLSL_OP1_NRM
HLSL_OP1_RCP
HLSL_OP1_REINTERPRET
HLSL_OP1_ROUND
HLSL_OP1_RSQ
HLSL_OP1_SAT
HLSL_OP1_SIGN
HLSL_OP1_SIN
HLSL_OP1_SIN_REDUCED
HLSL_OP1_SQRT
HLSL_OP1_TRUNC
HLSL_OP2_ADD
HLSL_OP2_BIT_AND
HLSL_OP2_BIT_OR
HLSL_OP2_BIT_XOR
HLSL_OP2_CRS
HLSL_OP2_DIV
HLSL_OP2_DOT
HLSL_OP2_EQUAL
HLSL_OP2_GEQUAL
HLSL_OP2_LESS
HLSL_OP2_LOGIC_AND
HLSL_OP2_LOGIC_OR
HLSL_OP2_LSHIFT
HLSL_OP2_MAX
HLSL_OP2_MIN
HLSL_OP2_MOD
HLSL_OP2_MUL
HLSL_OP2_NEQUAL
HLSL_OP2_RSHIFT
HLSL_OP2_SLT
HLSL_OP3_DP2ADD
HLSL_OP3_CMP
HLSL_OP3_TERNARY
HLSL_OP3_MAD

Definition at line 680 of file hlsl.h.

{
    HLSL_OP0_ERROR,
    HLSL_OP0_VOID,
    HLSL_OP0_RASTERIZER_SAMPLE_COUNT,
 
    HLSL_OP1_ABS,
    HLSL_OP1_BIT_NOT,
    HLSL_OP1_CAST,
    HLSL_OP1_CEIL,
    HLSL_OP1_COS,
    HLSL_OP1_COS_REDUCED,    /* Reduced range [-pi, pi], writes to .x */
    HLSL_OP1_DSX,
    HLSL_OP1_DSX_COARSE,
    HLSL_OP1_DSX_FINE,
    HLSL_OP1_DSY,
    HLSL_OP1_DSY_COARSE,
    HLSL_OP1_DSY_FINE,
    HLSL_OP1_EXP2,
    HLSL_OP1_F16TOF32,
    HLSL_OP1_F32TOF16,
    HLSL_OP1_FLOOR,
    HLSL_OP1_FRACT,
    HLSL_OP1_LOG2,
    HLSL_OP1_LOGIC_NOT,
    HLSL_OP1_NEG,
    HLSL_OP1_NRM,
    HLSL_OP1_RCP,
    HLSL_OP1_REINTERPRET,
    HLSL_OP1_ROUND,
    HLSL_OP1_RSQ,
    HLSL_OP1_SAT,
    HLSL_OP1_SIGN,
    HLSL_OP1_SIN,
    HLSL_OP1_SIN_REDUCED,    /* Reduced range [-pi, pi], writes to .y */
    HLSL_OP1_SQRT,
    HLSL_OP1_TRUNC,
 
    HLSL_OP2_ADD,
    HLSL_OP2_BIT_AND,
    HLSL_OP2_BIT_OR,
    HLSL_OP2_BIT_XOR,
    HLSL_OP2_CRS,
    HLSL_OP2_DIV,
    HLSL_OP2_DOT,
    HLSL_OP2_EQUAL,
    HLSL_OP2_GEQUAL,
    HLSL_OP2_LESS,
    HLSL_OP2_LOGIC_AND,
    HLSL_OP2_LOGIC_OR,
    HLSL_OP2_LSHIFT,
    HLSL_OP2_MAX,
    HLSL_OP2_MIN,
    HLSL_OP2_MOD,
    HLSL_OP2_MUL,
    HLSL_OP2_NEQUAL,
    HLSL_OP2_RSHIFT,
    /* SLT(a, b) retrieves 1.0 if (a < b), else 0.0. Only used for SM1-SM3 target vertex shaders. */
    HLSL_OP2_SLT,
 
    /* DP2ADD(a, b, c) computes the scalar product of a.xy and b.xy,
     * then adds c, where c must have dimx=1. */
    HLSL_OP3_DP2ADD,
    /* TERNARY(a, b, c) returns 'b' if 'a' is true and 'c' otherwise. 'a' must always be boolean.
     * CMP(a, b, c) returns 'b' if 'a' >= 0, and 'c' otherwise. It's used only for SM1-SM3 targets. */
    HLSL_OP3_CMP,
    HLSL_OP3_TERNARY,
    HLSL_OP3_MAD,
};

◆ hlsl_ir_jump_type

enum hlsl_ir_jump_type

Enumerator
HLSL_IR_JUMP_BREAK
HLSL_IR_JUMP_CONTINUE
HLSL_IR_JUMP_DISCARD_NEG
HLSL_IR_JUMP_DISCARD_NZ
HLSL_IR_JUMP_RETURN
HLSL_IR_JUMP_UNRESOLVED_CONTINUE

Definition at line 759 of file hlsl.h.

{
    HLSL_IR_JUMP_BREAK,
    HLSL_IR_JUMP_CONTINUE,
    HLSL_IR_JUMP_DISCARD_NEG,
    HLSL_IR_JUMP_DISCARD_NZ,
    HLSL_IR_JUMP_RETURN,
    /* UNRESOLVED_CONTINUE type is used by the parser when 'continue' statement is found,
       it never reaches code generation, and is resolved to CONTINUE type once iteration
       and loop exit logic was properly applied. */
    HLSL_IR_JUMP_UNRESOLVED_CONTINUE,
};

◆ hlsl_ir_loop_unroll_type

enum hlsl_ir_loop_unroll_type

Enumerator
HLSL_IR_LOOP_UNROLL
HLSL_IR_LOOP_FORCE_UNROLL
HLSL_IR_LOOP_FORCE_LOOP

Definition at line 647 of file hlsl.h.

{
    HLSL_IR_LOOP_UNROLL,
    HLSL_IR_LOOP_FORCE_UNROLL,
    HLSL_IR_LOOP_FORCE_LOOP
};

◆ hlsl_ir_node_type

enum hlsl_ir_node_type

Enumerator
HLSL_IR_CALL
HLSL_IR_CONSTANT
HLSL_IR_EXPR
HLSL_IR_IF
HLSL_IR_INDEX
HLSL_IR_LOAD
HLSL_IR_LOOP
HLSL_IR_JUMP
HLSL_IR_RESOURCE_LOAD
HLSL_IR_RESOURCE_STORE
HLSL_IR_STRING_CONSTANT
HLSL_IR_STORE
HLSL_IR_SWIZZLE
HLSL_IR_SWITCH
HLSL_IR_COMPILE
HLSL_IR_SAMPLER_STATE
HLSL_IR_STATEBLOCK_CONSTANT
HLSL_IR_VSIR_INSTRUCTION_REF

Definition at line 313 of file hlsl.h.

{
    HLSL_IR_CALL,
    HLSL_IR_CONSTANT,
    HLSL_IR_EXPR,
    HLSL_IR_IF,
    HLSL_IR_INDEX,
    HLSL_IR_LOAD,
    HLSL_IR_LOOP,
    HLSL_IR_JUMP,
    HLSL_IR_RESOURCE_LOAD,
    HLSL_IR_RESOURCE_STORE,
    HLSL_IR_STRING_CONSTANT,
    HLSL_IR_STORE,
    HLSL_IR_SWIZZLE,
    HLSL_IR_SWITCH,
 
    HLSL_IR_COMPILE,
    HLSL_IR_SAMPLER_STATE,
    HLSL_IR_STATEBLOCK_CONSTANT,
 
    HLSL_IR_VSIR_INSTRUCTION_REF,
};

◆ hlsl_regset

enum hlsl_regset

Enumerator
HLSL_REGSET_SAMPLERS
HLSL_REGSET_TEXTURES
HLSL_REGSET_UAVS
HLSL_REGSET_LAST_OBJECT
HLSL_REGSET_NUMERIC
HLSL_REGSET_LAST

Definition at line 145 of file hlsl.h.

{
    HLSL_REGSET_SAMPLERS,
    HLSL_REGSET_TEXTURES,
    HLSL_REGSET_UAVS,
    HLSL_REGSET_LAST_OBJECT = HLSL_REGSET_UAVS,
    HLSL_REGSET_NUMERIC,
    HLSL_REGSET_LAST = HLSL_REGSET_NUMERIC,
};

◆ hlsl_resource_load_type

enum hlsl_resource_load_type

Enumerator
HLSL_RESOURCE_LOAD
HLSL_RESOURCE_SAMPLE
HLSL_RESOURCE_SAMPLE_CMP
HLSL_RESOURCE_SAMPLE_CMP_LZ
HLSL_RESOURCE_SAMPLE_LOD
HLSL_RESOURCE_SAMPLE_LOD_BIAS
HLSL_RESOURCE_SAMPLE_GRAD
HLSL_RESOURCE_SAMPLE_PROJ
HLSL_RESOURCE_GATHER_RED
HLSL_RESOURCE_GATHER_GREEN
HLSL_RESOURCE_GATHER_BLUE
HLSL_RESOURCE_GATHER_ALPHA
HLSL_RESOURCE_SAMPLE_INFO
HLSL_RESOURCE_RESINFO

Definition at line 833 of file hlsl.h.

{
    HLSL_RESOURCE_LOAD,
    HLSL_RESOURCE_SAMPLE,
    HLSL_RESOURCE_SAMPLE_CMP,
    HLSL_RESOURCE_SAMPLE_CMP_LZ,
    HLSL_RESOURCE_SAMPLE_LOD,
    HLSL_RESOURCE_SAMPLE_LOD_BIAS,
    HLSL_RESOURCE_SAMPLE_GRAD,
    HLSL_RESOURCE_SAMPLE_PROJ,
    HLSL_RESOURCE_GATHER_RED,
    HLSL_RESOURCE_GATHER_GREEN,
    HLSL_RESOURCE_GATHER_BLUE,
    HLSL_RESOURCE_GATHER_ALPHA,
    HLSL_RESOURCE_SAMPLE_INFO,
    HLSL_RESOURCE_RESINFO,
};

◆ hlsl_sampler_dim

enum hlsl_sampler_dim

Enumerator
HLSL_SAMPLER_DIM_GENERIC
HLSL_SAMPLER_DIM_COMPARISON
HLSL_SAMPLER_DIM_1D
HLSL_SAMPLER_DIM_2D
HLSL_SAMPLER_DIM_3D
HLSL_SAMPLER_DIM_CUBE
HLSL_SAMPLER_DIM_LAST_SAMPLER
HLSL_SAMPLER_DIM_1DARRAY
HLSL_SAMPLER_DIM_2DARRAY
HLSL_SAMPLER_DIM_2DMS
HLSL_SAMPLER_DIM_2DMSARRAY
HLSL_SAMPLER_DIM_CUBEARRAY
HLSL_SAMPLER_DIM_BUFFER
HLSL_SAMPLER_DIM_STRUCTURED_BUFFER
HLSL_SAMPLER_DIM_RAW_BUFFER
HLSL_SAMPLER_DIM_MAX

Definition at line 124 of file hlsl.h.

{
    HLSL_SAMPLER_DIM_GENERIC = 0,
    HLSL_SAMPLER_DIM_COMPARISON,
    HLSL_SAMPLER_DIM_1D,
    HLSL_SAMPLER_DIM_2D,
    HLSL_SAMPLER_DIM_3D,
    HLSL_SAMPLER_DIM_CUBE,
    HLSL_SAMPLER_DIM_LAST_SAMPLER = HLSL_SAMPLER_DIM_CUBE,
    HLSL_SAMPLER_DIM_1DARRAY,
    HLSL_SAMPLER_DIM_2DARRAY,
    HLSL_SAMPLER_DIM_2DMS,
    HLSL_SAMPLER_DIM_2DMSARRAY,
    HLSL_SAMPLER_DIM_CUBEARRAY,
    HLSL_SAMPLER_DIM_BUFFER,
    HLSL_SAMPLER_DIM_STRUCTURED_BUFFER,
    HLSL_SAMPLER_DIM_RAW_BUFFER,
    HLSL_SAMPLER_DIM_MAX = HLSL_SAMPLER_DIM_RAW_BUFFER,
    /* NOTE: Remember to update object_methods[] in hlsl.y if this enum is modified. */
};

◆ hlsl_type_class

enum hlsl_type_class

Enumerator
HLSL_CLASS_SCALAR
HLSL_CLASS_VECTOR
HLSL_CLASS_MATRIX
HLSL_CLASS_LAST_NUMERIC
HLSL_CLASS_STRUCT
HLSL_CLASS_ARRAY
HLSL_CLASS_DEPTH_STENCIL_STATE
HLSL_CLASS_DEPTH_STENCIL_VIEW
HLSL_CLASS_EFFECT_GROUP
HLSL_CLASS_PASS
HLSL_CLASS_PIXEL_SHADER
HLSL_CLASS_RASTERIZER_STATE
HLSL_CLASS_RENDER_TARGET_VIEW
HLSL_CLASS_SAMPLER
HLSL_CLASS_STRING
HLSL_CLASS_TECHNIQUE
HLSL_CLASS_TEXTURE
HLSL_CLASS_UAV
HLSL_CLASS_VERTEX_SHADER
HLSL_CLASS_COMPUTE_SHADER
HLSL_CLASS_DOMAIN_SHADER
HLSL_CLASS_HULL_SHADER
HLSL_CLASS_GEOMETRY_SHADER
HLSL_CLASS_CONSTANT_BUFFER
HLSL_CLASS_BLEND_STATE
HLSL_CLASS_VOID
HLSL_CLASS_NULL
HLSL_CLASS_ERROR

Definition at line 81 of file hlsl.h.

{
    HLSL_CLASS_SCALAR,
    HLSL_CLASS_VECTOR,
    HLSL_CLASS_MATRIX,
    HLSL_CLASS_LAST_NUMERIC = HLSL_CLASS_MATRIX,
    HLSL_CLASS_STRUCT,
    HLSL_CLASS_ARRAY,
    HLSL_CLASS_DEPTH_STENCIL_STATE,
    HLSL_CLASS_DEPTH_STENCIL_VIEW,
    HLSL_CLASS_EFFECT_GROUP,
    HLSL_CLASS_PASS,
    HLSL_CLASS_PIXEL_SHADER,
    HLSL_CLASS_RASTERIZER_STATE,
    HLSL_CLASS_RENDER_TARGET_VIEW,
    HLSL_CLASS_SAMPLER,
    HLSL_CLASS_STRING,
    HLSL_CLASS_TECHNIQUE,
    HLSL_CLASS_TEXTURE,
    HLSL_CLASS_UAV,
    HLSL_CLASS_VERTEX_SHADER,
    HLSL_CLASS_COMPUTE_SHADER,
    HLSL_CLASS_DOMAIN_SHADER,
    HLSL_CLASS_HULL_SHADER,
    HLSL_CLASS_GEOMETRY_SHADER,
    HLSL_CLASS_CONSTANT_BUFFER,
    HLSL_CLASS_BLEND_STATE,
    HLSL_CLASS_VOID,
    HLSL_CLASS_NULL,
    HLSL_CLASS_ERROR,
};

Function Documentation

◆ clone_stateblock_entry()

struct hlsl_state_block_entry * clone_stateblock_entry	(	struct hlsl_ctx *	ctx,
		const struct hlsl_state_block_entry *	src,
		const char *	name,
		bool	lhs_has_index,
		unsigned int	lhs_index,
		bool	single_arg,
		unsigned int	arg_index
	)

Definition at line 2379 of file hlsl.c.

{
    struct hlsl_state_block_entry *entry;
    struct clone_instr_map map = { 0 };
 
    if (!(entry = hlsl_alloc(ctx, sizeof(*entry))))
        return NULL;
    entry->name = hlsl_strdup(ctx, name);
    entry->lhs_has_index = lhs_has_index;
    entry->lhs_index = lhs_index;
    if (!(entry->instrs = hlsl_alloc(ctx, sizeof(*entry->instrs))))
    {
        hlsl_free_state_block_entry(entry);
        return NULL;
    }
 
    if (single_arg)
        entry->args_count = 1;
    else
        entry->args_count = src->args_count;
 
    if (!(entry->args = hlsl_alloc(ctx, sizeof(*entry->args) * entry->args_count)))
    {
        hlsl_free_state_block_entry(entry);
        return NULL;
    }
 
    hlsl_block_init(entry->instrs);
    if (!clone_block(ctx, entry->instrs, src->instrs, &map))
    {
        hlsl_free_state_block_entry(entry);
        return NULL;
    }
 
    if (single_arg)
    {
        clone_src(&map, entry->args, &src->args[arg_index]);
    }
    else
    {
        for (unsigned int i = 0; i < src->args_count; ++i)
            clone_src(&map, &entry->args[i], &src->args[i]);
    }
    vkd3d_free(map.instrs);
 
    return entry;
}

Referenced by decompose_fx_4_state_block_expand_array(), decompose_fx_4_state_function_call(), and hlsl_new_sampler_state().

◆ d3dbc_compile()

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

Definition at line 2359 of file d3dbc.c.

{
    const struct vkd3d_shader_version *version = &program->shader_version;
    struct d3dbc_compiler d3dbc = {0};
    struct vkd3d_bytecode_buffer *buffer = &d3dbc.buffer;
    int result;
 
    d3dbc.program = program;
    d3dbc.message_context = message_context;
    switch (version->type)
    {
        case VKD3D_SHADER_TYPE_VERTEX:
            d3dbc.opcode_table = vs_opcode_table;
            break;
 
        case VKD3D_SHADER_TYPE_PIXEL:
            d3dbc.opcode_table = ps_opcode_table;
            break;
 
        default:
            vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_D3DBC_INVALID_PROFILE,
                    "Invalid shader type %u.", version->type);
            return VKD3D_ERROR_INVALID_SHADER;
    }
 
    put_u32(buffer, sm1_version(version->type, version->major, version->minor));
 
    bytecode_put_bytes(buffer, ctab->code, ctab->size);
 
    d3dbc_write_semantic_dcls(&d3dbc);
    d3dbc_write_program_instructions(&d3dbc);
 
    put_u32(buffer, VKD3D_SM1_OP_END);
 
    result = VKD3D_OK;
    if (buffer->status)
        result = buffer->status;
    if (d3dbc.failed)
        result = VKD3D_ERROR_INVALID_SHADER;
 
    if (!result)
    {
        out->code = buffer->data;
        out->size = buffer->size;
    }
    else
    {
        vkd3d_free(buffer->data);
    }
    return result;
}

Referenced by hlsl_emit_bytecode().

◆ debug_hlsl_expr_op()

char const char * debug_hlsl_expr_op ( enum hlsl_ir_expr_op op )

Definition at line 3176 of file hlsl.c.

{
    static const char *const op_names[] =
    {
        [HLSL_OP0_ERROR]        = "error",
        [HLSL_OP0_VOID]         = "void",
        [HLSL_OP0_RASTERIZER_SAMPLE_COUNT] = "GetRenderTargetSampleCount",
 
        [HLSL_OP1_ABS]          = "abs",
        [HLSL_OP1_BIT_NOT]      = "~",
        [HLSL_OP1_CAST]         = "cast",
        [HLSL_OP1_CEIL]         = "ceil",
        [HLSL_OP1_COS]          = "cos",
        [HLSL_OP1_COS_REDUCED]  = "cos_reduced",
        [HLSL_OP1_DSX]          = "dsx",
        [HLSL_OP1_DSX_COARSE]   = "dsx_coarse",
        [HLSL_OP1_DSX_FINE]     = "dsx_fine",
        [HLSL_OP1_DSY]          = "dsy",
        [HLSL_OP1_DSY_COARSE]   = "dsy_coarse",
        [HLSL_OP1_DSY_FINE]     = "dsy_fine",
        [HLSL_OP1_EXP2]         = "exp2",
        [HLSL_OP1_F16TOF32]     = "f16tof32",
        [HLSL_OP1_F32TOF16]     = "f32tof16",
        [HLSL_OP1_FLOOR]        = "floor",
        [HLSL_OP1_FRACT]        = "fract",
        [HLSL_OP1_LOG2]         = "log2",
        [HLSL_OP1_LOGIC_NOT]    = "!",
        [HLSL_OP1_NEG]          = "-",
        [HLSL_OP1_NRM]          = "nrm",
        [HLSL_OP1_RCP]          = "rcp",
        [HLSL_OP1_REINTERPRET]  = "reinterpret",
        [HLSL_OP1_ROUND]        = "round",
        [HLSL_OP1_RSQ]          = "rsq",
        [HLSL_OP1_SAT]          = "sat",
        [HLSL_OP1_SIGN]         = "sign",
        [HLSL_OP1_SIN]          = "sin",
        [HLSL_OP1_SIN_REDUCED]  = "sin_reduced",
        [HLSL_OP1_SQRT]         = "sqrt",
        [HLSL_OP1_TRUNC]        = "trunc",
 
        [HLSL_OP2_ADD]         = "+",
        [HLSL_OP2_BIT_AND]     = "&",
        [HLSL_OP2_BIT_OR]      = "|",
        [HLSL_OP2_BIT_XOR]     = "^",
        [HLSL_OP2_CRS]         = "crs",
        [HLSL_OP2_DIV]         = "/",
        [HLSL_OP2_DOT]         = "dot",
        [HLSL_OP2_EQUAL]       = "==",
        [HLSL_OP2_GEQUAL]      = ">=",
        [HLSL_OP2_LESS]        = "<",
        [HLSL_OP2_LOGIC_AND]   = "&&",
        [HLSL_OP2_LOGIC_OR]    = "||",
        [HLSL_OP2_LSHIFT]      = "<<",
        [HLSL_OP2_MAX]         = "max",
        [HLSL_OP2_MIN]         = "min",
        [HLSL_OP2_MOD]         = "%",
        [HLSL_OP2_MUL]         = "*",
        [HLSL_OP2_NEQUAL]      = "!=",
        [HLSL_OP2_RSHIFT]      = ">>",
        [HLSL_OP2_SLT]         = "slt",
 
        [HLSL_OP3_CMP]         = "cmp",
        [HLSL_OP3_DP2ADD]      = "dp2add",
        [HLSL_OP3_TERNARY]     = "ternary",
        [HLSL_OP3_MAD]         = "mad",
    };
 
    return op_names[op];
}

Referenced by dump_ir_expr(), hlsl_fold_constant_exprs(), sm1_generate_vsir_instr_expr(), and sm4_generate_vsir_instr_expr().

◆ debug_hlsl_swizzle()

const char * debug_hlsl_swizzle	(	unsigned int	swizzle,
		unsigned int	count
	)

◆ debug_hlsl_type()

const char * debug_hlsl_type	(	struct hlsl_ctx *	ctx,
		const struct hlsl_type *	type
	)

Definition at line 2889 of file hlsl.c.

{
    struct vkd3d_string_buffer *string;
    const char *ret;
 
    if (!(string = hlsl_type_to_string(ctx, type)))
        return NULL;
    ret = vkd3d_dbg_sprintf("%s", string->buffer);
    hlsl_release_string_buffer(ctx, string);
    return ret;
}

Referenced by dump_instr(), dump_ir_var(), fold_abs(), fold_add(), fold_and(), fold_bit_xor(), fold_cast(), fold_ceil(), fold_div(), fold_dot(), fold_dp2add(), fold_exp2(), fold_floor(), fold_fract(), fold_log2(), fold_max(), fold_min(), fold_mod(), fold_mul(), fold_neg(), fold_not(), fold_or(), fold_rcp(), fold_rsq(), fold_sat(), fold_sqrt(), sm1_generate_vsir_instr_expr_cast(), and sm4_generate_vsir_instr_expr().

◆ debug_hlsl_writemask()

const char * debug_hlsl_writemask ( unsigned int writemask )

Definition at line 3074 of file hlsl.c.

{
    static const char components[] = {'x', 'y', 'z', 'w'};
    char string[5];
    unsigned int i = 0, pos = 0;
 
    VKD3D_ASSERT(!(writemask & ~VKD3DSP_WRITEMASK_ALL));
 
    while (writemask)
    {
        if (writemask & 1)
            string[pos++] = components[i];
        writemask >>= 1;
        i++;
    }
    string[pos] = '\0';
    return vkd3d_dbg_sprintf(".%s", string);
}

Referenced by copy_propagation_invalidate_variable(), copy_propagation_set_value(), debug_register(), and dump_ir_store().

◆ hlsl_add_conditional()

struct hlsl_ir_node * hlsl_add_conditional	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block,
		struct hlsl_ir_node *	condition,
		struct hlsl_ir_node *	if_true,
		struct hlsl_ir_node *	if_false
	)

Definition at line 3667 of file hlsl_codegen.c.

{
    struct hlsl_type *cond_type = condition->data_type;
    struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS];
    struct hlsl_ir_node *cond;
 
    VKD3D_ASSERT(hlsl_types_are_equal(if_true->data_type, if_false->data_type));
 
    if (cond_type->e.numeric.type != HLSL_TYPE_BOOL)
    {
        cond_type = hlsl_get_numeric_type(ctx, cond_type->class, HLSL_TYPE_BOOL, cond_type->dimx, cond_type->dimy);
 
        if (!(condition = hlsl_new_cast(ctx, condition, cond_type, &condition->loc)))
            return NULL;
        hlsl_block_add_instr(instrs, condition);
    }
 
    operands[0] = condition;
    operands[1] = if_true;
    operands[2] = if_false;
    if (!(cond = hlsl_new_expr(ctx, HLSL_OP3_TERNARY, operands, if_true->data_type, &condition->loc)))
        return false;
    hlsl_block_add_instr(instrs, cond);
 
    return cond;
}

Referenced by lower_float_modulus(), lower_int_division(), and lower_int_modulus().

◆ hlsl_add_function()

void hlsl_add_function	(	struct hlsl_ctx *	ctx,
		char *	name,
		struct hlsl_ir_function_decl *	decl
	)

Definition at line 3946 of file hlsl.c.

{
    struct hlsl_ir_function *func;
    struct rb_entry *func_entry;
 
    if (ctx->internal_func_name)
    {
        char *internal_name;
 
        if (!(internal_name = hlsl_strdup(ctx, ctx->internal_func_name)))
            return;
        vkd3d_free(name);
        name = internal_name;
    }
 
    func_entry = rb_get(&ctx->functions, name);
    if (func_entry)
    {
        func = RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry);
        decl->func = func;
        list_add_tail(&func->overloads, &decl->entry);
        vkd3d_free(name);
        return;
    }
    func = hlsl_alloc(ctx, sizeof(*func));
    func->name = name;
    list_init(&func->overloads);
    decl->func = func;
    list_add_tail(&func->overloads, &decl->entry);
    rb_put(&ctx->functions, func->name, &func->entry);
}

◆ hlsl_add_load_component()

struct hlsl_ir_node * hlsl_add_load_component	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block,
		struct hlsl_ir_node *	var_instr,
		unsigned int	comp,
		const struct vkd3d_shader_location *	loc
	)

Referenced by lower_discard_neg(), and lower_matrix_swizzles().

◆ hlsl_add_var()

bool hlsl_add_var	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_var *	decl,
		bool	local_var
	)

Definition at line 96 of file hlsl.c.

{
    struct hlsl_scope *scope = ctx->cur_scope;
    struct hlsl_ir_var *var;
 
    if (decl->name)
    {
        LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
        {
            if (var->name && !strcmp(decl->name, var->name))
                return false;
        }
        if (local_var && scope->upper->upper == ctx->globals)
        {
            /* Check whether the variable redefines a function parameter. */
            LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
            {
                if (var->name && !strcmp(decl->name, var->name))
                    return false;
            }
        }
    }
 
    list_add_tail(&scope->vars, &decl->scope_entry);
    return true;
}

◆ hlsl_alloc()

static void * hlsl_alloc	(	struct hlsl_ctx *	ctx,
		size_t	size
	)

inlinestatic

Definition at line 1300 of file hlsl.h.

{
    void *ptr = vkd3d_calloc(1, size);
 
    if (!ptr)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ptr;
}

Referenced by clone_compile(), clone_load(), clone_resource_load(), clone_resource_store(), clone_stateblock_entry(), clone_store(), copy_propagation_create_var_def(), hlsl_add_function(), hlsl_ctx_init(), hlsl_new_array_type(), hlsl_new_buffer(), hlsl_new_call(), hlsl_new_cb_type(), hlsl_new_compile(), hlsl_new_constant(), hlsl_new_expr(), hlsl_new_func_decl(), hlsl_new_if(), hlsl_new_index(), hlsl_new_jump(), hlsl_new_load_component(), hlsl_new_load_index(), hlsl_new_loop(), hlsl_new_resource_load(), hlsl_new_resource_store(), hlsl_new_sampler_state(), hlsl_new_scope(), hlsl_new_simple_type(), hlsl_new_stateblock_constant(), hlsl_new_store_component(), hlsl_new_store_index(), hlsl_new_string_constant(), hlsl_new_struct_type(), hlsl_new_switch(), hlsl_new_switch_case(), hlsl_new_swizzle(), hlsl_new_texture_type(), hlsl_new_type(), hlsl_new_uav_type(), hlsl_new_var(), hlsl_new_vsir_instruction_ref(), hlsl_type_clone(), write_fx_4_string(), and write_type().

◆ hlsl_array_reserve()

static bool hlsl_array_reserve	(	struct hlsl_ctx *	ctx,
		void **	elements,
		size_t *	capacity,
		size_t	element_count,
		size_t	element_size
	)

inlinestatic

Definition at line 1336 of file hlsl.h.

{
    bool ret = vkd3d_array_reserve(elements, capacity, element_count, element_size);
 
    if (!ret)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ret;
}

Referenced by clone_block(), copy_propagation_trace_record_value(), find_recursive_calls(), record_allocation(), record_constant(), and sm4_get_extern_resources().

◆ hlsl_block_add_block()

static void hlsl_block_add_block	(	struct hlsl_block *	block,
		struct hlsl_block *	add
	)

inlinestatic

Definition at line 1280 of file hlsl.h.

{
    list_move_tail(&block->instrs, &add->instrs);
    block->value = add->value;
}

Referenced by hlsl_new_compile(), hlsl_new_if(), hlsl_new_load_component(), hlsl_new_loop(), hlsl_new_store_component(), hlsl_new_switch_case(), lower_matrix_swizzles(), lower_trig(), new_offset_instr_from_deref(), and transform_unroll_loops().

◆ hlsl_block_add_instr()

static void hlsl_block_add_instr	(	struct hlsl_block *	block,
		struct hlsl_ir_node *	instr
	)

inlinestatic

Definition at line 1274 of file hlsl.h.

{
    list_add_tail(&block->instrs, &instr->entry);
    block->value = (instr->data_type ? instr : NULL);
}

Referenced by add_last_vsir_instr_to_block(), append_output_copy(), append_output_copy_recurse(), append_output_var_copy(), clone_block(), hlsl_add_conditional(), hlsl_ctx_init(), hlsl_new_func_decl(), hlsl_new_load_component(), hlsl_new_store_component(), init_deref_from_component_index(), insert_early_return_break(), lower_abs(), lower_broadcasts(), lower_casts_to_bool(), lower_casts_to_int(), lower_ceil(), lower_cmp(), lower_comparison_operators(), lower_discard_neg(), lower_discard_nz(), lower_division(), lower_dot(), lower_f16tof32(), lower_f32tof16(), lower_float_modulus(), lower_floor(), lower_index_loads(), lower_int_abs(), lower_int_division(), lower_int_dot(), lower_int_modulus(), lower_logic_not(), lower_matrix_swizzles(), lower_narrowing_casts(), lower_nonconstant_array_loads(), lower_nonconstant_vector_derefs(), lower_nonfloat_exprs(), lower_return(), lower_round(), lower_slt(), lower_sqrt(), lower_ternary(), lower_trig(), new_offset_from_path_index(), new_offset_instr_from_deref(), and normalize_switch_cases().

◆ hlsl_block_cleanup()

void hlsl_block_cleanup ( struct hlsl_block * block )

Definition at line 3675 of file hlsl.c.

{
    hlsl_free_instr_list(&block->instrs);
}

Referenced by call_lower_func(), clone_block(), clone_compile(), clone_if(), clone_loop(), clone_switch(), free_function_decl(), free_ir_compile(), free_ir_if(), free_ir_loop(), hlsl_ctx_cleanup(), hlsl_emit_bytecode(), hlsl_free_attribute(), hlsl_free_ir_switch_case(), hlsl_free_state_block_entry(), init_deref_from_component_index(), loop_unrolling_unroll_loop(), new_offset_instr_from_deref(), remove_unreachable_code(), sm4_generate_vsir_add_function(), and transform_unroll_loops().

◆ hlsl_block_init()

static void hlsl_block_init ( struct hlsl_block * block )

inlinestatic

Definition at line 1268 of file hlsl.h.

{
    list_init(&block->instrs);
    block->value = NULL;
}

Referenced by call_lower_func(), clone_block(), clone_stateblock_entry(), hlsl_ctx_init(), hlsl_emit_bytecode(), hlsl_new_compile(), hlsl_new_func_decl(), hlsl_new_if(), hlsl_new_load_component(), hlsl_new_loop(), hlsl_new_store_component(), hlsl_new_switch_case(), init_deref_from_component_index(), insert_early_return_break(), lower_discard_neg(), lower_discard_nz(), lower_return(), new_offset_instr_from_deref(), remove_unreachable_code(), sm1_generate_vsir(), sm4_generate_vsir_add_function(), and transform_unroll_loops().

◆ hlsl_calculate_buffer_offsets()

void hlsl_calculate_buffer_offsets ( struct hlsl_ctx * ctx )

Definition at line 5551 of file hlsl_codegen.c.

{
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
    {
        if (!var->is_uniform || hlsl_type_is_resource(var->data_type))
            continue;
 
        if (hlsl_var_has_buffer_offset_register_reservation(ctx, var))
            hlsl_calculate_buffer_offset(ctx, var, true);
    }
 
    LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
    {
        if (!var->is_uniform || hlsl_type_is_resource(var->data_type))
            continue;
 
        if (!hlsl_var_has_buffer_offset_register_reservation(ctx, var))
            hlsl_calculate_buffer_offset(ctx, var, false);
    }
}

Referenced by allocate_buffers(), and fx_write_context_init().

◆ hlsl_calloc()

static void * hlsl_calloc	(	struct hlsl_ctx *	ctx,
		size_t	count,
		size_t	size
	)

inlinestatic

Definition at line 1309 of file hlsl.h.

{
    void *ptr = vkd3d_calloc(count, size);
 
    if (!ptr)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ptr;
}

Referenced by hlsl_new_var(), hlsl_type_clone(), init_deref(), and write_fx_4_type().

◆ hlsl_cleanup_deref()

void hlsl_cleanup_deref ( struct hlsl_deref * deref )

Definition at line 1408 of file hlsl.c.

{
    unsigned int i;
 
    for (i = 0; i < deref->path_len; ++i)
        hlsl_src_remove(&deref->path[i]);
    vkd3d_free(deref->path);
 
    deref->path = NULL;
    deref->path_len = 0;
 
    hlsl_src_remove(&deref->rel_offset);
    deref->const_offset = 0;
}

Referenced by clone_resource_load(), copy_propagation_transform_object_load(), free_ir_load(), free_ir_resource_load(), free_ir_resource_store(), free_ir_store(), hlsl_new_resource_load(), lower_nonconstant_array_loads(), and replace_deref_path_with_offset().

◆ hlsl_cleanup_ir_switch_cases()

void hlsl_cleanup_ir_switch_cases ( struct list * cases )

Definition at line 2436 of file hlsl.c.

{
    struct hlsl_ir_switch_case *c, *next;
 
    LIST_FOR_EACH_ENTRY_SAFE(c, next, cases, struct hlsl_ir_switch_case, entry)
    {
        hlsl_free_ir_switch_case(c);
    }
}

Referenced by clone_switch(), and free_ir_switch().

◆ hlsl_cleanup_semantic()

void hlsl_cleanup_semantic ( struct hlsl_semantic * semantic )

Definition at line 3896 of file hlsl.c.

{
    vkd3d_free((void *)semantic->name);
    vkd3d_free((void *)semantic->raw_name);
    memset(semantic, 0, sizeof(*semantic));
}

Referenced by add_semantic_var(), hlsl_clone_semantic(), hlsl_free_type(), and hlsl_free_var().

◆ hlsl_clone_block()

bool hlsl_clone_block	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	dst_block,
		const struct hlsl_block *	src_block
	)

Definition at line 2544 of file hlsl.c.

{
    struct clone_instr_map map = {0};
    bool ret;
 
    ret = clone_block(ctx, dst_block, src_block, &map);
    vkd3d_free(map.instrs);
    return ret;
}

Referenced by loop_unrolling_unroll_loop(), lower_calls(), process_entry_function(), and transform_unroll_loops().

◆ hlsl_clone_semantic()

bool hlsl_clone_semantic	(	struct hlsl_ctx *	ctx,
		struct hlsl_semantic *	dst,
		const struct hlsl_semantic *	src
	)

Definition at line 3903 of file hlsl.c.

{
    *dst = *src;
    dst->name = dst->raw_name = NULL;
    if (src->name && !(dst->name = hlsl_strdup(ctx, src->name)))
        return false;
    if (src->raw_name && !(dst->raw_name = hlsl_strdup(ctx, src->raw_name)))
    {
        hlsl_cleanup_semantic(dst);
        return false;
    }
 
    return true;
}

Referenced by add_semantic_var().

◆ hlsl_combine_swizzles()

uint32_t hlsl_combine_swizzles	(	uint32_t	first,
		uint32_t	second,
		unsigned int	dim
	)

Definition at line 4042 of file hlsl.c.

{
    uint32_t ret = 0;
    unsigned int i;
    for (i = 0; i < dim; ++i)
    {
        unsigned int s = hlsl_swizzle_get_component(second, i);
        ret |= hlsl_swizzle_get_component(first, s) << HLSL_SWIZZLE_SHIFT(i);
    }
    return ret;
}

Referenced by fold_swizzle_chains(), generate_vsir_instr_swizzle(), and write_sm4_swizzle().

◆ hlsl_combine_writemasks()

unsigned int hlsl_combine_writemasks	(	unsigned int	first,
		unsigned int	second
	)

Definition at line 4026 of file hlsl.c.

{
    unsigned int ret = 0, i, j = 0;
 
    for (i = 0; i < 4; ++i)
    {
        if (first & (1 << i))
        {
            if (second & (1 << j++))
                ret |= (1 << i);
        }
    }
 
    return ret;
}

Referenced by allocate_register(), hlsl_reg_from_deref(), sm1_generate_vsir_init_dst_param_from_deref(), sm4_numeric_register_from_deref(), and write_sm4_store().

◆ hlsl_compile_internal_function()

struct hlsl_ir_function_decl * hlsl_compile_internal_function	(	struct hlsl_ctx *	ctx,
		const char *	name,
		const char *	hlsl
	)

Definition at line 4642 of file hlsl.c.

{
    const struct hlsl_ir_function_decl *saved_cur_function = ctx->cur_function;
    struct vkd3d_shader_code code = {.code = hlsl, .size = strlen(hlsl)};
    const char *saved_internal_func_name = ctx->internal_func_name;
    struct vkd3d_string_buffer *internal_name;
    struct hlsl_ir_function_decl *func;
    void *saved_scanner = ctx->scanner;
    int ret;
 
    TRACE("name %s, hlsl %s.\n", debugstr_a(name), debugstr_a(hlsl));
 
    /* The actual name of the function is mangled with a unique prefix, both to
     * allow defining multiple variants of a function with the same name, and to
     * avoid polluting the user name space. */
 
    if (!(internal_name = hlsl_get_string_buffer(ctx)))
        return NULL;
    vkd3d_string_buffer_printf(internal_name, "<%s-%u>", name, ctx->internal_name_counter++);
 
    /* Save and restore everything that matters.
     * Note that saving the scope stack is hard, and shouldn't be necessary. */
 
    hlsl_push_scope(ctx);
    ctx->scanner = NULL;
    ctx->internal_func_name = internal_name->buffer;
    ctx->cur_function = NULL;
    ret = hlsl_lexer_compile(ctx, &code);
    ctx->scanner = saved_scanner;
    ctx->internal_func_name = saved_internal_func_name;
    ctx->cur_function = saved_cur_function;
    hlsl_pop_scope(ctx);
    if (ret)
    {
        ERR("Failed to compile intrinsic, error %u.\n", ret);
        hlsl_release_string_buffer(ctx, internal_name);
        return NULL;
    }
    func = hlsl_get_first_func_decl(ctx, internal_name->buffer);
    hlsl_release_string_buffer(ctx, internal_name);
    return func;
}

Referenced by lower_f16tof32(), and lower_f32tof16().

◆ hlsl_component_index_range_from_deref()

bool hlsl_component_index_range_from_deref	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref,
		unsigned int *	start,
		unsigned int *	count
	)

Definition at line 5811 of file hlsl_codegen.c.

{
    struct hlsl_type *type = deref->var->data_type;
    unsigned int i, k;
 
    *start = 0;
    *count = 0;
 
    for (i = 0; i < deref->path_len; ++i)
    {
        struct hlsl_ir_node *path_node = deref->path[i].node;
        unsigned int idx = 0;
 
        VKD3D_ASSERT(path_node);
        if (path_node->type != HLSL_IR_CONSTANT)
            return false;
 
        /* We should always have generated a cast to UINT. */
        VKD3D_ASSERT(path_node->data_type->class == HLSL_CLASS_SCALAR
                && path_node->data_type->e.numeric.type == HLSL_TYPE_UINT);
 
        idx = hlsl_ir_constant(path_node)->value.u[0].u;
 
        switch (type->class)
        {
            case HLSL_CLASS_VECTOR:
                if (idx >= type->dimx)
                    return false;
                *start += idx;
                break;
 
            case HLSL_CLASS_MATRIX:
                if (idx >= hlsl_type_major_size(type))
                    return false;
                if (hlsl_type_is_row_major(type))
                    *start += idx * type->dimx;
                else
                    *start += idx * type->dimy;
                break;
 
            case HLSL_CLASS_ARRAY:
                if (idx >= type->e.array.elements_count)
                    return false;
                *start += idx * hlsl_type_component_count(type->e.array.type);
                break;
 
            case HLSL_CLASS_STRUCT:
                for (k = 0; k < idx; ++k)
                    *start += hlsl_type_component_count(type->e.record.fields[k].type);
                break;
 
            default:
                vkd3d_unreachable();
        }
 
        type = hlsl_get_element_type_from_path_index(ctx, type, path_node);
    }
 
    *count = hlsl_type_component_count(type);
    return true;
}

Referenced by copy_propagation_record_store(), copy_propagation_replace_with_constant_vector(), copy_propagation_replace_with_single_instr(), and copy_propagation_transform_object_load().

◆ hlsl_component_to_string()

struct vkd3d_string_buffer * hlsl_component_to_string	(	struct hlsl_ctx *	ctx,
		const struct hlsl_ir_var *	var,
		unsigned int	index
	)

Definition at line 2864 of file hlsl.c.

{
    struct hlsl_type *type = var->data_type, *current_type;
    struct vkd3d_string_buffer *buffer;
    unsigned int element_index;
 
    if (!(buffer = hlsl_get_string_buffer(ctx)))
        return NULL;
 
    vkd3d_string_buffer_printf(buffer, "%s", var->name);
 
    while (!type_is_single_component(type))
    {
        current_type = type;
        element_index = traverse_path_from_component_index(ctx, &type, &index);
        if (current_type->class == HLSL_CLASS_STRUCT)
            vkd3d_string_buffer_printf(buffer, ".%s", current_type->e.record.fields[element_index].name);
        else
            vkd3d_string_buffer_printf(buffer, "[%u]", element_index);
    }
 
    return buffer;
}

Referenced by sm4_get_extern_resources().

◆ hlsl_copy_deref()

bool hlsl_copy_deref	(	struct hlsl_ctx *	ctx,
		struct hlsl_deref *	deref,
		const struct hlsl_deref *	other
	)

Definition at line 1388 of file hlsl.c.

{
    unsigned int i;
 
    memset(deref, 0, sizeof(*deref));
 
    if (!other)
        return true;
 
    VKD3D_ASSERT(!hlsl_deref_is_lowered(other));
 
    if (!init_deref(ctx, deref, other->var, other->path_len))
        return false;
 
    for (i = 0; i < deref->path_len; ++i)
        hlsl_src_from_node(&deref->path[i], other->path[i].node);
 
    return true;
}

Referenced by copy_propagation_transform_object_load(), hlsl_new_resource_store(), lower_combined_samples(), and lower_nonconstant_array_loads().

◆ hlsl_copy_propagation_execute()

bool hlsl_copy_propagation_execute	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block
	)

Definition at line 2009 of file hlsl_codegen.c.

{
    struct copy_propagation_state state;
    bool progress;
 
    index_instructions(block, 2);
 
    copy_propagation_state_init(ctx, &state, NULL);
 
    progress = copy_propagation_transform_block(ctx, block, &state);
 
    copy_propagation_state_destroy(&state);
 
    return progress;
}

Referenced by hlsl_run_const_passes().

◆ hlsl_deref_get_regset()

enum hlsl_regset hlsl_deref_get_regset	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref
	)

Definition at line 327 of file hlsl.c.

{
    return type_get_regset(hlsl_deref_get_type(ctx, deref));
}

Referenced by clean_constant_deref_offset_srcs(), hlsl_offset_from_deref(), lower_combined_samples(), new_offset_instr_from_deref(), register_deref_usage(), sm4_register_from_deref(), track_components_usage(), track_object_components_sampler_dim(), and write_sm4_ld().

◆ hlsl_deref_get_type()

struct hlsl_type * hlsl_deref_get_type	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref
	)

Definition at line 783 of file hlsl.c.

{
    struct hlsl_type *type;
    unsigned int i;
 
    VKD3D_ASSERT(deref);
 
    if (hlsl_deref_is_lowered(deref))
        return deref->data_type;
 
    type = deref->var->data_type;
    for (i = 0; i < deref->path_len; ++i)
        type = hlsl_get_element_type_from_path_index(ctx, type, deref->path[i].node);
    return type;
}

Referenced by hlsl_deref_get_regset(), hlsl_new_load_component(), hlsl_new_load_index(), hlsl_new_resource_load(), init_deref_from_component_index(), lower_combined_samples(), register_deref_usage(), replace_deref_path_with_offset(), sm4_register_from_deref(), write_sm4_ld(), and write_sm4_resource_store().

◆ hlsl_deref_is_lowered()

static bool hlsl_deref_is_lowered ( const struct hlsl_deref * deref )

inlinestatic

Definition at line 822 of file hlsl.h.

{
    return !!deref->data_type;
}

Referenced by clone_deref(), deref_mark_last_read(), dump_deref(), hlsl_copy_deref(), hlsl_deref_get_type(), hlsl_new_load_index(), hlsl_new_store_index(), and replace_deref_path_with_offset().

◆ hlsl_dump_function()

void hlsl_dump_function	(	struct hlsl_ctx *	ctx,
		const struct hlsl_ir_function_decl *	func
	)

Definition at line 3573 of file hlsl.c.

{
    struct vkd3d_string_buffer buffer;
    size_t i;
 
    vkd3d_string_buffer_init(&buffer);
    vkd3d_string_buffer_printf(&buffer, "Dumping function %s.\n", func->func->name);
    vkd3d_string_buffer_printf(&buffer, "Function parameters:\n");
    for (i = 0; i < func->parameters.count; ++i)
    {
        dump_ir_var(ctx, &buffer, func->parameters.vars[i]);
        vkd3d_string_buffer_printf(&buffer, "\n");
    }
    if (func->has_body)
        dump_block(ctx, &buffer, &func->body);
 
    vkd3d_string_buffer_trace(&buffer);
    vkd3d_string_buffer_cleanup(&buffer);
}

Referenced by dump_function().

◆ hlsl_dump_var_default_values()

void hlsl_dump_var_default_values ( const struct hlsl_ir_var * var )

Definition at line 3593 of file hlsl.c.

{
    unsigned int k, component_count = hlsl_type_component_count(var->data_type);
    struct vkd3d_string_buffer buffer;
 
    vkd3d_string_buffer_init(&buffer);
    if (!var->default_values)
    {
        vkd3d_string_buffer_printf(&buffer, "var \"%s\" has no default values.\n", var->name);
        vkd3d_string_buffer_trace(&buffer);
        vkd3d_string_buffer_cleanup(&buffer);
        return;
    }
 
    vkd3d_string_buffer_printf(&buffer, "var \"%s\" default values:", var->name);
    for (k = 0; k < component_count; ++k)
    {
        bool is_string = var->default_values[k].string;
 
        if (k % 4 == 0 || is_string)
            vkd3d_string_buffer_printf(&buffer, "\n   ");
 
        if (is_string)
            vkd3d_string_buffer_printf(&buffer, " %s", debugstr_a(var->default_values[k].string));
        else
            vkd3d_string_buffer_printf(&buffer, " 0x%08x", var->default_values[k].number.u);
    }
    vkd3d_string_buffer_printf(&buffer, "\n");
 
    vkd3d_string_buffer_trace(&buffer);
    vkd3d_string_buffer_cleanup(&buffer);
}

◆ hlsl_emit_bytecode()

int hlsl_emit_bytecode	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_function_decl *	entry_func,
		enum vkd3d_shader_target_type	target_type,
		struct vkd3d_shader_code *	out
	)

Definition at line 9202 of file hlsl_codegen.c.

{
    const struct hlsl_profile_info *profile = ctx->profile;
    struct hlsl_block global_uniform_block;
    struct hlsl_ir_var *var;
 
    parse_entry_function_attributes(ctx, entry_func);
    if (ctx->result)
        return ctx->result;
 
    if (profile->type == VKD3D_SHADER_TYPE_HULL)
        validate_hull_shader_attributes(ctx, entry_func);
    else if (profile->type == VKD3D_SHADER_TYPE_COMPUTE && !ctx->found_numthreads)
        hlsl_error(ctx, &entry_func->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_ATTRIBUTE,
                "Entry point \"%s\" is missing a [numthreads] attribute.", entry_func->func->name);
    else if (profile->type == VKD3D_SHADER_TYPE_DOMAIN && ctx->domain == VKD3D_TESSELLATOR_DOMAIN_INVALID)
        hlsl_error(ctx, &entry_func->loc, VKD3D_SHADER_ERROR_HLSL_MISSING_ATTRIBUTE,
                "Entry point \"%s\" is missing a [domain] attribute.", entry_func->func->name);
 
    hlsl_block_init(&global_uniform_block);
 
    LIST_FOR_EACH_ENTRY(var, &ctx->globals->vars, struct hlsl_ir_var, scope_entry)
    {
        if (var->storage_modifiers & HLSL_STORAGE_UNIFORM)
            prepend_uniform_copy(ctx, &global_uniform_block, var);
    }
 
    process_entry_function(ctx, &global_uniform_block, entry_func);
    if (ctx->result)
        return ctx->result;
 
    if (profile->type == VKD3D_SHADER_TYPE_HULL)
    {
        process_entry_function(ctx, &global_uniform_block, ctx->patch_constant_func);
        if (ctx->result)
            return ctx->result;
    }
 
    hlsl_block_cleanup(&global_uniform_block);
 
    if (profile->major_version < 4)
    {
        mark_indexable_vars(ctx, entry_func);
        allocate_temp_registers(ctx, entry_func);
        allocate_const_registers(ctx, entry_func);
    }
    else
    {
        allocate_buffers(ctx);
        allocate_objects(ctx, entry_func, HLSL_REGSET_TEXTURES);
        allocate_objects(ctx, entry_func, HLSL_REGSET_UAVS);
    }
    allocate_objects(ctx, entry_func, HLSL_REGSET_SAMPLERS);
 
    if (TRACE_ON())
        rb_for_each_entry(&ctx->functions, dump_function, ctx);
 
    if (ctx->result)
        return ctx->result;
 
    switch (target_type)
    {
        case VKD3D_SHADER_TARGET_D3D_BYTECODE:
        {
            uint32_t config_flags = vkd3d_shader_init_config_flags();
            struct vkd3d_shader_code ctab = {0};
            struct vsir_program program;
            int result;
 
            sm1_generate_vsir(ctx, entry_func, config_flags, &program, &ctab);
            if (ctx->result)
            {
                vsir_program_cleanup(&program);
                vkd3d_shader_free_shader_code(&ctab);
                return ctx->result;
            }
 
            result = d3dbc_compile(&program, config_flags, NULL, &ctab, out, ctx->message_context);
            vsir_program_cleanup(&program);
            vkd3d_shader_free_shader_code(&ctab);
            return result;
        }
 
        case VKD3D_SHADER_TARGET_DXBC_TPF:
        {
            uint32_t config_flags = vkd3d_shader_init_config_flags();
            struct vsir_program program;
            int result;
 
            sm4_generate_vsir(ctx, entry_func, config_flags, &program);
            if (ctx->result)
            {
                vsir_program_cleanup(&program);
                return ctx->result;
            }
 
            result = tpf_compile(&program, config_flags, out, ctx->message_context, ctx, entry_func);
            vsir_program_cleanup(&program);
            return result;
        }
 
        default:
            ERR("Unsupported shader target type %#x.\n", target_type);
            return VKD3D_ERROR_INVALID_ARGUMENT;
    }
}

Referenced by hlsl_compile_shader().

◆ hlsl_emit_effect_binary()

int hlsl_emit_effect_binary	(	struct hlsl_ctx *	ctx,
		struct vkd3d_shader_code *	out
	)

Definition at line 2865 of file fx.c.

{
    if (ctx->profile->major_version == 2)
    {
        return hlsl_fx_2_write(ctx, out);
    }
    else if (ctx->profile->major_version == 4)
    {
        return hlsl_fx_4_write(ctx, out);
    }
    else if (ctx->profile->major_version == 5)
    {
        return hlsl_fx_5_write(ctx, out);
    }
    else
    {
        vkd3d_unreachable();
    }
}

Referenced by hlsl_compile_shader().

◆ hlsl_error()

void hlsl_error	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_location *	loc,
		enum vkd3d_shader_error	error,
		const char *	fmt,
			...
	)

◆ hlsl_fixme()

void void hlsl_fixme	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_location *	loc,
		const char *	fmt,
			...
	)

◆ hlsl_fold_constant_exprs()

bool hlsl_fold_constant_exprs	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	instr,
		void *	context
	)

Definition at line 1218 of file hlsl_constant_ops.c.

{
    struct hlsl_ir_constant *arg1, *arg2 = NULL, *arg3 = NULL;
    struct hlsl_constant_value res = {0};
    struct hlsl_ir_node *res_node;
    struct hlsl_ir_expr *expr;
    unsigned int i;
    bool success;
 
    if (instr->type != HLSL_IR_EXPR)
        return false;
    expr = hlsl_ir_expr(instr);
    if (!expr->operands[0].node)
        return false;
 
    if (instr->data_type->class > HLSL_CLASS_VECTOR)
        return false;
 
    for (i = 0; i < ARRAY_SIZE(expr->operands); ++i)
    {
        if (expr->operands[i].node)
        {
            if (expr->operands[i].node->type != HLSL_IR_CONSTANT)
                return false;
            VKD3D_ASSERT(expr->operands[i].node->data_type->class <= HLSL_CLASS_VECTOR);
        }
    }
    arg1 = hlsl_ir_constant(expr->operands[0].node);
    if (expr->operands[1].node)
        arg2 = hlsl_ir_constant(expr->operands[1].node);
    if (expr->operands[2].node)
        arg3 = hlsl_ir_constant(expr->operands[2].node);
 
    switch (expr->op)
    {
        case HLSL_OP1_ABS:
            success = fold_abs(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_BIT_NOT:
            success = fold_bit_not(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_CAST:
            success = fold_cast(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_CEIL:
            success = fold_ceil(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_EXP2:
            success = fold_exp2(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_FLOOR:
            success = fold_floor(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_FRACT:
            success = fold_fract(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_LOG2:
            success = fold_log2(ctx, &res, instr->data_type, arg1, &instr->loc);
            break;
 
        case HLSL_OP1_NEG:
            success = fold_neg(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_LOGIC_NOT:
            success = fold_not(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_RCP:
            success = fold_rcp(ctx, &res, instr->data_type, arg1, &instr->loc);
            break;
 
        case HLSL_OP1_RSQ:
            success = fold_rsq(ctx, &res, instr->data_type, arg1, &instr->loc);
            break;
 
        case HLSL_OP1_SAT:
            success = fold_sat(ctx, &res, instr->data_type, arg1);
            break;
 
        case HLSL_OP1_SQRT:
            success = fold_sqrt(ctx, &res, instr->data_type, arg1, &instr->loc);
            break;
 
        case HLSL_OP2_ADD:
            success = fold_add(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_BIT_AND:
        case HLSL_OP2_LOGIC_AND:
            success = fold_and(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_BIT_OR:
        case HLSL_OP2_LOGIC_OR:
            success = fold_or(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_BIT_XOR:
            success = fold_bit_xor(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_DOT:
            success = fold_dot(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_DIV:
            success = fold_div(ctx, &res, instr->data_type, arg1, arg2, &instr->loc);
            break;
 
        case HLSL_OP2_EQUAL:
            success = fold_equal(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_GEQUAL:
            success = fold_gequal(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_LESS:
            success = fold_less(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_LSHIFT:
            success = fold_lshift(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_MAX:
            success = fold_max(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_MIN:
            success = fold_min(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_MOD:
            success = fold_mod(ctx, &res, instr->data_type, arg1, arg2, &instr->loc);
            break;
 
        case HLSL_OP2_MUL:
            success = fold_mul(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_NEQUAL:
            success = fold_nequal(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP2_RSHIFT:
            success = fold_rshift(ctx, &res, instr->data_type, arg1, arg2);
            break;
 
        case HLSL_OP3_DP2ADD:
            success = fold_dp2add(ctx, &res, instr->data_type, arg1, arg2, arg3);
            break;
 
        case HLSL_OP3_TERNARY:
            success = fold_ternary(ctx, &res, instr->data_type, arg1, arg2, arg3);
            break;
 
        default:
            FIXME("Fold \"%s\" expression.\n", debug_hlsl_expr_op(expr->op));
            success = false;
            break;
    }
 
    if (success)
    {
        if (!(res_node = hlsl_new_constant(ctx, instr->data_type, &res, &instr->loc)))
            return false;
        list_add_before(&expr->node.entry, &res_node->entry);
        hlsl_replace_node(&expr->node, res_node);
    }
    return success;
}

Referenced by hlsl_run_const_passes(), and process_entry_function().

◆ hlsl_fold_constant_identities()

bool hlsl_fold_constant_identities	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	instr,
		void *	context
	)

Definition at line 1471 of file hlsl_constant_ops.c.

{
    struct hlsl_ir_constant *const_arg = NULL;
    struct hlsl_ir_node *mut_arg = NULL;
    struct hlsl_ir_node *res_node;
    struct hlsl_ir_expr *expr;
    unsigned int i;
 
    if (instr->type != HLSL_IR_EXPR)
        return false;
    expr = hlsl_ir_expr(instr);
 
    if (instr->data_type->class > HLSL_CLASS_VECTOR)
        return false;
 
    /* Verify that the expression has two operands. */
    for (i = 0; i < ARRAY_SIZE(expr->operands); ++i)
    {
        if (!!expr->operands[i].node != (i < 2))
            return false;
    }
 
    if (expr->operands[0].node->type == HLSL_IR_CONSTANT)
    {
        const_arg = hlsl_ir_constant(expr->operands[0].node);
        mut_arg = expr->operands[1].node;
    }
    else if (expr->operands[1].node->type == HLSL_IR_CONSTANT)
    {
        mut_arg = expr->operands[0].node;
        const_arg = hlsl_ir_constant(expr->operands[1].node);
    }
    else
    {
        return false;
    }
 
    res_node = NULL;
    switch (expr->op)
    {
        case HLSL_OP2_ADD:
            if (constant_is_zero(const_arg))
                res_node = mut_arg;
            break;
 
        case HLSL_OP2_MUL:
            if (constant_is_one(const_arg))
                res_node = mut_arg;
            break;
 
        case HLSL_OP2_LOGIC_AND:
            if (constant_is_zero(const_arg))
                res_node = &const_arg->node;
            else if (constant_is_one(const_arg))
                res_node = mut_arg;
            break;
 
        case HLSL_OP2_LOGIC_OR:
            if (constant_is_zero(const_arg))
                res_node = mut_arg;
            else if (constant_is_one(const_arg))
                res_node = &const_arg->node;
            break;
 
        default:
            break;
    }
 
    if (res_node)
    {
        hlsl_replace_node(&expr->node, res_node);
        return true;
    }
    return false;
}

Referenced by hlsl_run_const_passes().

◆ hlsl_fold_constant_swizzles()

bool hlsl_fold_constant_swizzles	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	instr,
		void *	context
	)

Definition at line 1547 of file hlsl_constant_ops.c.

{
    struct hlsl_constant_value value;
    struct hlsl_ir_swizzle *swizzle;
    struct hlsl_ir_constant *src;
    struct hlsl_ir_node *dst;
    unsigned int i;
 
    if (instr->type != HLSL_IR_SWIZZLE)
        return false;
    swizzle = hlsl_ir_swizzle(instr);
    if (swizzle->val.node->type != HLSL_IR_CONSTANT)
        return false;
    src = hlsl_ir_constant(swizzle->val.node);
 
    for (i = 0; i < swizzle->node.data_type->dimx; ++i)
        value.u[i] = src->value.u[hlsl_swizzle_get_component(swizzle->swizzle, i)];
 
    if (!(dst = hlsl_new_constant(ctx, instr->data_type, &value, &instr->loc)))
        return false;
 
    list_add_before(&swizzle->node.entry, &dst->entry);
    hlsl_replace_node(&swizzle->node, dst);
    return true;
}

Referenced by hlsl_run_const_passes().

◆ hlsl_free_attribute()

void hlsl_free_attribute ( struct hlsl_attribute * attr )

Definition at line 3885 of file hlsl.c.

{
    unsigned int i;
 
    for (i = 0; i < attr->args_count; ++i)
        hlsl_src_remove(&attr->args[i]);
    hlsl_block_cleanup(&attr->instrs);
    vkd3d_free((void *)attr->name);
    vkd3d_free(attr);
}

Referenced by free_function_decl().

◆ hlsl_free_instr()

void hlsl_free_instr ( struct hlsl_ir_node * node )

Definition at line 3805 of file hlsl.c.

{
    VKD3D_ASSERT(list_empty(&node->uses));
 
    switch (node->type)
    {
        case HLSL_IR_CALL:
            free_ir_call(hlsl_ir_call(node));
            break;
 
        case HLSL_IR_CONSTANT:
            free_ir_constant(hlsl_ir_constant(node));
            break;
 
        case HLSL_IR_EXPR:
            free_ir_expr(hlsl_ir_expr(node));
            break;
 
        case HLSL_IR_IF:
            free_ir_if(hlsl_ir_if(node));
            break;
 
        case HLSL_IR_INDEX:
            free_ir_index(hlsl_ir_index(node));
            break;
 
        case HLSL_IR_JUMP:
            free_ir_jump(hlsl_ir_jump(node));
            break;
 
        case HLSL_IR_LOAD:
            free_ir_load(hlsl_ir_load(node));
            break;
 
        case HLSL_IR_LOOP:
            free_ir_loop(hlsl_ir_loop(node));
            break;
 
        case HLSL_IR_RESOURCE_LOAD:
            free_ir_resource_load(hlsl_ir_resource_load(node));
            break;
 
        case HLSL_IR_STRING_CONSTANT:
            free_ir_string_constant(hlsl_ir_string_constant(node));
            break;
 
        case HLSL_IR_RESOURCE_STORE:
            free_ir_resource_store(hlsl_ir_resource_store(node));
            break;
 
        case HLSL_IR_STORE:
            free_ir_store(hlsl_ir_store(node));
            break;
 
        case HLSL_IR_SWIZZLE:
            free_ir_swizzle(hlsl_ir_swizzle(node));
            break;
 
        case HLSL_IR_SWITCH:
            free_ir_switch(hlsl_ir_switch(node));
            break;
 
        case HLSL_IR_COMPILE:
            free_ir_compile(hlsl_ir_compile(node));
            break;
 
        case HLSL_IR_SAMPLER_STATE:
            free_ir_sampler_state(hlsl_ir_sampler_state(node));
            break;
 
        case HLSL_IR_STATEBLOCK_CONSTANT:
            free_ir_stateblock_constant(hlsl_ir_stateblock_constant(node));
            break;
 
        case HLSL_IR_VSIR_INSTRUCTION_REF:
            vkd3d_free(hlsl_ir_vsir_instruction_ref(node));
            break;
    }
}

Referenced by dce(), hlsl_free_instr_list(), hlsl_new_sampler_state(), hlsl_new_string_constant(), hlsl_replace_node(), loop_unrolling_unroll_loop(), lower_calls(), lower_return(), remove_trivial_conditional_branches(), split_array_copies(), split_matrix_copies(), and split_struct_copies().

◆ hlsl_free_instr_list()

void hlsl_free_instr_list ( struct list * list )

Definition at line 3663 of file hlsl.c.

{
    struct hlsl_ir_node *node, *next_node;
 
    if (!list)
        return;
    /* Iterate in reverse, to avoid use-after-free when unlinking sources from
     * the "uses" list. */
    LIST_FOR_EACH_ENTRY_SAFE_REV(node, next_node, list, struct hlsl_ir_node, entry)
        hlsl_free_instr(node);
}

Referenced by hlsl_block_cleanup().

◆ hlsl_free_ir_switch_case()

void hlsl_free_ir_switch_case ( struct hlsl_ir_switch_case * c )

Definition at line 2429 of file hlsl.c.

{
    hlsl_block_cleanup(&c->body);
    list_remove(&c->entry);
    vkd3d_free(c);
}

Referenced by hlsl_cleanup_ir_switch_cases(), and normalize_switch_cases().

◆ hlsl_free_state_block()

void hlsl_free_state_block ( struct hlsl_state_block * state_block )

Definition at line 150 of file hlsl.c.

{
    unsigned int k;
 
    VKD3D_ASSERT(state_block);
    for (k = 0; k < state_block->count; ++k)
        hlsl_free_state_block_entry(state_block->entries[k]);
    vkd3d_free(state_block->entries);
    vkd3d_free(state_block);
}

Referenced by free_ir_sampler_state(), hlsl_ctx_cleanup(), and hlsl_free_var().

◆ hlsl_free_state_block_entry()

void hlsl_free_state_block_entry ( struct hlsl_state_block_entry * state_block_entry )

Definition at line 137 of file hlsl.c.

{
    unsigned int i;
 
    vkd3d_free(entry->name);
    for (i = 0; i < entry->args_count; ++i)
        hlsl_src_remove(&entry->args[i]);
    vkd3d_free(entry->args);
    hlsl_block_cleanup(entry->instrs);
    vkd3d_free(entry->instrs);
    vkd3d_free(entry);
}

Referenced by clone_stateblock_entry(), decompose_fx_4_state_function_call(), and hlsl_free_state_block().

◆ hlsl_free_type()

void hlsl_free_type ( struct hlsl_type * type )

Definition at line 3643 of file hlsl.c.

{
    struct hlsl_struct_field *field;
    size_t i;
 
    vkd3d_free((void *)type->name);
    if (type->class == HLSL_CLASS_STRUCT)
    {
        for (i = 0; i < type->e.record.field_count; ++i)
        {
            field = &type->e.record.fields[i];
 
            vkd3d_free((void *)field->name);
            hlsl_cleanup_semantic(&field->semantic);
        }
        vkd3d_free((void *)type->e.record.fields);
    }
    vkd3d_free(type);
}

Referenced by hlsl_ctx_cleanup().

◆ hlsl_free_var()

void hlsl_free_var ( struct hlsl_ir_var * decl )

Definition at line 161 of file hlsl.c.

{
    unsigned int k, i;
 
    vkd3d_free((void *)decl->name);
    hlsl_cleanup_semantic(&decl->semantic);
    for (k = 0; k <= HLSL_REGSET_LAST_OBJECT; ++k)
        vkd3d_free((void *)decl->objects_usage[k]);
 
    if (decl->default_values)
    {
        unsigned int component_count = hlsl_type_component_count(decl->data_type);
 
        for (k = 0; k < component_count; ++k)
            vkd3d_free((void *)decl->default_values[k].string);
        vkd3d_free(decl->default_values);
    }
 
    for (i = 0; i < decl->state_block_count; ++i)
        hlsl_free_state_block(decl->state_blocks[i]);
    vkd3d_free(decl->state_blocks);
 
    vkd3d_free(decl);
}

Referenced by hlsl_ctx_cleanup().

◆ hlsl_get_element_type_from_path_index()

struct hlsl_type * hlsl_get_element_type_from_path_index	(	struct hlsl_ctx *	ctx,
		const struct hlsl_type *	type,
		struct hlsl_ir_node *	idx
	)

Definition at line 848 of file hlsl.c.

{
    VKD3D_ASSERT(idx);
 
    switch (type->class)
    {
        case HLSL_CLASS_VECTOR:
            return hlsl_get_scalar_type(ctx, type->e.numeric.type);
 
        case HLSL_CLASS_MATRIX:
            if (hlsl_type_is_row_major(type))
                return hlsl_get_vector_type(ctx, type->e.numeric.type, type->dimx);
            else
                return hlsl_get_vector_type(ctx, type->e.numeric.type, type->dimy);
 
        case HLSL_CLASS_ARRAY:
            return type->e.array.type;
 
        case HLSL_CLASS_STRUCT:
        {
            struct hlsl_ir_constant *c = hlsl_ir_constant(idx);
 
            VKD3D_ASSERT(c->value.u[0].u < type->e.record.field_count);
            return type->e.record.fields[c->value.u[0].u].type;
        }
 
        default:
            vkd3d_unreachable();
    }
}

Referenced by copy_propagation_invalidate_variable_from_deref_recurse(), hlsl_component_index_range_from_deref(), hlsl_deref_get_type(), hlsl_new_index(), hlsl_new_load_index(), hlsl_regset_index_from_deref(), lower_nonconstant_array_loads(), lower_nonconstant_vector_derefs(), new_offset_instr_from_deref(), validate_component_index_range_from_deref(), and validate_nonconstant_vector_store_derefs().

◆ hlsl_get_first_func_decl()

struct hlsl_ir_function_decl * hlsl_get_first_func_decl	(	struct hlsl_ctx *	ctx,
		const char *	name
	)

Definition at line 1028 of file hlsl.c.

{
    struct hlsl_ir_function *func;
    struct rb_entry *entry;
 
    if ((entry = rb_get(&ctx->functions, name)))
    {
        func = RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry);
        return LIST_ENTRY(list_head(&func->overloads), struct hlsl_ir_function_decl, entry);
    }
 
    return NULL;
}

Referenced by hlsl_compile_internal_function().

◆ hlsl_get_func_decl()

struct hlsl_ir_function_decl * hlsl_get_func_decl	(	struct hlsl_ctx *	ctx,
		const char *	name,
		const struct hlsl_func_parameters *	parameters
	)

Definition at line 2678 of file hlsl.c.

{
    struct hlsl_ir_function_decl *decl;
    struct hlsl_ir_function *func;
 
    if (!(func = hlsl_get_function(ctx, name)))
        return NULL;
 
    LIST_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry)
    {
        if (func_decl_matches(decl, parameters))
            return decl;
    }
 
    return NULL;
}

◆ hlsl_get_function()

struct hlsl_ir_function * hlsl_get_function	(	struct hlsl_ctx *	ctx,
		const char *	name
	)

Definition at line 1019 of file hlsl.c.

{
    struct rb_entry *entry;
 
    if ((entry = rb_get(&ctx->functions, name)))
        return RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry);
    return NULL;
}

Referenced by hlsl_compile_shader(), hlsl_get_func_decl(), and parse_patchconstantfunc_attribute().

◆ hlsl_get_matrix_type()

static struct hlsl_type * hlsl_get_matrix_type	(	const struct hlsl_ctx *	ctx,
		enum hlsl_base_type	base_type,
		unsigned int	dimx,
		unsigned int	dimy
	)

inlinestatic

Definition at line 1371 of file hlsl.h.

{
    return ctx->builtin_types.matrix[base_type][dimx - 1][dimy - 1];
}

Referenced by hlsl_get_numeric_type().

◆ hlsl_get_multiarray_element_type()

const struct hlsl_type * hlsl_get_multiarray_element_type ( const struct hlsl_type * type )

Definition at line 226 of file hlsl.c.

{
    if (type->class == HLSL_CLASS_ARRAY)
        return hlsl_get_multiarray_element_type(type->e.array.type);
    return type;
}

Referenced by decompose_fx_4_state_block_expand_array(), get_fx_4_type_size(), hlsl_get_multiarray_element_type(), is_numeric_fx_4_type(), is_supported_object_variable(), process_entry_function(), resolve_fx_4_state_block_values(), validate_field_semantic(), write_fx_2_default_value(), write_fx_2_initial_value(), write_fx_2_object_initializer(), write_fx_2_parameter(), write_fx_4_annotation(), write_fx_4_default_value(), write_fx_4_object_variable(), write_fx_4_type(), write_sm1_type(), write_sm4_type(), and write_type().

◆ hlsl_get_multiarray_size()

unsigned int hlsl_get_multiarray_size ( const struct hlsl_type * type )

Definition at line 233 of file hlsl.c.

{
    if (type->class == HLSL_CLASS_ARRAY)
        return hlsl_get_multiarray_size(type->e.array.type) * type->e.array.elements_count;
    return 1;
}

Referenced by get_fx_4_type_size(), hlsl_get_multiarray_size(), hlsl_type_calculate_reg_size(), write_fx_2_default_value(), write_fx_2_object_initializer(), write_fx_2_parameter(), write_fx_4_default_value(), write_fx_4_object_variable(), write_fx_4_shader_initializer(), write_fx_4_state_object_initializer(), write_fx_4_string_initializer(), write_fx_4_type(), write_fx_5_shader_initializer(), write_sm1_type(), write_sm4_type(), and write_type().

◆ hlsl_get_numeric_type()

static struct hlsl_type * hlsl_get_numeric_type	(	const struct hlsl_ctx *	ctx,
		enum hlsl_type_class	type,
		enum hlsl_base_type	base_type,
		unsigned int	dimx,
		unsigned int	dimy
	)

inlinestatic

Definition at line 1377 of file hlsl.h.

{
    if (type == HLSL_CLASS_SCALAR)
        return hlsl_get_scalar_type(ctx, base_type);
    else if (type == HLSL_CLASS_VECTOR)
        return hlsl_get_vector_type(ctx, base_type, dimx);
    else
        return hlsl_get_matrix_type(ctx, base_type, dimx, dimy);
}

Referenced by hlsl_add_conditional(), lower_discard_neg(), lower_float_modulus(), lower_int_division(), lower_int_modulus(), and lower_ternary().

◆ hlsl_get_scalar_type()

static struct hlsl_type * hlsl_get_scalar_type	(	const struct hlsl_ctx *	ctx,
		enum hlsl_base_type	base_type
	)

inlinestatic

Definition at line 1360 of file hlsl.h.

{
    return ctx->builtin_types.scalar[base_type];
}

Referenced by hlsl_get_element_type_from_path_index(), hlsl_get_numeric_type(), hlsl_new_bool_constant(), hlsl_new_float_constant(), hlsl_new_func_decl(), hlsl_new_int_constant(), hlsl_new_stateblock_constant(), hlsl_new_swizzle(), hlsl_new_uint_constant(), lower_broadcasts(), lower_discard_neg(), lower_nonconstant_array_loads(), resolve_fx_4_state_block_values(), traverse_path_from_component_index(), and write_fx_4_state_assignment().

◆ hlsl_get_string_buffer()

static struct vkd3d_string_buffer * hlsl_get_string_buffer ( struct hlsl_ctx * ctx )

inlinestatic

Definition at line 1346 of file hlsl.h.

{
    struct vkd3d_string_buffer *ret = vkd3d_string_buffer_get(&ctx->string_buffers);
 
    if (!ret)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ret;
}

Referenced by declare_predefined_types(), hlsl_compile_internal_function(), hlsl_component_to_string(), hlsl_fixme(), hlsl_modifiers_to_string(), hlsl_new_synthetic_var(), hlsl_sprintf_alloc(), hlsl_type_to_string(), and lower_combined_samples().

◆ hlsl_get_target_info()

const struct hlsl_profile_info * hlsl_get_target_info ( const char * target )

Definition at line 4054 of file hlsl.c.

{
    unsigned int i;
 
    static const struct hlsl_profile_info profiles[] =
    {
        {"cs_4_0",              VKD3D_SHADER_TYPE_COMPUTE,  4, 0, 0, 0, false},
        {"cs_4_1",              VKD3D_SHADER_TYPE_COMPUTE,  4, 1, 0, 0, false},
        {"cs_5_0",              VKD3D_SHADER_TYPE_COMPUTE,  5, 0, 0, 0, false},
        {"cs_5_1",              VKD3D_SHADER_TYPE_COMPUTE,  5, 1, 0, 0, false},
        {"ds_5_0",              VKD3D_SHADER_TYPE_DOMAIN,   5, 0, 0, 0, false},
        {"ds_5_1",              VKD3D_SHADER_TYPE_DOMAIN,   5, 1, 0, 0, false},
        {"fx_2_0",              VKD3D_SHADER_TYPE_EFFECT,   2, 0, 0, 0, false},
        {"fx_4_0",              VKD3D_SHADER_TYPE_EFFECT,   4, 0, 0, 0, false},
        {"fx_4_1",              VKD3D_SHADER_TYPE_EFFECT,   4, 1, 0, 0, false},
        {"fx_5_0",              VKD3D_SHADER_TYPE_EFFECT,   5, 0, 0, 0, false},
        {"gs_4_0",              VKD3D_SHADER_TYPE_GEOMETRY, 4, 0, 0, 0, false},
        {"gs_4_1",              VKD3D_SHADER_TYPE_GEOMETRY, 4, 1, 0, 0, false},
        {"gs_5_0",              VKD3D_SHADER_TYPE_GEOMETRY, 5, 0, 0, 0, false},
        {"gs_5_1",              VKD3D_SHADER_TYPE_GEOMETRY, 5, 1, 0, 0, false},
        {"hs_5_0",              VKD3D_SHADER_TYPE_HULL,     5, 0, 0, 0, false},
        {"hs_5_1",              VKD3D_SHADER_TYPE_HULL,     5, 1, 0, 0, false},
        {"ps.1.0",              VKD3D_SHADER_TYPE_PIXEL,    1, 0, 0, 0, false},
        {"ps.1.1",              VKD3D_SHADER_TYPE_PIXEL,    1, 1, 0, 0, false},
        {"ps.1.2",              VKD3D_SHADER_TYPE_PIXEL,    1, 2, 0, 0, false},
        {"ps.1.3",              VKD3D_SHADER_TYPE_PIXEL,    1, 3, 0, 0, false},
        {"ps.1.4",              VKD3D_SHADER_TYPE_PIXEL,    1, 4, 0, 0, false},
        {"ps.2.0",              VKD3D_SHADER_TYPE_PIXEL,    2, 0, 0, 0, false},
        {"ps.2.a",              VKD3D_SHADER_TYPE_PIXEL,    2, 1, 0, 0, false},
        {"ps.2.b",              VKD3D_SHADER_TYPE_PIXEL,    2, 2, 0, 0, false},
        {"ps.2.sw",             VKD3D_SHADER_TYPE_PIXEL,    2, 0, 0, 0, true},
        {"ps.3.0",              VKD3D_SHADER_TYPE_PIXEL,    3, 0, 0, 0, false},
        {"ps_1_0",              VKD3D_SHADER_TYPE_PIXEL,    1, 0, 0, 0, false},
        {"ps_1_1",              VKD3D_SHADER_TYPE_PIXEL,    1, 1, 0, 0, false},
        {"ps_1_2",              VKD3D_SHADER_TYPE_PIXEL,    1, 2, 0, 0, false},
        {"ps_1_3",              VKD3D_SHADER_TYPE_PIXEL,    1, 3, 0, 0, false},
        {"ps_1_4",              VKD3D_SHADER_TYPE_PIXEL,    1, 4, 0, 0, false},
        {"ps_2_0",              VKD3D_SHADER_TYPE_PIXEL,    2, 0, 0, 0, false},
        {"ps_2_a",              VKD3D_SHADER_TYPE_PIXEL,    2, 1, 0, 0, false},
        {"ps_2_b",              VKD3D_SHADER_TYPE_PIXEL,    2, 2, 0, 0, false},
        {"ps_2_sw",             VKD3D_SHADER_TYPE_PIXEL,    2, 0, 0, 0, true},
        {"ps_3_0",              VKD3D_SHADER_TYPE_PIXEL,    3, 0, 0, 0, false},
        {"ps_3_sw",             VKD3D_SHADER_TYPE_PIXEL,    3, 0, 0, 0, true},
        {"ps_4_0",              VKD3D_SHADER_TYPE_PIXEL,    4, 0, 0, 0, false},
        {"ps_4_0_level_9_0",    VKD3D_SHADER_TYPE_PIXEL,    4, 0, 9, 0, false},
        {"ps_4_0_level_9_1",    VKD3D_SHADER_TYPE_PIXEL,    4, 0, 9, 1, false},
        {"ps_4_0_level_9_3",    VKD3D_SHADER_TYPE_PIXEL,    4, 0, 9, 3, false},
        {"ps_4_1",              VKD3D_SHADER_TYPE_PIXEL,    4, 1, 0, 0, false},
        {"ps_5_0",              VKD3D_SHADER_TYPE_PIXEL,    5, 0, 0, 0, false},
        {"ps_5_1",              VKD3D_SHADER_TYPE_PIXEL,    5, 1, 0, 0, false},
        {"tx_1_0",              VKD3D_SHADER_TYPE_TEXTURE,  1, 0, 0, 0, false},
        {"vs.1.0",              VKD3D_SHADER_TYPE_VERTEX,   1, 0, 0, 0, false},
        {"vs.1.1",              VKD3D_SHADER_TYPE_VERTEX,   1, 1, 0, 0, false},
        {"vs.2.0",              VKD3D_SHADER_TYPE_VERTEX,   2, 0, 0, 0, false},
        {"vs.2.a",              VKD3D_SHADER_TYPE_VERTEX,   2, 1, 0, 0, false},
        {"vs.2.sw",             VKD3D_SHADER_TYPE_VERTEX,   2, 0, 0, 0, true},
        {"vs.3.0",              VKD3D_SHADER_TYPE_VERTEX,   3, 0, 0, 0, false},
        {"vs.3.sw",             VKD3D_SHADER_TYPE_VERTEX,   3, 0, 0, 0, true},
        {"vs_1_0",              VKD3D_SHADER_TYPE_VERTEX,   1, 0, 0, 0, false},
        {"vs_1_1",              VKD3D_SHADER_TYPE_VERTEX,   1, 1, 0, 0, false},
        {"vs_2_0",              VKD3D_SHADER_TYPE_VERTEX,   2, 0, 0, 0, false},
        {"vs_2_a",              VKD3D_SHADER_TYPE_VERTEX,   2, 1, 0, 0, false},
        {"vs_2_sw",             VKD3D_SHADER_TYPE_VERTEX,   2, 0, 0, 0, true},
        {"vs_3_0",              VKD3D_SHADER_TYPE_VERTEX,   3, 0, 0, 0, false},
        {"vs_3_sw",             VKD3D_SHADER_TYPE_VERTEX,   3, 0, 0, 0, true},
        {"vs_4_0",              VKD3D_SHADER_TYPE_VERTEX,   4, 0, 0, 0, false},
        {"vs_4_0_level_9_0",    VKD3D_SHADER_TYPE_VERTEX,   4, 0, 9, 0, false},
        {"vs_4_0_level_9_1",    VKD3D_SHADER_TYPE_VERTEX,   4, 0, 9, 1, false},
        {"vs_4_0_level_9_3",    VKD3D_SHADER_TYPE_VERTEX,   4, 0, 9, 3, false},
        {"vs_4_1",              VKD3D_SHADER_TYPE_VERTEX,   4, 1, 0, 0, false},
        {"vs_5_0",              VKD3D_SHADER_TYPE_VERTEX,   5, 0, 0, 0, false},
        {"vs_5_1",              VKD3D_SHADER_TYPE_VERTEX,   5, 1, 0, 0, false},
    };
 
    for (i = 0; i < ARRAY_SIZE(profiles); ++i)
    {
        if (!strcmp(target, profiles[i].name))
            return &profiles[i];
    }
 
    return NULL;
}

Referenced by hlsl_compile_shader(), and hlsl_new_compile().

◆ hlsl_get_type()

struct hlsl_type * hlsl_get_type	(	struct hlsl_scope *	scope,
		const char *	name,
		bool	recursive,
		bool	case_insensitive
	)

Definition at line 995 of file hlsl.c.

{
    struct rb_entry *entry = rb_get(&scope->types, name);
 
    if (entry)
        return RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
 
    if (scope->upper)
    {
        if (recursive)
            return hlsl_get_type(scope->upper, name, recursive, case_insensitive);
    }
    else
    {
        if (case_insensitive && (name = get_case_insensitive_typename(name)))
        {
            if ((entry = rb_get(&scope->types, name)))
                return RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
        }
    }
 
    return NULL;
}

Referenced by hlsl_get_type(), hlsl_new_compile(), and hlsl_scope_add_type().

◆ hlsl_get_var()

struct hlsl_ir_var * hlsl_get_var	(	struct hlsl_scope *	scope,
		const char *	name
	)

Definition at line 123 of file hlsl.c.

{
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
    {
        if (var->name && !strcmp(name, var->name))
            return var;
    }
    if (!scope->upper)
        return NULL;
    return hlsl_get_var(scope->upper, name);
}

Referenced by hlsl_get_var(), and lower_combined_samples().

◆ hlsl_get_vector_type()

static struct hlsl_type * hlsl_get_vector_type	(	const struct hlsl_ctx *	ctx,
		enum hlsl_base_type	base_type,
		unsigned int	dimx
	)

inlinestatic

Definition at line 1365 of file hlsl.h.

{
    return ctx->builtin_types.vector[base_type][dimx - 1];
}

Referenced by add_zero_mipmap_level(), allocate_sincos_const_registers(), append_output_copy(), hlsl_get_element_type_from_path_index(), hlsl_get_numeric_type(), hlsl_new_index(), hlsl_new_swizzle(), lower_cmp(), lower_combined_samples(), lower_comparison_operators(), lower_discard_nz(), lower_logic_not(), lower_narrowing_casts(), lower_nonconstant_vector_derefs(), lower_nonfloat_exprs(), lower_slt(), prepend_input_copy(), resolve_fx_4_state_block_values(), split_matrix_copies(), and traverse_path_from_component_index().

◆ hlsl_index_chain_has_resource_access()

bool hlsl_index_chain_has_resource_access ( struct hlsl_ir_index * index )

Definition at line 2013 of file hlsl.c.

{
    if (hlsl_index_is_resource_access(index))
        return true;
    if (index->val.node->type == HLSL_IR_INDEX)
        return hlsl_index_chain_has_resource_access(hlsl_ir_index(index->val.node));
    return false;
}

Referenced by hlsl_index_chain_has_resource_access().

◆ hlsl_index_is_noncontiguous()

bool hlsl_index_is_noncontiguous ( struct hlsl_ir_index * index )

Definition at line 1999 of file hlsl.c.

{
    struct hlsl_type *type = index->val.node->data_type;
 
    return type->class == HLSL_CLASS_MATRIX && !hlsl_type_is_row_major(type);
}

Referenced by hlsl_init_deref_from_index_chain(), and lower_index_loads().

◆ hlsl_index_is_resource_access()

bool hlsl_index_is_resource_access ( struct hlsl_ir_index * index )

Definition at line 2006 of file hlsl.c.

{
    const struct hlsl_type *type = index->val.node->data_type;
 
    return type->class == HLSL_CLASS_TEXTURE || type->class == HLSL_CLASS_UAV;
}

Referenced by hlsl_index_chain_has_resource_access(), and lower_index_loads().

◆ hlsl_init_deref_from_index_chain()

bool hlsl_init_deref_from_index_chain	(	struct hlsl_ctx *	ctx,
		struct hlsl_deref *	deref,
		struct hlsl_ir_node *	chain
	)

Definition at line 717 of file hlsl.c.

{
    struct hlsl_ir_index *index;
    struct hlsl_ir_load *load;
    unsigned int chain_len, i;
    struct hlsl_ir_node *ptr;
 
    deref->path = NULL;
    deref->path_len = 0;
    deref->rel_offset.node = NULL;
    deref->const_offset = 0;
 
    VKD3D_ASSERT(chain);
    if (chain->type == HLSL_IR_INDEX)
        VKD3D_ASSERT(!hlsl_index_is_noncontiguous(hlsl_ir_index(chain)));
 
    /* Find the length of the index chain */
    chain_len = 0;
    ptr = chain;
    while (ptr->type == HLSL_IR_INDEX)
    {
        index = hlsl_ir_index(ptr);
 
        chain_len++;
        ptr = index->val.node;
    }
 
    if (ptr->type != HLSL_IR_LOAD)
    {
        hlsl_error(ctx, &chain->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_LVALUE, "Invalid l-value.");
        return false;
    }
    load = hlsl_ir_load(ptr);
 
    if (!init_deref(ctx, deref, load->src.var, load->src.path_len + chain_len))
        return false;
 
    for (i = 0; i < load->src.path_len; ++i)
        hlsl_src_from_node(&deref->path[i], load->src.path[i].node);
 
    chain_len = 0;
    ptr = chain;
    while (ptr->type == HLSL_IR_INDEX)
    {
        unsigned int p = deref->path_len - 1 - chain_len;
 
        index = hlsl_ir_index(ptr);
        if (hlsl_index_is_noncontiguous(index))
        {
            hlsl_src_from_node(&deref->path[p], deref->path[p + 1].node);
            hlsl_src_remove(&deref->path[p + 1]);
            hlsl_src_from_node(&deref->path[p + 1], index->idx.node);
        }
        else
        {
            hlsl_src_from_node(&deref->path[p], index->idx.node);
        }
 
        chain_len++;
        ptr = index->val.node;
    }
    VKD3D_ASSERT(deref->path_len == load->src.path_len + chain_len);
 
    return true;
}

Referenced by hlsl_new_resource_load().

◆ hlsl_init_simple_deref_from_var()

void hlsl_init_simple_deref_from_var	(	struct hlsl_deref *	deref,
		struct hlsl_ir_var *	var
	)

Definition at line 1424 of file hlsl.c.

{
    memset(deref, 0, sizeof(*deref));
    deref->var = var;
}

Referenced by add_zero_mipmap_level(), hlsl_new_simple_store(), hlsl_new_var_load(), lower_index_loads(), lower_matrix_swizzles(), and lower_trig().

◆ hlsl_ir_call()

static struct hlsl_ir_call * hlsl_ir_call ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1160 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_CALL);
    return CONTAINING_RECORD(node, struct hlsl_ir_call, node);
}

◆ hlsl_ir_compile()

static struct hlsl_ir_compile * hlsl_ir_compile ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1244 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_COMPILE);
    return CONTAINING_RECORD(node, struct hlsl_ir_compile, node);
}

◆ hlsl_ir_constant()

static struct hlsl_ir_constant * hlsl_ir_constant ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1166 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_CONSTANT);
    return CONTAINING_RECORD(node, struct hlsl_ir_constant, node);
}

◆ hlsl_ir_expr()

static struct hlsl_ir_expr * hlsl_ir_expr ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1178 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_EXPR);
    return CONTAINING_RECORD(node, struct hlsl_ir_expr, node);
}

◆ hlsl_ir_if()

static struct hlsl_ir_if * hlsl_ir_if ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1184 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_IF);
    return CONTAINING_RECORD(node, struct hlsl_ir_if, node);
}

◆ hlsl_ir_index()

static struct hlsl_ir_index * hlsl_ir_index ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1232 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_INDEX);
    return CONTAINING_RECORD(node, struct hlsl_ir_index, node);
}

◆ hlsl_ir_jump()

static struct hlsl_ir_jump * hlsl_ir_jump ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1190 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_JUMP);
    return CONTAINING_RECORD(node, struct hlsl_ir_jump, node);
}

◆ hlsl_ir_load()

static struct hlsl_ir_load * hlsl_ir_load ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1196 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_LOAD);
    return CONTAINING_RECORD(node, struct hlsl_ir_load, node);
}

◆ hlsl_ir_loop()

static struct hlsl_ir_loop * hlsl_ir_loop ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1202 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_LOOP);
    return CONTAINING_RECORD(node, struct hlsl_ir_loop, node);
}

◆ hlsl_ir_resource_load()

static struct hlsl_ir_resource_load * hlsl_ir_resource_load ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1208 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_RESOURCE_LOAD);
    return CONTAINING_RECORD(node, struct hlsl_ir_resource_load, node);
}

◆ hlsl_ir_resource_store()

static struct hlsl_ir_resource_store * hlsl_ir_resource_store ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1214 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_RESOURCE_STORE);
    return CONTAINING_RECORD(node, struct hlsl_ir_resource_store, node);
}

◆ hlsl_ir_sampler_state()

static struct hlsl_ir_sampler_state * hlsl_ir_sampler_state ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1250 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_SAMPLER_STATE);
    return CONTAINING_RECORD(node, struct hlsl_ir_sampler_state, node);
};

◆ hlsl_ir_stateblock_constant()

static struct hlsl_ir_stateblock_constant * hlsl_ir_stateblock_constant ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1256 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_STATEBLOCK_CONSTANT);
    return CONTAINING_RECORD(node, struct hlsl_ir_stateblock_constant, node);
}

◆ hlsl_ir_store()

static struct hlsl_ir_store * hlsl_ir_store ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1220 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_STORE);
    return CONTAINING_RECORD(node, struct hlsl_ir_store, node);
}

◆ hlsl_ir_string_constant()

static struct hlsl_ir_string_constant * hlsl_ir_string_constant ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1172 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_STRING_CONSTANT);
    return CONTAINING_RECORD(node, struct hlsl_ir_string_constant, node);
}

◆ hlsl_ir_switch()

static struct hlsl_ir_switch * hlsl_ir_switch ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1238 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_SWITCH);
    return CONTAINING_RECORD(node, struct hlsl_ir_switch, node);
}

◆ hlsl_ir_swizzle()

static struct hlsl_ir_swizzle * hlsl_ir_swizzle ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1226 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_SWIZZLE);
    return CONTAINING_RECORD(node, struct hlsl_ir_swizzle, node);
}

◆ hlsl_ir_vsir_instruction_ref()

static struct hlsl_ir_vsir_instruction_ref * hlsl_ir_vsir_instruction_ref ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1262 of file hlsl.h.

{
    VKD3D_ASSERT(node->type == HLSL_IR_VSIR_INSTRUCTION_REF);
    return CONTAINING_RECORD(node, struct hlsl_ir_vsir_instruction_ref, node);
}

◆ hlsl_is_numeric_type()

static bool hlsl_is_numeric_type ( const struct hlsl_type * type )

inlinestatic

Definition at line 1388 of file hlsl.h.

{
    return type->class <= HLSL_CLASS_LAST_NUMERIC;
}

Referenced by allocate_const_registers_recurse(), append_output_copy(), copy_propagation_record_store(), hlsl_new_swizzle(), hlsl_reg_from_deref(), hlsl_type_to_string(), is_numeric_fx_4_type(), prepend_input_copy(), validate_field_semantic(), write_fx_2_parameter(), write_fx_4_annotation(), write_fx_4_type(), and write_sm4_load().

◆ hlsl_jump_type_to_string()

const char * hlsl_jump_type_to_string ( enum hlsl_ir_jump_type type )

Definition at line 2979 of file hlsl.c.

{
    static const char * const names[] =
    {
        [HLSL_IR_JUMP_BREAK]       = "HLSL_IR_JUMP_BREAK",
        [HLSL_IR_JUMP_CONTINUE]    = "HLSL_IR_JUMP_CONTINUE",
        [HLSL_IR_JUMP_DISCARD_NEG] = "HLSL_IR_JUMP_DISCARD_NEG",
        [HLSL_IR_JUMP_DISCARD_NZ]  = "HLSL_IR_JUMP_DISCARD_NZ",
        [HLSL_IR_JUMP_RETURN]      = "HLSL_IR_JUMP_RETURN",
    };
 
    VKD3D_ASSERT(type < ARRAY_SIZE(names));
    return names[type];
}

Referenced by sm1_generate_vsir_instr_jump(), and write_sm4_jump().

◆ hlsl_lexer_compile()

int hlsl_lexer_compile	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_code *	hlsl
	)

Referenced by hlsl_compile_internal_function(), and hlsl_compile_shader().

◆ hlsl_lower_index_loads()

void hlsl_lower_index_loads	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	body
	)

Definition at line 6392 of file hlsl_codegen.c.

{
    lower_ir(ctx, lower_index_loads, body);
}

◆ hlsl_map_swizzle()

uint32_t hlsl_map_swizzle	(	uint32_t	swizzle,
		unsigned int	writemask
	)

Definition at line 3978 of file hlsl.c.

{
    uint32_t ret = 0;
    unsigned int i;
 
    /* Leave replicate swizzles alone; some instructions need them. */
    if (swizzle == HLSL_SWIZZLE(X, X, X, X)
            || swizzle == HLSL_SWIZZLE(Y, Y, Y, Y)
            || swizzle == HLSL_SWIZZLE(Z, Z, Z, Z)
            || swizzle == HLSL_SWIZZLE(W, W, W, W))
        return swizzle;
 
    for (i = 0; i < 4; ++i)
    {
        if (writemask & (1 << i))
        {
            ret |= (swizzle & 3) << (i * 2);
            swizzle >>= 2;
        }
    }
    return ret;
}

Referenced by generate_vsir_get_src_swizzle(), generate_vsir_instr_swizzle(), sm4_src_from_deref(), sm4_src_from_node(), and write_sm4_swizzle().

◆ hlsl_modifiers_to_string()

struct vkd3d_string_buffer * hlsl_modifiers_to_string	(	struct hlsl_ctx *	ctx,
		unsigned int	modifiers
	)

◆ hlsl_new_array_type()

struct hlsl_type * hlsl_new_array_type	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	basic_type,
		unsigned int	array_size
	)

Definition at line 880 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
 
    type->class = HLSL_CLASS_ARRAY;
    type->modifiers = basic_type->modifiers;
    type->e.array.elements_count = array_size;
    type->e.array.type = basic_type;
    type->dimx = basic_type->dimx;
    type->dimy = basic_type->dimy;
    type->sampler_dim = basic_type->sampler_dim;
    hlsl_type_calculate_reg_size(ctx, type);
 
    list_add_tail(&ctx->types, &type->entry);
 
    return type;
}

Referenced by lower_combined_samples().

◆ hlsl_new_binary_expr()

struct hlsl_ir_node * hlsl_new_binary_expr	(	struct hlsl_ctx *	ctx,
		enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	arg1,
		struct hlsl_ir_node *	arg2
	)

Definition at line 1619 of file hlsl.c.

{
    struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS] = {arg1, arg2};
 
    return hlsl_new_expr(ctx, op, operands, arg1->data_type, &arg1->loc);
}

Referenced by lower_abs(), lower_casts_to_bool(), lower_ceil(), lower_cmp(), lower_comparison_operators(), lower_discard_neg(), lower_division(), lower_dot(), lower_float_modulus(), lower_floor(), lower_int_abs(), lower_int_division(), lower_int_dot(), lower_int_modulus(), lower_logic_not(), lower_round(), lower_slt(), new_offset_from_path_index(), and resolve_fx_4_state_block_values().

◆ hlsl_new_bool_constant()

struct hlsl_ir_node * hlsl_new_bool_constant	(	struct hlsl_ctx *	ctx,
		bool	b,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1537 of file hlsl.c.

{
    struct hlsl_constant_value value;
 
    value.u[0].u = b ? ~0u : 0;
    return hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_BOOL), &value, loc);
}

Referenced by hlsl_new_func_decl(), and lower_return().

◆ hlsl_new_buffer()

struct hlsl_buffer * hlsl_new_buffer	(	struct hlsl_ctx *	ctx,
		enum hlsl_buffer_type	type,
		const char *	name,
		uint32_t	modifiers,
		const struct hlsl_reg_reservation *	reservation,
		struct hlsl_scope *	annotations,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 2594 of file hlsl.c.

{
    struct hlsl_buffer *buffer;
 
    if (!(buffer = hlsl_alloc(ctx, sizeof(*buffer))))
        return NULL;
    buffer->type = type;
    buffer->name = name;
    buffer->modifiers = modifiers;
    if (reservation)
        buffer->reservation = *reservation;
    buffer->annotations = annotations;
    buffer->loc = *loc;
    list_add_tail(&ctx->buffers, &buffer->entry);
    return buffer;
}

Referenced by hlsl_ctx_init().

◆ hlsl_new_call()

struct hlsl_ir_node * hlsl_new_call	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_function_decl *	decl,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1508 of file hlsl.c.

{
    struct hlsl_ir_call *call;
 
    if (!(call = hlsl_alloc(ctx, sizeof(*call))))
        return NULL;
 
    init_node(&call->node, HLSL_IR_CALL, NULL, loc);
    call->decl = decl;
    return &call->node;
}

Referenced by clone_call(), lower_f16tof32(), and lower_f32tof16().

◆ hlsl_new_cast()

struct hlsl_ir_node * hlsl_new_cast	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	node,
		struct hlsl_type *	type,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1294 of file hlsl.c.

{
    struct hlsl_ir_node *cast;
 
    cast = hlsl_new_unary_expr(ctx, HLSL_OP1_CAST, node, loc);
    if (cast)
        cast->data_type = type;
    return cast;
}

Referenced by hlsl_add_conditional(), hlsl_new_copy(), lower_broadcasts(), lower_cmp(), lower_comparison_operators(), lower_discard_nz(), lower_int_division(), lower_int_modulus(), lower_logic_not(), lower_narrowing_casts(), lower_nonconstant_vector_derefs(), lower_nonfloat_exprs(), lower_slt(), lower_ternary(), prepend_input_copy(), and resolve_fx_4_state_block_values().

◆ hlsl_new_cb_type()

struct hlsl_type * hlsl_new_cb_type	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	format
	)

Definition at line 956 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
    type->class = HLSL_CLASS_CONSTANT_BUFFER;
    type->dimy = 1;
    type->e.resource.format = format;
    hlsl_type_calculate_reg_size(ctx, type);
    list_add_tail(&ctx->types, &type->entry);
    return type;
}

◆ hlsl_new_compile()

struct hlsl_ir_node * hlsl_new_compile	(	struct hlsl_ctx *	ctx,
		enum hlsl_compile_type	compile_type,
		const char *	profile_name,
		struct hlsl_ir_node **	args,
		unsigned int	args_count,
		struct hlsl_block *	args_instrs,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1866 of file hlsl.c.

{
    const struct hlsl_profile_info *profile_info = NULL;
    struct hlsl_ir_compile *compile;
    struct hlsl_type *type = NULL;
    unsigned int i;
 
    switch (compile_type)
    {
        case HLSL_COMPILE_TYPE_COMPILE:
            if (!(profile_info = hlsl_get_target_info(profile_name)))
            {
                hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_PROFILE, "Unknown profile \"%s\".", profile_name);
                return NULL;
            }
 
            if (profile_info->type == VKD3D_SHADER_TYPE_PIXEL)
                type = hlsl_get_type(ctx->cur_scope, "PixelShader", true, true);
            else if (profile_info->type == VKD3D_SHADER_TYPE_VERTEX)
                type = hlsl_get_type(ctx->cur_scope, "VertexShader", true, true);
 
            if (!type)
            {
                hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_PROFILE, "Invalid profile \"%s\".", profile_name);
                return NULL;
            }
 
            break;
 
        case HLSL_COMPILE_TYPE_CONSTRUCTGSWITHSO:
            type = hlsl_get_type(ctx->cur_scope, "GeometryShader", true, true);
            break;
    }
 
    if (!(compile = hlsl_alloc(ctx, sizeof(*compile))))
        return NULL;
 
    init_node(&compile->node, HLSL_IR_COMPILE, type, loc);
 
    compile->compile_type = compile_type;
    compile->profile = profile_info;
 
    hlsl_block_init(&compile->instrs);
    hlsl_block_add_block(&compile->instrs, args_instrs);
 
    compile->args_count = args_count;
    if (!(compile->args = hlsl_alloc(ctx, sizeof(*compile->args) * args_count)))
    {
        vkd3d_free(compile);
        return NULL;
    }
    for (i = 0; i < compile->args_count; ++i)
        hlsl_src_from_node(&compile->args[i], args[i]);
 
    return &compile->node;
}

Referenced by clone_compile().

◆ hlsl_new_constant()

struct hlsl_ir_node * hlsl_new_constant	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	type,
		const struct hlsl_constant_value *	value,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1521 of file hlsl.c.

{
    struct hlsl_ir_constant *c;
 
    VKD3D_ASSERT(type->class <= HLSL_CLASS_VECTOR || type->class == HLSL_CLASS_NULL);
 
    if (!(c = hlsl_alloc(ctx, sizeof(*c))))
        return NULL;
 
    init_node(&c->node, HLSL_IR_CONSTANT, type, loc);
    c->value = *value;
 
    return &c->node;
}

Referenced by clone_constant(), copy_propagation_replace_with_constant_vector(), hlsl_fold_constant_exprs(), hlsl_fold_constant_swizzles(), hlsl_new_bool_constant(), hlsl_new_float_constant(), hlsl_new_int_constant(), hlsl_new_null_constant(), hlsl_new_uint_constant(), lower_casts_to_bool(), lower_cmp(), lower_comparison_operators(), lower_discard_neg(), lower_float_modulus(), lower_int_division(), lower_int_modulus(), lower_logic_not(), lower_nonconstant_array_loads(), lower_nonconstant_vector_derefs(), lower_round(), lower_slt(), and lower_trig().

◆ hlsl_new_copy()

struct hlsl_ir_node * hlsl_new_copy	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	node
	)

Definition at line 1305 of file hlsl.c.

{
    /* Use a cast to the same type as a makeshift identity expression. */
    return hlsl_new_cast(ctx, node, node->data_type, &node->loc);
}

◆ hlsl_new_expr()

struct hlsl_ir_node * hlsl_new_expr	(	struct hlsl_ctx *	ctx,
		enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	operands[HLSL_MAX_OPERANDS],
		struct hlsl_type *	data_type,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1595 of file hlsl.c.

{
    struct hlsl_ir_expr *expr;
    unsigned int i;
 
    if (!(expr = hlsl_alloc(ctx, sizeof(*expr))))
        return NULL;
    init_node(&expr->node, HLSL_IR_EXPR, data_type, loc);
    expr->op = op;
    for (i = 0; i < HLSL_MAX_OPERANDS; ++i)
        hlsl_src_from_node(&expr->operands[i], operands[i]);
    return &expr->node;
}

Referenced by clone_expr(), hlsl_add_conditional(), hlsl_new_binary_expr(), hlsl_new_error_expr(), hlsl_new_ternary_expr(), hlsl_new_unary_expr(), lower_casts_to_int(), lower_comparison_operators(), lower_discard_neg(), lower_dot(), lower_logic_not(), lower_nonconstant_array_loads(), lower_nonconstant_vector_derefs(), lower_nonfloat_exprs(), and lower_ternary().

◆ hlsl_new_float_constant()

struct hlsl_ir_node * hlsl_new_float_constant	(	struct hlsl_ctx *	ctx,
		float	f,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1545 of file hlsl.c.

{
    struct hlsl_constant_value value;
 
    value.u[0].f = f;
    return hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_FLOAT), &value, loc);
}

Referenced by lower_dot().

◆ hlsl_new_func_decl()

struct hlsl_ir_function_decl * hlsl_new_func_decl	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	return_type,
		const struct hlsl_func_parameters *	parameters,
		const struct hlsl_semantic *	semantic,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 2554 of file hlsl.c.

{
    struct hlsl_ir_node *constant, *store;
    struct hlsl_ir_function_decl *decl;
 
    if (!(decl = hlsl_alloc(ctx, sizeof(*decl))))
        return NULL;
    hlsl_block_init(&decl->body);
    decl->return_type = return_type;
    decl->parameters = *parameters;
    decl->loc = *loc;
    list_init(&decl->extern_vars);
 
    if (!hlsl_types_are_equal(return_type, ctx->builtin_types.Void))
    {
        if (!(decl->return_var = hlsl_new_synthetic_var(ctx, "retval", return_type, loc)))
        {
            vkd3d_free(decl);
            return NULL;
        }
        decl->return_var->semantic = *semantic;
    }
 
    if (!(decl->early_return_var = hlsl_new_synthetic_var(ctx, "early_return",
            hlsl_get_scalar_type(ctx, HLSL_TYPE_BOOL), loc)))
        return decl;
 
    if (!(constant = hlsl_new_bool_constant(ctx, false, loc)))
        return decl;
    hlsl_block_add_instr(&decl->body, constant);
 
    if (!(store = hlsl_new_simple_store(ctx, decl->early_return_var, constant)))
        return decl;
    hlsl_block_add_instr(&decl->body, store);
 
    return decl;
}

◆ hlsl_new_if()

struct hlsl_ir_node * hlsl_new_if	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	condition,
		struct hlsl_block *	then_block,
		struct hlsl_block *	else_block,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1647 of file hlsl.c.

{
    struct hlsl_ir_if *iff;
 
    if (!(iff = hlsl_alloc(ctx, sizeof(*iff))))
        return NULL;
    init_node(&iff->node, HLSL_IR_IF, NULL, loc);
    hlsl_src_from_node(&iff->condition, condition);
    hlsl_block_init(&iff->then_block);
    hlsl_block_add_block(&iff->then_block, then_block);
    hlsl_block_init(&iff->else_block);
    if (else_block)
        hlsl_block_add_block(&iff->else_block, else_block);
    return &iff->node;
}

Referenced by clone_if(), insert_early_return_break(), and lower_return().

◆ hlsl_new_index()

struct hlsl_ir_node * hlsl_new_index	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	val,
		struct hlsl_ir_node *	idx,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 2022 of file hlsl.c.

{
    struct hlsl_type *type = val->data_type;
    struct hlsl_ir_index *index;
 
    if (!(index = hlsl_alloc(ctx, sizeof(*index))))
        return NULL;
 
    if (type->class == HLSL_CLASS_TEXTURE || type->class == HLSL_CLASS_UAV)
        type = type->e.resource.format;
    else if (type->class == HLSL_CLASS_MATRIX)
        type = hlsl_get_vector_type(ctx, type->e.numeric.type, type->dimx);
    else
        type = hlsl_get_element_type_from_path_index(ctx, type, idx);
 
    init_node(&index->node, HLSL_IR_INDEX, type, loc);
    hlsl_src_from_node(&index->val, val);
    hlsl_src_from_node(&index->idx, idx);
    return &index->node;
}

Referenced by clone_index().

◆ hlsl_new_int_constant()

struct hlsl_ir_node * hlsl_new_int_constant	(	struct hlsl_ctx *	ctx,
		int32_t	n,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1554 of file hlsl.c.

{
    struct hlsl_constant_value value;
 
    value.u[0].i = n;
    return hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_INT), &value, loc);
}

◆ hlsl_new_jump()

struct hlsl_ir_node * hlsl_new_jump	(	struct hlsl_ctx *	ctx,
		enum hlsl_ir_jump_type	type,
		struct hlsl_ir_node *	condition,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 2044 of file hlsl.c.

{
    struct hlsl_ir_jump *jump;
 
    if (!(jump = hlsl_alloc(ctx, sizeof(*jump))))
        return NULL;
    init_node(&jump->node, HLSL_IR_JUMP, NULL, loc);
    jump->type = type;
    hlsl_src_from_node(&jump->condition, condition);
    return &jump->node;
}

Referenced by clone_jump(), insert_early_return_break(), and normalize_switch_cases().

◆ hlsl_new_load_component()

struct hlsl_ir_node * hlsl_new_load_component	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block,
		const struct hlsl_deref *	deref,
		unsigned int	comp,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1766 of file hlsl.c.

{
    struct hlsl_type *type, *comp_type;
    struct hlsl_block comp_path_block;
    struct hlsl_ir_load *load;
 
    hlsl_block_init(block);
 
    if (!(load = hlsl_alloc(ctx, sizeof(*load))))
        return NULL;
 
    type = hlsl_deref_get_type(ctx, deref);
    comp_type = hlsl_type_get_component_type(ctx, type, comp);
    init_node(&load->node, HLSL_IR_LOAD, comp_type, loc);
 
    if (!init_deref_from_component_index(ctx, &comp_path_block, &load->src, deref, comp, loc))
    {
        vkd3d_free(load);
        return NULL;
    }
    hlsl_block_add_block(block, &comp_path_block);
 
    hlsl_block_add_instr(block, &load->node);
 
    return &load->node;
}

◆ hlsl_new_load_index()

struct hlsl_ir_load * hlsl_new_load_index	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref,
		struct hlsl_ir_node *	idx,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1714 of file hlsl.c.

{
    struct hlsl_ir_load *load;
    struct hlsl_type *type;
    unsigned int i;
 
    VKD3D_ASSERT(!hlsl_deref_is_lowered(deref));
 
    type = hlsl_deref_get_type(ctx, deref);
    if (idx)
        type = hlsl_get_element_type_from_path_index(ctx, type, idx);
 
    if (!(load = hlsl_alloc(ctx, sizeof(*load))))
        return NULL;
    init_node(&load->node, HLSL_IR_LOAD, type, loc);
 
    if (!init_deref(ctx, &load->src, deref->var, deref->path_len + !!idx))
    {
        vkd3d_free(load);
        return NULL;
    }
    for (i = 0; i < deref->path_len; ++i)
        hlsl_src_from_node(&load->src.path[i], deref->path[i].node);
    if (idx)
        hlsl_src_from_node(&load->src.path[deref->path_len], idx);
 
    return load;
}

Referenced by append_output_copy(), append_output_copy_recurse(), hlsl_new_load_parent(), hlsl_new_var_load(), lower_index_loads(), lower_nonconstant_array_loads(), lower_trig(), prepend_input_copy_recurse(), and split_copy().

◆ hlsl_new_load_parent()

struct hlsl_ir_load * hlsl_new_load_parent	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1744 of file hlsl.c.

{
    /* This deref can only exists temporarily because it is not the real owner of its members. */
    struct hlsl_deref tmp_deref;
 
    VKD3D_ASSERT(deref->path_len >= 1);
 
    tmp_deref = *deref;
    tmp_deref.path_len = deref->path_len - 1;
    return hlsl_new_load_index(ctx, &tmp_deref, NULL, loc);
}

Referenced by lower_nonconstant_vector_derefs().

◆ hlsl_new_loop()

struct hlsl_ir_node * hlsl_new_loop	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block,
		enum hlsl_ir_loop_unroll_type	unroll_type,
		unsigned int	unroll_limit,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 2057 of file hlsl.c.

{
    struct hlsl_ir_loop *loop;
 
    if (!(loop = hlsl_alloc(ctx, sizeof(*loop))))
        return NULL;
    init_node(&loop->node, HLSL_IR_LOOP, NULL, loc);
    hlsl_block_init(&loop->body);
    hlsl_block_add_block(&loop->body, block);
 
    loop->unroll_type = unroll_type;
    loop->unroll_limit = unroll_limit;
    return &loop->node;
}

Referenced by clone_loop().

◆ hlsl_new_null_constant()

struct hlsl_ir_node * hlsl_new_null_constant	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1589 of file hlsl.c.

{
    struct hlsl_constant_value value = { 0 };
    return hlsl_new_constant(ctx, ctx->builtin_types.null, &value, loc);
}

◆ hlsl_new_resource_load()

struct hlsl_ir_node * hlsl_new_resource_load	(	struct hlsl_ctx *	ctx,
		const struct hlsl_resource_load_params *	params,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1794 of file hlsl.c.

{
    struct hlsl_ir_resource_load *load;
 
    if (!(load = hlsl_alloc(ctx, sizeof(*load))))
        return NULL;
    init_node(&load->node, HLSL_IR_RESOURCE_LOAD, params->format, loc);
    load->load_type = params->type;
 
    if (!hlsl_init_deref_from_index_chain(ctx, &load->resource, params->resource))
    {
        vkd3d_free(load);
        return NULL;
    }
 
    if (params->sampler)
    {
        if (!hlsl_init_deref_from_index_chain(ctx, &load->sampler, params->sampler))
        {
            hlsl_cleanup_deref(&load->resource);
            vkd3d_free(load);
            return NULL;
        }
    }
 
    hlsl_src_from_node(&load->coords, params->coords);
    hlsl_src_from_node(&load->sample_index, params->sample_index);
    hlsl_src_from_node(&load->texel_offset, params->texel_offset);
    hlsl_src_from_node(&load->lod, params->lod);
    hlsl_src_from_node(&load->ddx, params->ddx);
    hlsl_src_from_node(&load->ddy, params->ddy);
    hlsl_src_from_node(&load->cmp, params->cmp);
    load->sampling_dim = params->sampling_dim;
    if (load->sampling_dim == HLSL_SAMPLER_DIM_GENERIC)
        load->sampling_dim = hlsl_deref_get_type(ctx, &load->resource)->sampler_dim;
    return &load->node;
}

Referenced by lower_index_loads().

◆ hlsl_new_resource_store()

struct hlsl_ir_node * hlsl_new_resource_store	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	resource,
		struct hlsl_ir_node *	coords,
		struct hlsl_ir_node *	value,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1833 of file hlsl.c.

{
    struct hlsl_ir_resource_store *store;
 
    if (!(store = hlsl_alloc(ctx, sizeof(*store))))
        return NULL;
    init_node(&store->node, HLSL_IR_RESOURCE_STORE, NULL, loc);
    hlsl_copy_deref(ctx, &store->resource, resource);
    hlsl_src_from_node(&store->coords, coords);
    hlsl_src_from_node(&store->value, value);
    return &store->node;
}

◆ hlsl_new_sampler_state()

struct hlsl_ir_node * hlsl_new_sampler_state	(	struct hlsl_ctx *	ctx,
		const struct hlsl_state_block *	state_block,
		struct vkd3d_shader_location *	loc
	)

Definition at line 1937 of file hlsl.c.

{
    struct hlsl_ir_sampler_state *sampler_state;
    struct hlsl_type *type = ctx->builtin_types.sampler[HLSL_SAMPLER_DIM_GENERIC];
 
    if (!(sampler_state = hlsl_alloc(ctx, sizeof(*sampler_state))))
        return NULL;
 
    init_node(&sampler_state->node, HLSL_IR_SAMPLER_STATE, type, loc);
 
    if (!(sampler_state->state_block = hlsl_alloc(ctx, sizeof(*sampler_state->state_block))))
    {
        vkd3d_free(sampler_state);
        return NULL;
    }
 
    if (state_block)
    {
        for (unsigned int i = 0; i < state_block->count; ++i)
        {
            const struct hlsl_state_block_entry *src = state_block->entries[i];
            struct hlsl_state_block_entry *entry;
 
            if (!(entry = clone_stateblock_entry(ctx, src, src->name, src->lhs_has_index, src->lhs_index, false, 0)))
            {
                hlsl_free_instr(&sampler_state->node);
                return NULL;
            }
 
            if (!hlsl_state_block_add_entry(sampler_state->state_block, entry))
            {
                hlsl_free_instr(&sampler_state->node);
                return NULL;
            }
        }
    }
 
    return &sampler_state->node;
}

Referenced by clone_sampler_state().

◆ hlsl_new_simple_store()

struct hlsl_ir_node * hlsl_new_simple_store	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_var *	lhs,
		struct hlsl_ir_node *	rhs
	)

Definition at line 1440 of file hlsl.c.

{
    struct hlsl_deref lhs_deref;
 
    hlsl_init_simple_deref_from_var(&lhs_deref, lhs);
    return hlsl_new_store_index(ctx, &lhs_deref, NULL, rhs, 0, &rhs->loc);
}

Referenced by append_output_copy(), hlsl_new_func_decl(), lower_f16tof32(), lower_f32tof16(), lower_index_loads(), lower_nonconstant_array_loads(), lower_return(), and prepend_uniform_copy().

◆ hlsl_new_stateblock_constant()

struct hlsl_ir_node * hlsl_new_stateblock_constant	(	struct hlsl_ctx *	ctx,
		const char *	name,
		struct vkd3d_shader_location *	loc
	)

Definition at line 1978 of file hlsl.c.

{
    struct hlsl_ir_stateblock_constant *constant;
    struct hlsl_type *type = hlsl_get_scalar_type(ctx, HLSL_TYPE_INT);
 
    if (!(constant = hlsl_alloc(ctx, sizeof(*constant))))
        return NULL;
 
    init_node(&constant->node, HLSL_IR_STATEBLOCK_CONSTANT, type, loc);
 
    if (!(constant->name = hlsl_alloc(ctx, strlen(name) + 1)))
    {
        vkd3d_free(constant);
        return NULL;
    }
    strcpy(constant->name, name);
 
    return &constant->node;
}

Referenced by clone_stateblock_constant().

◆ hlsl_new_store_component()

bool hlsl_new_store_component	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	block,
		const struct hlsl_deref *	lhs,
		unsigned int	comp,
		struct hlsl_ir_node *	rhs
	)

Definition at line 1480 of file hlsl.c.

{
    struct hlsl_block comp_path_block;
    struct hlsl_ir_store *store;
 
    hlsl_block_init(block);
 
    if (!(store = hlsl_alloc(ctx, sizeof(*store))))
        return false;
    init_node(&store->node, HLSL_IR_STORE, NULL, &rhs->loc);
 
    if (!init_deref_from_component_index(ctx, &comp_path_block, &store->lhs, lhs, comp, &rhs->loc))
    {
        vkd3d_free(store);
        return false;
    }
    hlsl_block_add_block(block, &comp_path_block);
    hlsl_src_from_node(&store->rhs, rhs);
 
    if (type_is_single_reg(rhs->data_type))
        store->writemask = (1 << rhs->data_type->dimx) - 1;
 
    hlsl_block_add_instr(block, &store->node);
 
    return true;
}

Referenced by lower_matrix_swizzles(), and lower_trig().

◆ hlsl_new_store_index()

struct hlsl_ir_node * hlsl_new_store_index	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	lhs,
		struct hlsl_ir_node *	idx,
		struct hlsl_ir_node *	rhs,
		unsigned int	writemask,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1448 of file hlsl.c.

{
    struct hlsl_ir_store *store;
    unsigned int i;
 
    VKD3D_ASSERT(lhs);
    VKD3D_ASSERT(!hlsl_deref_is_lowered(lhs));
 
    if (!(store = hlsl_alloc(ctx, sizeof(*store))))
        return NULL;
    init_node(&store->node, HLSL_IR_STORE, NULL, loc);
 
    if (!init_deref(ctx, &store->lhs, lhs->var, lhs->path_len + !!idx))
    {
        vkd3d_free(store);
        return NULL;
    }
    for (i = 0; i < lhs->path_len; ++i)
        hlsl_src_from_node(&store->lhs.path[i], lhs->path[i].node);
    if (idx)
        hlsl_src_from_node(&store->lhs.path[lhs->path_len], idx);
 
    hlsl_src_from_node(&store->rhs, rhs);
 
    if (!writemask && type_is_single_reg(rhs->data_type))
        writemask = (1 << rhs->data_type->dimx) - 1;
    store->writemask = writemask;
 
    return &store->node;
}

Referenced by add_zero_mipmap_level(), hlsl_new_simple_store(), lower_index_loads(), prepend_input_copy(), and split_copy().

◆ hlsl_new_string_constant()

struct hlsl_ir_node * hlsl_new_string_constant	(	struct hlsl_ctx *	ctx,
		const char *	str,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1571 of file hlsl.c.

{
    struct hlsl_ir_string_constant *s;
 
    if (!(s = hlsl_alloc(ctx, sizeof(*s))))
        return NULL;
 
    init_node(&s->node, HLSL_IR_STRING_CONSTANT, ctx->builtin_types.string, loc);
 
    if (!(s->string = hlsl_strdup(ctx, str)))
    {
        hlsl_free_instr(&s->node);
        return NULL;
    }
    return &s->node;
}

Referenced by clone_string_constant().

◆ hlsl_new_struct_type()

struct hlsl_type * hlsl_new_struct_type	(	struct hlsl_ctx *	ctx,
		const char *	name,
		struct hlsl_struct_field *	fields,
		size_t	field_count
	)

Definition at line 901 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
    type->class = HLSL_CLASS_STRUCT;
    type->name = name;
    type->dimy = 1;
    type->e.record.fields = fields;
    type->e.record.field_count = field_count;
    hlsl_type_calculate_reg_size(ctx, type);
 
    list_add_tail(&ctx->types, &type->entry);
 
    return type;
}

◆ hlsl_new_switch()

struct hlsl_ir_node * hlsl_new_switch	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_node *	selector,
		struct list *	cases,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1682 of file hlsl.c.

{
    struct hlsl_ir_switch *s;
 
    if (!(s = hlsl_alloc(ctx, sizeof(*s))))
        return NULL;
    init_node(&s->node, HLSL_IR_SWITCH, NULL, loc);
    hlsl_src_from_node(&s->selector, selector);
    list_init(&s->cases);
    if (cases)
        list_move_head(&s->cases, cases);
 
    return &s->node;
}

Referenced by clone_switch().

◆ hlsl_new_switch_case()

struct hlsl_ir_switch_case * hlsl_new_switch_case	(	struct hlsl_ctx *	ctx,
		unsigned int	value,
		bool	is_default,
		struct hlsl_block *	body,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1664 of file hlsl.c.

{
    struct hlsl_ir_switch_case *c;
 
    if (!(c = hlsl_alloc(ctx, sizeof(*c))))
        return NULL;
 
    c->value = value;
    c->is_default = is_default;
    hlsl_block_init(&c->body);
    if (body)
        hlsl_block_add_block(&c->body, body);
    c->loc = *loc;
 
    return c;
}

Referenced by clone_switch(), and normalize_switch_cases().

◆ hlsl_new_swizzle()

struct hlsl_ir_node * hlsl_new_swizzle	(	struct hlsl_ctx *	ctx,
		uint32_t	s,
		unsigned int	components,
		struct hlsl_ir_node *	val,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1847 of file hlsl.c.

{
    struct hlsl_ir_swizzle *swizzle;
    struct hlsl_type *type;
 
    if (!(swizzle = hlsl_alloc(ctx, sizeof(*swizzle))))
        return NULL;
    VKD3D_ASSERT(hlsl_is_numeric_type(val->data_type));
    if (components == 1)
        type = hlsl_get_scalar_type(ctx, val->data_type->e.numeric.type);
    else
        type = hlsl_get_vector_type(ctx, val->data_type->e.numeric.type, components);
    init_node(&swizzle->node, HLSL_IR_SWIZZLE, type, loc);
    hlsl_src_from_node(&swizzle->val, val);
    swizzle->swizzle = s;
    return &swizzle->node;
}

Referenced by clone_swizzle(), copy_propagation_replace_with_single_instr(), fold_swizzle_chains(), lower_broadcasts(), lower_dot(), lower_int_dot(), lower_narrowing_casts(), lower_nonconstant_array_loads(), lower_nonconstant_vector_derefs(), and lower_trig().

◆ hlsl_new_synthetic_var()

struct hlsl_ir_var * hlsl_new_synthetic_var	(	struct hlsl_ctx *	ctx,
		const char *	template,
		struct hlsl_type *	type,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1349 of file hlsl.c.

{
    struct vkd3d_string_buffer *string;
    struct hlsl_ir_var *var;
 
    if (!(string = hlsl_get_string_buffer(ctx)))
        return NULL;
    vkd3d_string_buffer_printf(string, "<%s-%u>", template, ctx->internal_name_counter++);
    var = hlsl_new_synthetic_var_named(ctx, string->buffer, type, loc, true);
    hlsl_release_string_buffer(ctx, string);
    return var;
}

Referenced by add_zero_mipmap_level(), hlsl_new_func_decl(), lower_index_loads(), lower_matrix_swizzles(), lower_nonconstant_array_loads(), and lower_trig().

◆ hlsl_new_synthetic_var_named()

struct hlsl_ir_var * hlsl_new_synthetic_var_named	(	struct hlsl_ctx *	ctx,
		const char *	name,
		struct hlsl_type *	type,
		const struct vkd3d_shader_location *	loc,
		bool	dummy_scope
	)

Definition at line 1363 of file hlsl.c.

{
    struct hlsl_ir_var *var;
    const char *name_copy;
 
    if (!(name_copy = hlsl_strdup(ctx, name)))
        return NULL;
    var = hlsl_new_var(ctx, name_copy, type, loc, NULL, 0, NULL);
    if (var)
    {
        if (dummy_scope)
            list_add_tail(&ctx->dummy_scope->vars, &var->scope_entry);
        else
            list_add_tail(&ctx->globals->vars, &var->scope_entry);
        var->is_synthetic = true;
    }
    return var;
}

Referenced by hlsl_new_synthetic_var(), and lower_combined_samples().

◆ hlsl_new_ternary_expr()

struct hlsl_ir_node * hlsl_new_ternary_expr	(	struct hlsl_ctx *	ctx,
		enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	arg1,
		struct hlsl_ir_node *	arg2,
		struct hlsl_ir_node *	arg3
	)

Definition at line 1627 of file hlsl.c.

{
    struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS] = {arg1, arg2, arg3};
 
    VKD3D_ASSERT(hlsl_types_are_equal(arg1->data_type, arg2->data_type));
    VKD3D_ASSERT(hlsl_types_are_equal(arg1->data_type, arg3->data_type));
    return hlsl_new_expr(ctx, op, operands, arg1->data_type, &arg1->loc);
}

Referenced by lower_slt(), and lower_trig().

◆ hlsl_new_texture_type()

struct hlsl_type * hlsl_new_texture_type	(	struct hlsl_ctx *	ctx,
		enum hlsl_sampler_dim	dim,
		struct hlsl_type *	format,
		unsigned int	sample_count
	)

Definition at line 920 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
    type->class = HLSL_CLASS_TEXTURE;
    type->dimx = 4;
    type->dimy = 1;
    type->sampler_dim = dim;
    type->e.resource.format = format;
    type->sample_count = sample_count;
    hlsl_type_calculate_reg_size(ctx, type);
    list_add_tail(&ctx->types, &type->entry);
    return type;
}

Referenced by lower_combined_samples().

◆ hlsl_new_uav_type()

struct hlsl_type * hlsl_new_uav_type	(	struct hlsl_ctx *	ctx,
		enum hlsl_sampler_dim	dim,
		struct hlsl_type *	format,
		bool	rasteriser_ordered
	)

Definition at line 938 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
    type->class = HLSL_CLASS_UAV;
    type->dimx = format->dimx;
    type->dimy = 1;
    type->sampler_dim = dim;
    type->e.resource.format = format;
    type->e.resource.rasteriser_ordered = rasteriser_ordered;
    hlsl_type_calculate_reg_size(ctx, type);
    list_add_tail(&ctx->types, &type->entry);
    return type;
}

◆ hlsl_new_uint_constant()

struct hlsl_ir_node * hlsl_new_uint_constant	(	struct hlsl_ctx *	ctx,
		unsigned int	n,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1562 of file hlsl.c.

{
    struct hlsl_constant_value value;
 
    value.u[0].u = n;
    return hlsl_new_constant(ctx, hlsl_get_scalar_type(ctx, HLSL_TYPE_UINT), &value, loc);
}

Referenced by add_zero_mipmap_level(), append_output_copy(), append_output_copy_recurse(), init_deref_from_component_index(), lower_index_loads(), lower_nonconstant_array_loads(), lower_null_constant(), new_offset_from_path_index(), new_offset_instr_from_deref(), prepend_input_copy(), prepend_input_copy_recurse(), replace_state_block_constant(), resolve_fx_4_state_block_values(), and split_copy().

◆ hlsl_new_unary_expr()

struct hlsl_ir_node * hlsl_new_unary_expr	(	struct hlsl_ctx *	ctx,
		enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	arg,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1611 of file hlsl.c.

{
    struct hlsl_ir_node *operands[HLSL_MAX_OPERANDS] = {arg};
 
    return hlsl_new_expr(ctx, op, operands, arg->data_type, loc);
}

Referenced by hlsl_new_cast(), lower_abs(), lower_casts_to_int(), lower_ceil(), lower_cmp(), lower_comparison_operators(), lower_discard_nz(), lower_division(), lower_float_modulus(), lower_floor(), lower_int_abs(), lower_int_division(), lower_int_modulus(), lower_logic_not(), lower_return(), lower_round(), lower_slt(), lower_sqrt(), lower_ternary(), and lower_trig().

◆ hlsl_new_var()

struct hlsl_ir_var * hlsl_new_var	(	struct hlsl_ctx *	ctx,
		const char *	name,
		struct hlsl_type *	type,
		const struct vkd3d_shader_location *	loc,
		const struct hlsl_semantic *	semantic,
		uint32_t	modifiers,
		const struct hlsl_reg_reservation *	reg_reservation
	)

Definition at line 1311 of file hlsl.c.

{
    struct hlsl_ir_var *var;
    unsigned int k;
 
    if (!(var = hlsl_alloc(ctx, sizeof(*var))))
        return NULL;
 
    var->name = name;
    var->data_type = type;
    var->loc = *loc;
    if (semantic)
        var->semantic = *semantic;
    var->storage_modifiers = modifiers;
    if (reg_reservation)
        var->reg_reservation = *reg_reservation;
 
    for (k = 0; k <= HLSL_REGSET_LAST_OBJECT; ++k)
    {
        unsigned int i, obj_count = type->reg_size[k];
 
        if (obj_count == 0)
            continue;
 
        if (!(var->objects_usage[k] = hlsl_calloc(ctx, obj_count, sizeof(*var->objects_usage[0]))))
        {
            for (i = 0; i < k; ++i)
                vkd3d_free(var->objects_usage[i]);
            vkd3d_free(var);
            return NULL;
        }
    }
 
    return var;
}

Referenced by add_semantic_var(), hlsl_new_synthetic_var_named(), and prepend_uniform_copy().

◆ hlsl_new_var_load()

struct hlsl_ir_load * hlsl_new_var_load	(	struct hlsl_ctx *	ctx,
		struct hlsl_ir_var *	var,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1757 of file hlsl.c.

{
    struct hlsl_deref var_deref;
 
    hlsl_init_simple_deref_from_var(&var_deref, var);
    return hlsl_new_load_index(ctx, &var_deref, NULL, loc);
}

Referenced by add_zero_mipmap_level(), append_output_var_copy(), insert_early_return_break(), lower_f16tof32(), lower_f32tof16(), lower_index_loads(), lower_matrix_swizzles(), lower_nonconstant_array_loads(), lower_return(), prepend_input_copy(), prepend_input_var_copy(), and prepend_uniform_copy().

◆ hlsl_new_vsir_instruction_ref()

struct hlsl_ir_node * hlsl_new_vsir_instruction_ref	(	struct hlsl_ctx *	ctx,
		unsigned int	vsir_instr_idx,
		struct hlsl_type *	type,
		const struct hlsl_reg *	reg,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 1698 of file hlsl.c.

{
    struct hlsl_ir_vsir_instruction_ref *vsir_instr;
 
    if (!(vsir_instr = hlsl_alloc(ctx, sizeof(*vsir_instr))))
        return NULL;
    init_node(&vsir_instr->node, HLSL_IR_VSIR_INSTRUCTION_REF, type, loc);
    vsir_instr->vsir_instr_idx = vsir_instr_idx;
 
    if (reg)
        vsir_instr->node.reg = *reg;
 
    return &vsir_instr->node;
}

Referenced by add_last_vsir_instr_to_block(), and replace_instr_with_last_vsir_instr().

◆ hlsl_node_type_to_string()

const char * hlsl_node_type_to_string ( enum hlsl_ir_node_type type )

Definition at line 2949 of file hlsl.c.

{
    static const char * const names[] =
    {
        [HLSL_IR_CALL           ] = "HLSL_IR_CALL",
        [HLSL_IR_CONSTANT       ] = "HLSL_IR_CONSTANT",
        [HLSL_IR_EXPR           ] = "HLSL_IR_EXPR",
        [HLSL_IR_IF             ] = "HLSL_IR_IF",
        [HLSL_IR_INDEX          ] = "HLSL_IR_INDEX",
        [HLSL_IR_LOAD           ] = "HLSL_IR_LOAD",
        [HLSL_IR_LOOP           ] = "HLSL_IR_LOOP",
        [HLSL_IR_JUMP           ] = "HLSL_IR_JUMP",
        [HLSL_IR_RESOURCE_LOAD  ] = "HLSL_IR_RESOURCE_LOAD",
        [HLSL_IR_RESOURCE_STORE ] = "HLSL_IR_RESOURCE_STORE",
        [HLSL_IR_STRING_CONSTANT] = "HLSL_IR_STRING_CONSTANT",
        [HLSL_IR_STORE          ] = "HLSL_IR_STORE",
        [HLSL_IR_SWITCH         ] = "HLSL_IR_SWITCH",
        [HLSL_IR_SWIZZLE        ] = "HLSL_IR_SWIZZLE",
 
        [HLSL_IR_COMPILE]             = "HLSL_IR_COMPILE",
        [HLSL_IR_SAMPLER_STATE]       = "HLSL_IR_SAMPLER_STATE",
        [HLSL_IR_STATEBLOCK_CONSTANT] = "HLSL_IR_STATEBLOCK_CONSTANT",
        [HLSL_IR_VSIR_INSTRUCTION_REF] = "HLSL_IR_VSIR_INSTRUCTION_REF",
    };
 
    if (type >= ARRAY_SIZE(names))
        return "Unexpected node type";
    return names[type];
}

Referenced by hlsl_offset_from_deref_safe(), sm1_generate_vsir_block(), and write_sm4_block().

◆ hlsl_note()

void void void void hlsl_note	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_location *	loc,
		enum vkd3d_shader_log_level	level,
		const char *	fmt,
			...
	)

◆ hlsl_offset_from_deref()

bool hlsl_offset_from_deref	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref,
		unsigned int *	offset
	)

Definition at line 5949 of file hlsl_codegen.c.

{
    enum hlsl_regset regset = hlsl_deref_get_regset(ctx, deref);
    struct hlsl_ir_node *offset_node = deref->rel_offset.node;
    unsigned int size;
 
    *offset = deref->const_offset;
 
    if (offset_node)
    {
        /* We should always have generated a cast to UINT. */
        VKD3D_ASSERT(offset_node->data_type->class == HLSL_CLASS_SCALAR
                && offset_node->data_type->e.numeric.type == HLSL_TYPE_UINT);
        VKD3D_ASSERT(offset_node->type != HLSL_IR_CONSTANT);
        return false;
    }
 
    size = deref->var->data_type->reg_size[regset];
    if (*offset >= size)
    {
        /* FIXME: Report a more specific location for the constant deref. */
        hlsl_error(ctx, &deref->var->loc, VKD3D_SHADER_ERROR_HLSL_OFFSET_OUT_OF_BOUNDS,
                "Dereference is out of bounds. %u/%u", *offset, size);
        return false;
    }
 
    return true;
}

Referenced by hlsl_offset_from_deref_safe().

◆ hlsl_offset_from_deref_safe()

unsigned int hlsl_offset_from_deref_safe	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref
	)

Definition at line 5978 of file hlsl_codegen.c.

{
    unsigned int offset;
 
    if (hlsl_offset_from_deref(ctx, deref, &offset))
        return offset;
 
    if (deref->rel_offset.node)
        hlsl_fixme(ctx, &deref->rel_offset.node->loc, "Dereference with non-constant offset of type %s.",
                hlsl_node_type_to_string(deref->rel_offset.node->type));
 
    return 0;
}

Referenced by hlsl_reg_from_deref(), sm1_generate_vsir_init_src_param_from_deref(), sm4_numeric_register_from_deref(), and sm4_register_from_deref().

◆ hlsl_pop_scope()

void hlsl_pop_scope ( struct hlsl_ctx * ctx )

Definition at line 2653 of file hlsl.c.

{
    struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
 
    VKD3D_ASSERT(prev_scope);
    TRACE("Popping current scope.\n");
    ctx->cur_scope = prev_scope;
}

Referenced by hlsl_compile_internal_function().

◆ hlsl_push_scope()

void void void void void hlsl_push_scope ( struct hlsl_ctx * ctx )

Definition at line 2642 of file hlsl.c.

{
    struct hlsl_scope *new_scope;
 
    if (!(new_scope = hlsl_new_scope(ctx, ctx->cur_scope)))
        return;
 
    TRACE("Pushing a new scope.\n");
    ctx->cur_scope = new_scope;
}

Referenced by hlsl_compile_internal_function(), and hlsl_ctx_init().

◆ hlsl_realloc()

static void * hlsl_realloc	(	struct hlsl_ctx *	ctx,
		void *	ptr,
		size_t	size
	)

inlinestatic

Definition at line 1318 of file hlsl.h.

{
    void *ret = vkd3d_realloc(ptr, size);
 
    if (!ret)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ret;
}

◆ hlsl_reg_from_deref()

struct hlsl_reg hlsl_reg_from_deref	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref
	)

Definition at line 5992 of file hlsl_codegen.c.

{
    const struct hlsl_ir_var *var = deref->var;
    struct hlsl_reg ret = var->regs[HLSL_REGSET_NUMERIC];
    unsigned int offset = hlsl_offset_from_deref_safe(ctx, deref);
 
    VKD3D_ASSERT(deref->data_type);
    VKD3D_ASSERT(hlsl_is_numeric_type(deref->data_type));
 
    ret.index += offset / 4;
    ret.id += offset / 4;
 
    ret.writemask = 0xf & (0xf << (offset % 4));
    if (var->regs[HLSL_REGSET_NUMERIC].writemask)
        ret.writemask = hlsl_combine_writemasks(var->regs[HLSL_REGSET_NUMERIC].writemask, ret.writemask);
 
    return ret;
}

Referenced by sm1_generate_vsir_init_dst_param_from_deref(), sm1_generate_vsir_init_src_param_from_deref(), and sm4_register_from_deref().

◆ hlsl_regset_index_from_deref()

bool hlsl_regset_index_from_deref	(	struct hlsl_ctx *	ctx,
		const struct hlsl_deref *	deref,
		enum hlsl_regset	regset,
		unsigned int *	index
	)

Definition at line 5876 of file hlsl_codegen.c.

{
    struct hlsl_type *type = deref->var->data_type;
    bool index_is_constant = true;
    unsigned int i;
 
    *index = 0;
 
    for (i = 0; i < deref->path_len; ++i)
    {
        struct hlsl_ir_node *path_node = deref->path[i].node;
        unsigned int idx = 0;
 
        VKD3D_ASSERT(path_node);
        if (path_node->type == HLSL_IR_CONSTANT)
        {
            /* We should always have generated a cast to UINT. */
            VKD3D_ASSERT(path_node->data_type->class == HLSL_CLASS_SCALAR
                    && path_node->data_type->e.numeric.type == HLSL_TYPE_UINT);
 
            idx = hlsl_ir_constant(path_node)->value.u[0].u;
 
            switch (type->class)
            {
                case HLSL_CLASS_ARRAY:
                    if (idx >= type->e.array.elements_count)
                        return false;
 
                    *index += idx * type->e.array.type->reg_size[regset];
                    break;
 
                case HLSL_CLASS_STRUCT:
                    *index += type->e.record.fields[idx].reg_offset[regset];
                    break;
 
                case HLSL_CLASS_MATRIX:
                    *index += 4 * idx;
                    break;
 
                default:
                    vkd3d_unreachable();
            }
        }
        else
        {
            index_is_constant = false;
 
            switch (type->class)
            {
                case HLSL_CLASS_ARRAY:
                    idx = type->e.array.elements_count - 1;
                    *index += idx * type->e.array.type->reg_size[regset];
                    break;
 
                case HLSL_CLASS_MATRIX:
                    idx = hlsl_type_major_size(type) - 1;
                    *index += idx * 4;
                    break;
 
                default:
                    vkd3d_unreachable();
            }
        }
 
        type = hlsl_get_element_type_from_path_index(ctx, type, path_node);
    }
 
    VKD3D_ASSERT(!(regset <= HLSL_REGSET_LAST_OBJECT) || (type->reg_size[regset] == 1));
    VKD3D_ASSERT(!(regset == HLSL_REGSET_NUMERIC) || type->reg_size[regset] <= 4);
    return index_is_constant;
}

Referenced by register_deref_usage(), and track_object_components_sampler_dim().

◆ hlsl_release_string_buffer()

static void hlsl_release_string_buffer	(	struct hlsl_ctx *	ctx,
		struct vkd3d_string_buffer *	buffer
	)

inlinestatic

Definition at line 1355 of file hlsl.h.

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

Referenced by allocate_register_reservations(), append_output_copy(), debug_hlsl_type(), declare_predefined_types(), dump_ir_call(), dump_ir_var(), generate_vsir_signature_entry(), get_string_argument_value(), hlsl_compile_internal_function(), hlsl_fixme(), hlsl_new_synthetic_var(), hlsl_sprintf_alloc(), hlsl_type_to_string(), lower_combined_samples(), parse_numthreads_attribute(), parse_outputcontrolpoints_attribute(), prepend_input_copy(), sm4_generate_vsir_block(), and sm4_get_extern_resources().

◆ hlsl_replace_node()

void hlsl_replace_node	(	struct hlsl_ir_node *	old,
		struct hlsl_ir_node *	new
	)

Definition at line 3626 of file hlsl.c.

{
    struct hlsl_src *src, *next;
 
    VKD3D_ASSERT(old->data_type == new->data_type || old->data_type->dimx == new->data_type->dimx);
    VKD3D_ASSERT(old->data_type == new->data_type || old->data_type->dimy == new->data_type->dimy);
 
    LIST_FOR_EACH_ENTRY_SAFE(src, next, &old->uses, struct hlsl_src, entry)
    {
        hlsl_src_remove(src);
        hlsl_src_from_node(src, new);
    }
    list_remove(&old->entry);
    hlsl_free_instr(old);
}

Referenced by call_lower_func(), copy_propagation_replace_with_constant_vector(), copy_propagation_replace_with_single_instr(), fold_redundant_casts(), fold_swizzle_chains(), hlsl_fold_constant_exprs(), hlsl_fold_constant_identities(), hlsl_fold_constant_swizzles(), lower_null_constant(), remove_trivial_swizzles(), replace_instr_with_last_vsir_instr(), and replace_state_block_constant().

◆ hlsl_run_const_passes()

void hlsl_run_const_passes	(	struct hlsl_ctx *	ctx,
		struct hlsl_block *	body
	)

Definition at line 6397 of file hlsl_codegen.c.

{
    bool progress;
 
    lower_ir(ctx, lower_matrix_swizzles, body);
 
    lower_ir(ctx, lower_broadcasts, body);
    while (hlsl_transform_ir(ctx, fold_redundant_casts, body, NULL));
    do
    {
        progress = hlsl_transform_ir(ctx, split_array_copies, body, NULL);
        progress |= hlsl_transform_ir(ctx, split_struct_copies, body, NULL);
    }
    while (progress);
    hlsl_transform_ir(ctx, split_matrix_copies, body, NULL);
 
    lower_ir(ctx, lower_narrowing_casts, body);
    lower_ir(ctx, lower_int_dot, body);
    lower_ir(ctx, lower_int_division, body);
    lower_ir(ctx, lower_int_modulus, body);
    lower_ir(ctx, lower_int_abs, body);
    lower_ir(ctx, lower_casts_to_bool, body);
    lower_ir(ctx, lower_float_modulus, body);
    hlsl_transform_ir(ctx, fold_redundant_casts, body, NULL);
 
    do
    {
        progress = hlsl_transform_ir(ctx, hlsl_fold_constant_exprs, body, NULL);
        progress |= hlsl_transform_ir(ctx, hlsl_fold_constant_identities, body, NULL);
        progress |= hlsl_transform_ir(ctx, hlsl_fold_constant_swizzles, body, NULL);
        progress |= hlsl_copy_propagation_execute(ctx, body);
        progress |= hlsl_transform_ir(ctx, fold_swizzle_chains, body, NULL);
        progress |= hlsl_transform_ir(ctx, remove_trivial_swizzles, body, NULL);
        progress |= hlsl_transform_ir(ctx, remove_trivial_conditional_branches, body, NULL);
    } while (progress);
}

Referenced by loop_unrolling_unroll_loop(), process_entry_function(), and resolve_fx_4_state_block_values().

◆ hlsl_sampler_dim_count()

static unsigned int hlsl_sampler_dim_count ( enum hlsl_sampler_dim dim )

inlinestatic

Definition at line 1393 of file hlsl.h.

{
    switch (dim)
    {
        case HLSL_SAMPLER_DIM_1D:
        case HLSL_SAMPLER_DIM_BUFFER:
        case HLSL_SAMPLER_DIM_RAW_BUFFER:
        case HLSL_SAMPLER_DIM_STRUCTURED_BUFFER:
            return 1;
        case HLSL_SAMPLER_DIM_1DARRAY:
        case HLSL_SAMPLER_DIM_2D:
        case HLSL_SAMPLER_DIM_2DMS:
            return 2;
        case HLSL_SAMPLER_DIM_2DARRAY:
        case HLSL_SAMPLER_DIM_2DMSARRAY:
        case HLSL_SAMPLER_DIM_3D:
        case HLSL_SAMPLER_DIM_CUBE:
            return 3;
        case HLSL_SAMPLER_DIM_CUBEARRAY:
            return 4;
        default:
            vkd3d_unreachable();
    }
}

Referenced by lower_index_loads(), and write_sm4_ld().

◆ hlsl_scope_add_type()

bool hlsl_scope_add_type	(	struct hlsl_scope *	scope,
		struct hlsl_type *	type
	)

Definition at line 1285 of file hlsl.c.

{
    if (hlsl_get_type(scope, type->name, false, false))
        return false;
 
    rb_put(&scope->types, type->name, &type->scope_entry);
    return true;
}

Referenced by declare_predefined_types().

◆ hlsl_sm1_base_type()

D3DXPARAMETER_TYPE hlsl_sm1_base_type ( const struct hlsl_type * type )

Definition at line 1575 of file d3dbc.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_SCALAR:
        case HLSL_CLASS_VECTOR:
        case HLSL_CLASS_MATRIX:
            switch (type->e.numeric.type)
            {
                case HLSL_TYPE_BOOL:
                    return D3DXPT_BOOL;
                /* Actually double behaves differently depending on DLL version:
                 * For <= 36, it maps to D3DXPT_FLOAT.
                 * For 37-40, it maps to zero (D3DXPT_VOID).
                 * For >= 41, it maps to 39, which is D3D_SVT_DOUBLE (note D3D_SVT_*
                 *            values are mostly compatible with D3DXPT_*).
                 * However, the latter two cases look like bugs, and a reasonable
                 * application certainly wouldn't know what to do with them.
                 * For fx_2_0 it's always D3DXPT_FLOAT regardless of DLL version. */
                case HLSL_TYPE_DOUBLE:
                case HLSL_TYPE_FLOAT:
                case HLSL_TYPE_HALF:
                    return D3DXPT_FLOAT;
                case HLSL_TYPE_INT:
                case HLSL_TYPE_UINT:
                    return D3DXPT_INT;
                default:
                    vkd3d_unreachable();
            }
 
        case HLSL_CLASS_SAMPLER:
            switch (type->sampler_dim)
            {
                case HLSL_SAMPLER_DIM_1D:
                    return D3DXPT_SAMPLER1D;
                case HLSL_SAMPLER_DIM_2D:
                    return D3DXPT_SAMPLER2D;
                case HLSL_SAMPLER_DIM_3D:
                    return D3DXPT_SAMPLER3D;
                case HLSL_SAMPLER_DIM_CUBE:
                    return D3DXPT_SAMPLERCUBE;
                case HLSL_SAMPLER_DIM_GENERIC:
                    return D3DXPT_SAMPLER;
                default:
                    ERR("Invalid dimension %#x.\n", type->sampler_dim);
                    vkd3d_unreachable();
            }
            break;
 
        case HLSL_CLASS_TEXTURE:
            switch (type->sampler_dim)
            {
                case HLSL_SAMPLER_DIM_1D:
                    return D3DXPT_TEXTURE1D;
                case HLSL_SAMPLER_DIM_2D:
                    return D3DXPT_TEXTURE2D;
                case HLSL_SAMPLER_DIM_3D:
                    return D3DXPT_TEXTURE3D;
                case HLSL_SAMPLER_DIM_CUBE:
                    return D3DXPT_TEXTURECUBE;
                case HLSL_SAMPLER_DIM_GENERIC:
                    return D3DXPT_TEXTURE;
                default:
                    ERR("Invalid dimension %#x.\n", type->sampler_dim);
                    vkd3d_unreachable();
            }
            break;
 
        case HLSL_CLASS_ARRAY:
            return hlsl_sm1_base_type(type->e.array.type);
 
        case HLSL_CLASS_STRUCT:
            return D3DXPT_VOID;
 
        case HLSL_CLASS_STRING:
            return D3DXPT_STRING;
 
        case HLSL_CLASS_PIXEL_SHADER:
            return D3DXPT_PIXELSHADER;
 
        case HLSL_CLASS_VERTEX_SHADER:
            return D3DXPT_VERTEXSHADER;
 
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_ERROR:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_TECHNIQUE:
        case HLSL_CLASS_UAV:
        case HLSL_CLASS_VOID:
        case HLSL_CLASS_CONSTANT_BUFFER:
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_NULL:
            break;
    }
 
    vkd3d_unreachable();
}

Referenced by hlsl_sm1_base_type(), write_fx_2_parameter(), and write_sm1_type().

◆ hlsl_sm1_class()

D3DXPARAMETER_CLASS hlsl_sm1_class ( const struct hlsl_type * type )

Definition at line 1528 of file d3dbc.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_ARRAY:
            return hlsl_sm1_class(type->e.array.type);
        case HLSL_CLASS_MATRIX:
            VKD3D_ASSERT(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK);
            if (type->modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
                return D3DXPC_MATRIX_COLUMNS;
            else
                return D3DXPC_MATRIX_ROWS;
        case HLSL_CLASS_SCALAR:
            return D3DXPC_SCALAR;
        case HLSL_CLASS_STRUCT:
            return D3DXPC_STRUCT;
        case HLSL_CLASS_VECTOR:
            return D3DXPC_VECTOR;
        case HLSL_CLASS_PIXEL_SHADER:
        case HLSL_CLASS_SAMPLER:
        case HLSL_CLASS_STRING:
        case HLSL_CLASS_TEXTURE:
        case HLSL_CLASS_VERTEX_SHADER:
            return D3DXPC_OBJECT;
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_ERROR:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_TECHNIQUE:
        case HLSL_CLASS_UAV:
        case HLSL_CLASS_VOID:
        case HLSL_CLASS_CONSTANT_BUFFER:
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_NULL:
            break;
    }
 
    vkd3d_unreachable();
}

Referenced by get_fx_2_type_class(), hlsl_sm1_class(), and write_sm1_type().

◆ hlsl_sprintf_alloc()

char * hlsl_sprintf_alloc	(	struct hlsl_ctx *	ctx,
		const char *	fmt,
			...
	)

◆ hlsl_src_from_node()

static void hlsl_src_from_node	(	struct hlsl_src *	src,
		struct hlsl_ir_node *	node
	)

inlinestatic

Definition at line 1286 of file hlsl.h.

{
    src->node = node;
    if (node)
        list_add_tail(&node->uses, &src->entry);
}

Referenced by clone_deref(), clone_src(), hlsl_copy_deref(), hlsl_init_deref_from_index_chain(), hlsl_new_compile(), hlsl_new_expr(), hlsl_new_if(), hlsl_new_index(), hlsl_new_jump(), hlsl_new_load_index(), hlsl_new_resource_load(), hlsl_new_resource_store(), hlsl_new_store_component(), hlsl_new_store_index(), hlsl_new_switch(), hlsl_new_swizzle(), hlsl_replace_node(), init_deref_from_component_index(), lower_discard_neg(), lower_discard_nz(), lower_nonconstant_array_loads(), replace_deref_path_with_offset(), and resolve_fx_4_state_block_values().

◆ hlsl_src_remove()

static void hlsl_src_remove ( struct hlsl_src * src )

inlinestatic

Definition at line 1293 of file hlsl.h.

{
    if (src->node)
        list_remove(&src->entry);
    src->node = NULL;
}

Referenced by clean_constant_deref_offset_srcs(), free_ir_compile(), free_ir_expr(), free_ir_if(), free_ir_index(), free_ir_jump(), free_ir_resource_load(), free_ir_resource_store(), free_ir_store(), free_ir_switch(), free_ir_swizzle(), hlsl_cleanup_deref(), hlsl_free_attribute(), hlsl_free_state_block_entry(), hlsl_init_deref_from_index_chain(), hlsl_replace_node(), lower_discard_neg(), lower_discard_nz(), lower_nonconstant_array_loads(), and resolve_fx_4_state_block_values().

◆ hlsl_state_block_add_entry()

bool hlsl_state_block_add_entry	(	struct hlsl_state_block *	state_block,
		struct hlsl_state_block_entry *	entry
	)

Definition at line 1925 of file hlsl.c.

{
    if (!vkd3d_array_reserve((void **)&state_block->entries,
            &state_block->capacity, state_block->count + 1,
            sizeof(*state_block->entries)))
        return false;
 
    state_block->entries[state_block->count++] = entry;
    return true;
}

Referenced by hlsl_new_sampler_state().

◆ hlsl_strdup()

static char * hlsl_strdup	(	struct hlsl_ctx *	ctx,
		const char *	string
	)

inlinestatic

Definition at line 1327 of file hlsl.h.

{
    char *ptr = vkd3d_strdup(string);
 
    if (!ptr)
        ctx->result = VKD3D_ERROR_OUT_OF_MEMORY;
    return ptr;
}

Referenced by clone_stateblock_entry(), decompose_fx_4_state_function_call(), hlsl_add_function(), hlsl_clone_semantic(), hlsl_ctx_init(), hlsl_new_simple_type(), hlsl_new_string_constant(), hlsl_new_synthetic_var_named(), hlsl_new_type(), hlsl_sprintf_alloc(), hlsl_type_clone(), and sm4_get_extern_resources().

◆ hlsl_swizzle_from_writemask()

uint32_t hlsl_swizzle_from_writemask ( unsigned int writemask )

Definition at line 4001 of file hlsl.c.

{
    static const unsigned int swizzles[16] =
    {
        0,
        HLSL_SWIZZLE(X, X, X, X),
        HLSL_SWIZZLE(Y, Y, Y, Y),
        HLSL_SWIZZLE(X, Y, X, X),
        HLSL_SWIZZLE(Z, Z, Z, Z),
        HLSL_SWIZZLE(X, Z, X, X),
        HLSL_SWIZZLE(Y, Z, X, X),
        HLSL_SWIZZLE(X, Y, Z, X),
        HLSL_SWIZZLE(W, W, W, W),
        HLSL_SWIZZLE(X, W, X, X),
        HLSL_SWIZZLE(Y, W, X, X),
        HLSL_SWIZZLE(X, Y, W, X),
        HLSL_SWIZZLE(Z, W, X, X),
        HLSL_SWIZZLE(X, Z, W, X),
        HLSL_SWIZZLE(Y, Z, W, X),
        HLSL_SWIZZLE(X, Y, Z, W),
    };
 
    return swizzles[writemask & 0xf];
}

Referenced by generate_vsir_get_src_swizzle(), generate_vsir_instr_swizzle(), lower_int_dot(), lower_trig(), sm4_numeric_register_from_deref(), sm4_src_from_deref(), sm4_src_from_node(), and write_sm4_swizzle().

◆ hlsl_swizzle_get_component()

static unsigned int hlsl_swizzle_get_component	(	uint32_t	swizzle,
		unsigned int	idx
	)

inlinestatic

Definition at line 68 of file hlsl.h.

{
    return (swizzle >> HLSL_SWIZZLE_SHIFT(idx)) & HLSL_SWIZZLE_MASK;
}

Referenced by copy_propagation_replace_with_constant_vector(), copy_propagation_replace_with_single_instr(), debug_hlsl_swizzle(), hlsl_combine_swizzles(), hlsl_fold_constant_swizzles(), remove_trivial_swizzles(), and vsir_swizzle_from_hlsl().

◆ hlsl_transform_ir()

bool hlsl_transform_ir	(	struct hlsl_ctx *	ctx,
		bool()(struct hlsl_ctx ctx, struct hlsl_ir_node , void )	func,
		struct hlsl_block *	block,
		void *	context
	)

Definition at line 642 of file hlsl_codegen.c.

{
    struct hlsl_ir_node *instr, *next;
    bool progress = false;
 
    LIST_FOR_EACH_ENTRY_SAFE(instr, next, &block->instrs, struct hlsl_ir_node, entry)
    {
        if (instr->type == HLSL_IR_IF)
        {
            struct hlsl_ir_if *iff = hlsl_ir_if(instr);
 
            progress |= hlsl_transform_ir(ctx, func, &iff->then_block, context);
            progress |= hlsl_transform_ir(ctx, func, &iff->else_block, context);
        }
        else if (instr->type == HLSL_IR_LOOP)
        {
            progress |= hlsl_transform_ir(ctx, func, &hlsl_ir_loop(instr)->body, context);
        }
        else if (instr->type == HLSL_IR_SWITCH)
        {
            struct hlsl_ir_switch *s = hlsl_ir_switch(instr);
            struct hlsl_ir_switch_case *c;
 
            LIST_FOR_EACH_ENTRY(c, &s->cases, struct hlsl_ir_switch_case, entry)
            {
                progress |= hlsl_transform_ir(ctx, func, &c->body, context);
            }
        }
 
        progress |= func(ctx, instr, context);
    }
 
    return progress;
}

Referenced by find_recursive_calls(), hlsl_run_const_passes(), hlsl_transform_ir(), lower_ir(), process_entry_function(), resolve_fx_4_state_block_values(), and transform_derefs().

◆ hlsl_type_clone()

struct hlsl_type * hlsl_type_clone	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	old,
		unsigned int	default_majority,
		uint32_t	modifiers
	)

Definition at line 1183 of file hlsl.c.

{
    struct hlsl_type *type;
 
    if (!(type = hlsl_alloc(ctx, sizeof(*type))))
        return NULL;
 
    if (old->name)
    {
        type->name = hlsl_strdup(ctx, old->name);
        if (!type->name)
        {
            vkd3d_free(type);
            return NULL;
        }
    }
    type->class = old->class;
    type->dimx = old->dimx;
    type->dimy = old->dimy;
    type->modifiers = old->modifiers | modifiers;
    if (!(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK))
        type->modifiers |= default_majority;
    type->sampler_dim = old->sampler_dim;
    type->is_minimum_precision = old->is_minimum_precision;
    type->sample_count = old->sample_count;
 
    switch (old->class)
    {
        case HLSL_CLASS_SCALAR:
        case HLSL_CLASS_VECTOR:
        case HLSL_CLASS_MATRIX:
            type->e.numeric.type = old->e.numeric.type;
            break;
 
        case HLSL_CLASS_ARRAY:
            if (!(type->e.array.type = hlsl_type_clone(ctx, old->e.array.type, default_majority, modifiers)))
            {
                vkd3d_free((void *)type->name);
                vkd3d_free(type);
                return NULL;
            }
            type->e.array.elements_count = old->e.array.elements_count;
            break;
 
        case HLSL_CLASS_STRUCT:
        {
            size_t field_count = old->e.record.field_count, i;
 
            type->e.record.field_count = field_count;
 
            if (!(type->e.record.fields = hlsl_calloc(ctx, field_count, sizeof(*type->e.record.fields))))
            {
                vkd3d_free((void *)type->name);
                vkd3d_free(type);
                return NULL;
            }
 
            for (i = 0; i < field_count; ++i)
            {
                const struct hlsl_struct_field *src_field = &old->e.record.fields[i];
                struct hlsl_struct_field *dst_field = &type->e.record.fields[i];
 
                dst_field->loc = src_field->loc;
                if (!(dst_field->type = hlsl_type_clone(ctx, src_field->type, default_majority, modifiers)))
                {
                    vkd3d_free(type->e.record.fields);
                    vkd3d_free((void *)type->name);
                    vkd3d_free(type);
                    return NULL;
                }
                dst_field->name = hlsl_strdup(ctx, src_field->name);
                if (src_field->semantic.name)
                {
                    dst_field->semantic.name = hlsl_strdup(ctx, src_field->semantic.name);
                    dst_field->semantic.index = src_field->semantic.index;
                }
            }
            break;
        }
 
        case HLSL_CLASS_UAV:
            type->e.resource.rasteriser_ordered = old->e.resource.rasteriser_ordered;
            /* fall through */
        case HLSL_CLASS_TEXTURE:
            type->e.resource.format = old->e.resource.format;
            break;
 
        case HLSL_CLASS_TECHNIQUE:
            type->e.version = old->e.version;
            break;
 
        default:
            break;
    }
 
    hlsl_type_calculate_reg_size(ctx, type);
 
    list_add_tail(&ctx->types, &type->entry);
    return type;
}

Referenced by hlsl_type_clone().

◆ hlsl_type_component_count()

unsigned int hlsl_type_component_count ( const struct hlsl_type * type )

Definition at line 1042 of file hlsl.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_SCALAR:
        case HLSL_CLASS_VECTOR:
        case HLSL_CLASS_MATRIX:
            return type->dimx * type->dimy;
 
        case HLSL_CLASS_STRUCT:
        {
            unsigned int count = 0, i;
 
            for (i = 0; i < type->e.record.field_count; ++i)
                count += hlsl_type_component_count(type->e.record.fields[i].type);
            return count;
        }
 
        case HLSL_CLASS_ARRAY:
            return hlsl_type_component_count(type->e.array.type) * type->e.array.elements_count;
 
        case HLSL_CLASS_CONSTANT_BUFFER:
            return hlsl_type_component_count(type->e.resource.format);
 
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_ERROR:
        case HLSL_CLASS_PIXEL_SHADER:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_SAMPLER:
        case HLSL_CLASS_STRING:
        case HLSL_CLASS_TEXTURE:
        case HLSL_CLASS_UAV:
        case HLSL_CLASS_VERTEX_SHADER:
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_NULL:
            return 1;
 
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_TECHNIQUE:
        case HLSL_CLASS_VOID:
            break;
    }
 
    vkd3d_unreachable();
}

Referenced by copy_propagation_create_var_def(), copy_propagation_get_value(), copy_propagation_invalidate_variable_from_deref_recurse(), copy_propagation_replace_with_constant_vector(), copy_propagation_replace_with_single_instr(), copy_propagation_var_def_destroy(), get_component_index_from_default_initializer_index(), hlsl_component_index_range_from_deref(), hlsl_dump_var_default_values(), hlsl_free_var(), hlsl_type_component_count(), lower_discard_neg(), lower_f16tof32(), lower_f32tof16(), lower_round(), prepend_uniform_copy(), sm4_get_extern_resources(), traverse_path_from_component_index(), write_fx_2_default_value(), write_fx_4_default_value(), write_fx_4_state_numeric_value(), write_fx_4_type(), write_sm1_uniforms(), write_sm4_rdef(), and write_sm4_type().

◆ hlsl_type_element_count()

unsigned int hlsl_type_element_count ( const struct hlsl_type * type )

Definition at line 209 of file hlsl.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_VECTOR:
            return type->dimx;
        case HLSL_CLASS_MATRIX:
            return hlsl_type_major_size(type);
        case HLSL_CLASS_ARRAY:
            return type->e.array.elements_count;
        case HLSL_CLASS_STRUCT:
            return type->e.record.field_count;
        default:
            return 0;
    }
}

Referenced by append_output_copy_recurse(), copy_propagation_invalidate_variable_from_deref_recurse(), lower_nonconstant_array_loads(), and prepend_input_copy_recurse().

◆ hlsl_type_get_array_element_reg_size()

unsigned int hlsl_type_get_array_element_reg_size	(	const struct hlsl_type *	type,
		enum hlsl_regset	regset
	)

Definition at line 444 of file hlsl.c.

{
    if (regset == HLSL_REGSET_NUMERIC)
        return align(type->reg_size[regset], 4);
    return type->reg_size[regset];
}

Referenced by append_output_copy_recurse(), new_offset_from_path_index(), and prepend_input_copy_recurse().

◆ hlsl_type_get_component_offset()

unsigned int hlsl_type_get_component_offset	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	type,
		unsigned int	index,
		enum hlsl_regset *	regset
	)

Definition at line 620 of file hlsl.c.

{
    unsigned int offset[HLSL_REGSET_LAST + 1] = {0};
    struct hlsl_type *next_type;
    unsigned int idx, r;
 
    while (!type_is_single_component(type))
    {
        next_type = type;
        idx = traverse_path_from_component_index(ctx, &next_type, &index);
 
        switch (type->class)
        {
            case HLSL_CLASS_VECTOR:
                offset[HLSL_REGSET_NUMERIC] += idx;
                break;
 
            case HLSL_CLASS_MATRIX:
                offset[HLSL_REGSET_NUMERIC] += 4 * idx;
                break;
 
            case HLSL_CLASS_STRUCT:
                for (r = 0; r <= HLSL_REGSET_LAST; ++r)
                    offset[r] += type->e.record.fields[idx].reg_offset[r];
                break;
 
            case HLSL_CLASS_ARRAY:
                for (r = 0; r <= HLSL_REGSET_LAST; ++r)
                {
                    if (r == HLSL_REGSET_NUMERIC)
                        offset[r] += idx * align(type->e.array.type->reg_size[r], 4);
                    else
                        offset[r] += idx * type->e.array.type->reg_size[r];
                }
                break;
 
            case HLSL_CLASS_DEPTH_STENCIL_STATE:
            case HLSL_CLASS_DEPTH_STENCIL_VIEW:
            case HLSL_CLASS_PIXEL_SHADER:
            case HLSL_CLASS_RASTERIZER_STATE:
            case HLSL_CLASS_RENDER_TARGET_VIEW:
            case HLSL_CLASS_SAMPLER:
            case HLSL_CLASS_STRING:
            case HLSL_CLASS_TEXTURE:
            case HLSL_CLASS_UAV:
            case HLSL_CLASS_VERTEX_SHADER:
            case HLSL_CLASS_COMPUTE_SHADER:
            case HLSL_CLASS_DOMAIN_SHADER:
            case HLSL_CLASS_HULL_SHADER:
            case HLSL_CLASS_GEOMETRY_SHADER:
            case HLSL_CLASS_BLEND_STATE:
                VKD3D_ASSERT(idx == 0);
                break;
 
            case HLSL_CLASS_EFFECT_GROUP:
            case HLSL_CLASS_ERROR:
            case HLSL_CLASS_PASS:
            case HLSL_CLASS_TECHNIQUE:
            case HLSL_CLASS_VOID:
            case HLSL_CLASS_SCALAR:
            case HLSL_CLASS_CONSTANT_BUFFER:
            case HLSL_CLASS_NULL:
                vkd3d_unreachable();
        }
        type = next_type;
    }
 
    *regset = type_get_regset(type);
    return offset[*regset];
}

Referenced by sm4_get_extern_resources(), write_sm1_uniforms(), and write_sm4_rdef().

◆ hlsl_type_get_component_type()

struct hlsl_type * hlsl_type_get_component_type	(	struct hlsl_ctx *	ctx,
		struct hlsl_type *	type,
		unsigned int	index
	)

Definition at line 611 of file hlsl.c.

{
    while (!type_is_single_component(type))
        traverse_path_from_component_index(ctx, &type, &index);
 
    return type;
}

Referenced by hlsl_new_load_component(), sm4_get_extern_resources(), write_sm1_uniforms(), and write_sm4_rdef().

◆ hlsl_type_get_sm4_offset()

unsigned int hlsl_type_get_sm4_offset	(	const struct hlsl_type *	type,
		unsigned int	offset
	)

Definition at line 332 of file hlsl.c.

{
    /* Align to the next vec4 boundary if:
     *  (a) the type is a struct or array type, or
     *  (b) the type would cross a vec4 boundary; i.e. a vec3 and a
     *      vec1 can be packed together, but not a vec3 and a vec2.
     */
    if (type->class == HLSL_CLASS_STRUCT || type->class == HLSL_CLASS_ARRAY
            || (offset & 3) + type->reg_size[HLSL_REGSET_NUMERIC] > 4)
        return align(offset, 4);
    return offset;
}

Referenced by hlsl_calculate_buffer_offset(), and hlsl_type_calculate_reg_size().

◆ hlsl_type_is_resource()

bool hlsl_type_is_resource ( const struct hlsl_type * type )

Definition at line 240 of file hlsl.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_ARRAY:
            return hlsl_type_is_resource(type->e.array.type);
 
        case HLSL_CLASS_SAMPLER:
        case HLSL_CLASS_TEXTURE:
        case HLSL_CLASS_UAV:
            return true;
 
        default:
            return false;
    }
}

Referenced by allocate_buffers(), append_output_copy_recurse(), hlsl_calculate_buffer_offsets(), hlsl_type_is_resource(), lower_combined_samples(), prepend_input_copy_recurse(), process_entry_function(), sm1_generate_vsir_init_src_param_from_deref(), sm4_get_extern_resources(), and validate_buffer_offsets().

◆ hlsl_type_is_row_major()

bool hlsl_type_is_row_major ( const struct hlsl_type * type )

Definition at line 186 of file hlsl.c.

{
    /* Default to column-major if the majority isn't explicitly set, which can
     * happen for anonymous nodes. */
    return !!(type->modifiers & HLSL_MODIFIER_ROW_MAJOR);
}

Referenced by hlsl_component_index_range_from_deref(), hlsl_get_element_type_from_path_index(), hlsl_index_is_noncontiguous(), hlsl_type_calculate_reg_size(), hlsl_type_major_size(), hlsl_type_minor_size(), lower_index_loads(), lower_nonconstant_array_loads(), and traverse_path_from_component_index().

◆ hlsl_type_is_shader()

bool hlsl_type_is_shader ( const struct hlsl_type * type )

Definition at line 257 of file hlsl.c.

{
    switch (type->class)
    {
        case HLSL_CLASS_ARRAY:
            return hlsl_type_is_shader(type->e.array.type);
 
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_PIXEL_SHADER:
        case HLSL_CLASS_VERTEX_SHADER:
            return true;
 
        case HLSL_CLASS_SCALAR:
        case HLSL_CLASS_VECTOR:
        case HLSL_CLASS_MATRIX:
        case HLSL_CLASS_STRUCT:
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_ERROR:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_SAMPLER:
        case HLSL_CLASS_STRING:
        case HLSL_CLASS_TECHNIQUE:
        case HLSL_CLASS_TEXTURE:
        case HLSL_CLASS_UAV:
        case HLSL_CLASS_CONSTANT_BUFFER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_VOID:
        case HLSL_CLASS_NULL:
            return false;
    }
    return false;
}

Referenced by hlsl_type_is_shader().

◆ hlsl_type_major_size()

unsigned int hlsl_type_major_size ( const struct hlsl_type * type )

Definition at line 201 of file hlsl.c.

{
    if (type->class != HLSL_CLASS_MATRIX || hlsl_type_is_row_major(type))
        return type->dimy;
    else
        return type->dimx;
}

Referenced by append_output_copy(), hlsl_component_index_range_from_deref(), hlsl_regset_index_from_deref(), hlsl_type_element_count(), prepend_input_copy(), split_matrix_copies(), and validate_component_index_range_from_deref().

◆ hlsl_type_minor_size()

unsigned int hlsl_type_minor_size ( const struct hlsl_type * type )

Definition at line 193 of file hlsl.c.

{
    if (type->class != HLSL_CLASS_MATRIX || hlsl_type_is_row_major(type))
        return type->dimx;
    else
        return type->dimy;
}

Referenced by append_output_copy(), prepend_input_copy(), and split_matrix_copies().

◆ hlsl_type_to_string()

struct vkd3d_string_buffer * hlsl_type_to_string	(	struct hlsl_ctx *	ctx,
		const struct hlsl_type *	type
	)

Definition at line 2696 of file hlsl.c.

{
    struct vkd3d_string_buffer *string, *inner_string;
 
    static const char *const base_types[] =
    {
        [HLSL_TYPE_FLOAT] = "float",
        [HLSL_TYPE_HALF] = "half",
        [HLSL_TYPE_DOUBLE] = "double",
        [HLSL_TYPE_INT] = "int",
        [HLSL_TYPE_UINT] = "uint",
        [HLSL_TYPE_BOOL] = "bool",
    };
 
    static const char *const dimensions[] =
    {
        [HLSL_SAMPLER_DIM_1D]        = "1D",
        [HLSL_SAMPLER_DIM_2D]        = "2D",
        [HLSL_SAMPLER_DIM_3D]        = "3D",
        [HLSL_SAMPLER_DIM_CUBE]      = "Cube",
        [HLSL_SAMPLER_DIM_1DARRAY]   = "1DArray",
        [HLSL_SAMPLER_DIM_2DARRAY]   = "2DArray",
        [HLSL_SAMPLER_DIM_2DMS]      = "2DMS",
        [HLSL_SAMPLER_DIM_2DMSARRAY] = "2DMSArray",
        [HLSL_SAMPLER_DIM_CUBEARRAY] = "CubeArray",
    };
 
    if (!(string = hlsl_get_string_buffer(ctx)))
        return NULL;
 
    if (type->name)
    {
        vkd3d_string_buffer_printf(string, "%s", type->name);
        return string;
    }
 
    switch (type->class)
    {
        case HLSL_CLASS_SCALAR:
            VKD3D_ASSERT(type->e.numeric.type < ARRAY_SIZE(base_types));
            vkd3d_string_buffer_printf(string, "%s", base_types[type->e.numeric.type]);
            return string;
 
        case HLSL_CLASS_VECTOR:
            VKD3D_ASSERT(type->e.numeric.type < ARRAY_SIZE(base_types));
            vkd3d_string_buffer_printf(string, "%s%u", base_types[type->e.numeric.type], type->dimx);
            return string;
 
        case HLSL_CLASS_MATRIX:
            VKD3D_ASSERT(type->e.numeric.type < ARRAY_SIZE(base_types));
            vkd3d_string_buffer_printf(string, "%s%ux%u", base_types[type->e.numeric.type], type->dimy, type->dimx);
            return string;
 
        case HLSL_CLASS_ARRAY:
        {
            const struct hlsl_type *t;
 
            for (t = type; t->class == HLSL_CLASS_ARRAY; t = t->e.array.type)
                ;
 
            if ((inner_string = hlsl_type_to_string(ctx, t)))
            {
                vkd3d_string_buffer_printf(string, "%s", inner_string->buffer);
                hlsl_release_string_buffer(ctx, inner_string);
            }
 
            for (t = type; t->class == HLSL_CLASS_ARRAY; t = t->e.array.type)
            {
                if (t->e.array.elements_count == HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT)
                    vkd3d_string_buffer_printf(string, "[]");
                else
                    vkd3d_string_buffer_printf(string, "[%u]", t->e.array.elements_count);
            }
            return string;
        }
 
        case HLSL_CLASS_STRUCT:
            vkd3d_string_buffer_printf(string, "<anonymous struct>");
            return string;
 
        case HLSL_CLASS_TEXTURE:
            if (type->sampler_dim == HLSL_SAMPLER_DIM_RAW_BUFFER)
            {
                vkd3d_string_buffer_printf(string, "ByteAddressBuffer");
                return string;
            }
 
            if (type->sampler_dim == HLSL_SAMPLER_DIM_GENERIC)
            {
                vkd3d_string_buffer_printf(string, "Texture");
                return string;
            }
 
            VKD3D_ASSERT(hlsl_is_numeric_type(type->e.resource.format));
            VKD3D_ASSERT(type->e.resource.format->e.numeric.type < ARRAY_SIZE(base_types));
            if (type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER)
            {
                vkd3d_string_buffer_printf(string, "Buffer");
            }
            else
            {
                VKD3D_ASSERT(type->sampler_dim < ARRAY_SIZE(dimensions));
                vkd3d_string_buffer_printf(string, "Texture%s", dimensions[type->sampler_dim]);
            }
            if ((inner_string = hlsl_type_to_string(ctx, type->e.resource.format)))
            {
                vkd3d_string_buffer_printf(string, "<%s>", inner_string->buffer);
                hlsl_release_string_buffer(ctx, inner_string);
            }
            return string;
 
        case HLSL_CLASS_UAV:
            if (type->sampler_dim == HLSL_SAMPLER_DIM_RAW_BUFFER)
            {
                vkd3d_string_buffer_printf(string, "RWByteAddressBuffer");
                return string;
            }
            if (type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER)
                vkd3d_string_buffer_printf(string, "RWBuffer");
            else if (type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
                vkd3d_string_buffer_printf(string, "RWStructuredBuffer");
            else
                vkd3d_string_buffer_printf(string, "RWTexture%s", dimensions[type->sampler_dim]);
            if ((inner_string = hlsl_type_to_string(ctx, type->e.resource.format)))
            {
                vkd3d_string_buffer_printf(string, "<%s>", inner_string->buffer);
                hlsl_release_string_buffer(ctx, inner_string);
            }
            return string;
 
        case HLSL_CLASS_CONSTANT_BUFFER:
            vkd3d_string_buffer_printf(string, "ConstantBuffer");
            if ((inner_string = hlsl_type_to_string(ctx, type->e.resource.format)))
            {
                vkd3d_string_buffer_printf(string, "<%s>", inner_string->buffer);
                hlsl_release_string_buffer(ctx, inner_string);
            }
            return string;
 
        case HLSL_CLASS_ERROR:
            vkd3d_string_buffer_printf(string, "<error type>");
            return string;
 
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_PIXEL_SHADER:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_SAMPLER:
        case HLSL_CLASS_STRING:
        case HLSL_CLASS_TECHNIQUE:
        case HLSL_CLASS_VERTEX_SHADER:
        case HLSL_CLASS_VOID:
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_NULL:
            break;
    }
 
    vkd3d_string_buffer_printf(string, "<unexpected type>");
    return string;
}

Referenced by allocate_register_reservations(), append_output_copy(), debug_hlsl_type(), dump_ir_call(), generate_vsir_signature_entry(), get_string_argument_value(), hlsl_type_to_string(), parse_numthreads_attribute(), parse_outputcontrolpoints_attribute(), prepend_input_copy(), and sm4_generate_vsir_block().

◆ hlsl_types_are_equal()

bool hlsl_types_are_equal	(	const struct hlsl_type *	t1,
		const struct hlsl_type *	t2
	)

Definition at line 1095 of file hlsl.c.

{
    if (t1 == t2)
        return true;
 
    if (t1->class != t2->class)
        return false;
 
    switch (t1->class)
    {
        case HLSL_CLASS_SCALAR:
        case HLSL_CLASS_VECTOR:
        case HLSL_CLASS_MATRIX:
            if (t1->e.numeric.type != t2->e.numeric.type)
                return false;
            if ((t1->modifiers & HLSL_MODIFIER_ROW_MAJOR)
                    != (t2->modifiers & HLSL_MODIFIER_ROW_MAJOR))
                return false;
            if (t1->dimx != t2->dimx)
                return false;
            if (t1->dimy != t2->dimy)
                return false;
            return true;
 
        case HLSL_CLASS_UAV:
            if (t1->e.resource.rasteriser_ordered != t2->e.resource.rasteriser_ordered)
                return false;
            /* fall through */
        case HLSL_CLASS_TEXTURE:
            if (t1->sampler_dim != HLSL_SAMPLER_DIM_GENERIC
                    && !hlsl_types_are_equal(t1->e.resource.format, t2->e.resource.format))
                return false;
            /* fall through */
        case HLSL_CLASS_SAMPLER:
            if (t1->sampler_dim != t2->sampler_dim)
                return false;
            return true;
 
        case HLSL_CLASS_STRUCT:
            if (t1->e.record.field_count != t2->e.record.field_count)
                return false;
 
            for (size_t i = 0; i < t1->e.record.field_count; ++i)
            {
                const struct hlsl_struct_field *field1 = &t1->e.record.fields[i];
                const struct hlsl_struct_field *field2 = &t2->e.record.fields[i];
 
                if (!hlsl_types_are_equal(field1->type, field2->type))
                    return false;
 
                if (strcmp(field1->name, field2->name))
                    return false;
            }
            return true;
 
        case HLSL_CLASS_ARRAY:
            return t1->e.array.elements_count == t2->e.array.elements_count
                    && hlsl_types_are_equal(t1->e.array.type, t2->e.array.type);
 
        case HLSL_CLASS_TECHNIQUE:
            return t1->e.version == t2->e.version;
 
        case HLSL_CLASS_CONSTANT_BUFFER:
            return hlsl_types_are_equal(t1->e.resource.format, t2->e.resource.format);
 
        case HLSL_CLASS_DEPTH_STENCIL_STATE:
        case HLSL_CLASS_DEPTH_STENCIL_VIEW:
        case HLSL_CLASS_EFFECT_GROUP:
        case HLSL_CLASS_ERROR:
        case HLSL_CLASS_PASS:
        case HLSL_CLASS_PIXEL_SHADER:
        case HLSL_CLASS_RASTERIZER_STATE:
        case HLSL_CLASS_RENDER_TARGET_VIEW:
        case HLSL_CLASS_STRING:
        case HLSL_CLASS_VERTEX_SHADER:
        case HLSL_CLASS_VOID:
        case HLSL_CLASS_COMPUTE_SHADER:
        case HLSL_CLASS_DOMAIN_SHADER:
        case HLSL_CLASS_HULL_SHADER:
        case HLSL_CLASS_GEOMETRY_SHADER:
        case HLSL_CLASS_BLEND_STATE:
        case HLSL_CLASS_NULL:
            return true;
    }
 
    vkd3d_unreachable();
}

Referenced by fold_redundant_casts(), func_decl_matches(), hlsl_add_conditional(), hlsl_new_func_decl(), hlsl_new_ternary_expr(), hlsl_types_are_equal(), and write_fx_4_state_assignment().

◆ hlsl_validate_state_block_entry()

bool hlsl_validate_state_block_entry	(	struct hlsl_ctx *	ctx,
		struct hlsl_state_block_entry *	entry,
		const struct vkd3d_shader_location *	loc
	)

Definition at line 145 of file fx.c.

{
    if (entry->is_function_call)
    {
        const struct state_block_function_info *info = get_state_block_function_info(entry->name);
 
        if (!info)
        {
            hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_STATE_BLOCK_ENTRY,
                    "Invalid state block function '%s'.", entry->name);
            return false;
        }
        if (entry->args_count < info->min_args || entry->args_count > info->max_args)
        {
            if (info->min_args == info->max_args)
            {
                hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_STATE_BLOCK_ENTRY,
                        "Invalid argument count for state block function '%s' (expected %u).",
                        entry->name, info->min_args);
            }
            else
            {
                hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_STATE_BLOCK_ENTRY,
                        "Invalid argument count for state block function '%s' (expected from %u to %u).",
                        entry->name, info->min_args, info->max_args);
            }
            return false;
        }
    }
 
    return true;
}

◆ hlsl_var_has_buffer_offset_register_reservation()

static bool hlsl_var_has_buffer_offset_register_reservation	(	struct hlsl_ctx *	ctx,
		const struct hlsl_ir_var *	var
	)

inlinestatic

Definition at line 1418 of file hlsl.h.

{
    return var->reg_reservation.reg_type == 'c' && var->buffer == ctx->globals_buffer;
}

Referenced by hlsl_calculate_buffer_offsets().

◆ hlsl_version_ge()

static bool hlsl_version_ge	(	const struct hlsl_ctx *	ctx,
		unsigned int	major,
		unsigned int	minor
	)

inlinestatic

Definition at line 1141 of file hlsl.h.

{
    return ctx->profile->major_version > major || (ctx->profile->major_version == major && ctx->profile->minor_version >= minor);
}

Referenced by allocate_buffers(), allocate_objects(), generate_vsir_signature_entry(), get_max_cbuffer_reg_index(), hlsl_version_lt(), loop_unrolling_get_max_iterations(), process_entry_function(), sm4_generate_vsir_instr_expr(), tpf_write_stat(), vsir_src_from_hlsl_node(), write_sm4_dcl_constant_buffer(), write_sm4_dcl_samplers(), and write_sm4_rdef().

◆ hlsl_version_lt()

static bool hlsl_version_lt	(	const struct hlsl_ctx *	ctx,
		unsigned int	major,
		unsigned int	minor
	)

inlinestatic

Definition at line 1146 of file hlsl.h.

{
    return !hlsl_version_ge(ctx, major, minor);
}

Referenced by decompose_fx_4_state_block_expand_array(), process_entry_function(), sm1_generate_vsir_instr_if(), sm4_get_extern_resources(), and vsir_data_type_from_hlsl_type().

◆ hlsl_warning()

void void void hlsl_warning	(	struct hlsl_ctx *	ctx,
		const struct vkd3d_shader_location *	loc,
		enum vkd3d_shader_error	error,
		const char *	fmt,
			...
	)

◆ sm4_get_interpolation_mode()

enum vkd3d_shader_interpolation_mode sm4_get_interpolation_mode	(	struct hlsl_type *	type,
		unsigned int	storage_modifiers
	)

Definition at line 5273 of file hlsl_codegen.c.

{
    unsigned int i;
 
    static const struct
    {
        unsigned int modifiers;
        enum vkd3d_shader_interpolation_mode mode;
    }
    modes[] =
    {
        {HLSL_STORAGE_CENTROID | HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE_CENTROID},
        {HLSL_STORAGE_NOPERSPECTIVE, VKD3DSIM_LINEAR_NOPERSPECTIVE},
        {HLSL_STORAGE_CENTROID, VKD3DSIM_LINEAR_CENTROID},
        {HLSL_STORAGE_CENTROID | HLSL_STORAGE_LINEAR, VKD3DSIM_LINEAR_CENTROID},
    };
 
    if ((storage_modifiers & HLSL_STORAGE_NOINTERPOLATION)
            || base_type_get_semantic_equivalent(type->e.numeric.type) == HLSL_TYPE_UINT)
        return VKD3DSIM_CONSTANT;
 
    for (i = 0; i < ARRAY_SIZE(modes); ++i)
    {
        if ((storage_modifiers & modes[i].modifiers) == modes[i].modifiers)
            return modes[i].mode;
    }
 
    return VKD3DSIM_LINEAR;
}

Referenced by allocate_semantic_register(), and sm4_generate_vsir_instr_dcl_semantic().

◆ tpf_compile()

int tpf_compile	(	struct vsir_program *	program,
		uint64_t	config_flags,
		struct vkd3d_shader_code *	out,
		struct vkd3d_shader_message_context *	message_context,
		struct hlsl_ctx *	ctx,
		struct hlsl_ir_function_decl *	entry_func
	)

Definition at line 6046 of file tpf.c.

{
    enum vkd3d_shader_type shader_type = program->shader_version.type;
    struct tpf_compiler tpf = {0};
    struct sm4_stat stat = {0};
    size_t i;
    int ret;
 
    tpf.ctx = ctx;
    tpf.program = program;
    tpf.buffer = NULL;
    tpf.stat = &stat;
    init_sm4_lookup_tables(&tpf.lookup);
    dxbc_writer_init(&tpf.dxbc);
 
    tpf_write_signature(&tpf, &program->input_signature, TAG_ISGN);
    tpf_write_signature(&tpf, &program->output_signature, TAG_OSGN);
    if (shader_type == VKD3D_SHADER_TYPE_HULL || shader_type == VKD3D_SHADER_TYPE_DOMAIN)
        tpf_write_signature(&tpf, &program->patch_constant_signature, TAG_PCSG);
    write_sm4_rdef(ctx, &tpf.dxbc);
    tpf_write_shdr(&tpf, entry_func);
    tpf_write_sfi0(&tpf);
    tpf_write_stat(&tpf);
 
    ret = VKD3D_OK;
    if (ctx->result)
        ret = ctx->result;
    if (tpf.result)
        ret = tpf.result;
 
    if (!ret)
        ret = dxbc_writer_write(&tpf.dxbc, out);
    for (i = 0; i < tpf.dxbc.section_count; ++i)
        vkd3d_shader_free_shader_code(&tpf.dxbc.sections[i].data);
    return ret;
}

Referenced by hlsl_emit_bytecode().

◆ vsir_swizzle_from_hlsl()

static uint32_t vsir_swizzle_from_hlsl ( uint32_t swizzle )

inlinestatic

Definition at line 73 of file hlsl.h.

{
    return vkd3d_shader_create_swizzle(hlsl_swizzle_get_component(swizzle, 0),
            hlsl_swizzle_get_component(swizzle, 1),
            hlsl_swizzle_get_component(swizzle, 2),
            hlsl_swizzle_get_component(swizzle, 3));
}

Referenced by generate_vsir_get_src_swizzle(), and generate_vsir_instr_swizzle().

◆ write_sm1_uniforms()

void write_sm1_uniforms	(	struct hlsl_ctx *	ctx,
		struct vkd3d_bytecode_buffer *	buffer
	)

Definition at line 1752 of file d3dbc.c.

{
    size_t ctab_offset, ctab_start, ctab_end, vars_offset, vars_start, size_offset, creator_offset, offset;
    unsigned int uniform_count = 0;
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
    {
        unsigned int r;
 
        for (r = 0; r <= HLSL_REGSET_LAST; ++r)
        {
            if (var->semantic.name || !var->regs[r].allocated || !var->last_read)
                continue;
 
            ++uniform_count;
 
            if (var->is_param && var->is_uniform)
            {
                char *new_name;
 
                if (!(new_name = hlsl_sprintf_alloc(ctx, "$%s", var->name)))
                    return;
                vkd3d_free((char *)var->name);
                var->name = new_name;
            }
        }
    }
 
    sm1_sort_externs(ctx);
 
    size_offset = put_u32(buffer, 0);
    ctab_offset = put_u32(buffer, VKD3D_MAKE_TAG('C','T','A','B'));
 
    ctab_start = put_u32(buffer, 7 * sizeof(uint32_t)); /* CTAB header size. */
    creator_offset = put_u32(buffer, 0);
    put_u32(buffer, sm1_version(ctx->profile->type, ctx->profile->major_version, ctx->profile->minor_version));
    put_u32(buffer, uniform_count);
    vars_offset = put_u32(buffer, 0);
    put_u32(buffer, 0); /* FIXME: flags */
    put_u32(buffer, 0); /* FIXME: target string */
 
    vars_start = bytecode_align(buffer);
    set_u32(buffer, vars_offset, vars_start - ctab_start);
 
    LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
    {
        unsigned int r;
 
        for (r = 0; r <= HLSL_REGSET_LAST; ++r)
        {
            if (var->semantic.name || !var->regs[r].allocated || !var->last_read)
                continue;
 
            put_u32(buffer, 0); /* name */
            if (r == HLSL_REGSET_NUMERIC)
            {
                put_u32(buffer, vkd3d_make_u32(D3DXRS_FLOAT4, var->regs[r].id));
                put_u32(buffer, var->bind_count[r]);
            }
            else
            {
                put_u32(buffer, vkd3d_make_u32(D3DXRS_SAMPLER, var->regs[r].index));
                put_u32(buffer, var->bind_count[r]);
            }
            put_u32(buffer, 0); /* type */
            put_u32(buffer, 0); /* default value */
        }
    }
 
    uniform_count = 0;
 
    LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
    {
        unsigned int r;
 
        for (r = 0; r <= HLSL_REGSET_LAST; ++r)
        {
            size_t var_offset, name_offset;
 
            if (var->semantic.name || !var->regs[r].allocated || !var->last_read)
                continue;
 
            var_offset = vars_start + (uniform_count * 5 * sizeof(uint32_t));
 
            name_offset = put_string(buffer, var->name);
            set_u32(buffer, var_offset, name_offset - ctab_start);
 
            write_sm1_type(buffer, var->data_type, ctab_start);
            set_u32(buffer, var_offset + 3 * sizeof(uint32_t), var->data_type->bytecode_offset - ctab_start);
 
            if (var->default_values)
            {
                unsigned int reg_size = var->data_type->reg_size[HLSL_REGSET_NUMERIC];
                unsigned int comp_count = hlsl_type_component_count(var->data_type);
                unsigned int default_value_offset;
                unsigned int k;
 
                default_value_offset = bytecode_reserve_bytes(buffer, reg_size * sizeof(uint32_t));
                set_u32(buffer, var_offset + 4 * sizeof(uint32_t), default_value_offset - ctab_start);
 
                for (k = 0; k < comp_count; ++k)
                {
                    struct hlsl_type *comp_type = hlsl_type_get_component_type(ctx, var->data_type, k);
                    unsigned int comp_offset;
                    enum hlsl_regset regset;
 
                    comp_offset = hlsl_type_get_component_offset(ctx, var->data_type, k, &regset);
                    if (regset == HLSL_REGSET_NUMERIC)
                    {
                        union
                        {
                            uint32_t u;
                            float f;
                        } uni;
 
                        switch (comp_type->e.numeric.type)
                        {
                            case HLSL_TYPE_DOUBLE:
                                if (ctx->double_as_float_alias)
                                    uni.u = var->default_values[k].number.u;
                                else
                                    uni.u = 0;
                                break;
 
                            case HLSL_TYPE_INT:
                                uni.f = var->default_values[k].number.i;
                                break;
 
                            case HLSL_TYPE_UINT:
                            case HLSL_TYPE_BOOL:
                                uni.f = var->default_values[k].number.u;
                                break;
 
                            case HLSL_TYPE_HALF:
                            case HLSL_TYPE_FLOAT:
                                uni.u = var->default_values[k].number.u;
                                break;
 
                            default:
                                vkd3d_unreachable();
                        }
 
                        set_u32(buffer, default_value_offset + comp_offset * sizeof(uint32_t), uni.u);
                    }
                }
            }
 
            ++uniform_count;
        }
    }
 
    offset = put_string(buffer, vkd3d_shader_get_version(NULL, NULL));
    set_u32(buffer, creator_offset, offset - ctab_start);
 
    ctab_end = bytecode_align(buffer);
    set_u32(buffer, size_offset, vkd3d_make_u32(VKD3D_SM1_OP_COMMENT, (ctab_end - ctab_offset) / sizeof(uint32_t)));
}

Referenced by sm1_generate_vsir().

Classes

Macros

Enumerations

Functions

Macro Definition Documentation

◆ HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT

◆ HLSL_INTERPOLATION_MODIFIERS_MASK

◆ HLSL_MAX_OPERANDS

◆ HLSL_MODIFIER_COLUMN_MAJOR

◆ HLSL_MODIFIER_CONST

◆ HLSL_MODIFIER_EXPORT

◆ HLSL_MODIFIER_INLINE

◆ HLSL_MODIFIER_PRECISE

◆ HLSL_MODIFIER_ROW_MAJOR

◆ HLSL_MODIFIER_SINGLE

◆ HLSL_MODIFIER_SNORM

◆ HLSL_MODIFIER_UNORM

◆ HLSL_MODIFIER_VOLATILE

◆ HLSL_MODIFIERS_MAJORITY_MASK

◆ HLSL_STORAGE_ANNOTATION

◆ HLSL_STORAGE_CENTROID

◆ HLSL_STORAGE_EXTERN

◆ HLSL_STORAGE_GROUPSHARED

◆ HLSL_STORAGE_IN

◆ HLSL_STORAGE_LINEAR

◆ HLSL_STORAGE_NOINTERPOLATION

◆ HLSL_STORAGE_NOPERSPECTIVE

◆ HLSL_STORAGE_OUT

◆ HLSL_STORAGE_SHARED

◆ HLSL_STORAGE_STATIC

◆ HLSL_STORAGE_UNIFORM

◆ HLSL_SWIZZLE

◆ HLSL_SWIZZLE_MASK

◆ HLSL_SWIZZLE_SHIFT

◆ HLSL_SWIZZLE_W

◆ HLSL_SWIZZLE_X

◆ HLSL_SWIZZLE_Y

◆ HLSL_SWIZZLE_Z

◆ HLSL_TYPE_MODIFIERS_MASK

Enumeration Type Documentation

◆ hlsl_base_type

◆ hlsl_buffer_type

◆ hlsl_ir_expr_op

◆ hlsl_ir_jump_type

◆ hlsl_ir_loop_unroll_type

◆ hlsl_ir_node_type

◆ hlsl_regset

◆ hlsl_resource_load_type

◆ hlsl_sampler_dim

◆ hlsl_type_class

Function Documentation

◆ clone_stateblock_entry()

◆ d3dbc_compile()

◆ debug_hlsl_expr_op()

◆ debug_hlsl_swizzle()

◆ debug_hlsl_type()

◆ debug_hlsl_writemask()

◆ hlsl_add_conditional()

◆ hlsl_add_function()

◆ hlsl_add_load_component()

◆ hlsl_add_var()

◆ hlsl_alloc()

◆ hlsl_array_reserve()

◆ hlsl_block_add_block()

◆ hlsl_block_add_instr()

◆ hlsl_block_cleanup()

◆ hlsl_block_init()

◆ hlsl_calculate_buffer_offsets()

◆ hlsl_calloc()

◆ hlsl_cleanup_deref()

◆ hlsl_cleanup_ir_switch_cases()

◆ hlsl_cleanup_semantic()

◆ hlsl_clone_block()

◆ hlsl_clone_semantic()

◆ hlsl_combine_swizzles()

◆ hlsl_combine_writemasks()

◆ hlsl_compile_internal_function()

◆ hlsl_component_index_range_from_deref()

◆ hlsl_component_to_string()

◆ hlsl_copy_deref()