?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wbemprox: Add query tests.
[wine/multimedia.git] / dlls / d3dcompiler_43 / utils.c
blob350a1169d220907a11a4bbb0f11a65b04751ba5c
1 /*
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
7 *
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.
12 *
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.
17 *
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
21 *
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdio.h>
28
29 #include "d3dcompiler_private.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
32
33 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
34
35 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c)
36 {
37 switch (c)
38 {
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
42 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
43 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
44 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
45 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
46 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
47 default:
48 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
49 return "unrecognized";
50 }
51 }
52
53 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t)
54 {
55 switch (t)
56 {
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
98 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
99 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
100 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
101 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
102 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
103 default:
104 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
105 return "unrecognized";
106 }
107 }
108
109 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part)
110 {
111 switch(part)
112 {
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
120 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
121 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
122 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
123 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
124 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
125 default:
126 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
127 return "unrecognized";
128 }
129 }
130
131 const char *debug_print_srcmod(DWORD mod)
132 {
133 switch (mod)
134 {
135 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
136 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
137 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
143 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
144 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
145 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
146 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
147 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
148 default:
149 FIXME("Unrecognized source modifier %#x.\n", mod);
150 return "unrecognized_src_mod";
151 }
152 }
153
154 #undef WINE_D3DCOMPILER_TO_STR
155
156 const char *debug_print_dstmod(DWORD mod)
157 {
158 switch (mod)
159 {
160 case 0:
161 return "";
162 case BWRITERSPDM_SATURATE:
163 return "_sat";
164 case BWRITERSPDM_PARTIALPRECISION:
165 return "_pp";
166 case BWRITERSPDM_MSAMPCENTROID:
167 return "_centroid";
168 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
169 return "_sat_pp";
170 case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
171 return "_sat_centroid";
172 case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
173 return "_pp_centroid";
174 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
175 return "_sat_pp_centroid";
176 default:
177 return "Unexpected modifier\n";
178 }
179 }
180
181 const char *debug_print_shift(DWORD shift)
182 {
183 static const char * const shiftstrings[] =
184 {
185 "",
186 "_x2",
187 "_x4",
188 "_x8",
189 "_x16",
190 "_x32",
191 "",
192 "",
193 "",
194 "",
195 "",
196 "",
197 "_d16",
198 "_d8",
199 "_d4",
200 "_d2",
201 };
202 return shiftstrings[shift];
203 }
204
205 static const char *get_regname(const struct shader_reg *reg)
206 {
207 switch (reg->type)
208 {
209 case BWRITERSPR_TEMP:
210 return wine_dbg_sprintf("r%u", reg->regnum);
211 case BWRITERSPR_INPUT:
212 return wine_dbg_sprintf("v%u", reg->regnum);
213 case BWRITERSPR_CONST:
214 return wine_dbg_sprintf("c%u", reg->regnum);
215 case BWRITERSPR_ADDR:
216 return wine_dbg_sprintf("a%u", reg->regnum);
217 case BWRITERSPR_TEXTURE:
218 return wine_dbg_sprintf("t%u", reg->regnum);
219 case BWRITERSPR_RASTOUT:
220 switch (reg->regnum)
221 {
222 case BWRITERSRO_POSITION: return "oPos";
223 case BWRITERSRO_FOG: return "oFog";
224 case BWRITERSRO_POINT_SIZE: return "oPts";
225 default: return "Unexpected RASTOUT";
226 }
227 case BWRITERSPR_ATTROUT:
228 return wine_dbg_sprintf("oD%u", reg->regnum);
229 case BWRITERSPR_TEXCRDOUT:
230 return wine_dbg_sprintf("oT%u", reg->regnum);
231 case BWRITERSPR_OUTPUT:
232 return wine_dbg_sprintf("o%u", reg->regnum);
233 case BWRITERSPR_CONSTINT:
234 return wine_dbg_sprintf("i%u", reg->regnum);
235 case BWRITERSPR_COLOROUT:
236 return wine_dbg_sprintf("oC%u", reg->regnum);
237 case BWRITERSPR_DEPTHOUT:
238 return "oDepth";
239 case BWRITERSPR_SAMPLER:
240 return wine_dbg_sprintf("s%u", reg->regnum);
241 case BWRITERSPR_CONSTBOOL:
242 return wine_dbg_sprintf("b%u", reg->regnum);
243 case BWRITERSPR_LOOP:
244 return "aL";
245 case BWRITERSPR_MISCTYPE:
246 switch (reg->regnum)
247 {
248 case 0: return "vPos";
249 case 1: return "vFace";
250 default: return "unexpected misctype";
251 }
252 case BWRITERSPR_LABEL:
253 return wine_dbg_sprintf("l%u", reg->regnum);
254 case BWRITERSPR_PREDICATE:
255 return wine_dbg_sprintf("p%u", reg->regnum);
256 default:
257 return wine_dbg_sprintf("unknown regname %#x", reg->type);
258 }
259 }
260
261 static const char *debug_print_writemask(DWORD mask)
262 {
263 char ret[6];
264 unsigned char pos = 1;
265
266 if(mask == BWRITERSP_WRITEMASK_ALL) return "";
267 ret[0] = '.';
268 if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
269 if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
270 if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
271 if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
272 ret[pos] = 0;
273
274 return wine_dbg_sprintf("%s", ret);
275 }
276
277 static const char *debug_print_swizzle(DWORD arg)
278 {
279 char ret[6];
280 unsigned int i;
281 DWORD swizzle[4];
282
283 switch (arg)
284 {
285 case BWRITERVS_NOSWIZZLE:
286 return "";
287 case BWRITERVS_SWIZZLE_X:
288 return ".x";
289 case BWRITERVS_SWIZZLE_Y:
290 return ".y";
291 case BWRITERVS_SWIZZLE_Z:
292 return ".z";
293 case BWRITERVS_SWIZZLE_W:
294 return ".w";
295 }
296
297 swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
298 swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
299 swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
300 swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
301
302 ret[0] = '.';
303 for (i = 0; i < 4; ++i)
304 {
305 switch (swizzle[i])
306 {
307 case 0: ret[1 + i] = 'x'; break;
308 case 1: ret[1 + i] = 'y'; break;
309 case 2: ret[1 + i] = 'z'; break;
310 case 3: ret[1 + i] = 'w'; break;
311 }
312 }
313 ret[5] = '\0';
314
315 return wine_dbg_sprintf("%s", ret);
316 }
317
318 static const char *debug_print_relarg(const struct shader_reg *reg)
319 {
320 const char *short_swizzle;
321 if (!reg->rel_reg) return "";
322
323 short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle);
324
325 if (reg->rel_reg->type == BWRITERSPR_ADDR)
326 return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
327 else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
328 return wine_dbg_sprintf("[aL%s]", short_swizzle);
329 else
330 return "Unexpected relative addressing argument";
331 }
332
333 const char *debug_print_dstreg(const struct shader_reg *reg)
334 {
335 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
336 debug_print_relarg(reg),
337 debug_print_writemask(reg->u.writemask));
338 }
339
340 const char *debug_print_srcreg(const struct shader_reg *reg)
341 {
342 switch (reg->srcmod)
343 {
344 case BWRITERSPSM_NONE:
345 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
346 debug_print_relarg(reg),
347 debug_print_swizzle(reg->u.swizzle));
348 case BWRITERSPSM_NEG:
349 return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
350 debug_print_relarg(reg),
351 debug_print_swizzle(reg->u.swizzle));
352 case BWRITERSPSM_BIAS:
353 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
354 debug_print_relarg(reg),
355 debug_print_swizzle(reg->u.swizzle));
356 case BWRITERSPSM_BIASNEG:
357 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
358 debug_print_relarg(reg),
359 debug_print_swizzle(reg->u.swizzle));
360 case BWRITERSPSM_SIGN:
361 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
362 debug_print_relarg(reg),
363 debug_print_swizzle(reg->u.swizzle));
364 case BWRITERSPSM_SIGNNEG:
365 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
366 debug_print_relarg(reg),
367 debug_print_swizzle(reg->u.swizzle));
368 case BWRITERSPSM_COMP:
369 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
370 debug_print_relarg(reg),
371 debug_print_swizzle(reg->u.swizzle));
372 case BWRITERSPSM_X2:
373 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
374 debug_print_relarg(reg),
375 debug_print_swizzle(reg->u.swizzle));
376 case BWRITERSPSM_X2NEG:
377 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
378 debug_print_relarg(reg),
379 debug_print_swizzle(reg->u.swizzle));
380 case BWRITERSPSM_DZ:
381 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
382 debug_print_relarg(reg),
383 debug_print_swizzle(reg->u.swizzle));
384 case BWRITERSPSM_DW:
385 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
386 debug_print_relarg(reg),
387 debug_print_swizzle(reg->u.swizzle));
388 case BWRITERSPSM_ABS:
389 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
390 debug_print_relarg(reg),
391 debug_print_swizzle(reg->u.swizzle));
392 case BWRITERSPSM_ABSNEG:
393 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
394 debug_print_relarg(reg),
395 debug_print_swizzle(reg->u.swizzle));
396 case BWRITERSPSM_NOT:
397 return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
398 debug_print_relarg(reg),
399 debug_print_swizzle(reg->u.swizzle));
400 }
401 return "Unknown modifier";
402 }
403
404 const char *debug_print_comp(DWORD comp)
405 {
406 switch (comp)
407 {
408 case BWRITER_COMPARISON_NONE: return "";
409 case BWRITER_COMPARISON_GT: return "_gt";
410 case BWRITER_COMPARISON_EQ: return "_eq";
411 case BWRITER_COMPARISON_GE: return "_ge";
412 case BWRITER_COMPARISON_LT: return "_lt";
413 case BWRITER_COMPARISON_NE: return "_ne";
414 case BWRITER_COMPARISON_LE: return "_le";
415 default: return "_unknown";
416 }
417 }
418
419 const char *debug_print_opcode(DWORD opcode)
420 {
421 switch (opcode)
422 {
423 case BWRITERSIO_NOP: return "nop";
424 case BWRITERSIO_MOV: return "mov";
425 case BWRITERSIO_ADD: return "add";
426 case BWRITERSIO_SUB: return "sub";
427 case BWRITERSIO_MAD: return "mad";
428 case BWRITERSIO_MUL: return "mul";
429 case BWRITERSIO_RCP: return "rcp";
430 case BWRITERSIO_RSQ: return "rsq";
431 case BWRITERSIO_DP3: return "dp3";
432 case BWRITERSIO_DP4: return "dp4";
433 case BWRITERSIO_MIN: return "min";
434 case BWRITERSIO_MAX: return "max";
435 case BWRITERSIO_SLT: return "slt";
436 case BWRITERSIO_SGE: return "sge";
437 case BWRITERSIO_EXP: return "exp";
438 case BWRITERSIO_LOG: return "log";
439 case BWRITERSIO_LIT: return "lit";
440 case BWRITERSIO_DST: return "dst";
441 case BWRITERSIO_LRP: return "lrp";
442 case BWRITERSIO_FRC: return "frc";
443 case BWRITERSIO_M4x4: return "m4x4";
444 case BWRITERSIO_M4x3: return "m4x3";
445 case BWRITERSIO_M3x4: return "m3x4";
446 case BWRITERSIO_M3x3: return "m3x3";
447 case BWRITERSIO_M3x2: return "m3x2";
448 case BWRITERSIO_CALL: return "call";
449 case BWRITERSIO_CALLNZ: return "callnz";
450 case BWRITERSIO_LOOP: return "loop";
451 case BWRITERSIO_RET: return "ret";
452 case BWRITERSIO_ENDLOOP: return "endloop";
453 case BWRITERSIO_LABEL: return "label";
454 case BWRITERSIO_DCL: return "dcl";
455 case BWRITERSIO_POW: return "pow";
456 case BWRITERSIO_CRS: return "crs";
457 case BWRITERSIO_SGN: return "sgn";
458 case BWRITERSIO_ABS: return "abs";
459 case BWRITERSIO_NRM: return "nrm";
460 case BWRITERSIO_SINCOS: return "sincos";
461 case BWRITERSIO_REP: return "rep";
462 case BWRITERSIO_ENDREP: return "endrep";
463 case BWRITERSIO_IF: return "if";
464 case BWRITERSIO_IFC: return "ifc";
465 case BWRITERSIO_ELSE: return "else";
466 case BWRITERSIO_ENDIF: return "endif";
467 case BWRITERSIO_BREAK: return "break";
468 case BWRITERSIO_BREAKC: return "breakc";
469 case BWRITERSIO_MOVA: return "mova";
470 case BWRITERSIO_DEFB: return "defb";
471 case BWRITERSIO_DEFI: return "defi";
472 case BWRITERSIO_TEXCOORD: return "texcoord";
473 case BWRITERSIO_TEXKILL: return "texkill";
474 case BWRITERSIO_TEX: return "tex";
475 case BWRITERSIO_TEXBEM: return "texbem";
476 case BWRITERSIO_TEXBEML: return "texbeml";
477 case BWRITERSIO_TEXREG2AR: return "texreg2ar";
478 case BWRITERSIO_TEXREG2GB: return "texreg2gb";
479 case BWRITERSIO_TEXM3x2PAD: return "texm3x2pad";
480 case BWRITERSIO_TEXM3x2TEX: return "texm3x2tex";
481 case BWRITERSIO_TEXM3x3PAD: return "texm3x3pad";
482 case BWRITERSIO_TEXM3x3TEX: return "texm3x3tex";
483 case BWRITERSIO_TEXM3x3SPEC: return "texm3x3vspec";
484 case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
485 case BWRITERSIO_EXPP: return "expp";
486 case BWRITERSIO_LOGP: return "logp";
487 case BWRITERSIO_CND: return "cnd";
488 case BWRITERSIO_DEF: return "def";
489 case BWRITERSIO_TEXREG2RGB: return "texreg2rgb";
490 case BWRITERSIO_TEXDP3TEX: return "texdp3tex";
491 case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
492 case BWRITERSIO_TEXDP3: return "texdp3";
493 case BWRITERSIO_TEXM3x3: return "texm3x3";
494 case BWRITERSIO_TEXDEPTH: return "texdepth";
495 case BWRITERSIO_CMP: return "cmp";
496 case BWRITERSIO_BEM: return "bem";
497 case BWRITERSIO_DP2ADD: return "dp2add";
498 case BWRITERSIO_DSX: return "dsx";
499 case BWRITERSIO_DSY: return "dsy";
500 case BWRITERSIO_TEXLDD: return "texldd";
501 case BWRITERSIO_SETP: return "setp";
502 case BWRITERSIO_TEXLDL: return "texldl";
503 case BWRITERSIO_BREAKP: return "breakp";
504 case BWRITERSIO_PHASE: return "phase";
505
506 case BWRITERSIO_TEXLDP: return "texldp";
507 case BWRITERSIO_TEXLDB: return "texldb";
508
509 default: return "unknown";
510 }
511 }
512
513 void skip_dword_unknown(const char **ptr, unsigned int count)
514 {
515 unsigned int i;
516 DWORD d;
517
518 FIXME("Skipping %u unknown DWORDs:\n", count);
519 for (i = 0; i < count; ++i)
520 {
521 read_dword(ptr, &d);
522 FIXME("\t0x%08x\n", d);
523 }
524 }
525
526 static void write_dword_unknown(char **ptr, DWORD d)
527 {
528 FIXME("Writing unknown DWORD 0x%08x\n", d);
529 write_dword(ptr, d);
530 }
531
532 HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
533 {
534 TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
535
536 if (dxbc->count >= dxbc->size)
537 {
538 struct dxbc_section *new_sections;
539 DWORD new_size = dxbc->size << 1;
540
541 new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
542 if (!new_sections)
543 {
544 ERR("Failed to allocate dxbc section memory\n");
545 return E_OUTOFMEMORY;
546 }
547
548 dxbc->sections = new_sections;
549 dxbc->size = new_size;
550 }
551
552 dxbc->sections[dxbc->count].tag = tag;
553 dxbc->sections[dxbc->count].data_size = data_size;
554 dxbc->sections[dxbc->count].data = data;
555 ++dxbc->count;
556
557 return S_OK;
558 }
559
560 HRESULT dxbc_init(struct dxbc *dxbc, UINT size)
561 {
562 TRACE("dxbc %p, size %u.\n", dxbc, size);
563
564 /* use a good starting value for the size if none specified */
565 if (!size) size = 2;
566
567 dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
568 if (!dxbc->sections)
569 {
570 ERR("Failed to allocate dxbc section memory\n");
571 return E_OUTOFMEMORY;
572 }
573
574 dxbc->size = size;
575 dxbc->count = 0;
576
577 return S_OK;
578 }
579
580 HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc)
581 {
582 const char *ptr = data;
583 HRESULT hr;
584 unsigned int i;
585 DWORD tag, total_size, chunk_count;
586
587 if (!data)
588 {
589 WARN("No data supplied.\n");
590 return E_FAIL;
591 }
592
593 read_dword(&ptr, &tag);
594 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
595
596 if (tag != TAG_DXBC)
597 {
598 WARN("Wrong tag.\n");
599 return E_FAIL;
600 }
601
602 /* checksum? */
603 skip_dword_unknown(&ptr, 4);
604
605 skip_dword_unknown(&ptr, 1);
606
607 read_dword(&ptr, &total_size);
608 TRACE("total size: %#x\n", total_size);
609
610 if (data_size != total_size)
611 {
612 WARN("Wrong size supplied.\n");
613 return D3DERR_INVALIDCALL;
614 }
615
616 read_dword(&ptr, &chunk_count);
617 TRACE("chunk count: %#x\n", chunk_count);
618
619 hr = dxbc_init(dxbc, chunk_count);
620 if (FAILED(hr))
621 {
622 WARN("Failed to init dxbc\n");
623 return hr;
624 }
625
626 for (i = 0; i < chunk_count; ++i)
627 {
628 DWORD chunk_tag, chunk_size;
629 const char *chunk_ptr;
630 DWORD chunk_offset;
631
632 read_dword(&ptr, &chunk_offset);
633 TRACE("chunk %u at offset %#x\n", i, chunk_offset);
634
635 chunk_ptr = data + chunk_offset;
636
637 read_dword(&chunk_ptr, &chunk_tag);
638 read_dword(&chunk_ptr, &chunk_size);
639
640 hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
641 if (FAILED(hr))
642 {
643 WARN("Failed to add section to dxbc\n");
644 return hr;
645 }
646 }
647
648 return hr;
649 }
650
651 void dxbc_destroy(struct dxbc *dxbc)
652 {
653 TRACE("dxbc %p.\n", dxbc);
654
655 HeapFree(GetProcessHeap(), 0, dxbc->sections);
656 }
657
658 HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob)
659 {
660 DWORD size = 32, offset = size + 4 * dxbc->count;
661 ID3DBlob *object;
662 HRESULT hr;
663 char *ptr;
664 unsigned int i;
665
666 TRACE("dxbc %p, blob %p.\n", dxbc, blob);
667
668 for (i = 0; i < dxbc->count; ++i)
669 {
670 size += 12 + dxbc->sections[i].data_size;
671 }
672
673 hr = D3DCreateBlob(size, &object);
674 if (FAILED(hr))
675 {
676 WARN("Failed to create blob\n");
677 return hr;
678 }
679
680 ptr = ID3D10Blob_GetBufferPointer(object);
681
682 write_dword(&ptr, TAG_DXBC);
683
684 /* signature(?) */
685 write_dword_unknown(&ptr, 0);
686 write_dword_unknown(&ptr, 0);
687 write_dword_unknown(&ptr, 0);
688 write_dword_unknown(&ptr, 0);
689
690 /* seems to be always 1 */
691 write_dword_unknown(&ptr, 1);
692
693 /* DXBC size */
694 write_dword(&ptr, size);
695
696 /* chunk count */
697 write_dword(&ptr, dxbc->count);
698
699 /* write the chunk offsets */
700 for (i = 0; i < dxbc->count; ++i)
701 {
702 write_dword(&ptr, offset);
703 offset += 8 + dxbc->sections[i].data_size;
704 }
705
706 /* write the chunks */
707 for (i = 0; i < dxbc->count; ++i)
708 {
709 write_dword(&ptr, dxbc->sections[i].tag);
710 write_dword(&ptr, dxbc->sections[i].data_size);
711 memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
712 ptr += dxbc->sections[i].data_size;
713 }
714
715 TRACE("Created ID3DBlob %p\n", object);
716
717 *blob = object;
718
719 return S_OK;
720 }
721
722 void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args)
723 {
724 char* buffer;
725 int rc, size;
726
727 if (msg->capacity == 0)
728 {
729 msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE);
730 if (msg->string == NULL)
731 {
732 ERR("Error allocating memory for parser messages\n");
733 return;
734 }
735 msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
736 }
737
738 while (1)
739 {
740 rc = vsnprintf(msg->string + msg->size,
741 msg->capacity - msg->size, fmt, args);
742
743 if (rc < 0 || rc >= msg->capacity - msg->size)
744 {
745 size = msg->capacity * 2;
746 buffer = d3dcompiler_realloc(msg->string, size);
747 if (buffer == NULL)
748 {
749 ERR("Error reallocating memory for parser messages\n");
750 return;
751 }
752 msg->string = buffer;
753 msg->capacity = size;
754 }
755 else
756 {
757 TRACE("%s", msg->string + msg->size);
758 msg->size += rc;
759 return;
760 }
761 }
762 }
763
764 BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
765 {
766 struct hlsl_ir_var *var;
767
768 LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
769 {
770 if (!strcmp(decl->name, var->name))
771 return FALSE;
772 }
773 if (local_var && scope->upper->upper == hlsl_ctx.globals)
774 {
775 /* Check whether the variable redefines a function parameter. */
776 LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
777 {
778 if (!strcmp(decl->name, var->name))
779 return FALSE;
780 }
781 }
782
783 list_add_tail(&scope->vars, &decl->scope_entry);
784 return TRUE;
785 }
786
787 struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name)
788 {
789 struct hlsl_ir_var *var;
790
791 LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
792 {
793 if (!strcmp(name, var->name))
794 return var;
795 }
796 if (!scope->upper)
797 return NULL;
798 return get_variable(scope->upper, name);
799 }
800
801 void free_declaration(struct hlsl_ir_var *decl)
802 {
803 d3dcompiler_free((void *)decl->name);
804 d3dcompiler_free((void *)decl->semantic);
805 d3dcompiler_free(decl);
806 }
807
808 BOOL add_func_parameter(struct list *list, struct parse_parameter *param, unsigned int line)
809 {
810 struct hlsl_ir_var *decl = d3dcompiler_alloc(sizeof(*decl));
811
812 if (!decl)
813 {
814 ERR("Out of memory.\n");
815 return FALSE;
816 }
817 decl->node.type = HLSL_IR_VAR;
818 decl->node.data_type = param->type;
819 decl->node.line = line;
820 decl->name = param->name;
821 decl->semantic = param->semantic;
822 decl->modifiers = param->modifiers;
823
824 if (!add_declaration(hlsl_ctx.cur_scope, decl, FALSE))
825 {
826 free_declaration(decl);
827 return FALSE;
828 }
829 list_add_tail(list, &decl->node.entry);
830 return TRUE;
831 }
832
833 struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class,
834 enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
835 {
836 struct hlsl_type *type;
837
838 type = d3dcompiler_alloc(sizeof(*type));
839 if (!type)
840 {
841 ERR("Out of memory\n");
842 return NULL;
843 }
844 type->name = name;
845 type->type = type_class;
846 type->base_type = base_type;
847 type->dimx = dimx;
848 type->dimy = dimy;
849
850 list_add_tail(&hlsl_ctx.types, &type->entry);
851
852 return type;
853 }
854
855 struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
856 {
857 FIXME("stub.\n");
858 return NULL;
859 }
860
861 struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive)
862 {
863 FIXME("stub.\n");
864 return NULL;
865 }
866
867 BOOL find_function(const char *name)
868 {
869 struct hlsl_ir_function_decl *func;
870
871 LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
872 {
873 if (!strcmp(func->name, name))
874 return TRUE;
875 }
876 return FALSE;
877 }
878
879 unsigned int components_count_type(struct hlsl_type *type)
880 {
881 unsigned int count = 0;
882 struct hlsl_struct_field *field;
883
884 if (type->type <= HLSL_CLASS_LAST_NUMERIC)
885 {
886 return type->dimx * type->dimy;
887 }
888 if (type->type == HLSL_CLASS_ARRAY)
889 {
890 return components_count_type(type->e.array.type) * type->e.array.elements_count;
891 }
892 if (type->type != HLSL_CLASS_STRUCT)
893 {
894 ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
895 return 0;
896 }
897
898 LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
899 {
900 count += components_count_type(field->type);
901 }
902 return count;
903 }
904
905 struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var)
906 {
907 struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
908
909 if (!deref)
910 {
911 ERR("Out of memory.\n");
912 return NULL;
913 }
914 deref->node.type = HLSL_IR_DEREF;
915 deref->node.data_type = var->node.data_type;
916 deref->type = HLSL_IR_DEREF_VAR;
917 deref->v.var = var;
918 return deref;
919 }
920
921 void push_scope(struct hlsl_parse_ctx *ctx)
922 {
923 struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
924
925 if (!new_scope)
926 {
927 ERR("Out of memory!\n");
928 return;
929 }
930 list_init(&new_scope->vars);
931 list_init(&new_scope->types);
932 new_scope->upper = ctx->cur_scope;
933 ctx->cur_scope = new_scope;
934 list_add_tail(&ctx->scopes, &new_scope->entry);
935 }
936
937 BOOL pop_scope(struct hlsl_parse_ctx *ctx)
938 {
939 struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
940 if (!prev_scope)
941 return FALSE;
942
943 ctx->cur_scope = prev_scope;
944 return TRUE;
945 }
946
947 struct hlsl_ir_function_decl *new_func_decl(const char *name, struct hlsl_type *return_type, struct list *parameters)
948 {
949 struct hlsl_ir_function_decl *decl;
950
951 decl = d3dcompiler_alloc(sizeof(*decl));
952 if (!decl)
953 {
954 ERR("Out of memory.\n");
955 return NULL;
956 }
957 decl->node.type = HLSL_IR_FUNCTION_DECL;
958 decl->node.data_type = return_type;
959 decl->name = name;
960 decl->parameters = parameters;
961
962 return decl;
963 }
964
965 static const char *debug_base_type(const struct hlsl_type *type)
966 {
967 const char *name = "(unknown)";
968
969 switch (type->base_type)
970 {
971 case HLSL_TYPE_FLOAT: name = "float"; break;
972 case HLSL_TYPE_HALF: name = "half"; break;
973 case HLSL_TYPE_INT: name = "int"; break;
974 case HLSL_TYPE_UINT: name = "uint"; break;
975 case HLSL_TYPE_BOOL: name = "bool"; break;
976 case HLSL_TYPE_SAMPLER:
977 switch (type->sampler_dim)
978 {
979 case HLSL_SAMPLER_DIM_GENERIC: name = "sampler"; break;
980 case HLSL_SAMPLER_DIM_1D: name = "sampler1D"; break;
981 case HLSL_SAMPLER_DIM_2D: name = "sampler2D"; break;
982 case HLSL_SAMPLER_DIM_3D: name = "sampler3D"; break;
983 case HLSL_SAMPLER_DIM_CUBE: name = "samplerCUBE"; break;
984 }
985 break;
986 default:
987 FIXME("Unhandled case %u\n", type->base_type);
988 }
989 return name;
990 }
991
992 const char *debug_hlsl_type(const struct hlsl_type *type)
993 {
994 const char *name;
995
996 if (type->name)
997 return debugstr_a(type->name);
998
999 if (type->type == HLSL_CLASS_STRUCT)
1000 name = "<anonymous struct>";
1001 else
1002 name = debug_base_type(type);
1003
1004 if (type->type == HLSL_CLASS_SCALAR)
1005 return wine_dbg_sprintf("%s", name);
1006 if (type->type == HLSL_CLASS_VECTOR)
1007 return wine_dbg_sprintf("vector<%s, %u>", name, type->dimx);
1008 if (type->type == HLSL_CLASS_MATRIX)
1009 return wine_dbg_sprintf("matrix<%s, %u, %u>", name, type->dimx, type->dimy);
1010 return "unexpected_type";
1011 }
1012
1013 const char *debug_modifiers(DWORD modifiers)
1014 {
1015 char string[110];
1016
1017 string[0] = 0;
1018 if (modifiers & HLSL_STORAGE_EXTERN)
1019 strcat(string, " extern"); /* 7 */
1020 if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
1021 strcat(string, " nointerpolation"); /* 16 */
1022 if (modifiers & HLSL_MODIFIER_PRECISE)
1023 strcat(string, " precise"); /* 8 */
1024 if (modifiers & HLSL_STORAGE_SHARED)
1025 strcat(string, " shared"); /* 7 */
1026 if (modifiers & HLSL_STORAGE_GROUPSHARED)
1027 strcat(string, " groupshared"); /* 12 */
1028 if (modifiers & HLSL_STORAGE_STATIC)
1029 strcat(string, " static"); /* 7 */
1030 if (modifiers & HLSL_STORAGE_UNIFORM)
1031 strcat(string, " uniform"); /* 8 */
1032 if (modifiers & HLSL_STORAGE_VOLATILE)
1033 strcat(string, " volatile"); /* 9 */
1034 if (modifiers & HLSL_MODIFIER_CONST)
1035 strcat(string, " const"); /* 6 */
1036 if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
1037 strcat(string, " row_major"); /* 10 */
1038 if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
1039 strcat(string, " column_major"); /* 13 */
1040 if ((modifiers & (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) == (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT))
1041 strcat(string, " inout"); /* 6 */
1042 else if (modifiers & HLSL_MODIFIER_IN)
1043 strcat(string, " in"); /* 3 */
1044 else if (modifiers & HLSL_MODIFIER_OUT)
1045 strcat(string, " out"); /* 4 */
1046
1047 return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
1048 }
1049
1050 static const char *debug_node_type(enum hlsl_ir_node_type type)
1051 {
1052 const char *names[] =
1053 {
1054 "HLSL_IR_VAR",
1055 "HLSL_IR_CONSTANT",
1056 "HLSL_IR_CONSTRUCTOR",
1057 "HLSL_IR_DEREF",
1058 "HLSL_IR_FUNCTION_DECL",
1059 };
1060
1061 if (type > sizeof(names) / sizeof(names[0]))
1062 {
1063 return "Unexpected node type";
1064 }
1065 return names[type];
1066 }
1067
1068 static void debug_dump_instr(const struct hlsl_ir_node *instr);
1069
1070 static void debug_dump_ir_var(const struct hlsl_ir_var *var)
1071 {
1072 if (var->modifiers)
1073 TRACE("%s ", debug_modifiers(var->modifiers));
1074 TRACE("%s %s", debug_hlsl_type(var->node.data_type), var->name);
1075 if (var->semantic)
1076 TRACE(" : %s", debugstr_a(var->semantic));
1077 }
1078
1079 static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref)
1080 {
1081 switch (deref->type)
1082 {
1083 case HLSL_IR_DEREF_VAR:
1084 TRACE("deref(");
1085 debug_dump_ir_var(deref->v.var);
1086 TRACE(")");
1087 break;
1088 case HLSL_IR_DEREF_ARRAY:
1089 debug_dump_instr(deref->v.array.array);
1090 TRACE("[");
1091 debug_dump_instr(deref->v.array.index);
1092 TRACE("]");
1093 break;
1094 case HLSL_IR_DEREF_RECORD:
1095 debug_dump_instr(deref->v.record.record);
1096 TRACE(".%s", debugstr_a(deref->v.record.field));
1097 break;
1098 }
1099 }
1100
1101 static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant)
1102 {
1103 struct hlsl_type *type = constant->node.data_type;
1104 unsigned int x, y;
1105
1106 if (type->dimy != 1)
1107 TRACE("{");
1108 for (y = 0; y < type->dimy; ++y)
1109 {
1110 if (type->dimx != 1)
1111 TRACE("{");
1112 for (x = 0; x < type->dimx; ++x)
1113 {
1114 switch (type->base_type)
1115 {
1116 case HLSL_TYPE_FLOAT:
1117 TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]);
1118 break;
1119 case HLSL_TYPE_DOUBLE:
1120 TRACE("%g ", constant->v.value.d[y * type->dimx + x]);
1121 break;
1122 case HLSL_TYPE_INT:
1123 TRACE("%d ", constant->v.value.i[y * type->dimx + x]);
1124 break;
1125 case HLSL_TYPE_UINT:
1126 TRACE("%u ", constant->v.value.u[y * type->dimx + x]);
1127 break;
1128 case HLSL_TYPE_BOOL:
1129 TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true");
1130 break;
1131 default:
1132 TRACE("Constants of type %s not supported\n", debug_base_type(type));
1133 }
1134 }
1135 if (type->dimx != 1)
1136 TRACE("}");
1137 }
1138 if (type->dimy != 1)
1139 TRACE("}");
1140 }
1141
1142 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor)
1143 {
1144 struct hlsl_ir_node *arg;
1145
1146 TRACE("%s (", debug_hlsl_type(constructor->node.data_type));
1147 LIST_FOR_EACH_ENTRY(arg, constructor->arguments, struct hlsl_ir_node, entry)
1148 {
1149 debug_dump_instr(arg);
1150 TRACE(" ");
1151 }
1152 TRACE(")");
1153 }
1154
1155 void debug_dump_instr(const struct hlsl_ir_node *instr)
1156 {
1157 switch (instr->type)
1158 {
1159 case HLSL_IR_DEREF:
1160 debug_dump_ir_deref(deref_from_node(instr));
1161 break;
1162 case HLSL_IR_CONSTANT:
1163 debug_dump_ir_constant(constant_from_node(instr));
1164 break;
1165 case HLSL_IR_CONSTRUCTOR:
1166 debug_dump_ir_constructor(constructor_from_node(instr));
1167 break;
1168 default:
1169 TRACE("No dump function for %s\n", debug_node_type(instr->type));
1170 }
1171 }
1172
1173 static void debug_dump_instr_list(const struct list *list)
1174 {
1175 struct hlsl_ir_node *instr;
1176
1177 LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry)
1178 {
1179 debug_dump_instr(instr);
1180 TRACE("\n");
1181 }
1182 }
1183
1184 void debug_dump_ir_function(const struct hlsl_ir_function_decl *func)
1185 {
1186 struct hlsl_ir_var *param;
1187
1188 TRACE("Dumping function %s.\n", debugstr_a(func->name));
1189 TRACE("Function parameters:\n");
1190 LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, node.entry)
1191 {
1192 debug_dump_ir_var(param);
1193 TRACE("\n");
1194 }
1195 if (func->semantic)
1196 TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
1197 if (func->body)
1198 {
1199 debug_dump_instr_list(func->body);
1200 }
1201 }
1202
1203 void free_hlsl_type(struct hlsl_type *type)
1204 {
1205 struct hlsl_struct_field *field, *next_field;
1206
1207 d3dcompiler_free((void *)type->name);
1208 if (type->type == HLSL_CLASS_STRUCT)
1209 {
1210 LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
1211 {
1212 d3dcompiler_free((void *)field->name);
1213 d3dcompiler_free((void *)field->semantic);
1214 d3dcompiler_free(field);
1215 }
1216 }
1217 d3dcompiler_free(type);
1218 }
1219
1220 void free_instr_list(struct list *list)
1221 {
1222 struct hlsl_ir_node *node, *next_node;
1223
1224 if (!list)
1225 return;
1226 LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry)
1227 free_instr(node);
1228 }
1229
1230 static void free_ir_constant(struct hlsl_ir_constant *constant)
1231 {
1232 struct hlsl_type *type = constant->node.data_type;
1233 unsigned int i;
1234 struct hlsl_ir_constant *field, *next_field;
1235
1236 switch (type->type)
1237 {
1238 case HLSL_CLASS_ARRAY:
1239 for (i = 0; i < type->e.array.elements_count; ++i)
1240 free_ir_constant(&constant->v.array_elements[i]);
1241 d3dcompiler_free(constant->v.array_elements);
1242 break;
1243 case HLSL_CLASS_STRUCT:
1244 LIST_FOR_EACH_ENTRY_SAFE(field, next_field, constant->v.struct_elements, struct hlsl_ir_constant, node.entry)
1245 free_ir_constant(field);
1246 break;
1247 default:
1248 break;
1249 }
1250 d3dcompiler_free(constant);
1251 }
1252
1253 static void free_ir_deref(struct hlsl_ir_deref *deref)
1254 {
1255 switch (deref->type)
1256 {
1257 case HLSL_IR_DEREF_VAR:
1258 /* Variables are shared among nodes in the tree. */
1259 break;
1260 case HLSL_IR_DEREF_ARRAY:
1261 free_instr(deref->v.array.array);
1262 free_instr(deref->v.array.index);
1263 break;
1264 case HLSL_IR_DEREF_RECORD:
1265 free_instr(deref->v.record.record);
1266 d3dcompiler_free((void *)deref->v.record.field);
1267 break;
1268 }
1269 d3dcompiler_free(deref);
1270 }
1271
1272 static void free_ir_constructor(struct hlsl_ir_constructor *constructor)
1273 {
1274 free_instr_list(constructor->arguments);
1275 d3dcompiler_free(constructor);
1276 }
1277
1278 void free_instr(struct hlsl_ir_node *node)
1279 {
1280 switch (node->type)
1281 {
1282 case HLSL_IR_VAR:
1283 /* These are freed later on from the scopes. */
1284 break;
1285 case HLSL_IR_CONSTANT:
1286 free_ir_constant(constant_from_node(node));
1287 break;
1288 case HLSL_IR_DEREF:
1289 free_ir_deref(deref_from_node(node));
1290 break;
1291 case HLSL_IR_CONSTRUCTOR:
1292 free_ir_constructor(constructor_from_node(node));
1293 break;
1294 default:
1295 FIXME("Unsupported node type %s\n", debug_node_type(node->type));
1296 }
1297 }
1298
1299 void free_function(struct hlsl_ir_function_decl *func)
1300 {
1301 struct hlsl_ir_var *param, *next_param;
1302
1303 d3dcompiler_free((void *)func->name);
1304 d3dcompiler_free((void *)func->semantic);
1305 LIST_FOR_EACH_ENTRY_SAFE(param, next_param, func->parameters, struct hlsl_ir_var, node.entry)
1306 d3dcompiler_free(param);
1307 d3dcompiler_free(func->parameters);
1308 free_instr_list(func->body);
1309 d3dcompiler_free(func->body);
1310 }
Maarten's multimedia branch