#include "wine/debug.h"
#include "wine/list.h"
#include "wine/rbtree.h"
#include "wine/heap.h"
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "d3dcompiler.h"
#include <assert.h>

Include dependency graph for d3dcompiler_private.h:

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

Go to the source code of this file.

Classes
struct	constant

struct	shader_reg

struct	instruction

struct	declaration

struct	samplerdecl

struct	bwriter_shader

struct	rel_reg

struct	src_regs

struct	asmparser_backend

struct	compilation_messages

struct	asm_parser

struct	bytecode_buffer

struct	bytecode_backend

struct	bytecode_backend::instr_handler_table

struct	bc_writer

struct	hlsl_type

struct	hlsl_struct_field

struct	source_location

struct	hlsl_ir_node

struct	reg_reservation

struct	hlsl_ir_var

struct	hlsl_ir_function

struct	hlsl_ir_function_decl

struct	hlsl_ir_if

struct	hlsl_ir_loop

struct	hlsl_ir_assignment

struct	hlsl_ir_expr

struct	hlsl_ir_jump

struct	hlsl_ir_swizzle

struct	hlsl_ir_deref

struct	hlsl_ir_constant

struct	hlsl_ir_constructor

struct	hlsl_scope

struct	parse_parameter

struct	parse_colon_attribute

struct	parse_initializer

struct	parse_variable_def

struct	parse_function

struct	parse_if_body

struct	hlsl_parse_ctx

struct	dxbc_section

struct	dxbc

Macros
#define	COBJMACROS

#define	D3DERR_INVALIDCALL 0x8876086c

#define	INSTRARRAY_INITIAL_SIZE 8

#define	MAX_SRC_REGS 4

#define	MESSAGEBUFFER_INITIAL_SIZE 256

#define	PRINTF_ATTR(fmt, args)

#define	BYTECODEBUFFER_INITIAL_SIZE 32

#define	SWIZZLE_ERR ~0U

#define	BWRITERSP_WRITEMASK_0 0x1 /* .x r */

#define	BWRITERSP_WRITEMASK_1 0x2 /* .y g */

#define	BWRITERSP_WRITEMASK_2 0x4 /* .z b */

#define	BWRITERSP_WRITEMASK_3 0x8 /* .w a */

#define	BWRITERSP_WRITEMASK_ALL 0xf /* all */

#define	BWRITERSI_TEXLD_PROJECT 1

#define	BWRITERSI_TEXLD_BIAS 2

#define	BWRITER_SM1_VS 0xfffeu

#define	BWRITER_SM1_PS 0xffffu

#define	BWRITERPS_VERSION(major, minor) ((BWRITER_SM1_PS << 16) \| ((major) << 8) \| (minor))

#define	BWRITERVS_VERSION(major, minor) ((BWRITER_SM1_VS << 16) \| ((major) << 8) \| (minor))

#define	BWRITERVS_SWIZZLE_SHIFT 16

#define	BWRITERVS_SWIZZLE_MASK (0xFF << BWRITERVS_SWIZZLE_SHIFT)

#define	BWRITERVS_X_X (0 << BWRITERVS_SWIZZLE_SHIFT)

#define	BWRITERVS_X_Y (1 << BWRITERVS_SWIZZLE_SHIFT)

#define	BWRITERVS_X_Z (2 << BWRITERVS_SWIZZLE_SHIFT)

#define	BWRITERVS_X_W (3 << BWRITERVS_SWIZZLE_SHIFT)

#define	BWRITERVS_Y_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 2))

#define	BWRITERVS_Y_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 2))

#define	BWRITERVS_Y_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 2))

#define	BWRITERVS_Y_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 2))

#define	BWRITERVS_Z_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 4))

#define	BWRITERVS_Z_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 4))

#define	BWRITERVS_Z_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 4))

#define	BWRITERVS_Z_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 4))

#define	BWRITERVS_W_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 6))

#define	BWRITERVS_W_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 6))

#define	BWRITERVS_W_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 6))

#define	BWRITERVS_W_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 6))

#define	BWRITERVS_NOSWIZZLE (BWRITERVS_X_X \| BWRITERVS_Y_Y \| BWRITERVS_Z_Z \| BWRITERVS_W_W)

#define	BWRITERVS_SWIZZLE_X (BWRITERVS_X_X \| BWRITERVS_Y_X \| BWRITERVS_Z_X \| BWRITERVS_W_X)

#define	BWRITERVS_SWIZZLE_Y (BWRITERVS_X_Y \| BWRITERVS_Y_Y \| BWRITERVS_Z_Y \| BWRITERVS_W_Y)

#define	BWRITERVS_SWIZZLE_Z (BWRITERVS_X_Z \| BWRITERVS_Y_Z \| BWRITERVS_Z_Z \| BWRITERVS_W_Z)

#define	BWRITERVS_SWIZZLE_W (BWRITERVS_X_W \| BWRITERVS_Y_W \| BWRITERVS_Z_W \| BWRITERVS_W_W)

#define	T0_REG 2

#define	T1_REG 3

#define	T2_REG 4

#define	T3_REG 5

#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_STORAGE_VOLATILE 0x00000080

#define	HLSL_MODIFIER_CONST 0x00000100

#define	HLSL_MODIFIER_ROW_MAJOR 0x00000200

#define	HLSL_MODIFIER_COLUMN_MAJOR 0x00000400

#define	HLSL_MODIFIER_IN 0x00000800

#define	HLSL_MODIFIER_OUT 0x00001000

#define	HLSL_TYPE_MODIFIERS_MASK

#define	HLSL_MODIFIERS_COMPARISON_MASK (HLSL_MODIFIER_ROW_MAJOR \| HLSL_MODIFIER_COLUMN_MAJOR)

#define	MAKE_TAG(ch0, ch1, ch2, ch3)

#define	TAG_Aon9 MAKE_TAG('A', 'o', 'n', '9')

#define	TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')

#define	TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N')

#define	TAG_OSGN MAKE_TAG('O', 'S', 'G', 'N')

#define	TAG_OSG5 MAKE_TAG('O', 'S', 'G', '5')

#define	TAG_PCSG MAKE_TAG('P', 'C', 'S', 'G')

#define	TAG_RDEF MAKE_TAG('R', 'D', 'E', 'F')

#define	TAG_SDBG MAKE_TAG('S', 'D', 'B', 'G')

#define	TAG_SHDR MAKE_TAG('S', 'H', 'D', 'R')

#define	TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X')

#define	TAG_STAT MAKE_TAG('S', 'T', 'A', 'T')

#define	TAG_XNAP MAKE_TAG('X', 'N', 'A', 'P')

#define	TAG_XNAS MAKE_TAG('X', 'N', 'A', 'S')

Typedefs
typedef void(*	instr_writer) (struct bc_writer This, const struct instruction instr, struct bytecode_buffer *buffer)

Enumerations
enum	shader_type { ST_UNKNOWN , ST_VERTEX , ST_PIXEL }

enum	bwriter_comparison_type { BWRITER_COMPARISON_NONE , BWRITER_COMPARISON_GT , BWRITER_COMPARISON_EQ , BWRITER_COMPARISON_GE , BWRITER_COMPARISON_LT , BWRITER_COMPARISON_NE , BWRITER_COMPARISON_LE }

enum	parse_status { PARSE_SUCCESS = 0 , PARSE_WARN = 1 , PARSE_ERR = 2 }

enum	bwritershader_instruction_opcode_type { BWRITERSIO_NOP , BWRITERSIO_MOV , BWRITERSIO_ADD , BWRITERSIO_SUB , BWRITERSIO_MAD , BWRITERSIO_MUL , BWRITERSIO_RCP , BWRITERSIO_RSQ , BWRITERSIO_DP3 , BWRITERSIO_DP4 , BWRITERSIO_MIN , BWRITERSIO_MAX , BWRITERSIO_SLT , BWRITERSIO_SGE , BWRITERSIO_EXP , BWRITERSIO_LOG , BWRITERSIO_LIT , BWRITERSIO_DST , BWRITERSIO_LRP , BWRITERSIO_FRC , BWRITERSIO_M4x4 , BWRITERSIO_M4x3 , BWRITERSIO_M3x4 , BWRITERSIO_M3x3 , BWRITERSIO_M3x2 , BWRITERSIO_CALL , BWRITERSIO_CALLNZ , BWRITERSIO_LOOP , BWRITERSIO_RET , BWRITERSIO_ENDLOOP , BWRITERSIO_LABEL , BWRITERSIO_DCL , BWRITERSIO_POW , BWRITERSIO_CRS , BWRITERSIO_SGN , BWRITERSIO_ABS , BWRITERSIO_NRM , BWRITERSIO_SINCOS , BWRITERSIO_REP , BWRITERSIO_ENDREP , BWRITERSIO_IF , BWRITERSIO_IFC , BWRITERSIO_ELSE , BWRITERSIO_ENDIF , BWRITERSIO_BREAK , BWRITERSIO_BREAKC , BWRITERSIO_MOVA , BWRITERSIO_DEFB , BWRITERSIO_DEFI , BWRITERSIO_TEXCOORD , BWRITERSIO_TEXKILL , BWRITERSIO_TEX , BWRITERSIO_TEXBEM , BWRITERSIO_TEXBEML , BWRITERSIO_TEXREG2AR , BWRITERSIO_TEXREG2GB , BWRITERSIO_TEXM3x2PAD , BWRITERSIO_TEXM3x2TEX , BWRITERSIO_TEXM3x3PAD , BWRITERSIO_TEXM3x3TEX , BWRITERSIO_TEXM3x3SPEC , BWRITERSIO_TEXM3x3VSPEC , BWRITERSIO_EXPP , BWRITERSIO_LOGP , BWRITERSIO_CND , BWRITERSIO_DEF , BWRITERSIO_TEXREG2RGB , BWRITERSIO_TEXDP3TEX , BWRITERSIO_TEXM3x2DEPTH , BWRITERSIO_TEXDP3 , BWRITERSIO_TEXM3x3 , BWRITERSIO_TEXDEPTH , BWRITERSIO_CMP , BWRITERSIO_BEM , BWRITERSIO_DP2ADD , BWRITERSIO_DSX , BWRITERSIO_DSY , BWRITERSIO_TEXLDD , BWRITERSIO_SETP , BWRITERSIO_TEXLDL , BWRITERSIO_BREAKP , BWRITERSIO_TEXLDP , BWRITERSIO_TEXLDB , BWRITERSIO_PHASE , BWRITERSIO_COMMENT , BWRITERSIO_END }

enum	bwritershader_param_register_type { BWRITERSPR_TEMP , BWRITERSPR_INPUT , BWRITERSPR_CONST , BWRITERSPR_ADDR , BWRITERSPR_TEXTURE , BWRITERSPR_RASTOUT , BWRITERSPR_ATTROUT , BWRITERSPR_TEXCRDOUT , BWRITERSPR_OUTPUT , BWRITERSPR_CONSTINT , BWRITERSPR_COLOROUT , BWRITERSPR_DEPTHOUT , BWRITERSPR_SAMPLER , BWRITERSPR_CONSTBOOL , BWRITERSPR_LOOP , BWRITERSPR_MISCTYPE , BWRITERSPR_LABEL , BWRITERSPR_PREDICATE }

enum	bwritervs_rastout_offsets { BWRITERSRO_POSITION , BWRITERSRO_FOG , BWRITERSRO_POINT_SIZE }

enum	bwritershader_param_dstmod_type { BWRITERSPDM_NONE = 0 , BWRITERSPDM_SATURATE = 1 , BWRITERSPDM_PARTIALPRECISION = 2 , BWRITERSPDM_MSAMPCENTROID = 4 }

enum	bwritersampler_texture_type { BWRITERSTT_UNKNOWN = 0 , BWRITERSTT_1D = 1 , BWRITERSTT_2D = 2 , BWRITERSTT_CUBE = 3 , BWRITERSTT_VOLUME = 4 }

enum	bwritershader_param_srcmod_type { BWRITERSPSM_NONE = 0 , BWRITERSPSM_NEG , BWRITERSPSM_BIAS , BWRITERSPSM_BIASNEG , BWRITERSPSM_SIGN , BWRITERSPSM_SIGNNEG , BWRITERSPSM_COMP , BWRITERSPSM_X2 , BWRITERSPSM_X2NEG , BWRITERSPSM_DZ , BWRITERSPSM_DW , BWRITERSPSM_ABS , BWRITERSPSM_ABSNEG , BWRITERSPSM_NOT }

enum	bwriterdeclusage { BWRITERDECLUSAGE_POSITION , BWRITERDECLUSAGE_BLENDWEIGHT , BWRITERDECLUSAGE_BLENDINDICES , BWRITERDECLUSAGE_NORMAL , BWRITERDECLUSAGE_PSIZE , BWRITERDECLUSAGE_TEXCOORD , BWRITERDECLUSAGE_TANGENT , BWRITERDECLUSAGE_BINORMAL , BWRITERDECLUSAGE_TESSFACTOR , BWRITERDECLUSAGE_POSITIONT , BWRITERDECLUSAGE_COLOR , BWRITERDECLUSAGE_FOG , BWRITERDECLUSAGE_DEPTH , BWRITERDECLUSAGE_SAMPLE }

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_OBJECT }

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 , HLSL_TYPE_SAMPLER , HLSL_TYPE_TEXTURE , HLSL_TYPE_PIXELSHADER , HLSL_TYPE_VERTEXSHADER , HLSL_TYPE_STRING , HLSL_TYPE_VOID }

enum	hlsl_sampler_dim { HLSL_SAMPLER_DIM_GENERIC , HLSL_SAMPLER_DIM_1D , HLSL_SAMPLER_DIM_2D , HLSL_SAMPLER_DIM_3D , HLSL_SAMPLER_DIM_CUBE }

enum	hlsl_matrix_majority { HLSL_COLUMN_MAJOR , HLSL_ROW_MAJOR }

enum	hlsl_ir_node_type { HLSL_IR_ASSIGNMENT = 0 , HLSL_IR_CONSTANT , HLSL_IR_CONSTRUCTOR , HLSL_IR_DEREF , HLSL_IR_EXPR , HLSL_IR_IF , HLSL_IR_LOOP , HLSL_IR_JUMP , HLSL_IR_SWIZZLE }

enum	hlsl_ir_expr_op { HLSL_IR_UNOP_BIT_NOT = 0 , HLSL_IR_UNOP_LOGIC_NOT , HLSL_IR_UNOP_NEG , HLSL_IR_UNOP_ABS , HLSL_IR_UNOP_SIGN , HLSL_IR_UNOP_RCP , HLSL_IR_UNOP_RSQ , HLSL_IR_UNOP_SQRT , HLSL_IR_UNOP_NRM , HLSL_IR_UNOP_EXP2 , HLSL_IR_UNOP_LOG2 , HLSL_IR_UNOP_CAST , HLSL_IR_UNOP_FRACT , HLSL_IR_UNOP_SIN , HLSL_IR_UNOP_COS , HLSL_IR_UNOP_SIN_REDUCED , HLSL_IR_UNOP_COS_REDUCED , HLSL_IR_UNOP_DSX , HLSL_IR_UNOP_DSY , HLSL_IR_UNOP_SAT , HLSL_IR_UNOP_PREINC , HLSL_IR_UNOP_PREDEC , HLSL_IR_UNOP_POSTINC , HLSL_IR_UNOP_POSTDEC , HLSL_IR_BINOP_ADD , HLSL_IR_BINOP_SUB , HLSL_IR_BINOP_MUL , HLSL_IR_BINOP_DIV , HLSL_IR_BINOP_MOD , HLSL_IR_BINOP_LESS , HLSL_IR_BINOP_GREATER , HLSL_IR_BINOP_LEQUAL , HLSL_IR_BINOP_GEQUAL , HLSL_IR_BINOP_EQUAL , HLSL_IR_BINOP_NEQUAL , HLSL_IR_BINOP_LOGIC_AND , HLSL_IR_BINOP_LOGIC_OR , HLSL_IR_BINOP_LSHIFT , HLSL_IR_BINOP_RSHIFT , HLSL_IR_BINOP_BIT_AND , HLSL_IR_BINOP_BIT_OR , HLSL_IR_BINOP_BIT_XOR , HLSL_IR_BINOP_DOT , HLSL_IR_BINOP_CRS , HLSL_IR_BINOP_MIN , HLSL_IR_BINOP_MAX , HLSL_IR_BINOP_POW , HLSL_IR_TEROP_LERP , HLSL_IR_SEQUENCE }

