#include "wine/debug.h"
#include "d3dcompiler_private.h"

Include dependency graph for asmparser.c:

Classes
struct	allowed_reg_type

Macros
#define	OT0_REG 0

#define	OT1_REG 1

#define	OT2_REG 2

#define	OT3_REG 3

#define	OT4_REG 4

#define	OT5_REG 5

#define	OT6_REG 6

#define	OT7_REG 7

#define	OPOS_REG 8

#define	OFOG_REG 9

#define	OFOG_WRITEMASK BWRITERSP_WRITEMASK_0

#define	OPTS_REG 9

#define	OPTS_WRITEMASK BWRITERSP_WRITEMASK_1

#define	OD0_REG 10

#define	OD1_REG 11

#define	C0_VARYING 0

#define	C1_VARYING 1

#define	T0_VARYING 2

#define	T1_VARYING 3

#define	T2_VARYING 4

#define	T3_VARYING 5

#define	T4_VARYING 6

#define	T5_VARYING 7

#define	T6_VARYING 8

#define	T7_VARYING 9

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (asmshader)

	WINE_DECLARE_DEBUG_CHANNEL (parsed_shader)

static void	asmparser_end (struct asm_parser *This)

static void	asmparser_constF (struct asm_parser *This, DWORD reg, float x, float y, float z, float w)

static void	asmparser_constB (struct asm_parser *This, DWORD reg, BOOL x)

static void	asmparser_constI (struct asm_parser *This, DWORD reg, INT x, INT y, INT z, INT w)

static void	asmparser_dcl_output (struct asm_parser This, DWORD usage, DWORD num, const struct shader_reg reg)

static void	asmparser_dcl_output_unsupported (struct asm_parser This, DWORD usage, DWORD num, const struct shader_reg reg)

static void	asmparser_dcl_input (struct asm_parser This, DWORD usage, DWORD num, DWORD mod, const struct shader_reg reg)

static void	asmparser_dcl_input_ps_2 (struct asm_parser This, DWORD usage, DWORD num, DWORD mod, const struct shader_reg reg)

static void	asmparser_dcl_input_unsupported (struct asm_parser This, DWORD usage, DWORD num, DWORD mod, const struct shader_reg reg)

static void	asmparser_dcl_sampler (struct asm_parser *This, DWORD samptype, DWORD mod, DWORD regnum, unsigned int line_no)

static void	asmparser_dcl_sampler_unsupported (struct asm_parser *This, DWORD samptype, DWORD mod, DWORD regnum, unsigned int line_no)

static void	asmparser_sincos (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct src_regs *srcs)

static struct shader_reg	map_oldps_register (const struct shader_reg *reg, BOOL tex_varying)

static void	asmparser_texcoord (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct src_regs *srcs)

static void	asmparser_texcrd (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct src_regs *srcs)

static void	asmparser_texkill (struct asm_parser This, const struct shader_reg dst)

static void	asmparser_texhelper (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct shader_reg *src0)

static void	asmparser_tex (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst)

static void	asmparser_texld14 (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct src_regs *srcs)

static void	asmparser_texreg2ar (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct shader_reg *src0)

static void	asmparser_texreg2gb (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct shader_reg *src0)

static void	asmparser_texreg2rgb (struct asm_parser This, DWORD mod, DWORD shift, const struct shader_reg dst, const struct shader_reg *src0)

static void	asmparser_instr (struct asm_parser This, DWORD opcode, DWORD mod, DWORD shift, enum bwriter_comparison_type comp, const struct shader_reg dst, const struct src_regs *srcs, int expectednsrcs)

static struct shader_reg	map_oldvs_register (const struct shader_reg *reg)

static void	check_legacy_srcmod (struct asm_parser *This, DWORD srcmod)

static void	check_abs_srcmod (struct asm_parser *This, DWORD srcmod)

static void	check_loop_swizzle (struct asm_parser This, const struct shader_reg src)

static void	check_shift_dstmod (struct asm_parser *This, DWORD shift)

static void	check_ps_dstmod (struct asm_parser *This, DWORD dstmod)

static BOOL	check_reg_type (const struct shader_reg reg, const struct allowed_reg_type allowed)

