?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vbscript: Fix a typo: jscript -> vbscript.
[wine.git] / dlls / d3dcompiler_43 / asmparser.c
blobc57343f9fceea79d9fcb43348281e914c705ebda
1 /*
2 * Direct3D asm shader parser
3 *
4 * Copyright 2008 Stefan Dösinger
5 * Copyright 2009 Matteo Bruni
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25 #include "wine/debug.h"
26
27 #include "d3dcompiler_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(asmshader);
30 WINE_DECLARE_DEBUG_CHANNEL(parsed_shader);
31
32
33 /* How to map vs 1.0 and 2.0 varyings to 3.0 ones
34 * oTx is mapped to ox, which happens to be an
35 * identical mapping since BWRITERSPR_TEXCRDOUT == BWRITERSPR_OUTPUT
36 * oPos, oFog and point size are mapped to general output regs as well.
37 * the vs 1.x and 2.x parser functions add varying declarations
38 * to the shader, and the 1.x and 2.x output functions check those varyings
39 */
40 #define OT0_REG 0
41 #define OT1_REG 1
42 #define OT2_REG 2
43 #define OT3_REG 3
44 #define OT4_REG 4
45 #define OT5_REG 5
46 #define OT6_REG 6
47 #define OT7_REG 7
48 #define OPOS_REG 8
49 #define OFOG_REG 9
50 #define OFOG_WRITEMASK BWRITERSP_WRITEMASK_0
51 #define OPTS_REG 9
52 #define OPTS_WRITEMASK BWRITERSP_WRITEMASK_1
53 #define OD0_REG 10
54 #define OD1_REG 11
55
56 /* Input color registers 0-1 are identically mapped */
57 #define C0_VARYING 0
58 #define C1_VARYING 1
59 #define T0_VARYING 2
60 #define T1_VARYING 3
61 #define T2_VARYING 4
62 #define T3_VARYING 5
63 #define T4_VARYING 6
64 #define T5_VARYING 7
65 #define T6_VARYING 8
66 #define T7_VARYING 9
67
68 /****************************************************************
69 * Common(non-version specific) shader parser control code *
70 ****************************************************************/
71
72 static void asmparser_end(struct asm_parser *This) {
73 TRACE("Finalizing shader\n");
74 }
75
76 static void asmparser_constF(struct asm_parser *This, DWORD reg, float x, float y, float z, float w) {
77 if(!This->shader) return;
78 TRACE("Adding float constant %u at pos %u\n", reg, This->shader->num_cf);
79 TRACE_(parsed_shader)("def c%u, %f, %f, %f, %f\n", reg, x, y, z, w);
80 if(!add_constF(This->shader, reg, x, y, z, w)) {
81 ERR("Out of memory\n");
82 set_parse_status(&This->status, PARSE_ERR);
83 }
84 }
85
86 static void asmparser_constB(struct asm_parser *This, DWORD reg, BOOL x) {
87 if(!This->shader) return;
88 TRACE("Adding boolean constant %u at pos %u\n", reg, This->shader->num_cb);
89 TRACE_(parsed_shader)("def b%u, %s\n", reg, x ? "true" : "false");
90 if(!add_constB(This->shader, reg, x)) {
91 ERR("Out of memory\n");
92 set_parse_status(&This->status, PARSE_ERR);
93 }
94 }
95
96 static void asmparser_constI(struct asm_parser *This, DWORD reg, INT x, INT y, INT z, INT w) {
97 if(!This->shader) return;
98 TRACE("Adding integer constant %u at pos %u\n", reg, This->shader->num_ci);
99 TRACE_(parsed_shader)("def i%u, %d, %d, %d, %d\n", reg, x, y, z, w);
100 if(!add_constI(This->shader, reg, x, y, z, w)) {
101 ERR("Out of memory\n");
102 set_parse_status(&This->status, PARSE_ERR);
103 }
104 }
105
106 static void asmparser_dcl_output(struct asm_parser *This, DWORD usage, DWORD num,
107 const struct shader_reg *reg) {
108 if(!This->shader) return;
109 if(This->shader->type == ST_PIXEL) {
110 asmparser_message(This, "Line %u: Output register declared in a pixel shader\n", This->line_no);
111 set_parse_status(&This->status, PARSE_ERR);
112 }
113 if(!record_declaration(This->shader, usage, num, 0, TRUE, reg->regnum, reg->u.writemask, FALSE)) {
114 ERR("Out of memory\n");
115 set_parse_status(&This->status, PARSE_ERR);
116 }
117 }
118
119 static void asmparser_dcl_output_unsupported(struct asm_parser *This, DWORD usage, DWORD num,
120 const struct shader_reg *reg) {
121 asmparser_message(This, "Line %u: Output declaration unsupported in this shader version\n", This->line_no);
122 set_parse_status(&This->status, PARSE_ERR);
123 }
124
125 static void asmparser_dcl_input(struct asm_parser *This, DWORD usage, DWORD num,
126 DWORD mod, const struct shader_reg *reg) {
127 struct instruction instr;
128
129 if(!This->shader) return;
130 if(mod != 0 &&
131 (This->shader->version != BWRITERPS_VERSION(3, 0) ||
132 (mod != BWRITERSPDM_MSAMPCENTROID &&
133 mod != BWRITERSPDM_PARTIALPRECISION))) {
134 asmparser_message(This, "Line %u: Unsupported modifier in dcl instruction\n", This->line_no);
135 set_parse_status(&This->status, PARSE_ERR);
136 return;
137 }
138
139 /* Check register type and modifiers */
140 instr.dstmod = mod;
141 instr.shift = 0;
142 This->funcs->dstreg(This, &instr, reg);
143
144 if(!record_declaration(This->shader, usage, num, mod, FALSE, reg->regnum, reg->u.writemask, FALSE)) {
145 ERR("Out of memory\n");
146 set_parse_status(&This->status, PARSE_ERR);
147 }
148 }
149
150 static void asmparser_dcl_input_ps_2(struct asm_parser *This, DWORD usage, DWORD num,
151 DWORD mod, const struct shader_reg *reg) {
152 struct instruction instr;
153
154 if(!This->shader) return;
155 instr.dstmod = mod;
156 instr.shift = 0;
157 This->funcs->dstreg(This, &instr, reg);
158 if(!record_declaration(This->shader, usage, num, mod, FALSE, instr.dst.regnum, instr.dst.u.writemask, FALSE)) {
159 ERR("Out of memory\n");
160 set_parse_status(&This->status, PARSE_ERR);
161 }
162 }
163
164 static void asmparser_dcl_input_unsupported(struct asm_parser *This,
165 DWORD usage, DWORD num, DWORD mod, const struct shader_reg *reg)
166 {
167 asmparser_message(This, "Line %u: Input declaration unsupported in this shader version\n", This->line_no);
168 set_parse_status(&This->status, PARSE_ERR);
169 }
170
171 static void asmparser_dcl_sampler(struct asm_parser *This, DWORD samptype,
172 DWORD mod, DWORD regnum,
173 unsigned int line_no) {
174 if(!This->shader) return;
175 if(mod != 0 &&
176 (This->shader->version != BWRITERPS_VERSION(3, 0) ||
177 (mod != BWRITERSPDM_MSAMPCENTROID &&
178 mod != BWRITERSPDM_PARTIALPRECISION))) {
179 asmparser_message(This, "Line %u: Unsupported modifier in dcl instruction\n", This->line_no);
180 set_parse_status(&This->status, PARSE_ERR);
181 return;
182 }
183 if(!record_sampler(This->shader, samptype, mod, regnum)) {
184 ERR("Out of memory\n");
185 set_parse_status(&This->status, PARSE_ERR);
186 }
187 }
188
189 static void asmparser_dcl_sampler_unsupported(struct asm_parser *This,
190 DWORD samptype, DWORD mod, DWORD regnum, unsigned int line_no)
191 {
192 asmparser_message(This, "Line %u: Sampler declaration unsupported in this shader version\n", This->line_no);
193 set_parse_status(&This->status, PARSE_ERR);
194 }
195
196 static void asmparser_sincos(struct asm_parser *This, DWORD mod, DWORD shift,
197 const struct shader_reg *dst,
198 const struct src_regs *srcs) {
199 struct instruction *instr;
200
201 if(!srcs || srcs->count != 3) {
202 asmparser_message(This, "Line %u: sincos (vs 2) has an incorrect number of source registers\n", This->line_no);
203 set_parse_status(&This->status, PARSE_ERR);
204 return;
205 }
206
207 instr = alloc_instr(3);
208 if(!instr) {
209 ERR("Error allocating memory for the instruction\n");
210 set_parse_status(&This->status, PARSE_ERR);
211 return;
212 }
213
214 instr->opcode = BWRITERSIO_SINCOS;
215 instr->dstmod = mod;
216 instr->shift = shift;
217 instr->comptype = 0;
218
219 This->funcs->dstreg(This, instr, dst);
220 This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
221 This->funcs->srcreg(This, instr, 1, &srcs->reg[1]);
222 This->funcs->srcreg(This, instr, 2, &srcs->reg[2]);
223
224 if(!add_instruction(This->shader, instr)) {
225 ERR("Out of memory\n");
226 set_parse_status(&This->status, PARSE_ERR);
227 }
228 }
229
230 static struct shader_reg map_oldps_register(const struct shader_reg *reg, BOOL tex_varying) {
231 struct shader_reg ret;
232 switch(reg->type) {
233 case BWRITERSPR_TEXTURE:
234 if(tex_varying) {
235 ret = *reg;
236 ret.type = BWRITERSPR_INPUT;
237 switch(reg->regnum) {
238 case 0: ret.regnum = T0_VARYING; break;
239 case 1: ret.regnum = T1_VARYING; break;
240 case 2: ret.regnum = T2_VARYING; break;
241 case 3: ret.regnum = T3_VARYING; break;
242 case 4: ret.regnum = T4_VARYING; break;
243 case 5: ret.regnum = T5_VARYING; break;
244 case 6: ret.regnum = T6_VARYING; break;
245 case 7: ret.regnum = T7_VARYING; break;
246 default:
247 FIXME("Unexpected TEXTURE register t%u\n", reg->regnum);
248 return *reg;
249 }
250 return ret;
251 } else {
252 ret = *reg;
253 ret.type = BWRITERSPR_TEMP;
254 switch(reg->regnum) {
255 case 0: ret.regnum = T0_REG; break;
256 case 1: ret.regnum = T1_REG; break;
257 case 2: ret.regnum = T2_REG; break;
258 case 3: ret.regnum = T3_REG; break;
259 default:
260 FIXME("Unexpected TEXTURE register t%u\n", reg->regnum);
261 return *reg;
262 }
263 return ret;
264 }
265
266 /* case BWRITERSPR_INPUT - Identical mapping of 1.x/2.0 color varyings
267 to 3.0 ones */
268
269 default: return *reg;
270 }
271 }
272
273 static void asmparser_texcoord(struct asm_parser *This, DWORD mod, DWORD shift,
274 const struct shader_reg *dst,
275 const struct src_regs *srcs) {
276 struct instruction *instr;
277
278 if(srcs) {
279 asmparser_message(This, "Line %u: Source registers in texcoord instruction\n", This->line_no);
280 set_parse_status(&This->status, PARSE_ERR);
281 return;
282 }
283
284 instr = alloc_instr(1);
285 if(!instr) {
286 ERR("Error allocating memory for the instruction\n");
287 set_parse_status(&This->status, PARSE_ERR);
288 return;
289 }
290
291 /* texcoord copies the texture coord data into a temporary register-like
292 * readable form. In newer shader models this equals a MOV from v0 to r0,
293 * record it as this.
294 */
295 instr->opcode = BWRITERSIO_MOV;
296 instr->dstmod = mod | BWRITERSPDM_SATURATE; /* texcoord clamps to [0;1] */
297 instr->shift = shift;
298 instr->comptype = 0;
299
300 This->funcs->dstreg(This, instr, dst);
301 /* The src reg needs special care */
302 instr->src[0] = map_oldps_register(dst, TRUE);
303
304 if(!add_instruction(This->shader, instr)) {
305 ERR("Out of memory\n");
306 set_parse_status(&This->status, PARSE_ERR);
307 }
308 }
309
310 static void asmparser_texcrd(struct asm_parser *This, DWORD mod, DWORD shift,
311 const struct shader_reg *dst,
312 const struct src_regs *srcs) {
313 struct instruction *instr;
314
315 if(!srcs || srcs->count != 1) {
316 asmparser_message(This, "Line %u: Wrong number of source registers in texcrd instruction\n", This->line_no);
317 set_parse_status(&This->status, PARSE_ERR);
318 return;
319 }
320
321 instr = alloc_instr(1);
322 if(!instr) {
323 ERR("Error allocating memory for the instruction\n");
324 set_parse_status(&This->status, PARSE_ERR);
325 return;
326 }
327
328 /* The job of texcrd is done by mov in later shader versions */
329 instr->opcode = BWRITERSIO_MOV;
330 instr->dstmod = mod;
331 instr->shift = shift;
332 instr->comptype = 0;
333
334 This->funcs->dstreg(This, instr, dst);
335 This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
336
337 if(!add_instruction(This->shader, instr)) {
338 ERR("Out of memory\n");
339 set_parse_status(&This->status, PARSE_ERR);
340 }
341 }
342
343 static void asmparser_texkill(struct asm_parser *This,
344 const struct shader_reg *dst) {
345 struct instruction *instr = alloc_instr(0);
346
347 if(!instr) {
348 ERR("Error allocating memory for the instruction\n");
349 set_parse_status(&This->status, PARSE_ERR);
350 return;
351 }
352
353 instr->opcode = BWRITERSIO_TEXKILL;
354 instr->dstmod = 0;
355 instr->shift = 0;
356 instr->comptype = 0;
357
358 /* Do not run the dst register through the normal
359 * register conversion. If used with ps_1_0 to ps_1_3
360 * the texture coordinate from that register is used,
361 * not the temporary register value. In ps_1_4 and
362 * ps_2_0 t0 is always a varying and temporaries can
363 * be used with texkill.
364 */
365 instr->dst = map_oldps_register(dst, TRUE);
366 instr->has_dst = TRUE;
367
368 if(!add_instruction(This->shader, instr)) {
369 ERR("Out of memory\n");
370 set_parse_status(&This->status, PARSE_ERR);
371 }
372 }
373
374 static void asmparser_texhelper(struct asm_parser *This, DWORD mod, DWORD shift,
375 const struct shader_reg *dst,
376 const struct shader_reg *src0) {
377 struct instruction *instr = alloc_instr(2);
378
379 if(!instr) {
380 ERR("Error allocating memory for the instruction\n");
381 set_parse_status(&This->status, PARSE_ERR);
382 return;
383 }
384
385 instr->opcode = BWRITERSIO_TEX;
386 instr->dstmod = mod;
387 instr->shift = shift;
388 instr->comptype = 0;
389 /* The dest register can be mapped normally to a temporary register */
390 This->funcs->dstreg(This, instr, dst);
391 /* Use the src passed as parameter by the specific instruction handler */
392 instr->src[0] = *src0;
393
394 /* The 2nd source register is the sampler register with the
395 * destination's regnum
396 */
397 ZeroMemory(&instr->src[1], sizeof(instr->src[1]));
398 instr->src[1].type = BWRITERSPR_SAMPLER;
399 instr->src[1].regnum = dst->regnum;
400 instr->src[1].u.swizzle = BWRITERVS_NOSWIZZLE;
401 instr->src[1].srcmod = BWRITERSPSM_NONE;
402 instr->src[1].rel_reg = NULL;
403
404 if(!add_instruction(This->shader, instr)) {
405 ERR("Out of memory\n");
406 set_parse_status(&This->status, PARSE_ERR);
407 }
408 }
409
410 static void asmparser_tex(struct asm_parser *This, DWORD mod, DWORD shift,
411 const struct shader_reg *dst) {
412 struct shader_reg src;
413
414 /* The first source register is the varying containing the coordinate */
415 src = map_oldps_register(dst, TRUE);
416 asmparser_texhelper(This, mod, shift, dst, &src);
417 }
418
419 static void asmparser_texld14(struct asm_parser *This, DWORD mod, DWORD shift,
420 const struct shader_reg *dst,
421 const struct src_regs *srcs) {
422 struct instruction *instr;
423
424 if(!srcs || srcs->count != 1) {
425 asmparser_message(This, "Line %u: texld (PS 1.4) has a wrong number of source registers\n", This->line_no);
426 set_parse_status(&This->status, PARSE_ERR);
427 return;
428 }
429
430 instr = alloc_instr(2);
431 if(!instr) {
432 ERR("Error allocating memory for the instruction\n");
433 set_parse_status(&This->status, PARSE_ERR);
434 return;
435 }
436
437 /* This code is recording a texld instruction, not tex. However,
438 * texld borrows the opcode of tex
439 */
440 instr->opcode = BWRITERSIO_TEX;
441 instr->dstmod = mod;
442 instr->shift = shift;
443 instr->comptype = 0;
444
445 This->funcs->dstreg(This, instr, dst);
446 This->funcs->srcreg(This, instr, 0, &srcs->reg[0]);
447
448 /* The 2nd source register is the sampler register with the
449 * destination's regnum
450 */
451 ZeroMemory(&instr->src[1], sizeof(instr->src[1]));
452 instr->src[1].type = BWRITERSPR_SAMPLER;
453 instr->src[1].regnum = dst->regnum;
454 instr->src[1].u.swizzle = BWRITERVS_NOSWIZZLE;
455 instr->src[1].srcmod = BWRITERSPSM_NONE;
456 instr->src[1].rel_reg = NULL;
457
458 if(!add_instruction(This->shader, instr)) {
459 ERR("Out of memory\n");
460 set_parse_status(&This->status, PARSE_ERR);
461 }
462 }
463
464 static void asmparser_texreg2ar(struct asm_parser *This, DWORD mod, DWORD shift,
465 const struct shader_reg *dst,
466 const struct shader_reg *src0) {
467 struct shader_reg src;
468
469 src = map_oldps_register(src0, FALSE);
470 /* Supply the correct swizzle */
471 src.u.swizzle = BWRITERVS_X_W | BWRITERVS_Y_X | BWRITERVS_Z_X | BWRITERVS_W_X;
472 asmparser_texhelper(This, mod, shift, dst, &src);
473 }
474
475 static void asmparser_texreg2gb(struct asm_parser *This, DWORD mod, DWORD shift,
476 const struct shader_reg *dst,
477 const struct shader_reg *src0) {
478 struct shader_reg src;
479
480 src = map_oldps_register(src0, FALSE);
481 /* Supply the correct swizzle */
482 src.u.swizzle = BWRITERVS_X_Y | BWRITERVS_Y_Z | BWRITERVS_Z_Z | BWRITERVS_W_Z;
483 asmparser_texhelper(This, mod, shift, dst, &src);
484 }
485
486 static void asmparser_texreg2rgb(struct asm_parser *This, DWORD mod, DWORD shift,
487 const struct shader_reg *dst,
488 const struct shader_reg *src0) {
489 struct shader_reg src;
490
491 src = map_oldps_register(src0, FALSE);
492 /* Supply the correct swizzle */
493 src.u.swizzle = BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_Z;
494 asmparser_texhelper(This, mod, shift, dst, &src);
495 }
496
497 /* Complex pixel shader 1.3 instructions like texm3x3tex are tricky - the
498 * bytecode writer works instruction by instruction, so we can't properly
499 * convert these from/to equivalent ps_3_0 instructions. Then simply keep using
500 * the ps_1_3 opcodes and just adapt the registers in the common fashion (i.e.
501 * go through asmparser_instr).
502 */
503
504 static void asmparser_instr(struct asm_parser *This, DWORD opcode,
505 DWORD mod, DWORD shift,
506 BWRITER_COMPARISON_TYPE comp,
507 const struct shader_reg *dst,
508 const struct src_regs *srcs, int expectednsrcs) {
509 struct instruction *instr;
510 unsigned int i;
511 BOOL firstreg = TRUE;
512 unsigned int src_count = srcs ? srcs->count : 0;
513
514 if(!This->shader) return;
515
516 TRACE_(parsed_shader)("%s%s%s%s ", debug_print_opcode(opcode),
517 debug_print_dstmod(mod),
518 debug_print_shift(shift),
519 debug_print_comp(comp));
520 if(dst) {
521 TRACE_(parsed_shader)("%s", debug_print_dstreg(dst));
522 firstreg = FALSE;
523 }
524 for(i = 0; i < src_count; i++) {
525 if(!firstreg) TRACE_(parsed_shader)(", ");
526 else firstreg = FALSE;
527 TRACE_(parsed_shader)("%s", debug_print_srcreg(&srcs->reg[i]));
528 }
529 TRACE_(parsed_shader)("\n");
530
531 /* Check for instructions with different syntaxes in different shader versions */
532 switch(opcode) {
533 case BWRITERSIO_SINCOS:
534 /* The syntax changes between vs 2 and the other shader versions */
535 if(This->shader->version == BWRITERVS_VERSION(2, 0) ||
536 This->shader->version == BWRITERVS_VERSION(2, 1)) {
537 asmparser_sincos(This, mod, shift, dst, srcs);
538 return;
539 }
540 /* Use the default handling */
541 break;
542 case BWRITERSIO_TEXCOORD:
543 /* texcoord/texcrd are two instructions present only in PS <= 1.3 and PS 1.4 respectively */
544 if(This->shader->version == BWRITERPS_VERSION(1, 4))
545 asmparser_texcrd(This, mod, shift, dst, srcs);
546 else asmparser_texcoord(This, mod, shift, dst, srcs);
547 return;
548 case BWRITERSIO_TEX:
549 /* this encodes both the tex PS 1.x instruction and the
550 texld 1.4/2.0+ instruction */
551 if(This->shader->version == BWRITERPS_VERSION(1, 0) ||
552 This->shader->version == BWRITERPS_VERSION(1, 1) ||
553 This->shader->version == BWRITERPS_VERSION(1, 2) ||
554 This->shader->version == BWRITERPS_VERSION(1, 3)) {
555 asmparser_tex(This, mod, shift, dst);
556 return;
557 }
558 else if(This->shader->version == BWRITERPS_VERSION(1, 4)) {
559 asmparser_texld14(This, mod, shift, dst, srcs);
560 return;
561 }
562 /* else fallback to the standard behavior */
563 break;
564 }
565
566 if(src_count != expectednsrcs) {
567 asmparser_message(This, "Line %u: Wrong number of source registers\n", This->line_no);
568 set_parse_status(&This->status, PARSE_ERR);
569 return;
570 }
571
572 /* Handle PS 1.x instructions, "regularizing" them */
573 switch(opcode) {
574 case BWRITERSIO_TEXKILL:
575 asmparser_texkill(This, dst);
576 return;
577 case BWRITERSIO_TEXREG2AR:
578 asmparser_texreg2ar(This, mod, shift, dst, &srcs->reg[0]);
579 return;
580 case BWRITERSIO_TEXREG2GB:
581 asmparser_texreg2gb(This, mod, shift, dst, &srcs->reg[0]);
582 return;
583 case BWRITERSIO_TEXREG2RGB:
584 asmparser_texreg2rgb(This, mod, shift, dst, &srcs->reg[0]);
585 return;
586 }
587
588 instr = alloc_instr(src_count);
589 if(!instr) {
590 ERR("Error allocating memory for the instruction\n");
591 set_parse_status(&This->status, PARSE_ERR);
592 return;
593 }
594
595 instr->opcode = opcode;
596 instr->dstmod = mod;
597 instr->shift = shift;
598 instr->comptype = comp;
599 if(dst) This->funcs->dstreg(This, instr, dst);
600 for(i = 0; i < src_count; i++) {
601 This->funcs->srcreg(This, instr, i, &srcs->reg[i]);
602 }
603
604 if(!add_instruction(This->shader, instr)) {
605 ERR("Out of memory\n");
606 set_parse_status(&This->status, PARSE_ERR);
607 }
608 }
609
610 static struct shader_reg map_oldvs_register(const struct shader_reg *reg) {
611 struct shader_reg ret;
612 switch(reg->type) {
613 case BWRITERSPR_RASTOUT:
614 ret = *reg;
615 ret.type = BWRITERSPR_OUTPUT;
616 switch(reg->regnum) {
617 case BWRITERSRO_POSITION:
618 ret.regnum = OPOS_REG;
619 break;
620 case BWRITERSRO_FOG:
621 ret.regnum = OFOG_REG;
622 ret.u.writemask = OFOG_WRITEMASK;
623 break;
624 case BWRITERSRO_POINT_SIZE:
625 ret.regnum = OPTS_REG;
626 ret.u.writemask = OPTS_WRITEMASK;
627 break;
628 default:
629 FIXME("Unhandled RASTOUT register %u\n", reg->regnum);
630 return *reg;
631 }
632 return ret;
633
634 case BWRITERSPR_TEXCRDOUT:
635 ret = *reg;
636 ret.type = BWRITERSPR_OUTPUT;
637 switch(reg->regnum) {
638 case 0: ret.regnum = OT0_REG; break;
639 case 1: ret.regnum = OT1_REG; break;
640 case 2: ret.regnum = OT2_REG; break;
641 case 3: ret.regnum = OT3_REG; break;
642 case 4: ret.regnum = OT4_REG; break;
643 case 5: ret.regnum = OT5_REG; break;
644 case 6: ret.regnum = OT6_REG; break;
645 case 7: ret.regnum = OT7_REG; break;
646 default:
647 FIXME("Unhandled TEXCRDOUT regnum %u\n", reg->regnum);
648 return *reg;
649 }
650 return ret;
651
652 case BWRITERSPR_ATTROUT:
653 ret = *reg;
654 ret.type = BWRITERSPR_OUTPUT;
655 switch(reg->regnum) {
656 case 0: ret.regnum = OD0_REG; break;
657 case 1: ret.regnum = OD1_REG; break;
658 default:
659 FIXME("Unhandled ATTROUT regnum %u\n", reg->regnum);
660 return *reg;
661 }
662 return ret;
663
664 default: return *reg;
665 }
666 }
667
668 /* Checks for unsupported source modifiers in VS (all versions) or
669 PS 2.0 and newer */
670 static void check_legacy_srcmod(struct asm_parser *This, DWORD srcmod) {
671 if(srcmod == BWRITERSPSM_BIAS || srcmod == BWRITERSPSM_BIASNEG ||
672 srcmod == BWRITERSPSM_SIGN || srcmod == BWRITERSPSM_SIGNNEG ||
673 srcmod == BWRITERSPSM_COMP || srcmod == BWRITERSPSM_X2 ||
674 srcmod == BWRITERSPSM_X2NEG || srcmod == BWRITERSPSM_DZ ||
675 srcmod == BWRITERSPSM_DW) {
676 asmparser_message(This, "Line %u: Source modifier %s not supported in this shader version\n",
677 This->line_no,
678 debug_print_srcmod(srcmod));
679 set_parse_status(&This->status, PARSE_ERR);
680 }
681 }
682
683 static void check_abs_srcmod(struct asm_parser *This, DWORD srcmod) {
684 if(srcmod == BWRITERSPSM_ABS || srcmod == BWRITERSPSM_ABSNEG) {
685 asmparser_message(This, "Line %u: Source modifier %s not supported in this shader version\n",
686 This->line_no,
687 debug_print_srcmod(srcmod));
688 set_parse_status(&This->status, PARSE_ERR);
689 }
690 }
691
692 static void check_loop_swizzle(struct asm_parser *This,
693 const struct shader_reg *src) {
694 if((src->type == BWRITERSPR_LOOP && src->u.swizzle != BWRITERVS_NOSWIZZLE) ||
695 (src->rel_reg && src->rel_reg->type == BWRITERSPR_LOOP &&
696 src->rel_reg->u.swizzle != BWRITERVS_NOSWIZZLE)) {
697 asmparser_message(This, "Line %u: Swizzle not allowed on aL register\n", This->line_no);
698 set_parse_status(&This->status, PARSE_ERR);
699 }
700 }
701
702 static void check_shift_dstmod(struct asm_parser *This, DWORD shift) {
703 if(shift != 0) {
704 asmparser_message(This, "Line %u: Shift modifiers not supported in this shader version\n",
705 This->line_no);
706 set_parse_status(&This->status, PARSE_ERR);
707 }
708 }
709
710 static void check_ps_dstmod(struct asm_parser *This, DWORD dstmod) {
711 if(dstmod == BWRITERSPDM_PARTIALPRECISION ||
712 dstmod == BWRITERSPDM_MSAMPCENTROID) {
713 asmparser_message(This, "Line %u: Instruction modifier %s not supported in this shader version\n",
714 This->line_no,
715 debug_print_dstmod(dstmod));
716 set_parse_status(&This->status, PARSE_ERR);
717 }
718 }
719
720 struct allowed_reg_type {
721 DWORD type;
722 DWORD count;
723 BOOL reladdr;
724 };
725
726 static BOOL check_reg_type(const struct shader_reg *reg,
727 const struct allowed_reg_type *allowed) {
728 unsigned int i = 0;
729
730 while(allowed[i].type != ~0U) {
731 if(reg->type == allowed[i].type) {
732 if(reg->rel_reg) {
733 if(allowed[i].reladdr)
734 return TRUE; /* The relative addressing register
735 can have a negative value, we
736 can't check the register index */
737 return FALSE;
738 }
739 if(reg->regnum < allowed[i].count) return TRUE;
740 return FALSE;
741 }
742 i++;
743 }
744 return FALSE;
745 }
746
747 /* Native assembler doesn't do separate checks for src and dst registers */
748 static const struct allowed_reg_type vs_1_reg_allowed[] = {
749 { BWRITERSPR_TEMP, 12, FALSE },
750 { BWRITERSPR_INPUT, 16, FALSE },
751 { BWRITERSPR_CONST, ~0U, TRUE },
752 { BWRITERSPR_ADDR, 1, FALSE },
753 { BWRITERSPR_RASTOUT, 3, FALSE }, /* oPos, oFog and oPts */
754 { BWRITERSPR_ATTROUT, 2, FALSE },
755 { BWRITERSPR_TEXCRDOUT, 8, FALSE },
756 { ~0U, 0 } /* End tag */
757 };
758
759 /* struct instruction *asmparser_srcreg
760 *
761 * Records a source register in the instruction and does shader version
762 * specific checks and modifications on it
763 *
764 * Parameters:
765 * This: Shader parser instance
766 * instr: instruction to store the register in
767 * num: Number of source register
768 * src: Pointer to source the register structure. The caller can free
769 * it afterwards
770 */
771 static void asmparser_srcreg_vs_1(struct asm_parser *This,
772 struct instruction *instr, int num,
773 const struct shader_reg *src) {
774 struct shader_reg reg;
775
776 if(!check_reg_type(src, vs_1_reg_allowed)) {
777 asmparser_message(This, "Line %u: Source register %s not supported in VS 1\n",
778 This->line_no,
779 debug_print_srcreg(src));
780 set_parse_status(&This->status, PARSE_ERR);
781 }
782 check_legacy_srcmod(This, src->srcmod);
783 check_abs_srcmod(This, src->srcmod);
784 reg = map_oldvs_register(src);
785 instr->src[num] = reg;
786 }
787
788 static const struct allowed_reg_type vs_2_reg_allowed[] = {
789 { BWRITERSPR_TEMP, 12, FALSE },
790 { BWRITERSPR_INPUT, 16, FALSE },
791 { BWRITERSPR_CONST, ~0U, TRUE },
792 { BWRITERSPR_ADDR, 1, FALSE },
793 { BWRITERSPR_CONSTBOOL, 16, FALSE },
794 { BWRITERSPR_CONSTINT, 16, FALSE },
795 { BWRITERSPR_LOOP, 1, FALSE },
796 { BWRITERSPR_LABEL, 2048, FALSE },
797 { BWRITERSPR_PREDICATE, 1, FALSE },
798 { BWRITERSPR_RASTOUT, 3, FALSE }, /* oPos, oFog and oPts */
799 { BWRITERSPR_ATTROUT, 2, FALSE },
800 { BWRITERSPR_TEXCRDOUT, 8, FALSE },
801 { ~0U, 0 } /* End tag */
802 };
803
804 static void asmparser_srcreg_vs_2(struct asm_parser *This,
805 struct instruction *instr, int num,
806 const struct shader_reg *src) {
807 struct shader_reg reg;
808
809 if(!check_reg_type(src, vs_2_reg_allowed)) {
810 asmparser_message(This, "Line %u: Source register %s not supported in VS 2\n",
811 This->line_no,
812 debug_print_srcreg(src));
813 set_parse_status(&This->status, PARSE_ERR);
814 }
815 check_loop_swizzle(This, src);
816 check_legacy_srcmod(This, src->srcmod);
817 check_abs_srcmod(This, src->srcmod);
818 reg = map_oldvs_register(src);
819 instr->src[num] = reg;
820 }
821
822 static const struct allowed_reg_type vs_3_reg_allowed[] = {
823 { BWRITERSPR_TEMP, 32, FALSE },
824 { BWRITERSPR_INPUT, 16, TRUE },
825 { BWRITERSPR_CONST, ~0U, TRUE },
826 { BWRITERSPR_ADDR, 1, FALSE },
827 { BWRITERSPR_CONSTBOOL, 16, FALSE },
828 { BWRITERSPR_CONSTINT, 16, FALSE },
829 { BWRITERSPR_LOOP, 1, FALSE },
830 { BWRITERSPR_LABEL, 2048, FALSE },
831 { BWRITERSPR_PREDICATE, 1, FALSE },
832 { BWRITERSPR_SAMPLER, 4, FALSE },
833 { BWRITERSPR_OUTPUT, 12, TRUE },
834 { ~0U, 0 } /* End tag */
835 };
836
837 static void asmparser_srcreg_vs_3(struct asm_parser *This,
838 struct instruction *instr, int num,
839 const struct shader_reg *src) {
840 if(!check_reg_type(src, vs_3_reg_allowed)) {
841 asmparser_message(This, "Line %u: Source register %s not supported in VS 3.0\n",
842 This->line_no,
843 debug_print_srcreg(src));
844 set_parse_status(&This->status, PARSE_ERR);
845 }
846 check_loop_swizzle(This, src);
847 check_legacy_srcmod(This, src->srcmod);
848 instr->src[num] = *src;
849 }
850
851 static const struct allowed_reg_type ps_1_0123_reg_allowed[] = {
852 { BWRITERSPR_CONST, 8, FALSE },
853 { BWRITERSPR_TEMP, 2, FALSE },
854 { BWRITERSPR_TEXTURE, 4, FALSE },
855 { BWRITERSPR_INPUT, 2, FALSE },
856 { ~0U, 0 } /* End tag */
857 };
858
859 static void asmparser_srcreg_ps_1_0123(struct asm_parser *This,
860 struct instruction *instr, int num,
861 const struct shader_reg *src) {
862 struct shader_reg reg;
863
864 if(!check_reg_type(src, ps_1_0123_reg_allowed)) {
865 asmparser_message(This, "Line %u: Source register %s not supported in <== PS 1.3\n",
866 This->line_no,
867 debug_print_srcreg(src));
868 set_parse_status(&This->status, PARSE_ERR);
869 }
870 check_abs_srcmod(This, src->srcmod);
871 reg = map_oldps_register(src, FALSE);
872 instr->src[num] = reg;
873 }
874
875 static const struct allowed_reg_type ps_1_4_reg_allowed[] = {
876 { BWRITERSPR_CONST, 8, FALSE },
877 { BWRITERSPR_TEMP, 6, FALSE },
878 { BWRITERSPR_TEXTURE, 6, FALSE },
879 { BWRITERSPR_INPUT, 2, FALSE },
880 { ~0U, 0 } /* End tag */
881 };
882
883 static void asmparser_srcreg_ps_1_4(struct asm_parser *This,
884 struct instruction *instr, int num,
885 const struct shader_reg *src) {
886 struct shader_reg reg;
887
888 if(!check_reg_type(src, ps_1_4_reg_allowed)) {
889 asmparser_message(This, "Line %u: Source register %s not supported in PS 1.4\n",
890 This->line_no,
891 debug_print_srcreg(src));
892 set_parse_status(&This->status, PARSE_ERR);
893 }
894 check_abs_srcmod(This, src->srcmod);
895 reg = map_oldps_register(src, TRUE);
896 instr->src[num] = reg;
897 }
898
899 static const struct allowed_reg_type ps_2_0_reg_allowed[] = {
900 { BWRITERSPR_INPUT, 2, FALSE },
901 { BWRITERSPR_TEMP, 32, FALSE },
902 { BWRITERSPR_CONST, 32, FALSE },
903 { BWRITERSPR_CONSTINT, 16, FALSE },
904 { BWRITERSPR_CONSTBOOL, 16, FALSE },
905 { BWRITERSPR_SAMPLER, 16, FALSE },
906 { BWRITERSPR_TEXTURE, 8, FALSE },
907 { BWRITERSPR_COLOROUT, 4, FALSE },
908 { BWRITERSPR_DEPTHOUT, 1, FALSE },
909 { ~0U, 0 } /* End tag */
910 };
911
912 static void asmparser_srcreg_ps_2(struct asm_parser *This,
913 struct instruction *instr, int num,
914 const struct shader_reg *src) {
915 struct shader_reg reg;
916
917 if(!check_reg_type(src, ps_2_0_reg_allowed)) {
918 asmparser_message(This, "Line %u: Source register %s not supported in PS 2.0\n",
919 This->line_no,
920 debug_print_srcreg(src));
921 set_parse_status(&This->status, PARSE_ERR);
922 }
923 check_legacy_srcmod(This, src->srcmod);
924 check_abs_srcmod(This, src->srcmod);
925 reg = map_oldps_register(src, TRUE);
926 instr->src[num] = reg;
927 }
928
929 static const struct allowed_reg_type ps_2_x_reg_allowed[] = {
930 { BWRITERSPR_INPUT, 2, FALSE },
931 { BWRITERSPR_TEMP, 32, FALSE },
932 { BWRITERSPR_CONST, 32, FALSE },
933 { BWRITERSPR_CONSTINT, 16, FALSE },
934 { BWRITERSPR_CONSTBOOL, 16, FALSE },
935 { BWRITERSPR_PREDICATE, 1, FALSE },
936 { BWRITERSPR_SAMPLER, 16, FALSE },
937 { BWRITERSPR_TEXTURE, 8, FALSE },
938 { BWRITERSPR_LABEL, 2048, FALSE },
939 { BWRITERSPR_COLOROUT, 4, FALSE },
940 { BWRITERSPR_DEPTHOUT, 1, FALSE },
941 { ~0U, 0 } /* End tag */
942 };
943
944 static void asmparser_srcreg_ps_2_x(struct asm_parser *This,
945 struct instruction *instr, int num,
946 const struct shader_reg *src) {
947 struct shader_reg reg;
948
949 if(!check_reg_type(src, ps_2_x_reg_allowed)) {
950 asmparser_message(This, "Line %u: Source register %s not supported in PS 2.x\n",
951 This->line_no,
952 debug_print_srcreg(src));
953 set_parse_status(&This->status, PARSE_ERR);
954 }
955 check_legacy_srcmod(This, src->srcmod);
956 check_abs_srcmod(This, src->srcmod);
957 reg = map_oldps_register(src, TRUE);
958 instr->src[num] = reg;
959 }
960
961 static const struct allowed_reg_type ps_3_reg_allowed[] = {
962 { BWRITERSPR_INPUT, 10, TRUE },
963 { BWRITERSPR_TEMP, 32, FALSE },
964 { BWRITERSPR_CONST, 224, FALSE },
965 { BWRITERSPR_CONSTINT, 16, FALSE },
966 { BWRITERSPR_CONSTBOOL, 16, FALSE },
967 { BWRITERSPR_PREDICATE, 1, FALSE },
968 { BWRITERSPR_SAMPLER, 16, FALSE },
969 { BWRITERSPR_MISCTYPE, 2, FALSE }, /* vPos and vFace */
970 { BWRITERSPR_LOOP, 1, FALSE },
971 { BWRITERSPR_LABEL, 2048, FALSE },
972 { BWRITERSPR_COLOROUT, 4, FALSE },
973 { BWRITERSPR_DEPTHOUT, 1, FALSE },
974 { ~0U, 0 } /* End tag */
975 };
976
977 static void asmparser_srcreg_ps_3(struct asm_parser *This,
978 struct instruction *instr, int num,
979 const struct shader_reg *src) {
980 if(!check_reg_type(src, ps_3_reg_allowed)) {
981 asmparser_message(This, "Line %u: Source register %s not supported in PS 3.0\n",
982 This->line_no,
983 debug_print_srcreg(src));
984 set_parse_status(&This->status, PARSE_ERR);
985 }
986 check_loop_swizzle(This, src);
987 check_legacy_srcmod(This, src->srcmod);
988 instr->src[num] = *src;
989 }
990
991 static void asmparser_dstreg_vs_1(struct asm_parser *This,
992 struct instruction *instr,
993 const struct shader_reg *dst) {
994 struct shader_reg reg;
995
996 if(!check_reg_type(dst, vs_1_reg_allowed)) {
997 asmparser_message(This, "Line %u: Destination register %s not supported in VS 1\n",
998 This->line_no,
999 debug_print_dstreg(dst));
1000 set_parse_status(&This->status, PARSE_ERR);
1001 }
1002 check_ps_dstmod(This, instr->dstmod);
1003 check_shift_dstmod(This, instr->shift);
1004 reg = map_oldvs_register(dst);
1005 instr->dst = reg;
1006 instr->has_dst = TRUE;
1007 }
1008
1009 static void asmparser_dstreg_vs_2(struct asm_parser *This,
1010 struct instruction *instr,
1011 const struct shader_reg *dst) {
1012 struct shader_reg reg;
1013
1014 if(!check_reg_type(dst, vs_2_reg_allowed)) {
1015 asmparser_message(This, "Line %u: Destination register %s not supported in VS 2.0\n",
1016 This->line_no,
1017 debug_print_dstreg(dst));
1018 set_parse_status(&This->status, PARSE_ERR);
1019 }
1020 check_ps_dstmod(This, instr->dstmod);
1021 check_shift_dstmod(This, instr->shift);
1022 reg = map_oldvs_register(dst);
1023 instr->dst = reg;
1024 instr->has_dst = TRUE;
1025 }
1026
1027 static void asmparser_dstreg_vs_3(struct asm_parser *This,
1028 struct instruction *instr,
1029 const struct shader_reg *dst) {
1030 if(!check_reg_type(dst, vs_3_reg_allowed)) {
1031 asmparser_message(This, "Line %u: Destination register %s not supported in VS 3.0\n",
1032 This->line_no,
1033 debug_print_dstreg(dst));
1034 set_parse_status(&This->status, PARSE_ERR);
1035 }
1036 check_ps_dstmod(This, instr->dstmod);
1037 check_shift_dstmod(This, instr->shift);
1038 instr->dst = *dst;
1039 instr->has_dst = TRUE;
1040 }
1041
1042 static void asmparser_dstreg_ps_1_0123(struct asm_parser *This,
1043 struct instruction *instr,
1044 const struct shader_reg *dst) {
1045 struct shader_reg reg;
1046
1047 if(!check_reg_type(dst, ps_1_0123_reg_allowed)) {
1048 asmparser_message(This, "Line %u: Destination register %s not supported in PS 1\n",
1049 This->line_no,
1050 debug_print_dstreg(dst));
1051 set_parse_status(&This->status, PARSE_ERR);
1052 }
1053 reg = map_oldps_register(dst, FALSE);
1054 instr->dst = reg;
1055 instr->has_dst = TRUE;
1056 }
1057
1058 static void asmparser_dstreg_ps_1_4(struct asm_parser *This,
1059 struct instruction *instr,
1060 const struct shader_reg *dst) {
1061 struct shader_reg reg;
1062
1063 if(!check_reg_type(dst, ps_1_4_reg_allowed)) {
1064 asmparser_message(This, "Line %u: Destination register %s not supported in PS 1\n",
1065 This->line_no,
1066 debug_print_dstreg(dst));
1067 set_parse_status(&This->status, PARSE_ERR);
1068 }
1069 reg = map_oldps_register(dst, TRUE);
1070 instr->dst = reg;
1071 instr->has_dst = TRUE;
1072 }
1073
1074 static void asmparser_dstreg_ps_2(struct asm_parser *This,
1075 struct instruction *instr,
1076 const struct shader_reg *dst) {
1077 struct shader_reg reg;
1078
1079 if(!check_reg_type(dst, ps_2_0_reg_allowed)) {
1080 asmparser_message(This, "Line %u: Destination register %s not supported in PS 2.0\n",
1081 This->line_no,
1082 debug_print_dstreg(dst));
1083 set_parse_status(&This->status, PARSE_ERR);
1084 }
1085 check_shift_dstmod(This, instr->shift);
1086 reg = map_oldps_register(dst, TRUE);
1087 instr->dst = reg;
1088 instr->has_dst = TRUE;
1089 }
1090
1091 static void asmparser_dstreg_ps_2_x(struct asm_parser *This,
1092 struct instruction *instr,
1093 const struct shader_reg *dst) {
1094 struct shader_reg reg;
1095
1096 if(!check_reg_type(dst, ps_2_x_reg_allowed)) {
1097 asmparser_message(This, "Line %u: Destination register %s not supported in PS 2.x\n",
1098 This->line_no,
1099 debug_print_dstreg(dst));
1100 set_parse_status(&This->status, PARSE_ERR);
1101 }
1102 check_shift_dstmod(This, instr->shift);
1103 reg = map_oldps_register(dst, TRUE);
1104 instr->dst = reg;
1105 instr->has_dst = TRUE;
1106 }
1107
1108 static void asmparser_dstreg_ps_3(struct asm_parser *This,
1109 struct instruction *instr,
1110 const struct shader_reg *dst) {
1111 if(!check_reg_type(dst, ps_3_reg_allowed)) {
1112 asmparser_message(This, "Line %u: Destination register %s not supported in PS 3.0\n",
1113 This->line_no,
1114 debug_print_dstreg(dst));
1115 set_parse_status(&This->status, PARSE_ERR);
1116 }
1117 check_shift_dstmod(This, instr->shift);
1118 instr->dst = *dst;
1119 instr->has_dst = TRUE;
1120 }
1121
1122 static void asmparser_predicate_supported(struct asm_parser *This,
1123 const struct shader_reg *predicate) {
1124 /* this sets the predicate of the last instruction added to the shader */
1125 if(!This->shader) return;
1126 if(This->shader->num_instrs == 0) ERR("Predicate without an instruction\n");
1127 This->shader->instr[This->shader->num_instrs - 1]->has_predicate = TRUE;
1128 This->shader->instr[This->shader->num_instrs - 1]->predicate = *predicate;
1129 }
1130
1131 static void asmparser_predicate_unsupported(struct asm_parser *This,
1132 const struct shader_reg *predicate) {
1133 asmparser_message(This, "Line %u: Predicate not supported in < VS 2.0 or PS 2.x\n", This->line_no);
1134 set_parse_status(&This->status, PARSE_ERR);
1135 }
1136
1137 static void asmparser_coissue_supported(struct asm_parser *This) {
1138 /* this sets the coissue flag of the last instruction added to the shader */
1139 if(!This->shader) return;
1140 if(This->shader->num_instrs == 0){
1141 asmparser_message(This, "Line %u: Coissue flag on the first shader instruction\n", This->line_no);
1142 set_parse_status(&This->status, PARSE_ERR);
1143 }
1144 This->shader->instr[This->shader->num_instrs-1]->coissue = TRUE;
1145 }
1146
1147 static void asmparser_coissue_unsupported(struct asm_parser *This) {
1148 asmparser_message(This, "Line %u: Coissue is only supported in pixel shaders versions <= 1.4\n", This->line_no);
1149 set_parse_status(&This->status, PARSE_ERR);
1150 }
1151
1152 static const struct asmparser_backend parser_vs_1 = {
1153 asmparser_constF,
1154 asmparser_constI,
1155 asmparser_constB,
1156
1157 asmparser_dstreg_vs_1,
1158 asmparser_srcreg_vs_1,
1159
1160 asmparser_predicate_unsupported,
1161 asmparser_coissue_unsupported,
1162
1163 asmparser_dcl_output_unsupported,
1164 asmparser_dcl_input,
1165 asmparser_dcl_sampler_unsupported,
1166
1167 asmparser_end,
1168
1169 asmparser_instr,
1170 };
1171
1172 static const struct asmparser_backend parser_vs_2 = {
1173 asmparser_constF,
1174 asmparser_constI,
1175 asmparser_constB,
1176
1177 asmparser_dstreg_vs_2,
1178 asmparser_srcreg_vs_2,
1179
1180 asmparser_predicate_supported,
1181 asmparser_coissue_unsupported,
1182
1183 asmparser_dcl_output_unsupported,
1184 asmparser_dcl_input,
1185 asmparser_dcl_sampler_unsupported,
1186
1187 asmparser_end,
1188
1189 asmparser_instr,
1190 };
1191
1192 static const struct asmparser_backend parser_vs_3 = {
1193 asmparser_constF,
1194 asmparser_constI,
1195 asmparser_constB,
1196
1197 asmparser_dstreg_vs_3,
1198 asmparser_srcreg_vs_3,
1199
1200 asmparser_predicate_supported,
1201 asmparser_coissue_unsupported,
1202
1203 asmparser_dcl_output,
1204 asmparser_dcl_input,
1205 asmparser_dcl_sampler,
1206
1207 asmparser_end,
1208
1209 asmparser_instr,
1210 };
1211
1212 static const struct asmparser_backend parser_ps_1_0123 = {
1213 asmparser_constF,
1214 asmparser_constI,
1215 asmparser_constB,
1216
1217 asmparser_dstreg_ps_1_0123,
1218 asmparser_srcreg_ps_1_0123,
1219
1220 asmparser_predicate_unsupported,
1221 asmparser_coissue_supported,
1222
1223 asmparser_dcl_output_unsupported,
1224 asmparser_dcl_input_unsupported,
1225 asmparser_dcl_sampler_unsupported,
1226
1227 asmparser_end,
1228
1229 asmparser_instr,
1230 };
1231
1232 static const struct asmparser_backend parser_ps_1_4 = {
1233 asmparser_constF,
1234 asmparser_constI,
1235 asmparser_constB,
1236
1237 asmparser_dstreg_ps_1_4,
1238 asmparser_srcreg_ps_1_4,
1239
1240 asmparser_predicate_unsupported,
1241 asmparser_coissue_supported,
1242
1243 asmparser_dcl_output_unsupported,
1244 asmparser_dcl_input_unsupported,
1245 asmparser_dcl_sampler_unsupported,
1246
1247 asmparser_end,
1248
1249 asmparser_instr,
1250 };
1251
1252 static const struct asmparser_backend parser_ps_2 = {
1253 asmparser_constF,
1254 asmparser_constI,
1255 asmparser_constB,
1256
1257 asmparser_dstreg_ps_2,
1258 asmparser_srcreg_ps_2,
1259
1260 asmparser_predicate_unsupported,
1261 asmparser_coissue_unsupported,
1262
1263 asmparser_dcl_output_unsupported,
1264 asmparser_dcl_input_ps_2,
1265 asmparser_dcl_sampler,
1266
1267 asmparser_end,
1268
1269 asmparser_instr,
1270 };
1271
1272 static const struct asmparser_backend parser_ps_2_x = {
1273 asmparser_constF,
1274 asmparser_constI,
1275 asmparser_constB,
1276
1277 asmparser_dstreg_ps_2_x,
1278 asmparser_srcreg_ps_2_x,
1279
1280 asmparser_predicate_supported,
1281 asmparser_coissue_unsupported,
1282
1283 asmparser_dcl_output_unsupported,
1284 asmparser_dcl_input_ps_2,
1285 asmparser_dcl_sampler,
1286
1287 asmparser_end,
1288
1289 asmparser_instr,
1290 };
1291
1292 static const struct asmparser_backend parser_ps_3 = {
1293 asmparser_constF,
1294 asmparser_constI,
1295 asmparser_constB,
1296
1297 asmparser_dstreg_ps_3,
1298 asmparser_srcreg_ps_3,
1299
1300 asmparser_predicate_supported,
1301 asmparser_coissue_unsupported,
1302
1303 asmparser_dcl_output_unsupported,
1304 asmparser_dcl_input,
1305 asmparser_dcl_sampler,
1306
1307 asmparser_end,
1308
1309 asmparser_instr,
1310 };
1311
1312 static void gen_oldvs_output(struct bwriter_shader *shader) {
1313 record_declaration(shader, BWRITERDECLUSAGE_POSITION, 0, 0, TRUE, OPOS_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1314 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 0, 0, TRUE, OT0_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1315 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 1, 0, TRUE, OT1_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1316 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 2, 0, TRUE, OT2_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1317 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 3, 0, TRUE, OT3_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1318 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 4, 0, TRUE, OT4_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1319 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 5, 0, TRUE, OT5_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1320 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 6, 0, TRUE, OT6_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1321 record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 7, 0, TRUE, OT7_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1322 record_declaration(shader, BWRITERDECLUSAGE_FOG, 0, 0, TRUE, OFOG_REG, OFOG_WRITEMASK, TRUE);
1323 record_declaration(shader, BWRITERDECLUSAGE_PSIZE, 0, 0, TRUE, OPTS_REG, OPTS_WRITEMASK, TRUE);
1324 record_declaration(shader, BWRITERDECLUSAGE_COLOR, 0, 0, TRUE, OD0_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1325 record_declaration(shader, BWRITERDECLUSAGE_COLOR, 1, 0, TRUE, OD1_REG, BWRITERSP_WRITEMASK_ALL, TRUE);
1326 }
1327
1328 static void gen_oldps_input(struct bwriter_shader *shader, DWORD texcoords) {
1329 switch(texcoords) {
1330 case 8: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 7, 0, FALSE, T7_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1331 /* fall through */
1332 case 7: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 6, 0, FALSE, T6_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1333 /* fall through */
1334 case 6: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 5, 0, FALSE, T5_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1335 /* fall through */
1336 case 5: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 4, 0, FALSE, T4_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1337 /* fall through */
1338 case 4: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 3, 0, FALSE, T3_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1339 /* fall through */
1340 case 3: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 2, 0, FALSE, T2_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1341 /* fall through */
1342 case 2: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 1, 0, FALSE, T1_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1343 /* fall through */
1344 case 1: record_declaration(shader, BWRITERDECLUSAGE_TEXCOORD, 0, 0, FALSE, T0_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1345 };
1346 record_declaration(shader, BWRITERDECLUSAGE_COLOR, 0, 0, FALSE, C0_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1347 record_declaration(shader, BWRITERDECLUSAGE_COLOR, 1, 0, FALSE, C1_VARYING, BWRITERSP_WRITEMASK_ALL, TRUE);
1348 }
1349
1350 void create_vs10_parser(struct asm_parser *ret) {
1351 TRACE_(parsed_shader)("vs_1_0\n");
1352
1353 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1354 if(!ret->shader) {
1355 ERR("Failed to allocate memory for the shader\n");
1356 set_parse_status(&ret->status, PARSE_ERR);
1357 return;
1358 }
1359
1360 ret->shader->type = ST_VERTEX;
1361 ret->shader->version = BWRITERVS_VERSION(1, 0);
1362 ret->funcs = &parser_vs_1;
1363 gen_oldvs_output(ret->shader);
1364 }
1365
1366 void create_vs11_parser(struct asm_parser *ret) {
1367 TRACE_(parsed_shader)("vs_1_1\n");
1368
1369 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1370 if(!ret->shader) {
1371 ERR("Failed to allocate memory for the shader\n");
1372 set_parse_status(&ret->status, PARSE_ERR);
1373 return;
1374 }
1375
1376 ret->shader->type = ST_VERTEX;
1377 ret->shader->version = BWRITERVS_VERSION(1, 1);
1378 ret->funcs = &parser_vs_1;
1379 gen_oldvs_output(ret->shader);
1380 }
1381
1382 void create_vs20_parser(struct asm_parser *ret) {
1383 TRACE_(parsed_shader)("vs_2_0\n");
1384
1385 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1386 if(!ret->shader) {
1387 ERR("Failed to allocate memory for the shader\n");
1388 set_parse_status(&ret->status, PARSE_ERR);
1389 return;
1390 }
1391
1392 ret->shader->type = ST_VERTEX;
1393 ret->shader->version = BWRITERVS_VERSION(2, 0);
1394 ret->funcs = &parser_vs_2;
1395 gen_oldvs_output(ret->shader);
1396 }
1397
1398 void create_vs2x_parser(struct asm_parser *ret) {
1399 TRACE_(parsed_shader)("vs_2_x\n");
1400
1401 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1402 if(!ret->shader) {
1403 ERR("Failed to allocate memory for the shader\n");
1404 set_parse_status(&ret->status, PARSE_ERR);
1405 return;
1406 }
1407
1408 ret->shader->type = ST_VERTEX;
1409 ret->shader->version = BWRITERVS_VERSION(2, 1);
1410 ret->funcs = &parser_vs_2;
1411 gen_oldvs_output(ret->shader);
1412 }
1413
1414 void create_vs30_parser(struct asm_parser *ret) {
1415 TRACE_(parsed_shader)("vs_3_0\n");
1416
1417 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1418 if(!ret->shader) {
1419 ERR("Failed to allocate memory for the shader\n");
1420 set_parse_status(&ret->status, PARSE_ERR);
1421 return;
1422 }
1423
1424 ret->shader->type = ST_VERTEX;
1425 ret->shader->version = BWRITERVS_VERSION(3, 0);
1426 ret->funcs = &parser_vs_3;
1427 }
1428
1429 void create_ps10_parser(struct asm_parser *ret) {
1430 TRACE_(parsed_shader)("ps_1_0\n");
1431
1432 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1433 if(!ret->shader) {
1434 ERR("Failed to allocate memory for the shader\n");
1435 set_parse_status(&ret->status, PARSE_ERR);
1436 return;
1437 }
1438
1439 ret->shader->type = ST_PIXEL;
1440 ret->shader->version = BWRITERPS_VERSION(1, 0);
1441 ret->funcs = &parser_ps_1_0123;
1442 gen_oldps_input(ret->shader, 4);
1443 }
1444
1445 void create_ps11_parser(struct asm_parser *ret) {
1446 TRACE_(parsed_shader)("ps_1_1\n");
1447
1448 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1449 if(!ret->shader) {
1450 ERR("Failed to allocate memory for the shader\n");
1451 set_parse_status(&ret->status, PARSE_ERR);
1452 return;
1453 }
1454
1455 ret->shader->type = ST_PIXEL;
1456 ret->shader->version = BWRITERPS_VERSION(1, 1);
1457 ret->funcs = &parser_ps_1_0123;
1458 gen_oldps_input(ret->shader, 4);
1459 }
1460
1461 void create_ps12_parser(struct asm_parser *ret) {
1462 TRACE_(parsed_shader)("ps_1_2\n");
1463
1464 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1465 if(!ret->shader) {
1466 ERR("Failed to allocate memory for the shader\n");
1467 set_parse_status(&ret->status, PARSE_ERR);
1468 return;
1469 }
1470
1471 ret->shader->type = ST_PIXEL;
1472 ret->shader->version = BWRITERPS_VERSION(1, 2);
1473 ret->funcs = &parser_ps_1_0123;
1474 gen_oldps_input(ret->shader, 4);
1475 }
1476
1477 void create_ps13_parser(struct asm_parser *ret) {
1478 TRACE_(parsed_shader)("ps_1_3\n");
1479
1480 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1481 if(!ret->shader) {
1482 ERR("Failed to allocate memory for the shader\n");
1483 set_parse_status(&ret->status, PARSE_ERR);
1484 return;
1485 }
1486
1487 ret->shader->type = ST_PIXEL;
1488 ret->shader->version = BWRITERPS_VERSION(1, 3);
1489 ret->funcs = &parser_ps_1_0123;
1490 gen_oldps_input(ret->shader, 4);
1491 }
1492
1493 void create_ps14_parser(struct asm_parser *ret) {
1494 TRACE_(parsed_shader)("ps_1_4\n");
1495
1496 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1497 if(!ret->shader) {
1498 ERR("Failed to allocate memory for the shader\n");
1499 set_parse_status(&ret->status, PARSE_ERR);
1500 return;
1501 }
1502
1503 ret->shader->type = ST_PIXEL;
1504 ret->shader->version = BWRITERPS_VERSION(1, 4);
1505 ret->funcs = &parser_ps_1_4;
1506 gen_oldps_input(ret->shader, 6);
1507 }
1508
1509 void create_ps20_parser(struct asm_parser *ret) {
1510 TRACE_(parsed_shader)("ps_2_0\n");
1511
1512 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1513 if(!ret->shader) {
1514 ERR("Failed to allocate memory for the shader\n");
1515 set_parse_status(&ret->status, PARSE_ERR);
1516 return;
1517 }
1518
1519 ret->shader->type = ST_PIXEL;
1520 ret->shader->version = BWRITERPS_VERSION(2, 0);
1521 ret->funcs = &parser_ps_2;
1522 gen_oldps_input(ret->shader, 8);
1523 }
1524
1525 void create_ps2x_parser(struct asm_parser *ret) {
1526 TRACE_(parsed_shader)("ps_2_x\n");
1527
1528 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1529 if(!ret->shader) {
1530 ERR("Failed to allocate memory for the shader\n");
1531 set_parse_status(&ret->status, PARSE_ERR);
1532 return;
1533 }
1534
1535 ret->shader->type = ST_PIXEL;
1536 ret->shader->version = BWRITERPS_VERSION(2, 1);
1537 ret->funcs = &parser_ps_2_x;
1538 gen_oldps_input(ret->shader, 8);
1539 }
1540
1541 void create_ps30_parser(struct asm_parser *ret) {
1542 TRACE_(parsed_shader)("ps_3_0\n");
1543
1544 ret->shader = d3dcompiler_alloc(sizeof(*ret->shader));
1545 if(!ret->shader) {
1546 ERR("Failed to allocate memory for the shader\n");
1547 set_parse_status(&ret->status, PARSE_ERR);
1548 return;
1549 }
1550
1551 ret->shader->type = ST_PIXEL;
1552 ret->shader->version = BWRITERPS_VERSION(3, 0);
1553 ret->funcs = &parser_ps_3;
1554 }
Windows API implementation