d3dcompiler: Store data types in a RB tree for faster search.
[wine] / dlls / d3dcompiler_43 / utils.c
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, const struct source_location *loc)
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.loc = *loc;
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     struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
864     if (entry)
865         return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
866
867     if (recursive && scope->upper)
868         return get_type(scope->upper, name, recursive);
869     return NULL;
870 }
871
872 BOOL find_function(const char *name)
873 {
874     struct hlsl_ir_function_decl *func;
875
876     LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
877     {
878         if (!strcmp(func->name, name))
879             return TRUE;
880     }
881     return FALSE;
882 }
883
884 unsigned int components_count_type(struct hlsl_type *type)
885 {
886     unsigned int count = 0;
887     struct hlsl_struct_field *field;
888
889     if (type->type <= HLSL_CLASS_LAST_NUMERIC)
890     {
891         return type->dimx * type->dimy;
892     }
893     if (type->type == HLSL_CLASS_ARRAY)
894     {
895         return components_count_type(type->e.array.type) * type->e.array.elements_count;
896     }
897     if (type->type != HLSL_CLASS_STRUCT)
898     {
899         ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
900         return 0;
901     }
902
903     LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
904     {
905         count += components_count_type(field->type);
906     }
907     return count;
908 }
909
910 static BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
911 {
912     if (t1 == t2)
913         return TRUE;
914
915     if (t1->type != t2->type)
916         return FALSE;
917     if (t1->base_type != t2->base_type)
918         return FALSE;
919     if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
920         return FALSE;
921     if ((t1->modifiers & HLSL_MODIFIERS_COMPARISON_MASK)
922             != (t2->modifiers & HLSL_MODIFIERS_COMPARISON_MASK))
923         return FALSE;
924     if (t1->dimx != t2->dimx)
925         return FALSE;
926     if (t1->dimy != t2->dimy)
927         return FALSE;
928     if (t1->type == HLSL_CLASS_STRUCT)
929     {
930         struct list *t1cur, *t2cur;
931         struct hlsl_struct_field *t1field, *t2field;
932
933         t1cur = list_head(t1->e.elements);
934         t2cur = list_head(t2->e.elements);
935         while (t1cur && t2cur)
936         {
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))
940                 return FALSE;
941             if (strcmp(t1field->name, t2field->name))
942                 return FALSE;
943             t1cur = list_next(t1->e.elements, t1cur);
944             t2cur = list_next(t2->e.elements, t2cur);
945         }
946         if (t1cur != t2cur)
947             return FALSE;
948     }
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);
952
953     return TRUE;
954 }
955
956 struct hlsl_type *clone_hlsl_type(struct hlsl_type *old)
957 {
958     struct hlsl_type *type;
959     struct hlsl_struct_field *old_field, *field;
960
961     type = d3dcompiler_alloc(sizeof(*type));
962     if (!type)
963     {
964         ERR("Out of memory\n");
965         return NULL;
966     }
967     if (old->name)
968     {
969         type->name = d3dcompiler_strdup(old->name);
970         if (!type->name)
971         {
972             d3dcompiler_free(type);
973             return NULL;
974         }
975     }
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;
982     switch (old->type)
983     {
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;
987             break;
988         case HLSL_CLASS_STRUCT:
989             type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
990             if (!type->e.elements)
991             {
992                 d3dcompiler_free((void *)type->name);
993                 d3dcompiler_free(type);
994                 return NULL;
995             }
996             list_init(type->e.elements);
997             LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
998             {
999                 field = d3dcompiler_alloc(sizeof(*field));
1000                 if (!field)
1001                 {
1002                     LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
1003                     {
1004                         d3dcompiler_free((void *)field->semantic);
1005                         d3dcompiler_free((void *)field->name);
1006                         d3dcompiler_free(field);
1007                     }
1008                     d3dcompiler_free(type->e.elements);
1009                     d3dcompiler_free((void *)type->name);
1010                     d3dcompiler_free(type);
1011                     return NULL;
1012                 }
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);
1019             }
1020             break;
1021         default:
1022             break;
1023     }
1024
1025     list_add_tail(&hlsl_ctx.types, &type->entry);
1026     return type;
1027 }
1028
1029 static BOOL convertible_data_type(struct hlsl_type *type)
1030 {
1031     return type->type != HLSL_CLASS_OBJECT;
1032 }
1033
1034 static BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1035 {
1036     if (!convertible_data_type(t1) || !convertible_data_type(t2))
1037         return FALSE;
1038
1039     if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1040     {
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)
1043             return TRUE;
1044         /* The other way around is true too */
1045         if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1046             return TRUE;
1047     }
1048
1049     if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY)
1050     {
1051         return components_count_type(t1) == components_count_type(t2);
1052     }
1053
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))
1056     {
1057         /* e.g. float4[3] to float4 is allowed */
1058         if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2))
1059             return TRUE;
1060         if (components_count_type(t1) == components_count_type(t2))
1061             return TRUE;
1062         return FALSE;
1063     }
1064
1065     if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR)
1066     {
1067         if (t1->dimx >= t2->dimx)
1068             return TRUE;
1069         return FALSE;
1070     }
1071
1072     if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1073     {
1074         if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX
1075                 && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1076             return TRUE;
1077
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))
1081             return TRUE;
1082         return FALSE;
1083     }
1084
1085     if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT)
1086         return compare_hlsl_types(t1, t2);
1087
1088     return FALSE;
1089 }
1090
1091 static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1092 {
1093     if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR)
1094         return FALSE;
1095
1096     /* Scalar vars can be converted to pretty much everything */
1097     if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1))
1098         return TRUE;
1099
1100     if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1101         return TRUE;
1102
1103     if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1104     {
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)
1108         {
1109             if (components_count_type(t1) == components_count_type(t2))
1110                 return TRUE;
1111
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));
1114         }
1115
1116         /* Both matrices */
1117         if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1118                 || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy))
1119             return TRUE;
1120     }
1121
1122     return FALSE;
1123 }
1124
1125 static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hlsl_base_type t2)
1126 {
1127     enum hlsl_base_type types[] =
1128     {
1129         HLSL_TYPE_BOOL,
1130         HLSL_TYPE_INT,
1131         HLSL_TYPE_UINT,
1132         HLSL_TYPE_HALF,
1133         HLSL_TYPE_FLOAT,
1134         HLSL_TYPE_DOUBLE,
1135     };
1136     int t1_idx = -1, t2_idx = -1, i;
1137
1138     for (i = 0; i < sizeof(types) / sizeof(types[0]); ++i)
1139     {
1140         /* Always convert away from HLSL_TYPE_HALF */
1141         if (t1 == types[i])
1142             t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i;
1143         if (t2 == types[i])
1144             t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i;
1145
1146         if (t1_idx != -1 && t2_idx != -1)
1147             break;
1148     }
1149     if (t1_idx == -1 || t2_idx == -1)
1150     {
1151         FIXME("Unexpected base type.\n");
1152         return HLSL_TYPE_FLOAT;
1153     }
1154     return t1_idx >= t2_idx ? t1 : t2;
1155 }
1156
1157 static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2,
1158         struct source_location *loc)
1159 {
1160     enum hlsl_type_class type;
1161     enum hlsl_base_type base;
1162     unsigned int dimx, dimy;
1163
1164     if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC)
1165     {
1166         hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1167                 "non scalar/vector/matrix data type in expression");
1168         return NULL;
1169     }
1170
1171     if (compare_hlsl_types(t1, t2))
1172         return t1;
1173
1174     if (!expr_compatible_data_types(t1, t2))
1175     {
1176         hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
1177                 "expression data types are incompatible");
1178         return NULL;
1179     }
1180
1181     if (t1->base_type == t2->base_type)
1182         base = t1->base_type;
1183     else
1184         base = expr_common_base_type(t1->base_type, t2->base_type);
1185
1186     if (t1->dimx == 1 && t1->dimy == 1)
1187     {
1188         type = t2->type;
1189         dimx = t2->dimx;
1190         dimy = t2->dimy;
1191     }
1192     else if (t2->dimx == 1 && t2->dimy == 1)
1193     {
1194         type = t1->type;
1195         dimx = t1->dimx;
1196         dimy = t1->dimy;
1197     }
1198     else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX)
1199     {
1200         type = HLSL_CLASS_MATRIX;
1201         dimx = min(t1->dimx, t2->dimx);
1202         dimy = min(t1->dimy, t2->dimy);
1203     }
1204     else
1205     {
1206         /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1207         unsigned int max_dim_1, max_dim_2;
1208
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)
1212         {
1213             type = HLSL_CLASS_VECTOR;
1214             dimx = max(t1->dimx, t2->dimx);
1215             dimy = 1;
1216         }
1217         else if (max_dim_1 <= max_dim_2)
1218         {
1219             type = t1->type;
1220             if (type == HLSL_CLASS_VECTOR)
1221             {
1222                 dimx = max_dim_1;
1223                 dimy = 1;
1224             }
1225             else
1226             {
1227                 dimx = t1->dimx;
1228                 dimy = t1->dimy;
1229             }
1230         }
1231         else
1232         {
1233             type = t2->type;
1234             if (type == HLSL_CLASS_VECTOR)
1235             {
1236                 dimx = max_dim_2;
1237                 dimy = 1;
1238             }
1239             else
1240             {
1241                 dimx = t2->dimx;
1242                 dimy = t2->dimy;
1243             }
1244         }
1245     }
1246
1247     return new_hlsl_type(NULL, type, base, dimx, dimy);
1248 }
1249
1250 static struct hlsl_ir_node *implicit_conversion(struct hlsl_ir_node *node, struct hlsl_type *type,
1251         struct source_location *loc)
1252 {
1253     struct hlsl_ir_expr *cast;
1254     struct hlsl_ir_node *operands[3];
1255
1256     if (compare_hlsl_types(node->data_type, type))
1257         return node;
1258     TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type));
1259     operands[0] = node;
1260     operands[1] = operands[2] = NULL;
1261     cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc);
1262     if (!cast)
1263         return NULL;
1264     cast->node.data_type = type;
1265     return &cast->node;
1266 }
1267
1268 struct hlsl_ir_expr *new_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands,
1269         struct source_location *loc)
1270 {
1271     struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr));
1272     struct hlsl_type *type;
1273     unsigned int i;
1274
1275     if (!expr)
1276     {
1277         ERR("Out of memory\n");
1278         return NULL;
1279     }
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)
1284     {
1285         if (!operands[i])
1286             break;
1287         type = expr_common_type(type, operands[i]->data_type, loc);
1288         if (!type)
1289         {
1290             d3dcompiler_free(expr);
1291             return NULL;
1292         }
1293     }
1294     for (i = 0; i <= 2; ++i)
1295     {
1296         if (!operands[i])
1297             break;
1298         if (compare_hlsl_types(operands[i]->data_type, type))
1299             continue;
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)
1303         {
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");
1307         }
1308         operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc);
1309         if (!operands[i])
1310         {
1311             ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type));
1312             d3dcompiler_free(expr);
1313             return NULL;
1314         }
1315     }
1316     expr->node.data_type = type;
1317     expr->op = op;
1318     expr->operands[0] = operands[0];
1319     expr->operands[1] = operands[1];
1320     expr->operands[2] = operands[2];
1321
1322     return expr;
1323 }
1324
1325 struct hlsl_ir_expr *hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1326         struct source_location *loc)
1327 {
1328     struct hlsl_ir_expr *expr;
1329     struct hlsl_ir_node *ops[3];
1330
1331     ops[0] = op1;
1332     ops[1] = op2;
1333     ops[2] = NULL;
1334     expr = new_expr(HLSL_IR_BINOP_MUL, ops, loc);
1335     return expr;
1336 }
1337
1338 struct hlsl_ir_expr *hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1339         struct source_location *loc)
1340 {
1341     struct hlsl_ir_expr *expr;
1342     struct hlsl_ir_node *ops[3];
1343
1344     ops[0] = op1;
1345     ops[1] = op2;
1346     ops[2] = NULL;
1347     expr = new_expr(HLSL_IR_BINOP_DIV, ops, loc);
1348     return expr;
1349 }
1350
1351 struct hlsl_ir_expr *hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1352         struct source_location *loc)
1353 {
1354     struct hlsl_ir_expr *expr;
1355     struct hlsl_ir_node *ops[3];
1356
1357     ops[0] = op1;
1358     ops[1] = op2;
1359     ops[2] = NULL;
1360     expr = new_expr(HLSL_IR_BINOP_MOD, ops, loc);
1361     return expr;
1362 }
1363
1364 struct hlsl_ir_expr *hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1365         struct source_location *loc)
1366 {
1367     struct hlsl_ir_expr *expr;
1368     struct hlsl_ir_node *ops[3];
1369
1370     ops[0] = op1;
1371     ops[1] = op2;
1372     ops[2] = NULL;
1373     expr = new_expr(HLSL_IR_BINOP_ADD, ops, loc);
1374     return expr;
1375 }
1376
1377 struct hlsl_ir_expr *hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1378         struct source_location *loc)
1379 {
1380     struct hlsl_ir_expr *expr;
1381     struct hlsl_ir_node *ops[3];
1382
1383     ops[0] = op1;
1384     ops[1] = op2;
1385     ops[2] = NULL;
1386     expr = new_expr(HLSL_IR_BINOP_SUB, ops, loc);
1387     return expr;
1388 }
1389
1390 struct hlsl_ir_expr *hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1391         struct source_location *loc)
1392 {
1393     struct hlsl_ir_expr *expr;
1394     struct hlsl_ir_node *ops[3];
1395
1396     ops[0] = op1;
1397     ops[1] = op2;
1398     ops[2] = NULL;
1399     expr = new_expr(HLSL_IR_BINOP_LESS, ops, loc);
1400     return expr;
1401 }
1402
1403 struct hlsl_ir_expr *hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1404         struct source_location *loc)
1405 {
1406     struct hlsl_ir_expr *expr;
1407     struct hlsl_ir_node *ops[3];
1408
1409     ops[0] = op1;
1410     ops[1] = op2;
1411     ops[2] = NULL;
1412     expr = new_expr(HLSL_IR_BINOP_GREATER, ops, loc);
1413     return expr;
1414 }
1415
1416 struct hlsl_ir_expr *hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1417         struct source_location *loc)
1418 {
1419     struct hlsl_ir_expr *expr;
1420     struct hlsl_ir_node *ops[3];
1421
1422     ops[0] = op1;
1423     ops[1] = op2;
1424     ops[2] = NULL;
1425     expr = new_expr(HLSL_IR_BINOP_LEQUAL, ops, loc);
1426     return expr;
1427 }
1428
1429 struct hlsl_ir_expr *hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1430         struct source_location *loc)
1431 {
1432     struct hlsl_ir_expr *expr;
1433     struct hlsl_ir_node *ops[3];
1434
1435     ops[0] = op1;
1436     ops[1] = op2;
1437     ops[2] = NULL;
1438     expr = new_expr(HLSL_IR_BINOP_GEQUAL, ops, loc);
1439     return expr;
1440 }
1441
1442 struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1443         struct source_location *loc)
1444 {
1445     struct hlsl_ir_expr *expr;
1446     struct hlsl_ir_node *ops[3];
1447
1448     ops[0] = op1;
1449     ops[1] = op2;
1450     ops[2] = NULL;
1451     expr = new_expr(HLSL_IR_BINOP_EQUAL, ops, loc);
1452     return expr;
1453 }
1454
1455 struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2,
1456         struct source_location *loc)
1457 {
1458     struct hlsl_ir_expr *expr;
1459     struct hlsl_ir_node *ops[3];
1460
1461     ops[0] = op1;
1462     ops[1] = op2;
1463     ops[2] = NULL;
1464     expr = new_expr(HLSL_IR_BINOP_NEQUAL, ops, loc);
1465     return expr;
1466 }
1467
1468 struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var)
1469 {
1470     struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
1471
1472     if (!deref)
1473     {
1474         ERR("Out of memory.\n");
1475         return NULL;
1476     }
1477     deref->node.type = HLSL_IR_DEREF;
1478     deref->node.data_type = var->node.data_type;
1479     deref->type = HLSL_IR_DEREF_VAR;
1480     deref->v.var = var;
1481     return deref;
1482 }
1483
1484 static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op)
1485 {
1486     static const enum hlsl_ir_expr_op ops[] =
1487     {
1488         0,
1489         HLSL_IR_BINOP_ADD,
1490         HLSL_IR_BINOP_SUB,
1491         HLSL_IR_BINOP_MUL,
1492         HLSL_IR_BINOP_DIV,
1493         HLSL_IR_BINOP_MOD,
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,
1499     };
1500
1501     return ops[op];
1502 }
1503
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)
1506 {
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;
1511
1512     if (!assign)
1513     {
1514         ERR("Out of memory\n");
1515         return NULL;
1516     }
1517
1518     TRACE("Creating proper assignment expression.\n");
1519     rhs = right;
1520     if (writemask == BWRITERSP_WRITEMASK_ALL)
1521         type = left->data_type;
1522     else
1523     {
1524         FIXME("Assignments with writemasks not supported yet.\n");
1525         type = NULL;
1526     }
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");
1532
1533     lhs = left;
1534     if (lhs->type == HLSL_IR_VAR)
1535     {
1536         struct hlsl_ir_deref *lhs_deref = new_var_deref(var_from_node(lhs));
1537         lhs = &lhs_deref->node;
1538     }
1539     /* FIXME: check for invalid writemasks on the lhs. */
1540
1541     if (!compare_hlsl_types(type, rhs->data_type))
1542     {
1543         struct hlsl_ir_node *converted_rhs;
1544
1545         if (!implicit_compatible_data_types(rhs->data_type, type))
1546         {
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));
1550             free_instr(lhs);
1551             free_instr(rhs);
1552             return NULL;
1553         }
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");
1557
1558         converted_rhs = implicit_conversion(rhs, type, &rhs->loc);
1559         if (!converted_rhs)
1560         {
1561             ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type));
1562             free_instr(lhs);
1563             free_instr(rhs);
1564             return NULL;
1565         }
1566         rhs = converted_rhs;
1567     }
1568
1569     assign->lhs = lhs;
1570     if (assign_op != ASSIGN_OP_ASSIGN)
1571     {
1572         struct hlsl_ir_node *operands[3];
1573         enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
1574
1575         if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR)
1576         {
1577             FIXME("LHS expression not supported in compound assignments yet.\n");
1578             assign->rhs = rhs;
1579         }
1580         else
1581         {
1582             struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref;
1583
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;
1587             operands[1] = rhs;
1588             operands[2] = NULL;
1589             expr = new_expr(op, operands, &left->loc);
1590             assign->rhs = &expr->node;
1591         }
1592     }
1593     else
1594         assign->rhs = rhs;
1595
1596     return &assign->node;
1597 }
1598
1599 int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
1600 {
1601     const char *name = (const char *)key;
1602     const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry);
1603
1604     if (name == type->name)
1605         return 0;
1606
1607     if (!name || !type->name)
1608     {
1609         ERR("hlsl_type without a name in a scope?\n");
1610         return -1;
1611     }
1612     return strcmp(name, type->name);
1613 }
1614
1615 static inline void *d3dcompiler_alloc_rb(size_t size)
1616 {
1617     return d3dcompiler_alloc(size);
1618 }
1619
1620 static inline void *d3dcompiler_realloc_rb(void *ptr, size_t size)
1621 {
1622     return d3dcompiler_realloc(ptr, size);
1623 }
1624
1625 static inline void d3dcompiler_free_rb(void *ptr)
1626 {
1627     d3dcompiler_free(ptr);
1628 }
1629 static const struct wine_rb_functions hlsl_type_rb_funcs =
1630 {
1631     d3dcompiler_alloc_rb,
1632     d3dcompiler_realloc_rb,
1633     d3dcompiler_free_rb,
1634     compare_hlsl_types_rb,
1635 };
1636
1637 void push_scope(struct hlsl_parse_ctx *ctx)
1638 {
1639     struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
1640
1641     if (!new_scope)
1642     {
1643         ERR("Out of memory!\n");
1644         return;
1645     }
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)
1649     {
1650         ERR("Failed to initialize types rbtree.\n");
1651         d3dcompiler_free(new_scope);
1652         return;
1653     }
1654     new_scope->upper = ctx->cur_scope;
1655     ctx->cur_scope = new_scope;
1656     list_add_tail(&ctx->scopes, &new_scope->entry);
1657 }
1658
1659 BOOL pop_scope(struct hlsl_parse_ctx *ctx)
1660 {
1661     struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
1662     if (!prev_scope)
1663         return FALSE;
1664
1665     TRACE("Popping current scope\n");
1666     ctx->cur_scope = prev_scope;
1667     return TRUE;
1668 }
1669
1670 struct hlsl_ir_function_decl *new_func_decl(const char *name, struct hlsl_type *return_type, struct list *parameters)
1671 {
1672     struct hlsl_ir_function_decl *decl;
1673
1674     decl = d3dcompiler_alloc(sizeof(*decl));
1675     if (!decl)
1676     {
1677         ERR("Out of memory.\n");
1678         return NULL;
1679     }
1680     decl->node.type = HLSL_IR_FUNCTION_DECL;
1681     decl->node.data_type = return_type;
1682     decl->name = name;
1683     decl->parameters = parameters;
1684
1685     return decl;
1686 }
1687
1688 static const char *debug_base_type(const struct hlsl_type *type)
1689 {
1690     const char *name = "(unknown)";
1691
1692     switch (type->base_type)
1693     {
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)
1702             {
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;
1708             }
1709             break;
1710         default:
1711             FIXME("Unhandled case %u\n", type->base_type);
1712     }
1713     return name;
1714 }
1715
1716 const char *debug_hlsl_type(const struct hlsl_type *type)
1717 {
1718     const char *name;
1719
1720     if (type->name)
1721         return debugstr_a(type->name);
1722
1723     if (type->type == HLSL_CLASS_STRUCT)
1724         return "<anonymous struct>";
1725
1726     name = debug_base_type(type);
1727
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";
1735 }
1736
1737 const char *debug_modifiers(DWORD modifiers)
1738 {
1739     char string[110];
1740
1741     string[0] = 0;
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 */
1770
1771     return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
1772 }
1773
1774 static const char *debug_node_type(enum hlsl_ir_node_type type)
1775 {
1776     const char *names[] =
1777     {
1778         "HLSL_IR_VAR",
1779         "HLSL_IR_ASSIGNMENT",
1780         "HLSL_IR_CONSTANT",
1781         "HLSL_IR_CONSTRUCTOR",
1782         "HLSL_IR_DEREF",
1783         "HLSL_IR_EXPR",
1784         "HLSL_IR_FUNCTION_DECL",
1785         "HLSL_IR_IF",
1786         "HLSL_IR_JUMP",
1787         "HLSL_IR_SWIZZLE",
1788     };
1789
1790     if (type >= sizeof(names) / sizeof(names[0]))
1791         return "Unexpected node type";
1792     return names[type];
1793 }
1794
1795 static void debug_dump_instr(const struct hlsl_ir_node *instr);
1796
1797 static void debug_dump_instr_list(const struct list *list)
1798 {
1799     struct hlsl_ir_node *instr;
1800
1801     LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry)
1802     {
1803         debug_dump_instr(instr);
1804         TRACE("\n");
1805     }
1806 }
1807
1808 static void debug_dump_ir_var(const struct hlsl_ir_var *var)
1809 {
1810     if (var->modifiers)
1811         TRACE("%s ", debug_modifiers(var->modifiers));
1812     TRACE("%s %s", debug_hlsl_type(var->node.data_type), var->name);
1813     if (var->semantic)
1814         TRACE(" : %s", debugstr_a(var->semantic));
1815 }
1816
1817 static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref)
1818 {
1819     switch (deref->type)
1820     {
1821         case HLSL_IR_DEREF_VAR:
1822             TRACE("deref(");
1823             debug_dump_ir_var(deref->v.var);
1824             TRACE(")");
1825             break;
1826         case HLSL_IR_DEREF_ARRAY:
1827             debug_dump_instr(deref->v.array.array);
1828             TRACE("[");
1829             debug_dump_instr(deref->v.array.index);
1830             TRACE("]");
1831             break;
1832         case HLSL_IR_DEREF_RECORD:
1833             debug_dump_instr(deref->v.record.record);
1834             TRACE(".%s", debugstr_a(deref->v.record.field));
1835             break;
1836     }
1837 }
1838
1839 static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant)
1840 {
1841     struct hlsl_type *type = constant->node.data_type;
1842     unsigned int x, y;
1843
1844     if (type->dimy != 1)
1845         TRACE("{");
1846     for (y = 0; y < type->dimy; ++y)
1847     {
1848         if (type->dimx != 1)
1849             TRACE("{");
1850         for (x = 0; x < type->dimx; ++x)
1851         {
1852             switch (type->base_type)
1853             {
1854                 case HLSL_TYPE_FLOAT:
1855                     TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]);
1856                     break;
1857                 case HLSL_TYPE_DOUBLE:
1858                     TRACE("%g ", constant->v.value.d[y * type->dimx + x]);
1859                     break;
1860                 case HLSL_TYPE_INT:
1861                     TRACE("%d ", constant->v.value.i[y * type->dimx + x]);
1862                     break;
1863                 case HLSL_TYPE_UINT:
1864                     TRACE("%u ", constant->v.value.u[y * type->dimx + x]);
1865                     break;
1866                 case HLSL_TYPE_BOOL:
1867                     TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true");
1868                     break;
1869                 default:
1870                     TRACE("Constants of type %s not supported\n", debug_base_type(type));
1871             }
1872         }
1873         if (type->dimx != 1)
1874             TRACE("}");
1875     }
1876     if (type->dimy != 1)
1877         TRACE("}");
1878 }
1879
1880 static const char *debug_expr_op(const struct hlsl_ir_expr *expr)
1881 {
1882     static const char *op_names[] =
1883     {
1884         "~",
1885         "!",
1886         "-",
1887         "abs",
1888         "sign",
1889         "rcp",
1890         "rsq",
1891         "sqrt",
1892         "nrm",
1893         "exp2",
1894         "log2",
1895
1896         "cast",
1897
1898         "fract",
1899
1900         "sin",
1901         "cos",
1902         "sin_reduced",
1903         "cos_reduced",
1904
1905         "dsx",
1906         "dsy",
1907
1908         "sat",
1909
1910         "+",
1911         "-",
1912         "*",
1913         "/",
1914
1915         "%",
1916
1917         "<",
1918         ">",
1919         "<=",
1920         ">=",
1921         "==",
1922         "!=",
1923
1924         "&&",
1925         "||",
1926
1927         "<<",
1928         ">>",
1929         "&",
1930         "|",
1931         "^",
1932
1933         "dot",
1934         "crs",
1935         "min",
1936         "max",
1937
1938         "pow",
1939
1940         "pre++",
1941         "pre--",
1942         "post++",
1943         "post--",
1944
1945         "lerp",
1946
1947         ",",
1948     };
1949
1950     if (expr->op == HLSL_IR_UNOP_CAST)
1951         return debug_hlsl_type(expr->node.data_type);
1952
1953     return op_names[expr->op];
1954 }
1955
1956 /* Dumps the expression in a prefix "operator (operands)" form */
1957 static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr)
1958 {
1959     unsigned int i;
1960
1961     TRACE("%s (", debug_expr_op(expr));
1962     for (i = 0; i < 3 && expr->operands[i]; ++i)
1963     {
1964         debug_dump_instr(expr->operands[i]);
1965         TRACE(" ");
1966     }
1967     TRACE(")");
1968 }
1969
1970 static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor)
1971 {
1972     struct hlsl_ir_node *arg;
1973
1974     TRACE("%s (", debug_hlsl_type(constructor->node.data_type));
1975     LIST_FOR_EACH_ENTRY(arg, constructor->arguments, struct hlsl_ir_node, entry)
1976     {
1977         debug_dump_instr(arg);
1978         TRACE(" ");
1979     }
1980     TRACE(")");
1981 }
1982
1983 static const char *debug_writemask(DWORD writemask)
1984 {
1985     char string[5], components[] = {'x', 'y', 'z', 'w'};
1986     unsigned int i = 0, pos = 0;
1987
1988     while (writemask)
1989     {
1990         if (writemask & 1)
1991             string[pos++] = components[i];
1992         writemask >>= 1;
1993         i++;
1994     }
1995     string[pos] = '\0';
1996     return wine_dbg_sprintf(".%s", string);
1997 }
1998
1999 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign)
2000 {
2001     TRACE("= (");
2002     debug_dump_instr(assign->lhs);
2003     if (assign->writemask != BWRITERSP_WRITEMASK_ALL)
2004         TRACE("%s", debug_writemask(assign->writemask));
2005     TRACE(" ");
2006     debug_dump_instr(assign->rhs);
2007     TRACE(")");
2008 }
2009
2010 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle *swizzle)
2011 {
2012     unsigned int i;
2013
2014     debug_dump_instr(swizzle->val);
2015     TRACE(".");
2016     if (swizzle->val->data_type->dimy > 1)
2017     {
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);
2020     }
2021     else
2022     {
2023         char c[] = {'x', 'y', 'z', 'w'};
2024
2025         for (i = 0; i < swizzle->node.data_type->dimx; ++i)
2026             TRACE("%c", c[(swizzle->swizzle >> i * 2) & 0x3]);
2027     }
2028 }
2029
2030 static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump)
2031 {
2032     switch (jump->type)
2033     {
2034         case HLSL_IR_JUMP_BREAK:
2035             TRACE("break");
2036             break;
2037         case HLSL_IR_JUMP_CONTINUE:
2038             TRACE("continue");
2039             break;
2040         case HLSL_IR_JUMP_DISCARD:
2041             TRACE("discard");
2042             break;
2043         case HLSL_IR_JUMP_RETURN:
2044             TRACE("return ");
2045             if (jump->return_value)
2046                 debug_dump_instr(jump->return_value);
2047             TRACE(";");
2048             break;
2049     }
2050 }
2051
2052 static void debug_dump_ir_if(const struct hlsl_ir_if *if_node)
2053 {
2054     TRACE("if (");
2055     debug_dump_instr(if_node->condition);
2056     TRACE(")\n{\n");
2057     debug_dump_instr_list(if_node->then_instrs);
2058     TRACE("}\n");
2059     if (if_node->else_instrs)
2060     {
2061         TRACE("else\n{\n");
2062         debug_dump_instr_list(if_node->else_instrs);
2063         TRACE("}\n");
2064     }
2065 }
2066
2067 static void debug_dump_instr(const struct hlsl_ir_node *instr)
2068 {
2069     switch (instr->type)
2070     {
2071         case HLSL_IR_EXPR:
2072             debug_dump_ir_expr(expr_from_node(instr));
2073             break;
2074         case HLSL_IR_DEREF:
2075             debug_dump_ir_deref(deref_from_node(instr));
2076             break;
2077         case HLSL_IR_CONSTANT:
2078             debug_dump_ir_constant(constant_from_node(instr));
2079             break;
2080         case HLSL_IR_ASSIGNMENT:
2081             debug_dump_ir_assignment(assignment_from_node(instr));
2082             break;
2083         case HLSL_IR_SWIZZLE:
2084             debug_dump_ir_swizzle(swizzle_from_node(instr));
2085             break;
2086         case HLSL_IR_CONSTRUCTOR:
2087             debug_dump_ir_constructor(constructor_from_node(instr));
2088             break;
2089         case HLSL_IR_JUMP:
2090             debug_dump_ir_jump(jump_from_node(instr));
2091             break;
2092         case HLSL_IR_IF:
2093             debug_dump_ir_if(if_from_node(instr));
2094             break;
2095         default:
2096             TRACE("No dump function for %s\n", debug_node_type(instr->type));
2097     }
2098 }
2099
2100 void debug_dump_ir_function(const struct hlsl_ir_function_decl *func)
2101 {
2102     struct hlsl_ir_var *param;
2103
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)
2107     {
2108         debug_dump_ir_var(param);
2109         TRACE("\n");
2110     }
2111     if (func->semantic)
2112         TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
2113     if (func->body)
2114     {
2115         debug_dump_instr_list(func->body);
2116     }
2117 }
2118
2119 void free_hlsl_type(struct hlsl_type *type)
2120 {
2121     struct hlsl_struct_field *field, *next_field;
2122
2123     d3dcompiler_free((void *)type->name);
2124     if (type->type == HLSL_CLASS_STRUCT)
2125     {
2126         LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
2127         {
2128             d3dcompiler_free((void *)field->name);
2129             d3dcompiler_free((void *)field->semantic);
2130             d3dcompiler_free(field);
2131         }
2132     }
2133     d3dcompiler_free(type);
2134 }
2135
2136 void free_instr_list(struct list *list)
2137 {
2138     struct hlsl_ir_node *node, *next_node;
2139
2140     if (!list)
2141         return;
2142     LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry)
2143         free_instr(node);
2144 }
2145
2146 static void free_ir_constant(struct hlsl_ir_constant *constant)
2147 {
2148     struct hlsl_type *type = constant->node.data_type;
2149     unsigned int i;
2150     struct hlsl_ir_constant *field, *next_field;
2151
2152     switch (type->type)
2153     {
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);
2158             break;
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);
2162             break;
2163         default:
2164             break;
2165     }
2166     d3dcompiler_free(constant);
2167 }
2168
2169 static void free_ir_deref(struct hlsl_ir_deref *deref)
2170 {
2171     switch (deref->type)
2172     {
2173         case HLSL_IR_DEREF_VAR:
2174             /* Variables are shared among nodes in the tree. */
2175             break;
2176         case HLSL_IR_DEREF_ARRAY:
2177             free_instr(deref->v.array.array);
2178             free_instr(deref->v.array.index);
2179             break;
2180         case HLSL_IR_DEREF_RECORD:
2181             free_instr(deref->v.record.record);
2182             d3dcompiler_free((void *)deref->v.record.field);
2183             break;
2184     }
2185     d3dcompiler_free(deref);
2186 }
2187
2188 static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle)
2189 {
2190     free_instr(swizzle->val);
2191     d3dcompiler_free(swizzle);
2192 }
2193
2194 static void free_ir_constructor(struct hlsl_ir_constructor *constructor)
2195 {
2196     free_instr_list(constructor->arguments);
2197     d3dcompiler_free(constructor);
2198 }
2199
2200 static void free_ir_expr(struct hlsl_ir_expr *expr)
2201 {
2202     unsigned int i;
2203
2204     for (i = 0; i < 3; ++i)
2205     {
2206         if (!expr->operands[i])
2207             break;
2208         free_instr(expr->operands[i]);
2209     }
2210     free_instr_list(expr->subexpressions);
2211     d3dcompiler_free(expr);
2212 }
2213
2214 static void free_ir_assignment(struct hlsl_ir_assignment *assignment)
2215 {
2216     free_instr(assignment->lhs);
2217     free_instr(assignment->rhs);
2218     d3dcompiler_free(assignment);
2219 }
2220
2221 static void free_ir_if(struct hlsl_ir_if *if_node)
2222 {
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);
2227 }
2228
2229 static void free_ir_jump(struct hlsl_ir_jump *jump)
2230 {
2231     if (jump->type == HLSL_IR_JUMP_RETURN)
2232         free_instr(jump->return_value);
2233     d3dcompiler_free(jump);
2234 }
2235
2236 void free_instr(struct hlsl_ir_node *node)
2237 {
2238     switch (node->type)
2239     {
2240         case HLSL_IR_VAR:
2241             /* These are freed later on from the scopes. */
2242             break;
2243         case HLSL_IR_CONSTANT:
2244             free_ir_constant(constant_from_node(node));
2245             break;
2246         case HLSL_IR_DEREF:
2247             free_ir_deref(deref_from_node(node));
2248             break;
2249         case HLSL_IR_SWIZZLE:
2250             free_ir_swizzle(swizzle_from_node(node));
2251             break;
2252         case HLSL_IR_CONSTRUCTOR:
2253             free_ir_constructor(constructor_from_node(node));
2254             break;
2255         case HLSL_IR_EXPR:
2256             free_ir_expr(expr_from_node(node));
2257             break;
2258         case HLSL_IR_ASSIGNMENT:
2259             free_ir_assignment(assignment_from_node(node));
2260             break;
2261         case HLSL_IR_IF:
2262             free_ir_if(if_from_node(node));
2263             break;
2264         case HLSL_IR_JUMP:
2265             free_ir_jump(jump_from_node(node));
2266             break;
2267         default:
2268             FIXME("Unsupported node type %s\n", debug_node_type(node->type));
2269     }
2270 }
2271
2272 void free_function(struct hlsl_ir_function_decl *func)
2273 {
2274     struct hlsl_ir_var *param, *next_param;
2275
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);
2283 }