enum	hlsl_ir_jump_type { HLSL_IR_JUMP_BREAK , HLSL_IR_JUMP_CONTINUE , HLSL_IR_JUMP_DISCARD , HLSL_IR_JUMP_RETURN }

enum	hlsl_ir_deref_type { HLSL_IR_DEREF_VAR , HLSL_IR_DEREF_ARRAY , HLSL_IR_DEREF_RECORD }

enum	parse_unary_op { UNARY_OP_PLUS , UNARY_OP_MINUS , UNARY_OP_LOGICNOT , UNARY_OP_BITNOT }

enum	parse_assign_op { ASSIGN_OP_ASSIGN , ASSIGN_OP_ADD , ASSIGN_OP_SUB , ASSIGN_OP_MUL , ASSIGN_OP_DIV , ASSIGN_OP_MOD , ASSIGN_OP_LSHIFT , ASSIGN_OP_RSHIFT , ASSIGN_OP_AND , ASSIGN_OP_OR , ASSIGN_OP_XOR }

enum	hlsl_error_level { HLSL_LEVEL_ERROR = 0 , HLSL_LEVEL_WARNING , HLSL_LEVEL_NOTE }

Functions
const char *	debug_d3dcompiler_d3d_blob_part (D3D_BLOB_PART part) DECLSPEC_HIDDEN

const char *	debug_d3dcompiler_shader_variable_class (D3D_SHADER_VARIABLE_CLASS c) DECLSPEC_HIDDEN

const char *	debug_d3dcompiler_shader_variable_type (D3D_SHADER_VARIABLE_TYPE t) DECLSPEC_HIDDEN

static void *	d3dcompiler_alloc (SIZE_T size)

static void *	d3dcompiler_realloc (void *ptr, SIZE_T size)

static BOOL	d3dcompiler_free (void *ptr)

static char *	d3dcompiler_strdup (const char *string)

struct instruction *	alloc_instr (unsigned int srcs) DECLSPEC_HIDDEN

BOOL	add_instruction (struct bwriter_shader shader, struct instruction instr) DECLSPEC_HIDDEN

BOOL	add_constF (struct bwriter_shader *shader, DWORD reg, float x, float y, float z, float w) DECLSPEC_HIDDEN

BOOL	add_constI (struct bwriter_shader *shader, DWORD reg, INT x, INT y, INT z, INT w) DECLSPEC_HIDDEN

BOOL	add_constB (struct bwriter_shader *shader, DWORD reg, BOOL x) DECLSPEC_HIDDEN

BOOL	record_declaration (struct bwriter_shader *shader, DWORD usage, DWORD usage_idx, DWORD mod, BOOL output, DWORD regnum, DWORD writemask, BOOL builtin) DECLSPEC_HIDDEN

BOOL	record_sampler (struct bwriter_shader *shader, DWORD samptype, DWORD mod, DWORD regnum) DECLSPEC_HIDDEN

void	create_vs10_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_vs11_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_vs20_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_vs2x_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_vs30_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps10_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps11_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps12_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps13_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps14_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps20_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps2x_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

void	create_ps30_parser (struct asm_parser *ret) DECLSPEC_HIDDEN

struct bwriter_shader *	parse_asm_shader (char **messages) DECLSPEC_HIDDEN

void	compilation_message (struct compilation_messages msg, const char fmt, __ms_va_list args) DECLSPEC_HIDDEN