static void	asmparser_srcreg_vs_1 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_vs_2 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_vs_3 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_ps_1_0123 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_ps_1_4 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_ps_2 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_ps_2_x (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_srcreg_ps_3 (struct asm_parser This, struct instruction instr, int num, const struct shader_reg *src)

static void	asmparser_dstreg_vs_1 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_vs_2 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_vs_3 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_ps_1_0123 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_ps_1_4 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_ps_2 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_ps_2_x (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_dstreg_ps_3 (struct asm_parser This, struct instruction instr, const struct shader_reg *dst)

static void	asmparser_predicate_supported (struct asm_parser This, const struct shader_reg predicate)

static void	asmparser_predicate_unsupported (struct asm_parser This, const struct shader_reg predicate)

static void	asmparser_coissue_supported (struct asm_parser *This)

static void	asmparser_coissue_unsupported (struct asm_parser *This)

static void	gen_oldvs_output (struct bwriter_shader *shader)

static void	gen_oldps_input (struct bwriter_shader *shader, DWORD texcoords)

void	create_vs10_parser (struct asm_parser *ret)

void	create_vs11_parser (struct asm_parser *ret)

void	create_vs20_parser (struct asm_parser *ret)

void	create_vs2x_parser (struct asm_parser *ret)

void	create_vs30_parser (struct asm_parser *ret)

void	create_ps10_parser (struct asm_parser *ret)

void	create_ps11_parser (struct asm_parser *ret)

void	create_ps12_parser (struct asm_parser *ret)

void	create_ps13_parser (struct asm_parser *ret)

void	create_ps14_parser (struct asm_parser *ret)

void	create_ps20_parser (struct asm_parser *ret)

void	create_ps2x_parser (struct asm_parser *ret)

void	create_ps30_parser (struct asm_parser *ret)

Variables
static const struct allowed_reg_type	vs_1_reg_allowed []

static const struct allowed_reg_type	vs_2_reg_allowed []

static const struct allowed_reg_type	vs_3_reg_allowed []

static const struct allowed_reg_type	ps_1_0123_reg_allowed []

static const struct allowed_reg_type	ps_1_4_reg_allowed []

static const struct allowed_reg_type	ps_2_0_reg_allowed []

static const struct allowed_reg_type	ps_2_x_reg_allowed []

static const struct allowed_reg_type	ps_3_reg_allowed []

static const struct asmparser_backend	parser_vs_1

static const struct asmparser_backend	parser_vs_2

static const struct asmparser_backend	parser_vs_3

static const struct asmparser_backend	parser_ps_1_0123

static const struct asmparser_backend	parser_ps_1_4

static const struct asmparser_backend	parser_ps_2

static const struct asmparser_backend	parser_ps_2_x

static const struct asmparser_backend	parser_ps_3

Macro Definition Documentation

◆ C0_VARYING

#define C0_VARYING 0

Definition at line 55 of file asmparser.c.

◆ C1_VARYING

#define C1_VARYING 1

Definition at line 56 of file asmparser.c.

◆ OD0_REG

#define OD0_REG 10

Definition at line 51 of file asmparser.c.

◆ OD1_REG

#define OD1_REG 11

Definition at line 52 of file asmparser.c.

◆ OFOG_REG

#define OFOG_REG 9

Definition at line 47 of file asmparser.c.

◆ OFOG_WRITEMASK

#define OFOG_WRITEMASK BWRITERSP_WRITEMASK_0

Definition at line 48 of file asmparser.c.

◆ OPOS_REG

#define OPOS_REG 8

Definition at line 46 of file asmparser.c.

◆ OPTS_REG

#define OPTS_REG 9

Definition at line 49 of file asmparser.c.

◆ OPTS_WRITEMASK

#define OPTS_WRITEMASK BWRITERSP_WRITEMASK_1

Definition at line 50 of file asmparser.c.

◆ OT0_REG

#define OT0_REG 0

Definition at line 38 of file asmparser.c.

◆ OT1_REG

#define OT1_REG 1

Definition at line 39 of file asmparser.c.

◆ OT2_REG

#define OT2_REG 2

Definition at line 40 of file asmparser.c.

◆ OT3_REG

#define OT3_REG 3

Definition at line 41 of file asmparser.c.

◆ OT4_REG

#define OT4_REG 4

Definition at line 42 of file asmparser.c.

◆ OT5_REG

#define OT5_REG 5

Definition at line 43 of file asmparser.c.

◆ OT6_REG

#define OT6_REG 6

Definition at line 44 of file asmparser.c.

◆ OT7_REG

#define OT7_REG 7

Definition at line 45 of file asmparser.c.

◆ T0_VARYING

#define T0_VARYING 2

Definition at line 57 of file asmparser.c.

◆ T1_VARYING

#define T1_VARYING 3

Definition at line 58 of file asmparser.c.

◆ T2_VARYING

#define T2_VARYING 4

Definition at line 59 of file asmparser.c.

◆ T3_VARYING

#define T3_VARYING 5

Definition at line 60 of file asmparser.c.

◆ T4_VARYING

#define T4_VARYING 6

Definition at line 61 of file asmparser.c.

◆ T5_VARYING

#define T5_VARYING 7

Definition at line 62 of file asmparser.c.

◆ T6_VARYING

#define T6_VARYING 8

Definition at line 63 of file asmparser.c.

◆ T7_VARYING

#define T7_VARYING 9

Definition at line 64 of file asmparser.c.

Function Documentation

◆ asmparser_coissue_supported()

static void asmparser_coissue_supported ( struct asm_parser * This )

static

Definition at line 1134 of file asmparser.c.

                                                                  {
     /* this sets the coissue flag of the last instruction added to the shader */
     if(!This->shader) return;
     if(This->shader->num_instrs == 0){
         asmparser_message(This, "Line %u: Coissue flag on the first shader instruction\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
     }
     This->shader->instr[This->shader->num_instrs-1]->coissue = TRUE;
 }

◆ asmparser_coissue_unsupported()

static void asmparser_coissue_unsupported ( struct asm_parser * This )

static

Definition at line 1144 of file asmparser.c.

                                                                    {
     asmparser_message(This, "Line %u: Coissue is only supported in pixel shaders versions <= 1.4\n", This->line_no);
     set_parse_status(&This->status, PARSE_ERR);
 }

◆ asmparser_constB()

static void asmparser_constB	(	struct asm_parser *	This,
		DWORD	reg,
		BOOL	x
	)

static

Definition at line 84 of file asmparser.c.

                                                                          {
     if(!This->shader) return;
     TRACE("Adding boolean constant %u at pos %u\n", reg, This->shader->num_cb);
     TRACE_(parsed_shader)("def b%u, %s\n", reg, x ? "true" : "false");
     if(!add_constB(This->shader, reg, x)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_constF()

static void asmparser_constF	(	struct asm_parser *	This,
		DWORD	reg,
		float	x,
		float	y,
		float	z,
		float	w
	)

static

Definition at line 74 of file asmparser.c.

                                                                                                      {
     if(!This->shader) return;
     TRACE("Adding float constant %u at pos %u\n", reg, This->shader->num_cf);
     TRACE_(parsed_shader)("def c%u, %f, %f, %f, %f\n", reg, x, y, z, w);
     if(!add_constF(This->shader, reg, x, y, z, w)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_constI()

static void asmparser_constI	(	struct asm_parser *	This,
		DWORD	reg,
		INT	x,
		INT	y,
		INT	z,
		INT	w
	)

static

Definition at line 94 of file asmparser.c.

                                                                                              {
     if(!This->shader) return;
     TRACE("Adding integer constant %u at pos %u\n", reg, This->shader->num_ci);
     TRACE_(parsed_shader)("def i%u, %d, %d, %d, %d\n", reg, x, y, z, w);
     if(!add_constI(This->shader, reg, x, y, z, w)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_dcl_input()

static void asmparser_dcl_input	(	struct asm_parser *	This,
		DWORD	usage,
		DWORD	num,
		DWORD	mod,
		const struct shader_reg *	reg
	)

static

Definition at line 123 of file asmparser.c.

                                                                          {
     struct instruction instr;
 
     if(!This->shader) return;
     if(mod != 0 &&
        (This->shader->version != BWRITERPS_VERSION(3, 0) ||
         (mod != BWRITERSPDM_MSAMPCENTROID &&
          mod != BWRITERSPDM_PARTIALPRECISION))) {
         asmparser_message(This, "Line %u: Unsupported modifier in dcl instruction\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     /* Check register type and modifiers */
     instr.dstmod = mod;
     instr.shift = 0;
     This->funcs->dstreg(This, &instr, reg);
 
     if(!record_declaration(This->shader, usage, num, mod, FALSE, reg->regnum, reg->u.writemask, FALSE)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_dcl_input_ps_2()

static void asmparser_dcl_input_ps_2	(	struct asm_parser *	This,
		DWORD	usage,
		DWORD	num,
		DWORD	mod,
		const struct shader_reg *	reg
	)

static

Definition at line 148 of file asmparser.c.

                                                                               {
     struct instruction instr;
 
     if(!This->shader) return;
     instr.dstmod = mod;
     instr.shift = 0;
     This->funcs->dstreg(This, &instr, reg);
     if(!record_declaration(This->shader, usage, num, mod, FALSE, instr.dst.regnum, instr.dst.u.writemask, FALSE)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_dcl_input_unsupported()

static void asmparser_dcl_input_unsupported	(	struct asm_parser *	This,
		DWORD	usage,
		DWORD	num,
		DWORD	mod,
		const struct shader_reg *	reg
	)

static

Definition at line 162 of file asmparser.c.

 {
     asmparser_message(This, "Line %u: Input declaration unsupported in this shader version\n", This->line_no);
     set_parse_status(&This->status, PARSE_ERR);
 }

◆ asmparser_dcl_output()

static void asmparser_dcl_output	(	struct asm_parser *	This,
		DWORD	usage,
		DWORD	num,
		const struct shader_reg *	reg
	)

static

Definition at line 104 of file asmparser.c.

                                                                {
     if(!This->shader) return;
     if(This->shader->type == ST_PIXEL) {
         asmparser_message(This, "Line %u: Output register declared in a pixel shader\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
     }
     if(!record_declaration(This->shader, usage, num, 0, TRUE, reg->regnum, reg->u.writemask, FALSE)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_dcl_output_unsupported()

static void asmparser_dcl_output_unsupported	(	struct asm_parser *	This,
		DWORD	usage,
		DWORD	num,
		const struct shader_reg *	reg
	)

static

Definition at line 117 of file asmparser.c.

                                                                            {
     asmparser_message(This, "Line %u: Output declaration unsupported in this shader version\n", This->line_no);
     set_parse_status(&This->status, PARSE_ERR);
 }

◆ asmparser_dcl_sampler()

static void asmparser_dcl_sampler	(	struct asm_parser *	This,
		DWORD	samptype,
		DWORD	mod,
		DWORD	regnum,
		unsigned int	line_no
	)

static

Definition at line 169 of file asmparser.c.

                                                         {
     if(!This->shader) return;
     if(mod != 0 &&
        (This->shader->version != BWRITERPS_VERSION(3, 0) ||
         (mod != BWRITERSPDM_MSAMPCENTROID &&
          mod != BWRITERSPDM_PARTIALPRECISION))) {
         asmparser_message(This, "Line %u: Unsupported modifier in dcl instruction\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
     if(!record_sampler(This->shader, samptype, mod, regnum)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_dcl_sampler_unsupported()

static void asmparser_dcl_sampler_unsupported	(	struct asm_parser *	This,
		DWORD	samptype,
		DWORD	mod,
		DWORD	regnum,
		unsigned int	line_no
	)

static

Definition at line 187 of file asmparser.c.

 {
     asmparser_message(This, "Line %u: Sampler declaration unsupported in this shader version\n", This->line_no);
     set_parse_status(&This->status, PARSE_ERR);
 }

◆ asmparser_dstreg_ps_1_0123()

static void asmparser_dstreg_ps_1_0123	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1039 of file asmparser.c.

                                                                      {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, ps_1_0123_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in PS 1\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     reg = map_oldps_register(dst, FALSE);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_ps_1_4()

static void asmparser_dstreg_ps_1_4	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1055 of file asmparser.c.

                                                                   {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, ps_1_4_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in PS 1\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     reg = map_oldps_register(dst, TRUE);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_ps_2()

static void asmparser_dstreg_ps_2	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1071 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, ps_2_0_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in PS 2.0\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_shift_dstmod(This, instr->shift);
     reg = map_oldps_register(dst, TRUE);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_ps_2_x()

static void asmparser_dstreg_ps_2_x	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1088 of file asmparser.c.

                                                                   {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, ps_2_x_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in PS 2.x\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_shift_dstmod(This, instr->shift);
     reg = map_oldps_register(dst, TRUE);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_ps_3()

static void asmparser_dstreg_ps_3	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1105 of file asmparser.c.

                                                                 {
     if(!check_reg_type(dst, ps_3_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in PS 3.0\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_shift_dstmod(This, instr->shift);
     instr->dst = *dst;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_vs_1()

static void asmparser_dstreg_vs_1	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 988 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, vs_1_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in VS 1\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_ps_dstmod(This, instr->dstmod);
     check_shift_dstmod(This, instr->shift);
     reg = map_oldvs_register(dst);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_vs_2()

static void asmparser_dstreg_vs_2	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1006 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(dst, vs_2_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in VS 2.0\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_ps_dstmod(This, instr->dstmod);
     check_shift_dstmod(This, instr->shift);
     reg = map_oldvs_register(dst);
     instr->dst = reg;
     instr->has_dst = TRUE;
 }

◆ asmparser_dstreg_vs_3()

static void asmparser_dstreg_vs_3	(	struct asm_parser *	This,
		struct instruction *	instr,
		const struct shader_reg *	dst
	)

static

Definition at line 1024 of file asmparser.c.

                                                                 {
     if(!check_reg_type(dst, vs_3_reg_allowed)) {
         asmparser_message(This, "Line %u: Destination register %s not supported in VS 3.0\n",
                           This->line_no,
                           debug_print_dstreg(dst));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_ps_dstmod(This, instr->dstmod);
     check_shift_dstmod(This, instr->shift);
     instr->dst = *dst;
     instr->has_dst = TRUE;
 }

◆ asmparser_end()

static void asmparser_end ( struct asm_parser * This )

static

Definition at line 70 of file asmparser.c.

                                                    {
     TRACE("Finalizing shader\n");
 }

◆ asmparser_instr()

static void asmparser_instr	(	struct asm_parser *	This,
		DWORD	opcode,
		DWORD	mod,
		DWORD	shift,
		enum bwriter_comparison_type	comp,
		const struct shader_reg *	dst,
		const struct src_regs *	srcs,
		int	expectednsrcs
	)

static

Definition at line 502 of file asmparser.c.

 {
     struct instruction *instr;
     unsigned int i;
     BOOL firstreg = TRUE;
     unsigned int src_count = srcs ? srcs->count : 0;
 
     if(!This->shader) return;
 
     TRACE_(parsed_shader)("%s%s%s%s ", debug_print_opcode(opcode),
                           debug_print_dstmod(mod),
                           debug_print_shift(shift),
                           debug_print_comp(comp));
     if(dst) {
         TRACE_(parsed_shader)("%s", debug_print_dstreg(dst));
         firstreg = FALSE;
     }
     for(i = 0; i < src_count; i++) {
         if(!firstreg) TRACE_(parsed_shader)(", ");
         else firstreg = FALSE;
         TRACE_(parsed_shader)("%s", debug_print_srcreg(&srcs->reg[i]));
     }
     TRACE_(parsed_shader)("\n");
 
  /* Check for instructions with different syntaxes in different shader versions */
     switch(opcode) {
         case BWRITERSIO_SINCOS:
             /* The syntax changes between vs 2 and the other shader versions */
             if(This->shader->version == BWRITERVS_VERSION(2, 0) ||
                This->shader->version == BWRITERVS_VERSION(2, 1)) {
                 asmparser_sincos(This, mod, shift, dst, srcs);
                 return;
             }
             /* Use the default handling */
             break;
         case BWRITERSIO_TEXCOORD:
             /* texcoord/texcrd are two instructions present only in PS <= 1.3 and PS 1.4 respectively */
             if(This->shader->version == BWRITERPS_VERSION(1, 4))
                 asmparser_texcrd(This, mod, shift, dst, srcs);
             else asmparser_texcoord(This, mod, shift, dst, srcs);
             return;
         case BWRITERSIO_TEX:
             /* this encodes both the tex PS 1.x instruction and the
                texld 1.4/2.0+ instruction */
             if(This->shader->version == BWRITERPS_VERSION(1, 0) ||
                This->shader->version == BWRITERPS_VERSION(1, 1) ||
                This->shader->version == BWRITERPS_VERSION(1, 2) ||
                This->shader->version == BWRITERPS_VERSION(1, 3)) {
                 asmparser_tex(This, mod, shift, dst);
                 return;
             }
             else if(This->shader->version == BWRITERPS_VERSION(1, 4)) {
                 asmparser_texld14(This, mod, shift, dst, srcs);
                 return;
             }
             /* else fallback to the standard behavior */
             break;
     }
 
     if(src_count != expectednsrcs) {
         asmparser_message(This, "Line %u: Wrong number of source registers\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     /* Handle PS 1.x instructions, "regularizing" them */
     switch(opcode) {
         case BWRITERSIO_TEXKILL:
             asmparser_texkill(This, dst);
             return;
         case BWRITERSIO_TEXREG2AR:
             asmparser_texreg2ar(This, mod, shift, dst, &srcs->reg[0]);
             return;
         case BWRITERSIO_TEXREG2GB:
             asmparser_texreg2gb(This, mod, shift, dst, &srcs->reg[0]);
             return;
         case BWRITERSIO_TEXREG2RGB:
             asmparser_texreg2rgb(This, mod, shift, dst, &srcs->reg[0]);
             return;
     }
 
     instr = alloc_instr(src_count);
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr->opcode = opcode;
     instr->dstmod = mod;
     instr->shift = shift;
     instr->comptype = comp;
     if(dst) This->funcs->dstreg(This, instr, dst);
     for(i = 0; i < src_count; i++) {
         This->funcs->srcreg(This, instr, i, &srcs->reg[i]);
     }
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

◆ asmparser_predicate_supported()

static void asmparser_predicate_supported	(	struct asm_parser *	This,
		const struct shader_reg *	predicate
	)

static

Definition at line 1119 of file asmparser.c.

                                                                               {
     /* this sets the predicate of the last instruction added to the shader */
     if(!This->shader) return;
     if(This->shader->num_instrs == 0) ERR("Predicate without an instruction\n");
     This->shader->instr[This->shader->num_instrs - 1]->has_predicate = TRUE;
     This->shader->instr[This->shader->num_instrs - 1]->predicate = *predicate;
 }

◆ asmparser_predicate_unsupported()

static void asmparser_predicate_unsupported	(	struct asm_parser *	This,
		const struct shader_reg *	predicate
	)

static

Definition at line 1128 of file asmparser.c.

                                                                                 {
     asmparser_message(This, "Line %u: Predicate not supported in < VS 2.0 or PS 2.x\n", This->line_no);
     set_parse_status(&This->status, PARSE_ERR);
 }

◆ asmparser_sincos()

static void asmparser_sincos	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct src_regs *	srcs
	)

static

Definition at line 194 of file asmparser.c.

                                                           {
     struct instruction *instr;
 
     if(!srcs || srcs->count != 3) {
         asmparser_message(This, "Line %u: sincos (vs 2) has an incorrect number of source registers\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr = alloc_instr(3);
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr->opcode = BWRITERSIO_SINCOS;
     instr->dstmod = mod;
     instr->shift = shift;
     instr->comptype = 0;
 
     This->funcs->dstreg(This, instr, dst);
     This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
     This->funcs->srcreg(This, instr, 1, &srcs->reg[1]);
     This->funcs->srcreg(This, instr, 2, &srcs->reg[2]);
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_instr().

◆ asmparser_srcreg_ps_1_0123()

static void asmparser_srcreg_ps_1_0123	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 856 of file asmparser.c.

                                                                      {
     struct shader_reg reg;
 
     if(!check_reg_type(src, ps_1_0123_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in <== PS 1.3\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldps_register(src, FALSE);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_ps_1_4()

static void asmparser_srcreg_ps_1_4	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 880 of file asmparser.c.

                                                                   {
     struct shader_reg reg;
 
     if(!check_reg_type(src, ps_1_4_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in PS 1.4\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldps_register(src, TRUE);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_ps_2()

static void asmparser_srcreg_ps_2	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 909 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(src, ps_2_0_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in PS 2.0\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_legacy_srcmod(This, src->srcmod);
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldps_register(src, TRUE);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_ps_2_x()

static void asmparser_srcreg_ps_2_x	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 941 of file asmparser.c.

                                                                   {
     struct shader_reg reg;
 
     if(!check_reg_type(src, ps_2_x_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in PS 2.x\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_legacy_srcmod(This, src->srcmod);
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldps_register(src, TRUE);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_ps_3()

static void asmparser_srcreg_ps_3	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 974 of file asmparser.c.

                                                                 {
     if(!check_reg_type(src, ps_3_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in PS 3.0\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_loop_swizzle(This, src);
     check_legacy_srcmod(This, src->srcmod);
     instr->src[num] = *src;
 }

◆ asmparser_srcreg_vs_1()

static void asmparser_srcreg_vs_1	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 768 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(src, vs_1_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in VS 1\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_legacy_srcmod(This, src->srcmod);
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldvs_register(src);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_vs_2()

static void asmparser_srcreg_vs_2	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 801 of file asmparser.c.

                                                                 {
     struct shader_reg reg;
 
     if(!check_reg_type(src, vs_2_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in VS 2\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_loop_swizzle(This, src);
     check_legacy_srcmod(This, src->srcmod);
     check_abs_srcmod(This, src->srcmod);
     reg = map_oldvs_register(src);
     instr->src[num] = reg;
 }

◆ asmparser_srcreg_vs_3()

static void asmparser_srcreg_vs_3	(	struct asm_parser *	This,
		struct instruction *	instr,
		int	num,
		const struct shader_reg *	src
	)

static

Definition at line 834 of file asmparser.c.

                                                                 {
     if(!check_reg_type(src, vs_3_reg_allowed)) {
         asmparser_message(This, "Line %u: Source register %s not supported in VS 3.0\n",
                           This->line_no,
                           debug_print_srcreg(src));
         set_parse_status(&This->status, PARSE_ERR);
     }
     check_loop_swizzle(This, src);
     check_legacy_srcmod(This, src->srcmod);
     instr->src[num] = *src;
 }

◆ asmparser_tex()

static void asmparser_tex	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst
	)

static

Definition at line 408 of file asmparser.c.

                                                         {
     struct shader_reg src;
 
     /* The first source register is the varying containing the coordinate */
     src = map_oldps_register(dst, TRUE);
     asmparser_texhelper(This, mod, shift, dst, &src);
 }

Referenced by asmparser_instr().

◆ asmparser_texcoord()

static void asmparser_texcoord	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct src_regs *	srcs
	)

static

Definition at line 271 of file asmparser.c.

                                                             {
     struct instruction *instr;
 
     if(srcs) {
         asmparser_message(This, "Line %u: Source registers in texcoord instruction\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr = alloc_instr(1);
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     /* texcoord copies the texture coord data into a temporary register-like
      * readable form. In newer shader models this equals a MOV from v0 to r0,
      * record it as this.
      */
     instr->opcode = BWRITERSIO_MOV;
     instr->dstmod = mod | BWRITERSPDM_SATURATE; /* texcoord clamps to [0;1] */
     instr->shift = shift;
     instr->comptype = 0;
 
     This->funcs->dstreg(This, instr, dst);
     /* The src reg needs special care */
     instr->src[0] = map_oldps_register(dst, TRUE);
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_instr().

◆ asmparser_texcrd()

static void asmparser_texcrd	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct src_regs *	srcs
	)

static

Definition at line 308 of file asmparser.c.

                                                           {
     struct instruction *instr;
 
     if(!srcs || srcs->count != 1) {
         asmparser_message(This, "Line %u: Wrong number of source registers in texcrd instruction\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr = alloc_instr(1);
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     /* The job of texcrd is done by mov in later shader versions */
     instr->opcode = BWRITERSIO_MOV;
     instr->dstmod = mod;
     instr->shift = shift;
     instr->comptype = 0;
 
     This->funcs->dstreg(This, instr, dst);
     This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_instr().

◆ asmparser_texhelper()

static void asmparser_texhelper	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct shader_reg *	src0
	)

static

Definition at line 372 of file asmparser.c.

                                                                {
     struct instruction *instr = alloc_instr(2);
 
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr->opcode = BWRITERSIO_TEX;
     instr->dstmod = mod;
     instr->shift = shift;
     instr->comptype = 0;
     /* The dest register can be mapped normally to a temporary register */
     This->funcs->dstreg(This, instr, dst);
     /* Use the src passed as parameter by the specific instruction handler */
     instr->src[0] = *src0;
 
     /* The 2nd source register is the sampler register with the
      * destination's regnum
      */
     ZeroMemory(&instr->src[1], sizeof(instr->src[1]));
     instr->src[1].type = BWRITERSPR_SAMPLER;
     instr->src[1].regnum = dst->regnum;
     instr->src[1].u.swizzle = BWRITERVS_NOSWIZZLE;
     instr->src[1].srcmod = BWRITERSPSM_NONE;
     instr->src[1].rel_reg = NULL;
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_tex(), asmparser_texreg2ar(), asmparser_texreg2gb(), and asmparser_texreg2rgb().

◆ asmparser_texkill()

static void asmparser_texkill	(	struct asm_parser *	This,
		const struct shader_reg *	dst
	)

static

Definition at line 341 of file asmparser.c.

                                                             {
     struct instruction *instr = alloc_instr(0);
 
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr->opcode = BWRITERSIO_TEXKILL;
     instr->dstmod = 0;
     instr->shift = 0;
     instr->comptype = 0;
 
     /* Do not run the dst register through the normal
      * register conversion. If used with ps_1_0 to ps_1_3
      * the texture coordinate from that register is used,
      * not the temporary register value. In ps_1_4 and
      * ps_2_0 t0 is always a varying and temporaries can
      * be used with texkill.
      */
     instr->dst = map_oldps_register(dst, TRUE);
     instr->has_dst = TRUE;
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_instr().

◆ asmparser_texld14()

static void asmparser_texld14	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct src_regs *	srcs
	)

static

Definition at line 417 of file asmparser.c.

                                                            {
     struct instruction *instr;
 
     if(!srcs || srcs->count != 1) {
         asmparser_message(This, "Line %u: texld (PS 1.4) has a wrong number of source registers\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     instr = alloc_instr(2);
     if(!instr) {
         ERR("Error allocating memory for the instruction\n");
         set_parse_status(&This->status, PARSE_ERR);
         return;
     }
 
     /* This code is recording a texld instruction, not tex. However,
      * texld borrows the opcode of tex
      */
     instr->opcode = BWRITERSIO_TEX;
     instr->dstmod = mod;
     instr->shift = shift;
     instr->comptype = 0;
 
     This->funcs->dstreg(This, instr, dst);
     This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
 
     /* The 2nd source register is the sampler register with the
      * destination's regnum
      */
     ZeroMemory(&instr->src[1], sizeof(instr->src[1]));
     instr->src[1].type = BWRITERSPR_SAMPLER;
     instr->src[1].regnum = dst->regnum;
     instr->src[1].u.swizzle = BWRITERVS_NOSWIZZLE;
     instr->src[1].srcmod = BWRITERSPSM_NONE;
     instr->src[1].rel_reg = NULL;
 
     if(!add_instruction(This->shader, instr)) {
         ERR("Out of memory\n");
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_instr().

◆ asmparser_texreg2ar()

static void asmparser_texreg2ar	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct shader_reg *	src0
	)

static

Definition at line 462 of file asmparser.c.

                                                                {
     struct shader_reg src;
 
     src = map_oldps_register(src0, FALSE);
     /* Supply the correct swizzle */
     src.u.swizzle = BWRITERVS_X_W | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X;
     asmparser_texhelper(This, mod, shift, dst, &src);
 }

Referenced by asmparser_instr().

◆ asmparser_texreg2gb()

static void asmparser_texreg2gb	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct shader_reg *	src0
	)

static

Definition at line 473 of file asmparser.c.

                                                                {
     struct shader_reg src;
 
     src = map_oldps_register(src0, FALSE);
     /* Supply the correct swizzle */
     src.u.swizzle = BWRITERVS_X_Y | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z;
     asmparser_texhelper(This, mod, shift, dst, &src);
 }

Referenced by asmparser_instr().

◆ asmparser_texreg2rgb()

static void asmparser_texreg2rgb	(	struct asm_parser *	This,
		DWORD	mod,
		DWORD	shift,
		const struct shader_reg *	dst,
		const struct shader_reg *	src0
	)

static

Definition at line 484 of file asmparser.c.

                                                                 {
     struct shader_reg src;
 
     src = map_oldps_register(src0, FALSE);
     /* Supply the correct swizzle */
     src.u.swizzle = BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_Z;
     asmparser_texhelper(This, mod, shift, dst, &src);
 }

Referenced by asmparser_instr().

◆ check_abs_srcmod()

static void check_abs_srcmod	(	struct asm_parser *	This,
		DWORD	srcmod
	)

static

Definition at line 680 of file asmparser.c.

                                                                     {
     if(srcmod == BWRITERSPSM_ABS || srcmod == BWRITERSPSM_ABSNEG) {
         asmparser_message(This, "Line %u: Source modifier %s not supported in this shader version\n",
                           This->line_no,
                           debug_print_srcmod(srcmod));
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

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

◆ check_legacy_srcmod()

static void check_legacy_srcmod	(	struct asm_parser *	This,
		DWORD	srcmod
	)

static

Definition at line 667 of file asmparser.c.

                                                                        {
     if(srcmod == BWRITERSPSM_BIAS || srcmod == BWRITERSPSM_BIASNEG ||
        srcmod == BWRITERSPSM_SIGN || srcmod == BWRITERSPSM_SIGNNEG ||
        srcmod == BWRITERSPSM_COMP || srcmod == BWRITERSPSM_X2 ||
        srcmod == BWRITERSPSM_X2NEG || srcmod == BWRITERSPSM_DZ ||
        srcmod == BWRITERSPSM_DW) {
         asmparser_message(This, "Line %u: Source modifier %s not supported in this shader version\n",
                           This->line_no,
                           debug_print_srcmod(srcmod));
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by 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().

◆ check_loop_swizzle()

static void check_loop_swizzle	(	struct asm_parser *	This,
		const struct shader_reg *	src
	)

static

Definition at line 689 of file asmparser.c.

                                                              {
     if((src->type == BWRITERSPR_LOOP && src->u.swizzle != BWRITERVS_NOSWIZZLE) ||
        (src->rel_reg && src->rel_reg->type == BWRITERSPR_LOOP &&
         src->rel_reg->u.swizzle != BWRITERVS_NOSWIZZLE)) {
         asmparser_message(This, "Line %u: Swizzle not allowed on aL register\n", This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_srcreg_ps_3(), asmparser_srcreg_vs_2(), and asmparser_srcreg_vs_3().

◆ check_ps_dstmod()

static void check_ps_dstmod	(	struct asm_parser *	This,
		DWORD	dstmod
	)

static

Definition at line 707 of file asmparser.c.

                                                                    {
     if(dstmod == BWRITERSPDM_PARTIALPRECISION ||
        dstmod == BWRITERSPDM_MSAMPCENTROID) {
         asmparser_message(This, "Line %u: Instruction modifier %s not supported in this shader version\n",
                           This->line_no,
                           debug_print_dstmod(dstmod));
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

Referenced by asmparser_dstreg_vs_1(), asmparser_dstreg_vs_2(), and asmparser_dstreg_vs_3().

◆ check_reg_type()

static BOOL check_reg_type	(	const struct shader_reg *	reg,
		const struct allowed_reg_type *	allowed
	)

static

Definition at line 723 of file asmparser.c.

                                                                    {
     unsigned int i = 0;
 
     while(allowed[i].type != ~0U) {
         if(reg->type == allowed[i].type) {
             if(reg->rel_reg) {
                 if(allowed[i].reladdr)
                     return TRUE; /* The relative addressing register
                                     can have a negative value, we
                                     can't check the register index */
                 return FALSE;
             }
             if(reg->regnum < allowed[i].count) return TRUE;
             return FALSE;
         }
         i++;
     }
     return FALSE;
 }

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(), 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().

◆ check_shift_dstmod()

static void check_shift_dstmod	(	struct asm_parser *	This,
		DWORD	shift
	)

static

Definition at line 699 of file asmparser.c.

                                                                      {
     if(shift != 0) {
         asmparser_message(This, "Line %u: Shift modifiers not supported in this shader version\n",
                           This->line_no);
         set_parse_status(&This->status, PARSE_ERR);
     }
 }

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

◆ 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;
 }

◆ gen_oldps_input()

static void gen_oldps_input	(	struct bwriter_shader *	shader,
		DWORD	texcoords
	)

static

Definition at line 1325 of file asmparser.c.

                                                                             {
     switch(texcoords) {
         case 8: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 7, 0, FALSE, T7_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 7: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 6, 0, FALSE, T6_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 6: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 5, 0, FALSE, T5_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 5: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 4, 0, FALSE, T4_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 4: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 3, 0, FALSE, T3_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 3: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 2, 0, FALSE, T2_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 2: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 1, 0, FALSE, T1_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
             /* fall through */
         case 1: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 0, 0, FALSE, T0_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
     };
     record_declaration(shader, BWRITERDECLUSAGE_COLOR, 0, 0, FALSE, C0_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_COLOR, 1, 0, FALSE, C1_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
 }

Referenced by create_ps10_parser(), create_ps11_parser(), create_ps12_parser(), create_ps13_parser(), create_ps14_parser(), create_ps20_parser(), and create_ps2x_parser().

◆ gen_oldvs_output()

static void gen_oldvs_output ( struct bwriter_shader * shader )

static

Definition at line 1309 of file asmparser.c.

                                                             {
     record_declaration(shader, BWRITERDECLUSAGE_POSITION, 0, 0, TRUE, OPOS_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 0, 0, TRUE, OT0_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 1, 0, TRUE, OT1_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 2, 0, TRUE, OT2_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 3, 0, TRUE, OT3_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 4, 0, TRUE, OT4_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 5, 0, TRUE, OT5_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 6, 0, TRUE, OT6_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 7, 0, TRUE, OT7_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_FOG, 0, 0, TRUE, OFOG_REG, OFOG_WRITEMASK, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_PSIZE, 0, 0, TRUE, OPTS_REG, OPTS_WRITEMASK, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_COLOR, 0, 0, TRUE, OD0_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
     record_declaration(shader, BWRITERDECLUSAGE_COLOR, 1, 0, TRUE, OD1_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
 }

Referenced by create_vs10_parser(), create_vs11_parser(), create_vs20_parser(), and create_vs2x_parser().

◆ map_oldps_register()

static struct shader_reg map_oldps_register	(	const struct shader_reg *	reg,
		BOOL	tex_varying
	)

static

Definition at line 228 of file asmparser.c.

                                                                                             {
     struct shader_reg ret;
     switch(reg->type) {
         case BWRITERSPR_TEXTURE:
             if(tex_varying) {
                 ret = *reg;
                 ret.type = BWRITERSPR_INPUT;
                 switch(reg->regnum) {
                     case 0:     ret.regnum = T0_VARYING; break;
                     case 1:     ret.regnum = T1_VARYING; break;
                     case 2:     ret.regnum = T2_VARYING; break;
                     case 3:     ret.regnum = T3_VARYING; break;
                     case 4:     ret.regnum = T4_VARYING; break;
                     case 5:     ret.regnum = T5_VARYING; break;
                     case 6:     ret.regnum = T6_VARYING; break;
                     case 7:     ret.regnum = T7_VARYING; break;
                     default:
                         FIXME("Unexpected TEXTURE register t%u\n", reg->regnum);
                         return *reg;
                 }
                 return ret;
             } else {
                 ret = *reg;
                 ret.type = BWRITERSPR_TEMP;
                 switch(reg->regnum) {
                     case 0:     ret.regnum = T0_REG; break;
                     case 1:     ret.regnum = T1_REG; break;
                     case 2:     ret.regnum = T2_REG; break;
                     case 3:     ret.regnum = T3_REG; break;
                     default:
                         FIXME("Unexpected TEXTURE register t%u\n", reg->regnum);
                         return *reg;
                 }
                 return ret;
             }
 
         /* case BWRITERSPR_INPUT - Identical mapping of 1.x/2.0 color varyings
            to 3.0 ones */
 
         default: return *reg;
     }
 }

Referenced by asmparser_dstreg_ps_1_0123(), asmparser_dstreg_ps_1_4(), asmparser_dstreg_ps_2(), asmparser_dstreg_ps_2_x(), asmparser_srcreg_ps_1_0123(), asmparser_srcreg_ps_1_4(), asmparser_srcreg_ps_2(), asmparser_srcreg_ps_2_x(), asmparser_tex(), asmparser_texcoord(), asmparser_texkill(), asmparser_texreg2ar(), asmparser_texreg2gb(), and asmparser_texreg2rgb().

◆ map_oldvs_register()

static struct shader_reg map_oldvs_register ( const struct shader_reg * reg )

static

Definition at line 607 of file asmparser.c.

                                                                           {
     struct shader_reg ret;
     switch(reg->type) {
         case BWRITERSPR_RASTOUT:
             ret = *reg;
             ret.type = BWRITERSPR_OUTPUT;
             switch(reg->regnum) {
                 case BWRITERSRO_POSITION:
                     ret.regnum = OPOS_REG;
                     break;
                 case BWRITERSRO_FOG:
                     ret.regnum = OFOG_REG;
                     ret.u.writemask = OFOG_WRITEMASK;
                     break;
                 case BWRITERSRO_POINT_SIZE:
                     ret.regnum = OPTS_REG;
                     ret.u.writemask = OPTS_WRITEMASK;
                     break;
                 default:
                     FIXME("Unhandled RASTOUT register %u\n", reg->regnum);
                     return *reg;
             }
             return ret;
 
         case BWRITERSPR_TEXCRDOUT:
             ret = *reg;
             ret.type = BWRITERSPR_OUTPUT;
             switch(reg->regnum) {
                 case 0: ret.regnum = OT0_REG; break;
                 case 1: ret.regnum = OT1_REG; break;
                 case 2: ret.regnum = OT2_REG; break;
                 case 3: ret.regnum = OT3_REG; break;
                 case 4: ret.regnum = OT4_REG; break;
                 case 5: ret.regnum = OT5_REG; break;
                 case 6: ret.regnum = OT6_REG; break;
                 case 7: ret.regnum = OT7_REG; break;
                 default:
                     FIXME("Unhandled TEXCRDOUT regnum %u\n", reg->regnum);
                     return *reg;
             }
             return ret;
 
         case BWRITERSPR_ATTROUT:
             ret = *reg;
             ret.type = BWRITERSPR_OUTPUT;
             switch(reg->regnum) {
                 case 0: ret.regnum = OD0_REG; break;
                 case 1: ret.regnum = OD1_REG; break;
                 default:
                     FIXME("Unhandled ATTROUT regnum %u\n", reg->regnum);
                     return *reg;
             }
             return ret;
 
         default: return *reg;
     }
 }

Referenced by asmparser_dstreg_vs_1(), asmparser_dstreg_vs_2(), asmparser_srcreg_vs_1(), and asmparser_srcreg_vs_2().

◆ WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL ( parsed_shader )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( asmshader )

Variable Documentation

◆ parser_ps_1_0123

const struct asmparser_backend parser_ps_1_0123

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_ps_1_0123,
    asmparser_srcreg_ps_1_0123,
    asmparser_predicate_unsupported,
    asmparser_coissue_supported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input_unsupported,
    asmparser_dcl_sampler_unsupported,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1209 of file asmparser.c.

Referenced by create_ps10_parser(), create_ps11_parser(), create_ps12_parser(), and create_ps13_parser().

◆ parser_ps_1_4

const struct asmparser_backend parser_ps_1_4

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_ps_1_4,
    asmparser_srcreg_ps_1_4,
    asmparser_predicate_unsupported,
    asmparser_coissue_supported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input_unsupported,
    asmparser_dcl_sampler_unsupported,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1229 of file asmparser.c.

Referenced by create_ps14_parser().

◆ parser_ps_2

const struct asmparser_backend parser_ps_2

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_ps_2,
    asmparser_srcreg_ps_2,
    asmparser_predicate_unsupported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input_ps_2,
    asmparser_dcl_sampler,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1249 of file asmparser.c.

Referenced by create_ps20_parser().

◆ parser_ps_2_x

const struct asmparser_backend parser_ps_2_x

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_ps_2_x,
    asmparser_srcreg_ps_2_x,
    asmparser_predicate_supported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input_ps_2,
    asmparser_dcl_sampler,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1269 of file asmparser.c.

Referenced by create_ps2x_parser().

◆ parser_ps_3

const struct asmparser_backend parser_ps_3

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_ps_3,
    asmparser_srcreg_ps_3,
    asmparser_predicate_supported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input,
    asmparser_dcl_sampler,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1289 of file asmparser.c.

Referenced by create_ps30_parser().

◆ parser_vs_1

const struct asmparser_backend parser_vs_1

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_vs_1,
    asmparser_srcreg_vs_1,
    asmparser_predicate_unsupported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input,
    asmparser_dcl_sampler_unsupported,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1149 of file asmparser.c.

Referenced by create_vs10_parser(), and create_vs11_parser().

◆ parser_vs_2

const struct asmparser_backend parser_vs_2

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_vs_2,
    asmparser_srcreg_vs_2,
    asmparser_predicate_supported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output_unsupported,
    asmparser_dcl_input,
    asmparser_dcl_sampler_unsupported,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1169 of file asmparser.c.

Referenced by create_vs20_parser(), and create_vs2x_parser().

◆ parser_vs_3

const struct asmparser_backend parser_vs_3

static

Initial value:

= {
    asmparser_constF,
    asmparser_constI,
    asmparser_constB,
    asmparser_dstreg_vs_3,
    asmparser_srcreg_vs_3,
    asmparser_predicate_supported,
    asmparser_coissue_unsupported,
    asmparser_dcl_output,
    asmparser_dcl_input,
    asmparser_dcl_sampler,
    asmparser_end,
    asmparser_instr,
}

Definition at line 1189 of file asmparser.c.

Referenced by create_vs30_parser().

◆ ps_1_0123_reg_allowed

const struct allowed_reg_type ps_1_0123_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_CONST,     8,  FALSE },
    { BWRITERSPR_TEMP,      2,  FALSE },
    { BWRITERSPR_TEXTURE,   4,  FALSE },
    { BWRITERSPR_INPUT,     2,  FALSE },
    { ~0U, 0 } 
}

Definition at line 848 of file asmparser.c.

Referenced by asmparser_dstreg_ps_1_0123(), and asmparser_srcreg_ps_1_0123().

◆ ps_1_4_reg_allowed

const struct allowed_reg_type ps_1_4_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_CONST,     8,  FALSE },
    { BWRITERSPR_TEMP,      6,  FALSE },
    { BWRITERSPR_TEXTURE,   6,  FALSE },
    { BWRITERSPR_INPUT,     2,  FALSE },
    { ~0U, 0 } 
}

Definition at line 872 of file asmparser.c.

Referenced by asmparser_dstreg_ps_1_4(), and asmparser_srcreg_ps_1_4().

◆ ps_2_0_reg_allowed

const struct allowed_reg_type ps_2_0_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_INPUT,         2,  FALSE },
    { BWRITERSPR_TEMP,         32,  FALSE },
    { BWRITERSPR_CONST,        32,  FALSE },
    { BWRITERSPR_CONSTINT,     16,  FALSE },
    { BWRITERSPR_CONSTBOOL,    16,  FALSE },
    { BWRITERSPR_SAMPLER,      16,  FALSE },
    { BWRITERSPR_TEXTURE,       8,  FALSE },
    { BWRITERSPR_COLOROUT,      4,  FALSE },
    { BWRITERSPR_DEPTHOUT,      1,  FALSE },
    { ~0U, 0 } 
}

Definition at line 896 of file asmparser.c.

Referenced by asmparser_dstreg_ps_2(), and asmparser_srcreg_ps_2().

◆ ps_2_x_reg_allowed

const struct allowed_reg_type ps_2_x_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_INPUT,         2,  FALSE },
    { BWRITERSPR_TEMP,         32,  FALSE },
    { BWRITERSPR_CONST,        32,  FALSE },
    { BWRITERSPR_CONSTINT,     16,  FALSE },
    { BWRITERSPR_CONSTBOOL,    16,  FALSE },
    { BWRITERSPR_PREDICATE,     1,  FALSE },
    { BWRITERSPR_SAMPLER,      16,  FALSE },
    { BWRITERSPR_TEXTURE,       8,  FALSE },
    { BWRITERSPR_LABEL,      2048,  FALSE },
    { BWRITERSPR_COLOROUT,      4,  FALSE },
    { BWRITERSPR_DEPTHOUT,      1,  FALSE },
    { ~0U, 0 } 
}

Definition at line 926 of file asmparser.c.

Referenced by asmparser_dstreg_ps_2_x(), and asmparser_srcreg_ps_2_x().

◆ ps_3_reg_allowed

const struct allowed_reg_type ps_3_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_INPUT,        10,   TRUE },
    { BWRITERSPR_TEMP,         32,  FALSE },
    { BWRITERSPR_CONST,       224,  FALSE },
    { BWRITERSPR_CONSTINT,     16,  FALSE },
    { BWRITERSPR_CONSTBOOL,    16,  FALSE },
    { BWRITERSPR_PREDICATE,     1,  FALSE },
    { BWRITERSPR_SAMPLER,      16,  FALSE },
    { BWRITERSPR_MISCTYPE,      2,  FALSE }, 
    { BWRITERSPR_LOOP,          1,  FALSE },
    { BWRITERSPR_LABEL,      2048,  FALSE },
    { BWRITERSPR_COLOROUT,      4,  FALSE },
    { BWRITERSPR_DEPTHOUT,      1,  FALSE },
    { ~0U, 0 } 
}

Definition at line 958 of file asmparser.c.

Referenced by asmparser_dstreg_ps_3(), and asmparser_srcreg_ps_3().

◆ vs_1_reg_allowed

const struct allowed_reg_type vs_1_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_TEMP,         12,  FALSE },
    { BWRITERSPR_INPUT,        16,  FALSE },
    { BWRITERSPR_CONST,       ~0U,   TRUE },
    { BWRITERSPR_ADDR,          1,  FALSE },
    { BWRITERSPR_RASTOUT,       3,  FALSE }, 
    { BWRITERSPR_ATTROUT,       2,  FALSE },
    { BWRITERSPR_TEXCRDOUT,     8,  FALSE },
    { ~0U, 0 } 
}

Definition at line 745 of file asmparser.c.

Referenced by asmparser_dstreg_vs_1(), and asmparser_srcreg_vs_1().

◆ vs_2_reg_allowed

const struct allowed_reg_type vs_2_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_TEMP,      12,  FALSE },
    { BWRITERSPR_INPUT,     16,  FALSE },
    { BWRITERSPR_CONST,    ~0U,   TRUE },
    { BWRITERSPR_ADDR,       1,  FALSE },
    { BWRITERSPR_CONSTBOOL, 16,  FALSE },
    { BWRITERSPR_CONSTINT,  16,  FALSE },
    { BWRITERSPR_LOOP,       1,  FALSE },
    { BWRITERSPR_LABEL,   2048,  FALSE },
    { BWRITERSPR_PREDICATE,  1,  FALSE },
    { BWRITERSPR_RASTOUT,    3,  FALSE }, 
    { BWRITERSPR_ATTROUT,    2,  FALSE },
    { BWRITERSPR_TEXCRDOUT,  8,  FALSE },
    { ~0U, 0 } 
}

Definition at line 785 of file asmparser.c.

Referenced by asmparser_dstreg_vs_2(), and asmparser_srcreg_vs_2().

◆ vs_3_reg_allowed

const struct allowed_reg_type vs_3_reg_allowed[]

static

Initial value:

= {
    { BWRITERSPR_TEMP,         32,  FALSE },
    { BWRITERSPR_INPUT,        16,   TRUE },
    { BWRITERSPR_CONST,       ~0U,   TRUE },
    { BWRITERSPR_ADDR,          1,  FALSE },
    { BWRITERSPR_CONSTBOOL,    16,  FALSE },
    { BWRITERSPR_CONSTINT,     16,  FALSE },
    { BWRITERSPR_LOOP,          1,  FALSE },
    { BWRITERSPR_LABEL,      2048,  FALSE },
    { BWRITERSPR_PREDICATE,     1,  FALSE },
    { BWRITERSPR_SAMPLER,       4,  FALSE },
    { BWRITERSPR_OUTPUT,       12,   TRUE },
    { ~0U, 0 } 
}

Definition at line 819 of file asmparser.c.

Referenced by asmparser_dstreg_vs_3(), and asmparser_srcreg_vs_3().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ C0_VARYING

◆ C1_VARYING

◆ OD0_REG

◆ OD1_REG

◆ OFOG_REG

◆ OFOG_WRITEMASK

◆ OPOS_REG

◆ OPTS_REG

◆ OPTS_WRITEMASK

◆ OT0_REG

◆ OT1_REG

◆ OT2_REG

◆ OT3_REG

◆ OT4_REG

◆ OT5_REG

◆ OT6_REG

◆ OT7_REG

◆ T0_VARYING

◆ T1_VARYING

◆ T2_VARYING

◆ T3_VARYING

◆ T4_VARYING

◆ T5_VARYING

◆ T6_VARYING

◆ T7_VARYING

Function Documentation

◆ asmparser_coissue_supported()

◆ asmparser_coissue_unsupported()

◆ asmparser_constB()

◆ asmparser_constF()

◆ asmparser_constI()

◆ asmparser_dcl_input()

◆ asmparser_dcl_input_ps_2()

◆ 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_end()

◆ asmparser_instr()

◆ asmparser_predicate_supported()

◆ 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_tex()

◆ asmparser_texcoord()

◆ asmparser_texcrd()

◆ asmparser_texhelper()

◆ asmparser_texkill()

◆ asmparser_texld14()

◆ asmparser_texreg2ar()

◆ asmparser_texreg2gb()

◆ asmparser_texreg2rgb()

◆ check_abs_srcmod()

◆ check_legacy_srcmod()

◆ check_loop_swizzle()

◆ check_ps_dstmod()

◆ check_reg_type()

◆ check_shift_dstmod()

◆ create_ps10_parser()