2 * Copyright 2008 Stefan Dösinger
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2008-2009 Henri Verbeet for CodeWeavers
5 * Copyright 2010 Rico Schüller
6 * Copyright 2012 Matteo Bruni for CodeWeavers
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
29 #include "d3dcompiler_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler
);
33 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
35 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c
)
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR
);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR
);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS
);
42 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS
);
43 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT
);
44 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT
);
45 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS
);
46 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER
);
48 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c
);
49 return "unrecognized";
53 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t
)
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID
);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL
);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT
);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT
);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING
);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE
);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D
);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D
);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D
);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE
);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER
);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER
);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER
);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT
);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8
);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER
);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER
);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL
);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND
);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER
);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER
);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER
);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY
);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY
);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW
);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW
);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS
);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY
);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY
);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER
);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER
);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER
);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER
);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE
);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D
);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY
);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D
);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY
);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D
);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER
);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER
);
98 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER
);
99 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER
);
100 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER
);
101 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER
);
102 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER
);
104 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t
);
105 return "unrecognized";
109 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part
)
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB
);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB
);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB
);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB
);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO
);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER
);
120 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER
);
121 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER
);
122 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER
);
123 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS
);
124 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF
);
126 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part
);
127 return "unrecognized";
131 const char *debug_print_srcmod(DWORD mod
)
135 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG
);
136 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS
);
137 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG
);
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN
);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG
);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP
);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2
);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG
);
143 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ
);
144 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW
);
145 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS
);
146 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG
);
147 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT
);
149 FIXME("Unrecognized source modifier %#x.\n", mod
);
150 return "unrecognized_src_mod";
154 #undef WINE_D3DCOMPILER_TO_STR
156 const char *debug_print_dstmod(DWORD mod
)
162 case BWRITERSPDM_SATURATE
:
164 case BWRITERSPDM_PARTIALPRECISION
:
166 case BWRITERSPDM_MSAMPCENTROID
:
168 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
:
170 case BWRITERSPDM_SATURATE
| BWRITERSPDM_MSAMPCENTROID
:
171 return "_sat_centroid";
172 case BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
173 return "_pp_centroid";
174 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
175 return "_sat_pp_centroid";
177 return "Unexpected modifier\n";
181 const char *debug_print_shift(DWORD shift
)
183 static const char * const shiftstrings
[] =
202 return shiftstrings
[shift
];
205 static const char *get_regname(const struct shader_reg
*reg
)
209 case BWRITERSPR_TEMP
:
210 return wine_dbg_sprintf("r%u", reg
->regnum
);
211 case BWRITERSPR_INPUT
:
212 return wine_dbg_sprintf("v%u", reg
->regnum
);
213 case BWRITERSPR_CONST
:
214 return wine_dbg_sprintf("c%u", reg
->regnum
);
215 case BWRITERSPR_ADDR
:
216 return wine_dbg_sprintf("a%u", reg
->regnum
);
217 case BWRITERSPR_TEXTURE
:
218 return wine_dbg_sprintf("t%u", reg
->regnum
);
219 case BWRITERSPR_RASTOUT
:
222 case BWRITERSRO_POSITION
: return "oPos";
223 case BWRITERSRO_FOG
: return "oFog";
224 case BWRITERSRO_POINT_SIZE
: return "oPts";
225 default: return "Unexpected RASTOUT";
227 case BWRITERSPR_ATTROUT
:
228 return wine_dbg_sprintf("oD%u", reg
->regnum
);
229 case BWRITERSPR_TEXCRDOUT
:
230 return wine_dbg_sprintf("oT%u", reg
->regnum
);
231 case BWRITERSPR_OUTPUT
:
232 return wine_dbg_sprintf("o%u", reg
->regnum
);
233 case BWRITERSPR_CONSTINT
:
234 return wine_dbg_sprintf("i%u", reg
->regnum
);
235 case BWRITERSPR_COLOROUT
:
236 return wine_dbg_sprintf("oC%u", reg
->regnum
);
237 case BWRITERSPR_DEPTHOUT
:
239 case BWRITERSPR_SAMPLER
:
240 return wine_dbg_sprintf("s%u", reg
->regnum
);
241 case BWRITERSPR_CONSTBOOL
:
242 return wine_dbg_sprintf("b%u", reg
->regnum
);
243 case BWRITERSPR_LOOP
:
245 case BWRITERSPR_MISCTYPE
:
248 case 0: return "vPos";
249 case 1: return "vFace";
250 default: return "unexpected misctype";
252 case BWRITERSPR_LABEL
:
253 return wine_dbg_sprintf("l%u", reg
->regnum
);
254 case BWRITERSPR_PREDICATE
:
255 return wine_dbg_sprintf("p%u", reg
->regnum
);
257 return wine_dbg_sprintf("unknown regname %#x", reg
->type
);
261 static const char *debug_print_writemask(DWORD mask
)
264 unsigned char pos
= 1;
266 if(mask
== BWRITERSP_WRITEMASK_ALL
) return "";
268 if(mask
& BWRITERSP_WRITEMASK_0
) ret
[pos
++] = 'x';
269 if(mask
& BWRITERSP_WRITEMASK_1
) ret
[pos
++] = 'y';
270 if(mask
& BWRITERSP_WRITEMASK_2
) ret
[pos
++] = 'z';
271 if(mask
& BWRITERSP_WRITEMASK_3
) ret
[pos
++] = 'w';
274 return wine_dbg_sprintf("%s", ret
);
277 static const char *debug_print_swizzle(DWORD arg
)
285 case BWRITERVS_NOSWIZZLE
:
287 case BWRITERVS_SWIZZLE_X
:
289 case BWRITERVS_SWIZZLE_Y
:
291 case BWRITERVS_SWIZZLE_Z
:
293 case BWRITERVS_SWIZZLE_W
:
297 swizzle
[0] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 0)) & 0x03;
298 swizzle
[1] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 2)) & 0x03;
299 swizzle
[2] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 4)) & 0x03;
300 swizzle
[3] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 6)) & 0x03;
303 for (i
= 0; i
< 4; ++i
)
307 case 0: ret
[1 + i
] = 'x'; break;
308 case 1: ret
[1 + i
] = 'y'; break;
309 case 2: ret
[1 + i
] = 'z'; break;
310 case 3: ret
[1 + i
] = 'w'; break;
315 return wine_dbg_sprintf("%s", ret
);
318 static const char *debug_print_relarg(const struct shader_reg
*reg
)
320 const char *short_swizzle
;
321 if (!reg
->rel_reg
) return "";
323 short_swizzle
= debug_print_swizzle(reg
->rel_reg
->u
.swizzle
);
325 if (reg
->rel_reg
->type
== BWRITERSPR_ADDR
)
326 return wine_dbg_sprintf("[a%u%s]", reg
->rel_reg
->regnum
, short_swizzle
);
327 else if(reg
->rel_reg
->type
== BWRITERSPR_LOOP
&& reg
->rel_reg
->regnum
== 0)
328 return wine_dbg_sprintf("[aL%s]", short_swizzle
);
330 return "Unexpected relative addressing argument";
333 const char *debug_print_dstreg(const struct shader_reg
*reg
)
335 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
336 debug_print_relarg(reg
),
337 debug_print_writemask(reg
->u
.writemask
));
340 const char *debug_print_srcreg(const struct shader_reg
*reg
)
344 case BWRITERSPSM_NONE
:
345 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
346 debug_print_relarg(reg
),
347 debug_print_swizzle(reg
->u
.swizzle
));
348 case BWRITERSPSM_NEG
:
349 return wine_dbg_sprintf("-%s%s%s", get_regname(reg
),
350 debug_print_relarg(reg
),
351 debug_print_swizzle(reg
->u
.swizzle
));
352 case BWRITERSPSM_BIAS
:
353 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg
),
354 debug_print_relarg(reg
),
355 debug_print_swizzle(reg
->u
.swizzle
));
356 case BWRITERSPSM_BIASNEG
:
357 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg
),
358 debug_print_relarg(reg
),
359 debug_print_swizzle(reg
->u
.swizzle
));
360 case BWRITERSPSM_SIGN
:
361 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg
),
362 debug_print_relarg(reg
),
363 debug_print_swizzle(reg
->u
.swizzle
));
364 case BWRITERSPSM_SIGNNEG
:
365 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg
),
366 debug_print_relarg(reg
),
367 debug_print_swizzle(reg
->u
.swizzle
));
368 case BWRITERSPSM_COMP
:
369 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg
),
370 debug_print_relarg(reg
),
371 debug_print_swizzle(reg
->u
.swizzle
));
373 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg
),
374 debug_print_relarg(reg
),
375 debug_print_swizzle(reg
->u
.swizzle
));
376 case BWRITERSPSM_X2NEG
:
377 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg
),
378 debug_print_relarg(reg
),
379 debug_print_swizzle(reg
->u
.swizzle
));
381 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg
),
382 debug_print_relarg(reg
),
383 debug_print_swizzle(reg
->u
.swizzle
));
385 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg
),
386 debug_print_relarg(reg
),
387 debug_print_swizzle(reg
->u
.swizzle
));
388 case BWRITERSPSM_ABS
:
389 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg
),
390 debug_print_relarg(reg
),
391 debug_print_swizzle(reg
->u
.swizzle
));
392 case BWRITERSPSM_ABSNEG
:
393 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg
),
394 debug_print_relarg(reg
),
395 debug_print_swizzle(reg
->u
.swizzle
));
396 case BWRITERSPSM_NOT
:
397 return wine_dbg_sprintf("!%s%s%s", get_regname(reg
),
398 debug_print_relarg(reg
),
399 debug_print_swizzle(reg
->u
.swizzle
));
401 return "Unknown modifier";
404 const char *debug_print_comp(DWORD comp
)
408 case BWRITER_COMPARISON_NONE
: return "";
409 case BWRITER_COMPARISON_GT
: return "_gt";
410 case BWRITER_COMPARISON_EQ
: return "_eq";
411 case BWRITER_COMPARISON_GE
: return "_ge";
412 case BWRITER_COMPARISON_LT
: return "_lt";
413 case BWRITER_COMPARISON_NE
: return "_ne";
414 case BWRITER_COMPARISON_LE
: return "_le";
415 default: return "_unknown";
419 const char *debug_print_opcode(DWORD opcode
)
423 case BWRITERSIO_NOP
: return "nop";
424 case BWRITERSIO_MOV
: return "mov";
425 case BWRITERSIO_ADD
: return "add";
426 case BWRITERSIO_SUB
: return "sub";
427 case BWRITERSIO_MAD
: return "mad";
428 case BWRITERSIO_MUL
: return "mul";
429 case BWRITERSIO_RCP
: return "rcp";
430 case BWRITERSIO_RSQ
: return "rsq";
431 case BWRITERSIO_DP3
: return "dp3";
432 case BWRITERSIO_DP4
: return "dp4";
433 case BWRITERSIO_MIN
: return "min";
434 case BWRITERSIO_MAX
: return "max";
435 case BWRITERSIO_SLT
: return "slt";
436 case BWRITERSIO_SGE
: return "sge";
437 case BWRITERSIO_EXP
: return "exp";
438 case BWRITERSIO_LOG
: return "log";
439 case BWRITERSIO_LIT
: return "lit";
440 case BWRITERSIO_DST
: return "dst";
441 case BWRITERSIO_LRP
: return "lrp";
442 case BWRITERSIO_FRC
: return "frc";
443 case BWRITERSIO_M4x4
: return "m4x4";
444 case BWRITERSIO_M4x3
: return "m4x3";
445 case BWRITERSIO_M3x4
: return "m3x4";
446 case BWRITERSIO_M3x3
: return "m3x3";
447 case BWRITERSIO_M3x2
: return "m3x2";
448 case BWRITERSIO_CALL
: return "call";
449 case BWRITERSIO_CALLNZ
: return "callnz";
450 case BWRITERSIO_LOOP
: return "loop";
451 case BWRITERSIO_RET
: return "ret";
452 case BWRITERSIO_ENDLOOP
: return "endloop";
453 case BWRITERSIO_LABEL
: return "label";
454 case BWRITERSIO_DCL
: return "dcl";
455 case BWRITERSIO_POW
: return "pow";
456 case BWRITERSIO_CRS
: return "crs";
457 case BWRITERSIO_SGN
: return "sgn";
458 case BWRITERSIO_ABS
: return "abs";
459 case BWRITERSIO_NRM
: return "nrm";
460 case BWRITERSIO_SINCOS
: return "sincos";
461 case BWRITERSIO_REP
: return "rep";
462 case BWRITERSIO_ENDREP
: return "endrep";
463 case BWRITERSIO_IF
: return "if";
464 case BWRITERSIO_IFC
: return "ifc";
465 case BWRITERSIO_ELSE
: return "else";
466 case BWRITERSIO_ENDIF
: return "endif";
467 case BWRITERSIO_BREAK
: return "break";
468 case BWRITERSIO_BREAKC
: return "breakc";
469 case BWRITERSIO_MOVA
: return "mova";
470 case BWRITERSIO_DEFB
: return "defb";
471 case BWRITERSIO_DEFI
: return "defi";
472 case BWRITERSIO_TEXCOORD
: return "texcoord";
473 case BWRITERSIO_TEXKILL
: return "texkill";
474 case BWRITERSIO_TEX
: return "tex";
475 case BWRITERSIO_TEXBEM
: return "texbem";
476 case BWRITERSIO_TEXBEML
: return "texbeml";
477 case BWRITERSIO_TEXREG2AR
: return "texreg2ar";
478 case BWRITERSIO_TEXREG2GB
: return "texreg2gb";
479 case BWRITERSIO_TEXM3x2PAD
: return "texm3x2pad";
480 case BWRITERSIO_TEXM3x2TEX
: return "texm3x2tex";
481 case BWRITERSIO_TEXM3x3PAD
: return "texm3x3pad";
482 case BWRITERSIO_TEXM3x3TEX
: return "texm3x3tex";
483 case BWRITERSIO_TEXM3x3SPEC
: return "texm3x3vspec";
484 case BWRITERSIO_TEXM3x3VSPEC
: return "texm3x3vspec";
485 case BWRITERSIO_EXPP
: return "expp";
486 case BWRITERSIO_LOGP
: return "logp";
487 case BWRITERSIO_CND
: return "cnd";
488 case BWRITERSIO_DEF
: return "def";
489 case BWRITERSIO_TEXREG2RGB
: return "texreg2rgb";
490 case BWRITERSIO_TEXDP3TEX
: return "texdp3tex";
491 case BWRITERSIO_TEXM3x2DEPTH
: return "texm3x2depth";
492 case BWRITERSIO_TEXDP3
: return "texdp3";
493 case BWRITERSIO_TEXM3x3
: return "texm3x3";
494 case BWRITERSIO_TEXDEPTH
: return "texdepth";
495 case BWRITERSIO_CMP
: return "cmp";
496 case BWRITERSIO_BEM
: return "bem";
497 case BWRITERSIO_DP2ADD
: return "dp2add";
498 case BWRITERSIO_DSX
: return "dsx";
499 case BWRITERSIO_DSY
: return "dsy";
500 case BWRITERSIO_TEXLDD
: return "texldd";
501 case BWRITERSIO_SETP
: return "setp";
502 case BWRITERSIO_TEXLDL
: return "texldl";
503 case BWRITERSIO_BREAKP
: return "breakp";
504 case BWRITERSIO_PHASE
: return "phase";
506 case BWRITERSIO_TEXLDP
: return "texldp";
507 case BWRITERSIO_TEXLDB
: return "texldb";
509 default: return "unknown";
513 void skip_dword_unknown(const char **ptr
, unsigned int count
)
518 FIXME("Skipping %u unknown DWORDs:\n", count
);
519 for (i
= 0; i
< count
; ++i
)
522 FIXME("\t0x%08x\n", d
);
526 static void write_dword_unknown(char **ptr
, DWORD d
)
528 FIXME("Writing unknown DWORD 0x%08x\n", d
);
532 HRESULT
dxbc_add_section(struct dxbc
*dxbc
, DWORD tag
, const char *data
, DWORD data_size
)
534 TRACE("dxbc %p, tag %s, size %#x.\n", dxbc
, debugstr_an((const char *)&tag
, 4), data_size
);
536 if (dxbc
->count
>= dxbc
->size
)
538 struct dxbc_section
*new_sections
;
539 DWORD new_size
= dxbc
->size
<< 1;
541 new_sections
= HeapReAlloc(GetProcessHeap(), 0, dxbc
->sections
, new_size
* sizeof(*dxbc
->sections
));
544 ERR("Failed to allocate dxbc section memory\n");
545 return E_OUTOFMEMORY
;
548 dxbc
->sections
= new_sections
;
549 dxbc
->size
= new_size
;
552 dxbc
->sections
[dxbc
->count
].tag
= tag
;
553 dxbc
->sections
[dxbc
->count
].data_size
= data_size
;
554 dxbc
->sections
[dxbc
->count
].data
= data
;
560 HRESULT
dxbc_init(struct dxbc
*dxbc
, UINT size
)
562 TRACE("dxbc %p, size %u.\n", dxbc
, size
);
564 /* use a good starting value for the size if none specified */
567 dxbc
->sections
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(*dxbc
->sections
));
570 ERR("Failed to allocate dxbc section memory\n");
571 return E_OUTOFMEMORY
;
580 HRESULT
dxbc_parse(const char *data
, SIZE_T data_size
, struct dxbc
*dxbc
)
582 const char *ptr
= data
;
585 DWORD tag
, total_size
, chunk_count
;
589 WARN("No data supplied.\n");
593 read_dword(&ptr
, &tag
);
594 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
598 WARN("Wrong tag.\n");
603 skip_dword_unknown(&ptr
, 4);
605 skip_dword_unknown(&ptr
, 1);
607 read_dword(&ptr
, &total_size
);
608 TRACE("total size: %#x\n", total_size
);
610 if (data_size
!= total_size
)
612 WARN("Wrong size supplied.\n");
613 return D3DERR_INVALIDCALL
;
616 read_dword(&ptr
, &chunk_count
);
617 TRACE("chunk count: %#x\n", chunk_count
);
619 hr
= dxbc_init(dxbc
, chunk_count
);
622 WARN("Failed to init dxbc\n");
626 for (i
= 0; i
< chunk_count
; ++i
)
628 DWORD chunk_tag
, chunk_size
;
629 const char *chunk_ptr
;
632 read_dword(&ptr
, &chunk_offset
);
633 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
635 chunk_ptr
= data
+ chunk_offset
;
637 read_dword(&chunk_ptr
, &chunk_tag
);
638 read_dword(&chunk_ptr
, &chunk_size
);
640 hr
= dxbc_add_section(dxbc
, chunk_tag
, chunk_ptr
, chunk_size
);
643 WARN("Failed to add section to dxbc\n");
651 void dxbc_destroy(struct dxbc
*dxbc
)
653 TRACE("dxbc %p.\n", dxbc
);
655 HeapFree(GetProcessHeap(), 0, dxbc
->sections
);
658 HRESULT
dxbc_write_blob(struct dxbc
*dxbc
, ID3DBlob
**blob
)
660 DWORD size
= 32, offset
= size
+ 4 * dxbc
->count
;
666 TRACE("dxbc %p, blob %p.\n", dxbc
, blob
);
668 for (i
= 0; i
< dxbc
->count
; ++i
)
670 size
+= 12 + dxbc
->sections
[i
].data_size
;
673 hr
= D3DCreateBlob(size
, &object
);
676 WARN("Failed to create blob\n");
680 ptr
= ID3D10Blob_GetBufferPointer(object
);
682 write_dword(&ptr
, TAG_DXBC
);
685 write_dword_unknown(&ptr
, 0);
686 write_dword_unknown(&ptr
, 0);
687 write_dword_unknown(&ptr
, 0);
688 write_dword_unknown(&ptr
, 0);
690 /* seems to be always 1 */
691 write_dword_unknown(&ptr
, 1);
694 write_dword(&ptr
, size
);
697 write_dword(&ptr
, dxbc
->count
);
699 /* write the chunk offsets */
700 for (i
= 0; i
< dxbc
->count
; ++i
)
702 write_dword(&ptr
, offset
);
703 offset
+= 8 + dxbc
->sections
[i
].data_size
;
706 /* write the chunks */
707 for (i
= 0; i
< dxbc
->count
; ++i
)
709 write_dword(&ptr
, dxbc
->sections
[i
].tag
);
710 write_dword(&ptr
, dxbc
->sections
[i
].data_size
);
711 memcpy(ptr
, dxbc
->sections
[i
].data
, dxbc
->sections
[i
].data_size
);
712 ptr
+= dxbc
->sections
[i
].data_size
;
715 TRACE("Created ID3DBlob %p\n", object
);
722 void compilation_message(struct compilation_messages
*msg
, const char *fmt
, va_list args
)
727 if (msg
->capacity
== 0)
729 msg
->string
= d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE
);
730 if (msg
->string
== NULL
)
732 ERR("Error allocating memory for parser messages\n");
735 msg
->capacity
= MESSAGEBUFFER_INITIAL_SIZE
;
740 rc
= vsnprintf(msg
->string
+ msg
->size
,
741 msg
->capacity
- msg
->size
, fmt
, args
);
743 if (rc
< 0 || rc
>= msg
->capacity
- msg
->size
)
745 size
= msg
->capacity
* 2;
746 buffer
= d3dcompiler_realloc(msg
->string
, size
);
749 ERR("Error reallocating memory for parser messages\n");
752 msg
->string
= buffer
;
753 msg
->capacity
= size
;
757 TRACE("%s", msg
->string
+ msg
->size
);
764 BOOL
add_declaration(struct hlsl_scope
*scope
, struct hlsl_ir_var
*decl
, BOOL local_var
)
766 struct hlsl_ir_var
*var
;
768 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
770 if (!strcmp(decl
->name
, var
->name
))
773 if (local_var
&& scope
->upper
->upper
== hlsl_ctx
.globals
)
775 /* Check whether the variable redefines a function parameter. */
776 LIST_FOR_EACH_ENTRY(var
, &scope
->upper
->vars
, struct hlsl_ir_var
, scope_entry
)
778 if (!strcmp(decl
->name
, var
->name
))
783 list_add_tail(&scope
->vars
, &decl
->scope_entry
);
787 struct hlsl_ir_var
*get_variable(struct hlsl_scope
*scope
, const char *name
)
789 struct hlsl_ir_var
*var
;
791 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
793 if (!strcmp(name
, var
->name
))
798 return get_variable(scope
->upper
, name
);
801 void free_declaration(struct hlsl_ir_var
*decl
)
803 d3dcompiler_free((void *)decl
->name
);
804 d3dcompiler_free((void *)decl
->semantic
);
805 d3dcompiler_free(decl
);
808 BOOL
add_func_parameter(struct list
*list
, struct parse_parameter
*param
, const struct source_location
*loc
)
810 struct hlsl_ir_var
*decl
= d3dcompiler_alloc(sizeof(*decl
));
814 ERR("Out of memory.\n");
817 decl
->node
.type
= HLSL_IR_VAR
;
818 decl
->node
.data_type
= param
->type
;
819 decl
->node
.loc
= *loc
;
820 decl
->name
= param
->name
;
821 decl
->semantic
= param
->semantic
;
822 decl
->modifiers
= param
->modifiers
;
824 if (!add_declaration(hlsl_ctx
.cur_scope
, decl
, FALSE
))
826 free_declaration(decl
);
829 list_add_tail(list
, &decl
->node
.entry
);
833 struct hlsl_type
*new_hlsl_type(const char *name
, enum hlsl_type_class type_class
,
834 enum hlsl_base_type base_type
, unsigned dimx
, unsigned dimy
)
836 struct hlsl_type
*type
;
838 type
= d3dcompiler_alloc(sizeof(*type
));
841 ERR("Out of memory\n");
845 type
->type
= type_class
;
846 type
->base_type
= base_type
;
850 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
855 struct hlsl_type
*new_array_type(struct hlsl_type
*basic_type
, unsigned int array_size
)
861 struct hlsl_type
*get_type(struct hlsl_scope
*scope
, const char *name
, BOOL recursive
)
867 BOOL
find_function(const char *name
)
869 struct hlsl_ir_function_decl
*func
;
871 LIST_FOR_EACH_ENTRY(func
, &hlsl_ctx
.functions
, struct hlsl_ir_function_decl
, node
.entry
)
873 if (!strcmp(func
->name
, name
))
879 unsigned int components_count_type(struct hlsl_type
*type
)
881 unsigned int count
= 0;
882 struct hlsl_struct_field
*field
;
884 if (type
->type
<= HLSL_CLASS_LAST_NUMERIC
)
886 return type
->dimx
* type
->dimy
;
888 if (type
->type
== HLSL_CLASS_ARRAY
)
890 return components_count_type(type
->e
.array
.type
) * type
->e
.array
.elements_count
;
892 if (type
->type
!= HLSL_CLASS_STRUCT
)
894 ERR("Unexpected data type %s.\n", debug_hlsl_type(type
));
898 LIST_FOR_EACH_ENTRY(field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
900 count
+= components_count_type(field
->type
);
905 static BOOL
compare_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
910 if (t1
->type
!= t2
->type
)
912 if (t1
->base_type
!= t2
->base_type
)
914 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
916 if (t1
->modifiers
!= t2
->modifiers
)
918 if (t1
->dimx
!= t2
->dimx
)
920 if (t1
->dimy
!= t2
->dimy
)
922 if (t1
->type
== HLSL_CLASS_STRUCT
)
924 struct list
*t1cur
, *t2cur
;
925 struct hlsl_struct_field
*t1field
, *t2field
;
927 t1cur
= list_head(t1
->e
.elements
);
928 t2cur
= list_head(t2
->e
.elements
);
929 while (t1cur
&& t2cur
)
931 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
932 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
933 if (!compare_hlsl_types(t1field
->type
, t2field
->type
))
935 if (strcmp(t1field
->name
, t2field
->name
))
937 t1cur
= list_next(t1
->e
.elements
, t1cur
);
938 t2cur
= list_next(t2
->e
.elements
, t2cur
);
943 if (t1
->type
== HLSL_CLASS_ARRAY
)
944 return t1
->e
.array
.elements_count
== t2
->e
.array
.elements_count
945 && compare_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
950 static BOOL
convertible_data_type(struct hlsl_type
*type
)
952 return type
->type
!= HLSL_CLASS_OBJECT
;
955 static BOOL
implicit_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
957 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
960 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
962 /* Scalar vars can be converted to any other numeric data type */
963 if (t1
->dimx
== 1 && t1
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
965 /* The other way around is true too */
966 if (t2
->dimx
== 1 && t2
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
970 if (t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
== HLSL_CLASS_ARRAY
)
972 return components_count_type(t1
) == components_count_type(t2
);
975 if ((t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
976 || (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->type
== HLSL_CLASS_ARRAY
))
978 /* e.g. float4[3] to float4 is allowed */
979 if (t1
->type
== HLSL_CLASS_ARRAY
&& compare_hlsl_types(t1
->e
.array
.type
, t2
))
981 if (components_count_type(t1
) == components_count_type(t2
))
986 if (t1
->type
<= HLSL_CLASS_VECTOR
&& t2
->type
<= HLSL_CLASS_VECTOR
)
988 if (t1
->dimx
>= t2
->dimx
)
993 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
995 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
996 && t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
999 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1000 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1001 && components_count_type(t1
) == components_count_type(t2
))
1006 if (t1
->type
== HLSL_CLASS_STRUCT
&& t2
->type
== HLSL_CLASS_STRUCT
)
1007 return compare_hlsl_types(t1
, t2
);
1012 static BOOL
expr_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1014 if (t1
->base_type
> HLSL_TYPE_LAST_SCALAR
|| t2
->base_type
> HLSL_TYPE_LAST_SCALAR
)
1017 /* Scalar vars can be converted to pretty much everything */
1018 if ((t1
->dimx
== 1 && t1
->dimy
== 1) || (t2
->dimx
== 1 && t2
->dimy
== 1))
1021 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1024 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1026 /* Matrix-vector conversion is apparently allowed if either they have the same components
1027 count or the matrix is nx1 or 1xn */
1028 if (t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1030 if (components_count_type(t1
) == components_count_type(t2
))
1033 return (t1
->type
== HLSL_CLASS_MATRIX
&& (t1
->dimx
== 1 || t1
->dimy
== 1))
1034 || (t2
->type
== HLSL_CLASS_MATRIX
&& (t2
->dimx
== 1 || t2
->dimy
== 1));
1038 if ((t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1039 || (t1
->dimx
<= t2
->dimx
&& t1
->dimy
<= t2
->dimy
))
1046 static enum hlsl_base_type
expr_common_base_type(enum hlsl_base_type t1
, enum hlsl_base_type t2
)
1048 enum hlsl_base_type types
[] =
1057 int t1_idx
= -1, t2_idx
= -1, i
;
1059 for (i
= 0; i
< sizeof(types
) / sizeof(types
[0]); ++i
)
1061 /* Always convert away from HLSL_TYPE_HALF */
1063 t1_idx
= t1
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1065 t2_idx
= t2
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1067 if (t1_idx
!= -1 && t2_idx
!= -1)
1070 if (t1_idx
== -1 || t2_idx
== -1)
1072 FIXME("Unexpected base type.\n");
1073 return HLSL_TYPE_FLOAT
;
1075 return t1_idx
>= t2_idx
? t1
: t2
;
1078 static struct hlsl_type
*expr_common_type(struct hlsl_type
*t1
, struct hlsl_type
*t2
,
1079 struct source_location
*loc
)
1081 enum hlsl_type_class type
;
1082 enum hlsl_base_type base
;
1083 unsigned int dimx
, dimy
;
1085 if (t1
->type
> HLSL_CLASS_LAST_NUMERIC
|| t2
->type
> HLSL_CLASS_LAST_NUMERIC
)
1087 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1088 "non scalar/vector/matrix data type in expression");
1092 if (compare_hlsl_types(t1
, t2
))
1095 if (!expr_compatible_data_types(t1
, t2
))
1097 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1098 "expression data types are incompatible");
1102 if (t1
->base_type
== t2
->base_type
)
1103 base
= t1
->base_type
;
1105 base
= expr_common_base_type(t1
->base_type
, t2
->base_type
);
1107 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1113 else if (t2
->dimx
== 1 && t2
->dimy
== 1)
1119 else if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
)
1121 type
= HLSL_CLASS_MATRIX
;
1122 dimx
= min(t1
->dimx
, t2
->dimx
);
1123 dimy
= min(t1
->dimy
, t2
->dimy
);
1127 /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1128 unsigned int max_dim_1
, max_dim_2
;
1130 max_dim_1
= max(t1
->dimx
, t1
->dimy
);
1131 max_dim_2
= max(t2
->dimx
, t2
->dimy
);
1132 if (t1
->dimx
* t1
->dimy
== t2
->dimx
* t2
->dimy
)
1134 type
= HLSL_CLASS_VECTOR
;
1135 dimx
= max(t1
->dimx
, t2
->dimx
);
1138 else if (max_dim_1
<= max_dim_2
)
1141 if (type
== HLSL_CLASS_VECTOR
)
1155 if (type
== HLSL_CLASS_VECTOR
)
1168 return new_hlsl_type(NULL
, type
, base
, dimx
, dimy
);
1171 static struct hlsl_ir_node
*implicit_conversion(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1172 struct source_location
*loc
)
1174 struct hlsl_ir_expr
*cast
;
1175 struct hlsl_ir_node
*operands
[3];
1177 if (compare_hlsl_types(node
->data_type
, type
))
1179 TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type
));
1181 operands
[1] = operands
[2] = NULL
;
1182 cast
= new_expr(HLSL_IR_UNOP_CAST
, operands
, loc
);
1185 cast
->node
.data_type
= type
;
1189 struct hlsl_ir_expr
*new_expr(enum hlsl_ir_expr_op op
, struct hlsl_ir_node
**operands
,
1190 struct source_location
*loc
)
1192 struct hlsl_ir_expr
*expr
= d3dcompiler_alloc(sizeof(*expr
));
1193 struct hlsl_type
*type
;
1198 ERR("Out of memory\n");
1201 expr
->node
.type
= HLSL_IR_EXPR
;
1202 expr
->node
.loc
= *loc
;
1203 type
= operands
[0]->data_type
;
1204 for (i
= 1; i
<= 2; ++i
)
1208 type
= expr_common_type(type
, operands
[i
]->data_type
, loc
);
1211 d3dcompiler_free(expr
);
1215 for (i
= 0; i
<= 2; ++i
)
1219 if (compare_hlsl_types(operands
[i
]->data_type
, type
))
1221 TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands
[i
]->data_type
), debug_hlsl_type(type
));
1222 if (operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= 1
1223 && operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= type
->dimx
* type
->dimy
)
1225 hlsl_report_message(operands
[i
]->loc
.file
,
1226 operands
[i
]->loc
.line
, operands
[i
]->loc
.col
, HLSL_LEVEL_WARNING
,
1227 "implicit truncation of vector/matrix type");
1229 operands
[i
] = implicit_conversion(operands
[i
], type
, &operands
[i
]->loc
);
1232 ERR("Impossible to convert expression operand %u to %s\n", i
+ 1, debug_hlsl_type(type
));
1233 d3dcompiler_free(expr
);
1237 expr
->node
.data_type
= type
;
1239 expr
->operands
[0] = operands
[0];
1240 expr
->operands
[1] = operands
[1];
1241 expr
->operands
[2] = operands
[2];
1246 struct hlsl_ir_expr
*hlsl_mul(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1247 struct source_location
*loc
)
1249 struct hlsl_ir_expr
*expr
;
1250 struct hlsl_ir_node
*ops
[3];
1255 expr
= new_expr(HLSL_IR_BINOP_MUL
, ops
, loc
);
1259 struct hlsl_ir_expr
*hlsl_div(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1260 struct source_location
*loc
)
1262 struct hlsl_ir_expr
*expr
;
1263 struct hlsl_ir_node
*ops
[3];
1268 expr
= new_expr(HLSL_IR_BINOP_DIV
, ops
, loc
);
1272 struct hlsl_ir_expr
*hlsl_mod(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1273 struct source_location
*loc
)
1275 struct hlsl_ir_expr
*expr
;
1276 struct hlsl_ir_node
*ops
[3];
1281 expr
= new_expr(HLSL_IR_BINOP_MOD
, ops
, loc
);
1285 struct hlsl_ir_expr
*hlsl_add(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1286 struct source_location
*loc
)
1288 struct hlsl_ir_expr
*expr
;
1289 struct hlsl_ir_node
*ops
[3];
1294 expr
= new_expr(HLSL_IR_BINOP_ADD
, ops
, loc
);
1298 struct hlsl_ir_expr
*hlsl_sub(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1299 struct source_location
*loc
)
1301 struct hlsl_ir_expr
*expr
;
1302 struct hlsl_ir_node
*ops
[3];
1307 expr
= new_expr(HLSL_IR_BINOP_SUB
, ops
, loc
);
1311 struct hlsl_ir_expr
*hlsl_lt(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1312 struct source_location
*loc
)
1314 struct hlsl_ir_expr
*expr
;
1315 struct hlsl_ir_node
*ops
[3];
1320 expr
= new_expr(HLSL_IR_BINOP_LESS
, ops
, loc
);
1324 struct hlsl_ir_expr
*hlsl_gt(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1325 struct source_location
*loc
)
1327 struct hlsl_ir_expr
*expr
;
1328 struct hlsl_ir_node
*ops
[3];
1333 expr
= new_expr(HLSL_IR_BINOP_GREATER
, ops
, loc
);
1337 struct hlsl_ir_expr
*hlsl_le(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1338 struct source_location
*loc
)
1340 struct hlsl_ir_expr
*expr
;
1341 struct hlsl_ir_node
*ops
[3];
1346 expr
= new_expr(HLSL_IR_BINOP_LEQUAL
, ops
, loc
);
1350 struct hlsl_ir_expr
*hlsl_ge(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1351 struct source_location
*loc
)
1353 struct hlsl_ir_expr
*expr
;
1354 struct hlsl_ir_node
*ops
[3];
1359 expr
= new_expr(HLSL_IR_BINOP_GEQUAL
, ops
, loc
);
1363 struct hlsl_ir_expr
*hlsl_eq(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1364 struct source_location
*loc
)
1366 struct hlsl_ir_expr
*expr
;
1367 struct hlsl_ir_node
*ops
[3];
1372 expr
= new_expr(HLSL_IR_BINOP_EQUAL
, ops
, loc
);
1376 struct hlsl_ir_expr
*hlsl_ne(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1377 struct source_location
*loc
)
1379 struct hlsl_ir_expr
*expr
;
1380 struct hlsl_ir_node
*ops
[3];
1385 expr
= new_expr(HLSL_IR_BINOP_NEQUAL
, ops
, loc
);
1389 struct hlsl_ir_deref
*new_var_deref(struct hlsl_ir_var
*var
)
1391 struct hlsl_ir_deref
*deref
= d3dcompiler_alloc(sizeof(*deref
));
1395 ERR("Out of memory.\n");
1398 deref
->node
.type
= HLSL_IR_DEREF
;
1399 deref
->node
.data_type
= var
->node
.data_type
;
1400 deref
->type
= HLSL_IR_DEREF_VAR
;
1405 static enum hlsl_ir_expr_op
op_from_assignment(enum parse_assign_op op
)
1407 static const enum hlsl_ir_expr_op ops
[] =
1415 HLSL_IR_BINOP_LSHIFT
,
1416 HLSL_IR_BINOP_RSHIFT
,
1417 HLSL_IR_BINOP_BIT_AND
,
1418 HLSL_IR_BINOP_BIT_OR
,
1419 HLSL_IR_BINOP_BIT_XOR
,
1425 struct hlsl_ir_node
*make_assignment(struct hlsl_ir_node
*left
, enum parse_assign_op assign_op
,
1426 DWORD writemask
, struct hlsl_ir_node
*right
)
1428 struct hlsl_ir_expr
*expr
;
1429 struct hlsl_ir_assignment
*assign
= d3dcompiler_alloc(sizeof(*assign
));
1430 struct hlsl_type
*type
;
1431 struct hlsl_ir_node
*lhs
, *rhs
;
1435 ERR("Out of memory\n");
1439 TRACE("Creating proper assignment expression.\n");
1441 if (writemask
== BWRITERSP_WRITEMASK_ALL
)
1442 type
= left
->data_type
;
1445 FIXME("Assignments with writemasks not supported yet.\n");
1448 assign
->node
.type
= HLSL_IR_ASSIGNMENT
;
1449 assign
->node
.loc
= left
->loc
;
1450 assign
->node
.data_type
= type
;
1451 assign
->writemask
= writemask
;
1452 FIXME("Check for casts in the lhs.\n");
1455 if (lhs
->type
== HLSL_IR_VAR
)
1457 struct hlsl_ir_deref
*lhs_deref
= new_var_deref(var_from_node(lhs
));
1458 lhs
= &lhs_deref
->node
;
1461 if (!compare_hlsl_types(type
, rhs
->data_type
))
1463 struct hlsl_ir_node
*converted_rhs
;
1465 if (!implicit_compatible_data_types(rhs
->data_type
, type
))
1467 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_ERROR
,
1468 "can't implicitly convert %s to %s",
1469 debug_hlsl_type(rhs
->data_type
), debug_hlsl_type(type
));
1474 if (lhs
->data_type
->dimx
* lhs
->data_type
->dimy
< rhs
->data_type
->dimx
* rhs
->data_type
->dimy
)
1475 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_WARNING
,
1476 "implicit truncation of vector type");
1478 converted_rhs
= implicit_conversion(rhs
, type
, &rhs
->loc
);
1481 ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type
));
1486 rhs
= converted_rhs
;
1490 if (assign_op
!= ASSIGN_OP_ASSIGN
)
1492 struct hlsl_ir_node
*operands
[3];
1493 enum hlsl_ir_expr_op op
= op_from_assignment(assign_op
);
1495 if (lhs
->type
!= HLSL_IR_DEREF
|| deref_from_node(lhs
)->type
!= HLSL_IR_DEREF_VAR
)
1497 FIXME("LHS expression not supported in compound assignments yet.\n");
1502 struct hlsl_ir_deref
*lhs_deref
= deref_from_node(lhs
), *new_deref
;
1504 TRACE("Adding an expression for the compound assignment.\n");
1505 new_deref
= new_var_deref(lhs_deref
->v
.var
);
1506 operands
[0] = &new_deref
->node
;
1509 expr
= new_expr(op
, operands
, &left
->loc
);
1510 assign
->rhs
= &expr
->node
;
1516 return &assign
->node
;
1519 void push_scope(struct hlsl_parse_ctx
*ctx
)
1521 struct hlsl_scope
*new_scope
= d3dcompiler_alloc(sizeof(*new_scope
));
1525 ERR("Out of memory!\n");
1528 TRACE("Pushing a new scope\n");
1529 list_init(&new_scope
->vars
);
1530 list_init(&new_scope
->types
);
1531 new_scope
->upper
= ctx
->cur_scope
;
1532 ctx
->cur_scope
= new_scope
;
1533 list_add_tail(&ctx
->scopes
, &new_scope
->entry
);
1536 BOOL
pop_scope(struct hlsl_parse_ctx
*ctx
)
1538 struct hlsl_scope
*prev_scope
= ctx
->cur_scope
->upper
;
1542 TRACE("Popping current scope\n");
1543 ctx
->cur_scope
= prev_scope
;
1547 struct hlsl_ir_function_decl
*new_func_decl(const char *name
, struct hlsl_type
*return_type
, struct list
*parameters
)
1549 struct hlsl_ir_function_decl
*decl
;
1551 decl
= d3dcompiler_alloc(sizeof(*decl
));
1554 ERR("Out of memory.\n");
1557 decl
->node
.type
= HLSL_IR_FUNCTION_DECL
;
1558 decl
->node
.data_type
= return_type
;
1560 decl
->parameters
= parameters
;
1565 static const char *debug_base_type(const struct hlsl_type
*type
)
1567 const char *name
= "(unknown)";
1569 switch (type
->base_type
)
1571 case HLSL_TYPE_FLOAT
: name
= "float"; break;
1572 case HLSL_TYPE_HALF
: name
= "half"; break;
1573 case HLSL_TYPE_DOUBLE
: name
= "double"; break;
1574 case HLSL_TYPE_INT
: name
= "int"; break;
1575 case HLSL_TYPE_UINT
: name
= "uint"; break;
1576 case HLSL_TYPE_BOOL
: name
= "bool"; break;
1577 case HLSL_TYPE_SAMPLER
:
1578 switch (type
->sampler_dim
)
1580 case HLSL_SAMPLER_DIM_GENERIC
: name
= "sampler"; break;
1581 case HLSL_SAMPLER_DIM_1D
: name
= "sampler1D"; break;
1582 case HLSL_SAMPLER_DIM_2D
: name
= "sampler2D"; break;
1583 case HLSL_SAMPLER_DIM_3D
: name
= "sampler3D"; break;
1584 case HLSL_SAMPLER_DIM_CUBE
: name
= "samplerCUBE"; break;
1588 FIXME("Unhandled case %u\n", type
->base_type
);
1593 const char *debug_hlsl_type(const struct hlsl_type
*type
)
1598 return debugstr_a(type
->name
);
1600 if (type
->type
== HLSL_CLASS_STRUCT
)
1601 return "<anonymous struct>";
1603 name
= debug_base_type(type
);
1605 if (type
->type
== HLSL_CLASS_SCALAR
)
1606 return wine_dbg_sprintf("%s", name
);
1607 if (type
->type
== HLSL_CLASS_VECTOR
)
1608 return wine_dbg_sprintf("%s%u", name
, type
->dimx
);
1609 if (type
->type
== HLSL_CLASS_MATRIX
)
1610 return wine_dbg_sprintf("%s%ux%u", name
, type
->dimx
, type
->dimy
);
1611 return "unexpected_type";
1614 const char *debug_modifiers(DWORD modifiers
)
1619 if (modifiers
& HLSL_STORAGE_EXTERN
)
1620 strcat(string
, " extern"); /* 7 */
1621 if (modifiers
& HLSL_STORAGE_NOINTERPOLATION
)
1622 strcat(string
, " nointerpolation"); /* 16 */
1623 if (modifiers
& HLSL_MODIFIER_PRECISE
)
1624 strcat(string
, " precise"); /* 8 */
1625 if (modifiers
& HLSL_STORAGE_SHARED
)
1626 strcat(string
, " shared"); /* 7 */
1627 if (modifiers
& HLSL_STORAGE_GROUPSHARED
)
1628 strcat(string
, " groupshared"); /* 12 */
1629 if (modifiers
& HLSL_STORAGE_STATIC
)
1630 strcat(string
, " static"); /* 7 */
1631 if (modifiers
& HLSL_STORAGE_UNIFORM
)
1632 strcat(string
, " uniform"); /* 8 */
1633 if (modifiers
& HLSL_STORAGE_VOLATILE
)
1634 strcat(string
, " volatile"); /* 9 */
1635 if (modifiers
& HLSL_MODIFIER_CONST
)
1636 strcat(string
, " const"); /* 6 */
1637 if (modifiers
& HLSL_MODIFIER_ROW_MAJOR
)
1638 strcat(string
, " row_major"); /* 10 */
1639 if (modifiers
& HLSL_MODIFIER_COLUMN_MAJOR
)
1640 strcat(string
, " column_major"); /* 13 */
1641 if ((modifiers
& (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
)) == (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
))
1642 strcat(string
, " inout"); /* 6 */
1643 else if (modifiers
& HLSL_MODIFIER_IN
)
1644 strcat(string
, " in"); /* 3 */
1645 else if (modifiers
& HLSL_MODIFIER_OUT
)
1646 strcat(string
, " out"); /* 4 */
1648 return wine_dbg_sprintf("%s", string
[0] ? string
+ 1 : "");
1651 static const char *debug_node_type(enum hlsl_ir_node_type type
)
1653 const char *names
[] =
1656 "HLSL_IR_ASSIGNMENT",
1658 "HLSL_IR_CONSTRUCTOR",
1661 "HLSL_IR_FUNCTION_DECL",
1664 if (type
>= sizeof(names
) / sizeof(names
[0]))
1665 return "Unexpected node type";
1669 static void debug_dump_instr(const struct hlsl_ir_node
*instr
);
1671 static void debug_dump_ir_var(const struct hlsl_ir_var
*var
)
1674 TRACE("%s ", debug_modifiers(var
->modifiers
));
1675 TRACE("%s %s", debug_hlsl_type(var
->node
.data_type
), var
->name
);
1677 TRACE(" : %s", debugstr_a(var
->semantic
));
1680 static void debug_dump_ir_deref(const struct hlsl_ir_deref
*deref
)
1682 switch (deref
->type
)
1684 case HLSL_IR_DEREF_VAR
:
1686 debug_dump_ir_var(deref
->v
.var
);
1689 case HLSL_IR_DEREF_ARRAY
:
1690 debug_dump_instr(deref
->v
.array
.array
);
1692 debug_dump_instr(deref
->v
.array
.index
);
1695 case HLSL_IR_DEREF_RECORD
:
1696 debug_dump_instr(deref
->v
.record
.record
);
1697 TRACE(".%s", debugstr_a(deref
->v
.record
.field
));
1702 static void debug_dump_ir_constant(const struct hlsl_ir_constant
*constant
)
1704 struct hlsl_type
*type
= constant
->node
.data_type
;
1707 if (type
->dimy
!= 1)
1709 for (y
= 0; y
< type
->dimy
; ++y
)
1711 if (type
->dimx
!= 1)
1713 for (x
= 0; x
< type
->dimx
; ++x
)
1715 switch (type
->base_type
)
1717 case HLSL_TYPE_FLOAT
:
1718 TRACE("%g ", (double)constant
->v
.value
.f
[y
* type
->dimx
+ x
]);
1720 case HLSL_TYPE_DOUBLE
:
1721 TRACE("%g ", constant
->v
.value
.d
[y
* type
->dimx
+ x
]);
1724 TRACE("%d ", constant
->v
.value
.i
[y
* type
->dimx
+ x
]);
1726 case HLSL_TYPE_UINT
:
1727 TRACE("%u ", constant
->v
.value
.u
[y
* type
->dimx
+ x
]);
1729 case HLSL_TYPE_BOOL
:
1730 TRACE("%s ", constant
->v
.value
.b
[y
* type
->dimx
+ x
] == FALSE
? "false" : "true");
1733 TRACE("Constants of type %s not supported\n", debug_base_type(type
));
1736 if (type
->dimx
!= 1)
1739 if (type
->dimy
!= 1)
1743 static const char *debug_expr_op(const struct hlsl_ir_expr
*expr
)
1745 static const char *op_names
[] =
1813 if (expr
->op
== HLSL_IR_UNOP_CAST
)
1814 return debug_hlsl_type(expr
->node
.data_type
);
1816 return op_names
[expr
->op
];
1819 /* Dumps the expression in a prefix "operator (operands)" form */
1820 static void debug_dump_ir_expr(const struct hlsl_ir_expr
*expr
)
1824 TRACE("%s (", debug_expr_op(expr
));
1825 for (i
= 0; i
< 3 && expr
->operands
[i
]; ++i
)
1827 debug_dump_instr(expr
->operands
[i
]);
1833 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor
*constructor
)
1835 struct hlsl_ir_node
*arg
;
1837 TRACE("%s (", debug_hlsl_type(constructor
->node
.data_type
));
1838 LIST_FOR_EACH_ENTRY(arg
, constructor
->arguments
, struct hlsl_ir_node
, entry
)
1840 debug_dump_instr(arg
);
1846 static const char *debug_writemask(DWORD writemask
)
1848 char string
[5], components
[] = {'x', 'y', 'z', 'w'};
1849 unsigned int i
= 0, pos
= 0;
1854 string
[pos
++] = components
[i
];
1859 return wine_dbg_sprintf(".%s", string
);
1862 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment
*assign
)
1865 debug_dump_instr(assign
->lhs
);
1866 if (assign
->writemask
!= BWRITERSP_WRITEMASK_ALL
)
1867 TRACE("%s", debug_writemask(assign
->writemask
));
1869 debug_dump_instr(assign
->rhs
);
1873 static void debug_dump_instr(const struct hlsl_ir_node
*instr
)
1875 switch (instr
->type
)
1878 debug_dump_ir_expr(expr_from_node(instr
));
1881 debug_dump_ir_deref(deref_from_node(instr
));
1883 case HLSL_IR_CONSTANT
:
1884 debug_dump_ir_constant(constant_from_node(instr
));
1886 case HLSL_IR_ASSIGNMENT
:
1887 debug_dump_ir_assignment(assignment_from_node(instr
));
1889 case HLSL_IR_CONSTRUCTOR
:
1890 debug_dump_ir_constructor(constructor_from_node(instr
));
1893 TRACE("No dump function for %s\n", debug_node_type(instr
->type
));
1897 static void debug_dump_instr_list(const struct list
*list
)
1899 struct hlsl_ir_node
*instr
;
1901 LIST_FOR_EACH_ENTRY(instr
, list
, struct hlsl_ir_node
, entry
)
1903 debug_dump_instr(instr
);
1908 void debug_dump_ir_function(const struct hlsl_ir_function_decl
*func
)
1910 struct hlsl_ir_var
*param
;
1912 TRACE("Dumping function %s.\n", debugstr_a(func
->name
));
1913 TRACE("Function parameters:\n");
1914 LIST_FOR_EACH_ENTRY(param
, func
->parameters
, struct hlsl_ir_var
, node
.entry
)
1916 debug_dump_ir_var(param
);
1920 TRACE("Function semantic: %s\n", debugstr_a(func
->semantic
));
1923 debug_dump_instr_list(func
->body
);
1927 void free_hlsl_type(struct hlsl_type
*type
)
1929 struct hlsl_struct_field
*field
, *next_field
;
1931 d3dcompiler_free((void *)type
->name
);
1932 if (type
->type
== HLSL_CLASS_STRUCT
)
1934 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
1936 d3dcompiler_free((void *)field
->name
);
1937 d3dcompiler_free((void *)field
->semantic
);
1938 d3dcompiler_free(field
);
1941 d3dcompiler_free(type
);
1944 void free_instr_list(struct list
*list
)
1946 struct hlsl_ir_node
*node
, *next_node
;
1950 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, list
, struct hlsl_ir_node
, entry
)
1954 static void free_ir_constant(struct hlsl_ir_constant
*constant
)
1956 struct hlsl_type
*type
= constant
->node
.data_type
;
1958 struct hlsl_ir_constant
*field
, *next_field
;
1962 case HLSL_CLASS_ARRAY
:
1963 for (i
= 0; i
< type
->e
.array
.elements_count
; ++i
)
1964 free_ir_constant(&constant
->v
.array_elements
[i
]);
1965 d3dcompiler_free(constant
->v
.array_elements
);
1967 case HLSL_CLASS_STRUCT
:
1968 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, constant
->v
.struct_elements
, struct hlsl_ir_constant
, node
.entry
)
1969 free_ir_constant(field
);
1974 d3dcompiler_free(constant
);
1977 static void free_ir_deref(struct hlsl_ir_deref
*deref
)
1979 switch (deref
->type
)
1981 case HLSL_IR_DEREF_VAR
:
1982 /* Variables are shared among nodes in the tree. */
1984 case HLSL_IR_DEREF_ARRAY
:
1985 free_instr(deref
->v
.array
.array
);
1986 free_instr(deref
->v
.array
.index
);
1988 case HLSL_IR_DEREF_RECORD
:
1989 free_instr(deref
->v
.record
.record
);
1990 d3dcompiler_free((void *)deref
->v
.record
.field
);
1993 d3dcompiler_free(deref
);
1996 static void free_ir_constructor(struct hlsl_ir_constructor
*constructor
)
1998 free_instr_list(constructor
->arguments
);
1999 d3dcompiler_free(constructor
);
2002 static void free_ir_expr(struct hlsl_ir_expr
*expr
)
2006 for (i
= 0; i
< 3; ++i
)
2008 if (!expr
->operands
[i
])
2010 free_instr(expr
->operands
[i
]);
2012 free_instr_list(expr
->subexpressions
);
2013 d3dcompiler_free(expr
);
2016 static void free_ir_assignment(struct hlsl_ir_assignment
*assignment
)
2018 free_instr(assignment
->lhs
);
2019 free_instr(assignment
->rhs
);
2020 d3dcompiler_free(assignment
);
2023 void free_instr(struct hlsl_ir_node
*node
)
2028 /* These are freed later on from the scopes. */
2030 case HLSL_IR_CONSTANT
:
2031 free_ir_constant(constant_from_node(node
));
2034 free_ir_deref(deref_from_node(node
));
2036 case HLSL_IR_CONSTRUCTOR
:
2037 free_ir_constructor(constructor_from_node(node
));
2040 free_ir_expr(expr_from_node(node
));
2042 case HLSL_IR_ASSIGNMENT
:
2043 free_ir_assignment(assignment_from_node(node
));
2046 FIXME("Unsupported node type %s\n", debug_node_type(node
->type
));
2050 void free_function(struct hlsl_ir_function_decl
*func
)
2052 struct hlsl_ir_var
*param
, *next_param
;
2054 d3dcompiler_free((void *)func
->name
);
2055 d3dcompiler_free((void *)func
->semantic
);
2056 LIST_FOR_EACH_ENTRY_SAFE(param
, next_param
, func
->parameters
, struct hlsl_ir_var
, node
.entry
)
2057 d3dcompiler_free(param
);
2058 d3dcompiler_free(func
->parameters
);
2059 free_instr_list(func
->body
);
2060 d3dcompiler_free(func
->body
);