void WINAPIV	asmparser_message (struct asm_parser ctx, const char fmt,...) PRINTF_ATTR(2

static void	set_parse_status (enum parse_status *current, enum parse_status update)

const char *	debug_print_srcmod (DWORD mod) DECLSPEC_HIDDEN

const char *	debug_print_dstmod (DWORD mod) DECLSPEC_HIDDEN

const char *	debug_print_shift (DWORD shift) DECLSPEC_HIDDEN

const char *	debug_print_dstreg (const struct shader_reg *reg) DECLSPEC_HIDDEN

const char *	debug_print_srcreg (const struct shader_reg *reg) DECLSPEC_HIDDEN

const char *	debug_print_comp (DWORD comp) DECLSPEC_HIDDEN

const char *	debug_print_opcode (DWORD opcode) DECLSPEC_HIDDEN

struct bwriter_shader *	SlAssembleShader (const char text, char *messages) DECLSPEC_HIDDEN

HRESULT	SlWriteBytecode (const struct bwriter_shader shader, int dxversion, DWORD result, DWORD size) DECLSPEC_HIDDEN

void	SlDeleteShader (struct bwriter_shader *shader) DECLSPEC_HIDDEN

void WINAPIV	hlsl_message (const char *fmt,...) PRINTF_ATTR(1

void WINAPIV	hlsl_report_message (const char filename, DWORD line, DWORD column, enum hlsl_error_level level, const char fmt,...) PRINTF_ATTR(5

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

static struct hlsl_ir_deref *	deref_from_node (const struct hlsl_ir_node *node)

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

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

static struct hlsl_ir_assignment *	assignment_from_node (const struct hlsl_ir_node *node)

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

static struct hlsl_ir_constructor *	constructor_from_node (const struct hlsl_ir_node *node)

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

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

BOOL	add_declaration (struct hlsl_scope scope, struct hlsl_ir_var decl, BOOL local_var) DECLSPEC_HIDDEN

struct hlsl_ir_var *	get_variable (struct hlsl_scope scope, const char name) DECLSPEC_HIDDEN

void	free_declaration (struct hlsl_ir_var *decl) DECLSPEC_HIDDEN

struct hlsl_type *	new_hlsl_type (const char *name, enum hlsl_type_class type_class, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN

struct hlsl_type *	new_array_type (struct hlsl_type *basic_type, unsigned int array_size) DECLSPEC_HIDDEN

struct hlsl_type *	clone_hlsl_type (struct hlsl_type *old) DECLSPEC_HIDDEN

struct hlsl_type *	get_type (struct hlsl_scope scope, const char name, BOOL recursive) DECLSPEC_HIDDEN

BOOL	find_function (const char *name) DECLSPEC_HIDDEN

unsigned int	components_count_type (struct hlsl_type *type) DECLSPEC_HIDDEN

BOOL	compare_hlsl_types (const struct hlsl_type t1, const struct hlsl_type t2) DECLSPEC_HIDDEN

BOOL	compatible_data_types (struct hlsl_type s1, struct hlsl_type s2) DECLSPEC_HIDDEN

struct hlsl_ir_expr *	new_expr (enum hlsl_ir_expr_op op, struct hlsl_ir_node *operands, struct source_location loc) DECLSPEC_HIDDEN

struct hlsl_ir_expr *	new_cast (struct hlsl_ir_node node, struct hlsl_type type, struct source_location *loc) DECLSPEC_HIDDEN

struct hlsl_ir_deref *	new_var_deref (struct hlsl_ir_var *var) DECLSPEC_HIDDEN

struct hlsl_ir_deref *	new_record_deref (struct hlsl_ir_node record, struct hlsl_struct_field field) DECLSPEC_HIDDEN

struct hlsl_ir_node *	make_assignment (struct hlsl_ir_node left, enum parse_assign_op assign_op, DWORD writemask, struct hlsl_ir_node right) DECLSPEC_HIDDEN

void	push_scope (struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN

BOOL	pop_scope (struct hlsl_parse_ctx *ctx) DECLSPEC_HIDDEN

struct hlsl_ir_function_decl *	new_func_decl (struct hlsl_type return_type, struct list parameters) DECLSPEC_HIDDEN

void	init_functions_tree (struct wine_rb_tree *funcs) DECLSPEC_HIDDEN

void	add_function_decl (struct wine_rb_tree funcs, char name, struct hlsl_ir_function_decl *decl, BOOL intrinsic) DECLSPEC_HIDDEN

struct bwriter_shader *	parse_hlsl_shader (const char text, enum shader_type type, DWORD major, DWORD minor, const char entrypoint, char **messages) DECLSPEC_HIDDEN

const char *	debug_hlsl_type (const struct hlsl_type *type) DECLSPEC_HIDDEN

const char *	debug_modifiers (DWORD modifiers) DECLSPEC_HIDDEN

void	debug_dump_ir_function_decl (const struct hlsl_ir_function_decl *func) DECLSPEC_HIDDEN

void	free_hlsl_type (struct hlsl_type *type) DECLSPEC_HIDDEN

void	free_instr (struct hlsl_ir_node *node) DECLSPEC_HIDDEN

void	free_instr_list (struct list *list) DECLSPEC_HIDDEN

void	free_function_rb (struct wine_rb_entry entry, void context) DECLSPEC_HIDDEN

static struct hlsl_ir_node *	new_unary_expr (enum hlsl_ir_expr_op op, struct hlsl_ir_node *op1, struct source_location loc)

static struct hlsl_ir_node *	new_binary_expr (enum hlsl_ir_expr_op op, struct hlsl_ir_node op1, struct hlsl_ir_node op2, struct source_location loc)

HRESULT	dxbc_write_blob (struct dxbc dxbc, ID3DBlob *blob) DECLSPEC_HIDDEN

void	dxbc_destroy (struct dxbc *dxbc) DECLSPEC_HIDDEN

HRESULT	dxbc_parse (const char data, SIZE_T data_size, struct dxbc dxbc) DECLSPEC_HIDDEN

HRESULT	dxbc_add_section (struct dxbc dxbc, DWORD tag, const char data, DWORD data_size) DECLSPEC_HIDDEN

HRESULT	dxbc_init (struct dxbc *dxbc, unsigned int size) DECLSPEC_HIDDEN

static void	read_dword (const char *ptr, DWORD d)

static void	write_dword (char **ptr, DWORD d)

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

Variables
struct asm_parser asm_ctx	DECLSPEC_HIDDEN

Macro Definition Documentation

◆ BWRITER_SM1_PS

#define BWRITER_SM1_PS 0xffffu

Definition at line 537 of file d3dcompiler_private.h.

◆ BWRITER_SM1_VS

#define BWRITER_SM1_VS 0xfffeu

Definition at line 536 of file d3dcompiler_private.h.

◆ BWRITERPS_VERSION

#define BWRITERPS_VERSION	(	major,
		minor
	)	((BWRITER_SM1_PS << 16) \| ((major) << 8) \| (minor))

Definition at line 539 of file d3dcompiler_private.h.

◆ BWRITERSI_TEXLD_BIAS

#define BWRITERSI_TEXLD_BIAS 2

Definition at line 516 of file d3dcompiler_private.h.

◆ BWRITERSI_TEXLD_PROJECT

#define BWRITERSI_TEXLD_PROJECT 1

Definition at line 515 of file d3dcompiler_private.h.

◆ BWRITERSP_WRITEMASK_0

#define BWRITERSP_WRITEMASK_0 0x1 /* .x r */

Definition at line 492 of file d3dcompiler_private.h.

◆ BWRITERSP_WRITEMASK_1

#define BWRITERSP_WRITEMASK_1 0x2 /* .y g */

Definition at line 493 of file d3dcompiler_private.h.

◆ BWRITERSP_WRITEMASK_2

#define BWRITERSP_WRITEMASK_2 0x4 /* .z b */

Definition at line 494 of file d3dcompiler_private.h.

◆ BWRITERSP_WRITEMASK_3

#define BWRITERSP_WRITEMASK_3 0x8 /* .w a */

Definition at line 495 of file d3dcompiler_private.h.

◆ BWRITERSP_WRITEMASK_ALL

#define BWRITERSP_WRITEMASK_ALL 0xf /* all */

Definition at line 496 of file d3dcompiler_private.h.

◆ BWRITERVS_NOSWIZZLE

#define BWRITERVS_NOSWIZZLE (BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_W)

Definition at line 565 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_MASK

#define BWRITERVS_SWIZZLE_MASK (0xFF << BWRITERVS_SWIZZLE_SHIFT)

Definition at line 543 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_SHIFT

#define BWRITERVS_SWIZZLE_SHIFT 16

Definition at line 542 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_W

#define BWRITERVS_SWIZZLE_W (BWRITERVS_X_W | BWRITERVS_Y_W | BWRITERVS_Z_W | BWRITERVS_W_W)

Definition at line 570 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_X

#define BWRITERVS_SWIZZLE_X (BWRITERVS_X_X | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X)

Definition at line 567 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_Y

#define BWRITERVS_SWIZZLE_Y (BWRITERVS_X_Y | BWRITERVS_Y_Y | BWRITERVS_Z_Y | BWRITERVS_W_Y)

Definition at line 568 of file d3dcompiler_private.h.

◆ BWRITERVS_SWIZZLE_Z

#define BWRITERVS_SWIZZLE_Z (BWRITERVS_X_Z | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z)

Definition at line 569 of file d3dcompiler_private.h.

◆ BWRITERVS_VERSION

#define BWRITERVS_VERSION	(	major,
		minor
	)	((BWRITER_SM1_VS << 16) \| ((major) << 8) \| (minor))

Definition at line 540 of file d3dcompiler_private.h.

◆ BWRITERVS_W_W

#define BWRITERVS_W_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 6))

Definition at line 563 of file d3dcompiler_private.h.

◆ BWRITERVS_W_X

#define BWRITERVS_W_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 6))

Definition at line 560 of file d3dcompiler_private.h.

◆ BWRITERVS_W_Y

#define BWRITERVS_W_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 6))

Definition at line 561 of file d3dcompiler_private.h.

◆ BWRITERVS_W_Z

#define BWRITERVS_W_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 6))

Definition at line 562 of file d3dcompiler_private.h.

◆ BWRITERVS_X_W

#define BWRITERVS_X_W (3 << BWRITERVS_SWIZZLE_SHIFT)

Definition at line 548 of file d3dcompiler_private.h.

◆ BWRITERVS_X_X

#define BWRITERVS_X_X (0 << BWRITERVS_SWIZZLE_SHIFT)

Definition at line 545 of file d3dcompiler_private.h.

◆ BWRITERVS_X_Y

#define BWRITERVS_X_Y (1 << BWRITERVS_SWIZZLE_SHIFT)

Definition at line 546 of file d3dcompiler_private.h.

◆ BWRITERVS_X_Z

#define BWRITERVS_X_Z (2 << BWRITERVS_SWIZZLE_SHIFT)

Definition at line 547 of file d3dcompiler_private.h.

◆ BWRITERVS_Y_W

#define BWRITERVS_Y_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 2))

Definition at line 553 of file d3dcompiler_private.h.

◆ BWRITERVS_Y_X

#define BWRITERVS_Y_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 2))

Definition at line 550 of file d3dcompiler_private.h.

◆ BWRITERVS_Y_Y

#define BWRITERVS_Y_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 2))

Definition at line 551 of file d3dcompiler_private.h.

◆ BWRITERVS_Y_Z

#define BWRITERVS_Y_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 2))

Definition at line 552 of file d3dcompiler_private.h.

◆ BWRITERVS_Z_W

#define BWRITERVS_Z_W (3 << (BWRITERVS_SWIZZLE_SHIFT + 4))

Definition at line 558 of file d3dcompiler_private.h.

◆ BWRITERVS_Z_X

#define BWRITERVS_Z_X (0 << (BWRITERVS_SWIZZLE_SHIFT + 4))

Definition at line 555 of file d3dcompiler_private.h.

◆ BWRITERVS_Z_Y

#define BWRITERVS_Z_Y (1 << (BWRITERVS_SWIZZLE_SHIFT + 4))

Definition at line 556 of file d3dcompiler_private.h.

◆ BWRITERVS_Z_Z

#define BWRITERVS_Z_Z (2 << (BWRITERVS_SWIZZLE_SHIFT + 4))

Definition at line 557 of file d3dcompiler_private.h.

◆ BYTECODEBUFFER_INITIAL_SIZE

#define BYTECODEBUFFER_INITIAL_SIZE 32

Definition at line 299 of file d3dcompiler_private.h.

◆ COBJMACROS

#define COBJMACROS

Definition at line 30 of file d3dcompiler_private.h.

◆ D3DERR_INVALIDCALL

#define D3DERR_INVALIDCALL 0x8876086c

Definition at line 44 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_COLUMN_MAJOR

#define HLSL_MODIFIER_COLUMN_MAJOR 0x00000400

Definition at line 739 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_CONST

#define HLSL_MODIFIER_CONST 0x00000100

Definition at line 737 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_IN

#define HLSL_MODIFIER_IN 0x00000800

Definition at line 740 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_OUT

#define HLSL_MODIFIER_OUT 0x00001000

Definition at line 741 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_PRECISE

#define HLSL_MODIFIER_PRECISE 0x00000004

Definition at line 731 of file d3dcompiler_private.h.

◆ HLSL_MODIFIER_ROW_MAJOR

#define HLSL_MODIFIER_ROW_MAJOR 0x00000200

Definition at line 738 of file d3dcompiler_private.h.

◆ HLSL_MODIFIERS_COMPARISON_MASK

#define HLSL_MODIFIERS_COMPARISON_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)

Definition at line 747 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_EXTERN

#define HLSL_STORAGE_EXTERN 0x00000001

Definition at line 729 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_GROUPSHARED

#define HLSL_STORAGE_GROUPSHARED 0x00000010

Definition at line 733 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_NOINTERPOLATION

#define HLSL_STORAGE_NOINTERPOLATION 0x00000002

Definition at line 730 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_SHARED

#define HLSL_STORAGE_SHARED 0x00000008

Definition at line 732 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_STATIC

#define HLSL_STORAGE_STATIC 0x00000020

Definition at line 734 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_UNIFORM

#define HLSL_STORAGE_UNIFORM 0x00000040

Definition at line 735 of file d3dcompiler_private.h.

◆ HLSL_STORAGE_VOLATILE

#define HLSL_STORAGE_VOLATILE 0x00000080

Definition at line 736 of file d3dcompiler_private.h.

◆ HLSL_TYPE_MODIFIERS_MASK

#define HLSL_TYPE_MODIFIERS_MASK

Value:

                                      (HLSL_MODIFIER_PRECISE | HLSL_STORAGE_VOLATILE | \
                                      HLSL_MODIFIER_CONST | HLSL_MODIFIER_ROW_MAJOR | \
                                      HLSL_MODIFIER_COLUMN_MAJOR)

Definition at line 743 of file d3dcompiler_private.h.

◆ INSTRARRAY_INITIAL_SIZE

#define INSTRARRAY_INITIAL_SIZE 8

Definition at line 118 of file d3dcompiler_private.h.

◆ MAKE_TAG

#define MAKE_TAG	(	ch0,
		ch1,
		ch2,
		ch3
	)

Value:

((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \

((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))

DWORD

unsigned long DWORD

Definition: ntddk_ex.h:95

DWORD

#define DWORD

Definition: nt_native.h:44

Definition at line 1175 of file d3dcompiler_private.h.

◆ MAX_SRC_REGS

#define MAX_SRC_REGS 4

Definition at line 190 of file d3dcompiler_private.h.

◆ MESSAGEBUFFER_INITIAL_SIZE

#define MESSAGEBUFFER_INITIAL_SIZE 256

Definition at line 234 of file d3dcompiler_private.h.

◆ PRINTF_ATTR

#define PRINTF_ATTR	(	fmt,
		args
	)

Definition at line 285 of file d3dcompiler_private.h.

◆ SWIZZLE_ERR

#define SWIZZLE_ERR ~0U

Definition at line 367 of file d3dcompiler_private.h.

◆ T0_REG

#define T0_REG 2

Definition at line 591 of file d3dcompiler_private.h.

◆ T1_REG

#define T1_REG 3

Definition at line 592 of file d3dcompiler_private.h.

◆ T2_REG

#define T2_REG 4

Definition at line 593 of file d3dcompiler_private.h.

◆ T3_REG

#define T3_REG 5

Definition at line 594 of file d3dcompiler_private.h.

◆ TAG_Aon9

#define TAG_Aon9 MAKE_TAG('A', 'o', 'n', '9')

Definition at line 1178 of file d3dcompiler_private.h.

◆ TAG_DXBC

#define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')

Definition at line 1179 of file d3dcompiler_private.h.

◆ TAG_ISGN

#define TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N')

Definition at line 1180 of file d3dcompiler_private.h.

◆ TAG_OSG5

#define TAG_OSG5 MAKE_TAG('O', 'S', 'G', '5')

Definition at line 1182 of file d3dcompiler_private.h.

◆ TAG_OSGN

#define TAG_OSGN MAKE_TAG('O', 'S', 'G', 'N')

Definition at line 1181 of file d3dcompiler_private.h.

◆ TAG_PCSG

#define TAG_PCSG MAKE_TAG('P', 'C', 'S', 'G')

Definition at line 1183 of file d3dcompiler_private.h.

◆ TAG_RDEF

#define TAG_RDEF MAKE_TAG('R', 'D', 'E', 'F')

Definition at line 1184 of file d3dcompiler_private.h.

◆ TAG_SDBG

#define TAG_SDBG MAKE_TAG('S', 'D', 'B', 'G')

Definition at line 1185 of file d3dcompiler_private.h.

◆ TAG_SHDR

#define TAG_SHDR MAKE_TAG('S', 'H', 'D', 'R')

Definition at line 1186 of file d3dcompiler_private.h.

◆ TAG_SHEX

#define TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X')

Definition at line 1187 of file d3dcompiler_private.h.

◆ TAG_STAT

#define TAG_STAT MAKE_TAG('S', 'T', 'A', 'T')

Definition at line 1188 of file d3dcompiler_private.h.

◆ TAG_XNAP

#define TAG_XNAP MAKE_TAG('X', 'N', 'A', 'P')

Definition at line 1189 of file d3dcompiler_private.h.

◆ TAG_XNAS

#define TAG_XNAS MAKE_TAG('X', 'N', 'A', 'S')

Definition at line 1190 of file d3dcompiler_private.h.

Typedef Documentation

◆ instr_writer

typedef void(* instr_writer) (struct bc_writer *This, const struct instruction *instr, struct bytecode_buffer *buffer)

Definition at line 312 of file d3dcompiler_private.h.

Enumeration Type Documentation

◆ bwriter_comparison_type

enum bwriter_comparison_type

Enumerator
BWRITER_COMPARISON_NONE
BWRITER_COMPARISON_GT
BWRITER_COMPARISON_EQ
BWRITER_COMPARISON_GE
BWRITER_COMPARISON_LT
BWRITER_COMPARISON_NE
BWRITER_COMPARISON_LE

Definition at line 58 of file d3dcompiler_private.h.

{
    BWRITER_COMPARISON_NONE,
    BWRITER_COMPARISON_GT,
    BWRITER_COMPARISON_EQ,
    BWRITER_COMPARISON_GE,
    BWRITER_COMPARISON_LT,
    BWRITER_COMPARISON_NE,
    BWRITER_COMPARISON_LE
};

◆ bwriterdeclusage

enum bwriterdeclusage

Enumerator
BWRITERDECLUSAGE_POSITION
BWRITERDECLUSAGE_BLENDWEIGHT
BWRITERDECLUSAGE_BLENDINDICES
BWRITERDECLUSAGE_NORMAL
BWRITERDECLUSAGE_PSIZE
BWRITERDECLUSAGE_TEXCOORD
BWRITERDECLUSAGE_TANGENT
BWRITERDECLUSAGE_BINORMAL
BWRITERDECLUSAGE_TESSFACTOR
BWRITERDECLUSAGE_POSITIONT
BWRITERDECLUSAGE_COLOR
BWRITERDECLUSAGE_FOG
BWRITERDECLUSAGE_DEPTH
BWRITERDECLUSAGE_SAMPLE

Definition at line 572 of file d3dcompiler_private.h.

{
    BWRITERDECLUSAGE_POSITION,
    BWRITERDECLUSAGE_BLENDWEIGHT,
    BWRITERDECLUSAGE_BLENDINDICES,
    BWRITERDECLUSAGE_NORMAL,
    BWRITERDECLUSAGE_PSIZE,
    BWRITERDECLUSAGE_TEXCOORD,
    BWRITERDECLUSAGE_TANGENT,
    BWRITERDECLUSAGE_BINORMAL,
    BWRITERDECLUSAGE_TESSFACTOR,
    BWRITERDECLUSAGE_POSITIONT,
    BWRITERDECLUSAGE_COLOR,
    BWRITERDECLUSAGE_FOG,
    BWRITERDECLUSAGE_DEPTH,
    BWRITERDECLUSAGE_SAMPLE
};

◆ bwritersampler_texture_type

enum bwritersampler_texture_type

Enumerator
BWRITERSTT_UNKNOWN
BWRITERSTT_1D
BWRITERSTT_2D
BWRITERSTT_CUBE
BWRITERSTT_VOLUME

Definition at line 506 of file d3dcompiler_private.h.

{
    BWRITERSTT_UNKNOWN = 0,
    BWRITERSTT_1D = 1,
    BWRITERSTT_2D = 2,
    BWRITERSTT_CUBE = 3,
    BWRITERSTT_VOLUME = 4,
};

◆ bwritershader_instruction_opcode_type

enum bwritershader_instruction_opcode_type

Enumerator
BWRITERSIO_NOP
BWRITERSIO_MOV
BWRITERSIO_ADD
BWRITERSIO_SUB
BWRITERSIO_MAD
BWRITERSIO_MUL
BWRITERSIO_RCP
BWRITERSIO_RSQ
BWRITERSIO_DP3
BWRITERSIO_DP4
BWRITERSIO_MIN
BWRITERSIO_MAX
BWRITERSIO_SLT
BWRITERSIO_SGE
BWRITERSIO_EXP
BWRITERSIO_LOG
BWRITERSIO_LIT
BWRITERSIO_DST
BWRITERSIO_LRP
BWRITERSIO_FRC
BWRITERSIO_M4x4
BWRITERSIO_M4x3
BWRITERSIO_M3x4
BWRITERSIO_M3x3
BWRITERSIO_M3x2
BWRITERSIO_CALL
BWRITERSIO_CALLNZ
BWRITERSIO_LOOP
BWRITERSIO_RET
BWRITERSIO_ENDLOOP
BWRITERSIO_LABEL
BWRITERSIO_DCL
BWRITERSIO_POW
BWRITERSIO_CRS
BWRITERSIO_SGN
BWRITERSIO_ABS
BWRITERSIO_NRM
BWRITERSIO_SINCOS
BWRITERSIO_REP
BWRITERSIO_ENDREP
BWRITERSIO_IF
BWRITERSIO_IFC
BWRITERSIO_ELSE
BWRITERSIO_ENDIF
BWRITERSIO_BREAK
BWRITERSIO_BREAKC
BWRITERSIO_MOVA
BWRITERSIO_DEFB
BWRITERSIO_DEFI
BWRITERSIO_TEXCOORD
BWRITERSIO_TEXKILL
BWRITERSIO_TEX
BWRITERSIO_TEXBEM
BWRITERSIO_TEXBEML
BWRITERSIO_TEXREG2AR
BWRITERSIO_TEXREG2GB
BWRITERSIO_TEXM3x2PAD
BWRITERSIO_TEXM3x2TEX
BWRITERSIO_TEXM3x3PAD
BWRITERSIO_TEXM3x3TEX
BWRITERSIO_TEXM3x3SPEC
BWRITERSIO_TEXM3x3VSPEC
BWRITERSIO_EXPP
BWRITERSIO_LOGP
BWRITERSIO_CND
BWRITERSIO_DEF
BWRITERSIO_TEXREG2RGB
BWRITERSIO_TEXDP3TEX
BWRITERSIO_TEXM3x2DEPTH
BWRITERSIO_TEXDP3
BWRITERSIO_TEXM3x3
BWRITERSIO_TEXDEPTH
BWRITERSIO_CMP
BWRITERSIO_BEM
BWRITERSIO_DP2ADD
BWRITERSIO_DSX
BWRITERSIO_DSY
BWRITERSIO_TEXLDD
BWRITERSIO_SETP
BWRITERSIO_TEXLDL
BWRITERSIO_BREAKP
BWRITERSIO_TEXLDP
BWRITERSIO_TEXLDB
BWRITERSIO_PHASE
BWRITERSIO_COMMENT
BWRITERSIO_END

Definition at line 371 of file d3dcompiler_private.h.

{
    BWRITERSIO_NOP,
    BWRITERSIO_MOV,
    BWRITERSIO_ADD,
    BWRITERSIO_SUB,
    BWRITERSIO_MAD,
    BWRITERSIO_MUL,
    BWRITERSIO_RCP,
    BWRITERSIO_RSQ,
    BWRITERSIO_DP3,
    BWRITERSIO_DP4,
    BWRITERSIO_MIN,
    BWRITERSIO_MAX,
    BWRITERSIO_SLT,
    BWRITERSIO_SGE,
    BWRITERSIO_EXP,
    BWRITERSIO_LOG,
    BWRITERSIO_LIT,
    BWRITERSIO_DST,
    BWRITERSIO_LRP,
    BWRITERSIO_FRC,
    BWRITERSIO_M4x4,
    BWRITERSIO_M4x3,
    BWRITERSIO_M3x4,
    BWRITERSIO_M3x3,
    BWRITERSIO_M3x2,
    BWRITERSIO_CALL,
    BWRITERSIO_CALLNZ,
    BWRITERSIO_LOOP,
    BWRITERSIO_RET,
    BWRITERSIO_ENDLOOP,
    BWRITERSIO_LABEL,
    BWRITERSIO_DCL,
    BWRITERSIO_POW,
    BWRITERSIO_CRS,
    BWRITERSIO_SGN,
    BWRITERSIO_ABS,
    BWRITERSIO_NRM,
    BWRITERSIO_SINCOS,
    BWRITERSIO_REP,
    BWRITERSIO_ENDREP,
    BWRITERSIO_IF,
    BWRITERSIO_IFC,
    BWRITERSIO_ELSE,
    BWRITERSIO_ENDIF,
    BWRITERSIO_BREAK,
    BWRITERSIO_BREAKC,
    BWRITERSIO_MOVA,
    BWRITERSIO_DEFB,
    BWRITERSIO_DEFI,
 
    BWRITERSIO_TEXCOORD,
    BWRITERSIO_TEXKILL,
    BWRITERSIO_TEX,
    BWRITERSIO_TEXBEM,
    BWRITERSIO_TEXBEML,
    BWRITERSIO_TEXREG2AR,
    BWRITERSIO_TEXREG2GB,
    BWRITERSIO_TEXM3x2PAD,
    BWRITERSIO_TEXM3x2TEX,
    BWRITERSIO_TEXM3x3PAD,
    BWRITERSIO_TEXM3x3TEX,
    BWRITERSIO_TEXM3x3SPEC,
    BWRITERSIO_TEXM3x3VSPEC,
    BWRITERSIO_EXPP,
    BWRITERSIO_LOGP,
    BWRITERSIO_CND,
    BWRITERSIO_DEF,
    BWRITERSIO_TEXREG2RGB,
    BWRITERSIO_TEXDP3TEX,
    BWRITERSIO_TEXM3x2DEPTH,
    BWRITERSIO_TEXDP3,
    BWRITERSIO_TEXM3x3,
    BWRITERSIO_TEXDEPTH,
    BWRITERSIO_CMP,
    BWRITERSIO_BEM,
    BWRITERSIO_DP2ADD,
    BWRITERSIO_DSX,
    BWRITERSIO_DSY,
    BWRITERSIO_TEXLDD,
    BWRITERSIO_SETP,
    BWRITERSIO_TEXLDL,
    BWRITERSIO_BREAKP,
    BWRITERSIO_TEXLDP,
    BWRITERSIO_TEXLDB,
 
    BWRITERSIO_PHASE,
    BWRITERSIO_COMMENT,
    BWRITERSIO_END,
};

◆ bwritershader_param_dstmod_type

enum bwritershader_param_dstmod_type

Enumerator
BWRITERSPDM_NONE
BWRITERSPDM_SATURATE
BWRITERSPDM_PARTIALPRECISION
BWRITERSPDM_MSAMPCENTROID

Definition at line 498 of file d3dcompiler_private.h.

{
    BWRITERSPDM_NONE = 0,
    BWRITERSPDM_SATURATE = 1,
    BWRITERSPDM_PARTIALPRECISION = 2,
    BWRITERSPDM_MSAMPCENTROID = 4,
};

◆ bwritershader_param_register_type

enum bwritershader_param_register_type

Enumerator
BWRITERSPR_TEMP
BWRITERSPR_INPUT
BWRITERSPR_CONST
BWRITERSPR_ADDR
BWRITERSPR_TEXTURE
BWRITERSPR_RASTOUT
BWRITERSPR_ATTROUT
BWRITERSPR_TEXCRDOUT
BWRITERSPR_OUTPUT
BWRITERSPR_CONSTINT
BWRITERSPR_COLOROUT
BWRITERSPR_DEPTHOUT
BWRITERSPR_SAMPLER
BWRITERSPR_CONSTBOOL
BWRITERSPR_LOOP
BWRITERSPR_MISCTYPE
BWRITERSPR_LABEL
BWRITERSPR_PREDICATE

Definition at line 463 of file d3dcompiler_private.h.

{
    BWRITERSPR_TEMP,
    BWRITERSPR_INPUT,
    BWRITERSPR_CONST,
    BWRITERSPR_ADDR,
    BWRITERSPR_TEXTURE,
    BWRITERSPR_RASTOUT,
    BWRITERSPR_ATTROUT,
    BWRITERSPR_TEXCRDOUT,
    BWRITERSPR_OUTPUT,
    BWRITERSPR_CONSTINT,
    BWRITERSPR_COLOROUT,
    BWRITERSPR_DEPTHOUT,
    BWRITERSPR_SAMPLER,
    BWRITERSPR_CONSTBOOL,
    BWRITERSPR_LOOP,
    BWRITERSPR_MISCTYPE,
    BWRITERSPR_LABEL,
    BWRITERSPR_PREDICATE
};

◆ bwritershader_param_srcmod_type

enum bwritershader_param_srcmod_type

Enumerator
BWRITERSPSM_NONE
BWRITERSPSM_NEG
BWRITERSPSM_BIAS
BWRITERSPSM_BIASNEG
BWRITERSPSM_SIGN
BWRITERSPSM_SIGNNEG
BWRITERSPSM_COMP
BWRITERSPSM_X2
BWRITERSPSM_X2NEG
BWRITERSPSM_DZ
BWRITERSPSM_DW
BWRITERSPSM_ABS
BWRITERSPSM_ABSNEG
BWRITERSPSM_NOT

Definition at line 518 of file d3dcompiler_private.h.

{
    BWRITERSPSM_NONE = 0,
    BWRITERSPSM_NEG,
    BWRITERSPSM_BIAS,
    BWRITERSPSM_BIASNEG,
    BWRITERSPSM_SIGN,
    BWRITERSPSM_SIGNNEG,
    BWRITERSPSM_COMP,
    BWRITERSPSM_X2,
    BWRITERSPSM_X2NEG,
    BWRITERSPSM_DZ,
    BWRITERSPSM_DW,
    BWRITERSPSM_ABS,
    BWRITERSPSM_ABSNEG,
    BWRITERSPSM_NOT,
};

◆ bwritervs_rastout_offsets

enum bwritervs_rastout_offsets

Enumerator
BWRITERSRO_POSITION
BWRITERSRO_FOG
BWRITERSRO_POINT_SIZE

Definition at line 485 of file d3dcompiler_private.h.

{
    BWRITERSRO_POSITION,
    BWRITERSRO_FOG,
    BWRITERSRO_POINT_SIZE
};

◆ 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
HLSL_TYPE_SAMPLER
HLSL_TYPE_TEXTURE
HLSL_TYPE_PIXELSHADER
HLSL_TYPE_VERTEXSHADER
HLSL_TYPE_STRING
HLSL_TYPE_VOID

Definition at line 637 of file d3dcompiler_private.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_TYPE_SAMPLER,
    HLSL_TYPE_TEXTURE,
    HLSL_TYPE_PIXELSHADER,
    HLSL_TYPE_VERTEXSHADER,
    HLSL_TYPE_STRING,
    HLSL_TYPE_VOID,
};

◆ hlsl_error_level

enum hlsl_error_level

Enumerator
HLSL_LEVEL_ERROR
HLSL_LEVEL_WARNING
HLSL_LEVEL_NOTE

Definition at line 1058 of file d3dcompiler_private.h.

{
    HLSL_LEVEL_ERROR = 0,
    HLSL_LEVEL_WARNING,
    HLSL_LEVEL_NOTE,
};

◆ hlsl_ir_deref_type

enum hlsl_ir_deref_type

Enumerator
HLSL_IR_DEREF_VAR
HLSL_IR_DEREF_ARRAY
HLSL_IR_DEREF_RECORD

Definition at line 907 of file d3dcompiler_private.h.

{
    HLSL_IR_DEREF_VAR,
    HLSL_IR_DEREF_ARRAY,
    HLSL_IR_DEREF_RECORD,
};

◆ hlsl_ir_expr_op

enum hlsl_ir_expr_op

Enumerator
HLSL_IR_UNOP_BIT_NOT
HLSL_IR_UNOP_LOGIC_NOT
HLSL_IR_UNOP_NEG
HLSL_IR_UNOP_ABS
HLSL_IR_UNOP_SIGN
HLSL_IR_UNOP_RCP
HLSL_IR_UNOP_RSQ
HLSL_IR_UNOP_SQRT
HLSL_IR_UNOP_NRM
HLSL_IR_UNOP_EXP2
HLSL_IR_UNOP_LOG2
HLSL_IR_UNOP_CAST
HLSL_IR_UNOP_FRACT
HLSL_IR_UNOP_SIN
HLSL_IR_UNOP_COS
HLSL_IR_UNOP_SIN_REDUCED
HLSL_IR_UNOP_COS_REDUCED
HLSL_IR_UNOP_DSX
HLSL_IR_UNOP_DSY
HLSL_IR_UNOP_SAT
HLSL_IR_UNOP_PREINC
HLSL_IR_UNOP_PREDEC
HLSL_IR_UNOP_POSTINC
HLSL_IR_UNOP_POSTDEC
HLSL_IR_BINOP_ADD
HLSL_IR_BINOP_SUB
HLSL_IR_BINOP_MUL
HLSL_IR_BINOP_DIV
HLSL_IR_BINOP_MOD
HLSL_IR_BINOP_LESS
HLSL_IR_BINOP_GREATER
HLSL_IR_BINOP_LEQUAL
HLSL_IR_BINOP_GEQUAL
HLSL_IR_BINOP_EQUAL
HLSL_IR_BINOP_NEQUAL
HLSL_IR_BINOP_LOGIC_AND
HLSL_IR_BINOP_LOGIC_OR
HLSL_IR_BINOP_LSHIFT
HLSL_IR_BINOP_RSHIFT
HLSL_IR_BINOP_BIT_AND
HLSL_IR_BINOP_BIT_OR
HLSL_IR_BINOP_BIT_XOR
HLSL_IR_BINOP_DOT
HLSL_IR_BINOP_CRS
HLSL_IR_BINOP_MIN
HLSL_IR_BINOP_MAX
HLSL_IR_BINOP_POW
HLSL_IR_TEROP_LERP
HLSL_IR_SEQUENCE

Definition at line 810 of file d3dcompiler_private.h.

                     {
    HLSL_IR_UNOP_BIT_NOT = 0,
    HLSL_IR_UNOP_LOGIC_NOT,
    HLSL_IR_UNOP_NEG,
    HLSL_IR_UNOP_ABS,
    HLSL_IR_UNOP_SIGN,
    HLSL_IR_UNOP_RCP,
    HLSL_IR_UNOP_RSQ,
    HLSL_IR_UNOP_SQRT,
    HLSL_IR_UNOP_NRM,
    HLSL_IR_UNOP_EXP2,
    HLSL_IR_UNOP_LOG2,
 
    HLSL_IR_UNOP_CAST,
 
    HLSL_IR_UNOP_FRACT,
 
    HLSL_IR_UNOP_SIN,
    HLSL_IR_UNOP_COS,
    HLSL_IR_UNOP_SIN_REDUCED,    /* Reduced range [-pi, pi] */
    HLSL_IR_UNOP_COS_REDUCED,    /* Reduced range [-pi, pi] */
 
    HLSL_IR_UNOP_DSX,
    HLSL_IR_UNOP_DSY,
 
    HLSL_IR_UNOP_SAT,
 
    HLSL_IR_UNOP_PREINC,
    HLSL_IR_UNOP_PREDEC,
    HLSL_IR_UNOP_POSTINC,
    HLSL_IR_UNOP_POSTDEC,
 
    HLSL_IR_BINOP_ADD,
    HLSL_IR_BINOP_SUB,
    HLSL_IR_BINOP_MUL,
    HLSL_IR_BINOP_DIV,
 
    HLSL_IR_BINOP_MOD,
 
    HLSL_IR_BINOP_LESS,
    HLSL_IR_BINOP_GREATER,
    HLSL_IR_BINOP_LEQUAL,
    HLSL_IR_BINOP_GEQUAL,
    HLSL_IR_BINOP_EQUAL,
    HLSL_IR_BINOP_NEQUAL,
 
    HLSL_IR_BINOP_LOGIC_AND,
    HLSL_IR_BINOP_LOGIC_OR,
 
    HLSL_IR_BINOP_LSHIFT,
    HLSL_IR_BINOP_RSHIFT,
    HLSL_IR_BINOP_BIT_AND,
    HLSL_IR_BINOP_BIT_OR,
    HLSL_IR_BINOP_BIT_XOR,
 
    HLSL_IR_BINOP_DOT,
    HLSL_IR_BINOP_CRS,
    HLSL_IR_BINOP_MIN,
    HLSL_IR_BINOP_MAX,
 
    HLSL_IR_BINOP_POW,
 
    HLSL_IR_TEROP_LERP,
 
    HLSL_IR_SEQUENCE,
};

◆ hlsl_ir_jump_type

enum hlsl_ir_jump_type

Enumerator
HLSL_IR_JUMP_BREAK
HLSL_IR_JUMP_CONTINUE
HLSL_IR_JUMP_DISCARD
HLSL_IR_JUMP_RETURN

Definition at line 885 of file d3dcompiler_private.h.

{
    HLSL_IR_JUMP_BREAK,
    HLSL_IR_JUMP_CONTINUE,
    HLSL_IR_JUMP_DISCARD,
    HLSL_IR_JUMP_RETURN,
};

◆ hlsl_ir_node_type

enum hlsl_ir_node_type

Enumerator
HLSL_IR_ASSIGNMENT
HLSL_IR_CONSTANT
HLSL_IR_CONSTRUCTOR
HLSL_IR_DEREF
HLSL_IR_EXPR
HLSL_IR_IF
HLSL_IR_LOOP
HLSL_IR_JUMP
HLSL_IR_SWIZZLE

Definition at line 707 of file d3dcompiler_private.h.

{
    HLSL_IR_ASSIGNMENT = 0,
    HLSL_IR_CONSTANT,
    HLSL_IR_CONSTRUCTOR,
    HLSL_IR_DEREF,
    HLSL_IR_EXPR,
    HLSL_IR_IF,
    HLSL_IR_LOOP,
    HLSL_IR_JUMP,
    HLSL_IR_SWIZZLE,
};

◆ hlsl_matrix_majority

enum hlsl_matrix_majority

Enumerator
HLSL_COLUMN_MAJOR
HLSL_ROW_MAJOR

Definition at line 663 of file d3dcompiler_private.h.

{
    HLSL_COLUMN_MAJOR,
    HLSL_ROW_MAJOR
};

◆ hlsl_sampler_dim

enum hlsl_sampler_dim

Enumerator
HLSL_SAMPLER_DIM_GENERIC
HLSL_SAMPLER_DIM_1D
HLSL_SAMPLER_DIM_2D
HLSL_SAMPLER_DIM_3D
HLSL_SAMPLER_DIM_CUBE

Definition at line 654 of file d3dcompiler_private.h.

{
   HLSL_SAMPLER_DIM_GENERIC,
   HLSL_SAMPLER_DIM_1D,
   HLSL_SAMPLER_DIM_2D,
   HLSL_SAMPLER_DIM_3D,
   HLSL_SAMPLER_DIM_CUBE,
};

◆ 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_OBJECT

Definition at line 626 of file d3dcompiler_private.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_OBJECT,
};

◆ parse_assign_op

enum parse_assign_op

Enumerator
ASSIGN_OP_ASSIGN
ASSIGN_OP_ADD
ASSIGN_OP_SUB
ASSIGN_OP_MUL
ASSIGN_OP_DIV
ASSIGN_OP_MOD
ASSIGN_OP_LSHIFT
ASSIGN_OP_RSHIFT
ASSIGN_OP_AND
ASSIGN_OP_OR
ASSIGN_OP_XOR

Definition at line 1021 of file d3dcompiler_private.h.

{
    ASSIGN_OP_ASSIGN,
    ASSIGN_OP_ADD,
    ASSIGN_OP_SUB,
    ASSIGN_OP_MUL,
    ASSIGN_OP_DIV,
    ASSIGN_OP_MOD,
    ASSIGN_OP_LSHIFT,
    ASSIGN_OP_RSHIFT,
    ASSIGN_OP_AND,
    ASSIGN_OP_OR,
    ASSIGN_OP_XOR,
};

◆ parse_status

enum parse_status

Enumerator
PARSE_SUCCESS
PARSE_WARN
PARSE_ERR

Definition at line 236 of file d3dcompiler_private.h.

{
    PARSE_SUCCESS = 0,
    PARSE_WARN = 1,
    PARSE_ERR = 2
};

◆ parse_unary_op

enum parse_unary_op

Enumerator
UNARY_OP_PLUS
UNARY_OP_MINUS
UNARY_OP_LOGICNOT
UNARY_OP_BITNOT

Definition at line 1013 of file d3dcompiler_private.h.

{
    UNARY_OP_PLUS,
    UNARY_OP_MINUS,
    UNARY_OP_LOGICNOT,
    UNARY_OP_BITNOT,
};

◆ shader_type

enum shader_type

Enumerator
ST_UNKNOWN
ST_VERTEX
ST_PIXEL

Definition at line 51 of file d3dcompiler_private.h.

{
    ST_UNKNOWN,
    ST_VERTEX,
    ST_PIXEL
};

Function Documentation

◆ add_constB()

BOOL add_constB	(	struct bwriter_shader *	shader,
		DWORD	reg,
		BOOL	x
	)

Definition at line 178 of file bytecodewriter.c.

                                                                  {
    struct constant *newconst;
 
    if(shader->num_cb) {
        struct constant **newarray;
        newarray = d3dcompiler_realloc(shader->constB,
                               sizeof(*shader->constB) * (shader->num_cb + 1));
        if(!newarray) {
            ERR("Failed to grow the constants array\n");
            return FALSE;
        }
        shader->constB = newarray;
    } else {
        shader->constB = d3dcompiler_alloc(sizeof(*shader->constB));
        if(!shader->constB) {
            ERR("Failed to allocate the constants array\n");
            return FALSE;
        }
    }
 
    newconst = d3dcompiler_alloc(sizeof(*newconst));
    if(!newconst) {
        ERR("Failed to allocate a new constant\n");
        return FALSE;
    }
    newconst->regnum = reg;
    newconst->value[0].b = x;
    shader->constB[shader->num_cb] = newconst;
 
    shader->num_cb++;
    return TRUE;
}

Referenced by asmparser_constB().

◆ add_constF()

BOOL add_constF	(	struct bwriter_shader *	shader,
		DWORD	reg,
		float	x,
		float	y,
		float	z,
		float	w
	)

Definition at line 106 of file bytecodewriter.c.

                                                                                              {
    struct constant *newconst;
 
    if(shader->num_cf) {
        struct constant **newarray;
        newarray = d3dcompiler_realloc(shader->constF,
                               sizeof(*shader->constF) * (shader->num_cf + 1));
        if(!newarray) {
            ERR("Failed to grow the constants array\n");
            return FALSE;
        }
        shader->constF = newarray;
    } else {
        shader->constF = d3dcompiler_alloc(sizeof(*shader->constF));
        if(!shader->constF) {
            ERR("Failed to allocate the constants array\n");
            return FALSE;
        }
    }
 
    newconst = d3dcompiler_alloc(sizeof(*newconst));
    if(!newconst) {
        ERR("Failed to allocate a new constant\n");
        return FALSE;
    }
    newconst->regnum = reg;
    newconst->value[0].f = x;
    newconst->value[1].f = y;
    newconst->value[2].f = z;
    newconst->value[3].f = w;
    shader->constF[shader->num_cf] = newconst;
 
    shader->num_cf++;
    return TRUE;
}

Referenced by asmparser_constF().

◆ add_constI()

BOOL add_constI	(	struct bwriter_shader *	shader,
		DWORD	reg,
		INT	x,
		INT	y,
		INT	z,
		INT	w
	)

Definition at line 142 of file bytecodewriter.c.

                                                                                      {
    struct constant *newconst;
 
    if(shader->num_ci) {
        struct constant **newarray;
        newarray = d3dcompiler_realloc(shader->constI,
                               sizeof(*shader->constI) * (shader->num_ci + 1));
        if(!newarray) {
            ERR("Failed to grow the constants array\n");
            return FALSE;
        }
        shader->constI = newarray;
    } else {
        shader->constI = d3dcompiler_alloc(sizeof(*shader->constI));
        if(!shader->constI) {
            ERR("Failed to allocate the constants array\n");
            return FALSE;
        }
    }
 
    newconst = d3dcompiler_alloc(sizeof(*newconst));
    if(!newconst) {
        ERR("Failed to allocate a new constant\n");
        return FALSE;
    }
    newconst->regnum = reg;
    newconst->value[0].i = x;
    newconst->value[1].i = y;
    newconst->value[2].i = z;
    newconst->value[3].i = w;
    shader->constI[shader->num_ci] = newconst;
 
    shader->num_ci++;
    return TRUE;
}

Referenced by asmparser_constI().

◆ add_declaration()

BOOL add_declaration	(	struct hlsl_scope *	scope,
		struct hlsl_ir_var *	decl,
		BOOL	local_var
	)

Definition at line 761 of file utils.c.

{
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
    {
        if (!strcmp(decl->name, var->name))
            return FALSE;
    }
    if (local_var && scope->upper->upper == hlsl_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 (!strcmp(decl->name, var->name))
                return FALSE;
        }
    }
 
    list_add_tail(&scope->vars, &decl->scope_entry);
    return TRUE;
}

