?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Support some flow control instructions in the shader assembler.
[wine/multimedia.git] / dlls / d3dx9_36 / asmutils.c
blob5d12e4e5c034241f4f1292d350d5431fb89f4d27
1 /*
2 * Direct3D shader library utility routines
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/debug.h"
25
26 #include "d3dx9_36_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(asmshader);
29
30 /* bwriter -> d3d9 conversion functions */
31 DWORD d3d9_swizzle(DWORD bwriter_swizzle) {
32 /* Currently a NOP, but this allows changing the internal definitions
33 * without side effects
34 */
35 DWORD ret = 0;
36
37 if((bwriter_swizzle & BWRITERVS_X_X) == BWRITERVS_X_X) ret |= D3DVS_X_X;
38 if((bwriter_swizzle & BWRITERVS_X_Y) == BWRITERVS_X_Y) ret |= D3DVS_X_Y;
39 if((bwriter_swizzle & BWRITERVS_X_Z) == BWRITERVS_X_Z) ret |= D3DVS_X_Z;
40 if((bwriter_swizzle & BWRITERVS_X_W) == BWRITERVS_X_W) ret |= D3DVS_X_W;
41
42 if((bwriter_swizzle & BWRITERVS_Y_X) == BWRITERVS_Y_X) ret |= D3DVS_Y_X;
43 if((bwriter_swizzle & BWRITERVS_Y_Y) == BWRITERVS_Y_Y) ret |= D3DVS_Y_Y;
44 if((bwriter_swizzle & BWRITERVS_Y_Z) == BWRITERVS_Y_Z) ret |= D3DVS_Y_Z;
45 if((bwriter_swizzle & BWRITERVS_Y_W) == BWRITERVS_Y_W) ret |= D3DVS_Y_W;
46
47 if((bwriter_swizzle & BWRITERVS_Z_X) == BWRITERVS_Z_X) ret |= D3DVS_Z_X;
48 if((bwriter_swizzle & BWRITERVS_Z_Y) == BWRITERVS_Z_Y) ret |= D3DVS_Z_Y;
49 if((bwriter_swizzle & BWRITERVS_Z_Z) == BWRITERVS_Z_Z) ret |= D3DVS_Z_Z;
50 if((bwriter_swizzle & BWRITERVS_Z_W) == BWRITERVS_Z_W) ret |= D3DVS_Z_W;
51
52 if((bwriter_swizzle & BWRITERVS_W_X) == BWRITERVS_W_X) ret |= D3DVS_W_X;
53 if((bwriter_swizzle & BWRITERVS_W_Y) == BWRITERVS_W_Y) ret |= D3DVS_W_Y;
54 if((bwriter_swizzle & BWRITERVS_W_Z) == BWRITERVS_W_Z) ret |= D3DVS_W_Z;
55 if((bwriter_swizzle & BWRITERVS_W_W) == BWRITERVS_W_W) ret |= D3DVS_W_W;
56
57 return ret;
58 }
59
60 DWORD d3d9_writemask(DWORD bwriter_writemask) {
61 DWORD ret = 0;
62
63 if(bwriter_writemask & BWRITERSP_WRITEMASK_0) ret |= D3DSP_WRITEMASK_0;
64 if(bwriter_writemask & BWRITERSP_WRITEMASK_1) ret |= D3DSP_WRITEMASK_1;
65 if(bwriter_writemask & BWRITERSP_WRITEMASK_2) ret |= D3DSP_WRITEMASK_2;
66 if(bwriter_writemask & BWRITERSP_WRITEMASK_3) ret |= D3DSP_WRITEMASK_3;
67
68 return ret;
69 }
70
71 DWORD d3d9_srcmod(DWORD bwriter_srcmod) {
72 switch(bwriter_srcmod) {
73 case BWRITERSPSM_NONE: return D3DSPSM_NONE;
74 case BWRITERSPSM_NEG: return D3DSPSM_NEG;
75 case BWRITERSPSM_ABS: return D3DSPSM_ABS;
76 case BWRITERSPSM_ABSNEG: return D3DSPSM_ABSNEG;
77 case BWRITERSPSM_NOT: return D3DSPSM_NOT;
78 default:
79 FIXME("Unhandled BWRITERSPSM token %u\n", bwriter_srcmod);
80 return 0;
81 }
82 }
83
84 DWORD d3d9_dstmod(DWORD bwriter_mod) {
85 DWORD ret = 0;
86
87 if(bwriter_mod & BWRITERSPDM_SATURATE) ret |= D3DSPDM_SATURATE;
88 if(bwriter_mod & BWRITERSPDM_PARTIALPRECISION) ret |= D3DSPDM_PARTIALPRECISION;
89 if(bwriter_mod & BWRITERSPDM_MSAMPCENTROID) ret |= D3DSPDM_MSAMPCENTROID;
90
91 return ret;
92 }
93
94 DWORD d3d9_register(DWORD bwriter_register) {
95 if(bwriter_register == BWRITERSPR_TEMP) return D3DSPR_TEMP;
96 if(bwriter_register == BWRITERSPR_INPUT) return D3DSPR_INPUT;
97 if(bwriter_register == BWRITERSPR_CONST) return D3DSPR_CONST;
98 if(bwriter_register == BWRITERSPR_ADDR) return D3DSPR_ADDR;
99 if(bwriter_register == BWRITERSPR_TEXTURE) return D3DSPR_TEXTURE;
100 if(bwriter_register == BWRITERSPR_RASTOUT) return D3DSPR_RASTOUT;
101 if(bwriter_register == BWRITERSPR_ATTROUT) return D3DSPR_ATTROUT;
102 if(bwriter_register == BWRITERSPR_TEXCRDOUT) return D3DSPR_TEXCRDOUT;
103 if(bwriter_register == BWRITERSPR_OUTPUT) return D3DSPR_OUTPUT;
104 if(bwriter_register == BWRITERSPR_CONSTINT) return D3DSPR_CONSTINT;
105 if(bwriter_register == BWRITERSPR_COLOROUT) return D3DSPR_COLOROUT;
106 if(bwriter_register == BWRITERSPR_DEPTHOUT) return D3DSPR_DEPTHOUT;
107 if(bwriter_register == BWRITERSPR_SAMPLER) return D3DSPR_SAMPLER;
108 if(bwriter_register == BWRITERSPR_CONSTBOOL) return D3DSPR_CONSTBOOL;
109 if(bwriter_register == BWRITERSPR_LOOP) return D3DSPR_LOOP;
110 if(bwriter_register == BWRITERSPR_MISCTYPE) return D3DSPR_MISCTYPE;
111 if(bwriter_register == BWRITERSPR_LABEL) return D3DSPR_LABEL;
112 if(bwriter_register == BWRITERSPR_PREDICATE) return D3DSPR_PREDICATE;
113
114 FIXME("Unexpected BWRITERSPR %u\n", bwriter_register);
115 return -1;
116 }
117
118 DWORD d3d9_opcode(DWORD bwriter_opcode) {
119 switch(bwriter_opcode) {
120 case BWRITERSIO_NOP: return D3DSIO_NOP;
121 case BWRITERSIO_MOV: return D3DSIO_MOV;
122 case BWRITERSIO_ADD: return D3DSIO_ADD;
123 case BWRITERSIO_SUB: return D3DSIO_SUB;
124 case BWRITERSIO_MAD: return D3DSIO_MAD;
125 case BWRITERSIO_MUL: return D3DSIO_MUL;
126 case BWRITERSIO_RCP: return D3DSIO_RCP;
127 case BWRITERSIO_RSQ: return D3DSIO_RSQ;
128 case BWRITERSIO_DP3: return D3DSIO_DP3;
129 case BWRITERSIO_DP4: return D3DSIO_DP4;
130 case BWRITERSIO_MIN: return D3DSIO_MIN;
131 case BWRITERSIO_MAX: return D3DSIO_MAX;
132 case BWRITERSIO_SLT: return D3DSIO_SLT;
133 case BWRITERSIO_SGE: return D3DSIO_SGE;
134 case BWRITERSIO_EXP: return D3DSIO_EXP;
135 case BWRITERSIO_LOG: return D3DSIO_LOG;
136 case BWRITERSIO_LIT: return D3DSIO_LIT;
137 case BWRITERSIO_DST: return D3DSIO_DST;
138 case BWRITERSIO_LRP: return D3DSIO_LRP;
139 case BWRITERSIO_FRC: return D3DSIO_FRC;
140 case BWRITERSIO_M4x4: return D3DSIO_M4x4;
141 case BWRITERSIO_M4x3: return D3DSIO_M4x3;
142 case BWRITERSIO_M3x4: return D3DSIO_M3x4;
143 case BWRITERSIO_M3x3: return D3DSIO_M3x3;
144 case BWRITERSIO_M3x2: return D3DSIO_M3x2;
145 case BWRITERSIO_CALL: return D3DSIO_CALL;
146 case BWRITERSIO_CALLNZ: return D3DSIO_CALLNZ;
147 case BWRITERSIO_LOOP: return D3DSIO_LOOP;
148 case BWRITERSIO_RET: return D3DSIO_RET;
149 case BWRITERSIO_ENDLOOP: return D3DSIO_ENDLOOP;
150 case BWRITERSIO_LABEL: return D3DSIO_LABEL;
151 case BWRITERSIO_POW: return D3DSIO_POW;
152 case BWRITERSIO_CRS: return D3DSIO_CRS;
153 case BWRITERSIO_SGN: return D3DSIO_SGN;
154 case BWRITERSIO_ABS: return D3DSIO_ABS;
155 case BWRITERSIO_NRM: return D3DSIO_NRM;
156 case BWRITERSIO_SINCOS: return D3DSIO_SINCOS;
157 case BWRITERSIO_REP: return D3DSIO_REP;
158 case BWRITERSIO_ENDREP: return D3DSIO_ENDREP;
159 case BWRITERSIO_IF: return D3DSIO_IF;
160 case BWRITERSIO_ELSE: return D3DSIO_ELSE;
161 case BWRITERSIO_ENDIF: return D3DSIO_ENDIF;
162 case BWRITERSIO_BREAK: return D3DSIO_BREAK;
163 case BWRITERSIO_MOVA: return D3DSIO_MOVA;
164 case BWRITERSIO_EXPP: return D3DSIO_EXPP;
165 case BWRITERSIO_LOGP: return D3DSIO_LOGP;
166 case BWRITERSIO_TEXLDL: return D3DSIO_TEXLDL;
167
168 case BWRITERSIO_COMMENT: return D3DSIO_COMMENT;
169 case BWRITERSIO_END: return D3DSIO_END;
170
171 default:
172 FIXME("Unhandled BWRITERSIO token %u\n", bwriter_opcode);
173 return -1;
174 }
175 }
176
177 /* Debug print functions */
178 const char *debug_print_srcmod(DWORD mod) {
179 switch(mod) {
180 case BWRITERSPSM_NEG: return "D3DSPSM_NEG";
181 case BWRITERSPSM_ABS: return "D3DSPSM_ABS";
182 case BWRITERSPSM_ABSNEG: return "D3DSPSM_ABSNEG";
183 case BWRITERSPSM_NOT: return "D3DSPSM_NOT";
184 default: return "Unknown source modifier\n";
185 }
186 }
187
188 const char *debug_print_dstmod(DWORD mod) {
189 switch(mod) {
190 case 0:
191 return "";
192
193 case BWRITERSPDM_SATURATE:
194 return "_sat";
195 case BWRITERSPDM_PARTIALPRECISION:
196 return "_pp";
197 case BWRITERSPDM_MSAMPCENTROID:
198 return "_centroid";
199
200 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
201 return "_sat_pp";
202 case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
203 return "_sat_centroid";
204 case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
205 return "_pp_centroid";
206
207 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
208 return "_sat_pp_centroid";
209
210 default:
211 return "Unexpected modifier\n";
212 }
213 }
214
215 static const char *get_regname(const struct shader_reg *reg, shader_type st) {
216 switch(reg->type) {
217 case BWRITERSPR_TEMP:
218 return wine_dbg_sprintf("r%u", reg->regnum);
219 case BWRITERSPR_INPUT:
220 return wine_dbg_sprintf("v%u", reg->regnum);
221 case BWRITERSPR_CONST:
222 return wine_dbg_sprintf("c%u", reg->regnum);
223 /* case BWRITERSPR_ADDR: */
224 case BWRITERSPR_TEXTURE:
225 if(st == ST_VERTEX) {
226 return wine_dbg_sprintf("a%u", reg->regnum);
227 } else {
228 return wine_dbg_sprintf("t%u", reg->regnum);
229 }
230 case BWRITERSPR_RASTOUT:
231 switch(reg->regnum) {
232 case BWRITERSRO_POSITION: return "oPos";
233 case BWRITERSRO_FOG: return "oFog";
234 case BWRITERSRO_POINT_SIZE: return "oPts";
235 default: return "Unexpected RASTOUT";
236 }
237 case BWRITERSPR_ATTROUT:
238 return wine_dbg_sprintf("oD%u", reg->regnum);
239 /* case BWRITERSPR_TEXCRDOUT: */
240 case BWRITERSPR_OUTPUT:
241 return wine_dbg_sprintf("o[T]%u", reg->regnum);
242 case BWRITERSPR_CONSTINT:
243 return wine_dbg_sprintf("i%u", reg->regnum);
244 case BWRITERSPR_COLOROUT:
245 return wine_dbg_sprintf("oC%u", reg->regnum);
246 case BWRITERSPR_DEPTHOUT:
247 return "oDepth";
248 case BWRITERSPR_SAMPLER:
249 return wine_dbg_sprintf("s%u", reg->regnum);
250 case BWRITERSPR_CONSTBOOL:
251 return wine_dbg_sprintf("b%u", reg->regnum);
252 case BWRITERSPR_LOOP:
253 return "aL";
254 case BWRITERSPR_MISCTYPE:
255 switch(reg->regnum) {
256 case 0: return "vPos";
257 case 1: return "vFace";
258 case 2: return "unexpected misctype";
259 }
260 case BWRITERSPR_LABEL:
261 return wine_dbg_sprintf("l%u", reg->regnum);
262 case BWRITERSPR_PREDICATE:
263 return wine_dbg_sprintf("p%u", reg->regnum);
264 default: return "unknown regname";
265 }
266 }
267
268 const char *debug_print_writemask(DWORD mask) {
269 char ret[6];
270 unsigned char pos = 1;
271
272 if(mask == BWRITERSP_WRITEMASK_ALL) return "";
273 ret[0] = '.';
274 if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
275 if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
276 if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
277 if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
278 ret[pos] = 0;
279 return wine_dbg_sprintf("%s", ret);
280 }
281
282 const char *debug_print_relarg(const struct shader_reg *reg) {
283 const char *short_swizzle;
284 if(!reg->rel_reg) return "";
285
286 short_swizzle = debug_print_swizzle(reg->rel_reg->swizzle);
287
288 if(reg->rel_reg->type == BWRITERSPR_ADDR) {
289 return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
290 } else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0) {
291 return wine_dbg_sprintf("[aL%s]", short_swizzle);
292 } else {
293 return "Unexpected relative addressing argument";
294 }
295 }
296
297 const char *debug_print_dstreg(const struct shader_reg *reg, shader_type st) {
298 return wine_dbg_sprintf("%s%s%s", get_regname(reg, st),
299 debug_print_relarg(reg),
300 debug_print_writemask(reg->writemask));
301 }
302
303 const char *debug_print_swizzle(DWORD arg) {
304 char ret[6];
305 unsigned int i;
306 DWORD swizzle[4];
307
308 switch(arg) {
309 case BWRITERVS_NOSWIZZLE:
310 return "";
311 case BWRITERVS_SWIZZLE_X:
312 return ".x";
313 case BWRITERVS_SWIZZLE_Y:
314 return ".y";
315 case BWRITERVS_SWIZZLE_Z:
316 return ".z";
317 case BWRITERVS_SWIZZLE_W:
318 return ".w";
319 }
320
321 swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
322 swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
323 swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
324 swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
325
326 ret[0] = '.';
327 for(i = 0; i < 4; i++) {
328 switch(swizzle[i]) {
329 case 0: ret[1 + i] = 'x'; break;
330 case 1: ret[1 + i] = 'y'; break;
331 case 2: ret[1 + i] = 'z'; break;
332 case 3: ret[1 + i] = 'w'; break;
333 }
334 }
335 ret[5] = '\0';
336 return wine_dbg_sprintf("%s", ret);
337 }
338
339 const char *debug_print_srcreg(const struct shader_reg *reg, shader_type st) {
340 switch(reg->srcmod) {
341 case BWRITERSPSM_NONE:
342 return wine_dbg_sprintf("%s%s%s", get_regname(reg, st),
343 debug_print_relarg(reg),
344 debug_print_swizzle(reg->swizzle));
345 case BWRITERSPSM_NEG:
346 return wine_dbg_sprintf("-%s%s%s", get_regname(reg, st),
347 debug_print_relarg(reg),
348 debug_print_swizzle(reg->swizzle));
349 case BWRITERSPSM_ABS:
350 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg, st),
351 debug_print_relarg(reg),
352 debug_print_swizzle(reg->swizzle));
353 case BWRITERSPSM_ABSNEG:
354 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg, st),
355 debug_print_relarg(reg),
356 debug_print_swizzle(reg->swizzle));
357 case BWRITERSPSM_NOT:
358 return wine_dbg_sprintf("!%s%s%s", get_regname(reg, st),
359 debug_print_relarg(reg),
360 debug_print_swizzle(reg->swizzle));
361 }
362 return "Unknown modifier";
363 }
364
365 const char *debug_print_opcode(DWORD opcode) {
366 switch(opcode){
367 case BWRITERSIO_NOP: return "nop";
368 case BWRITERSIO_MOV: return "mov";
369 case BWRITERSIO_ADD: return "add";
370 case BWRITERSIO_SUB: return "sub";
371 case BWRITERSIO_MAD: return "mad";
372 case BWRITERSIO_MUL: return "mul";
373 case BWRITERSIO_RCP: return "rcp";
374 case BWRITERSIO_RSQ: return "rsq";
375 case BWRITERSIO_DP3: return "dp3";
376 case BWRITERSIO_DP4: return "dp4";
377 case BWRITERSIO_MIN: return "min";
378 case BWRITERSIO_MAX: return "max";
379 case BWRITERSIO_SLT: return "slt";
380 case BWRITERSIO_SGE: return "sge";
381 case BWRITERSIO_EXP: return "exp";
382 case BWRITERSIO_LOG: return "log";
383 case BWRITERSIO_LIT: return "lit";
384 case BWRITERSIO_DST: return "dst";
385 case BWRITERSIO_LRP: return "lrp";
386 case BWRITERSIO_FRC: return "frc";
387 case BWRITERSIO_M4x4: return "m4x4";
388 case BWRITERSIO_M4x3: return "m4x3";
389 case BWRITERSIO_M3x4: return "m3x4";
390 case BWRITERSIO_M3x3: return "m3x3";
391 case BWRITERSIO_M3x2: return "m3x2";
392 case BWRITERSIO_CALL: return "call";
393 case BWRITERSIO_CALLNZ: return "callnz";
394 case BWRITERSIO_LOOP: return "loop";
395 case BWRITERSIO_RET: return "ret";
396 case BWRITERSIO_ENDLOOP: return "endloop";
397 case BWRITERSIO_LABEL: return "label";
398 case BWRITERSIO_POW: return "pow";
399 case BWRITERSIO_CRS: return "crs";
400 case BWRITERSIO_SGN: return "sgn";
401 case BWRITERSIO_ABS: return "abs";
402 case BWRITERSIO_NRM: return "nrm";
403 case BWRITERSIO_SINCOS: return "sincos";
404 case BWRITERSIO_REP: return "rep";
405 case BWRITERSIO_ENDREP: return "endrep";
406 case BWRITERSIO_IF: return "if";
407 case BWRITERSIO_ELSE: return "else";
408 case BWRITERSIO_ENDIF: return "endif";
409 case BWRITERSIO_BREAK: return "break";
410 case BWRITERSIO_MOVA: return "mova";
411 case BWRITERSIO_EXPP: return "expp";
412 case BWRITERSIO_LOGP: return "logp";
413 case BWRITERSIO_TEXLDL: return "texldl";
414
415 default: return "unknown";
416 }
417 }
Maarten's multimedia branch