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
24 #include "d3dcompiler_private.h"
26 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler
);
28 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
30 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c
)
34 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR
);
35 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR
);
36 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS
);
37 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS
);
38 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT
);
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT
);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS
);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER
);
43 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c
);
44 return "unrecognized";
48 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t
)
52 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID
);
53 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL
);
54 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT
);
55 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT
);
56 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING
);
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE
);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D
);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D
);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D
);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE
);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER
);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER
);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER
);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT
);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8
);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER
);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER
);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL
);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND
);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER
);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER
);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER
);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY
);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY
);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW
);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW
);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS
);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY
);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY
);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER
);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER
);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER
);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER
);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE
);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D
);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY
);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D
);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY
);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D
);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER
);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER
);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER
);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER
);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER
);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER
);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER
);
99 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t
);
100 return "unrecognized";
104 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part
)
108 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB
);
109 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB
);
110 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
);
111 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB
);
112 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB
);
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO
);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER
);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER
);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER
);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER
);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS
);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF
);
121 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part
);
122 return "unrecognized";
126 const char *debug_print_srcmod(DWORD mod
)
130 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG
);
131 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS
);
132 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG
);
133 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN
);
134 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG
);
135 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP
);
136 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2
);
137 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG
);
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ
);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW
);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS
);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG
);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT
);
144 FIXME("Unrecognized source modifier %#x.\n", mod
);
145 return "unrecognized_src_mod";
149 #undef WINE_D3DCOMPILER_TO_STR
151 const char *debug_print_dstmod(DWORD mod
)
157 case BWRITERSPDM_SATURATE
:
159 case BWRITERSPDM_PARTIALPRECISION
:
161 case BWRITERSPDM_MSAMPCENTROID
:
163 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
:
165 case BWRITERSPDM_SATURATE
| BWRITERSPDM_MSAMPCENTROID
:
166 return "_sat_centroid";
167 case BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
168 return "_pp_centroid";
169 case BWRITERSPDM_SATURATE
| BWRITERSPDM_PARTIALPRECISION
| BWRITERSPDM_MSAMPCENTROID
:
170 return "_sat_pp_centroid";
172 return "Unexpected modifier\n";
176 const char *debug_print_shift(DWORD shift
)
178 static const char * const shiftstrings
[] =
197 return shiftstrings
[shift
];
200 static const char *get_regname(const struct shader_reg
*reg
)
204 case BWRITERSPR_TEMP
:
205 return wine_dbg_sprintf("r%u", reg
->regnum
);
206 case BWRITERSPR_INPUT
:
207 return wine_dbg_sprintf("v%u", reg
->regnum
);
208 case BWRITERSPR_CONST
:
209 return wine_dbg_sprintf("c%u", reg
->regnum
);
210 case BWRITERSPR_ADDR
:
211 return wine_dbg_sprintf("a%u", reg
->regnum
);
212 case BWRITERSPR_TEXTURE
:
213 return wine_dbg_sprintf("t%u", reg
->regnum
);
214 case BWRITERSPR_RASTOUT
:
217 case BWRITERSRO_POSITION
: return "oPos";
218 case BWRITERSRO_FOG
: return "oFog";
219 case BWRITERSRO_POINT_SIZE
: return "oPts";
220 default: return "Unexpected RASTOUT";
222 case BWRITERSPR_ATTROUT
:
223 return wine_dbg_sprintf("oD%u", reg
->regnum
);
224 case BWRITERSPR_TEXCRDOUT
:
225 return wine_dbg_sprintf("oT%u", reg
->regnum
);
226 case BWRITERSPR_OUTPUT
:
227 return wine_dbg_sprintf("o%u", reg
->regnum
);
228 case BWRITERSPR_CONSTINT
:
229 return wine_dbg_sprintf("i%u", reg
->regnum
);
230 case BWRITERSPR_COLOROUT
:
231 return wine_dbg_sprintf("oC%u", reg
->regnum
);
232 case BWRITERSPR_DEPTHOUT
:
234 case BWRITERSPR_SAMPLER
:
235 return wine_dbg_sprintf("s%u", reg
->regnum
);
236 case BWRITERSPR_CONSTBOOL
:
237 return wine_dbg_sprintf("b%u", reg
->regnum
);
238 case BWRITERSPR_LOOP
:
240 case BWRITERSPR_MISCTYPE
:
243 case 0: return "vPos";
244 case 1: return "vFace";
245 default: return "unexpected misctype";
247 case BWRITERSPR_LABEL
:
248 return wine_dbg_sprintf("l%u", reg
->regnum
);
249 case BWRITERSPR_PREDICATE
:
250 return wine_dbg_sprintf("p%u", reg
->regnum
);
252 return wine_dbg_sprintf("unknown regname %#x", reg
->type
);
256 static const char *debug_print_writemask(DWORD mask
)
259 unsigned char pos
= 1;
261 if(mask
== BWRITERSP_WRITEMASK_ALL
) return "";
263 if(mask
& BWRITERSP_WRITEMASK_0
) ret
[pos
++] = 'x';
264 if(mask
& BWRITERSP_WRITEMASK_1
) ret
[pos
++] = 'y';
265 if(mask
& BWRITERSP_WRITEMASK_2
) ret
[pos
++] = 'z';
266 if(mask
& BWRITERSP_WRITEMASK_3
) ret
[pos
++] = 'w';
269 return wine_dbg_sprintf("%s", ret
);
272 static const char *debug_print_swizzle(DWORD arg
)
280 case BWRITERVS_NOSWIZZLE
:
282 case BWRITERVS_SWIZZLE_X
:
284 case BWRITERVS_SWIZZLE_Y
:
286 case BWRITERVS_SWIZZLE_Z
:
288 case BWRITERVS_SWIZZLE_W
:
292 swizzle
[0] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 0)) & 0x03;
293 swizzle
[1] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 2)) & 0x03;
294 swizzle
[2] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 4)) & 0x03;
295 swizzle
[3] = (arg
>> (BWRITERVS_SWIZZLE_SHIFT
+ 6)) & 0x03;
298 for (i
= 0; i
< 4; ++i
)
302 case 0: ret
[1 + i
] = 'x'; break;
303 case 1: ret
[1 + i
] = 'y'; break;
304 case 2: ret
[1 + i
] = 'z'; break;
305 case 3: ret
[1 + i
] = 'w'; break;
310 return wine_dbg_sprintf("%s", ret
);
313 static const char *debug_print_relarg(const struct shader_reg
*reg
)
315 const char *short_swizzle
;
316 if (!reg
->rel_reg
) return "";
318 short_swizzle
= debug_print_swizzle(reg
->rel_reg
->u
.swizzle
);
320 if (reg
->rel_reg
->type
== BWRITERSPR_ADDR
)
321 return wine_dbg_sprintf("[a%u%s]", reg
->rel_reg
->regnum
, short_swizzle
);
322 else if(reg
->rel_reg
->type
== BWRITERSPR_LOOP
&& reg
->rel_reg
->regnum
== 0)
323 return wine_dbg_sprintf("[aL%s]", short_swizzle
);
325 return "Unexpected relative addressing argument";
328 const char *debug_print_dstreg(const struct shader_reg
*reg
)
330 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
331 debug_print_relarg(reg
),
332 debug_print_writemask(reg
->u
.writemask
));
335 const char *debug_print_srcreg(const struct shader_reg
*reg
)
339 case BWRITERSPSM_NONE
:
340 return wine_dbg_sprintf("%s%s%s", get_regname(reg
),
341 debug_print_relarg(reg
),
342 debug_print_swizzle(reg
->u
.swizzle
));
343 case BWRITERSPSM_NEG
:
344 return wine_dbg_sprintf("-%s%s%s", get_regname(reg
),
345 debug_print_relarg(reg
),
346 debug_print_swizzle(reg
->u
.swizzle
));
347 case BWRITERSPSM_BIAS
:
348 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg
),
349 debug_print_relarg(reg
),
350 debug_print_swizzle(reg
->u
.swizzle
));
351 case BWRITERSPSM_BIASNEG
:
352 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg
),
353 debug_print_relarg(reg
),
354 debug_print_swizzle(reg
->u
.swizzle
));
355 case BWRITERSPSM_SIGN
:
356 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg
),
357 debug_print_relarg(reg
),
358 debug_print_swizzle(reg
->u
.swizzle
));
359 case BWRITERSPSM_SIGNNEG
:
360 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg
),
361 debug_print_relarg(reg
),
362 debug_print_swizzle(reg
->u
.swizzle
));
363 case BWRITERSPSM_COMP
:
364 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg
),
365 debug_print_relarg(reg
),
366 debug_print_swizzle(reg
->u
.swizzle
));
368 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg
),
369 debug_print_relarg(reg
),
370 debug_print_swizzle(reg
->u
.swizzle
));
371 case BWRITERSPSM_X2NEG
:
372 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg
),
373 debug_print_relarg(reg
),
374 debug_print_swizzle(reg
->u
.swizzle
));
376 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg
),
377 debug_print_relarg(reg
),
378 debug_print_swizzle(reg
->u
.swizzle
));
380 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg
),
381 debug_print_relarg(reg
),
382 debug_print_swizzle(reg
->u
.swizzle
));
383 case BWRITERSPSM_ABS
:
384 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg
),
385 debug_print_relarg(reg
),
386 debug_print_swizzle(reg
->u
.swizzle
));
387 case BWRITERSPSM_ABSNEG
:
388 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg
),
389 debug_print_relarg(reg
),
390 debug_print_swizzle(reg
->u
.swizzle
));
391 case BWRITERSPSM_NOT
:
392 return wine_dbg_sprintf("!%s%s%s", get_regname(reg
),
393 debug_print_relarg(reg
),
394 debug_print_swizzle(reg
->u
.swizzle
));
396 return "Unknown modifier";
399 const char *debug_print_comp(DWORD comp
)
403 case BWRITER_COMPARISON_NONE
: return "";
404 case BWRITER_COMPARISON_GT
: return "_gt";
405 case BWRITER_COMPARISON_EQ
: return "_eq";
406 case BWRITER_COMPARISON_GE
: return "_ge";
407 case BWRITER_COMPARISON_LT
: return "_lt";
408 case BWRITER_COMPARISON_NE
: return "_ne";
409 case BWRITER_COMPARISON_LE
: return "_le";
410 default: return "_unknown";
414 const char *debug_print_opcode(DWORD opcode
)
418 case BWRITERSIO_NOP
: return "nop";
419 case BWRITERSIO_MOV
: return "mov";
420 case BWRITERSIO_ADD
: return "add";
421 case BWRITERSIO_SUB
: return "sub";
422 case BWRITERSIO_MAD
: return "mad";
423 case BWRITERSIO_MUL
: return "mul";
424 case BWRITERSIO_RCP
: return "rcp";
425 case BWRITERSIO_RSQ
: return "rsq";
426 case BWRITERSIO_DP3
: return "dp3";
427 case BWRITERSIO_DP4
: return "dp4";
428 case BWRITERSIO_MIN
: return "min";
429 case BWRITERSIO_MAX
: return "max";
430 case BWRITERSIO_SLT
: return "slt";
431 case BWRITERSIO_SGE
: return "sge";
432 case BWRITERSIO_EXP
: return "exp";
433 case BWRITERSIO_LOG
: return "log";
434 case BWRITERSIO_LIT
: return "lit";
435 case BWRITERSIO_DST
: return "dst";
436 case BWRITERSIO_LRP
: return "lrp";
437 case BWRITERSIO_FRC
: return "frc";
438 case BWRITERSIO_M4x4
: return "m4x4";
439 case BWRITERSIO_M4x3
: return "m4x3";
440 case BWRITERSIO_M3x4
: return "m3x4";
441 case BWRITERSIO_M3x3
: return "m3x3";
442 case BWRITERSIO_M3x2
: return "m3x2";
443 case BWRITERSIO_CALL
: return "call";
444 case BWRITERSIO_CALLNZ
: return "callnz";
445 case BWRITERSIO_LOOP
: return "loop";
446 case BWRITERSIO_RET
: return "ret";
447 case BWRITERSIO_ENDLOOP
: return "endloop";
448 case BWRITERSIO_LABEL
: return "label";
449 case BWRITERSIO_DCL
: return "dcl";
450 case BWRITERSIO_POW
: return "pow";
451 case BWRITERSIO_CRS
: return "crs";
452 case BWRITERSIO_SGN
: return "sgn";
453 case BWRITERSIO_ABS
: return "abs";
454 case BWRITERSIO_NRM
: return "nrm";
455 case BWRITERSIO_SINCOS
: return "sincos";
456 case BWRITERSIO_REP
: return "rep";
457 case BWRITERSIO_ENDREP
: return "endrep";
458 case BWRITERSIO_IF
: return "if";
459 case BWRITERSIO_IFC
: return "ifc";
460 case BWRITERSIO_ELSE
: return "else";
461 case BWRITERSIO_ENDIF
: return "endif";
462 case BWRITERSIO_BREAK
: return "break";
463 case BWRITERSIO_BREAKC
: return "breakc";
464 case BWRITERSIO_MOVA
: return "mova";
465 case BWRITERSIO_DEFB
: return "defb";
466 case BWRITERSIO_DEFI
: return "defi";
467 case BWRITERSIO_TEXCOORD
: return "texcoord";
468 case BWRITERSIO_TEXKILL
: return "texkill";
469 case BWRITERSIO_TEX
: return "tex";
470 case BWRITERSIO_TEXBEM
: return "texbem";
471 case BWRITERSIO_TEXBEML
: return "texbeml";
472 case BWRITERSIO_TEXREG2AR
: return "texreg2ar";
473 case BWRITERSIO_TEXREG2GB
: return "texreg2gb";
474 case BWRITERSIO_TEXM3x2PAD
: return "texm3x2pad";
475 case BWRITERSIO_TEXM3x2TEX
: return "texm3x2tex";
476 case BWRITERSIO_TEXM3x3PAD
: return "texm3x3pad";
477 case BWRITERSIO_TEXM3x3TEX
: return "texm3x3tex";
478 case BWRITERSIO_TEXM3x3SPEC
: return "texm3x3vspec";
479 case BWRITERSIO_TEXM3x3VSPEC
: return "texm3x3vspec";
480 case BWRITERSIO_EXPP
: return "expp";
481 case BWRITERSIO_LOGP
: return "logp";
482 case BWRITERSIO_CND
: return "cnd";
483 case BWRITERSIO_DEF
: return "def";
484 case BWRITERSIO_TEXREG2RGB
: return "texreg2rgb";
485 case BWRITERSIO_TEXDP3TEX
: return "texdp3tex";
486 case BWRITERSIO_TEXM3x2DEPTH
: return "texm3x2depth";
487 case BWRITERSIO_TEXDP3
: return "texdp3";
488 case BWRITERSIO_TEXM3x3
: return "texm3x3";
489 case BWRITERSIO_TEXDEPTH
: return "texdepth";
490 case BWRITERSIO_CMP
: return "cmp";
491 case BWRITERSIO_BEM
: return "bem";
492 case BWRITERSIO_DP2ADD
: return "dp2add";
493 case BWRITERSIO_DSX
: return "dsx";
494 case BWRITERSIO_DSY
: return "dsy";
495 case BWRITERSIO_TEXLDD
: return "texldd";
496 case BWRITERSIO_SETP
: return "setp";
497 case BWRITERSIO_TEXLDL
: return "texldl";
498 case BWRITERSIO_BREAKP
: return "breakp";
499 case BWRITERSIO_PHASE
: return "phase";
501 case BWRITERSIO_TEXLDP
: return "texldp";
502 case BWRITERSIO_TEXLDB
: return "texldb";
504 default: return "unknown";
508 void skip_dword_unknown(const char **ptr
, unsigned int count
)
513 FIXME("Skipping %u unknown DWORDs:\n", count
);
514 for (i
= 0; i
< count
; ++i
)
517 FIXME("\t0x%08x\n", d
);
521 static void write_dword_unknown(char **ptr
, DWORD d
)
523 FIXME("Writing unknown DWORD 0x%08x\n", d
);
527 HRESULT
dxbc_add_section(struct dxbc
*dxbc
, DWORD tag
, const char *data
, DWORD data_size
)
529 TRACE("dxbc %p, tag %s, size %#x.\n", dxbc
, debugstr_an((const char *)&tag
, 4), data_size
);
531 if (dxbc
->count
>= dxbc
->size
)
533 struct dxbc_section
*new_sections
;
534 DWORD new_size
= dxbc
->size
<< 1;
536 new_sections
= HeapReAlloc(GetProcessHeap(), 0, dxbc
->sections
, new_size
* sizeof(*dxbc
->sections
));
539 ERR("Failed to allocate dxbc section memory\n");
540 return E_OUTOFMEMORY
;
543 dxbc
->sections
= new_sections
;
544 dxbc
->size
= new_size
;
547 dxbc
->sections
[dxbc
->count
].tag
= tag
;
548 dxbc
->sections
[dxbc
->count
].data_size
= data_size
;
549 dxbc
->sections
[dxbc
->count
].data
= data
;
555 HRESULT
dxbc_init(struct dxbc
*dxbc
, UINT size
)
557 TRACE("dxbc %p, size %u.\n", dxbc
, size
);
559 /* use a good starting value for the size if none specified */
562 dxbc
->sections
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(*dxbc
->sections
));
565 ERR("Failed to allocate dxbc section memory\n");
566 return E_OUTOFMEMORY
;
575 HRESULT
dxbc_parse(const char *data
, SIZE_T data_size
, struct dxbc
*dxbc
)
577 const char *ptr
= data
;
580 DWORD tag
, total_size
, chunk_count
;
584 WARN("No data supplied.\n");
588 read_dword(&ptr
, &tag
);
589 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
593 WARN("Wrong tag.\n");
598 skip_dword_unknown(&ptr
, 4);
600 skip_dword_unknown(&ptr
, 1);
602 read_dword(&ptr
, &total_size
);
603 TRACE("total size: %#x\n", total_size
);
605 if (data_size
!= total_size
)
607 WARN("Wrong size supplied.\n");
608 return D3DERR_INVALIDCALL
;
611 read_dword(&ptr
, &chunk_count
);
612 TRACE("chunk count: %#x\n", chunk_count
);
614 hr
= dxbc_init(dxbc
, chunk_count
);
617 WARN("Failed to init dxbc\n");
621 for (i
= 0; i
< chunk_count
; ++i
)
623 DWORD chunk_tag
, chunk_size
;
624 const char *chunk_ptr
;
627 read_dword(&ptr
, &chunk_offset
);
628 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
630 chunk_ptr
= data
+ chunk_offset
;
632 read_dword(&chunk_ptr
, &chunk_tag
);
633 read_dword(&chunk_ptr
, &chunk_size
);
635 hr
= dxbc_add_section(dxbc
, chunk_tag
, chunk_ptr
, chunk_size
);
638 WARN("Failed to add section to dxbc\n");
646 void dxbc_destroy(struct dxbc
*dxbc
)
648 TRACE("dxbc %p.\n", dxbc
);
650 HeapFree(GetProcessHeap(), 0, dxbc
->sections
);
653 HRESULT
dxbc_write_blob(struct dxbc
*dxbc
, ID3DBlob
**blob
)
655 DWORD size
= 32, offset
= size
+ 4 * dxbc
->count
;
661 TRACE("dxbc %p, blob %p.\n", dxbc
, blob
);
663 for (i
= 0; i
< dxbc
->count
; ++i
)
665 size
+= 12 + dxbc
->sections
[i
].data_size
;
668 hr
= D3DCreateBlob(size
, &object
);
671 WARN("Failed to create blob\n");
675 ptr
= ID3D10Blob_GetBufferPointer(object
);
677 write_dword(&ptr
, TAG_DXBC
);
680 write_dword_unknown(&ptr
, 0);
681 write_dword_unknown(&ptr
, 0);
682 write_dword_unknown(&ptr
, 0);
683 write_dword_unknown(&ptr
, 0);
685 /* seems to be always 1 */
686 write_dword_unknown(&ptr
, 1);
689 write_dword(&ptr
, size
);
692 write_dword(&ptr
, dxbc
->count
);
694 /* write the chunk offsets */
695 for (i
= 0; i
< dxbc
->count
; ++i
)
697 write_dword(&ptr
, offset
);
698 offset
+= 8 + dxbc
->sections
[i
].data_size
;
701 /* write the chunks */
702 for (i
= 0; i
< dxbc
->count
; ++i
)
704 write_dword(&ptr
, dxbc
->sections
[i
].tag
);
705 write_dword(&ptr
, dxbc
->sections
[i
].data_size
);
706 memcpy(ptr
, dxbc
->sections
[i
].data
, dxbc
->sections
[i
].data_size
);
707 ptr
+= dxbc
->sections
[i
].data_size
;
710 TRACE("Created ID3DBlob %p\n", object
);
717 void compilation_message(struct compilation_messages
*msg
, const char *fmt
, va_list args
)
722 if (msg
->capacity
== 0)
724 msg
->string
= d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE
);
725 if (msg
->string
== NULL
)
727 ERR("Error allocating memory for parser messages\n");
730 msg
->capacity
= MESSAGEBUFFER_INITIAL_SIZE
;
735 rc
= vsnprintf(msg
->string
+ msg
->size
,
736 msg
->capacity
- msg
->size
, fmt
, args
);
738 if (rc
< 0 || rc
>= msg
->capacity
- msg
->size
)
740 size
= msg
->capacity
* 2;
741 buffer
= d3dcompiler_realloc(msg
->string
, size
);
744 ERR("Error reallocating memory for parser messages\n");
747 msg
->string
= buffer
;
748 msg
->capacity
= size
;
752 TRACE("%s", msg
->string
+ msg
->size
);
759 BOOL
add_declaration(struct hlsl_scope
*scope
, struct hlsl_ir_var
*decl
, BOOL local_var
)
761 struct hlsl_ir_var
*var
;
763 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
765 if (!strcmp(decl
->name
, var
->name
))
768 if (local_var
&& scope
->upper
->upper
== hlsl_ctx
.globals
)
770 /* Check whether the variable redefines a function parameter. */
771 LIST_FOR_EACH_ENTRY(var
, &scope
->upper
->vars
, struct hlsl_ir_var
, scope_entry
)
773 if (!strcmp(decl
->name
, var
->name
))
778 list_add_tail(&scope
->vars
, &decl
->scope_entry
);
782 struct hlsl_ir_var
*get_variable(struct hlsl_scope
*scope
, const char *name
)
784 struct hlsl_ir_var
*var
;
786 LIST_FOR_EACH_ENTRY(var
, &scope
->vars
, struct hlsl_ir_var
, scope_entry
)
788 if (!strcmp(name
, var
->name
))
793 return get_variable(scope
->upper
, name
);
796 void free_declaration(struct hlsl_ir_var
*decl
)
798 d3dcompiler_free((void *)decl
->name
);
799 d3dcompiler_free((void *)decl
->semantic
);
800 d3dcompiler_free(decl
);
803 BOOL
add_func_parameter(struct list
*list
, struct parse_parameter
*param
, const struct source_location
*loc
)
805 struct hlsl_ir_var
*decl
= d3dcompiler_alloc(sizeof(*decl
));
809 ERR("Out of memory.\n");
812 decl
->node
.type
= HLSL_IR_VAR
;
813 decl
->node
.data_type
= param
->type
;
814 decl
->node
.loc
= *loc
;
815 decl
->name
= param
->name
;
816 decl
->semantic
= param
->semantic
;
817 decl
->modifiers
= param
->modifiers
;
819 if (!add_declaration(hlsl_ctx
.cur_scope
, decl
, FALSE
))
821 free_declaration(decl
);
824 list_add_tail(list
, &decl
->node
.entry
);
828 struct hlsl_type
*new_hlsl_type(const char *name
, enum hlsl_type_class type_class
,
829 enum hlsl_base_type base_type
, unsigned dimx
, unsigned dimy
)
831 struct hlsl_type
*type
;
833 type
= d3dcompiler_alloc(sizeof(*type
));
836 ERR("Out of memory\n");
840 type
->type
= type_class
;
841 type
->base_type
= base_type
;
845 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
850 struct hlsl_type
*new_array_type(struct hlsl_type
*basic_type
, unsigned int array_size
)
852 struct hlsl_type
*type
= new_hlsl_type(NULL
, HLSL_CLASS_ARRAY
, HLSL_TYPE_FLOAT
, 1, 1);
857 type
->modifiers
= basic_type
->modifiers
;
858 type
->e
.array
.elements_count
= array_size
;
859 type
->e
.array
.type
= basic_type
;
863 struct hlsl_type
*get_type(struct hlsl_scope
*scope
, const char *name
, BOOL recursive
)
865 struct wine_rb_entry
*entry
= wine_rb_get(&scope
->types
, name
);
867 return WINE_RB_ENTRY_VALUE(entry
, struct hlsl_type
, scope_entry
);
869 if (recursive
&& scope
->upper
)
870 return get_type(scope
->upper
, name
, recursive
);
874 BOOL
find_function(const char *name
)
876 return wine_rb_get(&hlsl_ctx
.functions
, name
) != NULL
;
879 unsigned int components_count_type(struct hlsl_type
*type
)
881 unsigned int count
= 0;
882 struct hlsl_struct_field
*field
;
884 if (type
->type
<= HLSL_CLASS_LAST_NUMERIC
)
886 return type
->dimx
* type
->dimy
;
888 if (type
->type
== HLSL_CLASS_ARRAY
)
890 return components_count_type(type
->e
.array
.type
) * type
->e
.array
.elements_count
;
892 if (type
->type
!= HLSL_CLASS_STRUCT
)
894 ERR("Unexpected data type %s.\n", debug_hlsl_type(type
));
898 LIST_FOR_EACH_ENTRY(field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
900 count
+= components_count_type(field
->type
);
905 BOOL
compare_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
910 if (t1
->type
!= t2
->type
)
912 if (t1
->base_type
!= t2
->base_type
)
914 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
916 if ((t1
->modifiers
& HLSL_MODIFIERS_COMPARISON_MASK
)
917 != (t2
->modifiers
& HLSL_MODIFIERS_COMPARISON_MASK
))
919 if (t1
->dimx
!= t2
->dimx
)
921 if (t1
->dimy
!= t2
->dimy
)
923 if (t1
->type
== HLSL_CLASS_STRUCT
)
925 struct list
*t1cur
, *t2cur
;
926 struct hlsl_struct_field
*t1field
, *t2field
;
928 t1cur
= list_head(t1
->e
.elements
);
929 t2cur
= list_head(t2
->e
.elements
);
930 while (t1cur
&& t2cur
)
932 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
933 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
934 if (!compare_hlsl_types(t1field
->type
, t2field
->type
))
936 if (strcmp(t1field
->name
, t2field
->name
))
938 t1cur
= list_next(t1
->e
.elements
, t1cur
);
939 t2cur
= list_next(t2
->e
.elements
, t2cur
);
944 if (t1
->type
== HLSL_CLASS_ARRAY
)
945 return t1
->e
.array
.elements_count
== t2
->e
.array
.elements_count
946 && compare_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
951 struct hlsl_type
*clone_hlsl_type(struct hlsl_type
*old
)
953 struct hlsl_type
*type
;
954 struct hlsl_struct_field
*old_field
, *field
;
956 type
= d3dcompiler_alloc(sizeof(*type
));
959 ERR("Out of memory\n");
964 type
->name
= d3dcompiler_strdup(old
->name
);
967 d3dcompiler_free(type
);
971 type
->type
= old
->type
;
972 type
->base_type
= old
->base_type
;
973 type
->dimx
= old
->dimx
;
974 type
->dimy
= old
->dimy
;
975 type
->modifiers
= old
->modifiers
;
976 type
->sampler_dim
= old
->sampler_dim
;
979 case HLSL_CLASS_ARRAY
:
980 type
->e
.array
.type
= old
->e
.array
.type
;
981 type
->e
.array
.elements_count
= old
->e
.array
.elements_count
;
983 case HLSL_CLASS_STRUCT
:
984 type
->e
.elements
= d3dcompiler_alloc(sizeof(*type
->e
.elements
));
985 if (!type
->e
.elements
)
987 d3dcompiler_free((void *)type
->name
);
988 d3dcompiler_free(type
);
991 list_init(type
->e
.elements
);
992 LIST_FOR_EACH_ENTRY(old_field
, old
->e
.elements
, struct hlsl_struct_field
, entry
)
994 field
= d3dcompiler_alloc(sizeof(*field
));
997 LIST_FOR_EACH_ENTRY_SAFE(field
, old_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
999 d3dcompiler_free((void *)field
->semantic
);
1000 d3dcompiler_free((void *)field
->name
);
1001 d3dcompiler_free(field
);
1003 d3dcompiler_free(type
->e
.elements
);
1004 d3dcompiler_free((void *)type
->name
);
1005 d3dcompiler_free(type
);
1008 field
->type
= clone_hlsl_type(old_field
->type
);
1009 field
->name
= d3dcompiler_strdup(old_field
->name
);
1010 if (old_field
->semantic
)
1011 field
->semantic
= d3dcompiler_strdup(old_field
->semantic
);
1012 field
->modifiers
= old_field
->modifiers
;
1013 list_add_tail(type
->e
.elements
, &field
->entry
);
1020 list_add_tail(&hlsl_ctx
.types
, &type
->entry
);
1024 static BOOL
convertible_data_type(struct hlsl_type
*type
)
1026 return type
->type
!= HLSL_CLASS_OBJECT
;
1029 BOOL
compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1031 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1034 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1036 /* Scalar vars can be cast to pretty much everything */
1037 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1040 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1041 return t1
->dimx
>= t2
->dimx
;
1044 /* The other way around is true too i.e. whatever to scalar */
1045 if (t2
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->dimx
== 1 && t2
->dimy
== 1)
1048 if (t1
->type
== HLSL_CLASS_ARRAY
)
1050 if (compare_hlsl_types(t1
->e
.array
.type
, t2
))
1051 /* e.g. float4[3] to float4 is allowed */
1054 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1055 return components_count_type(t1
) >= components_count_type(t2
);
1057 return components_count_type(t1
) == components_count_type(t2
);
1060 if (t1
->type
== HLSL_CLASS_STRUCT
)
1061 return components_count_type(t1
) >= components_count_type(t2
);
1063 if (t2
->type
== HLSL_CLASS_ARRAY
|| t2
->type
== HLSL_CLASS_STRUCT
)
1064 return components_count_type(t1
) == components_count_type(t2
);
1066 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1068 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
&& t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1071 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1072 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1073 && components_count_type(t1
) == components_count_type(t2
))
1078 if (components_count_type(t1
) >= components_count_type(t2
))
1083 static BOOL
implicit_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1085 if (!convertible_data_type(t1
) || !convertible_data_type(t2
))
1088 if (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1090 /* Scalar vars can be converted to any other numeric data type */
1091 if (t1
->dimx
== 1 && t1
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1093 /* The other way around is true too */
1094 if (t2
->dimx
== 1 && t2
->dimy
== 1 && t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1098 if (t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
== HLSL_CLASS_ARRAY
)
1100 return components_count_type(t1
) == components_count_type(t2
);
1103 if ((t1
->type
== HLSL_CLASS_ARRAY
&& t2
->type
<= HLSL_CLASS_LAST_NUMERIC
)
1104 || (t1
->type
<= HLSL_CLASS_LAST_NUMERIC
&& t2
->type
== HLSL_CLASS_ARRAY
))
1106 /* e.g. float4[3] to float4 is allowed */
1107 if (t1
->type
== HLSL_CLASS_ARRAY
&& compare_hlsl_types(t1
->e
.array
.type
, t2
))
1109 if (components_count_type(t1
) == components_count_type(t2
))
1114 if (t1
->type
<= HLSL_CLASS_VECTOR
&& t2
->type
<= HLSL_CLASS_VECTOR
)
1116 if (t1
->dimx
>= t2
->dimx
)
1121 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1123 if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
1124 && t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1127 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1128 if ((t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1129 && components_count_type(t1
) == components_count_type(t2
))
1134 if (t1
->type
== HLSL_CLASS_STRUCT
&& t2
->type
== HLSL_CLASS_STRUCT
)
1135 return compare_hlsl_types(t1
, t2
);
1140 static BOOL
expr_compatible_data_types(struct hlsl_type
*t1
, struct hlsl_type
*t2
)
1142 if (t1
->base_type
> HLSL_TYPE_LAST_SCALAR
|| t2
->base_type
> HLSL_TYPE_LAST_SCALAR
)
1145 /* Scalar vars can be converted to pretty much everything */
1146 if ((t1
->dimx
== 1 && t1
->dimy
== 1) || (t2
->dimx
== 1 && t2
->dimy
== 1))
1149 if (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1152 if (t1
->type
== HLSL_CLASS_MATRIX
|| t2
->type
== HLSL_CLASS_MATRIX
)
1154 /* Matrix-vector conversion is apparently allowed if either they have the same components
1155 count or the matrix is nx1 or 1xn */
1156 if (t1
->type
== HLSL_CLASS_VECTOR
|| t2
->type
== HLSL_CLASS_VECTOR
)
1158 if (components_count_type(t1
) == components_count_type(t2
))
1161 return (t1
->type
== HLSL_CLASS_MATRIX
&& (t1
->dimx
== 1 || t1
->dimy
== 1))
1162 || (t2
->type
== HLSL_CLASS_MATRIX
&& (t2
->dimx
== 1 || t2
->dimy
== 1));
1166 if ((t1
->dimx
>= t2
->dimx
&& t1
->dimy
>= t2
->dimy
)
1167 || (t1
->dimx
<= t2
->dimx
&& t1
->dimy
<= t2
->dimy
))
1174 static enum hlsl_base_type
expr_common_base_type(enum hlsl_base_type t1
, enum hlsl_base_type t2
)
1176 enum hlsl_base_type types
[] =
1185 int t1_idx
= -1, t2_idx
= -1, i
;
1187 for (i
= 0; i
< sizeof(types
) / sizeof(types
[0]); ++i
)
1189 /* Always convert away from HLSL_TYPE_HALF */
1191 t1_idx
= t1
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1193 t2_idx
= t2
== HLSL_TYPE_HALF
? i
+ 1 : i
;
1195 if (t1_idx
!= -1 && t2_idx
!= -1)
1198 if (t1_idx
== -1 || t2_idx
== -1)
1200 FIXME("Unexpected base type.\n");
1201 return HLSL_TYPE_FLOAT
;
1203 return t1_idx
>= t2_idx
? t1
: t2
;
1206 static struct hlsl_type
*expr_common_type(struct hlsl_type
*t1
, struct hlsl_type
*t2
,
1207 struct source_location
*loc
)
1209 enum hlsl_type_class type
;
1210 enum hlsl_base_type base
;
1211 unsigned int dimx
, dimy
;
1213 if (t1
->type
> HLSL_CLASS_LAST_NUMERIC
|| t2
->type
> HLSL_CLASS_LAST_NUMERIC
)
1215 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1216 "non scalar/vector/matrix data type in expression");
1220 if (compare_hlsl_types(t1
, t2
))
1223 if (!expr_compatible_data_types(t1
, t2
))
1225 hlsl_report_message(loc
->file
, loc
->line
, loc
->col
, HLSL_LEVEL_ERROR
,
1226 "expression data types are incompatible");
1230 if (t1
->base_type
== t2
->base_type
)
1231 base
= t1
->base_type
;
1233 base
= expr_common_base_type(t1
->base_type
, t2
->base_type
);
1235 if (t1
->dimx
== 1 && t1
->dimy
== 1)
1241 else if (t2
->dimx
== 1 && t2
->dimy
== 1)
1247 else if (t1
->type
== HLSL_CLASS_MATRIX
&& t2
->type
== HLSL_CLASS_MATRIX
)
1249 type
= HLSL_CLASS_MATRIX
;
1250 dimx
= min(t1
->dimx
, t2
->dimx
);
1251 dimy
= min(t1
->dimy
, t2
->dimy
);
1255 /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1256 unsigned int max_dim_1
, max_dim_2
;
1258 max_dim_1
= max(t1
->dimx
, t1
->dimy
);
1259 max_dim_2
= max(t2
->dimx
, t2
->dimy
);
1260 if (t1
->dimx
* t1
->dimy
== t2
->dimx
* t2
->dimy
)
1262 type
= HLSL_CLASS_VECTOR
;
1263 dimx
= max(t1
->dimx
, t2
->dimx
);
1266 else if (max_dim_1
<= max_dim_2
)
1269 if (type
== HLSL_CLASS_VECTOR
)
1283 if (type
== HLSL_CLASS_VECTOR
)
1296 return new_hlsl_type(NULL
, type
, base
, dimx
, dimy
);
1299 static struct hlsl_ir_node
*implicit_conversion(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1300 struct source_location
*loc
)
1302 struct hlsl_ir_expr
*cast
;
1303 struct hlsl_ir_node
*operands
[3];
1305 if (compare_hlsl_types(node
->data_type
, type
))
1307 TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type
));
1309 operands
[1] = operands
[2] = NULL
;
1310 cast
= new_expr(HLSL_IR_UNOP_CAST
, operands
, loc
);
1313 cast
->node
.data_type
= type
;
1317 struct hlsl_ir_expr
*new_expr(enum hlsl_ir_expr_op op
, struct hlsl_ir_node
**operands
,
1318 struct source_location
*loc
)
1320 struct hlsl_ir_expr
*expr
= d3dcompiler_alloc(sizeof(*expr
));
1321 struct hlsl_type
*type
;
1326 ERR("Out of memory\n");
1329 expr
->node
.type
= HLSL_IR_EXPR
;
1330 expr
->node
.loc
= *loc
;
1331 type
= operands
[0]->data_type
;
1332 for (i
= 1; i
<= 2; ++i
)
1336 type
= expr_common_type(type
, operands
[i
]->data_type
, loc
);
1339 d3dcompiler_free(expr
);
1343 for (i
= 0; i
<= 2; ++i
)
1347 if (compare_hlsl_types(operands
[i
]->data_type
, type
))
1349 TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands
[i
]->data_type
), debug_hlsl_type(type
));
1350 if (operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= 1
1351 && operands
[i
]->data_type
->dimx
* operands
[i
]->data_type
->dimy
!= type
->dimx
* type
->dimy
)
1353 hlsl_report_message(operands
[i
]->loc
.file
,
1354 operands
[i
]->loc
.line
, operands
[i
]->loc
.col
, HLSL_LEVEL_WARNING
,
1355 "implicit truncation of vector/matrix type");
1357 operands
[i
] = implicit_conversion(operands
[i
], type
, &operands
[i
]->loc
);
1360 ERR("Impossible to convert expression operand %u to %s\n", i
+ 1, debug_hlsl_type(type
));
1361 d3dcompiler_free(expr
);
1365 expr
->node
.data_type
= type
;
1367 expr
->operands
[0] = operands
[0];
1368 expr
->operands
[1] = operands
[1];
1369 expr
->operands
[2] = operands
[2];
1374 struct hlsl_ir_expr
*new_cast(struct hlsl_ir_node
*node
, struct hlsl_type
*type
,
1375 struct source_location
*loc
)
1377 struct hlsl_ir_expr
*cast
;
1378 struct hlsl_ir_node
*operands
[3];
1381 operands
[1] = operands
[2] = NULL
;
1382 cast
= new_expr(HLSL_IR_UNOP_CAST
, operands
, loc
);
1384 cast
->node
.data_type
= type
;
1388 struct hlsl_ir_expr
*hlsl_mul(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1389 struct source_location
*loc
)
1391 struct hlsl_ir_expr
*expr
;
1392 struct hlsl_ir_node
*ops
[3];
1397 expr
= new_expr(HLSL_IR_BINOP_MUL
, ops
, loc
);
1401 struct hlsl_ir_expr
*hlsl_div(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1402 struct source_location
*loc
)
1404 struct hlsl_ir_expr
*expr
;
1405 struct hlsl_ir_node
*ops
[3];
1410 expr
= new_expr(HLSL_IR_BINOP_DIV
, ops
, loc
);
1414 struct hlsl_ir_expr
*hlsl_mod(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1415 struct source_location
*loc
)
1417 struct hlsl_ir_expr
*expr
;
1418 struct hlsl_ir_node
*ops
[3];
1423 expr
= new_expr(HLSL_IR_BINOP_MOD
, ops
, loc
);
1427 struct hlsl_ir_expr
*hlsl_add(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1428 struct source_location
*loc
)
1430 struct hlsl_ir_expr
*expr
;
1431 struct hlsl_ir_node
*ops
[3];
1436 expr
= new_expr(HLSL_IR_BINOP_ADD
, ops
, loc
);
1440 struct hlsl_ir_expr
*hlsl_sub(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1441 struct source_location
*loc
)
1443 struct hlsl_ir_expr
*expr
;
1444 struct hlsl_ir_node
*ops
[3];
1449 expr
= new_expr(HLSL_IR_BINOP_SUB
, ops
, loc
);
1453 struct hlsl_ir_expr
*hlsl_lt(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1454 struct source_location
*loc
)
1456 struct hlsl_ir_expr
*expr
;
1457 struct hlsl_ir_node
*ops
[3];
1462 expr
= new_expr(HLSL_IR_BINOP_LESS
, ops
, loc
);
1466 struct hlsl_ir_expr
*hlsl_gt(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1467 struct source_location
*loc
)
1469 struct hlsl_ir_expr
*expr
;
1470 struct hlsl_ir_node
*ops
[3];
1475 expr
= new_expr(HLSL_IR_BINOP_GREATER
, ops
, loc
);
1479 struct hlsl_ir_expr
*hlsl_le(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1480 struct source_location
*loc
)
1482 struct hlsl_ir_expr
*expr
;
1483 struct hlsl_ir_node
*ops
[3];
1488 expr
= new_expr(HLSL_IR_BINOP_LEQUAL
, ops
, loc
);
1492 struct hlsl_ir_expr
*hlsl_ge(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1493 struct source_location
*loc
)
1495 struct hlsl_ir_expr
*expr
;
1496 struct hlsl_ir_node
*ops
[3];
1501 expr
= new_expr(HLSL_IR_BINOP_GEQUAL
, ops
, loc
);
1505 struct hlsl_ir_expr
*hlsl_eq(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1506 struct source_location
*loc
)
1508 struct hlsl_ir_expr
*expr
;
1509 struct hlsl_ir_node
*ops
[3];
1514 expr
= new_expr(HLSL_IR_BINOP_EQUAL
, ops
, loc
);
1518 struct hlsl_ir_expr
*hlsl_ne(struct hlsl_ir_node
*op1
, struct hlsl_ir_node
*op2
,
1519 struct source_location
*loc
)
1521 struct hlsl_ir_expr
*expr
;
1522 struct hlsl_ir_node
*ops
[3];
1527 expr
= new_expr(HLSL_IR_BINOP_NEQUAL
, ops
, loc
);
1531 struct hlsl_ir_deref
*new_var_deref(struct hlsl_ir_var
*var
)
1533 struct hlsl_ir_deref
*deref
= d3dcompiler_alloc(sizeof(*deref
));
1537 ERR("Out of memory.\n");
1540 deref
->node
.type
= HLSL_IR_DEREF
;
1541 deref
->node
.data_type
= var
->node
.data_type
;
1542 deref
->type
= HLSL_IR_DEREF_VAR
;
1547 struct hlsl_ir_deref
*new_record_deref(struct hlsl_ir_node
*record
, struct hlsl_struct_field
*field
)
1549 struct hlsl_ir_deref
*deref
= d3dcompiler_alloc(sizeof(*deref
));
1553 ERR("Out of memory.\n");
1556 deref
->node
.type
= HLSL_IR_DEREF
;
1557 deref
->node
.data_type
= field
->type
;
1558 deref
->type
= HLSL_IR_DEREF_RECORD
;
1559 if (record
->type
== HLSL_IR_VAR
)
1560 deref
->v
.record
.record
= &new_var_deref(var_from_node(record
))->node
;
1562 deref
->v
.record
.record
= record
;
1563 deref
->v
.record
.field
= field
;
1567 static enum hlsl_ir_expr_op
op_from_assignment(enum parse_assign_op op
)
1569 static const enum hlsl_ir_expr_op ops
[] =
1577 HLSL_IR_BINOP_LSHIFT
,
1578 HLSL_IR_BINOP_RSHIFT
,
1579 HLSL_IR_BINOP_BIT_AND
,
1580 HLSL_IR_BINOP_BIT_OR
,
1581 HLSL_IR_BINOP_BIT_XOR
,
1587 struct hlsl_ir_node
*make_assignment(struct hlsl_ir_node
*left
, enum parse_assign_op assign_op
,
1588 DWORD writemask
, struct hlsl_ir_node
*right
)
1590 struct hlsl_ir_expr
*expr
;
1591 struct hlsl_ir_assignment
*assign
= d3dcompiler_alloc(sizeof(*assign
));
1592 struct hlsl_type
*type
;
1593 struct hlsl_ir_node
*lhs
, *rhs
;
1597 ERR("Out of memory\n");
1601 TRACE("Creating proper assignment expression.\n");
1603 if (writemask
== BWRITERSP_WRITEMASK_ALL
)
1604 type
= left
->data_type
;
1607 FIXME("Assignments with writemasks not supported yet.\n");
1610 assign
->node
.type
= HLSL_IR_ASSIGNMENT
;
1611 assign
->node
.loc
= left
->loc
;
1612 assign
->node
.data_type
= type
;
1613 assign
->writemask
= writemask
;
1614 FIXME("Check for casts in the lhs.\n");
1617 if (lhs
->type
== HLSL_IR_VAR
)
1619 struct hlsl_ir_deref
*lhs_deref
= new_var_deref(var_from_node(lhs
));
1620 lhs
= &lhs_deref
->node
;
1622 /* FIXME: check for invalid writemasks on the lhs. */
1624 if (!compare_hlsl_types(type
, rhs
->data_type
))
1626 struct hlsl_ir_node
*converted_rhs
;
1628 if (!implicit_compatible_data_types(rhs
->data_type
, type
))
1630 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_ERROR
,
1631 "can't implicitly convert %s to %s",
1632 debug_hlsl_type(rhs
->data_type
), debug_hlsl_type(type
));
1635 d3dcompiler_free(assign
);
1638 if (lhs
->data_type
->dimx
* lhs
->data_type
->dimy
< rhs
->data_type
->dimx
* rhs
->data_type
->dimy
)
1639 hlsl_report_message(rhs
->loc
.file
, rhs
->loc
.line
, rhs
->loc
.col
, HLSL_LEVEL_WARNING
,
1640 "implicit truncation of vector type");
1642 converted_rhs
= implicit_conversion(rhs
, type
, &rhs
->loc
);
1645 ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type
));
1648 d3dcompiler_free(assign
);
1651 rhs
= converted_rhs
;
1655 if (assign_op
!= ASSIGN_OP_ASSIGN
)
1657 struct hlsl_ir_node
*operands
[3];
1658 enum hlsl_ir_expr_op op
= op_from_assignment(assign_op
);
1660 if (lhs
->type
!= HLSL_IR_DEREF
|| deref_from_node(lhs
)->type
!= HLSL_IR_DEREF_VAR
)
1662 FIXME("LHS expression not supported in compound assignments yet.\n");
1667 struct hlsl_ir_deref
*lhs_deref
= deref_from_node(lhs
), *new_deref
;
1669 TRACE("Adding an expression for the compound assignment.\n");
1670 new_deref
= new_var_deref(lhs_deref
->v
.var
);
1671 operands
[0] = &new_deref
->node
;
1674 expr
= new_expr(op
, operands
, &left
->loc
);
1675 assign
->rhs
= &expr
->node
;
1681 return &assign
->node
;
1684 static int compare_hlsl_types_rb(const void *key
, const struct wine_rb_entry
*entry
)
1686 const char *name
= (const char *)key
;
1687 const struct hlsl_type
*type
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_type
, scope_entry
);
1689 if (name
== type
->name
)
1692 if (!name
|| !type
->name
)
1694 ERR("hlsl_type without a name in a scope?\n");
1697 return strcmp(name
, type
->name
);
1700 static inline void *d3dcompiler_alloc_rb(size_t size
)
1702 return d3dcompiler_alloc(size
);
1705 static inline void *d3dcompiler_realloc_rb(void *ptr
, size_t size
)
1707 return d3dcompiler_realloc(ptr
, size
);
1710 static inline void d3dcompiler_free_rb(void *ptr
)
1712 d3dcompiler_free(ptr
);
1714 static const struct wine_rb_functions hlsl_type_rb_funcs
=
1716 d3dcompiler_alloc_rb
,
1717 d3dcompiler_realloc_rb
,
1718 d3dcompiler_free_rb
,
1719 compare_hlsl_types_rb
,
1722 void push_scope(struct hlsl_parse_ctx
*ctx
)
1724 struct hlsl_scope
*new_scope
= d3dcompiler_alloc(sizeof(*new_scope
));
1728 ERR("Out of memory!\n");
1731 TRACE("Pushing a new scope\n");
1732 list_init(&new_scope
->vars
);
1733 if (wine_rb_init(&new_scope
->types
, &hlsl_type_rb_funcs
) == -1)
1735 ERR("Failed to initialize types rbtree.\n");
1736 d3dcompiler_free(new_scope
);
1739 new_scope
->upper
= ctx
->cur_scope
;
1740 ctx
->cur_scope
= new_scope
;
1741 list_add_tail(&ctx
->scopes
, &new_scope
->entry
);
1744 BOOL
pop_scope(struct hlsl_parse_ctx
*ctx
)
1746 struct hlsl_scope
*prev_scope
= ctx
->cur_scope
->upper
;
1750 TRACE("Popping current scope\n");
1751 ctx
->cur_scope
= prev_scope
;
1755 struct hlsl_ir_function_decl
*new_func_decl(struct hlsl_type
*return_type
, struct list
*parameters
)
1757 struct hlsl_ir_function_decl
*decl
;
1759 decl
= d3dcompiler_alloc(sizeof(*decl
));
1762 ERR("Out of memory.\n");
1765 decl
->node
.type
= HLSL_IR_FUNCTION_DECL
;
1766 decl
->node
.data_type
= return_type
;
1767 decl
->parameters
= parameters
;
1772 static int compare_param_hlsl_types(const struct hlsl_type
*t1
, const struct hlsl_type
*t2
)
1774 if (t1
->type
!= t2
->type
)
1776 if (!((t1
->type
== HLSL_CLASS_SCALAR
&& t2
->type
== HLSL_CLASS_VECTOR
)
1777 || (t1
->type
== HLSL_CLASS_VECTOR
&& t2
->type
== HLSL_CLASS_SCALAR
)))
1778 return t1
->type
- t2
->type
;
1780 if (t1
->base_type
!= t2
->base_type
)
1781 return t1
->base_type
- t2
->base_type
;
1782 if (t1
->base_type
== HLSL_TYPE_SAMPLER
&& t1
->sampler_dim
!= t2
->sampler_dim
)
1783 return t1
->sampler_dim
- t2
->sampler_dim
;
1784 if (t1
->dimx
!= t2
->dimx
)
1785 return t1
->dimx
- t2
->dimx
;
1786 if (t1
->dimy
!= t2
->dimy
)
1787 return t1
->dimx
- t2
->dimx
;
1788 if (t1
->type
== HLSL_CLASS_STRUCT
)
1790 struct list
*t1cur
, *t2cur
;
1791 struct hlsl_struct_field
*t1field
, *t2field
;
1794 t1cur
= list_head(t1
->e
.elements
);
1795 t2cur
= list_head(t2
->e
.elements
);
1796 while (t1cur
&& t2cur
)
1798 t1field
= LIST_ENTRY(t1cur
, struct hlsl_struct_field
, entry
);
1799 t2field
= LIST_ENTRY(t2cur
, struct hlsl_struct_field
, entry
);
1800 if ((r
= compare_param_hlsl_types(t1field
->type
, t2field
->type
)))
1802 if ((r
= strcmp(t1field
->name
, t2field
->name
)))
1804 t1cur
= list_next(t1
->e
.elements
, t1cur
);
1805 t2cur
= list_next(t2
->e
.elements
, t2cur
);
1808 return t1cur
? 1 : -1;
1811 if (t1
->type
== HLSL_CLASS_ARRAY
)
1813 if (t1
->e
.array
.elements_count
!= t2
->e
.array
.elements_count
)
1814 return t1
->e
.array
.elements_count
- t2
->e
.array
.elements_count
;
1815 return compare_param_hlsl_types(t1
->e
.array
.type
, t2
->e
.array
.type
);
1821 static int compare_function_decl_rb(const void *key
, const struct wine_rb_entry
*entry
)
1823 const struct list
*params
= (const struct list
*)key
;
1824 const struct hlsl_ir_function_decl
*decl
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_ir_function_decl
, entry
);
1825 int params_count
= params
? list_count(params
) : 0;
1826 int decl_params_count
= decl
->parameters
? list_count(decl
->parameters
) : 0;
1828 struct list
*p1cur
, *p2cur
;
1830 if (params_count
!= decl_params_count
)
1831 return params_count
- decl_params_count
;
1833 p1cur
= params
? list_head(params
) : NULL
;
1834 p2cur
= decl
->parameters
? list_head(decl
->parameters
) : NULL
;
1835 while (p1cur
&& p2cur
)
1837 struct hlsl_ir_var
*p1
, *p2
;
1838 p1
= LIST_ENTRY(p1cur
, struct hlsl_ir_var
, node
.entry
);
1839 p2
= LIST_ENTRY(p2cur
, struct hlsl_ir_var
, node
.entry
);
1840 if ((r
= compare_param_hlsl_types(p1
->node
.data_type
, p2
->node
.data_type
)))
1842 p1cur
= list_next(params
, p1cur
);
1843 p2cur
= list_next(decl
->parameters
, p2cur
);
1848 static const struct wine_rb_functions hlsl_ir_function_decl_rb_funcs
=
1850 d3dcompiler_alloc_rb
,
1851 d3dcompiler_realloc_rb
,
1852 d3dcompiler_free_rb
,
1853 compare_function_decl_rb
,
1856 static int compare_function_rb(const void *key
, const struct wine_rb_entry
*entry
)
1858 const char *name
= (const char *)key
;
1859 const struct hlsl_ir_function
*func
= WINE_RB_ENTRY_VALUE(entry
, const struct hlsl_ir_function
,entry
);
1861 return strcmp(name
, func
->name
);
1864 static const struct wine_rb_functions function_rb_funcs
=
1866 d3dcompiler_alloc_rb
,
1867 d3dcompiler_realloc_rb
,
1868 d3dcompiler_free_rb
,
1869 compare_function_rb
,
1872 void init_functions_tree(struct wine_rb_tree
*funcs
)
1874 if (wine_rb_init(&hlsl_ctx
.functions
, &function_rb_funcs
) == -1)
1875 ERR("Failed to initialize functions rbtree.\n");
1878 static const char *debug_base_type(const struct hlsl_type
*type
)
1880 const char *name
= "(unknown)";
1882 switch (type
->base_type
)
1884 case HLSL_TYPE_FLOAT
: name
= "float"; break;
1885 case HLSL_TYPE_HALF
: name
= "half"; break;
1886 case HLSL_TYPE_DOUBLE
: name
= "double"; break;
1887 case HLSL_TYPE_INT
: name
= "int"; break;
1888 case HLSL_TYPE_UINT
: name
= "uint"; break;
1889 case HLSL_TYPE_BOOL
: name
= "bool"; break;
1890 case HLSL_TYPE_SAMPLER
:
1891 switch (type
->sampler_dim
)
1893 case HLSL_SAMPLER_DIM_GENERIC
: name
= "sampler"; break;
1894 case HLSL_SAMPLER_DIM_1D
: name
= "sampler1D"; break;
1895 case HLSL_SAMPLER_DIM_2D
: name
= "sampler2D"; break;
1896 case HLSL_SAMPLER_DIM_3D
: name
= "sampler3D"; break;
1897 case HLSL_SAMPLER_DIM_CUBE
: name
= "samplerCUBE"; break;
1901 FIXME("Unhandled case %u\n", type
->base_type
);
1906 const char *debug_hlsl_type(const struct hlsl_type
*type
)
1911 return debugstr_a(type
->name
);
1913 if (type
->type
== HLSL_CLASS_STRUCT
)
1914 return "<anonymous struct>";
1916 if (type
->type
== HLSL_CLASS_ARRAY
)
1918 name
= debug_base_type(type
->e
.array
.type
);
1919 return wine_dbg_sprintf("%s[%u]", name
, type
->e
.array
.elements_count
);
1922 name
= debug_base_type(type
);
1924 if (type
->type
== HLSL_CLASS_SCALAR
)
1925 return wine_dbg_sprintf("%s", name
);
1926 if (type
->type
== HLSL_CLASS_VECTOR
)
1927 return wine_dbg_sprintf("%s%u", name
, type
->dimx
);
1928 if (type
->type
== HLSL_CLASS_MATRIX
)
1929 return wine_dbg_sprintf("%s%ux%u", name
, type
->dimx
, type
->dimy
);
1930 return "unexpected_type";
1933 const char *debug_modifiers(DWORD modifiers
)
1938 if (modifiers
& HLSL_STORAGE_EXTERN
)
1939 strcat(string
, " extern"); /* 7 */
1940 if (modifiers
& HLSL_STORAGE_NOINTERPOLATION
)
1941 strcat(string
, " nointerpolation"); /* 16 */
1942 if (modifiers
& HLSL_MODIFIER_PRECISE
)
1943 strcat(string
, " precise"); /* 8 */
1944 if (modifiers
& HLSL_STORAGE_SHARED
)
1945 strcat(string
, " shared"); /* 7 */
1946 if (modifiers
& HLSL_STORAGE_GROUPSHARED
)
1947 strcat(string
, " groupshared"); /* 12 */
1948 if (modifiers
& HLSL_STORAGE_STATIC
)
1949 strcat(string
, " static"); /* 7 */
1950 if (modifiers
& HLSL_STORAGE_UNIFORM
)
1951 strcat(string
, " uniform"); /* 8 */
1952 if (modifiers
& HLSL_STORAGE_VOLATILE
)
1953 strcat(string
, " volatile"); /* 9 */
1954 if (modifiers
& HLSL_MODIFIER_CONST
)
1955 strcat(string
, " const"); /* 6 */
1956 if (modifiers
& HLSL_MODIFIER_ROW_MAJOR
)
1957 strcat(string
, " row_major"); /* 10 */
1958 if (modifiers
& HLSL_MODIFIER_COLUMN_MAJOR
)
1959 strcat(string
, " column_major"); /* 13 */
1960 if ((modifiers
& (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
)) == (HLSL_MODIFIER_IN
| HLSL_MODIFIER_OUT
))
1961 strcat(string
, " inout"); /* 6 */
1962 else if (modifiers
& HLSL_MODIFIER_IN
)
1963 strcat(string
, " in"); /* 3 */
1964 else if (modifiers
& HLSL_MODIFIER_OUT
)
1965 strcat(string
, " out"); /* 4 */
1967 return wine_dbg_sprintf("%s", string
[0] ? string
+ 1 : "");
1970 static const char *debug_node_type(enum hlsl_ir_node_type type
)
1972 const char *names
[] =
1975 "HLSL_IR_ASSIGNMENT",
1977 "HLSL_IR_CONSTRUCTOR",
1980 "HLSL_IR_FUNCTION_DECL",
1986 if (type
>= sizeof(names
) / sizeof(names
[0]))
1987 return "Unexpected node type";
1991 static void debug_dump_instr(const struct hlsl_ir_node
*instr
);
1993 static void debug_dump_instr_list(const struct list
*list
)
1995 struct hlsl_ir_node
*instr
;
1997 LIST_FOR_EACH_ENTRY(instr
, list
, struct hlsl_ir_node
, entry
)
1999 debug_dump_instr(instr
);
2004 static void debug_dump_ir_var(const struct hlsl_ir_var
*var
)
2007 TRACE("%s ", debug_modifiers(var
->modifiers
));
2008 TRACE("%s %s", debug_hlsl_type(var
->node
.data_type
), var
->name
);
2010 TRACE(" : %s", debugstr_a(var
->semantic
));
2013 static void debug_dump_ir_deref(const struct hlsl_ir_deref
*deref
)
2015 switch (deref
->type
)
2017 case HLSL_IR_DEREF_VAR
:
2019 debug_dump_ir_var(deref
->v
.var
);
2022 case HLSL_IR_DEREF_ARRAY
:
2023 debug_dump_instr(deref
->v
.array
.array
);
2025 debug_dump_instr(deref
->v
.array
.index
);
2028 case HLSL_IR_DEREF_RECORD
:
2029 debug_dump_instr(deref
->v
.record
.record
);
2030 TRACE(".%s", debugstr_a(deref
->v
.record
.field
->name
));
2035 static void debug_dump_ir_constant(const struct hlsl_ir_constant
*constant
)
2037 struct hlsl_type
*type
= constant
->node
.data_type
;
2040 if (type
->dimy
!= 1)
2042 for (y
= 0; y
< type
->dimy
; ++y
)
2044 if (type
->dimx
!= 1)
2046 for (x
= 0; x
< type
->dimx
; ++x
)
2048 switch (type
->base_type
)
2050 case HLSL_TYPE_FLOAT
:
2051 TRACE("%g ", (double)constant
->v
.value
.f
[y
* type
->dimx
+ x
]);
2053 case HLSL_TYPE_DOUBLE
:
2054 TRACE("%g ", constant
->v
.value
.d
[y
* type
->dimx
+ x
]);
2057 TRACE("%d ", constant
->v
.value
.i
[y
* type
->dimx
+ x
]);
2059 case HLSL_TYPE_UINT
:
2060 TRACE("%u ", constant
->v
.value
.u
[y
* type
->dimx
+ x
]);
2062 case HLSL_TYPE_BOOL
:
2063 TRACE("%s ", constant
->v
.value
.b
[y
* type
->dimx
+ x
] == FALSE
? "false" : "true");
2066 TRACE("Constants of type %s not supported\n", debug_base_type(type
));
2069 if (type
->dimx
!= 1)
2072 if (type
->dimy
!= 1)
2076 static const char *debug_expr_op(const struct hlsl_ir_expr
*expr
)
2078 static const char *op_names
[] =
2146 if (expr
->op
== HLSL_IR_UNOP_CAST
)
2147 return debug_hlsl_type(expr
->node
.data_type
);
2149 return op_names
[expr
->op
];
2152 /* Dumps the expression in a prefix "operator (operands)" form */
2153 static void debug_dump_ir_expr(const struct hlsl_ir_expr
*expr
)
2157 TRACE("%s (", debug_expr_op(expr
));
2158 for (i
= 0; i
< 3 && expr
->operands
[i
]; ++i
)
2160 debug_dump_instr(expr
->operands
[i
]);
2166 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor
*constructor
)
2168 struct hlsl_ir_node
*arg
;
2170 TRACE("%s (", debug_hlsl_type(constructor
->node
.data_type
));
2171 LIST_FOR_EACH_ENTRY(arg
, constructor
->arguments
, struct hlsl_ir_node
, entry
)
2173 debug_dump_instr(arg
);
2179 static const char *debug_writemask(DWORD writemask
)
2181 char string
[5], components
[] = {'x', 'y', 'z', 'w'};
2182 unsigned int i
= 0, pos
= 0;
2187 string
[pos
++] = components
[i
];
2192 return wine_dbg_sprintf(".%s", string
);
2195 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment
*assign
)
2198 debug_dump_instr(assign
->lhs
);
2199 if (assign
->writemask
!= BWRITERSP_WRITEMASK_ALL
)
2200 TRACE("%s", debug_writemask(assign
->writemask
));
2202 debug_dump_instr(assign
->rhs
);
2206 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle
*swizzle
)
2210 debug_dump_instr(swizzle
->val
);
2212 if (swizzle
->val
->data_type
->dimy
> 1)
2214 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
2215 TRACE("_m%u%u", (swizzle
->swizzle
>> i
* 8) & 0xf, (swizzle
->swizzle
>> (i
* 8 + 4)) & 0xf);
2219 char c
[] = {'x', 'y', 'z', 'w'};
2221 for (i
= 0; i
< swizzle
->node
.data_type
->dimx
; ++i
)
2222 TRACE("%c", c
[(swizzle
->swizzle
>> i
* 2) & 0x3]);
2226 static void debug_dump_ir_jump(const struct hlsl_ir_jump
*jump
)
2230 case HLSL_IR_JUMP_BREAK
:
2233 case HLSL_IR_JUMP_CONTINUE
:
2236 case HLSL_IR_JUMP_DISCARD
:
2239 case HLSL_IR_JUMP_RETURN
:
2241 if (jump
->return_value
)
2242 debug_dump_instr(jump
->return_value
);
2248 static void debug_dump_ir_if(const struct hlsl_ir_if
*if_node
)
2251 debug_dump_instr(if_node
->condition
);
2253 debug_dump_instr_list(if_node
->then_instrs
);
2255 if (if_node
->else_instrs
)
2258 debug_dump_instr_list(if_node
->else_instrs
);
2263 static void debug_dump_instr(const struct hlsl_ir_node
*instr
)
2265 switch (instr
->type
)
2268 debug_dump_ir_expr(expr_from_node(instr
));
2271 debug_dump_ir_deref(deref_from_node(instr
));
2273 case HLSL_IR_CONSTANT
:
2274 debug_dump_ir_constant(constant_from_node(instr
));
2276 case HLSL_IR_ASSIGNMENT
:
2277 debug_dump_ir_assignment(assignment_from_node(instr
));
2279 case HLSL_IR_SWIZZLE
:
2280 debug_dump_ir_swizzle(swizzle_from_node(instr
));
2282 case HLSL_IR_CONSTRUCTOR
:
2283 debug_dump_ir_constructor(constructor_from_node(instr
));
2286 debug_dump_ir_jump(jump_from_node(instr
));
2289 debug_dump_ir_if(if_from_node(instr
));
2292 TRACE("<No dump function for %s>", debug_node_type(instr
->type
));
2296 void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl
*func
)
2298 struct hlsl_ir_var
*param
;
2300 TRACE("Dumping function %s.\n", debugstr_a(func
->func
->name
));
2301 TRACE("Function parameters:\n");
2302 LIST_FOR_EACH_ENTRY(param
, func
->parameters
, struct hlsl_ir_var
, node
.entry
)
2304 debug_dump_ir_var(param
);
2308 TRACE("Function semantic: %s\n", debugstr_a(func
->semantic
));
2311 debug_dump_instr_list(func
->body
);
2315 void free_hlsl_type(struct hlsl_type
*type
)
2317 struct hlsl_struct_field
*field
, *next_field
;
2319 d3dcompiler_free((void *)type
->name
);
2320 if (type
->type
== HLSL_CLASS_STRUCT
)
2322 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, type
->e
.elements
, struct hlsl_struct_field
, entry
)
2324 d3dcompiler_free((void *)field
->name
);
2325 d3dcompiler_free((void *)field
->semantic
);
2326 d3dcompiler_free(field
);
2329 d3dcompiler_free(type
);
2332 void free_instr_list(struct list
*list
)
2334 struct hlsl_ir_node
*node
, *next_node
;
2338 LIST_FOR_EACH_ENTRY_SAFE(node
, next_node
, list
, struct hlsl_ir_node
, entry
)
2340 d3dcompiler_free(list
);
2343 static void free_ir_constant(struct hlsl_ir_constant
*constant
)
2345 struct hlsl_type
*type
= constant
->node
.data_type
;
2347 struct hlsl_ir_constant
*field
, *next_field
;
2351 case HLSL_CLASS_ARRAY
:
2352 for (i
= 0; i
< type
->e
.array
.elements_count
; ++i
)
2353 free_ir_constant(&constant
->v
.array_elements
[i
]);
2354 d3dcompiler_free(constant
->v
.array_elements
);
2356 case HLSL_CLASS_STRUCT
:
2357 LIST_FOR_EACH_ENTRY_SAFE(field
, next_field
, constant
->v
.struct_elements
, struct hlsl_ir_constant
, node
.entry
)
2358 free_ir_constant(field
);
2363 d3dcompiler_free(constant
);
2366 static void free_ir_deref(struct hlsl_ir_deref
*deref
)
2368 switch (deref
->type
)
2370 case HLSL_IR_DEREF_VAR
:
2371 /* Variables are shared among nodes in the tree. */
2373 case HLSL_IR_DEREF_ARRAY
:
2374 free_instr(deref
->v
.array
.array
);
2375 free_instr(deref
->v
.array
.index
);
2377 case HLSL_IR_DEREF_RECORD
:
2378 free_instr(deref
->v
.record
.record
);
2381 d3dcompiler_free(deref
);
2384 static void free_ir_swizzle(struct hlsl_ir_swizzle
*swizzle
)
2386 free_instr(swizzle
->val
);
2387 d3dcompiler_free(swizzle
);
2390 static void free_ir_constructor(struct hlsl_ir_constructor
*constructor
)
2392 free_instr_list(constructor
->arguments
);
2393 d3dcompiler_free(constructor
);
2396 static void free_ir_expr(struct hlsl_ir_expr
*expr
)
2400 for (i
= 0; i
< 3; ++i
)
2402 if (!expr
->operands
[i
])
2404 free_instr(expr
->operands
[i
]);
2406 free_instr_list(expr
->subexpressions
);
2407 d3dcompiler_free(expr
);
2410 static void free_ir_assignment(struct hlsl_ir_assignment
*assignment
)
2412 free_instr(assignment
->lhs
);
2413 free_instr(assignment
->rhs
);
2414 d3dcompiler_free(assignment
);
2417 static void free_ir_if(struct hlsl_ir_if
*if_node
)
2419 free_instr(if_node
->condition
);
2420 free_instr_list(if_node
->then_instrs
);
2421 free_instr_list(if_node
->else_instrs
);
2422 d3dcompiler_free(if_node
);
2425 static void free_ir_jump(struct hlsl_ir_jump
*jump
)
2427 if (jump
->type
== HLSL_IR_JUMP_RETURN
)
2428 free_instr(jump
->return_value
);
2429 d3dcompiler_free(jump
);
2432 void free_instr(struct hlsl_ir_node
*node
)
2437 /* These are freed later on from the scopes. */
2439 case HLSL_IR_CONSTANT
:
2440 free_ir_constant(constant_from_node(node
));
2443 free_ir_deref(deref_from_node(node
));
2445 case HLSL_IR_SWIZZLE
:
2446 free_ir_swizzle(swizzle_from_node(node
));
2448 case HLSL_IR_CONSTRUCTOR
:
2449 free_ir_constructor(constructor_from_node(node
));
2452 free_ir_expr(expr_from_node(node
));
2454 case HLSL_IR_ASSIGNMENT
:
2455 free_ir_assignment(assignment_from_node(node
));
2458 free_ir_if(if_from_node(node
));
2461 free_ir_jump(jump_from_node(node
));
2464 FIXME("Unsupported node type %s\n", debug_node_type(node
->type
));
2468 static void free_function_decl(struct hlsl_ir_function_decl
*func
)
2470 d3dcompiler_free((void *)func
->semantic
);
2471 d3dcompiler_free(func
->parameters
);
2472 free_instr_list(func
->body
);
2473 d3dcompiler_free(func
);
2476 static void free_function_decl_rb(struct wine_rb_entry
*entry
, void *context
)
2478 free_function_decl(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function_decl
, entry
));
2481 static void free_function(struct hlsl_ir_function
*func
)
2483 wine_rb_destroy(&func
->overloads
, free_function_decl_rb
, NULL
);
2484 d3dcompiler_free((void *)func
->name
);
2487 void free_function_rb(struct wine_rb_entry
*entry
, void *context
)
2489 free_function(WINE_RB_ENTRY_VALUE(entry
, struct hlsl_ir_function
, entry
));
2492 void add_function_decl(struct wine_rb_tree
*funcs
, char *name
, struct hlsl_ir_function_decl
*decl
, BOOL intrinsic
)
2494 struct hlsl_ir_function
*func
;
2495 struct wine_rb_entry
*func_entry
, *old_entry
;
2497 func_entry
= wine_rb_get(funcs
, name
);
2500 func
= WINE_RB_ENTRY_VALUE(func_entry
, struct hlsl_ir_function
, entry
);
2502 if ((old_entry
= wine_rb_get(&func
->overloads
, decl
->parameters
)))
2504 struct hlsl_ir_function_decl
*old_decl
=
2505 WINE_RB_ENTRY_VALUE(old_entry
, struct hlsl_ir_function_decl
, entry
);
2509 free_function_decl(decl
);
2510 d3dcompiler_free(name
);
2513 wine_rb_remove(&func
->overloads
, decl
->parameters
);
2514 free_function_decl(old_decl
);
2516 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2517 d3dcompiler_free(name
);
2520 func
= d3dcompiler_alloc(sizeof(*func
));
2522 if (wine_rb_init(&func
->overloads
, &hlsl_ir_function_decl_rb_funcs
) == -1)
2524 ERR("Failed to initialize function rbtree.\n");
2525 d3dcompiler_free(name
);
2526 d3dcompiler_free(func
);
2530 wine_rb_put(&func
->overloads
, decl
->parameters
, &decl
->entry
);
2531 func
->intrinsic
= intrinsic
;
2532 wine_rb_put(funcs
, func
->name
, &func
->entry
);