From c4273f0bbef5262775365996c38a8a980567e8e0 Mon Sep 17 00:00:00 2001 From: Matteo Bruni Date: Wed, 9 Feb 2022 16:30:05 +0100 Subject: [PATCH] d3dcompiler: Use more consistent integer data types. Signed-off-by: Matteo Bruni Signed-off-by: Alexandre Julliard --- dlls/d3dcompiler_43/asmparser.c | 986 ++++++++-------- dlls/d3dcompiler_43/asmshader.y | 68 +- dlls/d3dcompiler_43/bytecodewriter.c | 1257 +++++++++++---------- dlls/d3dcompiler_43/compiler.c | 7 +- dlls/d3dcompiler_43/d3dcompiler_private.h | 141 +-- dlls/d3dcompiler_43/reflection.c | 344 +++--- dlls/d3dcompiler_43/utils.c | 154 +-- 7 files changed, 1579 insertions(+), 1378 deletions(-) diff --git a/dlls/d3dcompiler_43/asmparser.c b/dlls/d3dcompiler_43/asmparser.c index fff11969581..3e400827d92 100644 --- a/dlls/d3dcompiler_43/asmparser.c +++ b/dlls/d3dcompiler_43/asmparser.c @@ -71,139 +71,163 @@ static void asmparser_end(struct asm_parser *This) { TRACE("Finalizing shader\n"); } -static void asmparser_constF(struct asm_parser *This, DWORD reg, float x, float y, float z, float w) { - if(!This->shader) return; - TRACE("Adding float constant %lu at pos %u.\n", reg, This->shader->num_cf); - TRACE_(parsed_shader)("def c%lu, %f, %f, %f, %f\n", reg, x, y, z, w); - if(!add_constF(This->shader, reg, x, y, z, w)) { +static void asmparser_constF(struct asm_parser *parser, uint32_t reg, float x, float y, float z, float w) +{ + if (!parser->shader) + return; + TRACE("Adding float constant %u at pos %u.\n", reg, parser->shader->num_cf); + TRACE_(parsed_shader)("def c%u, %f, %f, %f, %f\n", reg, x, y, z, w); + if (!add_constF(parser->shader, reg, x, y, z, w)) + { + ERR("Out of memory.\n"); + set_parse_status(&parser->status, PARSE_ERR); + } +} + +static void asmparser_constB(struct asm_parser *parser, uint32_t reg, BOOL x) +{ + if (!parser->shader) + return; + TRACE("Adding boolean constant %u at pos %u.\n", reg, parser->shader->num_cb); + TRACE_(parsed_shader)("def b%u, %s\n", reg, x ? "true" : "false"); + if (!add_constB(parser->shader, reg, x)) + { + ERR("Out of memory.\n"); + set_parse_status(&parser->status, PARSE_ERR); + } +} + +static void asmparser_constI(struct asm_parser *parser, uint32_t reg, int x, int y, int z, int w) +{ + if (!parser->shader) + return; + TRACE("Adding integer constant %u at pos %u.\n", reg, parser->shader->num_ci); + TRACE_(parsed_shader)("def i%u, %d, %d, %d, %d\n", reg, x, y, z, w); + if (!add_constI(parser->shader, reg, x, y, z, w)) + { + ERR("Out of memory.\n"); + set_parse_status(&parser->status, PARSE_ERR); + } +} + +static void asmparser_dcl_output(struct asm_parser *parser, uint32_t usage, uint32_t num, + const struct shader_reg *reg) +{ + if (!parser->shader) + return; + if (parser->shader->type == ST_PIXEL) + { + asmparser_message(parser, "Line %u: Output register declared in a pixel shader\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); + } + if (!record_declaration(parser->shader, usage, num, 0, TRUE, reg->regnum, reg->writemask, FALSE)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static void asmparser_constB(struct asm_parser *This, DWORD reg, BOOL x) { - if(!This->shader) return; - TRACE("Adding boolean constant %lu at pos %u.\n", reg, This->shader->num_cb); - TRACE_(parsed_shader)("def b%lu, %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); - } +static void asmparser_dcl_output_unsupported(struct asm_parser *parser, uint32_t usage, uint32_t num, + const struct shader_reg *reg) +{ + asmparser_message(parser, "Line %u: Output declaration unsupported in this shader version\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } -static void asmparser_constI(struct asm_parser *This, DWORD reg, INT x, INT y, INT z, INT w) { - if(!This->shader) return; - TRACE("Adding integer constant %lu at pos %u.\n", reg, This->shader->num_ci); - TRACE_(parsed_shader)("def i%lu, %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); - } -} - -static void asmparser_dcl_output(struct asm_parser *This, DWORD usage, DWORD num, - const struct shader_reg *reg) { - 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); - } -} - -static void asmparser_dcl_output_unsupported(struct asm_parser *This, DWORD usage, DWORD num, - const struct shader_reg *reg) { - asmparser_message(This, "Line %u: Output declaration unsupported in this shader version\n", This->line_no); - set_parse_status(&This->status, PARSE_ERR); -} - -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(struct asm_parser *parser, uint32_t usage, uint32_t num, uint32_t mod, + const struct shader_reg *reg) +{ struct instruction instr; - if(!This->shader) return; - if (mod && (This->shader->type != ST_PIXEL || This->shader->major_version != 3 + if (!parser->shader) + return; + if (mod && (parser->shader->type != ST_PIXEL || parser->shader->major_version != 3 || (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); + asmparser_message(parser, "Line %u: Unsupported modifier in dcl instruction\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } /* Check register type and modifiers */ instr.dstmod = mod; instr.shift = 0; - This->funcs->dstreg(This, &instr, reg); + parser->funcs->dstreg(parser, &instr, reg); - if(!record_declaration(This->shader, usage, num, mod, FALSE, reg->regnum, reg->u.writemask, FALSE)) { + if (!record_declaration(parser->shader, usage, num, mod, FALSE, reg->regnum, reg->writemask, FALSE)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -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_ps_2(struct asm_parser *parser, uint32_t usage, uint32_t num, uint32_t mod, + const struct shader_reg *reg) +{ struct instruction instr; - if(!This->shader) return; + if (!parser->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)) { + parser->funcs->dstreg(parser, &instr, reg); + if (!record_declaration(parser->shader, usage, num, mod, FALSE, instr.dst.regnum, instr.dst.writemask, FALSE)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -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_input_unsupported(struct asm_parser *parser, uint32_t usage, uint32_t num, uint32_t mod, + const struct shader_reg *reg) { - asmparser_message(This, "Line %u: Input declaration unsupported in this shader version\n", This->line_no); - set_parse_status(&This->status, PARSE_ERR); + asmparser_message(parser, "Line %u: Input declaration unsupported in this shader version\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } -static void asmparser_dcl_sampler(struct asm_parser *This, DWORD samptype, - DWORD mod, DWORD regnum, - unsigned int line_no) { - if(!This->shader) return; - if (mod && (This->shader->type != ST_PIXEL || This->shader->major_version != 3 +static void asmparser_dcl_sampler(struct asm_parser *parser, uint32_t samptype, uint32_t mod, uint32_t regnum, + unsigned int line_no) +{ + if (!parser->shader) + return; + if (mod && (parser->shader->type != ST_PIXEL || parser->shader->major_version != 3 || (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); + asmparser_message(parser, "Line %u: Unsupported modifier in dcl instruction\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } - if(!record_sampler(This->shader, samptype, mod, regnum)) { + if (!record_sampler(parser->shader, samptype, mod, regnum)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static void asmparser_dcl_sampler_unsupported(struct asm_parser *This, - DWORD samptype, DWORD mod, DWORD regnum, unsigned int line_no) +static void asmparser_dcl_sampler_unsupported(struct asm_parser *parser, uint32_t samptype, uint32_t mod, + uint32_t regnum, unsigned int line_no) { - asmparser_message(This, "Line %u: Sampler declaration unsupported in this shader version\n", This->line_no); - set_parse_status(&This->status, PARSE_ERR); + asmparser_message(parser, "Line %u: Sampler declaration unsupported in this shader version\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } -static void asmparser_sincos(struct asm_parser *This, DWORD mod, DWORD shift, - const struct shader_reg *dst, - const struct src_regs *srcs) { +static void asmparser_sincos(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct src_regs *srcs) +{ 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); + if (!srcs || srcs->count != 3) + { + asmparser_message(parser, "Line %u: sincos (vs 2) has an incorrect number of source registers\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } instr = alloc_instr(3); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -212,25 +236,31 @@ static void asmparser_sincos(struct asm_parser *This, DWORD mod, DWORD shift, 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]); + parser->funcs->dstreg(parser, instr, dst); + parser->funcs->srcreg(parser, instr, 0, &srcs->reg[0]); + parser->funcs->srcreg(parser, instr, 1, &srcs->reg[1]); + parser->funcs->srcreg(parser, instr, 2, &srcs->reg[2]); - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static struct shader_reg map_oldps_register(const struct shader_reg *reg, BOOL tex_varying) { +static struct shader_reg map_oldps_register(const struct shader_reg *reg, BOOL tex_varying) +{ struct shader_reg ret; - switch(reg->type) { + + switch (reg->type) + { case BWRITERSPR_TEXTURE: - if(tex_varying) { + if (tex_varying) + { ret = *reg; ret.type = BWRITERSPR_INPUT; - switch(reg->regnum) { + switch (reg->regnum) + { case 0: ret.regnum = T0_VARYING; break; case 1: ret.regnum = T1_VARYING; break; case 2: ret.regnum = T2_VARYING; break; @@ -240,20 +270,23 @@ static struct shader_reg map_oldps_register(const struct shader_reg *reg, BOOL t case 6: ret.regnum = T6_VARYING; break; case 7: ret.regnum = T7_VARYING; break; default: - FIXME("Unexpected TEXTURE register t%lu.\n", reg->regnum); + FIXME("Unexpected TEXTURE register t%u.\n", reg->regnum); return *reg; } return ret; - } else { + } + else + { ret = *reg; ret.type = BWRITERSPR_TEMP; - switch(reg->regnum) { + 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%lu.\n", reg->regnum); + FIXME("Unexpected TEXTURE register t%u.\n", reg->regnum); return *reg; } return ret; @@ -266,21 +299,23 @@ static struct shader_reg map_oldps_register(const struct shader_reg *reg, BOOL t } } -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_texcoord(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct src_regs *srcs) +{ 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); + if (srcs) + { + asmparser_message(parser, "Line %u: Source registers in texcoord instruction\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } instr = alloc_instr(1); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -293,31 +328,34 @@ static void asmparser_texcoord(struct asm_parser *This, DWORD mod, DWORD shift, instr->shift = shift; instr->comptype = 0; - This->funcs->dstreg(This, instr, dst); + parser->funcs->dstreg(parser, instr, dst); /* The src reg needs special care */ instr->src[0] = map_oldps_register(dst, TRUE); - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -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_texcrd(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct src_regs *srcs) +{ 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); + if (!srcs || srcs->count != 1) + { + asmparser_message(parser, "Line %u: Wrong number of source registers in texcrd instruction\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } instr = alloc_instr(1); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -327,22 +365,24 @@ static void asmparser_texcrd(struct asm_parser *This, DWORD mod, DWORD shift, instr->shift = shift; instr->comptype = 0; - This->funcs->dstreg(This, instr, dst); - This->funcs->srcreg(This, instr, 0, &srcs->reg[0]); + parser->funcs->dstreg(parser, instr, dst); + parser->funcs->srcreg(parser, instr, 0, &srcs->reg[0]); - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static void asmparser_texkill(struct asm_parser *This, - const struct shader_reg *dst) { +static void asmparser_texkill(struct asm_parser *parser, const struct shader_reg *dst) +{ struct instruction *instr = alloc_instr(0); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -361,20 +401,22 @@ static void asmparser_texkill(struct asm_parser *This, instr->dst = map_oldps_register(dst, TRUE); instr->has_dst = TRUE; - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -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_texhelper(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct shader_reg *src0) +{ struct instruction *instr = alloc_instr(2); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -383,7 +425,7 @@ static void asmparser_texhelper(struct asm_parser *This, DWORD mod, DWORD shift, instr->shift = shift; instr->comptype = 0; /* The dest register can be mapped normally to a temporary register */ - This->funcs->dstreg(This, instr, dst); + parser->funcs->dstreg(parser, instr, dst); /* Use the src passed as parameter by the specific instruction handler */ instr->src[0] = *src0; @@ -393,40 +435,43 @@ static void asmparser_texhelper(struct asm_parser *This, DWORD mod, DWORD shift, 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].swizzle = BWRITERVS_NOSWIZZLE; instr->src[1].srcmod = BWRITERSPSM_NONE; instr->src[1].rel_reg = NULL; - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static void asmparser_tex(struct asm_parser *This, DWORD mod, DWORD shift, - const struct shader_reg *dst) { +static void asmparser_tex(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst) +{ 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); + asmparser_texhelper(parser, mod, shift, dst, &src); } -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_texld14(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct src_regs *srcs) +{ 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); + if (!srcs || srcs->count != 1) + { + asmparser_message(parser, "Line %u: texld (PS 1.4) has a wrong number of source registers\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } instr = alloc_instr(2); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -438,8 +483,8 @@ static void asmparser_texld14(struct asm_parser *This, DWORD mod, DWORD shift, instr->shift = shift; instr->comptype = 0; - This->funcs->dstreg(This, instr, dst); - This->funcs->srcreg(This, instr, 0, &srcs->reg[0]); + parser->funcs->dstreg(parser, instr, dst); + parser->funcs->srcreg(parser, instr, 0, &srcs->reg[0]); /* The 2nd source register is the sampler register with the * destination's regnum @@ -447,47 +492,48 @@ static void asmparser_texld14(struct asm_parser *This, DWORD mod, DWORD shift, 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].swizzle = BWRITERVS_NOSWIZZLE; instr->src[1].srcmod = BWRITERSPSM_NONE; instr->src[1].rel_reg = NULL; - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -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_texreg2ar(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct shader_reg *src0) +{ 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); + src.swizzle = BWRITERVS_X_W | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X; + asmparser_texhelper(parser, mod, shift, dst, &src); } -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_texreg2gb(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct shader_reg *src0) +{ 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); + src.swizzle = BWRITERVS_X_Y | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z; + asmparser_texhelper(parser, mod, shift, dst, &src); } -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_texreg2rgb(struct asm_parser *parser, uint32_t mod, uint32_t shift, const struct shader_reg *dst, + const struct shader_reg *src0) +{ 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); + src.swizzle = BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_Z; + asmparser_texhelper(parser, mod, shift, dst, &src); } /* Complex pixel shader 1.3 instructions like texm3x3tex are tricky - the @@ -497,40 +543,45 @@ static void asmparser_texreg2rgb(struct asm_parser *This, DWORD mod, DWORD shift * go through asmparser_instr). */ -static void asmparser_instr(struct asm_parser *This, DWORD opcode, DWORD mod, DWORD shift, +static void asmparser_instr(struct asm_parser *parser, uint32_t opcode, uint32_t mod, uint32_t shift, enum bwriter_comparison_type comp, const struct shader_reg *dst, const struct src_regs *srcs, int expectednsrcs) { - struct bwriter_shader *shader = This->shader; - struct instruction *instr; - unsigned int i; - BOOL firstreg = TRUE; unsigned int src_count = srcs ? srcs->count : 0; + struct bwriter_shader *shader = parser->shader; + struct instruction *instr; + BOOL firstreg = TRUE; + unsigned int i; - if(!This->shader) return; + if (!parser->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) { + if (dst) + { TRACE_(parsed_shader)("%s", debug_print_dstreg(dst)); firstreg = FALSE; } - for(i = 0; i < src_count; i++) { - if(!firstreg) TRACE_(parsed_shader)(", "); + 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) { + switch(opcode) + { case BWRITERSIO_SINCOS: /* The syntax changes between vs 2 and the other shader versions */ - if (This->shader->type == ST_VERTEX && This->shader->major_version == 2) + if (parser->shader->type == ST_VERTEX && parser->shader->major_version == 2) { - asmparser_sincos(This, mod, shift, dst, srcs); + asmparser_sincos(parser, mod, shift, dst, srcs); return; } /* Use the default handling */ @@ -538,9 +589,9 @@ static void asmparser_instr(struct asm_parser *This, DWORD opcode, DWORD mod, DW case BWRITERSIO_TEXCOORD: /* texcoord/texcrd are two instructions present only in PS <= 1.3 and PS 1.4 respectively */ if (shader->type == ST_PIXEL && shader->major_version == 1 && shader->minor_version == 4) - asmparser_texcrd(This, mod, shift, dst, srcs); + asmparser_texcrd(parser, mod, shift, dst, srcs); else - asmparser_texcoord(This, mod, shift, dst, srcs); + asmparser_texcoord(parser, mod, shift, dst, srcs); return; case BWRITERSIO_TEX: /* this encodes both the tex PS 1.x instruction and the @@ -548,41 +599,44 @@ static void asmparser_instr(struct asm_parser *This, DWORD opcode, DWORD mod, DW if (shader->type == ST_PIXEL && shader->major_version == 1) { if (shader->minor_version < 4) - asmparser_tex(This, mod, shift, dst); + asmparser_tex(parser, mod, shift, dst); else - asmparser_texld14(This, mod, shift, dst, srcs); + asmparser_texld14(parser, 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); + if (src_count != expectednsrcs) + { + asmparser_message(parser, "Line %u: Wrong number of source registers\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); return; } /* Handle PS 1.x instructions, "regularizing" them */ - switch(opcode) { + switch(opcode) + { case BWRITERSIO_TEXKILL: - asmparser_texkill(This, dst); + asmparser_texkill(parser, dst); return; case BWRITERSIO_TEXREG2AR: - asmparser_texreg2ar(This, mod, shift, dst, &srcs->reg[0]); + asmparser_texreg2ar(parser, mod, shift, dst, &srcs->reg[0]); return; case BWRITERSIO_TEXREG2GB: - asmparser_texreg2gb(This, mod, shift, dst, &srcs->reg[0]); + asmparser_texreg2gb(parser, mod, shift, dst, &srcs->reg[0]); return; case BWRITERSIO_TEXREG2RGB: - asmparser_texreg2rgb(This, mod, shift, dst, &srcs->reg[0]); + asmparser_texreg2rgb(parser, mod, shift, dst, &srcs->reg[0]); return; } instr = alloc_instr(src_count); - if(!instr) { + if (!instr) + { ERR("Error allocating memory for the instruction\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); return; } @@ -590,37 +644,44 @@ static void asmparser_instr(struct asm_parser *This, DWORD opcode, DWORD mod, DW 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 (dst) + parser->funcs->dstreg(parser, instr, dst); + for (i = 0; i < src_count; i++) + { + parser->funcs->srcreg(parser, instr, i, &srcs->reg[i]); } - if(!add_instruction(This->shader, instr)) { + if (!add_instruction(parser->shader, instr)) + { ERR("Out of memory\n"); - set_parse_status(&This->status, PARSE_ERR); + set_parse_status(&parser->status, PARSE_ERR); } } -static struct shader_reg map_oldvs_register(const struct shader_reg *reg) { +static struct shader_reg map_oldvs_register(const struct shader_reg *reg) +{ struct shader_reg ret; - switch(reg->type) { + + switch(reg->type) + { case BWRITERSPR_RASTOUT: ret = *reg; ret.type = BWRITERSPR_OUTPUT; - switch(reg->regnum) { + switch(reg->regnum) + { case BWRITERSRO_POSITION: ret.regnum = OPOS_REG; break; case BWRITERSRO_FOG: ret.regnum = OFOG_REG; - ret.u.writemask = OFOG_WRITEMASK; + ret.writemask = OFOG_WRITEMASK; break; case BWRITERSRO_POINT_SIZE: ret.regnum = OPTS_REG; - ret.u.writemask = OPTS_WRITEMASK; + ret.writemask = OPTS_WRITEMASK; break; default: - FIXME("Unhandled RASTOUT register %lu.\n", reg->regnum); + FIXME("Unhandled RASTOUT register %u.\n", reg->regnum); return *reg; } return ret; @@ -628,7 +689,8 @@ static struct shader_reg map_oldvs_register(const struct shader_reg *reg) { case BWRITERSPR_TEXCRDOUT: ret = *reg; ret.type = BWRITERSPR_OUTPUT; - switch(reg->regnum) { + switch(reg->regnum) + { case 0: ret.regnum = OT0_REG; break; case 1: ret.regnum = OT1_REG; break; case 2: ret.regnum = OT2_REG; break; @@ -638,7 +700,7 @@ static struct shader_reg map_oldvs_register(const struct shader_reg *reg) { case 6: ret.regnum = OT6_REG; break; case 7: ret.regnum = OT7_REG; break; default: - FIXME("Unhandled TEXCRDOUT regnum %lu.\n", reg->regnum); + FIXME("Unhandled TEXCRDOUT regnum %u.\n", reg->regnum); return *reg; } return ret; @@ -646,11 +708,12 @@ static struct shader_reg map_oldvs_register(const struct shader_reg *reg) { case BWRITERSPR_ATTROUT: ret = *reg; ret.type = BWRITERSPR_OUTPUT; - switch(reg->regnum) { + switch(reg->regnum) + { case 0: ret.regnum = OD0_REG; break; case 1: ret.regnum = OD1_REG; break; default: - FIXME("Unhandled ATTROUT regnum %lu.\n", reg->regnum); + FIXME("Unhandled ATTROUT regnum %u.\n", reg->regnum); return *reg; } return ret; @@ -661,76 +724,85 @@ static struct shader_reg map_oldvs_register(const struct shader_reg *reg) { /* Checks for unsupported source modifiers in VS (all versions) or PS 2.0 and newer */ -static void check_legacy_srcmod(struct asm_parser *This, DWORD srcmod) { - 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); +static void check_legacy_srcmod(struct asm_parser *parser, uint32_t srcmod) +{ + 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(parser, "Line %u: Source modifier %s not supported in this shader version\n", + parser->line_no, debug_print_srcmod(srcmod)); + set_parse_status(&parser->status, PARSE_ERR); } } -static void check_abs_srcmod(struct asm_parser *This, DWORD srcmod) { - 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); +static void check_abs_srcmod(struct asm_parser *parser, uint32_t srcmod) +{ + if (srcmod == BWRITERSPSM_ABS || srcmod == BWRITERSPSM_ABSNEG) + { + asmparser_message(parser, "Line %u: Source modifier %s not supported in this shader version\n", + parser->line_no, debug_print_srcmod(srcmod)); + set_parse_status(&parser->status, PARSE_ERR); } } -static void check_loop_swizzle(struct asm_parser *This, - const struct shader_reg *src) { - 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); +static void check_loop_swizzle(struct asm_parser *parser, const struct shader_reg *src) +{ + if ((src->type == BWRITERSPR_LOOP && src->swizzle != BWRITERVS_NOSWIZZLE) + || (src->rel_reg && src->rel_reg->type == BWRITERSPR_LOOP && + src->rel_reg->swizzle != BWRITERVS_NOSWIZZLE)) + { + asmparser_message(parser, "Line %u: Swizzle not allowed on aL register\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } } -static void check_shift_dstmod(struct asm_parser *This, DWORD shift) { - 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); +static void check_shift_dstmod(struct asm_parser *parser, uint32_t shift) +{ + if (shift != 0) + { + asmparser_message(parser, "Line %u: Shift modifiers not supported in this shader version\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } } -static void check_ps_dstmod(struct asm_parser *This, DWORD dstmod) { - 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); +static void check_ps_dstmod(struct asm_parser *parser, uint32_t dstmod) +{ + if(dstmod == BWRITERSPDM_PARTIALPRECISION || dstmod == BWRITERSPDM_MSAMPCENTROID) + { + asmparser_message(parser, "Line %u: Instruction modifier %s not supported in this shader version\n", + parser->line_no, debug_print_dstmod(dstmod)); + set_parse_status(&parser->status, PARSE_ERR); } } -struct allowed_reg_type { - DWORD type; - DWORD count; +struct allowed_reg_type +{ + uint32_t type; + unsigned int count; BOOL reladdr; }; -static BOOL check_reg_type(const struct shader_reg *reg, - const struct allowed_reg_type *allowed) { +static BOOL check_reg_type(const struct shader_reg *reg, const struct allowed_reg_type *allowed) +{ 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 */ + while (allowed[i].type != ~0u) + { + if (reg->type == allowed[i].type) + { + if (reg->rel_reg) + { + /* The relative addressing register can have a negative value, + * we can't check the register index. */ + if (allowed[i].reladdr) + return TRUE; return FALSE; } - if(reg->regnum < allowed[i].count) return TRUE; + if (reg->regnum < allowed[i].count) + return TRUE; return FALSE; } i++; @@ -739,15 +811,16 @@ static BOOL check_reg_type(const struct shader_reg *reg, } /* Native assembler doesn't do separate checks for src and dst registers */ -static const struct allowed_reg_type vs_1_reg_allowed[] = { +static const struct allowed_reg_type vs_1_reg_allowed[] = +{ { BWRITERSPR_TEMP, 12, FALSE }, { BWRITERSPR_INPUT, 16, FALSE }, - { BWRITERSPR_CONST, ~0U, TRUE }, + { BWRITERSPR_CONST, ~0u, TRUE }, { BWRITERSPR_ADDR, 1, FALSE }, { BWRITERSPR_RASTOUT, 3, FALSE }, /* oPos, oFog and oPts */ { BWRITERSPR_ATTROUT, 2, FALSE }, { BWRITERSPR_TEXCRDOUT, 8, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; /* struct instruction *asmparser_srcreg @@ -762,27 +835,28 @@ static const struct allowed_reg_type vs_1_reg_allowed[] = { * src: Pointer to source the register structure. The caller can free * it afterwards */ -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_1(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, vs_1_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in VS 1\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_legacy_srcmod(This, src->srcmod); - check_abs_srcmod(This, src->srcmod); + check_legacy_srcmod(parser, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldvs_register(src); instr->src[num] = reg; } -static const struct allowed_reg_type vs_2_reg_allowed[] = { +static const struct allowed_reg_type vs_2_reg_allowed[] = +{ { BWRITERSPR_TEMP, 12, FALSE }, { BWRITERSPR_INPUT, 16, FALSE }, - { BWRITERSPR_CONST, ~0U, TRUE }, + { BWRITERSPR_CONST, ~0u, TRUE }, { BWRITERSPR_ADDR, 1, FALSE }, { BWRITERSPR_CONSTBOOL, 16, FALSE }, { BWRITERSPR_CONSTINT, 16, FALSE }, @@ -792,31 +866,32 @@ static const struct allowed_reg_type vs_2_reg_allowed[] = { { BWRITERSPR_RASTOUT, 3, FALSE }, /* oPos, oFog and oPts */ { BWRITERSPR_ATTROUT, 2, FALSE }, { BWRITERSPR_TEXCRDOUT, 8, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -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_2(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, vs_2_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in VS 2\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_loop_swizzle(This, src); - check_legacy_srcmod(This, src->srcmod); - check_abs_srcmod(This, src->srcmod); + check_loop_swizzle(parser, src); + check_legacy_srcmod(parser, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldvs_register(src); instr->src[num] = reg; } -static const struct allowed_reg_type vs_3_reg_allowed[] = { +static const struct allowed_reg_type vs_3_reg_allowed[] = +{ { BWRITERSPR_TEMP, 32, FALSE }, { BWRITERSPR_INPUT, 16, TRUE }, - { BWRITERSPR_CONST, ~0U, TRUE }, + { BWRITERSPR_CONST, ~0u, TRUE }, { BWRITERSPR_ADDR, 1, FALSE }, { BWRITERSPR_CONSTBOOL, 16, FALSE }, { BWRITERSPR_CONSTINT, 16, FALSE }, @@ -825,72 +900,75 @@ static const struct allowed_reg_type vs_3_reg_allowed[] = { { BWRITERSPR_PREDICATE, 1, FALSE }, { BWRITERSPR_SAMPLER, 4, FALSE }, { BWRITERSPR_OUTPUT, 12, TRUE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -static void asmparser_srcreg_vs_3(struct asm_parser *This, - struct instruction *instr, int num, - const struct shader_reg *src) { - 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); +static void asmparser_srcreg_vs_3(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ + if (!check_reg_type(src, vs_3_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in VS 3.0\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_loop_swizzle(This, src); - check_legacy_srcmod(This, src->srcmod); + check_loop_swizzle(parser, src); + check_legacy_srcmod(parser, src->srcmod); instr->src[num] = *src; } -static const struct allowed_reg_type ps_1_0123_reg_allowed[] = { +static const struct allowed_reg_type ps_1_0123_reg_allowed[] = +{ { BWRITERSPR_CONST, 8, FALSE }, { BWRITERSPR_TEMP, 2, FALSE }, { BWRITERSPR_TEXTURE, 4, FALSE }, { BWRITERSPR_INPUT, 2, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -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_0123(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, ps_1_0123_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in <== PS 1.3\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_abs_srcmod(This, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldps_register(src, FALSE); instr->src[num] = reg; } -static const struct allowed_reg_type ps_1_4_reg_allowed[] = { +static const struct allowed_reg_type ps_1_4_reg_allowed[] = +{ { BWRITERSPR_CONST, 8, FALSE }, { BWRITERSPR_TEMP, 6, FALSE }, { BWRITERSPR_TEXTURE, 6, FALSE }, { BWRITERSPR_INPUT, 2, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -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_1_4(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, ps_1_4_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in PS 1.4\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_abs_srcmod(This, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldps_register(src, TRUE); instr->src[num] = reg; } -static const struct allowed_reg_type ps_2_0_reg_allowed[] = { +static const struct allowed_reg_type ps_2_0_reg_allowed[] = +{ { BWRITERSPR_INPUT, 2, FALSE }, { BWRITERSPR_TEMP, 32, FALSE }, { BWRITERSPR_CONST, 32, FALSE }, @@ -900,27 +978,28 @@ static const struct allowed_reg_type ps_2_0_reg_allowed[] = { { BWRITERSPR_TEXTURE, 8, FALSE }, { BWRITERSPR_COLOROUT, 4, FALSE }, { BWRITERSPR_DEPTHOUT, 1, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -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(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, ps_2_0_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in PS 2.0\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_legacy_srcmod(This, src->srcmod); - check_abs_srcmod(This, src->srcmod); + check_legacy_srcmod(parser, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldps_register(src, TRUE); instr->src[num] = reg; } -static const struct allowed_reg_type ps_2_x_reg_allowed[] = { +static const struct allowed_reg_type ps_2_x_reg_allowed[] = +{ { BWRITERSPR_INPUT, 2, FALSE }, { BWRITERSPR_TEMP, 32, FALSE }, { BWRITERSPR_CONST, 32, FALSE }, @@ -932,27 +1011,28 @@ static const struct allowed_reg_type ps_2_x_reg_allowed[] = { { BWRITERSPR_LABEL, 2048, FALSE }, { BWRITERSPR_COLOROUT, 4, FALSE }, { BWRITERSPR_DEPTHOUT, 1, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -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_2_x(struct asm_parser *parser, struct instruction *instr, int num, + const struct shader_reg *src) +{ 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); + if (!check_reg_type(src, ps_2_x_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in PS 2.x\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_legacy_srcmod(This, src->srcmod); - check_abs_srcmod(This, src->srcmod); + check_legacy_srcmod(parser, src->srcmod); + check_abs_srcmod(parser, src->srcmod); reg = map_oldps_register(src, TRUE); instr->src[num] = reg; } -static const struct allowed_reg_type ps_3_reg_allowed[] = { +static const struct allowed_reg_type ps_3_reg_allowed[] = +{ { BWRITERSPR_INPUT, 10, TRUE }, { BWRITERSPR_TEMP, 32, FALSE }, { BWRITERSPR_CONST, 224, FALSE }, @@ -965,182 +1045,188 @@ static const struct allowed_reg_type ps_3_reg_allowed[] = { { BWRITERSPR_LABEL, 2048, FALSE }, { BWRITERSPR_COLOROUT, 4, FALSE }, { BWRITERSPR_DEPTHOUT, 1, FALSE }, - { ~0U, 0 } /* End tag */ + { ~0u, 0 } /* End tag */ }; -static void asmparser_srcreg_ps_3(struct asm_parser *This, - struct instruction *instr, int num, - const struct shader_reg *src) { - 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); +static void asmparser_srcreg_ps_3(struct asm_parser *parser,struct instruction *instr, int num, + const struct shader_reg *src) +{ + if (!check_reg_type(src, ps_3_reg_allowed)) + { + asmparser_message(parser, "Line %u: Source register %s not supported in PS 3.0\n", + parser->line_no, debug_print_srcreg(src)); + set_parse_status(&parser->status, PARSE_ERR); } - check_loop_swizzle(This, src); - check_legacy_srcmod(This, src->srcmod); + check_loop_swizzle(parser, src); + check_legacy_srcmod(parser, src->srcmod); instr->src[num] = *src; } -static void asmparser_dstreg_vs_1(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { +static void asmparser_dstreg_vs_1(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, vs_1_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in VS 1\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_ps_dstmod(This, instr->dstmod); - check_shift_dstmod(This, instr->shift); + check_ps_dstmod(parser, instr->dstmod); + check_shift_dstmod(parser, instr->shift); reg = map_oldvs_register(dst); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_vs_2(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { +static void asmparser_dstreg_vs_2(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, vs_2_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in VS 2.0\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_ps_dstmod(This, instr->dstmod); - check_shift_dstmod(This, instr->shift); + check_ps_dstmod(parser, instr->dstmod); + check_shift_dstmod(parser, instr->shift); reg = map_oldvs_register(dst); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_vs_3(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { - 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); +static void asmparser_dstreg_vs_3(struct asm_parser *parser,struct instruction *instr, + const struct shader_reg *dst) +{ + if (!check_reg_type(dst, vs_3_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in VS 3.0\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_ps_dstmod(This, instr->dstmod); - check_shift_dstmod(This, instr->shift); + check_ps_dstmod(parser, instr->dstmod); + check_shift_dstmod(parser, instr->shift); instr->dst = *dst; instr->has_dst = TRUE; } -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_0123(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, ps_1_0123_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in PS 1\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } reg = map_oldps_register(dst, FALSE); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_ps_1_4(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { +static void asmparser_dstreg_ps_1_4(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, ps_1_4_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in PS 1\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } reg = map_oldps_register(dst, TRUE); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_ps_2(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { +static void asmparser_dstreg_ps_2(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, ps_2_0_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in PS 2.0\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_shift_dstmod(This, instr->shift); + check_shift_dstmod(parser, instr->shift); reg = map_oldps_register(dst, TRUE); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_ps_2_x(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { +static void asmparser_dstreg_ps_2_x(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ 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); + if (!check_reg_type(dst, ps_2_x_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in PS 2.x\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_shift_dstmod(This, instr->shift); + check_shift_dstmod(parser, instr->shift); reg = map_oldps_register(dst, TRUE); instr->dst = reg; instr->has_dst = TRUE; } -static void asmparser_dstreg_ps_3(struct asm_parser *This, - struct instruction *instr, - const struct shader_reg *dst) { - 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); +static void asmparser_dstreg_ps_3(struct asm_parser *parser, struct instruction *instr, + const struct shader_reg *dst) +{ + if (!check_reg_type(dst, ps_3_reg_allowed)) + { + asmparser_message(parser, "Line %u: Destination register %s not supported in PS 3.0\n", + parser->line_no, debug_print_dstreg(dst)); + set_parse_status(&parser->status, PARSE_ERR); } - check_shift_dstmod(This, instr->shift); + check_shift_dstmod(parser, instr->shift); instr->dst = *dst; instr->has_dst = TRUE; } -static void asmparser_predicate_supported(struct asm_parser *This, - const struct shader_reg *predicate) { - /* 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; +static void asmparser_predicate_supported(struct asm_parser *parser, const struct shader_reg *predicate) +{ + if (!parser->shader) + return; + if (parser->shader->num_instrs == 0) + ERR("Predicate without an instruction.\n"); + /* Set the predicate of the last instruction added to the shader. */ + parser->shader->instr[parser->shader->num_instrs - 1]->has_predicate = TRUE; + parser->shader->instr[parser->shader->num_instrs - 1]->predicate = *predicate; } -static void asmparser_predicate_unsupported(struct asm_parser *This, - const struct shader_reg *predicate) { - 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); +static void asmparser_predicate_unsupported(struct asm_parser *parser, const struct shader_reg *predicate) +{ + asmparser_message(parser, "Line %u: Predicate not supported in < VS 2.0 or PS 2.x\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } -static void asmparser_coissue_supported(struct asm_parser *This) { - /* 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); +static void asmparser_coissue_supported(struct asm_parser *parser) +{ + if (!parser->shader) + return; + if (parser->shader->num_instrs == 0) + { + asmparser_message(parser, "Line %u: Coissue flag on the first shader instruction\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } - This->shader->instr[This->shader->num_instrs-1]->coissue = TRUE; + /* Set the coissue flag of the last instruction added to the shader. */ + parser->shader->instr[parser->shader->num_instrs - 1]->coissue = TRUE; } -static void asmparser_coissue_unsupported(struct asm_parser *This) { - 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); +static void asmparser_coissue_unsupported(struct asm_parser *parser) +{ + asmparser_message(parser, "Line %u: Coissue is only supported in pixel shaders versions <= 1.4\n", parser->line_no); + set_parse_status(&parser->status, PARSE_ERR); } static const struct asmparser_backend parser_vs_1 = { @@ -1319,8 +1405,10 @@ static void gen_oldvs_output(struct bwriter_shader *shader) { record_declaration(shader, BWRITERDECLUSAGE_COLOR, 1, 0, TRUE, OD1_REG, BWRITERSP_WRITEMASK_ALL, TRUE); } -static void gen_oldps_input(struct bwriter_shader *shader, DWORD texcoords) { - switch(texcoords) { +static void gen_oldps_input(struct bwriter_shader *shader, uint32_t texcoords) +{ + 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); diff --git a/dlls/d3dcompiler_43/asmshader.y b/dlls/d3dcompiler_43/asmshader.y index ff0f1e3ec9c..00c98b1dbc3 100644 --- a/dlls/d3dcompiler_43/asmshader.y +++ b/dlls/d3dcompiler_43/asmshader.y @@ -54,7 +54,7 @@ static void set_rel_reg(struct shader_reg *reg, struct rel_reg *rel) { return; } reg->rel_reg->type = rel->type; - reg->rel_reg->u.swizzle = rel->swizzle; + reg->rel_reg->swizzle = rel->swizzle; reg->rel_reg->regnum = rel->rel_regnum; } } @@ -75,26 +75,26 @@ int asmshader_lex(void); BOOL immbool; unsigned int regnum; struct shader_reg reg; - DWORD srcmod; - DWORD writemask; + uint32_t srcmod; + uint32_t writemask; struct { - DWORD writemask; - DWORD idx; - DWORD last; + uint32_t writemask; + uint32_t idx; + uint32_t last; } wm_components; - DWORD swizzle; + uint32_t swizzle; struct { - DWORD swizzle; - DWORD idx; + uint32_t swizzle; + uint32_t idx; } sw_components; - DWORD component; + uint32_t component; struct { - DWORD mod; - DWORD shift; + uint32_t mod; + uint32_t shift; } modshift; enum bwriter_comparison_type comptype; struct { - DWORD dclusage; + uint32_t dclusage; unsigned int regnum; } declaration; enum bwritersampler_texture_type samplertype; @@ -569,7 +569,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $3; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = BWRITERSP_WRITEMASK_ALL; + reg.writemask = BWRITERSP_WRITEMASK_ALL; asm_ctx.funcs->dcl_output(&asm_ctx, $2.dclusage, $2.regnum, ®); } | INSTR_DCL dclusage REG_OUTPUT writemask @@ -581,7 +581,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $3; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = $4; + reg.writemask = $4; asm_ctx.funcs->dcl_output(&asm_ctx, $2.dclusage, $2.regnum, ®); } | INSTR_DCL dclusage omods dcl_inputreg @@ -604,7 +604,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $4.regnum; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = BWRITERSP_WRITEMASK_ALL; + reg.writemask = BWRITERSP_WRITEMASK_ALL; asm_ctx.funcs->dcl_input(&asm_ctx, $2.dclusage, $2.regnum, $3.mod, ®); } | INSTR_DCL dclusage omods dcl_inputreg writemask @@ -627,7 +627,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $4.regnum; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = $5; + reg.writemask = $5; asm_ctx.funcs->dcl_input(&asm_ctx, $2.dclusage, $2.regnum, $3.mod, ®); } | INSTR_DCL omods dcl_inputreg @@ -649,7 +649,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $3.regnum; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = BWRITERSP_WRITEMASK_ALL; + reg.writemask = BWRITERSP_WRITEMASK_ALL; asm_ctx.funcs->dcl_input(&asm_ctx, 0, 0, $2.mod, ®); } | INSTR_DCL omods dcl_inputreg writemask @@ -671,7 +671,7 @@ instruction: INSTR_ADD omods dreg ',' sregs reg.regnum = $3.regnum; reg.rel_reg = NULL; reg.srcmod = 0; - reg.u.writemask = $4; + reg.writemask = $4; asm_ctx.funcs->dcl_input(&asm_ctx, 0, 0, $2.mod, ®); } | INSTR_DCL sampdcl omods REG_SAMPLER @@ -988,7 +988,7 @@ dreg: dreg_name rel_reg { $$.regnum = $1.regnum; $$.type = $1.type; - $$.u.writemask = BWRITERSP_WRITEMASK_ALL; + $$.writemask = BWRITERSP_WRITEMASK_ALL; $$.srcmod = BWRITERSPSM_NONE; set_rel_reg(&$$, &$2); } @@ -996,7 +996,7 @@ dreg: dreg_name rel_reg { $$.regnum = $1.regnum; $$.type = $1.type; - $$.u.writemask = $2; + $$.writemask = $2; $$.srcmod = BWRITERSPSM_NONE; $$.rel_reg = NULL; } @@ -1108,7 +1108,7 @@ writemask: '.' wm_components } else { $$ = $2.writemask; - TRACE("Writemask: %lx\n", $$); + TRACE("Writemask: %x\n", $$); } } @@ -1136,7 +1136,7 @@ wm_components: COMPONENT swizzle: /* empty */ { $$ = BWRITERVS_NOSWIZZLE; - TRACE("Default swizzle: %08lx\n", $$); + TRACE("Default swizzle: %08x\n", $$); } | '.' sw_components { @@ -1148,7 +1148,7 @@ swizzle: /* empty */ $$ = BWRITERVS_NOSWIZZLE; } else { - DWORD last, i; + uint32_t last, i; $$ = $2.swizzle; /* Fill the swizzle by extending the last component */ @@ -1156,7 +1156,7 @@ swizzle: /* empty */ for(i = $2.idx; i < 4; i++){ $$ |= last << (2 * i); } - TRACE("Got a swizzle: %08lx\n", $$); + TRACE("Got a swizzle: %08x\n", $$); } } @@ -1262,7 +1262,7 @@ sreg: sreg_name rel_reg swizzle { $$.type = $1.type; $$.regnum = $1.regnum; - $$.u.swizzle = $3; + $$.swizzle = $3; $$.srcmod = BWRITERSPSM_NONE; set_rel_reg(&$$, &$2); } @@ -1272,7 +1272,7 @@ sreg: sreg_name rel_reg swizzle $$.regnum = $1.regnum; set_rel_reg(&$$, &$2); $$.srcmod = $3; - $$.u.swizzle = $4; + $$.swizzle = $4; } | '-' sreg_name rel_reg swizzle { @@ -1280,7 +1280,7 @@ sreg: sreg_name rel_reg swizzle $$.regnum = $2.regnum; $$.srcmod = BWRITERSPSM_NEG; set_rel_reg(&$$, &$3); - $$.u.swizzle = $4; + $$.swizzle = $4; } | '-' sreg_name rel_reg smod swizzle { @@ -1303,9 +1303,9 @@ sreg: sreg_name rel_reg swizzle set_parse_status(&asm_ctx.status, PARSE_ERR); break; default: - FIXME("Unhandled combination of NEGATE and %lu\n", $4); + FIXME("Unhandled combination of NEGATE and %u\n", $4); } - $$.u.swizzle = $5; + $$.swizzle = $5; } | IMMVAL '-' sreg_name rel_reg swizzle { @@ -1319,7 +1319,7 @@ sreg: sreg_name rel_reg swizzle $$.regnum = $3.regnum; $$.srcmod = BWRITERSPSM_COMP; set_rel_reg(&$$, &$4); - $$.u.swizzle = $5; + $$.swizzle = $5; } | IMMVAL '-' sreg_name rel_reg smod swizzle { @@ -1341,7 +1341,7 @@ sreg: sreg_name rel_reg swizzle $$.regnum = $2.regnum; $$.rel_reg = NULL; $$.srcmod = BWRITERSPSM_NOT; - $$.u.swizzle = $3; + $$.swizzle = $3; } rel_reg: /* empty */ @@ -1659,7 +1659,7 @@ predicate: '(' REG_PREDICATE swizzle ')' $$.regnum = 0; $$.rel_reg = NULL; $$.srcmod = BWRITERSPSM_NONE; - $$.u.swizzle = $3; + $$.swizzle = $3; } | '(' SMOD_NOT REG_PREDICATE swizzle ')' { @@ -1667,7 +1667,7 @@ predicate: '(' REG_PREDICATE swizzle ')' $$.regnum = 0; $$.rel_reg = NULL; $$.srcmod = BWRITERSPSM_NOT; - $$.u.swizzle = $4; + $$.swizzle = $4; } %% diff --git a/dlls/d3dcompiler_43/bytecodewriter.c b/dlls/d3dcompiler_43/bytecodewriter.c index 2e5e24ea884..cd4aa4ba11e 100644 --- a/dlls/d3dcompiler_43/bytecodewriter.c +++ b/dlls/d3dcompiler_43/bytecodewriter.c @@ -113,28 +113,34 @@ BOOL add_instruction(struct bwriter_shader *shader, struct instruction *instr) { return TRUE; } -BOOL add_constF(struct bwriter_shader *shader, DWORD reg, float x, float y, float z, float w) { +BOOL add_constF(struct bwriter_shader *shader, uint32_t reg, float x, float y, float z, float w) +{ struct constant *newconst; - if(shader->num_cf) { + if (shader->num_cf) + { struct constant **newarray; - newarray = d3dcompiler_realloc(shader->constF, - sizeof(*shader->constF) * (shader->num_cf + 1)); - if(!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 { + } + else + { shader->constF = d3dcompiler_alloc(sizeof(*shader->constF)); - if(!shader->constF) { + if (!shader->constF) + { ERR("Failed to allocate the constants array\n"); return FALSE; } } newconst = d3dcompiler_alloc(sizeof(*newconst)); - if(!newconst) { + if (!newconst) + { ERR("Failed to allocate a new constant\n"); return FALSE; } @@ -149,28 +155,34 @@ BOOL add_constF(struct bwriter_shader *shader, DWORD reg, float x, float y, floa return TRUE; } -BOOL add_constI(struct bwriter_shader *shader, DWORD reg, INT x, INT y, INT z, INT w) { +BOOL add_constI(struct bwriter_shader *shader, uint32_t reg, int x, int y, int z, int w) +{ struct constant *newconst; - if(shader->num_ci) { + if (shader->num_ci) + { struct constant **newarray; - newarray = d3dcompiler_realloc(shader->constI, - sizeof(*shader->constI) * (shader->num_ci + 1)); - if(!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 { + } + else + { shader->constI = d3dcompiler_alloc(sizeof(*shader->constI)); - if(!shader->constI) { + if (!shader->constI) + { ERR("Failed to allocate the constants array\n"); return FALSE; } } newconst = d3dcompiler_alloc(sizeof(*newconst)); - if(!newconst) { + if (!newconst) + { ERR("Failed to allocate a new constant\n"); return FALSE; } @@ -185,28 +197,34 @@ BOOL add_constI(struct bwriter_shader *shader, DWORD reg, INT x, INT y, INT z, I return TRUE; } -BOOL add_constB(struct bwriter_shader *shader, DWORD reg, BOOL x) { +BOOL add_constB(struct bwriter_shader *shader, uint32_t reg, BOOL x) +{ struct constant *newconst; - if(shader->num_cb) { + if (shader->num_cb) + { struct constant **newarray; - newarray = d3dcompiler_realloc(shader->constB, - sizeof(*shader->constB) * (shader->num_cb + 1)); - if(!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 { + } + else + { shader->constB = d3dcompiler_alloc(sizeof(*shader->constB)); - if(!shader->constB) { + if (!shader->constB) + { ERR("Failed to allocate the constants array\n"); return FALSE; } } newconst = d3dcompiler_alloc(sizeof(*newconst)); - if(!newconst) { + if (!newconst) + { ERR("Failed to allocate a new constant\n"); return FALSE; } @@ -218,41 +236,50 @@ BOOL add_constB(struct bwriter_shader *shader, DWORD reg, BOOL x) { return TRUE; } -BOOL record_declaration(struct bwriter_shader *shader, DWORD usage, - DWORD usage_idx, DWORD mod, BOOL output, - DWORD regnum, DWORD writemask, BOOL builtin) { - unsigned int *num; +BOOL record_declaration(struct bwriter_shader *shader, uint32_t usage, uint32_t usage_idx, + uint32_t mod, BOOL output, uint32_t regnum, uint32_t writemask, BOOL builtin) +{ struct declaration **decl; - unsigned int i; + unsigned int i, *num; - if(!shader) return FALSE; + if (!shader) + return FALSE; - if(output) { + if (output) + { num = &shader->num_outputs; decl = &shader->outputs; - } else { + } + else + { num = &shader->num_inputs; decl = &shader->inputs; } - if(*num == 0) { + if (*num == 0) + { *decl = d3dcompiler_alloc(sizeof(**decl)); - if(!*decl) { + if (!*decl) + { ERR("Error allocating declarations array\n"); return FALSE; } - } else { + } + else + { struct declaration *newdecl; - for(i = 0; i < *num; i++) { - if((*decl)[i].regnum == regnum && ((*decl)[i].writemask & writemask)) { - WARN("Declaration of register %lu already exists, writemask match %#lx.\n", + + 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) { + if (!newdecl) + { ERR("Error reallocating declarations array\n"); return FALSE; } @@ -269,32 +296,38 @@ BOOL record_declaration(struct bwriter_shader *shader, DWORD usage, return TRUE; } -BOOL record_sampler(struct bwriter_shader *shader, DWORD samptype, DWORD mod, DWORD regnum) { +BOOL record_sampler(struct bwriter_shader *shader, uint32_t samptype, uint32_t mod, uint32_t regnum) { unsigned int i; - if(!shader) return FALSE; + if (!shader) + return FALSE; - if(shader->num_samplers == 0) { + if (shader->num_samplers == 0) + { shader->samplers = d3dcompiler_alloc(sizeof(*shader->samplers)); - if(!shader->samplers) { + if (!shader->samplers) + { ERR("Error allocating samplers array\n"); return FALSE; } - } else { + } + else + { struct samplerdecl *newarray; - for(i = 0; i < shader->num_samplers; i++) { - if(shader->samplers[i].regnum == regnum) { - WARN("Sampler %lu already declared.\n", regnum); + 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 - */ + * Direct3D might refuse to load the compiled shader though */ } } - newarray = d3dcompiler_realloc(shader->samplers, - sizeof(*shader->samplers) * (shader->num_samplers + 1)); - if(!newarray) { + newarray = d3dcompiler_realloc(shader->samplers, sizeof(*shader->samplers) * (shader->num_samplers + 1)); + if (!newarray) + { ERR("Error reallocating samplers array\n"); return FALSE; } @@ -310,7 +343,7 @@ BOOL record_sampler(struct bwriter_shader *shader, DWORD samptype, DWORD mod, DW struct bytecode_buffer { - DWORD *data; + uint32_t *data; unsigned int size, alloc_size; HRESULT state; }; @@ -329,13 +362,13 @@ struct bytecode_backend void (*srcreg)(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer); void (*dstreg)(struct bc_writer *writer, const struct shader_reg *reg, - struct bytecode_buffer *buffer, DWORD shift, DWORD mod); + struct bytecode_buffer *buffer, uint32_t shift, uint32_t mod); void (*opcode)(struct bc_writer *writer, const struct instruction *instr, - DWORD token, struct bytecode_buffer *buffer); + uint32_t token, struct bytecode_buffer *buffer); const struct instr_handler_table { - DWORD opcode; + uint32_t opcode; instr_writer func; } *instructions; }; @@ -348,16 +381,16 @@ struct bc_writer HRESULT state; /* Vertex shader varying mapping. */ - DWORD oPos_regnum, oD_regnum[2], oT_regnum[8], oFog_regnum, oFog_mask, oPts_regnum, oPts_mask; + uint32_t oPos_regnum, oD_regnum[2], oT_regnum[8], oFog_regnum, oFog_mask, oPts_regnum, oPts_mask; /* Pixel shader varying mapping. */ - DWORD t_regnum[8], v_regnum[2]; + uint32_t t_regnum[8], v_regnum[2]; }; /* shader bytecode buffer manipulation functions. - * allocate_buffer creates a new buffer structure, put_dword adds a new - * DWORD to the buffer. In the rare case of a memory allocation failure + * allocate_buffer creates a new buffer structure, put_u32 adds a new + * uint32_t to the buffer. In the rare case of a memory allocation failure * when trying to grow the buffer a flag is set in the buffer to mark it * invalid. This avoids return value checking and passing in many places */ @@ -370,8 +403,10 @@ static struct bytecode_buffer *allocate_buffer(void) { return ret; } -static void put_dword(struct bytecode_buffer *buffer, DWORD value) { - if(FAILED(buffer->state)) return; +static void put_u32(struct bytecode_buffer *buffer, uint32_t value) +{ + if (FAILED(buffer->state)) + return; if (!array_reserve((void **)&buffer->data, &buffer->alloc_size, buffer->size + 1, sizeof(*buffer->data))) { @@ -384,7 +419,7 @@ static void put_dword(struct bytecode_buffer *buffer, DWORD value) { /* bwriter -> d3d9 conversion functions. */ -static DWORD sm1_version(const struct bwriter_shader *shader) +static uint32_t sm1_version(const struct bwriter_shader *shader) { switch (shader->type) { @@ -398,9 +433,9 @@ static DWORD sm1_version(const struct bwriter_shader *shader) } } -static DWORD d3d9_swizzle(DWORD bwriter_swizzle) +static uint32_t d3d9_swizzle(uint32_t bwriter_swizzle) { - DWORD ret = 0; + uint32_t ret = 0; if ((bwriter_swizzle & BWRITERVS_X_X) == BWRITERVS_X_X) ret |= D3DVS_X_X; if ((bwriter_swizzle & BWRITERVS_X_Y) == BWRITERVS_X_Y) ret |= D3DVS_X_Y; @@ -425,9 +460,9 @@ static DWORD d3d9_swizzle(DWORD bwriter_swizzle) return ret; } -static DWORD d3d9_writemask(DWORD bwriter_writemask) +static uint32_t d3d9_writemask(uint32_t bwriter_writemask) { - DWORD ret = 0; + uint32_t ret = 0; if (bwriter_writemask & BWRITERSP_WRITEMASK_0) ret |= D3DSP_WRITEMASK_0; if (bwriter_writemask & BWRITERSP_WRITEMASK_1) ret |= D3DSP_WRITEMASK_1; @@ -437,7 +472,7 @@ static DWORD d3d9_writemask(DWORD bwriter_writemask) return ret; } -static DWORD d3d9_srcmod(DWORD bwriter_srcmod) +static uint32_t d3d9_srcmod(uint32_t bwriter_srcmod) { switch (bwriter_srcmod) { @@ -456,14 +491,14 @@ static DWORD d3d9_srcmod(DWORD bwriter_srcmod) case BWRITERSPSM_ABSNEG: return D3DSPSM_ABSNEG; case BWRITERSPSM_NOT: return D3DSPSM_NOT; default: - FIXME("Unhandled BWRITERSPSM token %#lx.\n", bwriter_srcmod); + FIXME("Unhandled BWRITERSPSM token %#x.\n", bwriter_srcmod); return 0; } } -static DWORD d3d9_dstmod(DWORD bwriter_mod) +static uint32_t d3d9_dstmod(uint32_t bwriter_mod) { - DWORD ret = 0; + uint32_t ret = 0; if (bwriter_mod & BWRITERSPDM_SATURATE) ret |= D3DSPDM_SATURATE; if (bwriter_mod & BWRITERSPDM_PARTIALPRECISION) ret |= D3DSPDM_PARTIALPRECISION; @@ -472,7 +507,7 @@ static DWORD d3d9_dstmod(DWORD bwriter_mod) return ret; } -static DWORD d3d9_comparetype(DWORD asmshader_comparetype) +static uint32_t d3d9_comparetype(uint32_t asmshader_comparetype) { switch (asmshader_comparetype) { @@ -483,24 +518,24 @@ static DWORD d3d9_comparetype(DWORD asmshader_comparetype) case BWRITER_COMPARISON_NE: return D3DSPC_NE; case BWRITER_COMPARISON_LE: return D3DSPC_LE; default: - FIXME("Unexpected BWRITER_COMPARISON type %#lx.\n", asmshader_comparetype); + FIXME("Unexpected BWRITER_COMPARISON type %#x.\n", asmshader_comparetype); return 0; } } -static DWORD d3d9_sampler(DWORD bwriter_sampler) +static uint32_t d3d9_sampler(uint32_t bwriter_sampler) { if (bwriter_sampler == BWRITERSTT_UNKNOWN) return D3DSTT_UNKNOWN; if (bwriter_sampler == BWRITERSTT_1D) return D3DSTT_1D; if (bwriter_sampler == BWRITERSTT_2D) return D3DSTT_2D; if (bwriter_sampler == BWRITERSTT_CUBE) return D3DSTT_CUBE; if (bwriter_sampler == BWRITERSTT_VOLUME) return D3DSTT_VOLUME; - FIXME("Unexpected BWRITERSAMPLER_TEXTURE_TYPE type %#lx.\n", bwriter_sampler); + FIXME("Unexpected BWRITERSAMPLER_TEXTURE_TYPE type %#x.\n", bwriter_sampler); return 0; } -static DWORD d3d9_register(DWORD bwriter_register) +static uint32_t d3d9_register(uint32_t bwriter_register) { if (bwriter_register == BWRITERSPR_TEMP) return D3DSPR_TEMP; if (bwriter_register == BWRITERSPR_INPUT) return D3DSPR_INPUT; @@ -521,11 +556,11 @@ static DWORD d3d9_register(DWORD bwriter_register) if (bwriter_register == BWRITERSPR_LABEL) return D3DSPR_LABEL; if (bwriter_register == BWRITERSPR_PREDICATE) return D3DSPR_PREDICATE; - FIXME("Unexpected BWRITERSPR %#lx.\n", bwriter_register); + FIXME("Unexpected BWRITERSPR %#x.\n", bwriter_register); return ~0U; } -static DWORD d3d9_opcode(DWORD bwriter_opcode) +static uint32_t d3d9_opcode(uint32_t bwriter_opcode) { switch (bwriter_opcode) { @@ -620,12 +655,12 @@ static DWORD d3d9_opcode(DWORD bwriter_opcode) case BWRITERSIO_TEXLDB: return D3DSIO_TEX | D3DSI_TEXLD_BIAS; default: - FIXME("Unhandled BWRITERSIO token %#lx.\n", bwriter_opcode); + FIXME("Unhandled BWRITERSIO token %#x.\n", bwriter_opcode); return ~0U; } } -static DWORD d3dsp_register( D3DSHADER_PARAM_REGISTER_TYPE type, DWORD num ) +static uint32_t d3dsp_register(D3DSHADER_PARAM_REGISTER_TYPE type, uint32_t num) { return ((type << D3DSP_REGTYPE_SHIFT) & D3DSP_REGTYPE_MASK) | ((type << D3DSP_REGTYPE_SHIFT2) & D3DSP_REGTYPE_MASK2) | @@ -635,43 +670,44 @@ static DWORD d3dsp_register( D3DSHADER_PARAM_REGISTER_TYPE type, DWORD num ) /****************************************************** * Implementation of the writer functions starts here * ******************************************************/ -static void write_declarations(struct bc_writer *This, struct bytecode_buffer *buffer, - const struct declaration *decls, unsigned int num, DWORD type) +static void write_declarations(struct bc_writer *writer, struct bytecode_buffer *buffer, + const struct declaration *decls, unsigned int num, uint32_t type) { - DWORD i; - DWORD instr_dcl = D3DSIO_DCL; - DWORD token; + uint32_t instr_dcl = D3DSIO_DCL; + uint32_t token; + unsigned int i; struct shader_reg reg; ZeroMemory(®, sizeof(reg)); - if (This->shader->major_version > 1) + if (writer->shader->major_version > 1) instr_dcl |= 2 << D3DSI_INSTLENGTH_SHIFT; for(i = 0; i < num; i++) { if(decls[i].builtin) continue; /* Write the DCL instruction */ - put_dword(buffer, instr_dcl); + put_u32(buffer, instr_dcl); /* Write the usage and index */ token = (1u << 31); /* Bit 31 of non-instruction opcodes is 1 */ token |= (decls[i].usage << D3DSP_DCL_USAGE_SHIFT) & D3DSP_DCL_USAGE_MASK; token |= (decls[i].usage_idx << D3DSP_DCL_USAGEINDEX_SHIFT) & D3DSP_DCL_USAGEINDEX_MASK; - put_dword(buffer, token); + put_u32(buffer, token); /* Write the dest register */ reg.type = type; reg.regnum = decls[i].regnum; - reg.u.writemask = decls[i].writemask; - This->funcs->dstreg(This, ®, buffer, 0, decls[i].mod); + reg.writemask = decls[i].writemask; + writer->funcs->dstreg(writer, ®, buffer, 0, decls[i].mod); } } -static void write_const(struct constant **consts, int num, DWORD opcode, DWORD reg_type, struct bytecode_buffer *buffer, BOOL len) { - int i; - DWORD instr_def = opcode; - const DWORD reg = (1u << 31) | d3dsp_register( reg_type, 0 ) | D3DSP_WRITEMASK_ALL; +static void write_const(struct constant **consts, int num, uint32_t opcode, uint32_t reg_type, struct bytecode_buffer *buffer, BOOL len) +{ + const uint32_t reg = (1u << 31) | d3dsp_register( reg_type, 0 ) | D3DSP_WRITEMASK_ALL; + uint32_t instr_def = opcode; + unsigned int i; if(len) { if(opcode == D3DSIO_DEFB) @@ -682,14 +718,14 @@ static void write_const(struct constant **consts, int num, DWORD opcode, DWORD r for(i = 0; i < num; i++) { /* Write the DEF instruction */ - put_dword(buffer, instr_def); + put_u32(buffer, instr_def); - put_dword(buffer, reg | (consts[i]->regnum & D3DSP_REGNUM_MASK)); - put_dword(buffer, consts[i]->value[0].d); + put_u32(buffer, reg | (consts[i]->regnum & D3DSP_REGNUM_MASK)); + put_u32(buffer, consts[i]->value[0].d); if(opcode != D3DSIO_DEFB) { - put_dword(buffer, consts[i]->value[1].d); - put_dword(buffer, consts[i]->value[2].d); - put_dword(buffer, consts[i]->value[3].d); + put_u32(buffer, consts[i]->value[1].d); + put_u32(buffer, consts[i]->value[2].d); + put_u32(buffer, consts[i]->value[3].d); } } } @@ -699,85 +735,97 @@ static void write_constF(const struct bwriter_shader *shader, struct bytecode_bu } /* This function looks for VS 1/2 registers mapping to VS 3 output registers */ -static HRESULT vs_find_builtin_varyings(struct bc_writer *This, const struct bwriter_shader *shader) { - DWORD i; - DWORD usage, usage_idx, writemask, regnum; +static HRESULT vs_find_builtin_varyings(struct bc_writer *writer, const struct bwriter_shader *shader) +{ + uint32_t usage, usage_idx, writemask, regnum; + unsigned int i; - for(i = 0; i < shader->num_outputs; i++) { - if(!shader->outputs[i].builtin) continue; + for (i = 0; i < shader->num_outputs; i++) + { + if (!shader->outputs[i].builtin) + continue; usage = shader->outputs[i].usage; usage_idx = shader->outputs[i].usage_idx; writemask = shader->outputs[i].writemask; regnum = shader->outputs[i].regnum; - switch(usage) { + switch (usage) + { case BWRITERDECLUSAGE_POSITION: case BWRITERDECLUSAGE_POSITIONT: - if(usage_idx > 0) { - WARN("dcl_position%lu not supported in sm 1/2 shaders.\n", usage_idx); + if (usage_idx > 0) + { + WARN("dcl_position%u not supported in sm 1/2 shaders.\n", usage_idx); return E_INVALIDARG; } - TRACE("o%lu is oPos.\n", regnum); - This->oPos_regnum = regnum; + TRACE("o%u is oPos.\n", regnum); + writer->oPos_regnum = regnum; break; case BWRITERDECLUSAGE_COLOR: - if(usage_idx > 1) { - WARN("dcl_color%lu not supported in sm 1/2 shaders.\n", usage_idx); + if (usage_idx > 1) + { + WARN("dcl_color%u not supported in sm 1/2 shaders.\n", usage_idx); return E_INVALIDARG; } - if(writemask != BWRITERSP_WRITEMASK_ALL) { + if (writemask != BWRITERSP_WRITEMASK_ALL) + { WARN("Only WRITEMASK_ALL is supported on color in sm 1/2\n"); return E_INVALIDARG; } - TRACE("o%lu is oD%lu.\n", regnum, usage_idx); - This->oD_regnum[usage_idx] = regnum; + TRACE("o%u is oD%u.\n", regnum, usage_idx); + writer->oD_regnum[usage_idx] = regnum; break; case BWRITERDECLUSAGE_TEXCOORD: - if(usage_idx >= 8) { - WARN("dcl_color%lu not supported in sm 1/2 shaders.\n", usage_idx); + if (usage_idx >= 8) + { + WARN("dcl_color%u not supported in sm 1/2 shaders.\n", usage_idx); return E_INVALIDARG; } - if(writemask != (BWRITERSP_WRITEMASK_0) && - writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1) && - writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1 | BWRITERSP_WRITEMASK_2) && - writemask != (BWRITERSP_WRITEMASK_ALL)) { + if (writemask != (BWRITERSP_WRITEMASK_0) + && writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1) + && writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1 | BWRITERSP_WRITEMASK_2) + && writemask != (BWRITERSP_WRITEMASK_ALL)) + { WARN("Partial writemasks not supported on texture coordinates in sm 1 and 2\n"); return E_INVALIDARG; } - TRACE("o%lu is oT%lu.\n", regnum, usage_idx); - This->oT_regnum[usage_idx] = regnum; + TRACE("o%u is oT%u.\n", regnum, usage_idx); + writer->oT_regnum[usage_idx] = regnum; break; case BWRITERDECLUSAGE_PSIZE: - if(usage_idx > 0) { - WARN("dcl_psize%lu not supported in sm 1/2 shaders.\n", usage_idx); + if (usage_idx > 0) + { + WARN("dcl_psize%u not supported in sm 1/2 shaders.\n", usage_idx); return E_INVALIDARG; } - TRACE("o%lu writemask 0x%08lx is oPts.\n", regnum, writemask); - This->oPts_regnum = regnum; - This->oPts_mask = writemask; + TRACE("o%u writemask 0x%08x is oPts.\n", regnum, writemask); + writer->oPts_regnum = regnum; + writer->oPts_mask = writemask; break; case BWRITERDECLUSAGE_FOG: - if(usage_idx > 0) { - WARN("dcl_fog%lu not supported in sm 1 shaders.\n", usage_idx); + if (usage_idx > 0) + { + WARN("dcl_fog%u not supported in sm 1 shaders.\n", usage_idx); return E_INVALIDARG; } - if(writemask != BWRITERSP_WRITEMASK_0 && writemask != BWRITERSP_WRITEMASK_1 && - writemask != BWRITERSP_WRITEMASK_2 && writemask != BWRITERSP_WRITEMASK_3) { + if (writemask != BWRITERSP_WRITEMASK_0 && writemask != BWRITERSP_WRITEMASK_1 + && writemask != BWRITERSP_WRITEMASK_2 && writemask != BWRITERSP_WRITEMASK_3) + { WARN("Unsupported fog writemask\n"); return E_INVALIDARG; } - TRACE("o%lu writemask 0x%08lx is oFog.\n", regnum, writemask); - This->oFog_regnum = regnum; - This->oFog_mask = writemask; + TRACE("o%u writemask 0x%08x is oFog.\n", regnum, writemask); + writer->oFog_regnum = regnum; + writer->oFog_mask = writemask; break; default: - WARN("Varying type %lu is not supported in shader model 1.x.\n", usage); + WARN("Varying type %u is not supported in shader model 1.x.\n", usage); return E_INVALIDARG; } } @@ -805,56 +853,63 @@ static void vs_1_x_header(struct bc_writer *This, const struct bwriter_shader *s write_constF(shader, buffer, FALSE); } -static HRESULT find_ps_builtin_semantics(struct bc_writer *This, - const struct bwriter_shader *shader, - DWORD texcoords) { - DWORD i; - DWORD usage, usage_idx, writemask, regnum; +static HRESULT find_ps_builtin_semantics(struct bc_writer *writer, const struct bwriter_shader *shader, + uint32_t texcoords) +{ + uint32_t usage, usage_idx, writemask, regnum; + unsigned int i; - This->v_regnum[0] = -1; This->v_regnum[1] = -1; - for(i = 0; i < 8; i++) This->t_regnum[i] = -1; + writer->v_regnum[0] = -1; + writer->v_regnum[1] = -1; + for (i = 0; i < 8; i++) + writer->t_regnum[i] = -1; - for(i = 0; i < shader->num_inputs; i++) { - if(!shader->inputs[i].builtin) continue; + for (i = 0; i < shader->num_inputs; i++) + { + if (!shader->inputs[i].builtin) + continue; usage = shader->inputs[i].usage; usage_idx = shader->inputs[i].usage_idx; writemask = shader->inputs[i].writemask; regnum = shader->inputs[i].regnum; - switch(usage) { + switch (usage) + { case BWRITERDECLUSAGE_COLOR: - if(usage_idx > 1) { - WARN("dcl_color%lu not supported in sm 1 shaders\n", usage_idx); + if (usage_idx > 1) + { + WARN("dcl_color%u not supported in sm 1 shaders\n", usage_idx); return E_INVALIDARG; } - if(writemask != BWRITERSP_WRITEMASK_ALL) { + if (writemask != BWRITERSP_WRITEMASK_ALL) + { WARN("Only WRITEMASK_ALL is supported on color in sm 1\n"); return E_INVALIDARG; } - TRACE("v%lu is v%lu\n", regnum, usage_idx); - This->v_regnum[usage_idx] = regnum; + TRACE("v%u is v%u\n", regnum, usage_idx); + writer->v_regnum[usage_idx] = regnum; break; case BWRITERDECLUSAGE_TEXCOORD: - if(usage_idx > texcoords) { - WARN("dcl_texcoord%lu not supported in this shader version\n", usage_idx); + if (usage_idx > texcoords) + { + WARN("dcl_texcoord%u not supported in this shader version\n", usage_idx); return E_INVALIDARG; } - if(writemask != (BWRITERSP_WRITEMASK_0) && - writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1) && - writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1 | BWRITERSP_WRITEMASK_2) && - writemask != (BWRITERSP_WRITEMASK_ALL)) { + if (writemask != (BWRITERSP_WRITEMASK_0) + && writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1) + && writemask != (BWRITERSP_WRITEMASK_0 | BWRITERSP_WRITEMASK_1 | BWRITERSP_WRITEMASK_2) + && writemask != (BWRITERSP_WRITEMASK_ALL)) WARN("Partial writemasks not supported on texture coordinates in sm 1 and 2\n"); - } else { + else writemask = BWRITERSP_WRITEMASK_ALL; - } - TRACE("v%lu is t%lu\n", regnum, usage_idx); - This->t_regnum[usage_idx] = regnum; + TRACE("v%u is t%u\n", regnum, usage_idx); + writer->t_regnum[usage_idx] = regnum; break; default: - WARN("Varying type %lu is not supported in shader model 1.x\n", usage); + WARN("Varying type %u is not supported in shader model 1.x\n", usage); return E_INVALIDARG; } } @@ -901,59 +956,66 @@ static void ps_1_4_header(struct bc_writer *This, const struct bwriter_shader *s write_constF(shader, buffer, FALSE); } -static void end(struct bc_writer *This, const struct bwriter_shader *shader, struct bytecode_buffer *buffer) { - put_dword(buffer, D3DSIO_END); +static void end(struct bc_writer *writer, const struct bwriter_shader *shader, struct bytecode_buffer *buffer) +{ + put_u32(buffer, D3DSIO_END); } -static DWORD map_vs_output(struct bc_writer *This, DWORD regnum, DWORD mask, DWORD *has_components) { - DWORD i; +static uint32_t map_vs_output(struct bc_writer *writer, uint32_t regnum, uint32_t mask, BOOL *has_components) +{ + unsigned int i; *has_components = TRUE; - if(regnum == This->oPos_regnum) { + if (regnum == writer->oPos_regnum) + { return d3dsp_register( D3DSPR_RASTOUT, D3DSRO_POSITION ); } - if(regnum == This->oFog_regnum && mask == This->oFog_mask) { + if (regnum == writer->oFog_regnum && mask == writer->oFog_mask) + { *has_components = FALSE; return d3dsp_register( D3DSPR_RASTOUT, D3DSRO_FOG ) | D3DSP_WRITEMASK_ALL; } - if(regnum == This->oPts_regnum && mask == This->oPts_mask) { + if (regnum == writer->oPts_regnum && mask == writer->oPts_mask) + { *has_components = FALSE; return d3dsp_register( D3DSPR_RASTOUT, D3DSRO_POINT_SIZE ) | D3DSP_WRITEMASK_ALL; } - for(i = 0; i < 2; i++) { - if(regnum == This->oD_regnum[i]) { + for (i = 0; i < 2; i++) + { + if (regnum == writer->oD_regnum[i]) return d3dsp_register( D3DSPR_ATTROUT, i ); - } } - for(i = 0; i < 8; i++) { - if(regnum == This->oT_regnum[i]) { + for (i = 0; i < 8; i++) + { + if (regnum == writer->oT_regnum[i]) return d3dsp_register( D3DSPR_TEXCRDOUT, i ); - } } /* The varying must be undeclared - if an unsupported varying was declared, * the vs_find_builtin_varyings function would have caught it and this code * would not run */ - WARN("Undeclared varying %lu.\n", regnum); - This->state = E_INVALIDARG; + WARN("Undeclared varying %u.\n", regnum); + writer->state = E_INVALIDARG; return -1; } -static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer, - DWORD shift, DWORD mod) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD has_wmask; +static void vs_12_dstreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer, + uint32_t shift, uint32_t mod) +{ + uint32_t token = (1u << 31); /* Bit 31 of registers is 1 */ + BOOL has_wmask; - if(reg->rel_reg) { + if (reg->rel_reg) + { WARN("Relative addressing not supported for destination registers\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_OUTPUT: - token |= map_vs_output(This, reg->regnum, reg->u.writemask, &has_wmask); + token |= map_vs_output(writer, reg->regnum, reg->writemask, &has_wmask); break; case BWRITERSPR_RASTOUT: @@ -961,7 +1023,7 @@ static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, /* These registers are mapped to input and output regs. They can be encoded in the bytecode, * but are unexpected. If we hit this path it might be due to an error. */ - FIXME("Unexpected register type %lu.\n", reg->type); + FIXME("Unexpected register type %u.\n", reg->type); /* drop through */ case BWRITERSPR_INPUT: case BWRITERSPR_TEMP: @@ -971,9 +1033,10 @@ static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, break; case BWRITERSPR_ADDR: - if(reg->regnum != 0) { + if (reg->regnum != 0) + { WARN("Only a0 exists\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= d3dsp_register( D3DSPR_ADDR, 0 ); @@ -981,15 +1044,16 @@ static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, break; case BWRITERSPR_PREDICATE: - if (This->shader->major_version != 2 || This->shader->minor_version != 1) + if (writer->shader->major_version != 2 || writer->shader->minor_version != 1) { WARN("Predicate register is allowed only in vs_2_x\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - if(reg->regnum != 0) { + if (reg->regnum != 0) + { WARN("Only predicate register p0 exists\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= d3dsp_register( D3DSPR_PREDICATE, 0 ); @@ -998,7 +1062,7 @@ static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, default: WARN("Invalid register type for 1.x-2.x vertex shader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } @@ -1009,24 +1073,24 @@ static void vs_12_dstreg(struct bc_writer *This, const struct shader_reg *reg, token |= (shift << D3DSP_DSTSHIFT_SHIFT) & D3DSP_DSTSHIFT_MASK; token |= d3d9_dstmod(mod); - if(has_wmask) { - token |= d3d9_writemask(reg->u.writemask); - } - put_dword(buffer, token); + if (has_wmask) + token |= d3d9_writemask(reg->writemask); + put_u32(buffer, token); } -static void vs_1_x_srcreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD has_swizzle; - DWORD component; +static void vs_1_x_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + uint32_t token = (1u << 31); /* Bit 31 of registers is 1 */ + uint32_t component; + BOOL has_swizzle; - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_OUTPUT: - /* Map the swizzle to a writemask, the format expected - by map_vs_output - */ - switch(reg->u.swizzle) { + /* Map the swizzle to a writemask, the format expected by + * map_vs_output */ + switch (reg->swizzle) + { case BWRITERVS_SWIZZLE_X: component = BWRITERSP_WRITEMASK_0; break; @@ -1042,27 +1106,28 @@ static void vs_1_x_srcreg(struct bc_writer *This, const struct shader_reg *reg, default: component = 0; } - token |= map_vs_output(This, reg->regnum, component, &has_swizzle); + token |= map_vs_output(writer, reg->regnum, component, &has_swizzle); break; case BWRITERSPR_RASTOUT: case BWRITERSPR_ATTROUT: - /* These registers are mapped to input and output regs. They can be encoded in the bytecode, - * but are unexpected. If we hit this path it might be due to an error. - */ - FIXME("Unexpected register type %lu.\n", reg->type); + /* These registers are mapped to input and output regs. They can + * be encoded in the bytecode, but are unexpected. If we hit this + * path it might be due to an error. */ + FIXME("Unexpected register type %u.\n", reg->type); /* drop through */ case BWRITERSPR_INPUT: case BWRITERSPR_TEMP: case BWRITERSPR_CONST: case BWRITERSPR_ADDR: - token |= d3dsp_register( reg->type, reg->regnum ); - if(reg->rel_reg) { - if(reg->rel_reg->type != BWRITERSPR_ADDR || - reg->rel_reg->regnum != 0 || - reg->rel_reg->u.swizzle != BWRITERVS_SWIZZLE_X) { + token |= d3dsp_register(reg->type, reg->regnum); + if (reg->rel_reg) + { + if (reg->rel_reg->type != BWRITERSPR_ADDR || reg->rel_reg->regnum != 0 + || reg->rel_reg->swizzle != BWRITERVS_SWIZZLE_X) + { WARN("Relative addressing in vs_1_x is only allowed with a0.x\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= D3DVS_ADDRMODE_RELATIVE & D3DVS_ADDRESSMODE_MASK; @@ -1071,73 +1136,76 @@ static void vs_1_x_srcreg(struct bc_writer *This, const struct shader_reg *reg, default: WARN("Invalid register type for 1.x vshader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ token |= d3d9_srcmod(reg->srcmod); - put_dword(buffer, token); + put_u32(buffer, token); } -static void write_srcregs(struct bc_writer *This, const struct instruction *instr, - struct bytecode_buffer *buffer){ +static void write_srcregs(struct bc_writer *writer, const struct instruction *instr, struct bytecode_buffer *buffer) +{ unsigned int i; - if(instr->has_predicate){ - This->funcs->srcreg(This, &instr->predicate, buffer); - } - for(i = 0; i < instr->num_srcs; i++){ - This->funcs->srcreg(This, &instr->src[i], buffer); - } + + if (instr->has_predicate) + writer->funcs->srcreg(writer, &instr->predicate, buffer); + + for (i = 0; i < instr->num_srcs; ++i) + writer->funcs->srcreg(writer, &instr->src[i], buffer); } -static DWORD map_ps13_temp(struct bc_writer *This, const struct shader_reg *reg) { - if(reg->regnum == T0_REG) { - return d3dsp_register( D3DSPR_TEXTURE, 0 ); - } else if(reg->regnum == T1_REG) { - return d3dsp_register( D3DSPR_TEXTURE, 1 ); - } else if(reg->regnum == T2_REG) { - return d3dsp_register( D3DSPR_TEXTURE, 2 ); - } else if(reg->regnum == T3_REG) { - return d3dsp_register( D3DSPR_TEXTURE, 3 ); - } else { - return d3dsp_register( D3DSPR_TEMP, reg->regnum ); - } +static uint32_t map_ps13_temp(struct bc_writer *writer, const struct shader_reg *reg) +{ + if (reg->regnum == T0_REG) + return d3dsp_register(D3DSPR_TEXTURE, 0); + if (reg->regnum == T1_REG) + return d3dsp_register(D3DSPR_TEXTURE, 1); + if(reg->regnum == T2_REG) + return d3dsp_register(D3DSPR_TEXTURE, 2); + if (reg->regnum == T3_REG) + return d3dsp_register(D3DSPR_TEXTURE, 3); + return d3dsp_register(D3DSPR_TEMP, reg->regnum); } -static DWORD map_ps_input(struct bc_writer *This, - const struct shader_reg *reg) { - DWORD i; +static uint32_t map_ps_input(struct bc_writer *writer, const struct shader_reg *reg) +{ + unsigned int i; + /* Map color interpolators */ - for(i = 0; i < 2; i++) { - if(reg->regnum == This->v_regnum[i]) { - return d3dsp_register( D3DSPR_INPUT, i ); - } + for (i = 0; i < ARRAY_SIZE(writer->v_regnum); ++i) + { + if (reg->regnum == writer->v_regnum[i]) + return d3dsp_register(D3DSPR_INPUT, i); } - for(i = 0; i < 8; i++) { - if(reg->regnum == This->t_regnum[i]) { - return d3dsp_register( D3DSPR_TEXTURE, i ); - } + for (i = 0; i < ARRAY_SIZE(writer->t_regnum); ++i) + { + if(reg->regnum == writer->t_regnum[i]) + return d3dsp_register(D3DSPR_TEXTURE, i); } WARN("Invalid ps 1/2 varying\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return 0; } -static void ps_1_0123_srcreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - if(reg->rel_reg) { +static void ps_1_0123_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + uint32_t token = 1u << 31; + + if (reg->rel_reg) + { WARN("Relative addressing not supported in <= ps_3_0\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; /* Take care about the texture temporaries. There's a problem: They aren't @@ -1145,7 +1213,7 @@ static void ps_1_0123_srcreg(struct bc_writer *This, const struct shader_reg *re * to map ps_1_3 shaders to the common shader structure */ case BWRITERSPR_TEMP: - token |= map_ps13_temp(This, reg); + token |= map_ps13_temp(writer, reg); break; case BWRITERSPR_CONST: /* Can be mapped 1:1 */ @@ -1154,92 +1222,93 @@ static void ps_1_0123_srcreg(struct bc_writer *This, const struct shader_reg *re default: WARN("Invalid register type for <= ps_1_3 shader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ - if(reg->srcmod == BWRITERSPSM_DZ || reg->srcmod == BWRITERSPSM_DW || - reg->srcmod == BWRITERSPSM_ABS || reg->srcmod == BWRITERSPSM_ABSNEG || - reg->srcmod == BWRITERSPSM_NOT) { - WARN("Invalid source modifier %lu for <= ps_1_3.\n", reg->srcmod); - This->state = E_INVALIDARG; + if(reg->srcmod == BWRITERSPSM_DZ || reg->srcmod == BWRITERSPSM_DW + || reg->srcmod == BWRITERSPSM_ABS || reg->srcmod == BWRITERSPSM_ABSNEG + || reg->srcmod == BWRITERSPSM_NOT) + { + WARN("Invalid source modifier %u for <= ps_1_3\n", reg->srcmod); + writer->state = E_INVALIDARG; return; } token |= d3d9_srcmod(reg->srcmod); - put_dword(buffer, token); + put_u32(buffer, token); } -static void ps_1_0123_dstreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer, - DWORD shift, DWORD mod) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ +static void ps_1_0123_dstreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer, + uint32_t shift, uint32_t mod) +{ + uint32_t token = (1u << 31); /* Bit 31 of registers is 1 */ - if(reg->rel_reg) { + if (reg->rel_reg) + { WARN("Relative addressing not supported for destination registers\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_TEMP: - token |= map_ps13_temp(This, reg); + token |= map_ps13_temp(writer, reg); break; /* texkill uses the input register as a destination parameter */ case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; default: WARN("Invalid dest register type for 1.x pshader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= (shift << D3DSP_DSTSHIFT_SHIFT) & D3DSP_DSTSHIFT_MASK; token |= d3d9_dstmod(mod); - token |= d3d9_writemask(reg->u.writemask); - put_dword(buffer, token); + token |= d3d9_writemask(reg->writemask); + put_u32(buffer, token); } /* The length of an instruction consists of the destination register (if any), * the number of source registers, the number of address registers used for - * indirect addressing, and optionally the predicate register - */ -static DWORD instrlen(const struct instruction *instr, unsigned int srcs, unsigned int dsts) { + * indirect addressing, and optionally the predicate register */ +static unsigned int instrlen(const struct instruction *instr, unsigned int srcs, unsigned int dsts) +{ + unsigned int ret = srcs + dsts + (instr->has_predicate ? 1 : 0); unsigned int i; - DWORD ret = srcs + dsts + (instr->has_predicate ? 1 : 0); - if(dsts){ - if(instr->dst.rel_reg) ret++; - } - for(i = 0; i < srcs; i++) { - if(instr->src[i].rel_reg) ret++; - } + if (dsts && instr->dst.rel_reg) + ++ret; + for (i = 0; i < srcs; ++i) + if (instr->src[i].rel_reg) + ++ret; return ret; } -static void sm_1_x_opcode(struct bc_writer *This, - const struct instruction *instr, - DWORD token, struct bytecode_buffer *buffer) { - /* In sm_1_x instruction length isn't encoded */ - if(instr->coissue){ +static void sm_1_x_opcode(struct bc_writer *writer, const struct instruction *instr, uint32_t token, + struct bytecode_buffer *buffer) +{ + /* Instruction length isn't encoded in sm_1_x. */ + if (instr->coissue) token |= D3DSI_COISSUE; - } - put_dword(buffer, token); + put_u32(buffer, token); } -static void instr_handler(struct bc_writer *This, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - DWORD token = d3d9_opcode(instr->opcode); +static void instr_handler(struct bc_writer *writer, const struct instruction *instr, struct bytecode_buffer *buffer) +{ + uint32_t token = d3d9_opcode(instr->opcode); - This->funcs->opcode(This, instr, token, buffer); - if(instr->has_dst) This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); - write_srcregs(This, instr, buffer); + writer->funcs->opcode(writer, instr, token, buffer); + if (instr->has_dst) + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); + write_srcregs(writer, instr, buffer); } static const struct instr_handler_table vs_1_x_handlers[] = { @@ -1283,113 +1352,131 @@ static const struct bytecode_backend vs_1_x_backend = { vs_1_x_handlers }; -static void instr_ps_1_0123_texld(struct bc_writer *This, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - DWORD idx; +static void instr_ps_1_0123_texld(struct bc_writer *writer, const struct instruction *instr, + struct bytecode_buffer *buffer) +{ struct shader_reg reg; - DWORD swizzlemask; + uint32_t swizzlemask; + uint32_t idx; - if(instr->src[1].type != BWRITERSPR_SAMPLER || - instr->src[1].regnum > 3) { - WARN("Unsupported sampler type %lu regnum %lu.\n", - instr->src[1].type, instr->src[1].regnum); - This->state = E_INVALIDARG; + if (instr->src[1].type != BWRITERSPR_SAMPLER || instr->src[1].regnum > 3) + { + WARN("Unsupported sampler type %u regnum %u.\n", instr->src[1].type, instr->src[1].regnum); + writer->state = E_INVALIDARG; return; - } else if(instr->dst.type != BWRITERSPR_TEMP) { + } + else if (instr->dst.type != BWRITERSPR_TEMP) + { WARN("Can only sample into a temp register\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } idx = instr->src[1].regnum; - if((idx == 0 && instr->dst.regnum != T0_REG) || - (idx == 1 && instr->dst.regnum != T1_REG) || - (idx == 2 && instr->dst.regnum != T2_REG) || - (idx == 3 && instr->dst.regnum != T3_REG)) { - WARN("Sampling from sampler s%lu to register r%lu is not possible in ps_1_x.\n", - idx, instr->dst.regnum); - This->state = E_INVALIDARG; + if ((idx == 0 && instr->dst.regnum != T0_REG) || (idx == 1 && instr->dst.regnum != T1_REG) + || (idx == 2 && instr->dst.regnum != T2_REG) || (idx == 3 && instr->dst.regnum != T3_REG)) + { + WARN("Sampling from sampler s%u to register r%u is not possible in ps_1_x\n", idx, instr->dst.regnum); + writer->state = E_INVALIDARG; return; } - if(instr->src[0].type == BWRITERSPR_INPUT) { + if (instr->src[0].type == BWRITERSPR_INPUT) + { /* A simple non-dependent read tex instruction */ - if(instr->src[0].regnum != This->t_regnum[idx]) { - WARN("Cannot sample from s%lu with texture address data from interpolator %lu.\n", - idx, instr->src[0].regnum); - This->state = E_INVALIDARG; + if (instr->src[0].regnum != writer->t_regnum[idx]) + { + WARN("Cannot sample from s%u with texture address data from interpolator %u\n", idx, instr->src[0].regnum); + writer->state = E_INVALIDARG; return; } - This->funcs->opcode(This, instr, D3DSIO_TEX & D3DSI_OPCODE_MASK, buffer); + writer->funcs->opcode(writer, instr, D3DSIO_TEX & D3DSI_OPCODE_MASK, buffer); /* map the temp dstreg to the ps_1_3 texture temporary register */ - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); - } else if(instr->src[0].type == BWRITERSPR_TEMP) { - + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); + } + else if (instr->src[0].type == BWRITERSPR_TEMP) + { swizzlemask = 3 | (3 << 2) | (3 << 4); - if((instr->src[0].u.swizzle & swizzlemask) == (BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z)) { + if ((instr->src[0].swizzle & swizzlemask) == (BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z)) + { TRACE("writing texreg2rgb\n"); - This->funcs->opcode(This, instr, D3DSIO_TEXREG2RGB & D3DSI_OPCODE_MASK, buffer); - } else if(instr->src[0].u.swizzle == (BWRITERVS_X_W | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X)) { + writer->funcs->opcode(writer, instr, D3DSIO_TEXREG2RGB & D3DSI_OPCODE_MASK, buffer); + } + else if (instr->src[0].swizzle == (BWRITERVS_X_W | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X)) + { TRACE("writing texreg2ar\n"); - This->funcs->opcode(This, instr, D3DSIO_TEXREG2AR & D3DSI_OPCODE_MASK, buffer); - } else if(instr->src[0].u.swizzle == (BWRITERVS_X_Y | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z)) { + writer->funcs->opcode(writer, instr, D3DSIO_TEXREG2AR & D3DSI_OPCODE_MASK, buffer); + } + else if (instr->src[0].swizzle == (BWRITERVS_X_Y | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z)) + { TRACE("writing texreg2gb\n"); - This->funcs->opcode(This, instr, D3DSIO_TEXREG2GB & D3DSI_OPCODE_MASK, buffer); - } else { - WARN("Unsupported src addr swizzle in dependent texld: 0x%08lx.\n", instr->src[0].u.swizzle); - This->state = E_INVALIDARG; + writer->funcs->opcode(writer, instr, D3DSIO_TEXREG2GB & D3DSI_OPCODE_MASK, buffer); + } + else + { + WARN("Unsupported src addr swizzle in dependent texld: 0x%08x\n", instr->src[0].swizzle); + writer->state = E_INVALIDARG; return; } - /* Dst and src reg can be mapped normally. Both registers are temporary registers in the - * source shader and have to be mapped to the temporary form of the texture registers. However, - * the src reg doesn't have a swizzle - */ - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); + /* Dst and src reg can be mapped normally. Both registers are + * temporary registers in the source shader and have to be mapped to + * the temporary form of the texture registers. However, the src reg + * doesn't have a swizzle. */ + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); reg = instr->src[0]; - reg.u.swizzle = BWRITERVS_NOSWIZZLE; - This->funcs->srcreg(This, ®, buffer); - } else { + reg.swizzle = BWRITERVS_NOSWIZZLE; + writer->funcs->srcreg(writer, ®, buffer); + } + else + { WARN("Invalid address data source register\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } } -static void instr_ps_1_0123_mov(struct bc_writer *This, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - DWORD token = D3DSIO_MOV & D3DSI_OPCODE_MASK; +static void instr_ps_1_0123_mov(struct bc_writer *writer, const struct instruction *instr, + struct bytecode_buffer *buffer) +{ + uint32_t token = D3DSIO_MOV & D3DSI_OPCODE_MASK; - if(instr->dst.type == BWRITERSPR_TEMP && instr->src[0].type == BWRITERSPR_INPUT) { - if((instr->dst.regnum == T0_REG && instr->src[0].regnum == This->t_regnum[0]) || - (instr->dst.regnum == T1_REG && instr->src[0].regnum == This->t_regnum[1]) || - (instr->dst.regnum == T2_REG && instr->src[0].regnum == This->t_regnum[2]) || - (instr->dst.regnum == T3_REG && instr->src[0].regnum == This->t_regnum[3])) { - if(instr->dstmod & BWRITERSPDM_SATURATE) { - This->funcs->opcode(This, instr, D3DSIO_TEXCOORD & D3DSI_OPCODE_MASK, buffer); + if (instr->dst.type == BWRITERSPR_TEMP && instr->src[0].type == BWRITERSPR_INPUT) + { + if ((instr->dst.regnum == T0_REG && instr->src[0].regnum == writer->t_regnum[0]) + || (instr->dst.regnum == T1_REG && instr->src[0].regnum == writer->t_regnum[1]) + || (instr->dst.regnum == T2_REG && instr->src[0].regnum == writer->t_regnum[2]) + || (instr->dst.regnum == T3_REG && instr->src[0].regnum == writer->t_regnum[3])) + { + if (instr->dstmod & BWRITERSPDM_SATURATE) + { + writer->funcs->opcode(writer, instr, D3DSIO_TEXCOORD & D3DSI_OPCODE_MASK, buffer); /* Remove the SATURATE flag, it's implicit to the instruction */ - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod & (~BWRITERSPDM_SATURATE)); - return; - } else { - WARN("A varying -> temp copy is only supported with the SATURATE modifier in <=ps_1_3\n"); - This->state = E_INVALIDARG; + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod & (~BWRITERSPDM_SATURATE)); return; } - } else if(instr->src[0].regnum == This->v_regnum[0] || - instr->src[0].regnum == This->v_regnum[1]) { + else + { + WARN("A varying -> temp copy is only supported with the SATURATE modifier in <=ps_1_3\n"); + writer->state = E_INVALIDARG; + return; + } + } + else if (instr->src[0].regnum == writer->v_regnum[0] || instr->src[0].regnum == writer->v_regnum[1]) + { /* Handled by the normal mov below. Just drop out of the if condition */ - } else { + } + else + { WARN("Unsupported varying -> temp mov in <= ps_1_3\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } } - This->funcs->opcode(This, instr, token, buffer); - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); - This->funcs->srcreg(This, &instr->src[0], buffer); + writer->funcs->opcode(writer, instr, token, buffer); + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); + writer->funcs->srcreg(writer, &instr->src[0], buffer); } static const struct instr_handler_table ps_1_0123_handlers[] = { @@ -1432,18 +1519,21 @@ static const struct bytecode_backend ps_1_0123_backend = { ps_1_0123_handlers }; -static void ps_1_4_srcreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - if(reg->rel_reg) { - WARN("Relative addressing not supported in <= ps_3_0\n"); - This->state = E_INVALIDARG; +static void ps_1_4_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + uint32_t token = 1u << 31; /* Bit 31 of registers is 1. */ + + if (reg->rel_reg) + { + WARN("Relative addressing not supported in <= ps_3_0.\n"); + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; /* Can be mapped 1:1 */ @@ -1454,110 +1544,117 @@ static void ps_1_4_srcreg(struct bc_writer *This, const struct shader_reg *reg, default: WARN("Invalid register type for ps_1_4 shader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ - if(reg->srcmod == BWRITERSPSM_ABS || reg->srcmod == BWRITERSPSM_ABSNEG || - reg->srcmod == BWRITERSPSM_NOT) { - WARN("Invalid source modifier %lu for ps_1_4.\n", reg->srcmod); - This->state = E_INVALIDARG; + if (reg->srcmod == BWRITERSPSM_ABS || reg->srcmod == BWRITERSPSM_ABSNEG || reg->srcmod == BWRITERSPSM_NOT) + { + WARN("Invalid source modifier %u for ps_1_4\n", reg->srcmod); + writer->state = E_INVALIDARG; return; } token |= d3d9_srcmod(reg->srcmod); - put_dword(buffer, token); + put_u32(buffer, token); } -static void ps_1_4_dstreg(struct bc_writer *This, const struct shader_reg *reg, - struct bytecode_buffer *buffer, - DWORD shift, DWORD mod) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ +static void ps_1_4_dstreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer, + uint32_t shift, uint32_t mod) +{ + uint32_t token = 1u << 31; /* Bit 31 of registers is 1. */ - if(reg->rel_reg) { + if (reg->rel_reg) + { WARN("Relative addressing not supported for destination registers\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_TEMP: /* 1:1 mapping */ token |= d3dsp_register( reg->type, reg->regnum ); break; /* For texkill */ case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; default: WARN("Invalid dest register type for 1.x pshader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= (shift << D3DSP_DSTSHIFT_SHIFT) & D3DSP_DSTSHIFT_MASK; token |= d3d9_dstmod(mod); - token |= d3d9_writemask(reg->u.writemask); - put_dword(buffer, token); + token |= d3d9_writemask(reg->writemask); + put_u32(buffer, token); } -static void instr_ps_1_4_mov(struct bc_writer *This, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - DWORD token = D3DSIO_MOV & D3DSI_OPCODE_MASK; +static void instr_ps_1_4_mov(struct bc_writer *writer, const struct instruction *instr, + struct bytecode_buffer *buffer) +{ + uint32_t token = D3DSIO_MOV & D3DSI_OPCODE_MASK; - if(instr->dst.type == BWRITERSPR_TEMP && instr->src[0].type == BWRITERSPR_INPUT) { - if(instr->src[0].regnum == This->t_regnum[0] || - instr->src[0].regnum == This->t_regnum[1] || - instr->src[0].regnum == This->t_regnum[2] || - instr->src[0].regnum == This->t_regnum[3] || - instr->src[0].regnum == This->t_regnum[4] || - instr->src[0].regnum == This->t_regnum[5]) { + if (instr->dst.type == BWRITERSPR_TEMP && instr->src[0].type == BWRITERSPR_INPUT) + { + if (instr->src[0].regnum == writer->t_regnum[0] || instr->src[0].regnum == writer->t_regnum[1] + || instr->src[0].regnum == writer->t_regnum[2] || instr->src[0].regnum == writer->t_regnum[3] + || instr->src[0].regnum == writer->t_regnum[4] || instr->src[0].regnum == writer->t_regnum[5]) + { /* Similar to a regular mov, but a different opcode */ token = D3DSIO_TEXCOORD & D3DSI_OPCODE_MASK; - } else if(instr->src[0].regnum == This->v_regnum[0] || - instr->src[0].regnum == This->v_regnum[1]) { + } + else if (instr->src[0].regnum == writer->v_regnum[0] || instr->src[0].regnum == writer->v_regnum[1]) + { /* Handled by the normal mov below. Just drop out of the if condition */ - } else { + } + else + { WARN("Unsupported varying -> temp mov in ps_1_4\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } } - This->funcs->opcode(This, instr, token, buffer); - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); - This->funcs->srcreg(This, &instr->src[0], buffer); + writer->funcs->opcode(writer, instr, token, buffer); + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); + writer->funcs->srcreg(writer, &instr->src[0], buffer); } -static void instr_ps_1_4_texld(struct bc_writer *This, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - if(instr->src[1].type != BWRITERSPR_SAMPLER || - instr->src[1].regnum > 5) { - WARN("Unsupported sampler type %lu regnum %lu.\n", +static void instr_ps_1_4_texld(struct bc_writer *writer, const struct instruction *instr, + struct bytecode_buffer *buffer) +{ + if (instr->src[1].type != BWRITERSPR_SAMPLER || instr->src[1].regnum > 5) + { + WARN("Unsupported sampler type %u regnum %u.\n", instr->src[1].type, instr->src[1].regnum); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; - } else if(instr->dst.type != BWRITERSPR_TEMP) { + } + else if (instr->dst.type != BWRITERSPR_TEMP) + { WARN("Can only sample into a temp register\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - if(instr->src[1].regnum != instr->dst.regnum) { - WARN("Sampling from sampler s%lu to register r%lu is not possible in ps_1_4.\n", + if (instr->src[1].regnum != instr->dst.regnum) + { + WARN("Sampling from sampler s%u to register r%u is not possible in ps_1_4.\n", instr->src[1].regnum, instr->dst.regnum); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - This->funcs->opcode(This, instr, D3DSIO_TEX & D3DSI_OPCODE_MASK, buffer); - This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod); - This->funcs->srcreg(This, &instr->src[0], buffer); + writer->funcs->opcode(writer, instr, D3DSIO_TEX & D3DSI_OPCODE_MASK, buffer); + writer->funcs->dstreg(writer, &instr->dst, buffer, instr->shift, instr->dstmod); + writer->funcs->srcreg(writer, &instr->src[0], buffer); } static const struct instr_handler_table ps_1_4_handlers[] = { @@ -1617,20 +1714,20 @@ static void vs_2_header(struct bc_writer *This, write_constI(shader, buffer, TRUE); } -static void vs_2_srcreg(struct bc_writer *This, - const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD has_swizzle; - DWORD component; - DWORD d3d9reg; +static void vs_2_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + uint32_t token = 1u << 31; /* Bit 31 of registers is 1 */ + uint32_t component; + uint32_t d3d9reg; + BOOL has_swizzle; - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_OUTPUT: - /* Map the swizzle to a writemask, the format expected - by map_vs_output - */ - switch(reg->u.swizzle) { + /* Map the swizzle to a writemask, the format expected by + * map_vs_output. */ + switch (reg->swizzle) + { case BWRITERVS_SWIZZLE_X: component = BWRITERSP_WRITEMASK_0; break; @@ -1646,7 +1743,7 @@ static void vs_2_srcreg(struct bc_writer *This, default: component = 0; } - token |= map_vs_output(This, reg->regnum, component, &has_swizzle); + token |= map_vs_output(writer, reg->regnum, component, &has_swizzle); break; case BWRITERSPR_RASTOUT: @@ -1654,7 +1751,7 @@ static void vs_2_srcreg(struct bc_writer *This, /* These registers are mapped to input and output regs. They can be encoded in the bytecode, * but are unexpected. If we hit this path it might be due to an error. */ - FIXME("Unexpected register type %lu.\n", reg->type); + FIXME("Unexpected register type %u.\n", reg->type); /* drop through */ case BWRITERSPR_INPUT: case BWRITERSPR_TEMP: @@ -1664,66 +1761,67 @@ static void vs_2_srcreg(struct bc_writer *This, case BWRITERSPR_CONSTBOOL: case BWRITERSPR_LABEL: d3d9reg = d3d9_register(reg->type); - token |= d3dsp_register( d3d9reg, reg->regnum ); + token |= d3dsp_register(d3d9reg, reg->regnum); break; case BWRITERSPR_LOOP: - if(reg->regnum != 0) { + if (reg->regnum != 0) + { WARN("Only regnum 0 is supported for the loop index register in vs_2_0\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3dsp_register( D3DSPR_LOOP, 0 ); + token |= d3dsp_register(D3DSPR_LOOP, 0); break; case BWRITERSPR_PREDICATE: - if (This->shader->major_version != 2 || This->shader->minor_version != 1) + if (writer->shader->major_version != 2 || writer->shader->minor_version != 1) { WARN("Predicate register is allowed only in vs_2_x\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - if(reg->regnum > 0) { + if (reg->regnum > 0) + { WARN("Only predicate register 0 is supported\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3dsp_register( D3DSPR_PREDICATE, 0 ); + token |= d3dsp_register(D3DSPR_PREDICATE, 0); break; default: WARN("Invalid register type for 2.0 vshader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ - + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ token |= d3d9_srcmod(reg->srcmod); - if(reg->rel_reg) + if (reg->rel_reg) token |= D3DVS_ADDRMODE_RELATIVE & D3DVS_ADDRESSMODE_MASK; - put_dword(buffer, token); + put_u32(buffer, token); - /* vs_2_0 and newer write the register containing the index explicitly in the - * binary code - */ - if(token & D3DVS_ADDRMODE_RELATIVE) - vs_2_srcreg(This, reg->rel_reg, buffer); + /* vs_2_0 and newer write the register containing the index explicitly in + * the binary code. */ + if (token & D3DVS_ADDRMODE_RELATIVE) + vs_2_srcreg(writer, reg->rel_reg, buffer); } -static void sm_2_opcode(struct bc_writer *This, - const struct instruction *instr, - DWORD token, struct bytecode_buffer *buffer) { - /* From sm 2 onwards instruction length is encoded in the opcode field */ - int dsts = instr->has_dst ? 1 : 0; - token |= instrlen(instr, instr->num_srcs, dsts) << D3DSI_INSTLENGTH_SHIFT; - if(instr->comptype) +static void sm_2_opcode(struct bc_writer *writer, const struct instruction *instr, uint32_t token, + struct bytecode_buffer *buffer) +{ + unsigned int dst_count = instr->has_dst ? 1 : 0; + + /* From SM 2 onwards instruction length is encoded in the opcode field. */ + token |= instrlen(instr, instr->num_srcs, dst_count) << D3DSI_INSTLENGTH_SHIFT; + if (instr->comptype) token |= (d3d9_comparetype(instr->comptype) << 16) & (0xf << 16); - if(instr->has_predicate) + if (instr->has_predicate) token |= D3DSHADER_INSTRUCTION_PREDICATED; - put_dword(buffer,token); + put_u32(buffer,token); } static const struct instr_handler_table vs_2_0_handlers[] = { @@ -1852,22 +1950,24 @@ static const struct bytecode_backend vs_2_x_backend = { vs_2_x_handlers }; -static void write_samplers(const struct bwriter_shader *shader, struct bytecode_buffer *buffer) { - DWORD i; - DWORD instr_dcl = D3DSIO_DCL | (2 << D3DSI_INSTLENGTH_SHIFT); - DWORD token; - const DWORD reg = (1u << 31) | d3dsp_register( D3DSPR_SAMPLER, 0 ) | D3DSP_WRITEMASK_ALL; +static void write_samplers(const struct bwriter_shader *shader, struct bytecode_buffer *buffer) +{ + const uint32_t reg = (1u << 31) | d3dsp_register(D3DSPR_SAMPLER, 0) | D3DSP_WRITEMASK_ALL; + uint32_t instr_dcl = D3DSIO_DCL | (2 << D3DSI_INSTLENGTH_SHIFT); + unsigned int i; + uint32_t token; - for(i = 0; i < shader->num_samplers; i++) { + for (i = 0; i < shader->num_samplers; ++i) + { /* Write the DCL instruction */ - put_dword(buffer, instr_dcl); - token = (1u << 31); + put_u32(buffer, instr_dcl); + token = 1u << 31; /* Already shifted */ - token |= (d3d9_sampler(shader->samplers[i].type)) & D3DSP_TEXTURETYPE_MASK; - put_dword(buffer, token); + token |= d3d9_sampler(shader->samplers[i].type) & D3DSP_TEXTURETYPE_MASK; + put_u32(buffer, token); token = reg | (shader->samplers[i].regnum & D3DSP_REGNUM_MASK); token |= d3d9_dstmod(shader->samplers[i].mod); - put_dword(buffer, token); + put_u32(buffer, token); } } @@ -1885,20 +1985,22 @@ static void ps_2_header(struct bc_writer *This, const struct bwriter_shader *sha write_constI(shader, buffer, TRUE); } -static void ps_2_srcreg(struct bc_writer *This, - const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD d3d9reg; - if(reg->rel_reg) { +static void ps_2_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + uint32_t token = 1u << 31; /* Bit 31 of registers is 1 */ + uint32_t d3d9reg; + + if (reg->rel_reg) + { WARN("Relative addressing not supported in <= ps_3_0\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; /* Can be mapped 1:1 */ @@ -1911,82 +2013,82 @@ static void ps_2_srcreg(struct bc_writer *This, case BWRITERSPR_LABEL: case BWRITERSPR_DEPTHOUT: d3d9reg = d3d9_register(reg->type); - token |= d3dsp_register( d3d9reg, reg->regnum ); + token |= d3dsp_register(d3d9reg, reg->regnum); break; case BWRITERSPR_PREDICATE: - if (This->shader->minor_version == 0) + if (writer->shader->minor_version == 0) { WARN("Predicate register not supported in ps_2_0\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; } if (reg->regnum) { - WARN("Predicate register with regnum %lu not supported.\n", - reg->regnum); - This->state = E_INVALIDARG; + WARN("Predicate register with regnum %u not supported.\n", reg->regnum); + writer->state = E_INVALIDARG; } - token |= d3dsp_register( D3DSPR_PREDICATE, 0 ); + token |= d3dsp_register(D3DSPR_PREDICATE, 0); break; default: WARN("Invalid register type for ps_2_0 shader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; /* already shifted */ token |= d3d9_srcmod(reg->srcmod); - put_dword(buffer, token); + put_u32(buffer, token); } -static void ps_2_0_dstreg(struct bc_writer *This, - const struct shader_reg *reg, - struct bytecode_buffer *buffer, - DWORD shift, DWORD mod) { - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD d3d9reg; +static void ps_2_0_dstreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer, + uint32_t shift, uint32_t mod) +{ + uint32_t token = 1u << 31; /* Bit 31 of registers is 1 */ + uint32_t d3d9reg; - if(reg->rel_reg) { + if (reg->rel_reg) + { WARN("Relative addressing not supported for destination registers\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } - switch(reg->type) { + switch (reg->type) + { case BWRITERSPR_TEMP: /* 1:1 mapping */ case BWRITERSPR_COLOROUT: case BWRITERSPR_DEPTHOUT: d3d9reg = d3d9_register(reg->type); - token |= d3dsp_register( d3d9reg, reg->regnum ); + token |= d3dsp_register(d3d9reg, reg->regnum); break; case BWRITERSPR_PREDICATE: - if (This->shader->minor_version == 0) + if (writer->shader->minor_version == 0) { WARN("Predicate register not supported in ps_2_0\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; } - token |= d3dsp_register( D3DSPR_PREDICATE, reg->regnum ); + token |= d3dsp_register(D3DSPR_PREDICATE, reg->regnum); break; /* texkill uses the input register as a destination parameter */ case BWRITERSPR_INPUT: - token |= map_ps_input(This, reg); + token |= map_ps_input(writer, reg); break; default: WARN("Invalid dest register type for 2.x pshader\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } token |= (shift << D3DSP_DSTSHIFT_SHIFT) & D3DSP_DSTSHIFT_MASK; token |= d3d9_dstmod(mod); - token |= d3d9_writemask(reg->u.writemask); - put_dword(buffer, token); + token |= d3d9_writemask(reg->writemask); + put_u32(buffer, token); } static const struct instr_handler_table ps_2_0_handlers[] = { @@ -2116,23 +2218,23 @@ static void sm_3_header(struct bc_writer *This, const struct bwriter_shader *sha write_samplers(shader, buffer); } -static void sm_3_srcreg(struct bc_writer *This, - const struct shader_reg *reg, - struct bytecode_buffer *buffer) { - const struct bwriter_shader *shader = This->shader; - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD d3d9reg; +static void sm_3_srcreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer) +{ + const struct bwriter_shader *shader = writer->shader; + uint32_t token = 1u << 31; /* Bit 31 of registers is 1 */ + uint32_t d3d9reg; d3d9reg = d3d9_register(reg->type); - token |= d3dsp_register( d3d9reg, reg->regnum ); - token |= d3d9_swizzle(reg->u.swizzle) & D3DVS_SWIZZLE_MASK; + token |= d3dsp_register(d3d9reg, reg->regnum); + token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK; token |= d3d9_srcmod(reg->srcmod); - if(reg->rel_reg) { + if (reg->rel_reg) + { if (reg->type == BWRITERSPR_CONST && shader->type == ST_PIXEL) { - WARN("c%lu[...] is unsupported in ps_3_0.\n", reg->regnum); - This->state = E_INVALIDARG; + WARN("c%u[...] is unsupported in ps_3_0.\n", reg->regnum); + writer->state = E_INVALIDARG; return; } @@ -2140,54 +2242,54 @@ static void sm_3_srcreg(struct bc_writer *This, || reg->rel_reg->type == BWRITERSPR_LOOP) && reg->rel_reg->regnum == 0) { token |= D3DVS_ADDRMODE_RELATIVE & D3DVS_ADDRESSMODE_MASK; - } else { + } + else + { WARN("Unsupported relative addressing register\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } } - put_dword(buffer, token); + put_u32(buffer, token); - /* vs_2_0 and newer write the register containing the index explicitly in the - * binary code - */ - if(token & D3DVS_ADDRMODE_RELATIVE) { - sm_3_srcreg(This, reg->rel_reg, buffer); - } + /* vs_2_0 and newer write the register containing the index explicitly in + * the binary code. */ + if (token & D3DVS_ADDRMODE_RELATIVE) + sm_3_srcreg(writer, reg->rel_reg, buffer); } -static void sm_3_dstreg(struct bc_writer *This, - const struct shader_reg *reg, - struct bytecode_buffer *buffer, - DWORD shift, DWORD mod) { - const struct bwriter_shader *shader = This->shader; - DWORD token = (1u << 31); /* Bit 31 of registers is 1 */ - DWORD d3d9reg; +static void sm_3_dstreg(struct bc_writer *writer, const struct shader_reg *reg, struct bytecode_buffer *buffer, + uint32_t shift, uint32_t mod) +{ + const struct bwriter_shader *shader = writer->shader; + uint32_t token = 1u << 31; /* Bit 31 of registers is 1 */ + uint32_t d3d9reg; - if(reg->rel_reg) { + if (reg->rel_reg) + { if (shader->type == ST_VERTEX && reg->type == BWRITERSPR_OUTPUT) { token |= D3DVS_ADDRMODE_RELATIVE & D3DVS_ADDRESSMODE_MASK; - } else { + } + else + { WARN("Relative addressing not supported for this shader type or register type\n"); - This->state = E_INVALIDARG; + writer->state = E_INVALIDARG; return; } } d3d9reg = d3d9_register(reg->type); - token |= d3dsp_register( d3d9reg, reg->regnum ); + token |= d3dsp_register(d3d9reg, reg->regnum); token |= d3d9_dstmod(mod); - token |= d3d9_writemask(reg->u.writemask); - put_dword(buffer, token); + token |= d3d9_writemask(reg->writemask); + put_u32(buffer, token); - /* vs_2_0 and newer write the register containing the index explicitly in the - * binary code - */ - if(token & D3DVS_ADDRMODE_RELATIVE) { - sm_3_srcreg(This, reg->rel_reg, buffer); - } + /* vs_2_0 and newer write the register containing the index explicitly in + * the binary code. */ + if (token & D3DVS_ADDRMODE_RELATIVE) + sm_3_srcreg(writer, reg->rel_reg, buffer); } static const struct instr_handler_table vs_3_handlers[] = { @@ -2352,29 +2454,30 @@ shader_backends[] = {ST_PIXEL, 3, 0, &ps_3_backend}, }; -static HRESULT call_instr_handler(struct bc_writer *writer, - const struct instruction *instr, - struct bytecode_buffer *buffer) { - DWORD i=0; +static HRESULT call_instr_handler(struct bc_writer *writer, const struct instruction *instr, + struct bytecode_buffer *buffer) +{ + unsigned int i; - while(writer->funcs->instructions[i].opcode != BWRITERSIO_END) { - if(instr->opcode == writer->funcs->instructions[i].opcode) { - if(!writer->funcs->instructions[i].func) { - WARN("Opcode %lu not supported by this profile.\n", instr->opcode); + for (i = 0; writer->funcs->instructions[i].opcode != BWRITERSIO_END; ++i) + { + if (instr->opcode == writer->funcs->instructions[i].opcode) + { + if (!writer->funcs->instructions[i].func) + { + WARN("Opcode %u not supported by this profile.\n", instr->opcode); return E_INVALIDARG; } writer->funcs->instructions[i].func(writer, instr, buffer); return S_OK; } - i++; } - FIXME("Unhandled instruction %lu - %s.\n", instr->opcode, - debug_print_opcode(instr->opcode)); + FIXME("Unhandled instruction %u - %s.\n", instr->opcode, debug_print_opcode(instr->opcode)); return E_INVALIDARG; } -HRESULT shader_write_bytecode(const struct bwriter_shader *shader, DWORD **result, DWORD *size) +HRESULT shader_write_bytecode(const struct bwriter_shader *shader, uint32_t **result, uint32_t *size) { struct bc_writer *writer; struct bytecode_buffer *buffer = NULL; @@ -2419,7 +2522,7 @@ HRESULT shader_write_bytecode(const struct bwriter_shader *shader, DWORD **resul } /* Write shader type and version */ - put_dword(buffer, sm1_version(shader)); + put_u32(buffer, sm1_version(shader)); writer->funcs->header(writer, shader, buffer); if(FAILED(writer->state)) { @@ -2446,7 +2549,7 @@ HRESULT shader_write_bytecode(const struct bwriter_shader *shader, DWORD **resul goto error; } - *size = buffer->size * sizeof(DWORD); + *size = buffer->size * sizeof(uint32_t); *result = buffer->data; buffer->data = NULL; hr = S_OK; diff --git a/dlls/d3dcompiler_43/compiler.c b/dlls/d3dcompiler_43/compiler.c index d7d2e1e681d..6ae51c75cd4 100644 --- a/dlls/d3dcompiler_43/compiler.c +++ b/dlls/d3dcompiler_43/compiler.c @@ -633,14 +633,13 @@ cleanup: return hr; } -static HRESULT assemble_shader(const char *preproc_shader, - ID3DBlob **shader_blob, ID3DBlob **error_messages) +static HRESULT assemble_shader(const char *preproc_shader, ID3DBlob **shader_blob, ID3DBlob **error_messages) { struct bwriter_shader *shader; char *messages = NULL; - HRESULT hr; - DWORD *res, size; + uint32_t *res, size; ID3DBlob *buffer; + HRESULT hr; char *pos; shader = SlAssembleShader(preproc_shader, &messages); diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index 713c900cee6..791c8d1cad2 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -35,6 +35,7 @@ #include "d3dcompiler.h" #include +#include /* * This doesn't belong here, but for some functions it is possible to return that value, @@ -66,31 +67,36 @@ enum bwriter_comparison_type BWRITER_COMPARISON_LE }; -struct constant { - DWORD regnum; - union { +struct constant +{ + unsigned int regnum; + union + { float f; - INT i; + int i; BOOL b; - DWORD d; - } value[4]; + uint32_t d; + } value[4]; }; -struct shader_reg { - DWORD type; - DWORD regnum; - struct shader_reg *rel_reg; - DWORD srcmod; - union { - DWORD swizzle; - DWORD writemask; - } u; +struct shader_reg +{ + uint32_t type; + unsigned int regnum; + struct shader_reg *rel_reg; + uint32_t srcmod; + union + { + uint32_t swizzle; + uint32_t writemask; + }; }; -struct instruction { - DWORD opcode; - DWORD dstmod; - DWORD shift; +struct instruction +{ + uint32_t opcode; + uint32_t dstmod; + uint32_t shift; enum bwriter_comparison_type comptype; BOOL has_dst; struct shader_reg dst; @@ -101,21 +107,24 @@ struct instruction { BOOL coissue; }; -struct declaration { - DWORD usage, usage_idx; - DWORD regnum; - DWORD mod; - DWORD writemask; +struct declaration +{ + uint32_t usage, usage_idx; + uint32_t regnum; + uint32_t mod; + uint32_t writemask; BOOL builtin; }; -struct samplerdecl { - DWORD type; - DWORD regnum; - DWORD mod; +struct samplerdecl +{ + uint32_t type; + uint32_t regnum; + uint32_t mod; }; -struct bwriter_shader { +struct bwriter_shader +{ enum shader_type type; unsigned char major_version, minor_version; @@ -163,25 +172,28 @@ struct asm_parser; /* This structure is only used in asmshader.y, but since the .l file accesses the semantic types * too it has to know it as well */ -struct rel_reg { +struct rel_reg +{ BOOL has_rel_reg; - DWORD type; - DWORD additional_offset; - DWORD rel_regnum; - DWORD swizzle; + uint32_t type; + uint32_t additional_offset; + uint32_t rel_regnum; + uint32_t swizzle; }; #define MAX_SRC_REGS 4 -struct src_regs { +struct src_regs +{ struct shader_reg reg[MAX_SRC_REGS]; unsigned int count; }; -struct asmparser_backend { - void (*constF)(struct asm_parser *This, DWORD reg, float x, float y, float z, float w); - void (*constI)(struct asm_parser *This, DWORD reg, INT x, INT y, INT z, INT w); - void (*constB)(struct asm_parser *This, DWORD reg, BOOL x); +struct asmparser_backend +{ + void (*constF)(struct asm_parser *This, uint32_t reg, float x, float y, float z, float w); + void (*constI)(struct asm_parser *This, uint32_t reg, int x, int y, int z, int w); + void (*constB)(struct asm_parser *This, uint32_t reg, BOOL x); void (*dstreg)(struct asm_parser *This, struct instruction *instr, const struct shader_reg *dst); @@ -192,28 +204,28 @@ struct asmparser_backend { const struct shader_reg *predicate); void (*coissue)(struct asm_parser *This); - void (*dcl_output)(struct asm_parser *This, DWORD usage, DWORD num, + void (*dcl_output)(struct asm_parser *This, uint32_t usage, uint32_t num, const struct shader_reg *reg); - void (*dcl_input)(struct asm_parser *This, DWORD usage, DWORD num, - DWORD mod, const struct shader_reg *reg); - void (*dcl_sampler)(struct asm_parser *This, DWORD samptype, DWORD mod, - DWORD regnum, unsigned int line_no); + void (*dcl_input)(struct asm_parser *This, uint32_t usage, uint32_t num, + uint32_t mod, const struct shader_reg *reg); + void (*dcl_sampler)(struct asm_parser *This, uint32_t samptype, uint32_t mod, + uint32_t regnum, unsigned int line_no); void (*end)(struct asm_parser *This); - void (*instr)(struct asm_parser *parser, DWORD opcode, DWORD mod, DWORD shift, + void (*instr)(struct asm_parser *parser, uint32_t opcode, uint32_t mod, uint32_t shift, enum bwriter_comparison_type comp, const struct shader_reg *dst, const struct src_regs *srcs, int expectednsrcs); }; 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; +BOOL add_constF(struct bwriter_shader *shader, uint32_t reg, float x, float y, float z, float w) DECLSPEC_HIDDEN; +BOOL add_constI(struct bwriter_shader *shader, uint32_t reg, int x, int y, int z, int w) DECLSPEC_HIDDEN; +BOOL add_constB(struct bwriter_shader *shader, uint32_t reg, BOOL x) DECLSPEC_HIDDEN; +BOOL record_declaration(struct bwriter_shader *shader, uint32_t usage, uint32_t usage_idx, + uint32_t mod, BOOL output, uint32_t regnum, uint32_t writemask, BOOL builtin) DECLSPEC_HIDDEN; +BOOL record_sampler(struct bwriter_shader *shader, uint32_t samptype, uint32_t mod, uint32_t regnum) DECLSPEC_HIDDEN; #define MESSAGEBUFFER_INITIAL_SIZE 256 @@ -280,13 +292,13 @@ static inline void set_parse_status(enum parse_status *current, enum parse_statu } /* Debug utility routines */ -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_srcmod(uint32_t mod) DECLSPEC_HIDDEN; +const char *debug_print_dstmod(uint32_t mod) DECLSPEC_HIDDEN; +const char *debug_print_shift(uint32_t 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; +const char *debug_print_comp(uint32_t comp) DECLSPEC_HIDDEN; +const char *debug_print_opcode(uint32_t opcode) DECLSPEC_HIDDEN; /* Used to signal an incorrect swizzle/writemask */ #define SWIZZLE_ERR ~0U @@ -516,7 +528,7 @@ enum bwriterdeclusage #define T3_REG 5 struct bwriter_shader *SlAssembleShader(const char *text, char **messages) DECLSPEC_HIDDEN; -HRESULT shader_write_bytecode(const struct bwriter_shader *shader, DWORD **result, DWORD *size) DECLSPEC_HIDDEN; +HRESULT shader_write_bytecode(const struct bwriter_shader *shader, uint32_t **result, uint32_t *size) DECLSPEC_HIDDEN; void SlDeleteShader(struct bwriter_shader *shader) DECLSPEC_HIDDEN; #define MAKE_TAG(ch0, ch1, ch2, ch3) \ @@ -553,23 +565,24 @@ struct dxbc 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_add_section(struct dxbc *dxbc, DWORD tag, const char *data, size_t data_size) DECLSPEC_HIDDEN; HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size) DECLSPEC_HIDDEN; -static inline DWORD read_dword(const char **ptr) +static inline uint32_t read_u32(const char **ptr) { - DWORD r; + uint32_t r; + memcpy(&r, *ptr, sizeof(r)); *ptr += sizeof(r); return r; } -static inline void write_dword(char **ptr, DWORD d) +static inline void write_u32(char **ptr, uint32_t u32) { - memcpy(*ptr, &d, sizeof(d)); - *ptr += sizeof(d); + memcpy(*ptr, &u32, sizeof(u32)); + *ptr += sizeof(u32); } -void skip_dword_unknown(const char **ptr, unsigned int count) DECLSPEC_HIDDEN; +void skip_u32_unknown(const char **ptr, unsigned int count) DECLSPEC_HIDDEN; #endif /* __WINE_D3DCOMPILER_PRIVATE_H */ diff --git a/dlls/d3dcompiler_43/reflection.c b/dlls/d3dcompiler_43/reflection.c index cbcf8246b70..5708d3d878f 100644 --- a/dlls/d3dcompiler_43/reflection.c +++ b/dlls/d3dcompiler_43/reflection.c @@ -36,7 +36,7 @@ enum D3DCOMPILER_SIGNATURE_ELEMENT_SIZE struct d3dcompiler_shader_signature { D3D11_SIGNATURE_PARAMETER_DESC *elements; - UINT element_count; + unsigned int element_count; char *string_data; }; @@ -45,7 +45,7 @@ struct d3dcompiler_shader_reflection_type ID3D11ShaderReflectionType ID3D11ShaderReflectionType_iface; ID3D10ShaderReflectionType ID3D10ShaderReflectionType_iface; - DWORD id; + uint32_t id; struct wine_rb_entry entry; struct d3dcompiler_shader_reflection *reflection; @@ -58,7 +58,7 @@ struct d3dcompiler_shader_reflection_type struct d3dcompiler_shader_reflection_type_member { char *name; - DWORD offset; + uint32_t offset; struct d3dcompiler_shader_reflection_type *type; }; @@ -109,7 +109,7 @@ struct d3dcompiler_shader_reflection enum D3DCOMPILER_REFLECTION_VERSION interface_version; - DWORD target; + uint32_t target; char *creator; UINT flags; UINT version; @@ -154,7 +154,7 @@ struct d3dcompiler_shader_reflection struct wine_rb_tree types; }; -static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, DWORD offset); +static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, uint32_t offset); static const struct ID3D11ShaderReflectionConstantBufferVtbl d3dcompiler_shader_reflection_constant_buffer_vtbl; static const struct ID3D11ShaderReflectionVariableVtbl d3dcompiler_shader_reflection_variable_vtbl; @@ -207,7 +207,7 @@ static BOOL copy_name(const char *ptr, char **name) return TRUE; } -static BOOL copy_value(const char *ptr, void **value, DWORD size) +static BOOL copy_value(const char *ptr, void **value, uint32_t size) { if (!ptr || !size) return TRUE; @@ -226,7 +226,7 @@ static BOOL copy_value(const char *ptr, void **value, DWORD size) static int d3dcompiler_shader_reflection_type_compare(const void *key, const struct wine_rb_entry *entry) { const struct d3dcompiler_shader_reflection_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3dcompiler_shader_reflection_type, entry); - const DWORD *id = key; + const uint32_t *id = key; return *id - t->id; } @@ -1087,119 +1087,119 @@ static const struct ID3D11ShaderReflectionTypeVtbl d3dcompiler_shader_reflection d3dcompiler_shader_reflection_type_ImplementsInterface, }; -static HRESULT d3dcompiler_parse_stat(struct d3dcompiler_shader_reflection *r, const char *data, DWORD data_size) +static HRESULT d3dcompiler_parse_stat(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size) { const char *ptr = data; - DWORD size = data_size >> 2; + size_t size = data_size >> 2; - TRACE("Size %lu\n", size); + TRACE("Size %Iu.\n", size); - r->instruction_count = read_dword(&ptr); - TRACE("InstructionCount: %u\n", r->instruction_count); + r->instruction_count = read_u32(&ptr); + TRACE("InstructionCount: %u.\n", r->instruction_count); - r->temp_register_count = read_dword(&ptr); - TRACE("TempRegisterCount: %u\n", r->temp_register_count); + r->temp_register_count = read_u32(&ptr); + TRACE("TempRegisterCount: %u.\n", r->temp_register_count); - r->def_count = read_dword(&ptr); - TRACE("DefCount: %u\n", r->def_count); + r->def_count = read_u32(&ptr); + TRACE("DefCount: %u.\n", r->def_count); - r->dcl_count = read_dword(&ptr); - TRACE("DclCount: %u\n", r->dcl_count); + r->dcl_count = read_u32(&ptr); + TRACE("DclCount: %u.\n", r->dcl_count); - r->float_instruction_count = read_dword(&ptr); - TRACE("FloatInstructionCount: %u\n", r->float_instruction_count); + r->float_instruction_count = read_u32(&ptr); + TRACE("FloatInstructionCount: %u.\n", r->float_instruction_count); - r->int_instruction_count = read_dword(&ptr); - TRACE("IntInstructionCount: %u\n", r->int_instruction_count); + r->int_instruction_count = read_u32(&ptr); + TRACE("IntInstructionCount: %u.\n", r->int_instruction_count); - r->uint_instruction_count = read_dword(&ptr); - TRACE("UintInstructionCount: %u\n", r->uint_instruction_count); + r->uint_instruction_count = read_u32(&ptr); + TRACE("UintInstructionCount: %u.\n", r->uint_instruction_count); - r->static_flow_control_count = read_dword(&ptr); - TRACE("StaticFlowControlCount: %u\n", r->static_flow_control_count); + r->static_flow_control_count = read_u32(&ptr); + TRACE("StaticFlowControlCount: %u.\n", r->static_flow_control_count); - r->dynamic_flow_control_count = read_dword(&ptr); - TRACE("DynamicFlowControlCount: %u\n", r->dynamic_flow_control_count); + r->dynamic_flow_control_count = read_u32(&ptr); + TRACE("DynamicFlowControlCount: %u.\n", r->dynamic_flow_control_count); - r->macro_instruction_count = read_dword(&ptr); - TRACE("MacroInstructionCount: %u\n", r->macro_instruction_count); + r->macro_instruction_count = read_u32(&ptr); + TRACE("MacroInstructionCount: %u.\n", r->macro_instruction_count); - r->temp_array_count = read_dword(&ptr); - TRACE("TempArrayCount: %u\n", r->temp_array_count); + r->temp_array_count = read_u32(&ptr); + TRACE("TempArrayCount: %u.\n", r->temp_array_count); - r->array_instruction_count = read_dword(&ptr); - TRACE("ArrayInstructionCount: %u\n", r->array_instruction_count); + r->array_instruction_count = read_u32(&ptr); + TRACE("ArrayInstructionCount: %u.\n", r->array_instruction_count); - r->cut_instruction_count = read_dword(&ptr); - TRACE("CutInstructionCount: %u\n", r->cut_instruction_count); + r->cut_instruction_count = read_u32(&ptr); + TRACE("CutInstructionCount: %u.\n", r->cut_instruction_count); - r->emit_instruction_count = read_dword(&ptr); - TRACE("EmitInstructionCount: %u\n", r->emit_instruction_count); + r->emit_instruction_count = read_u32(&ptr); + TRACE("EmitInstructionCount: %u.\n", r->emit_instruction_count); - r->texture_normal_instructions = read_dword(&ptr); - TRACE("TextureNormalInstructions: %u\n", r->texture_normal_instructions); + r->texture_normal_instructions = read_u32(&ptr); + TRACE("TextureNormalInstructions: %u.\n", r->texture_normal_instructions); - r->texture_load_instructions = read_dword(&ptr); - TRACE("TextureLoadInstructions: %u\n", r->texture_load_instructions); + r->texture_load_instructions = read_u32(&ptr); + TRACE("TextureLoadInstructions: %u.\n", r->texture_load_instructions); - r->texture_comp_instructions = read_dword(&ptr); - TRACE("TextureCompInstructions: %u\n", r->texture_comp_instructions); + r->texture_comp_instructions = read_u32(&ptr); + TRACE("TextureCompInstructions: %u.\n", r->texture_comp_instructions); - r->texture_bias_instructions = read_dword(&ptr); - TRACE("TextureBiasInstructions: %u\n", r->texture_bias_instructions); + r->texture_bias_instructions = read_u32(&ptr); + TRACE("TextureBiasInstructions: %u.\n", r->texture_bias_instructions); - r->texture_gradient_instructions = read_dword(&ptr); - TRACE("TextureGradientInstructions: %u\n", r->texture_gradient_instructions); + r->texture_gradient_instructions = read_u32(&ptr); + TRACE("TextureGradientInstructions: %u.\n", r->texture_gradient_instructions); - r->mov_instruction_count = read_dword(&ptr); - TRACE("MovInstructionCount: %u\n", r->mov_instruction_count); + r->mov_instruction_count = read_u32(&ptr); + TRACE("MovInstructionCount: %u.\n", r->mov_instruction_count); - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); - r->conversion_instruction_count = read_dword(&ptr); - TRACE("ConversionInstructionCount: %u\n", r->conversion_instruction_count); + r->conversion_instruction_count = read_u32(&ptr); + TRACE("ConversionInstructionCount: %u.\n", r->conversion_instruction_count); - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); - r->input_primitive = read_dword(&ptr); - TRACE("InputPrimitive: %x\n", r->input_primitive); + r->input_primitive = read_u32(&ptr); + TRACE("InputPrimitive: %x.\n", r->input_primitive); - r->gs_output_topology = read_dword(&ptr); - TRACE("GSOutputTopology: %x\n", r->gs_output_topology); + r->gs_output_topology = read_u32(&ptr); + TRACE("GSOutputTopology: %x.\n", r->gs_output_topology); - r->gs_max_output_vertex_count = read_dword(&ptr); - TRACE("GSMaxOutputVertexCount: %u\n", r->gs_max_output_vertex_count); + r->gs_max_output_vertex_count = read_u32(&ptr); + TRACE("GSMaxOutputVertexCount: %u.\n", r->gs_max_output_vertex_count); - skip_dword_unknown(&ptr, 2); + skip_u32_unknown(&ptr, 2); /* old dx10 stat size */ if (size == 28) return S_OK; - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); /* dx10 stat size */ if (size == 29) return S_OK; - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); - r->c_control_points = read_dword(&ptr); - TRACE("cControlPoints: %u\n", r->c_control_points); + r->c_control_points = read_u32(&ptr); + TRACE("cControlPoints: %u.\n", r->c_control_points); - r->hs_output_primitive = read_dword(&ptr); - TRACE("HSOutputPrimitive: %x\n", r->hs_output_primitive); + r->hs_output_primitive = read_u32(&ptr); + TRACE("HSOutputPrimitive: %x.\n", r->hs_output_primitive); - r->hs_partitioning = read_dword(&ptr); - TRACE("HSPartitioning: %x\n", r->hs_partitioning); + r->hs_partitioning = read_u32(&ptr); + TRACE("HSPartitioning: %x.\n", r->hs_partitioning); - r->tessellator_domain = read_dword(&ptr); - TRACE("TessellatorDomain: %x\n", r->tessellator_domain); + r->tessellator_domain = read_u32(&ptr); + TRACE("TessellatorDomain: %x.\n", r->tessellator_domain); - skip_dword_unknown(&ptr, 3); + skip_u32_unknown(&ptr, 3); /* dx11 stat size */ if (size == 37) return S_OK; - FIXME("Unhandled size %lu.\n", size); + FIXME("Unhandled size %Iu.\n", size); return E_FAIL; } @@ -1207,9 +1207,9 @@ static HRESULT d3dcompiler_parse_stat(struct d3dcompiler_shader_reflection *r, c static HRESULT d3dcompiler_parse_type_members(struct d3dcompiler_shader_reflection *ref, struct d3dcompiler_shader_reflection_type_member *member, const char *data, const char **ptr) { - DWORD offset; + uint32_t offset; - offset = read_dword(ptr); + offset = read_u32(ptr); if (!copy_name(data + offset, &member->name)) { ERR("Failed to copy name.\n"); @@ -1217,8 +1217,8 @@ static HRESULT d3dcompiler_parse_type_members(struct d3dcompiler_shader_reflecti } TRACE("Member name: %s.\n", debugstr_a(member->name)); - offset = read_dword(ptr); - TRACE("Member type offset: %#lx\n", offset); + offset = read_u32(ptr); + TRACE("Member type offset: %x.\n", offset); member->type = get_reflection_type(ref, data, offset); if (!member->type) @@ -1228,45 +1228,45 @@ static HRESULT d3dcompiler_parse_type_members(struct d3dcompiler_shader_reflecti return E_FAIL; } - member->offset = read_dword(ptr); - TRACE("Member offset %#lx\n", member->offset); + member->offset = read_u32(ptr); + TRACE("Member offset %x.\n", member->offset); return S_OK; } -static HRESULT d3dcompiler_parse_type(struct d3dcompiler_shader_reflection_type *type, const char *data, DWORD offset) +static HRESULT d3dcompiler_parse_type(struct d3dcompiler_shader_reflection_type *type, const char *data, uint32_t offset) { const char *ptr = data + offset; - DWORD temp; + uint32_t temp; D3D11_SHADER_TYPE_DESC *desc; unsigned int i; struct d3dcompiler_shader_reflection_type_member *members = NULL; HRESULT hr; - DWORD member_offset; + uint32_t member_offset; desc = &type->desc; - temp = read_dword(&ptr); + temp = read_u32(&ptr); desc->Class = temp & 0xffff; desc->Type = temp >> 16; TRACE("Class %s, Type %s\n", debug_d3dcompiler_shader_variable_class(desc->Class), debug_d3dcompiler_shader_variable_type(desc->Type)); - temp = read_dword(&ptr); + temp = read_u32(&ptr); desc->Rows = temp & 0xffff; desc->Columns = temp >> 16; TRACE("Rows %u, Columns %u\n", desc->Rows, desc->Columns); - temp = read_dword(&ptr); + temp = read_u32(&ptr); desc->Elements = temp & 0xffff; desc->Members = temp >> 16; TRACE("Elements %u, Members %u\n", desc->Elements, desc->Members); - member_offset = read_dword(&ptr); - TRACE("Member Offset %lu\n", member_offset); + member_offset = read_u32(&ptr); + TRACE("Member Offset %u.\n", member_offset); if ((type->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500) - skip_dword_unknown(&ptr, 4); + skip_u32_unknown(&ptr, 4); if (desc->Members) { @@ -1292,7 +1292,7 @@ static HRESULT d3dcompiler_parse_type(struct d3dcompiler_shader_reflection_type if ((type->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500) { - offset = read_dword(&ptr); + offset = read_u32(&ptr); if (!copy_name(data + offset, &type->name)) { ERR("Failed to copy name.\n"); @@ -1316,7 +1316,7 @@ err_out: return hr; } -static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, DWORD offset) +static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3dcompiler_shader_reflection *reflection, const char *data, uint32_t offset) { struct d3dcompiler_shader_reflection_type *type; struct wine_rb_entry *entry; @@ -1357,7 +1357,7 @@ static struct d3dcompiler_shader_reflection_type *get_reflection_type(struct d3d } static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_constant_buffer *cb, - const char *data, DWORD data_size, const char *ptr) + const char *data, size_t data_size, const char *ptr) { struct d3dcompiler_shader_reflection_variable *variables; unsigned int i; @@ -1373,13 +1373,13 @@ static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_ for (i = 0; i < cb->variable_count; i++) { struct d3dcompiler_shader_reflection_variable *v = &variables[i]; - DWORD offset; + uint32_t offset; v->ID3D11ShaderReflectionVariable_iface.lpVtbl = &d3dcompiler_shader_reflection_variable_vtbl; v->ID3D10ShaderReflectionVariable_iface.lpVtbl = &d3d10_shader_reflection_variable_vtbl; v->constant_buffer = cb; - offset = read_dword(&ptr); + offset = read_u32(&ptr); if (!copy_name(data + offset, &v->name)) { ERR("Failed to copy name.\n"); @@ -1388,17 +1388,17 @@ static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_ } TRACE("Variable name: %s.\n", debugstr_a(v->name)); - v->start_offset = read_dword(&ptr); + v->start_offset = read_u32(&ptr); TRACE("Variable offset: %u\n", v->start_offset); - v->size = read_dword(&ptr); + v->size = read_u32(&ptr); TRACE("Variable size: %u\n", v->size); - v->flags = read_dword(&ptr); + v->flags = read_u32(&ptr); TRACE("Variable flags: %u\n", v->flags); - offset = read_dword(&ptr); - TRACE("Variable type offset: %#lx.\n", offset); + offset = read_u32(&ptr); + TRACE("Variable type offset: %x.\n", offset); v->type = get_reflection_type(cb->reflection, data, offset); if (!v->type) { @@ -1407,8 +1407,8 @@ static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_ goto err_out; } - offset = read_dword(&ptr); - TRACE("Variable default value offset: %#lx.\n", offset); + offset = read_u32(&ptr); + TRACE("Variable default value offset: %x.\n", offset); if (!copy_value(data + offset, &v->default_value, offset ? v->size : 0)) { ERR("Failed to copy name.\n"); @@ -1417,7 +1417,7 @@ static HRESULT d3dcompiler_parse_variables(struct d3dcompiler_shader_reflection_ } if ((cb->reflection->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK) >= 0x500) - skip_dword_unknown(&ptr, 4); + skip_u32_unknown(&ptr, 4); } cb->variables = variables; @@ -1433,50 +1433,50 @@ err_out: return hr; } -static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, const char *data, DWORD data_size) +static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size) { struct d3dcompiler_shader_reflection_constant_buffer *constant_buffers = NULL; - DWORD offset, cbuffer_offset, resource_offset, creator_offset; + uint32_t offset, cbuffer_offset, resource_offset, creator_offset; unsigned int i, string_data_offset, string_data_size; D3D12_SHADER_INPUT_BIND_DESC *bound_resources = NULL; char *string_data = NULL, *creator = NULL; - DWORD size = data_size >> 2; + size_t size = data_size >> 2; + uint32_t target_version; const char *ptr = data; - DWORD target_version; HRESULT hr; - TRACE("Size %lu\n", size); + TRACE("Size %Iu.\n", size); - r->constant_buffer_count = read_dword(&ptr); - TRACE("Constant buffer count: %u\n", r->constant_buffer_count); + r->constant_buffer_count = read_u32(&ptr); + TRACE("Constant buffer count: %u.\n", r->constant_buffer_count); - cbuffer_offset = read_dword(&ptr); - TRACE("Constant buffer offset: %#lx\n", cbuffer_offset); + cbuffer_offset = read_u32(&ptr); + TRACE("Constant buffer offset: %#x.\n", cbuffer_offset); - r->bound_resource_count = read_dword(&ptr); - TRACE("Bound resource count: %u\n", r->bound_resource_count); + r->bound_resource_count = read_u32(&ptr); + TRACE("Bound resource count: %u.\n", r->bound_resource_count); - resource_offset = read_dword(&ptr); - TRACE("Bound resource offset: %#lx\n", resource_offset); + resource_offset = read_u32(&ptr); + TRACE("Bound resource offset: %#x.\n", resource_offset); - r->target = read_dword(&ptr); - TRACE("Target: %#lx\n", r->target); + r->target = read_u32(&ptr); + TRACE("Target: %#x.\n", r->target); target_version = r->target & D3DCOMPILER_SHADER_TARGET_VERSION_MASK; #if D3D_COMPILER_VERSION < 47 if (target_version >= 0x501) { - WARN("Target version %#lx is not supported in d3dcompiler %u.\n", target_version, D3D_COMPILER_VERSION); + WARN("Target version %#x is not supported in d3dcompiler %u.\n", target_version, D3D_COMPILER_VERSION); return E_INVALIDARG; } #endif - r->flags = read_dword(&ptr); - TRACE("Flags: %u\n", r->flags); + r->flags = read_u32(&ptr); + TRACE("Flags: %u.\n", r->flags); - creator_offset = read_dword(&ptr); - TRACE("Creator at offset %#lx.\n", creator_offset); + creator_offset = read_u32(&ptr); + TRACE("Creator at offset %#x.\n", creator_offset); if (!copy_name(data + creator_offset, &creator)) { @@ -1488,13 +1488,13 @@ static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, c /* todo: Parse RD11 */ if (target_version >= 0x500) { - skip_dword_unknown(&ptr, 8); + skip_u32_unknown(&ptr, 8); } if (r->bound_resource_count) { /* 8 for each bind desc */ - string_data_offset = resource_offset + r->bound_resource_count * 8 * sizeof(DWORD); + string_data_offset = resource_offset + r->bound_resource_count * 8 * sizeof(uint32_t); string_data_size = (cbuffer_offset ? cbuffer_offset : creator_offset) - string_data_offset; string_data = HeapAlloc(GetProcessHeap(), 0, string_data_size); @@ -1519,36 +1519,36 @@ static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, c { D3D12_SHADER_INPUT_BIND_DESC *desc = &bound_resources[i]; - offset = read_dword(&ptr); + offset = read_u32(&ptr); desc->Name = string_data + (offset - string_data_offset); - TRACE("Input bind Name: %s\n", debugstr_a(desc->Name)); + TRACE("Input bind Name: %s.\n", debugstr_a(desc->Name)); - desc->Type = read_dword(&ptr); - TRACE("Input bind Type: %#x\n", desc->Type); + desc->Type = read_u32(&ptr); + TRACE("Input bind Type: %#x.\n", desc->Type); - desc->ReturnType = read_dword(&ptr); - TRACE("Input bind ReturnType: %#x\n", desc->ReturnType); + desc->ReturnType = read_u32(&ptr); + TRACE("Input bind ReturnType: %#x.\n", desc->ReturnType); - desc->Dimension = read_dword(&ptr); - TRACE("Input bind Dimension: %#x\n", desc->Dimension); + desc->Dimension = read_u32(&ptr); + TRACE("Input bind Dimension: %#x.\n", desc->Dimension); - desc->NumSamples = read_dword(&ptr); - TRACE("Input bind NumSamples: %u\n", desc->NumSamples); + desc->NumSamples = read_u32(&ptr); + TRACE("Input bind NumSamples: %u.\n", desc->NumSamples); - desc->BindPoint = read_dword(&ptr); - TRACE("Input bind BindPoint: %u\n", desc->BindPoint); + desc->BindPoint = read_u32(&ptr); + TRACE("Input bind BindPoint: %u.\n", desc->BindPoint); - desc->BindCount = read_dword(&ptr); - TRACE("Input bind BindCount: %u\n", desc->BindCount); + desc->BindCount = read_u32(&ptr); + TRACE("Input bind BindCount: %u.\n", desc->BindCount); - desc->uFlags = read_dword(&ptr); - TRACE("Input bind uFlags: %u\n", desc->uFlags); + desc->uFlags = read_u32(&ptr); + TRACE("Input bind uFlags: %u.\n", desc->uFlags); if (target_version >= 0x501) { - desc->Space = read_dword(&ptr); + desc->Space = read_u32(&ptr); TRACE("Input bind Space %u.\n", desc->Space); - desc->uID = read_dword(&ptr); + desc->uID = read_u32(&ptr); TRACE("Input bind uID %u.\n", desc->uID); } else @@ -1578,7 +1578,7 @@ static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, c cb->ID3D10ShaderReflectionConstantBuffer_iface.lpVtbl = &d3d10_shader_reflection_constant_buffer_vtbl; cb->reflection = r; - offset = read_dword(&ptr); + offset = read_u32(&ptr); if (!copy_name(data + offset, &cb->name)) { ERR("Failed to copy name.\n"); @@ -1587,11 +1587,11 @@ static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, c } TRACE("Name: %s.\n", debugstr_a(cb->name)); - cb->variable_count = read_dword(&ptr); - TRACE("Variable count: %u\n", cb->variable_count); + cb->variable_count = read_u32(&ptr); + TRACE("Variable count: %u.\n", cb->variable_count); - offset = read_dword(&ptr); - TRACE("Variable offset: %#lx\n", offset); + offset = read_u32(&ptr); + TRACE("Variable offset: %x.\n", offset); hr = d3dcompiler_parse_variables(cb, data, data_size, data + offset); if (hr != S_OK) @@ -1600,14 +1600,14 @@ static HRESULT d3dcompiler_parse_rdef(struct d3dcompiler_shader_reflection *r, c goto err_out; } - cb->size = read_dword(&ptr); - TRACE("Cbuffer size: %u\n", cb->size); + cb->size = read_u32(&ptr); + TRACE("Cbuffer size: %u.\n", cb->size); - cb->flags = read_dword(&ptr); - TRACE("Cbuffer flags: %u\n", cb->flags); + cb->flags = read_u32(&ptr); + TRACE("Cbuffer flags: %u.\n", cb->flags); - cb->type = read_dword(&ptr); - TRACE("Cbuffer type: %#x\n", cb->type); + cb->type = read_u32(&ptr); + TRACE("Cbuffer type: %#x.\n", cb->type); } } @@ -1633,14 +1633,13 @@ err_out: static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature *s, struct dxbc_section *section) { + enum D3DCOMPILER_SIGNATURE_ELEMENT_SIZE element_size; D3D11_SIGNATURE_PARAMETER_DESC *d; unsigned int string_data_offset; - unsigned int string_data_size; const char *ptr = section->data; + unsigned int string_data_size; + unsigned int i, count; char *string_data; - unsigned int i; - DWORD count; - enum D3DCOMPILER_SIGNATURE_ELEMENT_SIZE element_size; switch (section->tag) { @@ -1660,10 +1659,10 @@ static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature * break; } - count = read_dword(&ptr); - TRACE("%lu elements\n", count); + count = read_u32(&ptr); + TRACE("%u elements\n", count); - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); d = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*d)); if (!d) @@ -1672,8 +1671,8 @@ static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature * return E_OUTOFMEMORY; } - /* 2 DWORDs for the header, element_size for each element. */ - string_data_offset = 2 * sizeof(DWORD) + count * element_size * sizeof(DWORD); + /* 2 u32s for the header, element_size for each element. */ + string_data_offset = 2 * sizeof(uint32_t) + count * element_size * sizeof(uint32_t); string_data_size = section->data_size - string_data_offset; string_data = HeapAlloc(GetProcessHeap(), 0, string_data_size); @@ -1687,8 +1686,7 @@ static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature * for (i = 0; i < count; ++i) { - UINT name_offset; - DWORD mask; + uint32_t name_offset, mask; #if D3D_COMPILER_VERSION >= 46 /* FIXME */ @@ -1696,20 +1694,20 @@ static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature * #endif if (element_size == D3DCOMPILER_SIGNATURE_ELEMENT_SIZE7) { - d[i].Stream = read_dword(&ptr); + d[i].Stream = read_u32(&ptr); } else { d[i].Stream = 0; } - name_offset = read_dword(&ptr); + name_offset = read_u32(&ptr); d[i].SemanticName = string_data + (name_offset - string_data_offset); - d[i].SemanticIndex = read_dword(&ptr); - d[i].SystemValueType = read_dword(&ptr); - d[i].ComponentType = read_dword(&ptr); - d[i].Register = read_dword(&ptr); - mask = read_dword(&ptr); + d[i].SemanticIndex = read_u32(&ptr); + d[i].SystemValueType = read_u32(&ptr); + d[i].ComponentType = read_u32(&ptr); + d[i].Register = read_u32(&ptr); + mask = read_u32(&ptr); d[i].ReadWriteMask = (mask >> 8) & 0xff; d[i].Mask = mask & 0xff; @@ -1737,11 +1735,11 @@ static HRESULT d3dcompiler_parse_signature(struct d3dcompiler_shader_signature * return S_OK; } -static HRESULT d3dcompiler_parse_shdr(struct d3dcompiler_shader_reflection *r, const char *data, DWORD data_size) +static HRESULT d3dcompiler_parse_shdr(struct d3dcompiler_shader_reflection *r, const char *data, size_t data_size) { const char *ptr = data; - r->version = read_dword(&ptr); + r->version = read_u32(&ptr); TRACE("Shader version: %u\n", r->version); /* todo: Check if anything else is needed from the shdr or shex blob. */ @@ -2353,8 +2351,8 @@ HRESULT WINAPI D3D10ReflectShader(const void *data, SIZE_T data_size, ID3D10Shad HRESULT WINAPI D3DReflect(const void *data, SIZE_T data_size, REFIID riid, void **reflector) { struct d3dcompiler_shader_reflection *object; + const uint32_t *temp = data; HRESULT hr; - const DWORD *temp = data; TRACE("data %p, data_size %Iu, riid %s, blob %p.\n", data, data_size, debugstr_guid(riid), reflector); diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c index 7d5c5395d6a..a8c13a63b67 100644 --- a/dlls/d3dcompiler_43/utils.c +++ b/dlls/d3dcompiler_43/utils.c @@ -125,7 +125,7 @@ const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part) } } -const char *debug_print_srcmod(DWORD mod) +const char *debug_print_srcmod(uint32_t mod) { switch (mod) { @@ -143,14 +143,14 @@ const char *debug_print_srcmod(DWORD mod) WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG); WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT); default: - FIXME("Unrecognized source modifier %#lx.\n", mod); + FIXME("Unrecognized source modifier %#x.\n", mod); return "unrecognized_src_mod"; } } #undef WINE_D3DCOMPILER_TO_STR -const char *debug_print_dstmod(DWORD mod) +const char *debug_print_dstmod(uint32_t mod) { switch (mod) { @@ -175,7 +175,7 @@ const char *debug_print_dstmod(DWORD mod) } } -const char *debug_print_shift(DWORD shift) +const char *debug_print_shift(uint32_t shift) { static const char * const shiftstrings[] = { @@ -204,15 +204,15 @@ static const char *get_regname(const struct shader_reg *reg) switch (reg->type) { case BWRITERSPR_TEMP: - return wine_dbg_sprintf("r%lu", reg->regnum); + return wine_dbg_sprintf("r%u", reg->regnum); case BWRITERSPR_INPUT: - return wine_dbg_sprintf("v%lu", reg->regnum); + return wine_dbg_sprintf("v%u", reg->regnum); case BWRITERSPR_CONST: - return wine_dbg_sprintf("c%lu", reg->regnum); + return wine_dbg_sprintf("c%u", reg->regnum); case BWRITERSPR_ADDR: - return wine_dbg_sprintf("a%lu", reg->regnum); + return wine_dbg_sprintf("a%u", reg->regnum); case BWRITERSPR_TEXTURE: - return wine_dbg_sprintf("t%lu", reg->regnum); + return wine_dbg_sprintf("t%u", reg->regnum); case BWRITERSPR_RASTOUT: switch (reg->regnum) { @@ -222,21 +222,21 @@ static const char *get_regname(const struct shader_reg *reg) default: return "Unexpected RASTOUT"; } case BWRITERSPR_ATTROUT: - return wine_dbg_sprintf("oD%lu", reg->regnum); + return wine_dbg_sprintf("oD%u", reg->regnum); case BWRITERSPR_TEXCRDOUT: - return wine_dbg_sprintf("oT%lu", reg->regnum); + return wine_dbg_sprintf("oT%u", reg->regnum); case BWRITERSPR_OUTPUT: - return wine_dbg_sprintf("o%lu", reg->regnum); + return wine_dbg_sprintf("o%u", reg->regnum); case BWRITERSPR_CONSTINT: - return wine_dbg_sprintf("i%lu", reg->regnum); + return wine_dbg_sprintf("i%u", reg->regnum); case BWRITERSPR_COLOROUT: - return wine_dbg_sprintf("oC%lu", reg->regnum); + return wine_dbg_sprintf("oC%u", reg->regnum); case BWRITERSPR_DEPTHOUT: return "oDepth"; case BWRITERSPR_SAMPLER: - return wine_dbg_sprintf("s%lu", reg->regnum); + return wine_dbg_sprintf("s%u", reg->regnum); case BWRITERSPR_CONSTBOOL: - return wine_dbg_sprintf("b%lu", reg->regnum); + return wine_dbg_sprintf("b%u", reg->regnum); case BWRITERSPR_LOOP: return "aL"; case BWRITERSPR_MISCTYPE: @@ -247,15 +247,15 @@ static const char *get_regname(const struct shader_reg *reg) default: return "unexpected misctype"; } case BWRITERSPR_LABEL: - return wine_dbg_sprintf("l%lu", reg->regnum); + return wine_dbg_sprintf("l%u", reg->regnum); case BWRITERSPR_PREDICATE: - return wine_dbg_sprintf("p%lu", reg->regnum); + return wine_dbg_sprintf("p%u", reg->regnum); default: - return wine_dbg_sprintf("unknown regname %#lx", reg->type); + return wine_dbg_sprintf("unknown regname %#x", reg->type); } } -static const char *debug_print_writemask(DWORD mask) +static const char *debug_print_writemask(uint32_t mask) { char ret[6]; unsigned char pos = 1; @@ -271,11 +271,11 @@ static const char *debug_print_writemask(DWORD mask) return wine_dbg_sprintf("%s", ret); } -static const char *debug_print_swizzle(DWORD arg) +static const char *debug_print_swizzle(uint32_t arg) { char ret[6]; unsigned int i; - DWORD swizzle[4]; + uint32_t swizzle[4]; switch (arg) { @@ -317,10 +317,10 @@ static const char *debug_print_relarg(const struct shader_reg *reg) const char *short_swizzle; if (!reg->rel_reg) return ""; - short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle); + short_swizzle = debug_print_swizzle(reg->rel_reg->swizzle); if (reg->rel_reg->type == BWRITERSPR_ADDR) - return wine_dbg_sprintf("[a%lu%s]", reg->rel_reg->regnum, short_swizzle); + return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle); else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0) return wine_dbg_sprintf("[aL%s]", short_swizzle); else @@ -331,7 +331,7 @@ const char *debug_print_dstreg(const struct shader_reg *reg) { return wine_dbg_sprintf("%s%s%s", get_regname(reg), debug_print_relarg(reg), - debug_print_writemask(reg->u.writemask)); + debug_print_writemask(reg->writemask)); } const char *debug_print_srcreg(const struct shader_reg *reg) @@ -341,64 +341,64 @@ const char *debug_print_srcreg(const struct shader_reg *reg) case BWRITERSPSM_NONE: return wine_dbg_sprintf("%s%s%s", get_regname(reg), debug_print_relarg(reg), - debug_print_swizzle(reg->u.swizzle)); + debug_print_swizzle(reg->swizzle)); case BWRITERSPSM_NEG: return wine_dbg_sprintf("-%s%s%s", get_regname(reg), debug_print_relarg(reg), - debug_print_swizzle(reg->u.swizzle)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->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)); + debug_print_swizzle(reg->swizzle)); case BWRITERSPSM_NOT: return wine_dbg_sprintf("!%s%s%s", get_regname(reg), debug_print_relarg(reg), - debug_print_swizzle(reg->u.swizzle)); + debug_print_swizzle(reg->swizzle)); } return "Unknown modifier"; } -const char *debug_print_comp(DWORD comp) +const char *debug_print_comp(uint32_t comp) { switch (comp) { @@ -413,7 +413,7 @@ const char *debug_print_comp(DWORD comp) } } -const char *debug_print_opcode(DWORD opcode) +const char *debug_print_opcode(uint32_t opcode) { switch (opcode) { @@ -507,28 +507,28 @@ const char *debug_print_opcode(DWORD opcode) } } -void skip_dword_unknown(const char **ptr, unsigned int count) +void skip_u32_unknown(const char **ptr, unsigned int count) { unsigned int i; - DWORD d; + uint32_t u32; - FIXME("Skipping %u unknown DWORDs:\n", count); + FIXME("Skipping %u unknown u32s:\n", count); for (i = 0; i < count; ++i) { - d = read_dword(ptr); - FIXME("\t0x%08lx\n", d); + u32 = read_u32(ptr); + FIXME("\t0x%08x\n", u32); } } -static void write_dword_unknown(char **ptr, DWORD d) +static void write_u32_unknown(char **ptr, uint32_t u32) { - FIXME("Writing unknown DWORD 0x%08lx.\n", d); - write_dword(ptr, d); + FIXME("Writing unknown u32 0x%08x.\n", u32); + write_u32(ptr, u32); } -HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size) +HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, size_t data_size) { - TRACE("dxbc %p, tag %s, size %#lx.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size); + TRACE("dxbc %p, tag %s, size %#Ix.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size); if (dxbc->count >= dxbc->size) { @@ -576,10 +576,10 @@ HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size) HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) { + uint32_t tag, total_size, chunk_count; const char *ptr = data; - HRESULT hr; unsigned int i; - DWORD tag, total_size, chunk_count; + HRESULT hr; if (!data) { @@ -587,7 +587,7 @@ HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) return E_FAIL; } - tag = read_dword(&ptr); + tag = read_u32(&ptr); TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4)); if (tag != TAG_DXBC) @@ -597,12 +597,12 @@ HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) } /* checksum? */ - skip_dword_unknown(&ptr, 4); + skip_u32_unknown(&ptr, 4); - skip_dword_unknown(&ptr, 1); + skip_u32_unknown(&ptr, 1); - total_size = read_dword(&ptr); - TRACE("total size: %#lx\n", total_size); + total_size = read_u32(&ptr); + TRACE("total size: %#x\n", total_size); if (data_size != total_size) { @@ -610,8 +610,8 @@ HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) return D3DERR_INVALIDCALL; } - chunk_count = read_dword(&ptr); - TRACE("chunk count: %#lx\n", chunk_count); + chunk_count = read_u32(&ptr); + TRACE("chunk count: %#x\n", chunk_count); hr = dxbc_init(dxbc, chunk_count); if (FAILED(hr)) @@ -622,17 +622,17 @@ HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) for (i = 0; i < chunk_count; ++i) { - DWORD chunk_tag, chunk_size; + uint32_t chunk_tag, chunk_size; const char *chunk_ptr; - DWORD chunk_offset; + uint32_t chunk_offset; - chunk_offset = read_dword(&ptr); - TRACE("chunk %u at offset %#lx\n", i, chunk_offset); + chunk_offset = read_u32(&ptr); + TRACE("chunk %u at offset %#x\n", i, chunk_offset); chunk_ptr = data + chunk_offset; - chunk_tag = read_dword(&chunk_ptr); - chunk_size = read_dword(&chunk_ptr); + chunk_tag = read_u32(&chunk_ptr); + chunk_size = read_u32(&chunk_ptr); hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size); if (FAILED(hr)) @@ -676,35 +676,35 @@ HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob) ptr = ID3D10Blob_GetBufferPointer(object); - write_dword(&ptr, TAG_DXBC); + write_u32(&ptr, TAG_DXBC); /* signature(?) */ - write_dword_unknown(&ptr, 0); - write_dword_unknown(&ptr, 0); - write_dword_unknown(&ptr, 0); - write_dword_unknown(&ptr, 0); + write_u32_unknown(&ptr, 0); + write_u32_unknown(&ptr, 0); + write_u32_unknown(&ptr, 0); + write_u32_unknown(&ptr, 0); /* seems to be always 1 */ - write_dword_unknown(&ptr, 1); + write_u32_unknown(&ptr, 1); /* DXBC size */ - write_dword(&ptr, size); + write_u32(&ptr, size); /* chunk count */ - write_dword(&ptr, dxbc->count); + write_u32(&ptr, dxbc->count); /* write the chunk offsets */ for (i = 0; i < dxbc->count; ++i) { - write_dword(&ptr, offset); + write_u32(&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); + write_u32(&ptr, dxbc->sections[i].tag); + write_u32(&ptr, dxbc->sections[i].data_size); memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size); ptr += dxbc->sections[i].data_size; }