◆ add_function_decl()

void add_function_decl	(	struct wine_rb_tree *	funcs,
		char *	name,
		struct hlsl_ir_function_decl *	decl,
		BOOL	intrinsic
	)

Definition at line 2282 of file utils.c.

{
    struct hlsl_ir_function *func;
    struct wine_rb_entry *func_entry, *old_entry;
 
    func_entry = wine_rb_get(funcs, name);
    if (func_entry)
    {
        func = WINE_RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry);
        if (intrinsic != func->intrinsic)
        {
            if (intrinsic)
            {
                ERR("Redeclaring a user defined function as an intrinsic.\n");
                return;
            }
            TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name));
            func->intrinsic = intrinsic;
            wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL);
            wine_rb_init(&func->overloads, compare_function_decl_rb);
        }
        decl->func = func;
        if ((old_entry = wine_rb_get(&func->overloads, decl->parameters)))
        {
            struct hlsl_ir_function_decl *old_decl =
                    WINE_RB_ENTRY_VALUE(old_entry, struct hlsl_ir_function_decl, entry);
 
            if (!decl->body)
            {
                free_function_decl(decl);
                d3dcompiler_free(name);
                return;
            }
            wine_rb_remove(&func->overloads, old_entry);
            free_function_decl(old_decl);
        }
        wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
        d3dcompiler_free(name);
        return;
    }
    func = d3dcompiler_alloc(sizeof(*func));
    func->name = name;
    wine_rb_init(&func->overloads, compare_function_decl_rb);
    decl->func = func;
    wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
    func->intrinsic = intrinsic;
    wine_rb_put(funcs, func->name, &func->entry);
}

