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
& 3;
295 swizzle
[1] = (arg
>> 2) & 3;
296 swizzle
[2] = (arg
>> 4) & 3;
297 swizzle
[3] = (arg
>> 6) & 3;
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 tag
= read_dword(&ptr
);
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 total_size
= read_dword(&ptr
);
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 chunk_count
= read_dword(&ptr
);
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 chunk_offset
= read_dword(&ptr
);
630 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
632 chunk_ptr
= data
+ chunk_offset
;
634 chunk_tag
= read_dword(&chunk_ptr
);
635 chunk_size
= read_dword(&chunk_ptr
);
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
;
823 if (type_class
== HLSL_CLASS_MATRIX
)
824 type
->reg_size
= is_row_major(type
) ? dimy
: dimx
;
828 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
833 struct hlsl_type
*new_array_type(struct hlsl_type
*basic_type
, unsigned int array_size
)
835 struct hlsl_type
*type
= new_hlsl_type(NULL
, HLSL_CLASS_ARRAY
, HLSL_TYPE_FLOAT
, 1, 1);
840 type
->modifiers
= basic_type
->modifiers
;
841 type
->e
.array
.elements_count
= array_size
;
842 type
->e
.array
.type
= basic_type
;
843 type
->reg_size
= basic_type
->reg_size
* array_size
;
844 type
->dimx
= basic_type
->dimx
;
845 type
->dimy
= basic_type
->dimy
;
849 struct hlsl_type
*get_type(struct hlsl_scope
*scope
, const char *name
, BOOL recursive
)
851 struct wine_rb_entry
*entry
= wine_rb_get(&scope
->types
, name
);
853 return WINE_RB_ENTRY_VALUE(entry
, struct hlsl_type
, scope_entry
);
855 if (recursive
&& scope
->upper
)
856 return get_type(scope
->upper
, name
, recursive
);
860 BOOL
find_function(const char *name
)
862 return wine_rb_get(&hlsl_ctx
.functions
, name
) != NULL
;
865 unsigned int components_count_type(struct hlsl_type
*type
)
867 unsigned int count
= 0;
868 struct hlsl_struct_field
*field
;
870 if (type
->type
<= HLSL_CLASS_LAST_NUMERIC
)
872 return type
->dimx
* type
->dimy
;
874 if (type
->type
== HLSL_CLASS_ARRAY
)
876 return components_count_type(type
->e
.array
.type
) * type
->e
.array
.elements_count
;
878 if (type
->type
!= HLSL_CLASS_STRUCT
)
880 ERR("Unexpected data type %s.\n", debug_hlsl_type(type
));
884 LIST_FOR_EACH_ENTRY(field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
886 count
+= components_count_type(field
->type
);
891 BOOL
compare_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
896 if (t1
->type
!= t2
->type
)
898 if (t1
->base_type
!= t2
->base_type
)
900 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
902 if ((t1
->modifiers
& HLSL_MODIFIERS_MAJORITY_MASK
)
903 != (t2
->modifiers
& HLSL_MODIFIERS_MAJORITY_MASK
))
905 if (t1
->dimx
!= t2
->dimx
)
907 if (t1
->dimy
!= t2
->dimy
)
909 if (t1
->type
== HLSL_CLASS_STRUCT
)
911 struct list
*t1cur
, *t2cur
;
912 struct hlsl_struct_field
*t1field
, *t2field
;
914 t1cur
= list_head(t1
->e
.elements
);
915 t2cur
= list_head(t2
->e
.elements
);
916 while (t1cur
&& t2cur
)
918 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
919 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
920 if (!compare_hlsl_types(t1field
->type
, t2field
->type
))
922 if (strcmp(t1field
->name
, t2field
->name
))
924 t1cur
= list_next(t1
->e
.elements
, t1cur
);
925 t2cur
= list_next(t2
->e
.elements
, t2cur
);
930 if (t1
->type
== HLSL_CLASS_ARRAY
)
931 return t1
->e
.array
.elements_count
== t2
->e
.array
.elements_count
932 && compare_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
937 struct hlsl_type
*clone_hlsl_type(struct hlsl_type
*old
, unsigned int default_majority
)
939 struct hlsl_type
*type
;
940 struct hlsl_struct_field
*old_field
, *field
;
942 type
= d3dcompiler_alloc(sizeof(*type
));
945 ERR("Out of memory\n");
950 type
->name
= d3dcompiler_strdup(old
->name
);
953 d3dcompiler_free(type
);
957 type
->type
= old
->type
;
958 type
->base_type
= old
->base_type
;
959 type
->dimx
= old
->dimx
;
960 type
->dimy
= old
->dimy
;
961 type
->modifiers
= old
->modifiers
;
962 if (!(type
->modifiers
& HLSL_MODIFIERS_MAJORITY_MASK
))
963 type
->modifiers
|= default_majority
;
964 type
->sampler_dim
= old
->sampler_dim
;
967 case HLSL_CLASS_ARRAY
:
968 type
->e
.array
.type
= clone_hlsl_type(old
->e
.array
.type
, default_majority
);
969 type
->e
.array
.elements_count
= old
->e
.array
.elements_count
;
970 type
->reg_size
= type
->e
.array
.elements_count
* type
->e
.array
.type
->reg_size
;
973 case HLSL_CLASS_STRUCT
:
975 unsigned int reg_size
= 0;
977 type
->e
.elements
= d3dcompiler_alloc(sizeof(*type
->e
.elements
));
978 if (!type
->e
.elements
)
980 d3dcompiler_free((void *)type
->name
);
981 d3dcompiler_free(type
);
984 list_init(type
->e
.elements
);
985 LIST_FOR_EACH_ENTRY(old_field
, old
->e
.elements
, struct hlsl_struct_field
, entry
)
987 field
= d3dcompiler_alloc(sizeof(*field
));
990 LIST_FOR_EACH_ENTRY_SAFE(field
, old_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
992 d3dcompiler_free((void *)field
->semantic
);
993 d3dcompiler_free((void *)field
->name
);
994 d3dcompiler_free(field
);
996 d3dcompiler_free(type
->e
.elements
);
997 d3dcompiler_free((void *)type
->name
);
998 d3dcompiler_free(type
);
1001 field
->type
= clone_hlsl_type(old_field
->type
, default_majority
);
1002 field
->name
= d3dcompiler_strdup(old_field
->name
);
1003 if (old_field
->semantic
)
1004 field
->semantic
= d3dcompiler_strdup(old_field
->semantic
);
1005 field
->modifiers
= old_field
->modifiers
;
1006 field
->reg_offset
= reg_size
;
1007 reg_size
+= field
->type
->reg_size
;
1008 list_add_tail(type
->e
.elements
, &field
->entry
);
1010 type
->reg_size
= reg_size
;
1014 case HLSL_CLASS_MATRIX
:
1015 type
->reg_size
= is_row_major(type
) ? type
->dimy
: type
->dimx
;
1023 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
1027 static BOOL
convertible_data_type(struct hlsl_type
*type
)
1029 return type
->type
!= HLSL_CLASS_OBJECT
;
1032 BOOL
compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1034 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1037 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1039 /* Scalar vars can be cast to pretty much everything */
1040 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1043 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1044 return t1
->dimx
>= t2
->dimx
;
1047 /* The other way around is true too i.e. whatever to scalar */
1048 if (t2
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->dimx
== 1 && t2
->dimy
== 1)
1051 if (t1
->type
== HLSL_CLASS_ARRAY
)
1053 if (compare_hlsl_types(t1
->e
.array
.type
, t2
))
1054 /* e.g. float4[3] to float4 is allowed */
1057 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1058 return components_count_type(t1
) >= components_count_type(t2
);
1060 return components_count_type(t1
) == components_count_type(t2
);
1063 if (t1
->type
== HLSL_CLASS_STRUCT
)
1064 return components_count_type(t1
) >= components_count_type(t2
);
1066 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1067 return components_count_type(t1
) == components_count_type(t2
);
1069 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1071 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
&& t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1074 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1075 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1076 && components_count_type(t1
) == components_count_type(t2
))
1081 if (components_count_type(t1
) >= components_count_type(t2
))
1086 static BOOL
implicit_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1088 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1091 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1093 /* Scalar vars can be converted to any other numeric data type */
1094 if (t1
->dimx
== 1 && t1
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1096 /* The other way around is true too */
1097 if (t2
->dimx
== 1 && t2
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1101 if (t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
== HLSL_CLASS_ARRAY
)
1103 return components_count_type(t1
) == components_count_type(t2
);
1106 if ((t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1107 || (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->type
== HLSL_CLASS_ARRAY
))
1109 /* e.g. float4[3] to float4 is allowed */
1110 if (t1
->type
== HLSL_CLASS_ARRAY
&& compare_hlsl_types(t1
->e
.array
.type
, t2
))
1112 if (components_count_type(t1
) == components_count_type(t2
))
1117 if (t1
->type
<= HLSL_CLASS_VECTOR
&& t2
->type
<= HLSL_CLASS_VECTOR
)
1119 if (t1
->dimx
>= t2
->dimx
)
1124 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1126 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
1127 && t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1130 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1131 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1132 && components_count_type(t1
) == components_count_type(t2
))
1137 if (t1
->type
== HLSL_CLASS_STRUCT
&& t2
->type
== HLSL_CLASS_STRUCT
)
1138 return compare_hlsl_types(t1
, t2
);
1143 static BOOL
expr_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1145 if (t1
->base_type
> HLSL_TYPE_LAST_SCALAR
|| t2
->base_type
> HLSL_TYPE_LAST_SCALAR
)
1148 /* Scalar vars can be converted to pretty much everything */
1149 if ((t1
->dimx
== 1 && t1
->dimy
== 1) || (t2
->dimx
== 1 && t2
->dimy
== 1))
1152 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1155 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1157 /* Matrix-vector conversion is apparently allowed if either they have the same components
1158 count or the matrix is nx1 or 1xn */
1159 if (t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1161 if (components_count_type(t1
) == components_count_type(t2
))
1164 return (t1
->type
== HLSL_CLASS_MATRIX
&& (t1
->dimx
== 1 || t1
->dimy
== 1))
1165 || (t2
->type
== HLSL_CLASS_MATRIX
&& (t2
->dimx
== 1 || t2
->dimy
== 1));
1169 if ((t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1170 || (t1
->dimx
<= t2
->dimx
&& t1
->dimy
<= t2
->dimy
))
1177 static enum hlsl_base_type
expr_common_base_type(enum hlsl_base_type t1
, enum hlsl_base_type t2
)
1179 static const enum hlsl_base_type types
[] =
1188 int t1_idx
= -1, t2_idx
= -1, i
;
1190 for (i
= 0; i
< ARRAY_SIZE(types
); ++i
)
1192 /* Always convert away from HLSL_TYPE_HALF */
1194 t1_idx
= t1
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1196 t2_idx
= t2
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1198 if (t1_idx
!= -1 && t2_idx
!= -1)
1201 if (t1_idx
== -1 || t2_idx
== -1)
1203 FIXME("Unexpected base type.\n");
1204 return HLSL_TYPE_FLOAT
;
1206 return t1_idx
>= t2_idx
? t1
: t2
;
1209 static struct hlsl_type
*expr_common_type(struct hlsl_type
*t1
, struct hlsl_type
*t2
,
1210 struct source_location
*loc
)
1212 enum hlsl_type_class type
;
1213 enum hlsl_base_type base
;
1214 unsigned int dimx
, dimy
;
1216 if (t1
->type
> HLSL_CLASS_LAST_NUMERIC
|| t2
->type
> HLSL_CLASS_LAST_NUMERIC
)
1218 hlsl_report_message(*loc
, HLSL_LEVEL_ERROR
, "non scalar/vector/matrix data type in expression");
1222 if (compare_hlsl_types(t1
, t2
))
1225 if (!expr_compatible_data_types(t1
, t2
))
1227 hlsl_report_message(*loc
, HLSL_LEVEL_ERROR
, "expression data types are incompatible");
1231 if (t1
->base_type
== t2
->base_type
)
1232 base
= t1
->base_type
;
1234 base
= expr_common_base_type(t1
->base_type
, t2
->base_type
);
1236 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1242 else if (t2
->dimx
== 1 && t2
->dimy
== 1)
1248 else if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
)
1250 type
= HLSL_CLASS_MATRIX
;
1251 dimx
= min(t1
->dimx
, t2
->dimx
);
1252 dimy
= min(t1
->dimy
, t2
->dimy
);
1256 /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1257 unsigned int max_dim_1
, max_dim_2
;
1259 max_dim_1
= max(t1
->dimx
, t1
->dimy
);
1260 max_dim_2
= max(t2
->dimx
, t2
->dimy
);
1261 if (t1
->dimx
* t1
->dimy
== t2
->dimx
* t2
->dimy
)
1263 type
= HLSL_CLASS_VECTOR
;
1264 dimx
= max(t1
->dimx
, t2
->dimx
);
1267 else if (max_dim_1
<= max_dim_2
)
1270 if (type
== HLSL_CLASS_VECTOR
)
1284 if (type
== HLSL_CLASS_VECTOR
)
1297 if (type
== HLSL_CLASS_SCALAR
)
1298 return hlsl_ctx
.builtin_types
.scalar
[base
];
1299 if (type
== HLSL_CLASS_VECTOR
)
1300 return hlsl_ctx
.builtin_types
.vector
[base
][dimx
- 1];
1301 return new_hlsl_type(NULL
, type
, base
, dimx
, dimy
);
1304 struct hlsl_ir_node
*add_implicit_conversion(struct list
*instrs
, struct hlsl_ir_node
*node
,
1305 struct hlsl_type
*dst_type
, struct source_location
*loc
)
1307 struct hlsl_type
*src_type
= node
->data_type
;
1308 struct hlsl_ir_expr
*cast
;
1310 if (compare_hlsl_types(src_type
, dst_type
))
1313 if (!implicit_compatible_data_types(src_type
, dst_type
))
1315 hlsl_report_message(*loc
, HLSL_LEVEL_ERROR
, "can't implicitly convert %s to %s",
1316 debug_hlsl_type(src_type
), debug_hlsl_type(dst_type
));
1320 if (dst_type
->dimx
* dst_type
->dimy
< src_type
->dimx
* src_type
->dimy
)
1321 hlsl_report_message(*loc
, HLSL_LEVEL_WARNING
, "implicit truncation of vector type");
1323 TRACE("Implicit conversion from %s to %s.\n", debug_hlsl_type(src_type
), debug_hlsl_type(dst_type
));
1325 if (!(cast
= new_cast(node
, dst_type
, loc
)))
1327 list_add_tail(instrs
, &cast
->node
.entry
);
1331 struct hlsl_ir_expr
*add_expr(struct list
*instrs
, enum hlsl_ir_expr_op op
, struct hlsl_ir_node
*operands
[3],
1332 struct source_location
*loc
)
1334 struct hlsl_ir_expr
*expr
;
1335 struct hlsl_type
*type
;
1338 type
= operands
[0]->data_type
;
1339 for (i
= 1; i
<= 2; ++i
)
1343 type
= expr_common_type(type
, operands
[i
]->data_type
, loc
);
1347 for (i
= 0; i
<= 2; ++i
)
1349 struct hlsl_ir_expr
*cast
;
1353 if (compare_hlsl_types(operands
[i
]->data_type
, type
))
1355 TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands
[i
]->data_type
), debug_hlsl_type(type
));
1356 if (operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= 1
1357 && operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= type
->dimx
* type
->dimy
)
1359 hlsl_report_message(operands
[i
]->loc
, HLSL_LEVEL_WARNING
, "implicit truncation of vector/matrix type");
1362 if (!(cast
= new_cast(operands
[i
], type
, &operands
[i
]->loc
)))
1364 list_add_after(&operands
[i
]->entry
, &cast
->node
.entry
);
1365 operands
[i
] = &cast
->node
;
1368 if (!(expr
= d3dcompiler_alloc(sizeof(*expr
))))
1370 init_node(&expr
->node
, HLSL_IR_EXPR
, type
, *loc
);
1372 for (i
= 0; i
<= 2; ++i
)
1373 hlsl_src_from_node(&expr
->operands
[i
], operands
[i
]);
1374 list_add_tail(instrs
, &expr
->node
.entry
);
1379 struct hlsl_ir_expr
*new_cast(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1380 struct source_location
*loc
)
1382 struct hlsl_ir_node
*cast
;
1384 cast
= new_unary_expr(HLSL_IR_UNOP_CAST
, node
, *loc
);
1386 cast
->data_type
= type
;
1387 return expr_from_node(cast
);
1390 static enum hlsl_ir_expr_op
op_from_assignment(enum parse_assign_op op
)
1392 static const enum hlsl_ir_expr_op ops
[] =
1400 HLSL_IR_BINOP_LSHIFT
,
1401 HLSL_IR_BINOP_RSHIFT
,
1402 HLSL_IR_BINOP_BIT_AND
,
1403 HLSL_IR_BINOP_BIT_OR
,
1404 HLSL_IR_BINOP_BIT_XOR
,
1410 static BOOL
invert_swizzle(unsigned int *swizzle
, unsigned int *writemask
, unsigned int *ret_width
)
1412 unsigned int i
, j
, bit
= 0, inverted
= 0, width
, new_writemask
= 0, new_swizzle
= 0;
1414 /* Apply the writemask to the swizzle to get a new writemask and swizzle. */
1415 for (i
= 0; i
< 4; ++i
)
1417 if (*writemask
& (1 << i
))
1419 unsigned int s
= (*swizzle
>> (i
* 2)) & 3;
1420 new_swizzle
|= s
<< (bit
++ * 2);
1421 if (new_writemask
& (1 << s
))
1423 new_writemask
|= 1 << s
;
1428 /* Invert the swizzle. */
1430 for (i
= 0; i
< 4; ++i
)
1432 for (j
= 0; j
< width
; ++j
)
1434 unsigned int s
= (new_swizzle
>> (j
* 2)) & 3;
1436 inverted
|= j
<< (bit
++ * 2);
1440 *swizzle
= inverted
;
1441 *writemask
= new_writemask
;
1446 struct hlsl_ir_node
*add_assignment(struct list
*instrs
, struct hlsl_ir_node
*lhs
,
1447 enum parse_assign_op assign_op
, struct hlsl_ir_node
*rhs
)
1449 struct hlsl_ir_assignment
*assign
;
1450 struct hlsl_type
*lhs_type
;
1451 DWORD writemask
= 0;
1453 lhs_type
= lhs
->data_type
;
1454 if (lhs_type
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1456 writemask
= (1 << lhs_type
->dimx
) - 1;
1458 if (!(rhs
= add_implicit_conversion(instrs
, rhs
, lhs_type
, &rhs
->loc
)))
1462 assign
= d3dcompiler_alloc(sizeof(*assign
));
1465 ERR("Out of memory\n");
1469 while (lhs
->type
!= HLSL_IR_LOAD
)
1471 struct hlsl_ir_node
*lhs_inner
;
1473 if (lhs
->type
== HLSL_IR_EXPR
&& expr_from_node(lhs
)->op
== HLSL_IR_UNOP_CAST
)
1475 FIXME("Cast on the lhs.\n");
1476 d3dcompiler_free(assign
);
1479 else if (lhs
->type
== HLSL_IR_SWIZZLE
)
1481 struct hlsl_ir_swizzle
*swizzle
= swizzle_from_node(lhs
);
1482 const struct hlsl_type
*swizzle_type
= swizzle
->node
.data_type
;
1485 if (lhs
->data_type
->type
== HLSL_CLASS_MATRIX
)
1486 FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
1488 lhs_inner
= swizzle
->val
.node
;
1489 hlsl_src_remove(&swizzle
->val
);
1490 list_remove(&lhs
->entry
);
1492 list_add_after(&rhs
->entry
, &lhs
->entry
);
1493 hlsl_src_from_node(&swizzle
->val
, rhs
);
1494 if (!invert_swizzle(&swizzle
->swizzle
, &writemask
, &width
))
1496 hlsl_report_message(lhs
->loc
, HLSL_LEVEL_ERROR
, "invalid writemask");
1497 d3dcompiler_free(assign
);
1500 assert(swizzle_type
->type
== HLSL_CLASS_VECTOR
);
1501 if (swizzle_type
->dimx
!= width
)
1502 swizzle
->node
.data_type
= hlsl_ctx
.builtin_types
.vector
[swizzle_type
->base_type
][width
- 1];
1503 rhs
= &swizzle
->node
;
1507 hlsl_report_message(lhs
->loc
, HLSL_LEVEL_ERROR
, "invalid lvalue");
1508 d3dcompiler_free(assign
);
1515 init_node(&assign
->node
, HLSL_IR_ASSIGNMENT
, lhs_type
, lhs
->loc
);
1516 assign
->writemask
= writemask
;
1517 assign
->lhs
.var
= load_from_node(lhs
)->src
.var
;
1518 hlsl_src_from_node(&assign
->lhs
.offset
, load_from_node(lhs
)->src
.offset
.node
);
1519 if (assign_op
!= ASSIGN_OP_ASSIGN
)
1521 enum hlsl_ir_expr_op op
= op_from_assignment(assign_op
);
1522 struct hlsl_ir_node
*expr
;
1524 TRACE("Adding an expression for the compound assignment.\n");
1525 expr
= new_binary_expr(op
, lhs
, rhs
);
1526 list_add_after(&rhs
->entry
, &expr
->entry
);
1529 hlsl_src_from_node(&assign
->rhs
, rhs
);
1530 list_add_tail(instrs
, &assign
->node
.entry
);
1532 return &assign
->node
;
1535 static int compare_hlsl_types_rb(const void *key
, const struct wine_rb_entry
*entry
)
1537 const char *name
= key
;
1538 const struct hlsl_type
*type
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_type
, scope_entry
);
1540 if (name
== type
->name
)
1543 if (!name
|| !type
->name
)
1545 ERR("hlsl_type without a name in a scope?\n");
1548 return strcmp(name
, type
->name
);
1551 void push_scope(struct hlsl_parse_ctx
*ctx
)
1553 struct hlsl_scope
*new_scope
= d3dcompiler_alloc(sizeof(*new_scope
));
1557 ERR("Out of memory!\n");
1560 TRACE("Pushing a new scope\n");
1561 list_init(&new_scope
->vars
);
1562 wine_rb_init(&new_scope
->types
, compare_hlsl_types_rb
);
1563 new_scope
->upper
= ctx
->cur_scope
;
1564 ctx
->cur_scope
= new_scope
;
1565 list_add_tail(&ctx
->scopes
, &new_scope
->entry
);
1568 BOOL
pop_scope(struct hlsl_parse_ctx
*ctx
)
1570 struct hlsl_scope
*prev_scope
= ctx
->cur_scope
->upper
;
1574 TRACE("Popping current scope\n");
1575 ctx
->cur_scope
= prev_scope
;
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 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_STORAGE_IN
| HLSL_STORAGE_OUT
)) == (HLSL_STORAGE_IN
| HLSL_STORAGE_OUT
))
1751 strcat(string
, " inout"); /* 6 */
1752 else if (modifiers
& HLSL_STORAGE_IN
)
1753 strcat(string
, " in"); /* 3 */
1754 else if (modifiers
& HLSL_STORAGE_OUT
)
1755 strcat(string
, " out"); /* 4 */
1757 return wine_dbg_sprintf("%s", string
[0] ? string
+ 1 : "");
1760 const char *debug_node_type(enum hlsl_ir_node_type type
)
1762 static const char * const names
[] =
1764 "HLSL_IR_ASSIGNMENT",
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
);
1788 wine_dbg_printf("\n");
1792 static void debug_dump_src(const struct hlsl_src
*src
)
1794 if (src
->node
->index
)
1795 wine_dbg_printf("@%u", src
->node
->index
);
1797 wine_dbg_printf("%p", src
->node
);
1800 static void debug_dump_ir_var(const struct hlsl_ir_var
*var
)
1803 wine_dbg_printf("%s ", debug_modifiers(var
->modifiers
));
1804 wine_dbg_printf("%s %s", debug_hlsl_type(var
->data_type
), var
->name
);
1806 wine_dbg_printf(" : %s", debugstr_a(var
->semantic
));
1809 static void debug_dump_deref(const struct hlsl_deref
*deref
)
1811 if (deref
->offset
.node
)
1812 /* Print the variable's type for convenience. */
1813 wine_dbg_printf("(%s %s)", debug_hlsl_type(deref
->var
->data_type
), deref
->var
->name
);
1815 wine_dbg_printf("%s", deref
->var
->name
);
1816 if (deref
->offset
.node
)
1818 wine_dbg_printf("[");
1819 debug_dump_src(&deref
->offset
);
1820 wine_dbg_printf("]");
1824 static void debug_dump_ir_constant(const struct hlsl_ir_constant
*constant
)
1826 struct hlsl_type
*type
= constant
->node
.data_type
;
1829 if (type
->dimx
!= 1)
1830 wine_dbg_printf("{");
1831 for (x
= 0; x
< type
->dimx
; ++x
)
1833 switch (type
->base_type
)
1835 case HLSL_TYPE_FLOAT
:
1836 wine_dbg_printf("%.8e ", constant
->value
.f
[x
]);
1838 case HLSL_TYPE_DOUBLE
:
1839 wine_dbg_printf("%.16e ", constant
->value
.d
[x
]);
1842 wine_dbg_printf("%d ", constant
->value
.i
[x
]);
1844 case HLSL_TYPE_UINT
:
1845 wine_dbg_printf("%u ", constant
->value
.u
[x
]);
1847 case HLSL_TYPE_BOOL
:
1848 wine_dbg_printf("%s ", constant
->value
.b
[x
] ? "true" : "false");
1851 wine_dbg_printf("Constants of type %s not supported\n", debug_base_type(type
));
1854 if (type
->dimx
!= 1)
1855 wine_dbg_printf("}");
1858 static const char *debug_expr_op(const struct hlsl_ir_expr
*expr
)
1860 static const char * const op_names
[] =
1928 if (expr
->op
== HLSL_IR_UNOP_CAST
)
1929 return debug_hlsl_type(expr
->node
.data_type
);
1931 return op_names
[expr
->op
];
1934 /* Dumps the expression in a prefix "operator (operands)" form */
1935 static void debug_dump_ir_expr(const struct hlsl_ir_expr
*expr
)
1939 wine_dbg_printf("%s (", debug_expr_op(expr
));
1940 for (i
= 0; i
< 3 && expr
->operands
[i
].node
; ++i
)
1942 debug_dump_src(&expr
->operands
[i
]);
1943 wine_dbg_printf(" ");
1945 wine_dbg_printf(")");
1948 static const char *debug_writemask(DWORD writemask
)
1950 static const char components
[] = {'x', 'y', 'z', 'w'};
1952 unsigned int i
= 0, pos
= 0;
1954 assert(!(writemask
& ~BWRITERSP_WRITEMASK_ALL
));
1959 string
[pos
++] = components
[i
];
1964 return wine_dbg_sprintf(".%s", string
);
1967 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment
*assign
)
1969 wine_dbg_printf("= (");
1970 debug_dump_deref(&assign
->lhs
);
1971 if (assign
->writemask
!= BWRITERSP_WRITEMASK_ALL
)
1972 wine_dbg_printf("%s", debug_writemask(assign
->writemask
));
1973 wine_dbg_printf(" ");
1974 debug_dump_src(&assign
->rhs
);
1975 wine_dbg_printf(")");
1978 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle
*swizzle
)
1982 debug_dump_src(&swizzle
->val
);
1983 wine_dbg_printf(".");
1984 if (swizzle
->val
.node
->data_type
->dimy
> 1)
1986 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
1987 wine_dbg_printf("_m%u%u", (swizzle
->swizzle
>> i
* 8) & 0xf, (swizzle
->swizzle
>> (i
* 8 + 4)) & 0xf);
1991 static const char c
[] = {'x', 'y', 'z', 'w'};
1993 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
1994 wine_dbg_printf("%c", c
[(swizzle
->swizzle
>> i
* 2) & 0x3]);
1998 static void debug_dump_ir_jump(const struct hlsl_ir_jump
*jump
)
2002 case HLSL_IR_JUMP_BREAK
:
2003 wine_dbg_printf("break");
2005 case HLSL_IR_JUMP_CONTINUE
:
2006 wine_dbg_printf("continue");
2008 case HLSL_IR_JUMP_DISCARD
:
2009 wine_dbg_printf("discard");
2011 case HLSL_IR_JUMP_RETURN
:
2012 wine_dbg_printf("return");
2017 static void debug_dump_ir_if(const struct hlsl_ir_if
*if_node
)
2019 wine_dbg_printf("if (");
2020 debug_dump_src(&if_node
->condition
);
2021 wine_dbg_printf(")\n{\n");
2022 debug_dump_instr_list(&if_node
->then_instrs
);
2023 wine_dbg_printf("}\nelse\n{\n");
2024 debug_dump_instr_list(&if_node
->else_instrs
);
2025 wine_dbg_printf("}\n");
2028 static void debug_dump_ir_loop(const struct hlsl_ir_loop
*loop
)
2030 wine_dbg_printf("for (;;)\n{\n");
2031 debug_dump_instr_list(&loop
->body
);
2032 wine_dbg_printf("}\n");
2035 static void debug_dump_instr(const struct hlsl_ir_node
*instr
)
2038 wine_dbg_printf("%4u: ", instr
->index
);
2040 wine_dbg_printf("%p: ", instr
);
2042 wine_dbg_printf("%10s | ", instr
->data_type
? debug_hlsl_type(instr
->data_type
) : "");
2044 switch (instr
->type
)
2047 debug_dump_ir_expr(expr_from_node(instr
));
2050 debug_dump_deref(&load_from_node(instr
)->src
);
2052 case HLSL_IR_CONSTANT
:
2053 debug_dump_ir_constant(constant_from_node(instr
));
2055 case HLSL_IR_ASSIGNMENT
:
2056 debug_dump_ir_assignment(assignment_from_node(instr
));
2058 case HLSL_IR_SWIZZLE
:
2059 debug_dump_ir_swizzle(swizzle_from_node(instr
));
2062 debug_dump_ir_jump(jump_from_node(instr
));
2065 debug_dump_ir_if(if_from_node(instr
));
2068 debug_dump_ir_loop(loop_from_node(instr
));
2071 wine_dbg_printf("<No dump function for %s>", debug_node_type(instr
->type
));
2075 void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl
*func
)
2077 struct hlsl_ir_var
*param
;
2079 TRACE("Dumping function %s.\n", debugstr_a(func
->func
->name
));
2080 TRACE("Function parameters:\n");
2081 LIST_FOR_EACH_ENTRY(param
, func
->parameters
, struct hlsl_ir_var
, param_entry
)
2083 debug_dump_ir_var(param
);
2084 wine_dbg_printf("\n");
2087 TRACE("Function semantic: %s\n", debugstr_a(func
->semantic
));
2090 debug_dump_instr_list(func
->body
);
2094 void free_hlsl_type(struct hlsl_type
*type
)
2096 struct hlsl_struct_field
*field
, *next_field
;
2098 d3dcompiler_free((void *)type
->name
);
2099 if (type
->type
== HLSL_CLASS_STRUCT
)
2101 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
2103 d3dcompiler_free((void *)field
->name
);
2104 d3dcompiler_free((void *)field
->semantic
);
2105 d3dcompiler_free(field
);
2108 d3dcompiler_free(type
);
2111 void free_instr_list(struct list
*list
)
2113 struct hlsl_ir_node
*node
, *next_node
;
2117 /* Iterate in reverse, to avoid use-after-free when unlinking sources from
2118 * the "uses" list. */
2119 LIST_FOR_EACH_ENTRY_SAFE_REV(node
, next_node
, list
, struct hlsl_ir_node
, entry
)
2121 d3dcompiler_free(list
);
2124 static void free_ir_constant(struct hlsl_ir_constant
*constant
)
2126 d3dcompiler_free(constant
);
2129 static void free_ir_load(struct hlsl_ir_load
*load
)
2131 hlsl_src_remove(&load
->src
.offset
);
2132 d3dcompiler_free(load
);
2135 static void free_ir_swizzle(struct hlsl_ir_swizzle
*swizzle
)
2137 hlsl_src_remove(&swizzle
->val
);
2138 d3dcompiler_free(swizzle
);
2141 static void free_ir_expr(struct hlsl_ir_expr
*expr
)
2145 for (i
= 0; i
< ARRAY_SIZE(expr
->operands
); ++i
)
2146 hlsl_src_remove(&expr
->operands
[i
]);
2147 d3dcompiler_free(expr
);
2150 static void free_ir_assignment(struct hlsl_ir_assignment
*assignment
)
2152 hlsl_src_remove(&assignment
->rhs
);
2153 hlsl_src_remove(&assignment
->lhs
.offset
);
2154 d3dcompiler_free(assignment
);
2157 static void free_ir_if(struct hlsl_ir_if
*if_node
)
2159 struct hlsl_ir_node
*node
, *next_node
;
2161 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, &if_node
->then_instrs
, struct hlsl_ir_node
, entry
)
2163 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, &if_node
->else_instrs
, struct hlsl_ir_node
, entry
)
2165 hlsl_src_remove(&if_node
->condition
);
2166 d3dcompiler_free(if_node
);
2169 static void free_ir_loop(struct hlsl_ir_loop
*loop
)
2171 struct hlsl_ir_node
*node
, *next_node
;
2173 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, &loop
->body
, struct hlsl_ir_node
, entry
)
2175 d3dcompiler_free(loop
);
2178 static void free_ir_jump(struct hlsl_ir_jump
*jump
)
2180 d3dcompiler_free(jump
);
2183 void free_instr(struct hlsl_ir_node
*node
)
2187 case HLSL_IR_CONSTANT
:
2188 free_ir_constant(constant_from_node(node
));
2191 free_ir_load(load_from_node(node
));
2193 case HLSL_IR_SWIZZLE
:
2194 free_ir_swizzle(swizzle_from_node(node
));
2197 free_ir_expr(expr_from_node(node
));
2199 case HLSL_IR_ASSIGNMENT
:
2200 free_ir_assignment(assignment_from_node(node
));
2203 free_ir_if(if_from_node(node
));
2206 free_ir_loop(loop_from_node(node
));
2209 free_ir_jump(jump_from_node(node
));
2212 FIXME("Unsupported node type %s\n", debug_node_type(node
->type
));
2216 static void free_function_decl(struct hlsl_ir_function_decl
*decl
)
2218 d3dcompiler_free((void *)decl
->semantic
);
2219 d3dcompiler_free(decl
->parameters
);
2220 free_instr_list(decl
->body
);
2221 d3dcompiler_free(decl
);
2224 static void free_function_decl_rb(struct wine_rb_entry
*entry
, void *context
)
2226 free_function_decl(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function_decl
, entry
));
2229 static void free_function(struct hlsl_ir_function
*func
)
2231 wine_rb_destroy(&func
->overloads
, free_function_decl_rb
, NULL
);
2232 d3dcompiler_free((void *)func
->name
);
2233 d3dcompiler_free(func
);
2236 void free_function_rb(struct wine_rb_entry
*entry
, void *context
)
2238 free_function(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function
, entry
));
2241 void add_function_decl(struct wine_rb_tree
*funcs
, char *name
, struct hlsl_ir_function_decl
*decl
, BOOL intrinsic
)
2243 struct hlsl_ir_function
*func
;
2244 struct wine_rb_entry
*func_entry
, *old_entry
;
2246 func_entry
= wine_rb_get(funcs
, name
);
2249 func
= WINE_RB_ENTRY_VALUE(func_entry
, struct hlsl_ir_function
, entry
);
2250 if (intrinsic
!= func
->intrinsic
)
2254 ERR("Redeclaring a user defined function as an intrinsic.\n");
2257 TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name
));
2258 func
->intrinsic
= intrinsic
;
2259 wine_rb_destroy(&func
->overloads
, free_function_decl_rb
, NULL
);
2260 wine_rb_init(&func
->overloads
, compare_function_decl_rb
);
2263 if ((old_entry
= wine_rb_get(&func
->overloads
, decl
->parameters
)))
2265 struct hlsl_ir_function_decl
*old_decl
=
2266 WINE_RB_ENTRY_VALUE(old_entry
, struct hlsl_ir_function_decl
, entry
);
2270 free_function_decl(decl
);
2271 d3dcompiler_free(name
);
2274 wine_rb_remove(&func
->overloads
, old_entry
);
2275 free_function_decl(old_decl
);
2277 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2278 d3dcompiler_free(name
);
2281 func
= d3dcompiler_alloc(sizeof(*func
));
2283 wine_rb_init(&func
->overloads
, compare_function_decl_rb
);
2285 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2286 func
->intrinsic
= intrinsic
;
2287 wine_rb_put(funcs
, func
->name
, &func
->entry
);