2 * Copyright 2008 Stefan Dösinger
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2008-2009 Henri Verbeet for CodeWeavers
5 * Copyright 2010 Rico Schüller
6 * Copyright 2012 Matteo Bruni for CodeWeavers
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
29 #include "d3dcompiler_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
33 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
35 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c)
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
42 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
43 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
44 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
45 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
46 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
48 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
49 return "unrecognized";
53 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t)
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
98 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
99 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
100 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
101 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
102 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
104 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
105 return "unrecognized";
109 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part)
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
120 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
121 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
122 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
123 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
124 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
126 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
127 return "unrecognized";
131 const char *debug_print_srcmod(DWORD mod)
135 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
136 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
137 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
143 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
144 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
145 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
146 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
147 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
149 FIXME("Unrecognized source modifier %#x.\n", mod);
150 return "unrecognized_src_mod";
154 #undef WINE_D3DCOMPILER_TO_STR
156 const char *debug_print_dstmod(DWORD mod)
162 case BWRITERSPDM_SATURATE:
164 case BWRITERSPDM_PARTIALPRECISION:
166 case BWRITERSPDM_MSAMPCENTROID:
168 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
170 case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
171 return "_sat_centroid";
172 case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
173 return "_pp_centroid";
174 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
175 return "_sat_pp_centroid";
177 return "Unexpected modifier\n";
181 const char *debug_print_shift(DWORD shift)
183 static const char * const shiftstrings[] =
202 return shiftstrings[shift];
205 static const char *get_regname(const struct shader_reg *reg)
209 case BWRITERSPR_TEMP:
210 return wine_dbg_sprintf("r%u", reg->regnum);
211 case BWRITERSPR_INPUT:
212 return wine_dbg_sprintf("v%u", reg->regnum);
213 case BWRITERSPR_CONST:
214 return wine_dbg_sprintf("c%u", reg->regnum);
215 case BWRITERSPR_ADDR:
216 return wine_dbg_sprintf("a%u", reg->regnum);
217 case BWRITERSPR_TEXTURE:
218 return wine_dbg_sprintf("t%u", reg->regnum);
219 case BWRITERSPR_RASTOUT:
222 case BWRITERSRO_POSITION: return "oPos";
223 case BWRITERSRO_FOG: return "oFog";
224 case BWRITERSRO_POINT_SIZE: return "oPts";
225 default: return "Unexpected RASTOUT";
227 case BWRITERSPR_ATTROUT:
228 return wine_dbg_sprintf("oD%u", reg->regnum);
229 case BWRITERSPR_TEXCRDOUT:
230 return wine_dbg_sprintf("oT%u", reg->regnum);
231 case BWRITERSPR_OUTPUT:
232 return wine_dbg_sprintf("o%u", reg->regnum);
233 case BWRITERSPR_CONSTINT:
234 return wine_dbg_sprintf("i%u", reg->regnum);
235 case BWRITERSPR_COLOROUT:
236 return wine_dbg_sprintf("oC%u", reg->regnum);
237 case BWRITERSPR_DEPTHOUT:
239 case BWRITERSPR_SAMPLER:
240 return wine_dbg_sprintf("s%u", reg->regnum);
241 case BWRITERSPR_CONSTBOOL:
242 return wine_dbg_sprintf("b%u", reg->regnum);
243 case BWRITERSPR_LOOP:
245 case BWRITERSPR_MISCTYPE:
248 case 0: return "vPos";
249 case 1: return "vFace";
250 default: return "unexpected misctype";
252 case BWRITERSPR_LABEL:
253 return wine_dbg_sprintf("l%u", reg->regnum);
254 case BWRITERSPR_PREDICATE:
255 return wine_dbg_sprintf("p%u", reg->regnum);
257 return wine_dbg_sprintf("unknown regname %#x", reg->type);
261 static const char *debug_print_writemask(DWORD mask)
264 unsigned char pos = 1;
266 if(mask == BWRITERSP_WRITEMASK_ALL) return "";
268 if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
269 if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
270 if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
271 if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
274 return wine_dbg_sprintf("%s", ret);
277 static const char *debug_print_swizzle(DWORD arg)
285 case BWRITERVS_NOSWIZZLE:
287 case BWRITERVS_SWIZZLE_X:
289 case BWRITERVS_SWIZZLE_Y:
291 case BWRITERVS_SWIZZLE_Z:
293 case BWRITERVS_SWIZZLE_W:
297 swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
298 swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
299 swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
300 swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
303 for (i = 0; i < 4; ++i)
307 case 0: ret[1 + i] = 'x'; break;
308 case 1: ret[1 + i] = 'y'; break;
309 case 2: ret[1 + i] = 'z'; break;
310 case 3: ret[1 + i] = 'w'; break;
315 return wine_dbg_sprintf("%s", ret);
318 static const char *debug_print_relarg(const struct shader_reg *reg)
320 const char *short_swizzle;
321 if (!reg->rel_reg) return "";
323 short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle);
325 if (reg->rel_reg->type == BWRITERSPR_ADDR)
326 return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
327 else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
328 return wine_dbg_sprintf("[aL%s]", short_swizzle);
330 return "Unexpected relative addressing argument";
333 const char *debug_print_dstreg(const struct shader_reg *reg)
335 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
336 debug_print_relarg(reg),
337 debug_print_writemask(reg->u.writemask));
340 const char *debug_print_srcreg(const struct shader_reg *reg)
344 case BWRITERSPSM_NONE:
345 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
346 debug_print_relarg(reg),
347 debug_print_swizzle(reg->u.swizzle));
348 case BWRITERSPSM_NEG:
349 return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
350 debug_print_relarg(reg),
351 debug_print_swizzle(reg->u.swizzle));
352 case BWRITERSPSM_BIAS:
353 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
354 debug_print_relarg(reg),
355 debug_print_swizzle(reg->u.swizzle));
356 case BWRITERSPSM_BIASNEG:
357 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
358 debug_print_relarg(reg),
359 debug_print_swizzle(reg->u.swizzle));
360 case BWRITERSPSM_SIGN:
361 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
362 debug_print_relarg(reg),
363 debug_print_swizzle(reg->u.swizzle));
364 case BWRITERSPSM_SIGNNEG:
365 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
366 debug_print_relarg(reg),
367 debug_print_swizzle(reg->u.swizzle));
368 case BWRITERSPSM_COMP:
369 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
370 debug_print_relarg(reg),
371 debug_print_swizzle(reg->u.swizzle));
373 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
374 debug_print_relarg(reg),
375 debug_print_swizzle(reg->u.swizzle));
376 case BWRITERSPSM_X2NEG:
377 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
378 debug_print_relarg(reg),
379 debug_print_swizzle(reg->u.swizzle));
381 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
382 debug_print_relarg(reg),
383 debug_print_swizzle(reg->u.swizzle));
385 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
386 debug_print_relarg(reg),
387 debug_print_swizzle(reg->u.swizzle));
388 case BWRITERSPSM_ABS:
389 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
390 debug_print_relarg(reg),
391 debug_print_swizzle(reg->u.swizzle));
392 case BWRITERSPSM_ABSNEG:
393 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
394 debug_print_relarg(reg),
395 debug_print_swizzle(reg->u.swizzle));
396 case BWRITERSPSM_NOT:
397 return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
398 debug_print_relarg(reg),
399 debug_print_swizzle(reg->u.swizzle));
401 return "Unknown modifier";
404 const char *debug_print_comp(DWORD comp)
408 case BWRITER_COMPARISON_NONE: return "";
409 case BWRITER_COMPARISON_GT: return "_gt";
410 case BWRITER_COMPARISON_EQ: return "_eq";
411 case BWRITER_COMPARISON_GE: return "_ge";
412 case BWRITER_COMPARISON_LT: return "_lt";
413 case BWRITER_COMPARISON_NE: return "_ne";
414 case BWRITER_COMPARISON_LE: return "_le";
415 default: return "_unknown";
419 const char *debug_print_opcode(DWORD opcode)
423 case BWRITERSIO_NOP: return "nop";
424 case BWRITERSIO_MOV: return "mov";
425 case BWRITERSIO_ADD: return "add";
426 case BWRITERSIO_SUB: return "sub";
427 case BWRITERSIO_MAD: return "mad";
428 case BWRITERSIO_MUL: return "mul";
429 case BWRITERSIO_RCP: return "rcp";
430 case BWRITERSIO_RSQ: return "rsq";
431 case BWRITERSIO_DP3: return "dp3";
432 case BWRITERSIO_DP4: return "dp4";
433 case BWRITERSIO_MIN: return "min";
434 case BWRITERSIO_MAX: return "max";
435 case BWRITERSIO_SLT: return "slt";
436 case BWRITERSIO_SGE: return "sge";
437 case BWRITERSIO_EXP: return "exp";
438 case BWRITERSIO_LOG: return "log";
439 case BWRITERSIO_LIT: return "lit";
440 case BWRITERSIO_DST: return "dst";
441 case BWRITERSIO_LRP: return "lrp";
442 case BWRITERSIO_FRC: return "frc";
443 case BWRITERSIO_M4x4: return "m4x4";
444 case BWRITERSIO_M4x3: return "m4x3";
445 case BWRITERSIO_M3x4: return "m3x4";
446 case BWRITERSIO_M3x3: return "m3x3";
447 case BWRITERSIO_M3x2: return "m3x2";
448 case BWRITERSIO_CALL: return "call";
449 case BWRITERSIO_CALLNZ: return "callnz";
450 case BWRITERSIO_LOOP: return "loop";
451 case BWRITERSIO_RET: return "ret";
452 case BWRITERSIO_ENDLOOP: return "endloop";
453 case BWRITERSIO_LABEL: return "label";
454 case BWRITERSIO_DCL: return "dcl";
455 case BWRITERSIO_POW: return "pow";
456 case BWRITERSIO_CRS: return "crs";
457 case BWRITERSIO_SGN: return "sgn";
458 case BWRITERSIO_ABS: return "abs";
459 case BWRITERSIO_NRM: return "nrm";
460 case BWRITERSIO_SINCOS: return "sincos";
461 case BWRITERSIO_REP: return "rep";
462 case BWRITERSIO_ENDREP: return "endrep";
463 case BWRITERSIO_IF: return "if";
464 case BWRITERSIO_IFC: return "ifc";
465 case BWRITERSIO_ELSE: return "else";
466 case BWRITERSIO_ENDIF: return "endif";
467 case BWRITERSIO_BREAK: return "break";
468 case BWRITERSIO_BREAKC: return "breakc";
469 case BWRITERSIO_MOVA: return "mova";
470 case BWRITERSIO_DEFB: return "defb";
471 case BWRITERSIO_DEFI: return "defi";
472 case BWRITERSIO_TEXCOORD: return "texcoord";
473 case BWRITERSIO_TEXKILL: return "texkill";
474 case BWRITERSIO_TEX: return "tex";
475 case BWRITERSIO_TEXBEM: return "texbem";
476 case BWRITERSIO_TEXBEML: return "texbeml";
477 case BWRITERSIO_TEXREG2AR: return "texreg2ar";
478 case BWRITERSIO_TEXREG2GB: return "texreg2gb";
479 case BWRITERSIO_TEXM3x2PAD: return "texm3x2pad";
480 case BWRITERSIO_TEXM3x2TEX: return "texm3x2tex";
481 case BWRITERSIO_TEXM3x3PAD: return "texm3x3pad";
482 case BWRITERSIO_TEXM3x3TEX: return "texm3x3tex";
483 case BWRITERSIO_TEXM3x3SPEC: return "texm3x3vspec";
484 case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
485 case BWRITERSIO_EXPP: return "expp";
486 case BWRITERSIO_LOGP: return "logp";
487 case BWRITERSIO_CND: return "cnd";
488 case BWRITERSIO_DEF: return "def";
489 case BWRITERSIO_TEXREG2RGB: return "texreg2rgb";
490 case BWRITERSIO_TEXDP3TEX: return "texdp3tex";
491 case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
492 case BWRITERSIO_TEXDP3: return "texdp3";
493 case BWRITERSIO_TEXM3x3: return "texm3x3";
494 case BWRITERSIO_TEXDEPTH: return "texdepth";
495 case BWRITERSIO_CMP: return "cmp";
496 case BWRITERSIO_BEM: return "bem";
497 case BWRITERSIO_DP2ADD: return "dp2add";
498 case BWRITERSIO_DSX: return "dsx";
499 case BWRITERSIO_DSY: return "dsy";
500 case BWRITERSIO_TEXLDD: return "texldd";
501 case BWRITERSIO_SETP: return "setp";
502 case BWRITERSIO_TEXLDL: return "texldl";
503 case BWRITERSIO_BREAKP: return "breakp";
504 case BWRITERSIO_PHASE: return "phase";
506 case BWRITERSIO_TEXLDP: return "texldp";
507 case BWRITERSIO_TEXLDB: return "texldb";
509 default: return "unknown";
513 void skip_dword_unknown(const char **ptr, unsigned int count)
518 FIXME("Skipping %u unknown DWORDs:\n", count);
519 for (i = 0; i < count; ++i)
522 FIXME("\t0x%08x\n", d);
526 static void write_dword_unknown(char **ptr, DWORD d)
528 FIXME("Writing unknown DWORD 0x%08x\n", d);
532 HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
534 TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
536 if (dxbc->count >= dxbc->size)
538 struct dxbc_section *new_sections;
539 DWORD new_size = dxbc->size << 1;
541 new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
544 ERR("Failed to allocate dxbc section memory\n");
545 return E_OUTOFMEMORY;
548 dxbc->sections = new_sections;
549 dxbc->size = new_size;
552 dxbc->sections[dxbc->count].tag = tag;
553 dxbc->sections[dxbc->count].data_size = data_size;
554 dxbc->sections[dxbc->count].data = data;
560 HRESULT dxbc_init(struct dxbc *dxbc, UINT size)
562 TRACE("dxbc %p, size %u.\n", dxbc, size);
564 /* use a good starting value for the size if none specified */
567 dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
570 ERR("Failed to allocate dxbc section memory\n");
571 return E_OUTOFMEMORY;
580 HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc)
582 const char *ptr = data;
585 DWORD tag, total_size, chunk_count;
589 WARN("No data supplied.\n");
593 read_dword(&ptr, &tag);
594 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
598 WARN("Wrong tag.\n");
603 skip_dword_unknown(&ptr, 4);
605 skip_dword_unknown(&ptr, 1);
607 read_dword(&ptr, &total_size);
608 TRACE("total size: %#x\n", total_size);
610 if (data_size != total_size)
612 WARN("Wrong size supplied.\n");
613 return D3DERR_INVALIDCALL;
616 read_dword(&ptr, &chunk_count);
617 TRACE("chunk count: %#x\n", chunk_count);
619 hr = dxbc_init(dxbc, chunk_count);
622 WARN("Failed to init dxbc\n");
626 for (i = 0; i < chunk_count; ++i)
628 DWORD chunk_tag, chunk_size;
629 const char *chunk_ptr;
632 read_dword(&ptr, &chunk_offset);
633 TRACE("chunk %u at offset %#x\n", i, chunk_offset);
635 chunk_ptr = data + chunk_offset;
637 read_dword(&chunk_ptr, &chunk_tag);
638 read_dword(&chunk_ptr, &chunk_size);
640 hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
643 WARN("Failed to add section to dxbc\n");
651 void dxbc_destroy(struct dxbc *dxbc)
653 TRACE("dxbc %p.\n", dxbc);
655 HeapFree(GetProcessHeap(), 0, dxbc->sections);
658 HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob)
660 DWORD size = 32, offset = size + 4 * dxbc->count;
666 TRACE("dxbc %p, blob %p.\n", dxbc, blob);
668 for (i = 0; i < dxbc->count; ++i)
670 size += 12 + dxbc->sections[i].data_size;
673 hr = D3DCreateBlob(size, &object);
676 WARN("Failed to create blob\n");
680 ptr = ID3D10Blob_GetBufferPointer(object);
682 write_dword(&ptr, TAG_DXBC);
685 write_dword_unknown(&ptr, 0);
686 write_dword_unknown(&ptr, 0);
687 write_dword_unknown(&ptr, 0);
688 write_dword_unknown(&ptr, 0);
690 /* seems to be always 1 */
691 write_dword_unknown(&ptr, 1);
694 write_dword(&ptr, size);
697 write_dword(&ptr, dxbc->count);
699 /* write the chunk offsets */
700 for (i = 0; i < dxbc->count; ++i)
702 write_dword(&ptr, offset);
703 offset += 8 + dxbc->sections[i].data_size;
706 /* write the chunks */
707 for (i = 0; i < dxbc->count; ++i)
709 write_dword(&ptr, dxbc->sections[i].tag);
710 write_dword(&ptr, dxbc->sections[i].data_size);
711 memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
712 ptr += dxbc->sections[i].data_size;
715 TRACE("Created ID3DBlob %p\n", object);
722 void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args)
727 if (msg->capacity == 0)
729 msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE);
730 if (msg->string == NULL)
732 ERR("Error allocating memory for parser messages\n");
735 msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
740 rc = vsnprintf(msg->string + msg->size,
741 msg->capacity - msg->size, fmt, args);
743 if (rc < 0 || rc >= msg->capacity - msg->size)
745 size = msg->capacity * 2;
746 buffer = d3dcompiler_realloc(msg->string, size);
749 ERR("Error reallocating memory for parser messages\n");
752 msg->string = buffer;
753 msg->capacity = size;
757 TRACE("%s", msg->string + msg->size);
764 BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
766 struct hlsl_ir_var *var;
768 LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
770 if (!strcmp(decl->name, var->name))
773 if (local_var && scope->upper->upper == hlsl_ctx.globals)
775 /* Check whether the variable redefines a function parameter. */
776 LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
778 if (!strcmp(decl->name, var->name))
783 list_add_tail(&scope->vars, &decl->scope_entry);
787 struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name)
789 struct hlsl_ir_var *var;
791 LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
793 if (!strcmp(name, var->name))
798 return get_variable(scope->upper, name);
801 void free_declaration(struct hlsl_ir_var *decl)
803 d3dcompiler_free((void *)decl->name);
804 d3dcompiler_free((void *)decl->semantic);
805 d3dcompiler_free(decl);
808 BOOL add_func_parameter(struct list *list, struct parse_parameter *param, const struct source_location *loc)
810 struct hlsl_ir_var *decl = d3dcompiler_alloc(sizeof(*decl));
814 ERR("Out of memory.\n");
817 decl->node.type = HLSL_IR_VAR;
818 decl->node.data_type = param->type;
819 decl->node.loc = *loc;
820 decl->name = param->name;
821 decl->semantic = param->semantic;
822 decl->modifiers = param->modifiers;
824 if (!add_declaration(hlsl_ctx.cur_scope, decl, FALSE))
826 free_declaration(decl);
829 list_add_tail(list, &decl->node.entry);
833 struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class,
834 enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
836 struct hlsl_type *type;
838 type = d3dcompiler_alloc(sizeof(*type));
841 ERR("Out of memory\n");
845 type->type = type_class;
846 type->base_type = base_type;
850 list_add_tail(&hlsl_ctx.types, &type->entry);
855 struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
861 struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive)
863 struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
865 return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
867 if (recursive && scope->upper)
868 return get_type(scope->upper, name, recursive);
872 BOOL find_function(const char *name)
874 struct hlsl_ir_function_decl *func;
876 LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
878 if (!strcmp(func->name, name))
884 unsigned int components_count_type(struct hlsl_type *type)
886 unsigned int count = 0;
887 struct hlsl_struct_field *field;
889 if (type->type <= HLSL_CLASS_LAST_NUMERIC)
891 return type->dimx * type->dimy;
893 if (type->type == HLSL_CLASS_ARRAY)
895 return components_count_type(type->e.array.type) * type->e.array.elements_count;
897 if (type->type != HLSL_CLASS_STRUCT)
899 ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
903 LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
905 count += components_count_type(field->type);
910 static BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
915 if (t1->type != t2->type)
917 if (t1->base_type != t2->base_type)
919 if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
921 if ((t1->modifiers & HLSL_MODIFIERS_COMPARISON_MASK)
922 != (t2->modifiers & HLSL_MODIFIERS_COMPARISON_MASK))
924 if (t1->dimx != t2->dimx)
926 if (t1->dimy != t2->dimy)
928 if (t1->type == HLSL_CLASS_STRUCT)
930 struct list *t1cur, *t2cur;
931 struct hlsl_struct_field *t1field, *t2field;
933 t1cur = list_head(t1->e.elements);
934 t2cur = list_head(t2->e.elements);
935 while (t1cur && t2cur)
937 t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
938 t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
939 if (!compare_hlsl_types(t1field->type, t2field->type))
941 if (strcmp(t1field->name, t2field->name))
943 t1cur = list_next(t1->e.elements, t1cur);
944 t2cur = list_next(t2->e.elements, t2cur);
949 if (t1->type == HLSL_CLASS_ARRAY)
950 return t1->e.array.elements_count == t2->e.array.elements_count
951 && compare_hlsl_types(t1->e.array.type, t2->e.array.type);
956 struct hlsl_type *clone_hlsl_type(struct hlsl_type *old)
958 struct hlsl_type *type;
959 struct hlsl_struct_field *old_field, *field;
961 type = d3dcompiler_alloc(sizeof(*type));
964 ERR("Out of memory\n");
969 type->name = d3dcompiler_strdup(old->name);
972 d3dcompiler_free(type);
976 type->type = old->type;
977 type->base_type = old->base_type;
978 type->dimx = old->dimx;
979 type->dimy = old->dimy;
980 type->modifiers = old->modifiers;
981 type->sampler_dim = old->sampler_dim;
984 case HLSL_CLASS_ARRAY:
985 type->e.array.type = old->e.array.type;
986 type->e.array.elements_count = old->e.array.elements_count;
988 case HLSL_CLASS_STRUCT:
989 type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
990 if (!type->e.elements)
992 d3dcompiler_free((void *)type->name);
993 d3dcompiler_free(type);
996 list_init(type->e.elements);
997 LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
999 field = d3dcompiler_alloc(sizeof(*field));
1002 LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
1004 d3dcompiler_free((void *)field->semantic);
1005 d3dcompiler_free((void *)field->name);
1006 d3dcompiler_free(field);
1008 d3dcompiler_free(type->e.elements);
1009 d3dcompiler_free((void *)type->name);
1010 d3dcompiler_free(type);
1013 field->type = clone_hlsl_type(old_field->type);
1014 field->name = d3dcompiler_strdup(old_field->name);
1015 if (old_field->semantic)
1016 field->semantic = d3dcompiler_strdup(old_field->semantic);
1017 field->modifiers = old_field->modifiers;
1018 list_add_tail(type->e.elements, &field->entry);
1025 list_add_tail(&hlsl_ctx.types, &type->entry);
1029 static BOOL convertible_data_type(struct hlsl_type *type)
1031 return type->type != HLSL_CLASS_OBJECT;
1034 static BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1036 if (!convertible_data_type(t1) || !convertible_data_type(t2))
1039 if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1041 /* Scalar vars can be converted to any other numeric data type */
1042 if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1044 /* The other way around is true too */
1045 if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1049 if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY)
1051 return components_count_type(t1) == components_count_type(t2);
1054 if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1055 || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY))
1057 /* e.g. float4[3] to float4 is allowed */
1058 if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2))
1060 if (components_count_type(t1) == components_count_type(t2))
1065 if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR)
1067 if (t1->dimx >= t2->dimx)
1072 if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1074 if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX
1075 && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1078 /* Matrix-vector conversion is apparently allowed if they have the same components count */
1079 if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1080 && components_count_type(t1) == components_count_type(t2))
1085 if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT)
1086 return compare_hlsl_types(t1, t2);
1091 static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1093 if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR)
1096 /* Scalar vars can be converted to pretty much everything */
1097 if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1))
1100 if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1103 if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1105 /* Matrix-vector conversion is apparently allowed if either they have the same components
1106 count or the matrix is nx1 or 1xn */
1107 if (t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1109 if (components_count_type(t1) == components_count_type(t2))
1112 return (t1->type == HLSL_CLASS_MATRIX && (t1->dimx == 1 || t1->dimy == 1))
1113 || (t2->type == HLSL_CLASS_MATRIX && (t2->dimx == 1 || t2->dimy == 1));
1117 if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1118 || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy))
1125 static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hlsl_base_type t2)
1127 enum hlsl_base_type types[] =
1136 int t1_idx = -1, t2_idx = -1, i;
1138 for (i = 0; i < sizeof(types) / sizeof(types[0]); ++i)
1140 /* Always convert away from HLSL_TYPE_HALF */
1142 t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i;
1144 t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i;
1146 if (t1_idx != -1 && t2_idx != -1)
1149 if (t1_idx == -1 || t2_idx == -1)
1151 FIXME("Unexpected base type.\n");
1152 return HLSL_TYPE_FLOAT;
1154 return t1_idx >= t2_idx ? t1 : t2;
1157 static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2,
1158 struct source_location *loc)
1160 enum hlsl_type_class type;
1161 enum hlsl_base_type base;
1162 unsigned int dimx, dimy;
1164 if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC)
1166 hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1167 "non scalar/vector/matrix data type in expression");
1171 if (compare_hlsl_types(t1, t2))
1174 if (!expr_compatible_data_types(t1, t2))
1176 hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1177 "expression data types are incompatible");
1181 if (t1->base_type == t2->base_type)
1182 base = t1->base_type;
1184 base = expr_common_base_type(t1->base_type, t2->base_type);
1186 if (t1->dimx == 1 && t1->dimy == 1)
1192 else if (t2->dimx == 1 && t2->dimy == 1)
1198 else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX)
1200 type = HLSL_CLASS_MATRIX;
1201 dimx = min(t1->dimx, t2->dimx);
1202 dimy = min(t1->dimy, t2->dimy);
1206 /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1207 unsigned int max_dim_1, max_dim_2;
1209 max_dim_1 = max(t1->dimx, t1->dimy);
1210 max_dim_2 = max(t2->dimx, t2->dimy);
1211 if (t1->dimx * t1->dimy == t2->dimx * t2->dimy)
1213 type = HLSL_CLASS_VECTOR;
1214 dimx = max(t1->dimx, t2->dimx);
1217 else if (max_dim_1 <= max_dim_2)
1220 if (type == HLSL_CLASS_VECTOR)
1234 if (type == HLSL_CLASS_VECTOR)
1247 return new_hlsl_type(NULL, type, base, dimx, dimy);
1250 static struct hlsl_ir_node *implicit_conversion(struct hlsl_ir_node *node, struct hlsl_type *type,
1251 struct source_location *loc)
1253 struct hlsl_ir_expr *cast;
1254 struct hlsl_ir_node *operands[3];
1256 if (compare_hlsl_types(node->data_type, type))
1258 TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type));
1260 operands[1] = operands[2] = NULL;
1261 cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc);
1264 cast->node.data_type = type;
1268 struct hlsl_ir_expr *new_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands,
1269 struct source_location *loc)
1271 struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr));
1272 struct hlsl_type *type;
1277 ERR("Out of memory\n");
1280 expr->node.type = HLSL_IR_EXPR;
1281 expr->node.loc = *loc;
1282 type = operands[0]->data_type;
1283 for (i = 1; i <= 2; ++i)
1287 type = expr_common_type(type, operands[i]->data_type, loc);
1290 d3dcompiler_free(expr);
1294 for (i = 0; i <= 2; ++i)
1298 if (compare_hlsl_types(operands[i]->data_type, type))
1300 TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type));
1301 if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1
1302 && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy)
1304 hlsl_report_message(operands[i]->loc.file,
1305 operands[i]->loc.line, operands[i]->loc.col, HLSL_LEVEL_WARNING,
1306 "implicit truncation of vector/matrix type");
1308 operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc);
1311 ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type));
1312 d3dcompiler_free(expr);
1316 expr->node.data_type = type;
1318 expr->operands[0] = operands[0];
1319 expr->operands[1] = operands[1];
1320 expr->operands[2] = operands[2];
1325 struct hlsl_ir_expr *hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1326 struct source_location *loc)
1328 struct hlsl_ir_expr *expr;
1329 struct hlsl_ir_node *ops[3];
1334 expr = new_expr(HLSL_IR_BINOP_MUL, ops, loc);
1338 struct hlsl_ir_expr *hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1339 struct source_location *loc)
1341 struct hlsl_ir_expr *expr;
1342 struct hlsl_ir_node *ops[3];
1347 expr = new_expr(HLSL_IR_BINOP_DIV, ops, loc);
1351 struct hlsl_ir_expr *hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1352 struct source_location *loc)
1354 struct hlsl_ir_expr *expr;
1355 struct hlsl_ir_node *ops[3];
1360 expr = new_expr(HLSL_IR_BINOP_MOD, ops, loc);
1364 struct hlsl_ir_expr *hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1365 struct source_location *loc)
1367 struct hlsl_ir_expr *expr;
1368 struct hlsl_ir_node *ops[3];
1373 expr = new_expr(HLSL_IR_BINOP_ADD, ops, loc);
1377 struct hlsl_ir_expr *hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1378 struct source_location *loc)
1380 struct hlsl_ir_expr *expr;
1381 struct hlsl_ir_node *ops[3];
1386 expr = new_expr(HLSL_IR_BINOP_SUB, ops, loc);
1390 struct hlsl_ir_expr *hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1391 struct source_location *loc)
1393 struct hlsl_ir_expr *expr;
1394 struct hlsl_ir_node *ops[3];
1399 expr = new_expr(HLSL_IR_BINOP_LESS, ops, loc);
1403 struct hlsl_ir_expr *hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1404 struct source_location *loc)
1406 struct hlsl_ir_expr *expr;
1407 struct hlsl_ir_node *ops[3];
1412 expr = new_expr(HLSL_IR_BINOP_GREATER, ops, loc);
1416 struct hlsl_ir_expr *hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1417 struct source_location *loc)
1419 struct hlsl_ir_expr *expr;
1420 struct hlsl_ir_node *ops[3];
1425 expr = new_expr(HLSL_IR_BINOP_LEQUAL, ops, loc);
1429 struct hlsl_ir_expr *hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1430 struct source_location *loc)
1432 struct hlsl_ir_expr *expr;
1433 struct hlsl_ir_node *ops[3];
1438 expr = new_expr(HLSL_IR_BINOP_GEQUAL, ops, loc);
1442 struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1443 struct source_location *loc)
1445 struct hlsl_ir_expr *expr;
1446 struct hlsl_ir_node *ops[3];
1451 expr = new_expr(HLSL_IR_BINOP_EQUAL, ops, loc);
1455 struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1456 struct source_location *loc)
1458 struct hlsl_ir_expr *expr;
1459 struct hlsl_ir_node *ops[3];
1464 expr = new_expr(HLSL_IR_BINOP_NEQUAL, ops, loc);
1468 struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var)
1470 struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
1474 ERR("Out of memory.\n");
1477 deref->node.type = HLSL_IR_DEREF;
1478 deref->node.data_type = var->node.data_type;
1479 deref->type = HLSL_IR_DEREF_VAR;
1484 static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op)
1486 static const enum hlsl_ir_expr_op ops[] =
1494 HLSL_IR_BINOP_LSHIFT,
1495 HLSL_IR_BINOP_RSHIFT,
1496 HLSL_IR_BINOP_BIT_AND,
1497 HLSL_IR_BINOP_BIT_OR,
1498 HLSL_IR_BINOP_BIT_XOR,
1504 struct hlsl_ir_node *make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op,
1505 DWORD writemask, struct hlsl_ir_node *right)
1507 struct hlsl_ir_expr *expr;
1508 struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign));
1509 struct hlsl_type *type;
1510 struct hlsl_ir_node *lhs, *rhs;
1514 ERR("Out of memory\n");
1518 TRACE("Creating proper assignment expression.\n");
1520 if (writemask == BWRITERSP_WRITEMASK_ALL)
1521 type = left->data_type;
1524 FIXME("Assignments with writemasks not supported yet.\n");
1527 assign->node.type = HLSL_IR_ASSIGNMENT;
1528 assign->node.loc = left->loc;
1529 assign->node.data_type = type;
1530 assign->writemask = writemask;
1531 FIXME("Check for casts in the lhs.\n");
1534 if (lhs->type == HLSL_IR_VAR)
1536 struct hlsl_ir_deref *lhs_deref = new_var_deref(var_from_node(lhs));
1537 lhs = &lhs_deref->node;
1539 /* FIXME: check for invalid writemasks on the lhs. */
1541 if (!compare_hlsl_types(type, rhs->data_type))
1543 struct hlsl_ir_node *converted_rhs;
1545 if (!implicit_compatible_data_types(rhs->data_type, type))
1547 hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR,
1548 "can't implicitly convert %s to %s",
1549 debug_hlsl_type(rhs->data_type), debug_hlsl_type(type));
1554 if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy)
1555 hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING,
1556 "implicit truncation of vector type");
1558 converted_rhs = implicit_conversion(rhs, type, &rhs->loc);
1561 ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type));
1566 rhs = converted_rhs;
1570 if (assign_op != ASSIGN_OP_ASSIGN)
1572 struct hlsl_ir_node *operands[3];
1573 enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
1575 if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR)
1577 FIXME("LHS expression not supported in compound assignments yet.\n");
1582 struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref;
1584 TRACE("Adding an expression for the compound assignment.\n");
1585 new_deref = new_var_deref(lhs_deref->v.var);
1586 operands[0] = &new_deref->node;
1589 expr = new_expr(op, operands, &left->loc);
1590 assign->rhs = &expr->node;
1596 return &assign->node;
1599 int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
1601 const char *name = (const char *)key;
1602 const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry);
1604 if (name == type->name)
1607 if (!name || !type->name)
1609 ERR("hlsl_type without a name in a scope?\n");
1612 return strcmp(name, type->name);
1615 static inline void *d3dcompiler_alloc_rb(size_t size)
1617 return d3dcompiler_alloc(size);
1620 static inline void *d3dcompiler_realloc_rb(void *ptr, size_t size)
1622 return d3dcompiler_realloc(ptr, size);
1625 static inline void d3dcompiler_free_rb(void *ptr)
1627 d3dcompiler_free(ptr);
1629 static const struct wine_rb_functions hlsl_type_rb_funcs =
1631 d3dcompiler_alloc_rb,
1632 d3dcompiler_realloc_rb,
1633 d3dcompiler_free_rb,
1634 compare_hlsl_types_rb,
1637 void push_scope(struct hlsl_parse_ctx *ctx)
1639 struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
1643 ERR("Out of memory!\n");
1646 TRACE("Pushing a new scope\n");
1647 list_init(&new_scope->vars);
1648 if (wine_rb_init(&new_scope->types, &hlsl_type_rb_funcs) == -1)
1650 ERR("Failed to initialize types rbtree.\n");
1651 d3dcompiler_free(new_scope);
1654 new_scope->upper = ctx->cur_scope;
1655 ctx->cur_scope = new_scope;
1656 list_add_tail(&ctx->scopes, &new_scope->entry);
1659 BOOL pop_scope(struct hlsl_parse_ctx *ctx)
1661 struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
1665 TRACE("Popping current scope\n");
1666 ctx->cur_scope = prev_scope;
1670 struct hlsl_ir_function_decl *new_func_decl(const char *name, struct hlsl_type *return_type, struct list *parameters)
1672 struct hlsl_ir_function_decl *decl;
1674 decl = d3dcompiler_alloc(sizeof(*decl));
1677 ERR("Out of memory.\n");
1680 decl->node.type = HLSL_IR_FUNCTION_DECL;
1681 decl->node.data_type = return_type;
1683 decl->parameters = parameters;
1688 static const char *debug_base_type(const struct hlsl_type *type)
1690 const char *name = "(unknown)";
1692 switch (type->base_type)
1694 case HLSL_TYPE_FLOAT: name = "float"; break;
1695 case HLSL_TYPE_HALF: name = "half"; break;
1696 case HLSL_TYPE_DOUBLE: name = "double"; break;
1697 case HLSL_TYPE_INT: name = "int"; break;
1698 case HLSL_TYPE_UINT: name = "uint"; break;
1699 case HLSL_TYPE_BOOL: name = "bool"; break;
1700 case HLSL_TYPE_SAMPLER:
1701 switch (type->sampler_dim)
1703 case HLSL_SAMPLER_DIM_GENERIC: name = "sampler"; break;
1704 case HLSL_SAMPLER_DIM_1D: name = "sampler1D"; break;
1705 case HLSL_SAMPLER_DIM_2D: name = "sampler2D"; break;
1706 case HLSL_SAMPLER_DIM_3D: name = "sampler3D"; break;
1707 case HLSL_SAMPLER_DIM_CUBE: name = "samplerCUBE"; break;
1711 FIXME("Unhandled case %u\n", type->base_type);
1716 const char *debug_hlsl_type(const struct hlsl_type *type)
1721 return debugstr_a(type->name);
1723 if (type->type == HLSL_CLASS_STRUCT)
1724 return "<anonymous struct>";
1726 name = debug_base_type(type);
1728 if (type->type == HLSL_CLASS_SCALAR)
1729 return wine_dbg_sprintf("%s", name);
1730 if (type->type == HLSL_CLASS_VECTOR)
1731 return wine_dbg_sprintf("%s%u", name, type->dimx);
1732 if (type->type == HLSL_CLASS_MATRIX)
1733 return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy);
1734 return "unexpected_type";
1737 const char *debug_modifiers(DWORD modifiers)
1742 if (modifiers & HLSL_STORAGE_EXTERN)
1743 strcat(string, " extern"); /* 7 */
1744 if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
1745 strcat(string, " nointerpolation"); /* 16 */
1746 if (modifiers & HLSL_MODIFIER_PRECISE)
1747 strcat(string, " precise"); /* 8 */
1748 if (modifiers & HLSL_STORAGE_SHARED)
1749 strcat(string, " shared"); /* 7 */
1750 if (modifiers & HLSL_STORAGE_GROUPSHARED)
1751 strcat(string, " groupshared"); /* 12 */
1752 if (modifiers & HLSL_STORAGE_STATIC)
1753 strcat(string, " static"); /* 7 */
1754 if (modifiers & HLSL_STORAGE_UNIFORM)
1755 strcat(string, " uniform"); /* 8 */
1756 if (modifiers & HLSL_STORAGE_VOLATILE)
1757 strcat(string, " volatile"); /* 9 */
1758 if (modifiers & HLSL_MODIFIER_CONST)
1759 strcat(string, " const"); /* 6 */
1760 if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
1761 strcat(string, " row_major"); /* 10 */
1762 if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
1763 strcat(string, " column_major"); /* 13 */
1764 if ((modifiers & (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) == (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT))
1765 strcat(string, " inout"); /* 6 */
1766 else if (modifiers & HLSL_MODIFIER_IN)
1767 strcat(string, " in"); /* 3 */
1768 else if (modifiers & HLSL_MODIFIER_OUT)
1769 strcat(string, " out"); /* 4 */
1771 return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
1774 static const char *debug_node_type(enum hlsl_ir_node_type type)
1776 const char *names[] =
1779 "HLSL_IR_ASSIGNMENT",
1781 "HLSL_IR_CONSTRUCTOR",
1784 "HLSL_IR_FUNCTION_DECL",
1790 if (type >= sizeof(names) / sizeof(names[0]))
1791 return "Unexpected node type";
1795 static void debug_dump_instr(const struct hlsl_ir_node *instr);
1797 static void debug_dump_instr_list(const struct list *list)
1799 struct hlsl_ir_node *instr;
1801 LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry)
1803 debug_dump_instr(instr);
1808 static void debug_dump_ir_var(const struct hlsl_ir_var *var)
1811 TRACE("%s ", debug_modifiers(var->modifiers));
1812 TRACE("%s %s", debug_hlsl_type(var->node.data_type), var->name);
1814 TRACE(" : %s", debugstr_a(var->semantic));
1817 static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref)
1819 switch (deref->type)
1821 case HLSL_IR_DEREF_VAR:
1823 debug_dump_ir_var(deref->v.var);
1826 case HLSL_IR_DEREF_ARRAY:
1827 debug_dump_instr(deref->v.array.array);
1829 debug_dump_instr(deref->v.array.index);
1832 case HLSL_IR_DEREF_RECORD:
1833 debug_dump_instr(deref->v.record.record);
1834 TRACE(".%s", debugstr_a(deref->v.record.field));
1839 static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant)
1841 struct hlsl_type *type = constant->node.data_type;
1844 if (type->dimy != 1)
1846 for (y = 0; y < type->dimy; ++y)
1848 if (type->dimx != 1)
1850 for (x = 0; x < type->dimx; ++x)
1852 switch (type->base_type)
1854 case HLSL_TYPE_FLOAT:
1855 TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]);
1857 case HLSL_TYPE_DOUBLE:
1858 TRACE("%g ", constant->v.value.d[y * type->dimx + x]);
1861 TRACE("%d ", constant->v.value.i[y * type->dimx + x]);
1863 case HLSL_TYPE_UINT:
1864 TRACE("%u ", constant->v.value.u[y * type->dimx + x]);
1866 case HLSL_TYPE_BOOL:
1867 TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true");
1870 TRACE("Constants of type %s not supported\n", debug_base_type(type));
1873 if (type->dimx != 1)
1876 if (type->dimy != 1)
1880 static const char *debug_expr_op(const struct hlsl_ir_expr *expr)
1882 static const char *op_names[] =
1950 if (expr->op == HLSL_IR_UNOP_CAST)
1951 return debug_hlsl_type(expr->node.data_type);
1953 return op_names[expr->op];
1956 /* Dumps the expression in a prefix "operator (operands)" form */
1957 static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr)
1961 TRACE("%s (", debug_expr_op(expr));
1962 for (i = 0; i < 3 && expr->operands[i]; ++i)
1964 debug_dump_instr(expr->operands[i]);
1970 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor)
1972 struct hlsl_ir_node *arg;
1974 TRACE("%s (", debug_hlsl_type(constructor->node.data_type));
1975 LIST_FOR_EACH_ENTRY(arg, constructor->arguments, struct hlsl_ir_node, entry)
1977 debug_dump_instr(arg);
1983 static const char *debug_writemask(DWORD writemask)
1985 char string[5], components[] = {'x', 'y', 'z', 'w'};
1986 unsigned int i = 0, pos = 0;
1991 string[pos++] = components[i];
1996 return wine_dbg_sprintf(".%s", string);
1999 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign)
2002 debug_dump_instr(assign->lhs);
2003 if (assign->writemask != BWRITERSP_WRITEMASK_ALL)
2004 TRACE("%s", debug_writemask(assign->writemask));
2006 debug_dump_instr(assign->rhs);
2010 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle *swizzle)
2014 debug_dump_instr(swizzle->val);
2016 if (swizzle->val->data_type->dimy > 1)
2018 for (i = 0; i < swizzle->node.data_type->dimx; ++i)
2019 TRACE("_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf);
2023 char c[] = {'x', 'y', 'z', 'w'};
2025 for (i = 0; i < swizzle->node.data_type->dimx; ++i)
2026 TRACE("%c", c[(swizzle->swizzle >> i * 2) & 0x3]);
2030 static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump)
2034 case HLSL_IR_JUMP_BREAK:
2037 case HLSL_IR_JUMP_CONTINUE:
2040 case HLSL_IR_JUMP_DISCARD:
2043 case HLSL_IR_JUMP_RETURN:
2045 if (jump->return_value)
2046 debug_dump_instr(jump->return_value);
2052 static void debug_dump_ir_if(const struct hlsl_ir_if *if_node)
2055 debug_dump_instr(if_node->condition);
2057 debug_dump_instr_list(if_node->then_instrs);
2059 if (if_node->else_instrs)
2062 debug_dump_instr_list(if_node->else_instrs);
2067 static void debug_dump_instr(const struct hlsl_ir_node *instr)
2069 switch (instr->type)
2072 debug_dump_ir_expr(expr_from_node(instr));
2075 debug_dump_ir_deref(deref_from_node(instr));
2077 case HLSL_IR_CONSTANT:
2078 debug_dump_ir_constant(constant_from_node(instr));
2080 case HLSL_IR_ASSIGNMENT:
2081 debug_dump_ir_assignment(assignment_from_node(instr));
2083 case HLSL_IR_SWIZZLE:
2084 debug_dump_ir_swizzle(swizzle_from_node(instr));
2086 case HLSL_IR_CONSTRUCTOR:
2087 debug_dump_ir_constructor(constructor_from_node(instr));
2090 debug_dump_ir_jump(jump_from_node(instr));
2093 debug_dump_ir_if(if_from_node(instr));
2096 TRACE("No dump function for %s\n", debug_node_type(instr->type));
2100 void debug_dump_ir_function(const struct hlsl_ir_function_decl *func)
2102 struct hlsl_ir_var *param;
2104 TRACE("Dumping function %s.\n", debugstr_a(func->name));
2105 TRACE("Function parameters:\n");
2106 LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, node.entry)
2108 debug_dump_ir_var(param);
2112 TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
2115 debug_dump_instr_list(func->body);
2119 void free_hlsl_type(struct hlsl_type *type)
2121 struct hlsl_struct_field *field, *next_field;
2123 d3dcompiler_free((void *)type->name);
2124 if (type->type == HLSL_CLASS_STRUCT)
2126 LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
2128 d3dcompiler_free((void *)field->name);
2129 d3dcompiler_free((void *)field->semantic);
2130 d3dcompiler_free(field);
2133 d3dcompiler_free(type);
2136 void free_instr_list(struct list *list)
2138 struct hlsl_ir_node *node, *next_node;
2142 LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry)
2146 static void free_ir_constant(struct hlsl_ir_constant *constant)
2148 struct hlsl_type *type = constant->node.data_type;
2150 struct hlsl_ir_constant *field, *next_field;
2154 case HLSL_CLASS_ARRAY:
2155 for (i = 0; i < type->e.array.elements_count; ++i)
2156 free_ir_constant(&constant->v.array_elements[i]);
2157 d3dcompiler_free(constant->v.array_elements);
2159 case HLSL_CLASS_STRUCT:
2160 LIST_FOR_EACH_ENTRY_SAFE(field, next_field, constant->v.struct_elements, struct hlsl_ir_constant, node.entry)
2161 free_ir_constant(field);
2166 d3dcompiler_free(constant);
2169 static void free_ir_deref(struct hlsl_ir_deref *deref)
2171 switch (deref->type)
2173 case HLSL_IR_DEREF_VAR:
2174 /* Variables are shared among nodes in the tree. */
2176 case HLSL_IR_DEREF_ARRAY:
2177 free_instr(deref->v.array.array);
2178 free_instr(deref->v.array.index);
2180 case HLSL_IR_DEREF_RECORD:
2181 free_instr(deref->v.record.record);
2182 d3dcompiler_free((void *)deref->v.record.field);
2185 d3dcompiler_free(deref);
2188 static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle)
2190 free_instr(swizzle->val);
2191 d3dcompiler_free(swizzle);
2194 static void free_ir_constructor(struct hlsl_ir_constructor *constructor)
2196 free_instr_list(constructor->arguments);
2197 d3dcompiler_free(constructor);
2200 static void free_ir_expr(struct hlsl_ir_expr *expr)
2204 for (i = 0; i < 3; ++i)
2206 if (!expr->operands[i])
2208 free_instr(expr->operands[i]);
2210 free_instr_list(expr->subexpressions);
2211 d3dcompiler_free(expr);
2214 static void free_ir_assignment(struct hlsl_ir_assignment *assignment)
2216 free_instr(assignment->lhs);
2217 free_instr(assignment->rhs);
2218 d3dcompiler_free(assignment);
2221 static void free_ir_if(struct hlsl_ir_if *if_node)
2223 free_instr(if_node->condition);
2224 free_instr_list(if_node->then_instrs);
2225 free_instr_list(if_node->else_instrs);
2226 d3dcompiler_free(if_node);
2229 static void free_ir_jump(struct hlsl_ir_jump *jump)
2231 if (jump->type == HLSL_IR_JUMP_RETURN)
2232 free_instr(jump->return_value);
2233 d3dcompiler_free(jump);
2236 void free_instr(struct hlsl_ir_node *node)
2241 /* These are freed later on from the scopes. */
2243 case HLSL_IR_CONSTANT:
2244 free_ir_constant(constant_from_node(node));
2247 free_ir_deref(deref_from_node(node));
2249 case HLSL_IR_SWIZZLE:
2250 free_ir_swizzle(swizzle_from_node(node));
2252 case HLSL_IR_CONSTRUCTOR:
2253 free_ir_constructor(constructor_from_node(node));
2256 free_ir_expr(expr_from_node(node));
2258 case HLSL_IR_ASSIGNMENT:
2259 free_ir_assignment(assignment_from_node(node));
2262 free_ir_if(if_from_node(node));
2265 free_ir_jump(jump_from_node(node));
2268 FIXME("Unsupported node type %s\n", debug_node_type(node->type));
2272 void free_function(struct hlsl_ir_function_decl *func)
2274 struct hlsl_ir_var *param, *next_param;
2276 d3dcompiler_free((void *)func->name);
2277 d3dcompiler_free((void *)func->semantic);
2278 LIST_FOR_EACH_ENTRY_SAFE(param, next_param, func->parameters, struct hlsl_ir_var, node.entry)
2279 d3dcompiler_free(param);
2280 d3dcompiler_free(func->parameters);
2281 free_instr_list(func->body);
2282 d3dcompiler_free(func->body);