◆ add_instruction()

BOOL add_instruction	(	struct bwriter_shader *	shader,
		struct instruction *	instr
	)

Definition at line 75 of file bytecodewriter.c.

                                                                               {
    struct instruction      **new_instructions;
 
    if(!shader) return FALSE;
 
    if(shader->instr_alloc_size == 0) {
        shader->instr = d3dcompiler_alloc(sizeof(*shader->instr) * INSTRARRAY_INITIAL_SIZE);
        if(!shader->instr) {
            ERR("Failed to allocate the shader instruction array\n");
            return FALSE;
        }
        shader->instr_alloc_size = INSTRARRAY_INITIAL_SIZE;
    } else if(shader->instr_alloc_size == shader->num_instrs) {
        new_instructions = d3dcompiler_realloc(shader->instr,
                                       sizeof(*shader->instr) * (shader->instr_alloc_size) * 2);
        if(!new_instructions) {
            ERR("Failed to grow the shader instruction array\n");
            return FALSE;
        }
        shader->instr = new_instructions;
        shader->instr_alloc_size = shader->instr_alloc_size * 2;
    } else if(shader->num_instrs > shader->instr_alloc_size) {
        ERR("More instructions than allocated. This should not happen\n");
        return FALSE;
    }
 
    shader->instr[shader->num_instrs] = instr;
    shader->num_instrs++;
    return TRUE;
}

Referenced by asmparser_instr(), asmparser_sincos(), asmparser_texcoord(), asmparser_texcrd(), asmparser_texhelper(), asmparser_texkill(), and asmparser_texld14().

◆ alloc_instr()

struct instruction * alloc_instr ( unsigned int srcs )

Definition at line 44 of file bytecodewriter.c.

                                                   {
    struct instruction *ret = d3dcompiler_alloc(sizeof(*ret));
    if(!ret) {
        ERR("Failed to allocate memory for an instruction structure\n");
        return NULL;
    }
 
    if(srcs) {
        ret->src = d3dcompiler_alloc(srcs * sizeof(*ret->src));
        if(!ret->src) {
            ERR("Failed to allocate memory for instruction registers\n");
            d3dcompiler_free(ret);
            return NULL;
        }
        ret->num_srcs = srcs;
    }
    return ret;
}

Referenced by asmparser_instr(), asmparser_sincos(), asmparser_texcoord(), asmparser_texcrd(), asmparser_texhelper(), asmparser_texkill(), and asmparser_texld14().

◆ asmparser_message()

void WINAPIV asmparser_message	(	struct asm_parser *	ctx,
		const char *	fmt,
			...
	)

Referenced by asmparser_coissue_supported(), asmparser_coissue_unsupported(), asmparser_dcl_input(), asmparser_dcl_input_unsupported(), asmparser_dcl_output(), asmparser_dcl_output_unsupported(), asmparser_dcl_sampler(), asmparser_dcl_sampler_unsupported(), asmparser_dstreg_ps_1_0123(), asmparser_dstreg_ps_1_4(), asmparser_dstreg_ps_2(), asmparser_dstreg_ps_2_x(), asmparser_dstreg_ps_3(), asmparser_dstreg_vs_1(), asmparser_dstreg_vs_2(), asmparser_dstreg_vs_3(), asmparser_instr(), asmparser_predicate_unsupported(), asmparser_sincos(), asmparser_srcreg_ps_1_0123(), asmparser_srcreg_ps_1_4(), asmparser_srcreg_ps_2(), asmparser_srcreg_ps_2_x(), asmparser_srcreg_ps_3(), asmparser_srcreg_vs_1(), asmparser_srcreg_vs_2(), asmparser_srcreg_vs_3(), asmparser_texcoord(), asmparser_texcrd(), asmparser_texld14(), check_abs_srcmod(), check_legacy_srcmod(), check_loop_swizzle(), check_ps_dstmod(), and check_shift_dstmod().

◆ assignment_from_node()

static struct hlsl_ir_assignment * assignment_from_node ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1093 of file d3dcompiler_private.h.

{
    assert(node->type == HLSL_IR_ASSIGNMENT);
    return CONTAINING_RECORD(node, struct hlsl_ir_assignment, node);
}

Referenced by debug_dump_instr(), and free_instr().

◆ clone_hlsl_type()

struct hlsl_type * clone_hlsl_type ( struct hlsl_type * old )

Definition at line 929 of file utils.c.

{
    struct hlsl_type *type;
    struct hlsl_struct_field *old_field, *field;
 
    type = d3dcompiler_alloc(sizeof(*type));
    if (!type)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    if (old->name)
    {
        type->name = d3dcompiler_strdup(old->name);
        if (!type->name)
        {
            d3dcompiler_free(type);
            return NULL;
        }
    }
    type->type = old->type;
    type->base_type = old->base_type;
    type->dimx = old->dimx;
    type->dimy = old->dimy;
    type->modifiers = old->modifiers;
    type->sampler_dim = old->sampler_dim;
    switch (old->type)
    {
        case HLSL_CLASS_ARRAY:
            type->e.array.type = old->e.array.type;
            type->e.array.elements_count = old->e.array.elements_count;
            break;
        case HLSL_CLASS_STRUCT:
            type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
            if (!type->e.elements)
            {
                d3dcompiler_free((void *)type->name);
                d3dcompiler_free(type);
                return NULL;
            }
            list_init(type->e.elements);
            LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
            {
                field = d3dcompiler_alloc(sizeof(*field));
                if (!field)
                {
                    LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
                    {
                        d3dcompiler_free((void *)field->semantic);
                        d3dcompiler_free((void *)field->name);
                        d3dcompiler_free(field);
                    }
                    d3dcompiler_free(type->e.elements);
                    d3dcompiler_free((void *)type->name);
                    d3dcompiler_free(type);
                    return NULL;
                }
                field->type = clone_hlsl_type(old_field->type);
                field->name = d3dcompiler_strdup(old_field->name);
                if (old_field->semantic)
                    field->semantic = d3dcompiler_strdup(old_field->semantic);
                field->modifiers = old_field->modifiers;
                list_add_tail(type->e.elements, &field->entry);
            }
            break;
        default:
            break;
    }
 
    list_add_tail(&hlsl_ctx.types, &type->entry);
    return type;
}

Referenced by clone_hlsl_type().

◆ compare_hlsl_types()

BOOL compare_hlsl_types	(	const struct hlsl_type *	t1,
		const struct hlsl_type *	t2
	)

Definition at line 883 of file utils.c.

{
    if (t1 == t2)
        return TRUE;
 
    if (t1->type != t2->type)
        return FALSE;
    if (t1->base_type != t2->base_type)
        return FALSE;
    if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
        return FALSE;
    if ((t1->modifiers & HLSL_MODIFIERS_COMPARISON_MASK)
            != (t2->modifiers & HLSL_MODIFIERS_COMPARISON_MASK))
        return FALSE;
    if (t1->dimx != t2->dimx)
        return FALSE;
    if (t1->dimy != t2->dimy)
        return FALSE;
    if (t1->type == HLSL_CLASS_STRUCT)
    {
        struct list *t1cur, *t2cur;
        struct hlsl_struct_field *t1field, *t2field;
 
        t1cur = list_head(t1->e.elements);
        t2cur = list_head(t2->e.elements);
        while (t1cur && t2cur)
        {
            t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
            t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
            if (!compare_hlsl_types(t1field->type, t2field->type))
                return FALSE;
            if (strcmp(t1field->name, t2field->name))
                return FALSE;
            t1cur = list_next(t1->e.elements, t1cur);
            t2cur = list_next(t2->e.elements, t2cur);
        }
        if (t1cur != t2cur)
            return FALSE;
    }
    if (t1->type == HLSL_CLASS_ARRAY)
        return t1->e.array.elements_count == t2->e.array.elements_count
                && compare_hlsl_types(t1->e.array.type, t2->e.array.type);
 
    return TRUE;
}

Referenced by compare_hlsl_types(), compatible_data_types(), expr_common_type(), implicit_compatible_data_types(), implicit_conversion(), make_assignment(), and new_expr().

◆ compatible_data_types()

BOOL compatible_data_types	(	struct hlsl_type *	s1,
		struct hlsl_type *	s2
	)

Definition at line 1007 of file utils.c.

{
   if (!convertible_data_type(t1) || !convertible_data_type(t2))
        return FALSE;
 
    if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
    {
        /* Scalar vars can be cast to pretty much everything */
        if (t1->dimx == 1 && t1->dimy == 1)
            return TRUE;
 
        if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
            return t1->dimx >= t2->dimx;
    }
 
    /* The other way around is true too i.e. whatever to scalar */
    if (t2->type <= HLSL_CLASS_LAST_NUMERIC && t2->dimx == 1 && t2->dimy == 1)
        return TRUE;
 
    if (t1->type == HLSL_CLASS_ARRAY)
    {
        if (compare_hlsl_types(t1->e.array.type, t2))
            /* e.g. float4[3] to float4 is allowed */
            return TRUE;
 
        if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
            return components_count_type(t1) >= components_count_type(t2);
        else
            return components_count_type(t1) == components_count_type(t2);
    }
 
    if (t1->type == HLSL_CLASS_STRUCT)
        return components_count_type(t1) >= components_count_type(t2);
 
    if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
        return components_count_type(t1) == components_count_type(t2);
 
    if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
    {
        if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
            return TRUE;
 
        /* Matrix-vector conversion is apparently allowed if they have the same components count */
        if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
                && components_count_type(t1) == components_count_type(t2))
            return TRUE;
        return FALSE;
    }
 
    if (components_count_type(t1) >= components_count_type(t2))
        return TRUE;
    return FALSE;
}

◆ compilation_message()

void compilation_message	(	struct compilation_messages *	msg,
		const char *	fmt,
		__ms_va_list	args
	)

Definition at line 719 of file utils.c.

{
    char* buffer;
    int rc, size;
 
    if (msg->capacity == 0)
    {
        msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE);
        if (msg->string == NULL)
        {
            ERR("Error allocating memory for parser messages\n");
            return;
        }
        msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
    }
 
    while (1)
    {
        rc = vsnprintf(msg->string + msg->size,
                msg->capacity - msg->size, fmt, args);
 
        if (rc < 0 || rc >= msg->capacity - msg->size)
        {
            size = msg->capacity * 2;
            buffer = d3dcompiler_realloc(msg->string, size);
            if (buffer == NULL)
            {
                ERR("Error reallocating memory for parser messages\n");
                return;
            }
            msg->string = buffer;
            msg->capacity = size;
        }
        else
        {
            TRACE("%s", msg->string + msg->size);
            msg->size += rc;
            return;
        }
    }
}

◆ components_count_type()

unsigned int components_count_type ( struct hlsl_type * type )

Definition at line 857 of file utils.c.

{
    unsigned int count = 0;
    struct hlsl_struct_field *field;
 
    if (type->type <= HLSL_CLASS_LAST_NUMERIC)
    {
        return type->dimx * type->dimy;
    }
    if (type->type == HLSL_CLASS_ARRAY)
    {
        return components_count_type(type->e.array.type) * type->e.array.elements_count;
    }
    if (type->type != HLSL_CLASS_STRUCT)
    {
        ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
        return 0;
    }
 
    LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
    {
        count += components_count_type(field->type);
    }
    return count;
}

Referenced by compatible_data_types(), components_count_type(), expr_compatible_data_types(), and implicit_compatible_data_types().

◆ constant_from_node()

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

inlinestatic

Definition at line 1081 of file d3dcompiler_private.h.

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

Referenced by debug_dump_instr(), and free_instr().

◆ constructor_from_node()

static struct hlsl_ir_constructor * constructor_from_node ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1105 of file d3dcompiler_private.h.

{
    assert(node->type == HLSL_IR_CONSTRUCTOR);
    return CONTAINING_RECORD(node, struct hlsl_ir_constructor, node);
}

Referenced by debug_dump_instr(), and free_instr().

◆ create_ps10_parser()

void create_ps10_parser ( struct asm_parser * ret )

Definition at line 1426 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_1_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(1, 0);
    ret->funcs = &parser_ps_1_0123;
    gen_oldps_input(ret->shader, 4);
}

◆ create_ps11_parser()

void create_ps11_parser ( struct asm_parser * ret )

Definition at line 1442 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_1_1\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(1, 1);
    ret->funcs = &parser_ps_1_0123;
    gen_oldps_input(ret->shader, 4);
}

◆ create_ps12_parser()

void create_ps12_parser ( struct asm_parser * ret )

Definition at line 1458 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_1_2\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(1, 2);
    ret->funcs = &parser_ps_1_0123;
    gen_oldps_input(ret->shader, 4);
}

◆ create_ps13_parser()

void create_ps13_parser ( struct asm_parser * ret )

Definition at line 1474 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_1_3\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(1, 3);
    ret->funcs = &parser_ps_1_0123;
    gen_oldps_input(ret->shader, 4);
}

◆ create_ps14_parser()

void create_ps14_parser ( struct asm_parser * ret )

Definition at line 1490 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_1_4\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(1, 4);
    ret->funcs = &parser_ps_1_4;
    gen_oldps_input(ret->shader, 6);
}

◆ create_ps20_parser()

void create_ps20_parser ( struct asm_parser * ret )

Definition at line 1506 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_2_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(2, 0);
    ret->funcs = &parser_ps_2;
    gen_oldps_input(ret->shader, 8);
}

◆ create_ps2x_parser()

void create_ps2x_parser ( struct asm_parser * ret )

Definition at line 1522 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_2_x\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(2, 1);
    ret->funcs = &parser_ps_2_x;
    gen_oldps_input(ret->shader, 8);
}

◆ create_ps30_parser()

void create_ps30_parser ( struct asm_parser * ret )

Definition at line 1538 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("ps_3_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_PIXEL;
    ret->shader->version = BWRITERPS_VERSION(3, 0);
    ret->funcs = &parser_ps_3;
}

◆ create_vs10_parser()

void create_vs10_parser ( struct asm_parser * ret )

