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
26 #include "d3dcompiler_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler
);
30 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
32 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c
)
36 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR
);
37 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR
);
38 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS
);
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS
);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT
);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT
);
42 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS
);
43 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER
);
45 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c
);
46 return "unrecognized";
50 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t
)
54 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID
);
55 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL
);
56 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT
);
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT
);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING
);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE
);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D
);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D
);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D
);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE
);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER
);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER
);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER
);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT
);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8
);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER
);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER
);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL
);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND
);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER
);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER
);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER
);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY
);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY
);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW
);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW
);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS
);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY
);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY
);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER
);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER
);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER
);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER
);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE
);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D
);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY
);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D
);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY
);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D
);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER
);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER
);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER
);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER
);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER
);
98 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER
);
99 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER
);
101 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t
);
102 return "unrecognized";
106 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part
)
110 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB
);
111 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB
);
112 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
);
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB
);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB
);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO
);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER
);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER
);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER
);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER
);
120 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS
);
121 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF
);
123 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part
);
124 return "unrecognized";
128 const char *debug_print_srcmod(DWORD mod
)
132 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG
);
133 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS
);
134 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG
);
135 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN
);
136 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG
);
137 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP
);
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2
);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG
);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ
);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW
);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS
);
143 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG
);
144 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT
);
146 FIXME("Unrecognized source modifier %#x.\n", mod
);
147 return "unrecognized_src_mod";
151 #undef WINE_D3DCOMPILER_TO_STR
153 const char *debug_print_dstmod(DWORD mod
)
159 case BWRITERSPDM_SATURATE
:
161 case BWRITERSPDM_PARTIALPRECISION
:
163 case BWRITERSPDM_MSAMPCENTROID
:
165 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
:
167 case BWRITERSPDM_SATURATE
| BWRITERSPDM_MSAMPCENTROID
:
168 return "_sat_centroid";
169 case BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
170 return "_pp_centroid";
171 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
172 return "_sat_pp_centroid";
174 return "Unexpected modifier\n";
178 const char *debug_print_shift(DWORD shift
)
180 static const char * const shiftstrings
[] =
199 return shiftstrings
[shift
];
202 static const char *get_regname(const struct shader_reg
*reg
)
206 case BWRITERSPR_TEMP
:
207 return wine_dbg_sprintf("r%u", reg
->regnum
);
208 case BWRITERSPR_INPUT
:
209 return wine_dbg_sprintf("v%u", reg
->regnum
);
210 case BWRITERSPR_CONST
:
211 return wine_dbg_sprintf("c%u", reg
->regnum
);
212 case BWRITERSPR_ADDR
:
213 return wine_dbg_sprintf("a%u", reg
->regnum
);
214 case BWRITERSPR_TEXTURE
:
215 return wine_dbg_sprintf("t%u", reg
->regnum
);
216 case BWRITERSPR_RASTOUT
:
219 case BWRITERSRO_POSITION
: return "oPos";
220 case BWRITERSRO_FOG
: return "oFog";
221 case BWRITERSRO_POINT_SIZE
: return "oPts";
222 default: return "Unexpected RASTOUT";
224 case BWRITERSPR_ATTROUT
:
225 return wine_dbg_sprintf("oD%u", reg
->regnum
);
226 case BWRITERSPR_TEXCRDOUT
:
227 return wine_dbg_sprintf("oT%u", reg
->regnum
);
228 case BWRITERSPR_OUTPUT
:
229 return wine_dbg_sprintf("o%u", reg
->regnum
);
230 case BWRITERSPR_CONSTINT
:
231 return wine_dbg_sprintf("i%u", reg
->regnum
);
232 case BWRITERSPR_COLOROUT
:
233 return wine_dbg_sprintf("oC%u", reg
->regnum
);
234 case BWRITERSPR_DEPTHOUT
:
236 case BWRITERSPR_SAMPLER
:
237 return wine_dbg_sprintf("s%u", reg
->regnum
);
238 case BWRITERSPR_CONSTBOOL
:
239 return wine_dbg_sprintf("b%u", reg
->regnum
);
240 case BWRITERSPR_LOOP
:
242 case BWRITERSPR_MISCTYPE
:
245 case 0: return "vPos";
246 case 1: return "vFace";
247 default: return "unexpected misctype";
249 case BWRITERSPR_LABEL
:
250 return wine_dbg_sprintf("l%u", reg
->regnum
);
251 case BWRITERSPR_PREDICATE
:
252 return wine_dbg_sprintf("p%u", reg
->regnum
);
254 return wine_dbg_sprintf("unknown regname %#x", reg
->type
);
258 static const char *debug_print_writemask(DWORD mask
)
261 unsigned char pos
= 1;
263 if(mask
== BWRITERSP_WRITEMASK_ALL
) return "";
265 if(mask
& BWRITERSP_WRITEMASK_0
) ret
[pos
++] = 'x';
266 if(mask
& BWRITERSP_WRITEMASK_1
) ret
[pos
++] = 'y';
267 if(mask
& BWRITERSP_WRITEMASK_2
) ret
[pos
++] = 'z';
268 if(mask
& BWRITERSP_WRITEMASK_3
) ret
[pos
++] = 'w';
271 return wine_dbg_sprintf("%s", ret
);
274 static const char *debug_print_swizzle(DWORD arg
)
282 case BWRITERVS_NOSWIZZLE
:
284 case BWRITERVS_SWIZZLE_X
:
286 case BWRITERVS_SWIZZLE_Y
:
288 case BWRITERVS_SWIZZLE_Z
:
290 case BWRITERVS_SWIZZLE_W
:
294 swizzle
[0] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 0)) & 0x03;
295 swizzle
[1] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 2)) & 0x03;
296 swizzle
[2] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 4)) & 0x03;
297 swizzle
[3] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 6)) & 0x03;
300 for (i
= 0; i
< 4; ++i
)
304 case 0: ret
[1 + i
] = 'x'; break;
305 case 1: ret
[1 + i
] = 'y'; break;
306 case 2: ret
[1 + i
] = 'z'; break;
307 case 3: ret
[1 + i
] = 'w'; break;
312 return wine_dbg_sprintf("%s", ret
);
315 static const char *debug_print_relarg(const struct shader_reg
*reg
)
317 const char *short_swizzle
;
318 if (!reg
->rel_reg
) return "";
320 short_swizzle
= debug_print_swizzle(reg
->rel_reg
->u
.swizzle
);
322 if (reg
->rel_reg
->type
== BWRITERSPR_ADDR
)
323 return wine_dbg_sprintf("[a%u%s]", reg
->rel_reg
->regnum
, short_swizzle
);
324 else if(reg
->rel_reg
->type
== BWRITERSPR_LOOP
&& reg
->rel_reg
->regnum
== 0)
325 return wine_dbg_sprintf("[aL%s]", short_swizzle
);
327 return "Unexpected relative addressing argument";
330 const char *debug_print_dstreg(const struct shader_reg
*reg
)
332 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
333 debug_print_relarg(reg
),
334 debug_print_writemask(reg
->u
.writemask
));
337 const char *debug_print_srcreg(const struct shader_reg
*reg
)
341 case BWRITERSPSM_NONE
:
342 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
343 debug_print_relarg(reg
),
344 debug_print_swizzle(reg
->u
.swizzle
));
345 case BWRITERSPSM_NEG
:
346 return wine_dbg_sprintf("-%s%s%s", get_regname(reg
),
347 debug_print_relarg(reg
),
348 debug_print_swizzle(reg
->u
.swizzle
));
349 case BWRITERSPSM_BIAS
:
350 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg
),
351 debug_print_relarg(reg
),
352 debug_print_swizzle(reg
->u
.swizzle
));
353 case BWRITERSPSM_BIASNEG
:
354 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg
),
355 debug_print_relarg(reg
),
356 debug_print_swizzle(reg
->u
.swizzle
));
357 case BWRITERSPSM_SIGN
:
358 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg
),
359 debug_print_relarg(reg
),
360 debug_print_swizzle(reg
->u
.swizzle
));
361 case BWRITERSPSM_SIGNNEG
:
362 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg
),
363 debug_print_relarg(reg
),
364 debug_print_swizzle(reg
->u
.swizzle
));
365 case BWRITERSPSM_COMP
:
366 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg
),
367 debug_print_relarg(reg
),
368 debug_print_swizzle(reg
->u
.swizzle
));
370 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg
),
371 debug_print_relarg(reg
),
372 debug_print_swizzle(reg
->u
.swizzle
));
373 case BWRITERSPSM_X2NEG
:
374 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg
),
375 debug_print_relarg(reg
),
376 debug_print_swizzle(reg
->u
.swizzle
));
378 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg
),
379 debug_print_relarg(reg
),
380 debug_print_swizzle(reg
->u
.swizzle
));
382 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg
),
383 debug_print_relarg(reg
),
384 debug_print_swizzle(reg
->u
.swizzle
));
385 case BWRITERSPSM_ABS
:
386 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg
),
387 debug_print_relarg(reg
),
388 debug_print_swizzle(reg
->u
.swizzle
));
389 case BWRITERSPSM_ABSNEG
:
390 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg
),
391 debug_print_relarg(reg
),
392 debug_print_swizzle(reg
->u
.swizzle
));
393 case BWRITERSPSM_NOT
:
394 return wine_dbg_sprintf("!%s%s%s", get_regname(reg
),
395 debug_print_relarg(reg
),
396 debug_print_swizzle(reg
->u
.swizzle
));
398 return "Unknown modifier";
401 const char *debug_print_comp(DWORD comp
)
405 case BWRITER_COMPARISON_NONE
: return "";
406 case BWRITER_COMPARISON_GT
: return "_gt";
407 case BWRITER_COMPARISON_EQ
: return "_eq";
408 case BWRITER_COMPARISON_GE
: return "_ge";
409 case BWRITER_COMPARISON_LT
: return "_lt";
410 case BWRITER_COMPARISON_NE
: return "_ne";
411 case BWRITER_COMPARISON_LE
: return "_le";
412 default: return "_unknown";
416 const char *debug_print_opcode(DWORD opcode
)
420 case BWRITERSIO_NOP
: return "nop";
421 case BWRITERSIO_MOV
: return "mov";
422 case BWRITERSIO_ADD
: return "add";
423 case BWRITERSIO_SUB
: return "sub";
424 case BWRITERSIO_MAD
: return "mad";
425 case BWRITERSIO_MUL
: return "mul";
426 case BWRITERSIO_RCP
: return "rcp";
427 case BWRITERSIO_RSQ
: return "rsq";
428 case BWRITERSIO_DP3
: return "dp3";
429 case BWRITERSIO_DP4
: return "dp4";
430 case BWRITERSIO_MIN
: return "min";
431 case BWRITERSIO_MAX
: return "max";
432 case BWRITERSIO_SLT
: return "slt";
433 case BWRITERSIO_SGE
: return "sge";
434 case BWRITERSIO_EXP
: return "exp";
435 case BWRITERSIO_LOG
: return "log";
436 case BWRITERSIO_LIT
: return "lit";
437 case BWRITERSIO_DST
: return "dst";
438 case BWRITERSIO_LRP
: return "lrp";
439 case BWRITERSIO_FRC
: return "frc";
440 case BWRITERSIO_M4x4
: return "m4x4";
441 case BWRITERSIO_M4x3
: return "m4x3";
442 case BWRITERSIO_M3x4
: return "m3x4";
443 case BWRITERSIO_M3x3
: return "m3x3";
444 case BWRITERSIO_M3x2
: return "m3x2";
445 case BWRITERSIO_CALL
: return "call";
446 case BWRITERSIO_CALLNZ
: return "callnz";
447 case BWRITERSIO_LOOP
: return "loop";
448 case BWRITERSIO_RET
: return "ret";
449 case BWRITERSIO_ENDLOOP
: return "endloop";
450 case BWRITERSIO_LABEL
: return "label";
451 case BWRITERSIO_DCL
: return "dcl";
452 case BWRITERSIO_POW
: return "pow";
453 case BWRITERSIO_CRS
: return "crs";
454 case BWRITERSIO_SGN
: return "sgn";
455 case BWRITERSIO_ABS
: return "abs";
456 case BWRITERSIO_NRM
: return "nrm";
457 case BWRITERSIO_SINCOS
: return "sincos";
458 case BWRITERSIO_REP
: return "rep";
459 case BWRITERSIO_ENDREP
: return "endrep";
460 case BWRITERSIO_IF
: return "if";
461 case BWRITERSIO_IFC
: return "ifc";
462 case BWRITERSIO_ELSE
: return "else";
463 case BWRITERSIO_ENDIF
: return "endif";
464 case BWRITERSIO_BREAK
: return "break";
465 case BWRITERSIO_BREAKC
: return "breakc";
466 case BWRITERSIO_MOVA
: return "mova";
467 case BWRITERSIO_DEFB
: return "defb";
468 case BWRITERSIO_DEFI
: return "defi";
469 case BWRITERSIO_TEXCOORD
: return "texcoord";
470 case BWRITERSIO_TEXKILL
: return "texkill";
471 case BWRITERSIO_TEX
: return "tex";
472 case BWRITERSIO_TEXBEM
: return "texbem";
473 case BWRITERSIO_TEXBEML
: return "texbeml";
474 case BWRITERSIO_TEXREG2AR
: return "texreg2ar";
475 case BWRITERSIO_TEXREG2GB
: return "texreg2gb";
476 case BWRITERSIO_TEXM3x2PAD
: return "texm3x2pad";
477 case BWRITERSIO_TEXM3x2TEX
: return "texm3x2tex";
478 case BWRITERSIO_TEXM3x3PAD
: return "texm3x3pad";
479 case BWRITERSIO_TEXM3x3TEX
: return "texm3x3tex";
480 case BWRITERSIO_TEXM3x3SPEC
: return "texm3x3vspec";
481 case BWRITERSIO_TEXM3x3VSPEC
: return "texm3x3vspec";
482 case BWRITERSIO_EXPP
: return "expp";
483 case BWRITERSIO_LOGP
: return "logp";
484 case BWRITERSIO_CND
: return "cnd";
485 case BWRITERSIO_DEF
: return "def";
486 case BWRITERSIO_TEXREG2RGB
: return "texreg2rgb";
487 case BWRITERSIO_TEXDP3TEX
: return "texdp3tex";
488 case BWRITERSIO_TEXM3x2DEPTH
: return "texm3x2depth";
489 case BWRITERSIO_TEXDP3
: return "texdp3";
490 case BWRITERSIO_TEXM3x3
: return "texm3x3";
491 case BWRITERSIO_TEXDEPTH
: return "texdepth";
492 case BWRITERSIO_CMP
: return "cmp";
493 case BWRITERSIO_BEM
: return "bem";
494 case BWRITERSIO_DP2ADD
: return "dp2add";
495 case BWRITERSIO_DSX
: return "dsx";
496 case BWRITERSIO_DSY
: return "dsy";
497 case BWRITERSIO_TEXLDD
: return "texldd";
498 case BWRITERSIO_SETP
: return "setp";
499 case BWRITERSIO_TEXLDL
: return "texldl";
500 case BWRITERSIO_BREAKP
: return "breakp";
501 case BWRITERSIO_PHASE
: return "phase";
503 case BWRITERSIO_TEXLDP
: return "texldp";
504 case BWRITERSIO_TEXLDB
: return "texldb";
506 default: return "unknown";
510 void skip_dword_unknown(const char **ptr
, unsigned int count
)
515 FIXME("Skipping %u unknown DWORDs:\n", count
);
516 for (i
= 0; i
< count
; ++i
)
519 FIXME("\t0x%08x\n", d
);
523 static void write_dword_unknown(char **ptr
, DWORD d
)
525 FIXME("Writing unknown DWORD 0x%08x\n", d
);
529 HRESULT
dxbc_add_section(struct dxbc
*dxbc
, DWORD tag
, const char *data
, DWORD data_size
)
531 TRACE("dxbc %p, tag %s, size %#x.\n", dxbc
, debugstr_an((const char *)&tag
, 4), data_size
);
533 if (dxbc
->count
>= dxbc
->size
)
535 struct dxbc_section
*new_sections
;
536 DWORD new_size
= dxbc
->size
<< 1;
538 new_sections
= HeapReAlloc(GetProcessHeap(), 0, dxbc
->sections
, new_size
* sizeof(*dxbc
->sections
));
541 ERR("Failed to allocate dxbc section memory\n");
542 return E_OUTOFMEMORY
;
545 dxbc
->sections
= new_sections
;
546 dxbc
->size
= new_size
;
549 dxbc
->sections
[dxbc
->count
].tag
= tag
;
550 dxbc
->sections
[dxbc
->count
].data_size
= data_size
;
551 dxbc
->sections
[dxbc
->count
].data
= data
;
557 HRESULT
dxbc_init(struct dxbc
*dxbc
, unsigned int size
)
559 TRACE("dxbc %p, size %u.\n", dxbc
, size
);
561 /* use a good starting value for the size if none specified */
564 dxbc
->sections
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(*dxbc
->sections
));
567 ERR("Failed to allocate dxbc section memory\n");
568 return E_OUTOFMEMORY
;
577 HRESULT
dxbc_parse(const char *data
, SIZE_T data_size
, struct dxbc
*dxbc
)
579 const char *ptr
= data
;
582 DWORD tag
, total_size
, chunk_count
;
586 WARN("No data supplied.\n");
590 read_dword(&ptr
, &tag
);
591 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
595 WARN("Wrong tag.\n");
600 skip_dword_unknown(&ptr
, 4);
602 skip_dword_unknown(&ptr
, 1);
604 read_dword(&ptr
, &total_size
);
605 TRACE("total size: %#x\n", total_size
);
607 if (data_size
!= total_size
)
609 WARN("Wrong size supplied.\n");
610 return D3DERR_INVALIDCALL
;
613 read_dword(&ptr
, &chunk_count
);
614 TRACE("chunk count: %#x\n", chunk_count
);
616 hr
= dxbc_init(dxbc
, chunk_count
);
619 WARN("Failed to init dxbc\n");
623 for (i
= 0; i
< chunk_count
; ++i
)
625 DWORD chunk_tag
, chunk_size
;
626 const char *chunk_ptr
;
629 read_dword(&ptr
, &chunk_offset
);
630 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
632 chunk_ptr
= data
+ chunk_offset
;
634 read_dword(&chunk_ptr
, &chunk_tag
);
635 read_dword(&chunk_ptr
, &chunk_size
);
637 hr
= dxbc_add_section(dxbc
, chunk_tag
, chunk_ptr
, chunk_size
);
640 WARN("Failed to add section to dxbc\n");
648 void dxbc_destroy(struct dxbc
*dxbc
)
650 TRACE("dxbc %p.\n", dxbc
);
652 HeapFree(GetProcessHeap(), 0, dxbc
->sections
);
655 HRESULT
dxbc_write_blob(struct dxbc
*dxbc
, ID3DBlob
**blob
)
657 DWORD size
= 32, offset
= size
+ 4 * dxbc
->count
;
663 TRACE("dxbc %p, blob %p.\n", dxbc
, blob
);
665 for (i
= 0; i
< dxbc
->count
; ++i
)
667 size
+= 12 + dxbc
->sections
[i
].data_size
;
670 hr
= D3DCreateBlob(size
, &object
);
673 WARN("Failed to create blob\n");
677 ptr
= ID3D10Blob_GetBufferPointer(object
);
679 write_dword(&ptr
, TAG_DXBC
);
682 write_dword_unknown(&ptr
, 0);
683 write_dword_unknown(&ptr
, 0);
684 write_dword_unknown(&ptr
, 0);
685 write_dword_unknown(&ptr
, 0);
687 /* seems to be always 1 */
688 write_dword_unknown(&ptr
, 1);
691 write_dword(&ptr
, size
);
694 write_dword(&ptr
, dxbc
->count
);
696 /* write the chunk offsets */
697 for (i
= 0; i
< dxbc
->count
; ++i
)
699 write_dword(&ptr
, offset
);
700 offset
+= 8 + dxbc
->sections
[i
].data_size
;
703 /* write the chunks */
704 for (i
= 0; i
< dxbc
->count
; ++i
)
706 write_dword(&ptr
, dxbc
->sections
[i
].tag
);
707 write_dword(&ptr
, dxbc
->sections
[i
].data_size
);
708 memcpy(ptr
, dxbc
->sections
[i
].data
, dxbc
->sections
[i
].data_size
);
709 ptr
+= dxbc
->sections
[i
].data_size
;
712 TRACE("Created ID3DBlob %p\n", object
);
719 void compilation_message(struct compilation_messages
*msg
, const char *fmt
, __ms_va_list args
)
724 if (msg
->capacity
== 0)
726 msg
->string
= d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE
);
727 if (msg
->string
== NULL
)
729 ERR("Error allocating memory for parser messages\n");
732 msg
->capacity
= MESSAGEBUFFER_INITIAL_SIZE
;
737 rc
= vsnprintf(msg
->string
+ msg
->size
,
738 msg
->capacity
- msg
->size
, fmt
, args
);
740 if (rc
< 0 || rc
>= msg
->capacity
- msg
->size
)
742 size
= msg
->capacity
* 2;
743 buffer
= d3dcompiler_realloc(msg
->string
, size
);
746 ERR("Error reallocating memory for parser messages\n");
749 msg
->string
= buffer
;
750 msg
->capacity
= size
;
754 TRACE("%s", msg
->string
+ msg
->size
);
761 #if D3D_COMPILER_VERSION
762 BOOL
add_declaration(struct hlsl_scope
*scope
, struct hlsl_ir_var
*decl
, BOOL local_var
)
764 struct hlsl_ir_var
*var
;
766 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
768 if (!strcmp(decl
->name
, var
->name
))
771 if (local_var
&& scope
->upper
->upper
== hlsl_ctx
.globals
)
773 /* Check whether the variable redefines a function parameter. */
774 LIST_FOR_EACH_ENTRY(var
, &scope
->upper
->vars
, struct hlsl_ir_var
, scope_entry
)
776 if (!strcmp(decl
->name
, var
->name
))
781 list_add_tail(&scope
->vars
, &decl
->scope_entry
);
785 struct hlsl_ir_var
*get_variable(struct hlsl_scope
*scope
, const char *name
)
787 struct hlsl_ir_var
*var
;
789 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
791 if (!strcmp(name
, var
->name
))
796 return get_variable(scope
->upper
, name
);
799 void free_declaration(struct hlsl_ir_var
*decl
)
801 d3dcompiler_free((void *)decl
->name
);
802 d3dcompiler_free((void *)decl
->semantic
);
803 d3dcompiler_free((void *)decl
->reg_reservation
);
804 d3dcompiler_free(decl
);
807 struct hlsl_type
*new_hlsl_type(const char *name
, enum hlsl_type_class type_class
,
808 enum hlsl_base_type base_type
, unsigned dimx
, unsigned dimy
)
810 struct hlsl_type
*type
;
812 type
= d3dcompiler_alloc(sizeof(*type
));
815 ERR("Out of memory\n");
819 type
->type
= type_class
;
820 type
->base_type
= base_type
;
824 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
829 struct hlsl_type
*new_array_type(struct hlsl_type
*basic_type
, unsigned int array_size
)
831 struct hlsl_type
*type
= new_hlsl_type(NULL
, HLSL_CLASS_ARRAY
, HLSL_TYPE_FLOAT
, 1, 1);
836 type
->modifiers
= basic_type
->modifiers
;
837 type
->e
.array
.elements_count
= array_size
;
838 type
->e
.array
.type
= basic_type
;
842 struct hlsl_type
*get_type(struct hlsl_scope
*scope
, const char *name
, BOOL recursive
)
844 struct wine_rb_entry
*entry
= wine_rb_get(&scope
->types
, name
);
846 return WINE_RB_ENTRY_VALUE(entry
, struct hlsl_type
, scope_entry
);
848 if (recursive
&& scope
->upper
)
849 return get_type(scope
->upper
, name
, recursive
);
853 BOOL
find_function(const char *name
)
855 return wine_rb_get(&hlsl_ctx
.functions
, name
) != NULL
;
858 unsigned int components_count_type(struct hlsl_type
*type
)
860 unsigned int count
= 0;
861 struct hlsl_struct_field
*field
;
863 if (type
->type
<= HLSL_CLASS_LAST_NUMERIC
)
865 return type
->dimx
* type
->dimy
;
867 if (type
->type
== HLSL_CLASS_ARRAY
)
869 return components_count_type(type
->e
.array
.type
) * type
->e
.array
.elements_count
;
871 if (type
->type
!= HLSL_CLASS_STRUCT
)
873 ERR("Unexpected data type %s.\n", debug_hlsl_type(type
));
877 LIST_FOR_EACH_ENTRY(field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
879 count
+= components_count_type(field
->type
);
884 BOOL
compare_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
889 if (t1
->type
!= t2
->type
)
891 if (t1
->base_type
!= t2
->base_type
)
893 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
895 if ((t1
->modifiers
& HLSL_MODIFIERS_COMPARISON_MASK
)
896 != (t2
->modifiers
& HLSL_MODIFIERS_COMPARISON_MASK
))
898 if (t1
->dimx
!= t2
->dimx
)
900 if (t1
->dimy
!= t2
->dimy
)
902 if (t1
->type
== HLSL_CLASS_STRUCT
)
904 struct list
*t1cur
, *t2cur
;
905 struct hlsl_struct_field
*t1field
, *t2field
;
907 t1cur
= list_head(t1
->e
.elements
);
908 t2cur
= list_head(t2
->e
.elements
);
909 while (t1cur
&& t2cur
)
911 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
912 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
913 if (!compare_hlsl_types(t1field
->type
, t2field
->type
))
915 if (strcmp(t1field
->name
, t2field
->name
))
917 t1cur
= list_next(t1
->e
.elements
, t1cur
);
918 t2cur
= list_next(t2
->e
.elements
, t2cur
);
923 if (t1
->type
== HLSL_CLASS_ARRAY
)
924 return t1
->e
.array
.elements_count
== t2
->e
.array
.elements_count
925 && compare_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
930 struct hlsl_type
*clone_hlsl_type(struct hlsl_type
*old
)
932 struct hlsl_type
*type
;
933 struct hlsl_struct_field
*old_field
, *field
;
935 type
= d3dcompiler_alloc(sizeof(*type
));
938 ERR("Out of memory\n");
943 type
->name
= d3dcompiler_strdup(old
->name
);
946 d3dcompiler_free(type
);
950 type
->type
= old
->type
;
951 type
->base_type
= old
->base_type
;
952 type
->dimx
= old
->dimx
;
953 type
->dimy
= old
->dimy
;
954 type
->modifiers
= old
->modifiers
;
955 type
->sampler_dim
= old
->sampler_dim
;
958 case HLSL_CLASS_ARRAY
:
959 type
->e
.array
.type
= old
->e
.array
.type
;
960 type
->e
.array
.elements_count
= old
->e
.array
.elements_count
;
962 case HLSL_CLASS_STRUCT
:
963 type
->e
.elements
= d3dcompiler_alloc(sizeof(*type
->e
.elements
));
964 if (!type
->e
.elements
)
966 d3dcompiler_free((void *)type
->name
);
967 d3dcompiler_free(type
);
970 list_init(type
->e
.elements
);
971 LIST_FOR_EACH_ENTRY(old_field
, old
->e
.elements
, struct hlsl_struct_field
, entry
)
973 field
= d3dcompiler_alloc(sizeof(*field
));
976 LIST_FOR_EACH_ENTRY_SAFE(field
, old_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
978 d3dcompiler_free((void *)field
->semantic
);
979 d3dcompiler_free((void *)field
->name
);
980 d3dcompiler_free(field
);
982 d3dcompiler_free(type
->e
.elements
);
983 d3dcompiler_free((void *)type
->name
);
984 d3dcompiler_free(type
);
987 field
->type
= clone_hlsl_type(old_field
->type
);
988 field
->name
= d3dcompiler_strdup(old_field
->name
);
989 if (old_field
->semantic
)
990 field
->semantic
= d3dcompiler_strdup(old_field
->semantic
);
991 field
->modifiers
= old_field
->modifiers
;
992 list_add_tail(type
->e
.elements
, &field
->entry
);
999 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
1003 static BOOL
convertible_data_type(struct hlsl_type
*type
)
1005 return type
->type
!= HLSL_CLASS_OBJECT
;
1008 BOOL
compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1010 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1013 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1015 /* Scalar vars can be cast to pretty much everything */
1016 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1019 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1020 return t1
->dimx
>= t2
->dimx
;
1023 /* The other way around is true too i.e. whatever to scalar */
1024 if (t2
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->dimx
== 1 && t2
->dimy
== 1)
1027 if (t1
->type
== HLSL_CLASS_ARRAY
)
1029 if (compare_hlsl_types(t1
->e
.array
.type
, t2
))
1030 /* e.g. float4[3] to float4 is allowed */
1033 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1034 return components_count_type(t1
) >= components_count_type(t2
);
1036 return components_count_type(t1
) == components_count_type(t2
);
1039 if (t1
->type
== HLSL_CLASS_STRUCT
)
1040 return components_count_type(t1
) >= components_count_type(t2
);
1042 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1043 return components_count_type(t1
) == components_count_type(t2
);
1045 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1047 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
&& t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1050 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1051 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1052 && components_count_type(t1
) == components_count_type(t2
))
1057 if (components_count_type(t1
) >= components_count_type(t2
))
1062 static BOOL
implicit_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1064 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1067 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1069 /* Scalar vars can be converted to any other numeric data type */
1070 if (t1
->dimx
== 1 && t1
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1072 /* The other way around is true too */
1073 if (t2
->dimx
== 1 && t2
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1077 if (t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
== HLSL_CLASS_ARRAY
)
1079 return components_count_type(t1
) == components_count_type(t2
);
1082 if ((t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1083 || (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->type
== HLSL_CLASS_ARRAY
))
1085 /* e.g. float4[3] to float4 is allowed */
1086 if (t1
->type
== HLSL_CLASS_ARRAY
&& compare_hlsl_types(t1
->e
.array
.type
, t2
))
1088 if (components_count_type(t1
) == components_count_type(t2
))
1093 if (t1
->type
<= HLSL_CLASS_VECTOR
&& t2
->type
<= HLSL_CLASS_VECTOR
)
1095 if (t1
->dimx
>= t2
->dimx
)
1100 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1102 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
1103 && t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1106 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1107 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1108 && components_count_type(t1
) == components_count_type(t2
))
1113 if (t1
->type
== HLSL_CLASS_STRUCT
&& t2
->type
== HLSL_CLASS_STRUCT
)
1114 return compare_hlsl_types(t1
, t2
);
1119 static BOOL
expr_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1121 if (t1
->base_type
> HLSL_TYPE_LAST_SCALAR
|| t2
->base_type
> HLSL_TYPE_LAST_SCALAR
)
1124 /* Scalar vars can be converted to pretty much everything */
1125 if ((t1
->dimx
== 1 && t1
->dimy
== 1) || (t2
->dimx
== 1 && t2
->dimy
== 1))
1128 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1131 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1133 /* Matrix-vector conversion is apparently allowed if either they have the same components
1134 count or the matrix is nx1 or 1xn */
1135 if (t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1137 if (components_count_type(t1
) == components_count_type(t2
))
1140 return (t1
->type
== HLSL_CLASS_MATRIX
&& (t1
->dimx
== 1 || t1
->dimy
== 1))
1141 || (t2
->type
== HLSL_CLASS_MATRIX
&& (t2
->dimx
== 1 || t2
->dimy
== 1));
1145 if ((t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1146 || (t1
->dimx
<= t2
->dimx
&& t1
->dimy
<= t2
->dimy
))
1153 static enum hlsl_base_type
expr_common_base_type(enum hlsl_base_type t1
, enum hlsl_base_type t2
)
1155 static const enum hlsl_base_type types
[] =
1164 int t1_idx
= -1, t2_idx
= -1, i
;
1166 for (i
= 0; i
< ARRAY_SIZE(types
); ++i
)
1168 /* Always convert away from HLSL_TYPE_HALF */
1170 t1_idx
= t1
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1172 t2_idx
= t2
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1174 if (t1_idx
!= -1 && t2_idx
!= -1)
1177 if (t1_idx
== -1 || t2_idx
== -1)
1179 FIXME("Unexpected base type.\n");
1180 return HLSL_TYPE_FLOAT
;
1182 return t1_idx
>= t2_idx
? t1
: t2
;
1185 static struct hlsl_type
*expr_common_type(struct hlsl_type
*t1
, struct hlsl_type
*t2
,
1186 struct source_location
*loc
)
1188 enum hlsl_type_class type
;
1189 enum hlsl_base_type base
;
1190 unsigned int dimx
, dimy
;
1192 if (t1
->type
> HLSL_CLASS_LAST_NUMERIC
|| t2
->type
> HLSL_CLASS_LAST_NUMERIC
)
1194 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1195 "non scalar/vector/matrix data type in expression");
1199 if (compare_hlsl_types(t1
, t2
))
1202 if (!expr_compatible_data_types(t1
, t2
))
1204 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1205 "expression data types are incompatible");
1209 if (t1
->base_type
== t2
->base_type
)
1210 base
= t1
->base_type
;
1212 base
= expr_common_base_type(t1
->base_type
, t2
->base_type
);
1214 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1220 else if (t2
->dimx
== 1 && t2
->dimy
== 1)
1226 else if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
)
1228 type
= HLSL_CLASS_MATRIX
;
1229 dimx
= min(t1
->dimx
, t2
->dimx
);
1230 dimy
= min(t1
->dimy
, t2
->dimy
);
1234 /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1235 unsigned int max_dim_1
, max_dim_2
;
1237 max_dim_1
= max(t1
->dimx
, t1
->dimy
);
1238 max_dim_2
= max(t2
->dimx
, t2
->dimy
);
1239 if (t1
->dimx
* t1
->dimy
== t2
->dimx
* t2
->dimy
)
1241 type
= HLSL_CLASS_VECTOR
;
1242 dimx
= max(t1
->dimx
, t2
->dimx
);
1245 else if (max_dim_1
<= max_dim_2
)
1248 if (type
== HLSL_CLASS_VECTOR
)
1262 if (type
== HLSL_CLASS_VECTOR
)
1275 return new_hlsl_type(NULL
, type
, base
, dimx
, dimy
);
1278 static struct hlsl_ir_node
*implicit_conversion(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1279 struct source_location
*loc
)
1281 if (compare_hlsl_types(node
->data_type
, type
))
1283 TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type
));
1284 return &new_cast(node
, type
, loc
)->node
;
1287 struct hlsl_ir_expr
*new_expr(enum hlsl_ir_expr_op op
, struct hlsl_ir_node
**operands
,
1288 struct source_location
*loc
)
1290 struct hlsl_ir_expr
*expr
= d3dcompiler_alloc(sizeof(*expr
));
1291 struct hlsl_type
*type
;
1296 ERR("Out of memory\n");
1299 expr
->node
.type
= HLSL_IR_EXPR
;
1300 expr
->node
.loc
= *loc
;
1301 type
= operands
[0]->data_type
;
1302 for (i
= 1; i
<= 2; ++i
)
1306 type
= expr_common_type(type
, operands
[i
]->data_type
, loc
);
1309 d3dcompiler_free(expr
);
1313 for (i
= 0; i
<= 2; ++i
)
1317 if (compare_hlsl_types(operands
[i
]->data_type
, type
))
1319 TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands
[i
]->data_type
), debug_hlsl_type(type
));
1320 if (operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= 1
1321 && operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= type
->dimx
* type
->dimy
)
1323 hlsl_report_message(operands
[i
]->loc
.file
,
1324 operands
[i
]->loc
.line
, operands
[i
]->loc
.col
, HLSL_LEVEL_WARNING
,
1325 "implicit truncation of vector/matrix type");
1327 operands
[i
] = implicit_conversion(operands
[i
], type
, &operands
[i
]->loc
);
1330 ERR("Impossible to convert expression operand %u to %s\n", i
+ 1, debug_hlsl_type(type
));
1331 d3dcompiler_free(expr
);
1335 expr
->node
.data_type
= type
;
1337 expr
->operands
[0] = operands
[0];
1338 expr
->operands
[1] = operands
[1];
1339 expr
->operands
[2] = operands
[2];
1344 struct hlsl_ir_expr
*new_cast(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1345 struct source_location
*loc
)
1347 struct hlsl_ir_node
*cast
;
1349 cast
= new_unary_expr(HLSL_IR_UNOP_CAST
, node
, *loc
);
1351 cast
->data_type
= type
;
1352 return expr_from_node(cast
);
1355 struct hlsl_ir_deref
*new_var_deref(struct hlsl_ir_var
*var
)
1357 struct hlsl_ir_deref
*deref
= d3dcompiler_alloc(sizeof(*deref
));
1361 ERR("Out of memory.\n");
1364 deref
->node
.type
= HLSL_IR_DEREF
;
1365 deref
->node
.data_type
= var
->data_type
;
1366 deref
->type
= HLSL_IR_DEREF_VAR
;
1371 struct hlsl_ir_deref
*new_record_deref(struct hlsl_ir_node
*record
, struct hlsl_struct_field
*field
)
1373 struct hlsl_ir_deref
*deref
= d3dcompiler_alloc(sizeof(*deref
));
1377 ERR("Out of memory.\n");
1380 deref
->node
.type
= HLSL_IR_DEREF
;
1381 deref
->node
.data_type
= field
->type
;
1382 deref
->type
= HLSL_IR_DEREF_RECORD
;
1383 deref
->v
.record
.record
= record
;
1384 deref
->v
.record
.field
= field
;
1388 static enum hlsl_ir_expr_op
op_from_assignment(enum parse_assign_op op
)
1390 static const enum hlsl_ir_expr_op ops
[] =
1398 HLSL_IR_BINOP_LSHIFT
,
1399 HLSL_IR_BINOP_RSHIFT
,
1400 HLSL_IR_BINOP_BIT_AND
,
1401 HLSL_IR_BINOP_BIT_OR
,
1402 HLSL_IR_BINOP_BIT_XOR
,
1408 struct hlsl_ir_node
*make_assignment(struct hlsl_ir_node
*left
, enum parse_assign_op assign_op
,
1409 DWORD writemask
, struct hlsl_ir_node
*right
)
1411 struct hlsl_ir_assignment
*assign
= d3dcompiler_alloc(sizeof(*assign
));
1412 struct hlsl_type
*type
;
1413 struct hlsl_ir_node
*lhs
, *rhs
;
1417 ERR("Out of memory\n");
1421 TRACE("Creating proper assignment expression.\n");
1423 if (writemask
== BWRITERSP_WRITEMASK_ALL
)
1424 type
= left
->data_type
;
1427 unsigned int dimx
= 0;
1429 enum hlsl_type_class type_class
;
1431 if (left
->data_type
->type
> HLSL_CLASS_LAST_NUMERIC
)
1433 hlsl_report_message(left
->loc
.file
, left
->loc
.line
, left
->loc
.col
, HLSL_LEVEL_ERROR
,
1434 "writemask on a non scalar/vector/matrix type");
1435 d3dcompiler_free(assign
);
1438 bitmask
= writemask
& ((1 << left
->data_type
->dimx
) - 1);
1445 if (left
->data_type
->type
== HLSL_CLASS_MATRIX
)
1446 FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
1448 type_class
= HLSL_CLASS_SCALAR
;
1450 type_class
= left
->data_type
->type
;
1451 type
= new_hlsl_type(NULL
, type_class
, left
->data_type
->base_type
, dimx
, 1);
1453 assign
->node
.type
= HLSL_IR_ASSIGNMENT
;
1454 assign
->node
.loc
= left
->loc
;
1455 assign
->node
.data_type
= type
;
1456 assign
->writemask
= writemask
;
1457 FIXME("Check for casts in the lhs.\n");
1460 /* FIXME: check for invalid writemasks on the lhs. */
1462 if (!compare_hlsl_types(type
, rhs
->data_type
))
1464 struct hlsl_ir_node
*converted_rhs
;
1466 if (!implicit_compatible_data_types(rhs
->data_type
, type
))
1468 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_ERROR
,
1469 "can't implicitly convert %s to %s",
1470 debug_hlsl_type(rhs
->data_type
), debug_hlsl_type(type
));
1473 d3dcompiler_free(assign
);
1476 if (lhs
->data_type
->dimx
* lhs
->data_type
->dimy
< rhs
->data_type
->dimx
* rhs
->data_type
->dimy
)
1477 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_WARNING
,
1478 "implicit truncation of vector type");
1480 converted_rhs
= implicit_conversion(rhs
, type
, &rhs
->loc
);
1483 ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type
));
1486 d3dcompiler_free(assign
);
1489 rhs
= converted_rhs
;
1493 if (assign_op
!= ASSIGN_OP_ASSIGN
)
1495 enum hlsl_ir_expr_op op
= op_from_assignment(assign_op
);
1496 struct hlsl_ir_node
*expr
;
1498 if (lhs
->type
!= HLSL_IR_DEREF
|| deref_from_node(lhs
)->type
!= HLSL_IR_DEREF_VAR
)
1500 FIXME("LHS expression not supported in compound assignments yet.\n");
1505 struct hlsl_ir_deref
*lhs_deref
= deref_from_node(lhs
), *new_deref
;
1507 TRACE("Adding an expression for the compound assignment.\n");
1508 new_deref
= new_var_deref(lhs_deref
->v
.var
);
1509 expr
= new_binary_expr(op
, &new_deref
->node
, rhs
, left
->loc
);
1516 return &assign
->node
;
1519 static int compare_hlsl_types_rb(const void *key
, const struct wine_rb_entry
*entry
)
1521 const char *name
= key
;
1522 const struct hlsl_type
*type
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_type
, scope_entry
);
1524 if (name
== type
->name
)
1527 if (!name
|| !type
->name
)
1529 ERR("hlsl_type without a name in a scope?\n");
1532 return strcmp(name
, type
->name
);
1535 void push_scope(struct hlsl_parse_ctx
*ctx
)
1537 struct hlsl_scope
*new_scope
= d3dcompiler_alloc(sizeof(*new_scope
));
1541 ERR("Out of memory!\n");
1544 TRACE("Pushing a new scope\n");
1545 list_init(&new_scope
->vars
);
1546 wine_rb_init(&new_scope
->types
, compare_hlsl_types_rb
);
1547 new_scope
->upper
= ctx
->cur_scope
;
1548 ctx
->cur_scope
= new_scope
;
1549 list_add_tail(&ctx
->scopes
, &new_scope
->entry
);
1552 BOOL
pop_scope(struct hlsl_parse_ctx
*ctx
)
1554 struct hlsl_scope
*prev_scope
= ctx
->cur_scope
->upper
;
1558 TRACE("Popping current scope\n");
1559 ctx
->cur_scope
= prev_scope
;
1563 struct hlsl_ir_function_decl
*new_func_decl(struct hlsl_type
*return_type
, struct list
*parameters
)
1565 struct hlsl_ir_function_decl
*decl
;
1567 decl
= d3dcompiler_alloc(sizeof(*decl
));
1570 ERR("Out of memory.\n");
1573 decl
->return_type
= return_type
;
1574 decl
->parameters
= parameters
;
1579 static int compare_param_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
1581 if (t1
->type
!= t2
->type
)
1583 if (!((t1
->type
== HLSL_CLASS_SCALAR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1584 || (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_SCALAR
)))
1585 return t1
->type
- t2
->type
;
1587 if (t1
->base_type
!= t2
->base_type
)
1588 return t1
->base_type
- t2
->base_type
;
1589 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
1590 return t1
->sampler_dim
- t2
->sampler_dim
;
1591 if (t1
->dimx
!= t2
->dimx
)
1592 return t1
->dimx
- t2
->dimx
;
1593 if (t1
->dimy
!= t2
->dimy
)
1594 return t1
->dimx
- t2
->dimx
;
1595 if (t1
->type
== HLSL_CLASS_STRUCT
)
1597 struct list
*t1cur
, *t2cur
;
1598 struct hlsl_struct_field
*t1field
, *t2field
;
1601 t1cur
= list_head(t1
->e
.elements
);
1602 t2cur
= list_head(t2
->e
.elements
);
1603 while (t1cur
&& t2cur
)
1605 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
1606 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
1607 if ((r
= compare_param_hlsl_types(t1field
->type
, t2field
->type
)))
1609 if ((r
= strcmp(t1field
->name
, t2field
->name
)))
1611 t1cur
= list_next(t1
->e
.elements
, t1cur
);
1612 t2cur
= list_next(t2
->e
.elements
, t2cur
);
1615 return t1cur
? 1 : -1;
1618 if (t1
->type
== HLSL_CLASS_ARRAY
)
1620 if (t1
->e
.array
.elements_count
!= t2
->e
.array
.elements_count
)
1621 return t1
->e
.array
.elements_count
- t2
->e
.array
.elements_count
;
1622 return compare_param_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
1628 static int compare_function_decl_rb(const void *key
, const struct wine_rb_entry
*entry
)
1630 const struct list
*params
= key
;
1631 const struct hlsl_ir_function_decl
*decl
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_ir_function_decl
, entry
);
1632 int params_count
= params
? list_count(params
) : 0;
1633 int decl_params_count
= decl
->parameters
? list_count(decl
->parameters
) : 0;
1635 struct list
*p1cur
, *p2cur
;
1637 if (params_count
!= decl_params_count
)
1638 return params_count
- decl_params_count
;
1640 p1cur
= params
? list_head(params
) : NULL
;
1641 p2cur
= decl
->parameters
? list_head(decl
->parameters
) : NULL
;
1642 while (p1cur
&& p2cur
)
1644 struct hlsl_ir_var
*p1
, *p2
;
1645 p1
= LIST_ENTRY(p1cur
, struct hlsl_ir_var
, param_entry
);
1646 p2
= LIST_ENTRY(p2cur
, struct hlsl_ir_var
, param_entry
);
1647 if ((r
= compare_param_hlsl_types(p1
->data_type
, p2
->data_type
)))
1649 p1cur
= list_next(params
, p1cur
);
1650 p2cur
= list_next(decl
->parameters
, p2cur
);
1655 static int compare_function_rb(const void *key
, const struct wine_rb_entry
*entry
)
1657 const char *name
= key
;
1658 const struct hlsl_ir_function
*func
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_ir_function
,entry
);
1660 return strcmp(name
, func
->name
);
1663 void init_functions_tree(struct wine_rb_tree
*funcs
)
1665 wine_rb_init(&hlsl_ctx
.functions
, compare_function_rb
);
1668 static const char *debug_base_type(const struct hlsl_type
*type
)
1670 const char *name
= "(unknown)";
1672 switch (type
->base_type
)
1674 case HLSL_TYPE_FLOAT
: name
= "float"; break;
1675 case HLSL_TYPE_HALF
: name
= "half"; break;
1676 case HLSL_TYPE_DOUBLE
: name
= "double"; break;
1677 case HLSL_TYPE_INT
: name
= "int"; break;
1678 case HLSL_TYPE_UINT
: name
= "uint"; break;
1679 case HLSL_TYPE_BOOL
: name
= "bool"; break;
1680 case HLSL_TYPE_SAMPLER
:
1681 switch (type
->sampler_dim
)
1683 case HLSL_SAMPLER_DIM_GENERIC
: name
= "sampler"; break;
1684 case HLSL_SAMPLER_DIM_1D
: name
= "sampler1D"; break;
1685 case HLSL_SAMPLER_DIM_2D
: name
= "sampler2D"; break;
1686 case HLSL_SAMPLER_DIM_3D
: name
= "sampler3D"; break;
1687 case HLSL_SAMPLER_DIM_CUBE
: name
= "samplerCUBE"; break;
1691 FIXME("Unhandled case %u\n", type
->base_type
);
1696 const char *debug_hlsl_type(const struct hlsl_type
*type
)
1701 return debugstr_a(type
->name
);
1703 if (type
->type
== HLSL_CLASS_STRUCT
)
1704 return "<anonymous struct>";
1706 if (type
->type
== HLSL_CLASS_ARRAY
)
1708 name
= debug_base_type(type
->e
.array
.type
);
1709 return wine_dbg_sprintf("%s[%u]", name
, type
->e
.array
.elements_count
);
1712 name
= debug_base_type(type
);
1714 if (type
->type
== HLSL_CLASS_SCALAR
)
1715 return wine_dbg_sprintf("%s", name
);
1716 if (type
->type
== HLSL_CLASS_VECTOR
)
1717 return wine_dbg_sprintf("%s%u", name
, type
->dimx
);
1718 if (type
->type
== HLSL_CLASS_MATRIX
)
1719 return wine_dbg_sprintf("%s%ux%u", name
, type
->dimx
, type
->dimy
);
1720 return "unexpected_type";
1723 const char *debug_modifiers(DWORD modifiers
)
1728 if (modifiers
& HLSL_STORAGE_EXTERN
)
1729 strcat(string
, " extern"); /* 7 */
1730 if (modifiers
& HLSL_STORAGE_NOINTERPOLATION
)
1731 strcat(string
, " nointerpolation"); /* 16 */
1732 if (modifiers
& HLSL_MODIFIER_PRECISE
)
1733 strcat(string
, " precise"); /* 8 */
1734 if (modifiers
& HLSL_STORAGE_SHARED
)
1735 strcat(string
, " shared"); /* 7 */
1736 if (modifiers
& HLSL_STORAGE_GROUPSHARED
)
1737 strcat(string
, " groupshared"); /* 12 */
1738 if (modifiers
& HLSL_STORAGE_STATIC
)
1739 strcat(string
, " static"); /* 7 */
1740 if (modifiers
& HLSL_STORAGE_UNIFORM
)
1741 strcat(string
, " uniform"); /* 8 */
1742 if (modifiers
& HLSL_STORAGE_VOLATILE
)
1743 strcat(string
, " volatile"); /* 9 */
1744 if (modifiers
& HLSL_MODIFIER_CONST
)
1745 strcat(string
, " const"); /* 6 */
1746 if (modifiers
& HLSL_MODIFIER_ROW_MAJOR
)
1747 strcat(string
, " row_major"); /* 10 */
1748 if (modifiers
& HLSL_MODIFIER_COLUMN_MAJOR
)
1749 strcat(string
, " column_major"); /* 13 */
1750 if ((modifiers
& (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
)) == (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
))
1751 strcat(string
, " inout"); /* 6 */
1752 else if (modifiers
& HLSL_MODIFIER_IN
)
1753 strcat(string
, " in"); /* 3 */
1754 else if (modifiers
& HLSL_MODIFIER_OUT
)
1755 strcat(string
, " out"); /* 4 */
1757 return wine_dbg_sprintf("%s", string
[0] ? string
+ 1 : "");
1760 static const char *debug_node_type(enum hlsl_ir_node_type type
)
1762 static const char * const names
[] =
1764 "HLSL_IR_ASSIGNMENT",
1766 "HLSL_IR_CONSTRUCTOR",
1774 if (type
>= ARRAY_SIZE(names
))
1775 return "Unexpected node type";
1779 static void debug_dump_instr(const struct hlsl_ir_node
*instr
);
1781 static void debug_dump_instr_list(const struct list
*list
)
1783 struct hlsl_ir_node
*instr
;
1785 LIST_FOR_EACH_ENTRY(instr
, list
, struct hlsl_ir_node
, entry
)
1787 debug_dump_instr(instr
);
1792 static void debug_dump_ir_var(const struct hlsl_ir_var
*var
)
1795 TRACE("%s ", debug_modifiers(var
->modifiers
));
1796 TRACE("%s %s", debug_hlsl_type(var
->data_type
), var
->name
);
1798 TRACE(" : %s", debugstr_a(var
->semantic
));
1801 static void debug_dump_ir_deref(const struct hlsl_ir_deref
*deref
)
1803 switch (deref
->type
)
1805 case HLSL_IR_DEREF_VAR
:
1807 debug_dump_ir_var(deref
->v
.var
);
1810 case HLSL_IR_DEREF_ARRAY
:
1811 debug_dump_instr(deref
->v
.array
.array
);
1813 debug_dump_instr(deref
->v
.array
.index
);
1816 case HLSL_IR_DEREF_RECORD
:
1817 debug_dump_instr(deref
->v
.record
.record
);
1818 TRACE(".%s", debugstr_a(deref
->v
.record
.field
->name
));
1823 static void debug_dump_ir_constant(const struct hlsl_ir_constant
*constant
)
1825 struct hlsl_type
*type
= constant
->node
.data_type
;
1828 if (type
->dimy
!= 1)
1830 for (y
= 0; y
< type
->dimy
; ++y
)
1832 if (type
->dimx
!= 1)
1834 for (x
= 0; x
< type
->dimx
; ++x
)
1836 switch (type
->base_type
)
1838 case HLSL_TYPE_FLOAT
:
1839 TRACE("%g ", (double)constant
->v
.value
.f
[y
* type
->dimx
+ x
]);
1841 case HLSL_TYPE_DOUBLE
:
1842 TRACE("%g ", constant
->v
.value
.d
[y
* type
->dimx
+ x
]);
1845 TRACE("%d ", constant
->v
.value
.i
[y
* type
->dimx
+ x
]);
1847 case HLSL_TYPE_UINT
:
1848 TRACE("%u ", constant
->v
.value
.u
[y
* type
->dimx
+ x
]);
1850 case HLSL_TYPE_BOOL
:
1851 TRACE("%s ", constant
->v
.value
.b
[y
* type
->dimx
+ x
] == FALSE
? "false" : "true");
1854 TRACE("Constants of type %s not supported\n", debug_base_type(type
));
1857 if (type
->dimx
!= 1)
1860 if (type
->dimy
!= 1)
1864 static const char *debug_expr_op(const struct hlsl_ir_expr
*expr
)
1866 static const char * const op_names
[] =
1934 if (expr
->op
== HLSL_IR_UNOP_CAST
)
1935 return debug_hlsl_type(expr
->node
.data_type
);
1937 return op_names
[expr
->op
];
1940 /* Dumps the expression in a prefix "operator (operands)" form */
1941 static void debug_dump_ir_expr(const struct hlsl_ir_expr
*expr
)
1945 TRACE("%s (", debug_expr_op(expr
));
1946 for (i
= 0; i
< 3 && expr
->operands
[i
]; ++i
)
1948 debug_dump_instr(expr
->operands
[i
]);
1954 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor
*constructor
)
1958 TRACE("%s (", debug_hlsl_type(constructor
->node
.data_type
));
1959 for (i
= 0; i
< constructor
->args_count
; ++i
)
1961 debug_dump_instr(constructor
->args
[i
]);
1967 static const char *debug_writemask(DWORD writemask
)
1969 static const char components
[] = {'x', 'y', 'z', 'w'};
1971 unsigned int i
= 0, pos
= 0;
1973 assert(!(writemask
& ~BWRITERSP_WRITEMASK_ALL
));
1978 string
[pos
++] = components
[i
];
1983 return wine_dbg_sprintf(".%s", string
);
1986 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment
*assign
)
1989 debug_dump_instr(assign
->lhs
);
1990 if (assign
->writemask
!= BWRITERSP_WRITEMASK_ALL
)
1991 TRACE("%s", debug_writemask(assign
->writemask
));
1993 debug_dump_instr(assign
->rhs
);
1997 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle
*swizzle
)
2001 debug_dump_instr(swizzle
->val
);
2003 if (swizzle
->val
->data_type
->dimy
> 1)
2005 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
2006 TRACE("_m%u%u", (swizzle
->swizzle
>> i
* 8) & 0xf, (swizzle
->swizzle
>> (i
* 8 + 4)) & 0xf);
2010 static const char c
[] = {'x', 'y', 'z', 'w'};
2012 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
2013 TRACE("%c", c
[(swizzle
->swizzle
>> i
* 2) & 0x3]);
2017 static void debug_dump_ir_jump(const struct hlsl_ir_jump
*jump
)
2021 case HLSL_IR_JUMP_BREAK
:
2024 case HLSL_IR_JUMP_CONTINUE
:
2027 case HLSL_IR_JUMP_DISCARD
:
2030 case HLSL_IR_JUMP_RETURN
:
2032 if (jump
->return_value
)
2033 debug_dump_instr(jump
->return_value
);
2039 static void debug_dump_ir_if(const struct hlsl_ir_if
*if_node
)
2042 debug_dump_instr(if_node
->condition
);
2044 debug_dump_instr_list(if_node
->then_instrs
);
2046 if (if_node
->else_instrs
)
2049 debug_dump_instr_list(if_node
->else_instrs
);
2054 static void debug_dump_instr(const struct hlsl_ir_node
*instr
)
2056 switch (instr
->type
)
2059 debug_dump_ir_expr(expr_from_node(instr
));
2062 debug_dump_ir_deref(deref_from_node(instr
));
2064 case HLSL_IR_CONSTANT
:
2065 debug_dump_ir_constant(constant_from_node(instr
));
2067 case HLSL_IR_ASSIGNMENT
:
2068 debug_dump_ir_assignment(assignment_from_node(instr
));
2070 case HLSL_IR_SWIZZLE
:
2071 debug_dump_ir_swizzle(swizzle_from_node(instr
));
2073 case HLSL_IR_CONSTRUCTOR
:
2074 debug_dump_ir_constructor(constructor_from_node(instr
));
2077 debug_dump_ir_jump(jump_from_node(instr
));
2080 debug_dump_ir_if(if_from_node(instr
));
2083 TRACE("<No dump function for %s>", debug_node_type(instr
->type
));
2087 void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl
*func
)
2089 struct hlsl_ir_var
*param
;
2091 TRACE("Dumping function %s.\n", debugstr_a(func
->func
->name
));
2092 TRACE("Function parameters:\n");
2093 LIST_FOR_EACH_ENTRY(param
, func
->parameters
, struct hlsl_ir_var
, param_entry
)
2095 debug_dump_ir_var(param
);
2099 TRACE("Function semantic: %s\n", debugstr_a(func
->semantic
));
2102 debug_dump_instr_list(func
->body
);
2106 void free_hlsl_type(struct hlsl_type
*type
)
2108 struct hlsl_struct_field
*field
, *next_field
;
2110 d3dcompiler_free((void *)type
->name
);
2111 if (type
->type
== HLSL_CLASS_STRUCT
)
2113 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
2115 d3dcompiler_free((void *)field
->name
);
2116 d3dcompiler_free((void *)field
->semantic
);
2117 d3dcompiler_free(field
);
2120 d3dcompiler_free(type
);
2123 void free_instr_list(struct list
*list
)
2125 struct hlsl_ir_node
*node
, *next_node
;
2129 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, list
, struct hlsl_ir_node
, entry
)
2131 d3dcompiler_free(list
);
2134 static void free_ir_constant(struct hlsl_ir_constant
*constant
)
2136 struct hlsl_type
*type
= constant
->node
.data_type
;
2138 struct hlsl_ir_constant
*field
, *next_field
;
2142 case HLSL_CLASS_ARRAY
:
2143 for (i
= 0; i
< type
->e
.array
.elements_count
; ++i
)
2144 free_ir_constant(&constant
->v
.array_elements
[i
]);
2145 d3dcompiler_free(constant
->v
.array_elements
);
2147 case HLSL_CLASS_STRUCT
:
2148 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, constant
->v
.struct_elements
, struct hlsl_ir_constant
, node
.entry
)
2149 free_ir_constant(field
);
2154 d3dcompiler_free(constant
);
2157 static void free_ir_deref(struct hlsl_ir_deref
*deref
)
2159 switch (deref
->type
)
2161 case HLSL_IR_DEREF_VAR
:
2162 /* Variables are shared among nodes in the tree. */
2164 case HLSL_IR_DEREF_ARRAY
:
2165 free_instr(deref
->v
.array
.array
);
2166 free_instr(deref
->v
.array
.index
);
2168 case HLSL_IR_DEREF_RECORD
:
2169 free_instr(deref
->v
.record
.record
);
2172 d3dcompiler_free(deref
);
2175 static void free_ir_swizzle(struct hlsl_ir_swizzle
*swizzle
)
2177 free_instr(swizzle
->val
);
2178 d3dcompiler_free(swizzle
);
2181 static void free_ir_constructor(struct hlsl_ir_constructor
*constructor
)
2184 for (i
= 0; i
< constructor
->args_count
; ++i
)
2185 free_instr(constructor
->args
[i
]);
2186 d3dcompiler_free(constructor
);
2189 static void free_ir_expr(struct hlsl_ir_expr
*expr
)
2193 for (i
= 0; i
< 3; ++i
)
2195 if (!expr
->operands
[i
])
2197 free_instr(expr
->operands
[i
]);
2199 free_instr_list(expr
->subexpressions
);
2200 d3dcompiler_free(expr
);
2203 static void free_ir_assignment(struct hlsl_ir_assignment
*assignment
)
2205 free_instr(assignment
->lhs
);
2206 free_instr(assignment
->rhs
);
2207 d3dcompiler_free(assignment
);
2210 static void free_ir_if(struct hlsl_ir_if
*if_node
)
2212 free_instr(if_node
->condition
);
2213 free_instr_list(if_node
->then_instrs
);
2214 free_instr_list(if_node
->else_instrs
);
2215 d3dcompiler_free(if_node
);
2218 static void free_ir_jump(struct hlsl_ir_jump
*jump
)
2220 if (jump
->type
== HLSL_IR_JUMP_RETURN
)
2221 free_instr(jump
->return_value
);
2222 d3dcompiler_free(jump
);
2225 void free_instr(struct hlsl_ir_node
*node
)
2229 case HLSL_IR_CONSTANT
:
2230 free_ir_constant(constant_from_node(node
));
2233 free_ir_deref(deref_from_node(node
));
2235 case HLSL_IR_SWIZZLE
:
2236 free_ir_swizzle(swizzle_from_node(node
));
2238 case HLSL_IR_CONSTRUCTOR
:
2239 free_ir_constructor(constructor_from_node(node
));
2242 free_ir_expr(expr_from_node(node
));
2244 case HLSL_IR_ASSIGNMENT
:
2245 free_ir_assignment(assignment_from_node(node
));
2248 free_ir_if(if_from_node(node
));
2251 free_ir_jump(jump_from_node(node
));
2254 FIXME("Unsupported node type %s\n", debug_node_type(node
->type
));
2258 static void free_function_decl(struct hlsl_ir_function_decl
*decl
)
2260 d3dcompiler_free((void *)decl
->semantic
);
2261 d3dcompiler_free(decl
->parameters
);
2262 free_instr_list(decl
->body
);
2263 d3dcompiler_free(decl
);
2266 static void free_function_decl_rb(struct wine_rb_entry
*entry
, void *context
)
2268 free_function_decl(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function_decl
, entry
));
2271 static void free_function(struct hlsl_ir_function
*func
)
2273 wine_rb_destroy(&func
->overloads
, free_function_decl_rb
, NULL
);
2274 d3dcompiler_free((void *)func
->name
);
2275 d3dcompiler_free(func
);
2278 void free_function_rb(struct wine_rb_entry
*entry
, void *context
)
2280 free_function(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function
, entry
));
2283 void add_function_decl(struct wine_rb_tree
*funcs
, char *name
, struct hlsl_ir_function_decl
*decl
, BOOL intrinsic
)
2285 struct hlsl_ir_function
*func
;
2286 struct wine_rb_entry
*func_entry
, *old_entry
;
2288 func_entry
= wine_rb_get(funcs
, name
);
2291 func
= WINE_RB_ENTRY_VALUE(func_entry
, struct hlsl_ir_function
, entry
);
2292 if (intrinsic
!= func
->intrinsic
)
2296 ERR("Redeclaring a user defined function as an intrinsic.\n");
2299 TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name
));
2300 func
->intrinsic
= intrinsic
;
2301 wine_rb_destroy(&func
->overloads
, free_function_decl_rb
, NULL
);
2302 wine_rb_init(&func
->overloads
, compare_function_decl_rb
);
2305 if ((old_entry
= wine_rb_get(&func
->overloads
, decl
->parameters
)))
2307 struct hlsl_ir_function_decl
*old_decl
=
2308 WINE_RB_ENTRY_VALUE(old_entry
, struct hlsl_ir_function_decl
, entry
);
2312 free_function_decl(decl
);
2313 d3dcompiler_free(name
);
2316 wine_rb_remove(&func
->overloads
, old_entry
);
2317 free_function_decl(old_decl
);
2319 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2320 d3dcompiler_free(name
);
2323 func
= d3dcompiler_alloc(sizeof(*func
));
2325 wine_rb_init(&func
->overloads
, compare_function_decl_rb
);
2327 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2328 func
->intrinsic
= intrinsic
;
2329 wine_rb_put(funcs
, func
->name
, &func
->entry
);