Definition at line 1347 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("vs_1_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_VERTEX;
    ret->shader->version = BWRITERVS_VERSION(1, 0);
    ret->funcs = &parser_vs_1;
    gen_oldvs_output(ret->shader);
}

◆ create_vs11_parser()

void create_vs11_parser ( struct asm_parser * ret )

Definition at line 1363 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("vs_1_1\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_VERTEX;
    ret->shader->version = BWRITERVS_VERSION(1, 1);
    ret->funcs = &parser_vs_1;
    gen_oldvs_output(ret->shader);
}

◆ create_vs20_parser()

void create_vs20_parser ( struct asm_parser * ret )

Definition at line 1379 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("vs_2_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_VERTEX;
    ret->shader->version = BWRITERVS_VERSION(2, 0);
    ret->funcs = &parser_vs_2;
    gen_oldvs_output(ret->shader);
}

◆ create_vs2x_parser()

void create_vs2x_parser ( struct asm_parser * ret )

Definition at line 1395 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("vs_2_x\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_VERTEX;
    ret->shader->version = BWRITERVS_VERSION(2, 1);
    ret->funcs = &parser_vs_2;
    gen_oldvs_output(ret->shader);
}

◆ create_vs30_parser()

void create_vs30_parser ( struct asm_parser * ret )

Definition at line 1411 of file asmparser.c.

                                                {
    TRACE_(parsed_shader)("vs_3_0\n");
 
    ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
    if(!ret->shader) {
        ERR("Failed to allocate memory for the shader\n");
        set_parse_status(&ret->status, PARSE_ERR);
        return;
    }
 
    ret->shader->type = ST_VERTEX;
    ret->shader->version = BWRITERVS_VERSION(3, 0);
    ret->funcs = &parser_vs_3;
}

◆ d3dcompiler_alloc()

static void * d3dcompiler_alloc ( SIZE_T size )

inlinestatic

Definition at line 147 of file d3dcompiler_private.h.

{
    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
}

Referenced by add_constB(), add_constF(), add_constI(), add_function_decl(), add_instruction(), alloc_instr(), allocate_buffer(), clone_hlsl_type(), compilation_message(), create_ps10_parser(), create_ps11_parser(), create_ps12_parser(), create_ps13_parser(), create_ps14_parser(), create_ps20_parser(), create_ps2x_parser(), create_ps30_parser(), create_vs10_parser(), create_vs11_parser(), create_vs20_parser(), create_vs2x_parser(), create_vs30_parser(), create_writer(), d3dcompiler_strdup(), make_assignment(), new_expr(), new_func_decl(), new_hlsl_type(), new_record_deref(), new_var_deref(), push_scope(), record_declaration(), and record_sampler().

◆ d3dcompiler_free()

static BOOL d3dcompiler_free ( void * ptr )

inlinestatic

Definition at line 157 of file d3dcompiler_private.h.

{
    return HeapFree(GetProcessHeap(), 0, ptr);
}

Referenced by add_function_decl(), alloc_instr(), allocate_buffer(), clone_hlsl_type(), create_writer(), free_declaration(), free_function(), free_function_decl(), free_hlsl_type(), free_instr_list(), free_ir_assignment(), free_ir_constant(), free_ir_constructor(), free_ir_deref(), free_ir_expr(), free_ir_if(), free_ir_jump(), free_ir_swizzle(), make_assignment(), new_expr(), SlDeleteShader(), and SlWriteBytecode().

◆ d3dcompiler_realloc()

static void * d3dcompiler_realloc	(	void *	ptr,
		SIZE_T	size
	)

inlinestatic

Definition at line 152 of file d3dcompiler_private.h.

{
    return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
}

Referenced by add_constB(), add_constF(), add_constI(), add_instruction(), compilation_message(), put_dword(), record_declaration(), and record_sampler().

◆ d3dcompiler_strdup()

static char * d3dcompiler_strdup ( const char * string )

inlinestatic

Definition at line 162 of file d3dcompiler_private.h.

{
    char *copy;
    SIZE_T len;
 
    if (!string)
        return NULL;
 
    len = strlen(string);
    copy = d3dcompiler_alloc(len + 1);
    if (copy)
        memcpy(copy, string, len + 1);
    return copy;
}

Referenced by clone_hlsl_type().

◆ debug_d3dcompiler_d3d_blob_part()

const char * debug_d3dcompiler_d3d_blob_part ( D3D_BLOB_PART part )

Definition at line 106 of file utils.c.

{
    switch(part)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
        default:
            FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
            return "unrecognized";
    }
}

Referenced by check_blob_part(), d3dcompiler_get_blob_part(), and D3DGetBlobPart().

◆ debug_d3dcompiler_shader_variable_class()

const char * debug_d3dcompiler_shader_variable_class ( D3D_SHADER_VARIABLE_CLASS c )

Definition at line 32 of file utils.c.

{
    switch (c)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
        default:
            FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
            return "unrecognized";
    }
}

Referenced by d3dcompiler_parse_type().

◆ debug_d3dcompiler_shader_variable_type()

const char * debug_d3dcompiler_shader_variable_type ( D3D_SHADER_VARIABLE_TYPE t )

Definition at line 50 of file utils.c.

{
    switch (t)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
        default:
            FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
            return "unrecognized";
    }
}

Referenced by d3dcompiler_parse_type().

◆ debug_dump_ir_function_decl()

void debug_dump_ir_function_decl ( const struct hlsl_ir_function_decl * func )

Definition at line 2086 of file utils.c.

{
    struct hlsl_ir_var *param;
 
    TRACE("Dumping function %s.\n", debugstr_a(func->func->name));
    TRACE("Function parameters:\n");
    LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, param_entry)
    {
        debug_dump_ir_var(param);
        TRACE("\n");
    }
    if (func->semantic)
        TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
    if (func->body)
    {
        debug_dump_instr_list(func->body);
    }
}

◆ debug_hlsl_type()

const char * debug_hlsl_type ( const struct hlsl_type * type )

Definition at line 1695 of file utils.c.

{
    const char *name;
 
    if (type->name)
        return debugstr_a(type->name);
 
    if (type->type == HLSL_CLASS_STRUCT)
        return "<anonymous struct>";
 
    if (type->type == HLSL_CLASS_ARRAY)
    {
        name = debug_base_type(type->e.array.type);
        return wine_dbg_sprintf("%s[%u]", name, type->e.array.elements_count);
    }
 
    name = debug_base_type(type);
 
    if (type->type == HLSL_CLASS_SCALAR)
        return wine_dbg_sprintf("%s", name);
    if (type->type == HLSL_CLASS_VECTOR)
        return wine_dbg_sprintf("%s%u", name, type->dimx);
    if (type->type == HLSL_CLASS_MATRIX)
        return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy);
    return "unexpected_type";
}

Referenced by components_count_type(), debug_dump_ir_constructor(), debug_dump_ir_var(), debug_expr_op(), implicit_conversion(), make_assignment(), and new_expr().

◆ debug_modifiers()

const char * debug_modifiers ( DWORD modifiers )

Definition at line 1722 of file utils.c.

{
    char string[110];
 
    string[0] = 0;
    if (modifiers & HLSL_STORAGE_EXTERN)
        strcat(string, " extern");                       /* 7 */
    if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
        strcat(string, " nointerpolation");              /* 16 */
    if (modifiers & HLSL_MODIFIER_PRECISE)
        strcat(string, " precise");                      /* 8 */
    if (modifiers & HLSL_STORAGE_SHARED)
        strcat(string, " shared");                       /* 7 */
    if (modifiers & HLSL_STORAGE_GROUPSHARED)
        strcat(string, " groupshared");                  /* 12 */
    if (modifiers & HLSL_STORAGE_STATIC)
        strcat(string, " static");                       /* 7 */
    if (modifiers & HLSL_STORAGE_UNIFORM)
        strcat(string, " uniform");                      /* 8 */
    if (modifiers & HLSL_STORAGE_VOLATILE)
        strcat(string, " volatile");                     /* 9 */
    if (modifiers & HLSL_MODIFIER_CONST)
        strcat(string, " const");                        /* 6 */
    if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
        strcat(string, " row_major");                    /* 10 */
    if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
        strcat(string, " column_major");                 /* 13 */
    if ((modifiers & (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) == (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT))
        strcat(string, " inout");                        /* 6 */
    else if (modifiers & HLSL_MODIFIER_IN)
        strcat(string, " in");                           /* 3 */
    else if (modifiers & HLSL_MODIFIER_OUT)
        strcat(string, " out");                          /* 4 */
 
    return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
}

Referenced by debug_dump_ir_var().

◆ debug_print_comp()

const char * debug_print_comp ( DWORD comp )

Definition at line 401 of file utils.c.

{
    switch (comp)
    {
        case BWRITER_COMPARISON_NONE: return "";
        case BWRITER_COMPARISON_GT:   return "_gt";
        case BWRITER_COMPARISON_EQ:   return "_eq";
        case BWRITER_COMPARISON_GE:   return "_ge";
        case BWRITER_COMPARISON_LT:   return "_lt";
        case BWRITER_COMPARISON_NE:   return "_ne";
        case BWRITER_COMPARISON_LE:   return "_le";
        default: return "_unknown";
    }
}

Referenced by asmparser_instr().

◆ debug_print_dstmod()

const char * debug_print_dstmod ( DWORD mod )

Definition at line 153 of file utils.c.

{
    switch (mod)
    {
        case 0:
            return "";
        case BWRITERSPDM_SATURATE:
            return "_sat";
        case BWRITERSPDM_PARTIALPRECISION:
            return "_pp";
        case BWRITERSPDM_MSAMPCENTROID:
            return "_centroid";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
            return "_sat_pp";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
            return "_sat_centroid";
        case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
            return "_pp_centroid";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
            return "_sat_pp_centroid";
        default:
            return "Unexpected modifier\n";
    }
}

Referenced by asmparser_instr(), and check_ps_dstmod().

◆ debug_print_dstreg()

const char * debug_print_dstreg ( const struct shader_reg * reg )

Definition at line 330 of file utils.c.

{
    return wine_dbg_sprintf("%s%s%s", get_regname(reg),
            debug_print_relarg(reg),
            debug_print_writemask(reg->u.writemask));
}

Referenced by asmparser_dstreg_ps_1_0123(), asmparser_dstreg_ps_1_4(), asmparser_dstreg_ps_2(), asmparser_dstreg_ps_2_x(), asmparser_dstreg_ps_3(), asmparser_dstreg_vs_1(), asmparser_dstreg_vs_2(), asmparser_dstreg_vs_3(), and asmparser_instr().

◆ debug_print_opcode()

const char * debug_print_opcode ( DWORD opcode )

Definition at line 416 of file utils.c.

{
    switch (opcode)
    {
        case BWRITERSIO_NOP:          return "nop";
        case BWRITERSIO_MOV:          return "mov";
        case BWRITERSIO_ADD:          return "add";
        case BWRITERSIO_SUB:          return "sub";
        case BWRITERSIO_MAD:          return "mad";
        case BWRITERSIO_MUL:          return "mul";
        case BWRITERSIO_RCP:          return "rcp";
        case BWRITERSIO_RSQ:          return "rsq";
        case BWRITERSIO_DP3:          return "dp3";
        case BWRITERSIO_DP4:          return "dp4";
        case BWRITERSIO_MIN:          return "min";
        case BWRITERSIO_MAX:          return "max";
        case BWRITERSIO_SLT:          return "slt";
        case BWRITERSIO_SGE:          return "sge";
        case BWRITERSIO_EXP:          return "exp";
        case BWRITERSIO_LOG:          return "log";
        case BWRITERSIO_LIT:          return "lit";
        case BWRITERSIO_DST:          return "dst";
        case BWRITERSIO_LRP:          return "lrp";
        case BWRITERSIO_FRC:          return "frc";
        case BWRITERSIO_M4x4:         return "m4x4";
        case BWRITERSIO_M4x3:         return "m4x3";
        case BWRITERSIO_M3x4:         return "m3x4";
        case BWRITERSIO_M3x3:         return "m3x3";
        case BWRITERSIO_M3x2:         return "m3x2";
        case BWRITERSIO_CALL:         return "call";
        case BWRITERSIO_CALLNZ:       return "callnz";
        case BWRITERSIO_LOOP:         return "loop";
        case BWRITERSIO_RET:          return "ret";
        case BWRITERSIO_ENDLOOP:      return "endloop";
        case BWRITERSIO_LABEL:        return "label";
        case BWRITERSIO_DCL:          return "dcl";
        case BWRITERSIO_POW:          return "pow";
        case BWRITERSIO_CRS:          return "crs";
        case BWRITERSIO_SGN:          return "sgn";
        case BWRITERSIO_ABS:          return "abs";
        case BWRITERSIO_NRM:          return "nrm";
        case BWRITERSIO_SINCOS:       return "sincos";
        case BWRITERSIO_REP:          return "rep";
        case BWRITERSIO_ENDREP:       return "endrep";
        case BWRITERSIO_IF:           return "if";
        case BWRITERSIO_IFC:          return "ifc";
        case BWRITERSIO_ELSE:         return "else";
        case BWRITERSIO_ENDIF:        return "endif";
        case BWRITERSIO_BREAK:        return "break";
        case BWRITERSIO_BREAKC:       return "breakc";
        case BWRITERSIO_MOVA:         return "mova";
        case BWRITERSIO_DEFB:         return "defb";
        case BWRITERSIO_DEFI:         return "defi";
        case BWRITERSIO_TEXCOORD:     return "texcoord";
        case BWRITERSIO_TEXKILL:      return "texkill";
        case BWRITERSIO_TEX:          return "tex";
        case BWRITERSIO_TEXBEM:       return "texbem";
        case BWRITERSIO_TEXBEML:      return "texbeml";
        case BWRITERSIO_TEXREG2AR:    return "texreg2ar";
        case BWRITERSIO_TEXREG2GB:    return "texreg2gb";
        case BWRITERSIO_TEXM3x2PAD:   return "texm3x2pad";
        case BWRITERSIO_TEXM3x2TEX:   return "texm3x2tex";
        case BWRITERSIO_TEXM3x3PAD:   return "texm3x3pad";
        case BWRITERSIO_TEXM3x3TEX:   return "texm3x3tex";
        case BWRITERSIO_TEXM3x3SPEC:  return "texm3x3vspec";
        case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
        case BWRITERSIO_EXPP:         return "expp";
        case BWRITERSIO_LOGP:         return "logp";
        case BWRITERSIO_CND:          return "cnd";
        case BWRITERSIO_DEF:          return "def";
        case BWRITERSIO_TEXREG2RGB:   return "texreg2rgb";
        case BWRITERSIO_TEXDP3TEX:    return "texdp3tex";
        case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
        case BWRITERSIO_TEXDP3:       return "texdp3";
        case BWRITERSIO_TEXM3x3:      return "texm3x3";
        case BWRITERSIO_TEXDEPTH:     return "texdepth";
        case BWRITERSIO_CMP:          return "cmp";
        case BWRITERSIO_BEM:          return "bem";
        case BWRITERSIO_DP2ADD:       return "dp2add";
        case BWRITERSIO_DSX:          return "dsx";
        case BWRITERSIO_DSY:          return "dsy";
        case BWRITERSIO_TEXLDD:       return "texldd";
        case BWRITERSIO_SETP:         return "setp";
        case BWRITERSIO_TEXLDL:       return "texldl";
        case BWRITERSIO_BREAKP:       return "breakp";
        case BWRITERSIO_PHASE:        return "phase";
 
        case BWRITERSIO_TEXLDP:       return "texldp";
        case BWRITERSIO_TEXLDB:       return "texldb";
 
        default:                      return "unknown";
    }
}

Referenced by asmparser_instr(), and call_instr_handler().

◆ debug_print_shift()

const char * debug_print_shift ( DWORD shift )

Definition at line 178 of file utils.c.

{
    static const char * const shiftstrings[] =
    {
        "",
        "_x2",
        "_x4",
        "_x8",
        "_x16",
        "_x32",
        "",
        "",
        "",
        "",
        "",
        "",
        "_d16",
        "_d8",
        "_d4",
        "_d2",
    };
    return shiftstrings[shift];
}

Referenced by asmparser_instr().

◆ debug_print_srcmod()

const char * debug_print_srcmod ( DWORD mod )

Definition at line 128 of file utils.c.

{
    switch (mod)
    {
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
        default:
            FIXME("Unrecognized source modifier %#x.\n", mod);
            return "unrecognized_src_mod";
    }
}

Referenced by check_abs_srcmod(), and check_legacy_srcmod().

◆ debug_print_srcreg()

const char * debug_print_srcreg ( const struct shader_reg * reg )

Definition at line 337 of file utils.c.

{
    switch (reg->srcmod)
    {
        case BWRITERSPSM_NONE:
            return wine_dbg_sprintf("%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_NEG:
            return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_BIAS:
            return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_BIASNEG:
            return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_SIGN:
            return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_SIGNNEG:
            return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_COMP:
            return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_X2:
            return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_X2NEG:
            return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_DZ:
            return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_DW:
            return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_ABS:
            return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_ABSNEG:
            return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_NOT:
            return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
    }
    return "Unknown modifier";
}

Referenced by asmparser_instr(), asmparser_srcreg_ps_1_0123(), asmparser_srcreg_ps_1_4(), asmparser_srcreg_ps_2(), asmparser_srcreg_ps_2_x(), asmparser_srcreg_ps_3(), asmparser_srcreg_vs_1(), asmparser_srcreg_vs_2(), and asmparser_srcreg_vs_3().

◆ deref_from_node()

static struct hlsl_ir_deref * deref_from_node ( const struct hlsl_ir_node * node )

inlinestatic

Definition at line 1075 of file d3dcompiler_private.h.

{
    assert(node->type == HLSL_IR_DEREF);
    return CONTAINING_RECORD(node, struct hlsl_ir_deref, node);
}

Referenced by debug_dump_instr(), free_instr(), and make_assignment().

◆ dxbc_add_section()

HRESULT dxbc_add_section	(	struct dxbc *	dxbc,
		DWORD	tag,
		const char *	data,
		DWORD	data_size
	)

Definition at line 529 of file utils.c.

{
    TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
 
    if (dxbc->count >= dxbc->size)
    {
        struct dxbc_section *new_sections;
        DWORD new_size = dxbc->size << 1;
 
        new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
        if (!new_sections)
        {
            ERR("Failed to allocate dxbc section memory\n");
            return E_OUTOFMEMORY;
        }
 
        dxbc->sections = new_sections;
        dxbc->size = new_size;
    }
 
    dxbc->sections[dxbc->count].tag = tag;
    dxbc->sections[dxbc->count].data_size = data_size;
    dxbc->sections[dxbc->count].data = data;
    ++dxbc->count;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), and dxbc_parse().

◆ dxbc_destroy()

void dxbc_destroy ( struct dxbc * dxbc )

Definition at line 648 of file utils.c.

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

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), and d3dcompiler_strip_shader().

◆ dxbc_init()

HRESULT dxbc_init	(	struct dxbc *	dxbc,
		unsigned int	size
	)

Definition at line 557 of file utils.c.

{
    TRACE("dxbc %p, size %u.\n", dxbc, size);
 
    /* use a good starting value for the size if none specified */
    if (!size) size = 2;
 
    dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
    if (!dxbc->sections)
    {
        ERR("Failed to allocate dxbc section memory\n");
        return E_OUTOFMEMORY;
    }
 
    dxbc->size = size;
    dxbc->count = 0;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), and dxbc_parse().

◆ dxbc_parse()

HRESULT dxbc_parse	(	const char *	data,
		SIZE_T	data_size,
		struct dxbc *	dxbc
	)

Definition at line 577 of file utils.c.

{
    const char *ptr = data;
    HRESULT hr;
    unsigned int i;
    DWORD tag, total_size, chunk_count;
 
    if (!data)
    {
        WARN("No data supplied.\n");
        return E_FAIL;
    }
 
    read_dword(&ptr, &tag);
    TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 
    if (tag != TAG_DXBC)
    {
        WARN("Wrong tag.\n");
        return E_FAIL;
    }
 
    /* checksum? */
    skip_dword_unknown(&ptr, 4);
 
    skip_dword_unknown(&ptr, 1);
 
    read_dword(&ptr, &total_size);
    TRACE("total size: %#x\n", total_size);
 
    if (data_size != total_size)
    {
        WARN("Wrong size supplied.\n");
        return D3DERR_INVALIDCALL;
    }
 
    read_dword(&ptr, &chunk_count);
    TRACE("chunk count: %#x\n", chunk_count);
 
    hr = dxbc_init(dxbc, chunk_count);
    if (FAILED(hr))
    {
        WARN("Failed to init dxbc\n");
        return hr;
    }
 
    for (i = 0; i < chunk_count; ++i)
    {
        DWORD chunk_tag, chunk_size;
        const char *chunk_ptr;
        DWORD chunk_offset;
 
        read_dword(&ptr, &chunk_offset);
        TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 
        chunk_ptr = data + chunk_offset;
 
        read_dword(&chunk_ptr, &chunk_tag);
        read_dword(&chunk_ptr, &chunk_size);
 
        hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
        if (FAILED(hr))
        {
            WARN("Failed to add section to dxbc\n");
            return hr;
        }
    }
 
    return hr;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), and d3dcompiler_strip_shader().

◆ dxbc_write_blob()

HRESULT dxbc_write_blob	(	struct dxbc *	dxbc,
		ID3DBlob **	blob
	)

Definition at line 655 of file utils.c.

{
    DWORD size = 32, offset = size + 4 * dxbc->count;
    ID3DBlob *object;
    HRESULT hr;
    char *ptr;
    unsigned int i;
 
    TRACE("dxbc %p, blob %p.\n", dxbc, blob);
 
    for (i = 0; i < dxbc->count; ++i)
    {
        size += 12 + dxbc->sections[i].data_size;
    }
 
    hr = D3DCreateBlob(size, &object);
    if (FAILED(hr))
    {
        WARN("Failed to create blob\n");
        return hr;
    }
 
    ptr = ID3D10Blob_GetBufferPointer(object);
 
    write_dword(&ptr, TAG_DXBC);
 
    /* signature(?) */
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
 
    /* seems to be always 1 */
    write_dword_unknown(&ptr, 1);
 
    /* DXBC size */
    write_dword(&ptr, size);
 
    /* chunk count */
    write_dword(&ptr, dxbc->count);
 
    /* write the chunk offsets */
    for (i = 0; i < dxbc->count; ++i)
    {
        write_dword(&ptr, offset);
        offset += 8 + dxbc->sections[i].data_size;
    }
 
    /* write the chunks */
    for (i = 0; i < dxbc->count; ++i)
    {
        write_dword(&ptr, dxbc->sections[i].tag);
        write_dword(&ptr, dxbc->sections[i].data_size);
        memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
        ptr += dxbc->sections[i].data_size;
    }
 
    TRACE("Created ID3DBlob %p\n", object);
 
    *blob = object;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), and d3dcompiler_strip_shader().

◆ expr_from_node()

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

inlinestatic

Definition at line 1069 of file d3dcompiler_private.h.

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

Referenced by debug_dump_instr(), free_instr(), and new_cast().

◆ find_function()

BOOL find_function ( const char * name )

Definition at line 852 of file utils.c.

{
    return wine_rb_get(&hlsl_ctx.functions, name) != NULL;
}

◆ free_declaration()

void free_declaration ( struct hlsl_ir_var * decl )

Definition at line 798 of file utils.c.

{
    d3dcompiler_free((void *)decl->name);
    d3dcompiler_free((void *)decl->semantic);
    d3dcompiler_free((void *)decl->reg_reservation);
    d3dcompiler_free(decl);
}

◆ free_function_rb()

void free_function_rb	(	struct wine_rb_entry *	entry,
		void *	context
	)

Definition at line 2277 of file utils.c.

{
    free_function(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry));
}

◆ free_hlsl_type()

void free_hlsl_type ( struct hlsl_type * type )

Definition at line 2105 of file utils.c.

{
    struct hlsl_struct_field *field, *next_field;
 
    d3dcompiler_free((void *)type->name);
    if (type->type == HLSL_CLASS_STRUCT)
    {
        LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
        {
            d3dcompiler_free((void *)field->name);
            d3dcompiler_free((void *)field->semantic);
            d3dcompiler_free(field);
        }
    }
    d3dcompiler_free(type);
}

◆ free_instr()

void free_instr ( struct hlsl_ir_node * node )

Definition at line 2224 of file utils.c.

{
    switch (node->type)
    {
        case HLSL_IR_CONSTANT:
            free_ir_constant(constant_from_node(node));
            break;
        case HLSL_IR_DEREF:
            free_ir_deref(deref_from_node(node));
            break;
        case HLSL_IR_SWIZZLE:
            free_ir_swizzle(swizzle_from_node(node));
            break;
        case HLSL_IR_CONSTRUCTOR:
            free_ir_constructor(constructor_from_node(node));
            break;
        case HLSL_IR_EXPR:
            free_ir_expr(expr_from_node(node));
            break;
        case HLSL_IR_ASSIGNMENT:
            free_ir_assignment(assignment_from_node(node));
            break;
        case HLSL_IR_IF:
            free_ir_if(if_from_node(node));
            break;
        case HLSL_IR_JUMP:
            free_ir_jump(jump_from_node(node));
            break;
        default:
            FIXME("Unsupported node type %s\n", debug_node_type(node->type));
    }
}

Referenced by free_instr_list(), free_ir_assignment(), free_ir_constructor(), free_ir_deref(), free_ir_expr(), free_ir_if(), free_ir_jump(), free_ir_swizzle(), and make_assignment().

◆ free_instr_list()

void free_instr_list ( struct list * list )

Definition at line 2122 of file utils.c.

{
    struct hlsl_ir_node *node, *next_node;
 
    if (!list)
        return;
    LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry)
        free_instr(node);
    d3dcompiler_free(list);
}

Referenced by free_function_decl(), free_ir_expr(), and free_ir_if().

◆ get_type()

struct hlsl_type * get_type	(	struct hlsl_scope *	scope,
		const char *	name,
		BOOL	recursive
	)

Definition at line 841 of file utils.c.

{
    struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
    if (entry)
        return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
 
    if (recursive && scope->upper)
        return get_type(scope->upper, name, recursive);
    return NULL;
}

Referenced by get_type(), type_apicontract_declare(), type_coclass_declare(), type_delegate_declare(), type_dispinterface_declare(), type_interface_declare(), type_module_declare(), type_parameterized_delegate_declare(), type_parameterized_interface_declare(), and type_runtimeclass_declare().

◆ get_variable()

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

Definition at line 784 of file utils.c.

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

Referenced by get_variable().

◆ hlsl_message()

void WINAPIV hlsl_message	(	const char *	fmt,
			...
	)

◆ hlsl_report_message()

void WINAPIV hlsl_report_message	(	const char *	filename,
		DWORD	line,
		DWORD	column,
		enum hlsl_error_level	level,
		const char *	fmt,
			...
	)

Referenced by expr_common_type(), make_assignment(), and new_expr().

◆ if_from_node()

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

inlinestatic

Definition at line 1111 of file d3dcompiler_private.h.

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

Referenced by debug_dump_instr(), and free_instr().

◆ init_functions_tree()

void init_functions_tree ( struct wine_rb_tree * funcs )

Definition at line 1662 of file utils.c.

{
    wine_rb_init(&hlsl_ctx.functions, compare_function_rb);
}

◆ jump_from_node()

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

inlinestatic

Definition at line 1087 of file d3dcompiler_private.h.

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

Referenced by debug_dump_instr(), and free_instr().

◆ loop_from_node()

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

inlinestatic

Definition at line 1117 of file d3dcompiler_private.h.

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

◆ make_assignment()

struct hlsl_ir_node * make_assignment	(	struct hlsl_ir_node *	left,
		enum parse_assign_op	assign_op,
		DWORD	writemask,
		struct hlsl_ir_node *	right
	)

Definition at line 1407 of file utils.c.

{
    struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign));
    struct hlsl_type *type;
    struct hlsl_ir_node *lhs, *rhs;
 
    if (!assign)
    {
        ERR("Out of memory\n");
        return NULL;
    }
 
    TRACE("Creating proper assignment expression.\n");
    rhs = right;
    if (writemask == BWRITERSP_WRITEMASK_ALL)
        type = left->data_type;
    else
    {
        unsigned int dimx = 0;
        DWORD bitmask;
        enum hlsl_type_class type_class;
 
        if (left->data_type->type > HLSL_CLASS_LAST_NUMERIC)
        {
            hlsl_report_message(left->loc.file, left->loc.line, left->loc.col, HLSL_LEVEL_ERROR,
                    "writemask on a non scalar/vector/matrix type");
            d3dcompiler_free(assign);
            return NULL;
        }
        bitmask = writemask & ((1 << left->data_type->dimx) - 1);
        while (bitmask)
        {
            if (bitmask & 1)
                dimx++;
            bitmask >>= 1;
        }
        if (left->data_type->type == HLSL_CLASS_MATRIX)
            FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
        if (dimx == 1)
            type_class = HLSL_CLASS_SCALAR;
        else
            type_class = left->data_type->type;
        type = new_hlsl_type(NULL, type_class, left->data_type->base_type, dimx, 1);
    }
    assign->node.type = HLSL_IR_ASSIGNMENT;
    assign->node.loc = left->loc;
    assign->node.data_type = type;
    assign->writemask = writemask;
    FIXME("Check for casts in the lhs.\n");
 
    lhs = left;
    /* FIXME: check for invalid writemasks on the lhs. */
 
    if (!compare_hlsl_types(type, rhs->data_type))
    {
        struct hlsl_ir_node *converted_rhs;
 
        if (!implicit_compatible_data_types(rhs->data_type, type))
        {
            hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR,
                    "can't implicitly convert %s to %s",
                    debug_hlsl_type(rhs->data_type), debug_hlsl_type(type));
            free_instr(lhs);
            free_instr(rhs);
            d3dcompiler_free(assign);
            return NULL;
        }
        if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy)
            hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING,
                    "implicit truncation of vector type");
 
        converted_rhs = implicit_conversion(rhs, type, &rhs->loc);
        if (!converted_rhs)
        {
            ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type));
            free_instr(lhs);
            free_instr(rhs);
            d3dcompiler_free(assign);
            return NULL;
        }
        rhs = converted_rhs;
    }
 
    assign->lhs = lhs;
    if (assign_op != ASSIGN_OP_ASSIGN)
    {
        enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
        struct hlsl_ir_node *expr;
 
        if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR)
        {
            FIXME("LHS expression not supported in compound assignments yet.\n");
            assign->rhs = rhs;
        }
        else
        {
            struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref;
 
            TRACE("Adding an expression for the compound assignment.\n");
            new_deref = new_var_deref(lhs_deref->v.var);
            expr = new_binary_expr(op, &new_deref->node, rhs, left->loc);
            assign->rhs = expr;
        }
    }
    else
        assign->rhs = rhs;
 
    return &assign->node;
}

◆ new_array_type()

struct hlsl_type * new_array_type	(	struct hlsl_type *	basic_type,
		unsigned int	array_size
	)

Definition at line 828 of file utils.c.

{
    struct hlsl_type *type = new_hlsl_type(NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1);
 
    if (!type)
        return NULL;
 
    type->modifiers = basic_type->modifiers;
    type->e.array.elements_count = array_size;
    type->e.array.type = basic_type;
    return type;
}

◆ new_binary_expr()

static struct hlsl_ir_node * new_binary_expr	(	enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	op1,
		struct hlsl_ir_node *	op2,
		struct source_location	loc
	)

inlinestatic

Definition at line 1168 of file d3dcompiler_private.h.

{
    struct hlsl_ir_node *operands[3] = {op1, op2};
    return &new_expr(op, operands, &loc)->node;
}

Referenced by make_assignment().

◆ new_cast()

struct hlsl_ir_expr * new_cast	(	struct hlsl_ir_node *	node,
		struct hlsl_type *	type,
		struct source_location *	loc
	)

Definition at line 1343 of file utils.c.

{
    struct hlsl_ir_node *cast;
 
    cast = new_unary_expr(HLSL_IR_UNOP_CAST, node, *loc);
    if (cast)
        cast->data_type = type;
    return expr_from_node(cast);
}

Referenced by implicit_conversion().

◆ new_expr()

struct hlsl_ir_expr * new_expr	(	enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node **	operands,
		struct source_location *	loc
	)

Definition at line 1286 of file utils.c.

{
    struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr));
    struct hlsl_type *type;
    unsigned int i;
 
    if (!expr)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    expr->node.type = HLSL_IR_EXPR;
    expr->node.loc = *loc;
    type = operands[0]->data_type;
    for (i = 1; i <= 2; ++i)
    {
        if (!operands[i])
            break;
        type = expr_common_type(type, operands[i]->data_type, loc);
        if (!type)
        {
            d3dcompiler_free(expr);
            return NULL;
        }
    }
    for (i = 0; i <= 2; ++i)
    {
        if (!operands[i])
            break;
        if (compare_hlsl_types(operands[i]->data_type, type))
            continue;
        TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type));
        if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1
                && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy)
        {
            hlsl_report_message(operands[i]->loc.file,
                    operands[i]->loc.line, operands[i]->loc.col, HLSL_LEVEL_WARNING,
                    "implicit truncation of vector/matrix type");
        }
        operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc);
        if (!operands[i])
        {
            ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type));
            d3dcompiler_free(expr);
            return NULL;
        }
    }
    expr->node.data_type = type;
    expr->op = op;
    expr->operands[0] = operands[0];
    expr->operands[1] = operands[1];
    expr->operands[2] = operands[2];
 
    return expr;
}

Referenced by new_binary_expr(), and new_unary_expr().

◆ new_func_decl()

struct hlsl_ir_function_decl * new_func_decl	(	struct hlsl_type *	return_type,
		struct list *	parameters
	)

Definition at line 1562 of file utils.c.

{
    struct hlsl_ir_function_decl *decl;
 
    decl = d3dcompiler_alloc(sizeof(*decl));
    if (!decl)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    decl->return_type = return_type;
    decl->parameters = parameters;
 
    return decl;
}

◆ new_hlsl_type()

struct hlsl_type * new_hlsl_type	(	const char *	name,
		enum hlsl_type_class	type_class,
		enum hlsl_base_type	base_type,
		unsigned	dimx,
		unsigned	dimy
	)

Definition at line 806 of file utils.c.

{
    struct hlsl_type *type;
 
    type = d3dcompiler_alloc(sizeof(*type));
    if (!type)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    type->name = name;
    type->type = type_class;
    type->base_type = base_type;
    type->dimx = dimx;
    type->dimy = dimy;
 
    list_add_tail(&hlsl_ctx.types, &type->entry);
 
    return type;
}

Referenced by expr_common_type(), make_assignment(), and new_array_type().

◆ new_record_deref()

struct hlsl_ir_deref * new_record_deref	(	struct hlsl_ir_node *	record,
		struct hlsl_struct_field *	field
	)

Definition at line 1370 of file utils.c.

{
    struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
 
    if (!deref)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    deref->node.type = HLSL_IR_DEREF;
    deref->node.data_type = field->type;
    deref->type = HLSL_IR_DEREF_RECORD;
    deref->v.record.record = record;
    deref->v.record.field = field;
    return deref;
}

◆ new_unary_expr()

static struct hlsl_ir_node * new_unary_expr	(	enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node *	op1,
		struct source_location	loc
	)

inlinestatic

Definition at line 1161 of file d3dcompiler_private.h.

{
    struct hlsl_ir_node *operands[3] = {op1};
    return &new_expr(op, operands, &loc)->node;
}

Referenced by new_cast().

◆ new_var_deref()

struct hlsl_ir_deref * new_var_deref ( struct hlsl_ir_var * var )

Definition at line 1354 of file utils.c.

{
    struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
 
    if (!deref)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    deref->node.type = HLSL_IR_DEREF;
    deref->node.data_type = var->data_type;
    deref->type = HLSL_IR_DEREF_VAR;
    deref->v.var = var;
    return deref;
}

Referenced by make_assignment().

◆ parse_asm_shader()

struct bwriter_shader * parse_asm_shader ( char ** messages )

◆ parse_hlsl_shader()

struct bwriter_shader * parse_hlsl_shader	(	const char *	text,
		enum shader_type	type,
		DWORD	major,
		DWORD	minor,
		const char *	entrypoint,
		char **	messages
	)

Referenced by compile_shader().

◆ pop_scope()

BOOL pop_scope ( struct hlsl_parse_ctx * ctx )

Definition at line 1551 of file utils.c.

{
    struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
    if (!prev_scope)
        return FALSE;
 
    TRACE("Popping current scope\n");
    ctx->cur_scope = prev_scope;
    return TRUE;
}

◆ push_scope()

void push_scope ( struct hlsl_parse_ctx * ctx )

Definition at line 1534 of file utils.c.

{
    struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
 
    if (!new_scope)
    {
        ERR("Out of memory!\n");
        return;
    }
    TRACE("Pushing a new scope\n");
    list_init(&new_scope->vars);
    wine_rb_init(&new_scope->types, compare_hlsl_types_rb);
    new_scope->upper = ctx->cur_scope;
    ctx->cur_scope = new_scope;
    list_add_tail(&ctx->scopes, &new_scope->entry);
}

◆ read_dword()

static void read_dword	(	const char **	ptr,
		DWORD *	d
	)

inlinestatic

Definition at line 1212 of file d3dcompiler_private.h.

{
    memcpy(d, *ptr, sizeof(*d));
    *ptr += sizeof(*d);
}

Referenced by d3dcompiler_parse_rdef(), d3dcompiler_parse_shdr(), d3dcompiler_parse_signature(), d3dcompiler_parse_stat(), d3dcompiler_parse_type(), d3dcompiler_parse_type_members(), d3dcompiler_parse_variables(), dxbc_parse(), and skip_dword_unknown().

◆ record_declaration()

BOOL record_declaration	(	struct bwriter_shader *	shader,
		DWORD	usage,
		DWORD	usage_idx,
		DWORD	mod,
		BOOL	output,
		DWORD	regnum,
		DWORD	writemask,
		BOOL	builtin
	)

Definition at line 211 of file bytecodewriter.c.

                                                                     {
    unsigned int *num;
    struct declaration **decl;
    unsigned int i;
 
    if(!shader) return FALSE;
 
    if(output) {
        num = &shader->num_outputs;
        decl = &shader->outputs;
    } else {
        num = &shader->num_inputs;
        decl = &shader->inputs;
    }
 
    if(*num == 0) {
        *decl = d3dcompiler_alloc(sizeof(**decl));
        if(!*decl) {
            ERR("Error allocating declarations array\n");
            return FALSE;
        }
    } else {
        struct declaration *newdecl;
        for(i = 0; i < *num; i++) {
            if((*decl)[i].regnum == regnum && ((*decl)[i].writemask & writemask)) {
                WARN("Declaration of register %u already exists, writemask match 0x%x\n",
                      regnum, (*decl)[i].writemask & writemask);
            }
        }
 
        newdecl = d3dcompiler_realloc(*decl,
                              sizeof(**decl) * ((*num) + 1));
        if(!newdecl) {
            ERR("Error reallocating declarations array\n");
            return FALSE;
        }
        *decl = newdecl;
    }
    (*decl)[*num].usage = usage;
    (*decl)[*num].usage_idx = usage_idx;
    (*decl)[*num].regnum = regnum;
    (*decl)[*num].mod = mod;
    (*decl)[*num].writemask = writemask;
    (*decl)[*num].builtin = builtin;
    (*num)++;
 
    return TRUE;
}

Referenced by asmparser_dcl_input(), asmparser_dcl_input_ps_2(), asmparser_dcl_output(), gen_oldps_input(), and gen_oldvs_output().

◆ record_sampler()

BOOL record_sampler	(	struct bwriter_shader *	shader,
		DWORD	samptype,
		DWORD	mod,
		DWORD	regnum
	)

Definition at line 262 of file bytecodewriter.c.

                                                                                            {
    unsigned int i;
 
    if(!shader) return FALSE;
 
    if(shader->num_samplers == 0) {
        shader->samplers = d3dcompiler_alloc(sizeof(*shader->samplers));
        if(!shader->samplers) {
            ERR("Error allocating samplers array\n");
            return FALSE;
        }
    } else {
        struct samplerdecl *newarray;
 
        for(i = 0; i < shader->num_samplers; i++) {
            if(shader->samplers[i].regnum == regnum) {
                WARN("Sampler %u already declared\n", regnum);
                /* This is not an error as far as the assembler is concerned.
                 * Direct3D might refuse to load the compiled shader though
                 */
            }
        }
 
        newarray = d3dcompiler_realloc(shader->samplers,
                               sizeof(*shader->samplers) * (shader->num_samplers + 1));
        if(!newarray) {
            ERR("Error reallocating samplers array\n");
            return FALSE;
        }
        shader->samplers = newarray;
    }
 
    shader->samplers[shader->num_samplers].type = samptype;
    shader->samplers[shader->num_samplers].mod = mod;
    shader->samplers[shader->num_samplers].regnum = regnum;
    shader->num_samplers++;
    return TRUE;
}

Referenced by asmparser_dcl_sampler().

◆ set_parse_status()

static void set_parse_status	(	enum parse_status *	current,
		enum parse_status	update
	)

inlinestatic

Definition at line 290 of file d3dcompiler_private.h.

{
    if (update == PARSE_ERR)
        *current = PARSE_ERR;
    else if (update == PARSE_WARN && *current == PARSE_SUCCESS)
        *current = PARSE_WARN;
}

◆ skip_dword_unknown()

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

Definition at line 510 of file utils.c.

{
    unsigned int i;
    DWORD d;
 
    FIXME("Skipping %u unknown DWORDs:\n", count);
    for (i = 0; i < count; ++i)
    {
        read_dword(ptr, &d);
        FIXME("\t0x%08x\n", d);
    }
}

Referenced by d3dcompiler_parse_rdef(), d3dcompiler_parse_signature(), d3dcompiler_parse_stat(), d3dcompiler_parse_type(), d3dcompiler_parse_variables(), and dxbc_parse().

◆ SlAssembleShader()

struct bwriter_shader * SlAssembleShader	(	const char *	text,
		char **	messages
	)

Referenced by assemble_shader().

◆ SlDeleteShader()

void SlDeleteShader ( struct bwriter_shader * shader )

Definition at line 2543 of file bytecodewriter.c.

                                                   {
    unsigned int i, j;
 
    TRACE("Deleting shader %p\n", shader);
 
    for(i = 0; i < shader->num_cf; i++) {
        d3dcompiler_free(shader->constF[i]);
    }
    d3dcompiler_free(shader->constF);
    for(i = 0; i < shader->num_ci; i++) {
        d3dcompiler_free(shader->constI[i]);
    }
    d3dcompiler_free(shader->constI);
    for(i = 0; i < shader->num_cb; i++) {
        d3dcompiler_free(shader->constB[i]);
    }
    d3dcompiler_free(shader->constB);
 
    d3dcompiler_free(shader->inputs);
    d3dcompiler_free(shader->outputs);
    d3dcompiler_free(shader->samplers);
 
    for(i = 0; i < shader->num_instrs; i++) {
        for(j = 0; j < shader->instr[i]->num_srcs; j++) {
            d3dcompiler_free(shader->instr[i]->src[j].rel_reg);
        }
        d3dcompiler_free(shader->instr[i]->src);
        d3dcompiler_free(shader->instr[i]->dst.rel_reg);
        d3dcompiler_free(shader->instr[i]);
    }
    d3dcompiler_free(shader->instr);
 
    d3dcompiler_free(shader);
}

Referenced by assemble_shader(), and compile_shader().

◆ SlWriteBytecode()

HRESULT SlWriteBytecode	(	const struct bwriter_shader *	shader,
		int	dxversion,
		DWORD **	result,
		DWORD *	size
	)

Definition at line 2473 of file bytecodewriter.c.

{
    struct bc_writer *writer;
    struct bytecode_buffer *buffer = NULL;
    HRESULT hr;
    unsigned int i;
 
    if(!shader){
        ERR("NULL shader structure, aborting\n");
        return E_FAIL;
    }
    writer = create_writer(shader->version, dxversion);
    *result = NULL;
 
    if(!writer) {
        WARN("Could not create a bytecode writer instance. Either unsupported version\n");
        WARN("or out of memory\n");
        hr = E_FAIL;
        goto error;
    }
 
    buffer = allocate_buffer();
    if(!buffer) {
        WARN("Failed to allocate a buffer for the shader bytecode\n");
        hr = E_FAIL;
        goto error;
    }
 
    /* Write shader type and version */
    put_dword(buffer, shader->version);
 
    writer->funcs->header(writer, shader, buffer);
    if(FAILED(writer->state)) {
        hr = writer->state;
        goto error;
    }
 
    for(i = 0; i < shader->num_instrs; i++) {
        hr = call_instr_handler(writer, shader->instr[i], buffer);
        if(FAILED(hr)) {
            goto error;
        }
    }
 
    if(FAILED(writer->state)) {
        hr = writer->state;
        goto error;
    }
 
    writer->funcs->end(writer, shader, buffer);
 
    if(FAILED(buffer->state)) {
        hr = buffer->state;
        goto error;
    }
 
    *size = buffer->size * sizeof(DWORD);
    *result = buffer->data;
    buffer->data = NULL;
    hr = S_OK;
 
error:
    if(buffer) {
        d3dcompiler_free(buffer->data);
        d3dcompiler_free(buffer);
    }
    d3dcompiler_free(writer);
    return hr;
}

Referenced by assemble_shader(), and compile_shader().

◆ swizzle_from_node()

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

inlinestatic

Definition at line 1099 of file d3dcompiler_private.h.

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

Referenced by debug_dump_instr(), and free_instr().

◆ write_dword()

static void write_dword	(	char **	ptr,
		DWORD	d
	)

inlinestatic

Definition at line 1218 of file d3dcompiler_private.h.

{
    memcpy(*ptr, &d, sizeof(d));
    *ptr += sizeof(d);
}

Referenced by dxbc_write_blob(), and write_dword_unknown().

Variable Documentation

◆ DECLSPEC_HIDDEN

void WINAPIV DECLSPEC_HIDDEN

Definition at line 289 of file d3dcompiler_private.h.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BWRITER_SM1_PS

◆ BWRITER_SM1_VS

◆ BWRITERPS_VERSION

◆ BWRITERSI_TEXLD_BIAS

◆ BWRITERSI_TEXLD_PROJECT

◆ BWRITERSP_WRITEMASK_0

◆ BWRITERSP_WRITEMASK_1

◆ BWRITERSP_WRITEMASK_2

◆ BWRITERSP_WRITEMASK_3

◆ BWRITERSP_WRITEMASK_ALL

◆ BWRITERVS_NOSWIZZLE

◆ BWRITERVS_SWIZZLE_MASK

◆ BWRITERVS_SWIZZLE_SHIFT

◆ BWRITERVS_SWIZZLE_W

◆ BWRITERVS_SWIZZLE_X

◆ BWRITERVS_SWIZZLE_Y

◆ BWRITERVS_SWIZZLE_Z

◆ BWRITERVS_VERSION

◆ BWRITERVS_W_W

◆ BWRITERVS_W_X

◆ BWRITERVS_W_Y

◆ BWRITERVS_W_Z

◆ BWRITERVS_X_W

◆ BWRITERVS_X_X

◆ BWRITERVS_X_Y

◆ BWRITERVS_X_Z

◆ BWRITERVS_Y_W

◆ BWRITERVS_Y_X

◆ BWRITERVS_Y_Y

◆ BWRITERVS_Y_Z

◆ BWRITERVS_Z_W

◆ BWRITERVS_Z_X

◆ BWRITERVS_Z_Y

◆ BWRITERVS_Z_Z

◆ BYTECODEBUFFER_INITIAL_SIZE

◆ COBJMACROS

◆ D3DERR_INVALIDCALL

◆ HLSL_MODIFIER_COLUMN_MAJOR

◆ HLSL_MODIFIER_CONST

◆ HLSL_MODIFIER_IN

◆ HLSL_MODIFIER_OUT

◆ HLSL_MODIFIER_PRECISE

◆ HLSL_MODIFIER_ROW_MAJOR

◆ HLSL_MODIFIERS_COMPARISON_MASK

◆ HLSL_STORAGE_EXTERN

◆ HLSL_STORAGE_GROUPSHARED

◆ HLSL_STORAGE_NOINTERPOLATION

◆ HLSL_STORAGE_SHARED

◆ HLSL_STORAGE_STATIC

◆ HLSL_STORAGE_UNIFORM

◆ HLSL_STORAGE_VOLATILE

◆ HLSL_TYPE_MODIFIERS_MASK

◆ INSTRARRAY_INITIAL_SIZE

◆ MAKE_TAG

◆ MAX_SRC_REGS

◆ MESSAGEBUFFER_INITIAL_SIZE

◆ PRINTF_ATTR

◆ SWIZZLE_ERR

◆ T0_REG

◆ T1_REG

◆ T2_REG

◆ T3_REG

◆ TAG_Aon9

◆ TAG_DXBC

◆ TAG_ISGN

◆ TAG_OSG5

◆ TAG_OSGN

◆ TAG_PCSG

◆ TAG_RDEF

◆ TAG_SDBG

◆ TAG_SHDR

◆ TAG_SHEX

◆ TAG_STAT