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 <stdio.h>
  25
  26 #include "d3dcompiler_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
  29
  30 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
  31
  32 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c)
  33 {
  34     switch (c)
  35     {
  36         WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
  37         WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
  38         WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
  39         WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
  40         WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
  41         WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
  42         WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
  43         WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
  44         default:
  45             FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
  46             return "unrecognized";
  47     }
  48 }
  49
  50 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t)
  51 {
  52     switch (t)
  53     {
  54         WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
  55         WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
  56         WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
  57         WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
  58         WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
  59         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
  60         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
  61         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
  62         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
  63         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
  64         WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
  65         WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
  66         WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
  67         WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
  68         WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
  69         WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
  70         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
  71         WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
  72         WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
  73         WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
  74         WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
  75         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
  76         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
  77         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
  78         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
  79         WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
  80         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
  81         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
  82         WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
  83         WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
  84         WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
  85         WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
  86         WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
  87         WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
  88         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
  89         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
  90         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
  91         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
  92         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
  93         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
  94         WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
  95         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
  96         WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
  97         WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
  98         WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
  99         WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
 100         default:
 101             FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
 102             return "unrecognized";
 103     }
 104 }
 105
 106 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part)
 107 {
 108     switch(part)
 109     {
 110         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
 111         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
 112         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
 113         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
 114         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
 115         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
 116         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
 117         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
 118         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
 119         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
 120         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
 121         WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
 122         default:
 123             FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
 124             return "unrecognized";
 125     }
 126 }
 127
 128 const char *debug_print_srcmod(DWORD mod)
 129 {
 130     switch (mod)
 131     {
 132         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
 133         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
 134         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
 135         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
 136         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
 137         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
 138         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
 139         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
 140         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
 141         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
 142         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
 143         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
 144         WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
 145         default:
 146             FIXME("Unrecognized source modifier %#x.\n", mod);
 147             return "unrecognized_src_mod";
 148     }
 149 }
 150
 151 #undef WINE_D3DCOMPILER_TO_STR
 152
 153 const char *debug_print_dstmod(DWORD mod)
 154 {
 155     switch (mod)
 156     {
 157         case 0:
 158             return "";
 159         case BWRITERSPDM_SATURATE:
 160             return "_sat";
 161         case BWRITERSPDM_PARTIALPRECISION:
 162             return "_pp";
 163         case BWRITERSPDM_MSAMPCENTROID:
 164             return "_centroid";
 165         case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
 166             return "_sat_pp";
 167         case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
 168             return "_sat_centroid";
 169         case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
 170             return "_pp_centroid";
 171         case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
 172             return "_sat_pp_centroid";
 173         default:
 174             return "Unexpected modifier\n";
 175     }
 176 }
 177
 178 const char *debug_print_shift(DWORD shift)
 179 {
 180     static const char * const shiftstrings[] =
 181     {
 182         "",
 183         "_x2",
 184         "_x4",
 185         "_x8",
 186         "_x16",
 187         "_x32",
 188         "",
 189         "",
 190         "",
 191         "",
 192         "",
 193         "",
 194         "_d16",
 195         "_d8",
 196         "_d4",
 197         "_d2",
 198     };
 199     return shiftstrings[shift];
 200 }
 201
 202 static const char *get_regname(const struct shader_reg *reg)
 203 {
 204     switch (reg->type)
 205     {
 206         case BWRITERSPR_TEMP:
 207             return wine_dbg_sprintf("r%u", reg->regnum);
 208         case BWRITERSPR_INPUT:
 209             return wine_dbg_sprintf("v%u", reg->regnum);
 210         case BWRITERSPR_CONST:
 211             return wine_dbg_sprintf("c%u", reg->regnum);
 212         case BWRITERSPR_ADDR:
 213             return wine_dbg_sprintf("a%u", reg->regnum);
 214         case BWRITERSPR_TEXTURE:
 215             return wine_dbg_sprintf("t%u", reg->regnum);
 216         case BWRITERSPR_RASTOUT:
 217             switch (reg->regnum)
 218             {
 219                 case BWRITERSRO_POSITION:   return "oPos";
 220                 case BWRITERSRO_FOG:        return "oFog";
 221                 case BWRITERSRO_POINT_SIZE: return "oPts";
 222                 default: return "Unexpected RASTOUT";
 223             }
 224         case BWRITERSPR_ATTROUT:
 225             return wine_dbg_sprintf("oD%u", reg->regnum);
 226         case BWRITERSPR_TEXCRDOUT:
 227             return wine_dbg_sprintf("oT%u", reg->regnum);
 228         case BWRITERSPR_OUTPUT:
 229             return wine_dbg_sprintf("o%u", reg->regnum);
 230         case BWRITERSPR_CONSTINT:
 231             return wine_dbg_sprintf("i%u", reg->regnum);
 232         case BWRITERSPR_COLOROUT:
 233             return wine_dbg_sprintf("oC%u", reg->regnum);
 234         case BWRITERSPR_DEPTHOUT:
 235             return "oDepth";
 236         case BWRITERSPR_SAMPLER:
 237             return wine_dbg_sprintf("s%u", reg->regnum);
 238         case BWRITERSPR_CONSTBOOL:
 239             return wine_dbg_sprintf("b%u", reg->regnum);
 240         case BWRITERSPR_LOOP:
 241             return "aL";
 242         case BWRITERSPR_MISCTYPE:
 243             switch (reg->regnum)
 244             {
 245                 case 0: return "vPos";
 246                 case 1: return "vFace";
 247                 default: return "unexpected misctype";
 248             }
 249         case BWRITERSPR_LABEL:
 250             return wine_dbg_sprintf("l%u", reg->regnum);
 251         case BWRITERSPR_PREDICATE:
 252             return wine_dbg_sprintf("p%u", reg->regnum);
 253         default:
 254             return wine_dbg_sprintf("unknown regname %#x", reg->type);
 255     }
 256 }
 257
 258 static const char *debug_print_writemask(DWORD mask)
 259 {
 260     char ret[6];
 261     unsigned char pos = 1;
 262
 263     if(mask == BWRITERSP_WRITEMASK_ALL) return "";
 264     ret[0] = '.';
 265     if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
 266     if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
 267     if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
 268     if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
 269     ret[pos] = 0;
 270
 271     return wine_dbg_sprintf("%s", ret);
 272 }
 273
 274 static const char *debug_print_swizzle(DWORD arg)
 275 {
 276     char ret[6];
 277     unsigned int i;
 278     DWORD swizzle[4];
 279
 280     switch (arg)
 281     {
 282         case BWRITERVS_NOSWIZZLE:
 283             return "";
 284         case BWRITERVS_SWIZZLE_X:
 285             return ".x";
 286         case BWRITERVS_SWIZZLE_Y:
 287             return ".y";
 288         case BWRITERVS_SWIZZLE_Z:
 289             return ".z";
 290         case BWRITERVS_SWIZZLE_W:
 291             return ".w";
 292     }
 293
 294     swizzle[0] = arg & 3;
 295     swizzle[1] = (arg >> 2) & 3;
 296     swizzle[2] = (arg >> 4) & 3;
 297     swizzle[3] = (arg >> 6) & 3;
 298
 299     ret[0] = '.';
 300     for (i = 0; i < 4; ++i)
 301     {
 302         switch (swizzle[i])
 303         {
 304             case 0: ret[1 + i] = 'x'; break;
 305             case 1: ret[1 + i] = 'y'; break;
 306             case 2: ret[1 + i] = 'z'; break;
 307             case 3: ret[1 + i] = 'w'; break;
 308         }
 309     }
 310     ret[5] = '\0';
 311
 312     return wine_dbg_sprintf("%s", ret);
 313 }
 314
 315 static const char *debug_print_relarg(const struct shader_reg *reg)
 316 {
 317     const char *short_swizzle;
 318     if (!reg->rel_reg) return "";
 319
 320     short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle);
 321
 322     if (reg->rel_reg->type == BWRITERSPR_ADDR)
 323         return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
 324     else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
 325         return wine_dbg_sprintf("[aL%s]", short_swizzle);
 326     else
 327         return "Unexpected relative addressing argument";
 328 }
 329
 330 const char *debug_print_dstreg(const struct shader_reg *reg)
 331 {
 332     return wine_dbg_sprintf("%s%s%s", get_regname(reg),
 333             debug_print_relarg(reg),
 334             debug_print_writemask(reg->u.writemask));
 335 }
 336
 337 const char *debug_print_srcreg(const struct shader_reg *reg)
 338 {
 339     switch (reg->srcmod)
 340     {
 341         case BWRITERSPSM_NONE:
 342             return wine_dbg_sprintf("%s%s%s", get_regname(reg),
 343                     debug_print_relarg(reg),
 344                     debug_print_swizzle(reg->u.swizzle));
 345         case BWRITERSPSM_NEG:
 346             return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
 347                     debug_print_relarg(reg),
 348                     debug_print_swizzle(reg->u.swizzle));
 349         case BWRITERSPSM_BIAS:
 350             return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
 351                     debug_print_relarg(reg),
 352                     debug_print_swizzle(reg->u.swizzle));
 353         case BWRITERSPSM_BIASNEG:
 354             return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
 355                     debug_print_relarg(reg),
 356                     debug_print_swizzle(reg->u.swizzle));
 357         case BWRITERSPSM_SIGN:
 358             return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
 359                     debug_print_relarg(reg),
 360                     debug_print_swizzle(reg->u.swizzle));
 361         case BWRITERSPSM_SIGNNEG:
 362             return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
 363                     debug_print_relarg(reg),
 364                     debug_print_swizzle(reg->u.swizzle));
 365         case BWRITERSPSM_COMP:
 366             return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
 367                     debug_print_relarg(reg),
 368                     debug_print_swizzle(reg->u.swizzle));
 369         case BWRITERSPSM_X2:
 370             return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
 371                     debug_print_relarg(reg),
 372                     debug_print_swizzle(reg->u.swizzle));
 373         case BWRITERSPSM_X2NEG:
 374             return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
 375                     debug_print_relarg(reg),
 376                     debug_print_swizzle(reg->u.swizzle));
 377         case BWRITERSPSM_DZ:
 378             return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
 379                     debug_print_relarg(reg),
 380                     debug_print_swizzle(reg->u.swizzle));
 381         case BWRITERSPSM_DW:
 382             return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
 383                     debug_print_relarg(reg),
 384                     debug_print_swizzle(reg->u.swizzle));
 385         case BWRITERSPSM_ABS:
 386             return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
 387                     debug_print_relarg(reg),
 388                     debug_print_swizzle(reg->u.swizzle));
 389         case BWRITERSPSM_ABSNEG:
 390             return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
 391                     debug_print_relarg(reg),
 392                     debug_print_swizzle(reg->u.swizzle));
 393         case BWRITERSPSM_NOT:
 394             return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
 395                     debug_print_relarg(reg),
 396                     debug_print_swizzle(reg->u.swizzle));
 397     }
 398     return "Unknown modifier";
 399 }
 400
 401 const char *debug_print_comp(DWORD comp)
 402 {
 403     switch (comp)
 404     {
 405         case BWRITER_COMPARISON_NONE: return "";
 406         case BWRITER_COMPARISON_GT:   return "_gt";
 407         case BWRITER_COMPARISON_EQ:   return "_eq";
 408         case BWRITER_COMPARISON_GE:   return "_ge";
 409         case BWRITER_COMPARISON_LT:   return "_lt";
 410         case BWRITER_COMPARISON_NE:   return "_ne";
 411         case BWRITER_COMPARISON_LE:   return "_le";
 412         default: return "_unknown";
 413     }
 414 }
 415
 416 const char *debug_print_opcode(DWORD opcode)
 417 {
 418     switch (opcode)
 419     {
 420         case BWRITERSIO_NOP:          return "nop";
 421         case BWRITERSIO_MOV:          return "mov";
 422         case BWRITERSIO_ADD:          return "add";
 423         case BWRITERSIO_SUB:          return "sub";
 424         case BWRITERSIO_MAD:          return "mad";
 425         case BWRITERSIO_MUL:          return "mul";
 426         case BWRITERSIO_RCP:          return "rcp";
 427         case BWRITERSIO_RSQ:          return "rsq";
 428         case BWRITERSIO_DP3:          return "dp3";
 429         case BWRITERSIO_DP4:          return "dp4";
 430         case BWRITERSIO_MIN:          return "min";
 431         case BWRITERSIO_MAX:          return "max";
 432         case BWRITERSIO_SLT:          return "slt";
 433         case BWRITERSIO_SGE:          return "sge";
 434         case BWRITERSIO_EXP:          return "exp";
 435         case BWRITERSIO_LOG:          return "log";
 436         case BWRITERSIO_LIT:          return "lit";
 437         case BWRITERSIO_DST:          return "dst";
 438         case BWRITERSIO_LRP:          return "lrp";
 439         case BWRITERSIO_FRC:          return "frc";
 440         case BWRITERSIO_M4x4:         return "m4x4";
 441         case BWRITERSIO_M4x3:         return "m4x3";
 442         case BWRITERSIO_M3x4:         return "m3x4";
 443         case BWRITERSIO_M3x3:         return "m3x3";
 444         case BWRITERSIO_M3x2:         return "m3x2";
 445         case BWRITERSIO_CALL:         return "call";
 446         case BWRITERSIO_CALLNZ:       return "callnz";
 447         case BWRITERSIO_LOOP:         return "loop";
 448         case BWRITERSIO_RET:          return "ret";
 449         case BWRITERSIO_ENDLOOP:      return "endloop";
 450         case BWRITERSIO_LABEL:        return "label";
 451         case BWRITERSIO_DCL:          return "dcl";
 452         case BWRITERSIO_POW:          return "pow";
 453         case BWRITERSIO_CRS:          return "crs";
 454         case BWRITERSIO_SGN:          return "sgn";
 455         case BWRITERSIO_ABS:          return "abs";
 456         case BWRITERSIO_NRM:          return "nrm";
 457         case BWRITERSIO_SINCOS:       return "sincos";
 458         case BWRITERSIO_REP:          return "rep";
 459         case BWRITERSIO_ENDREP:       return "endrep";
 460         case BWRITERSIO_IF:           return "if";
 461         case BWRITERSIO_IFC:          return "ifc";
 462         case BWRITERSIO_ELSE:         return "else";
 463         case BWRITERSIO_ENDIF:        return "endif";
 464         case BWRITERSIO_BREAK:        return "break";
 465         case BWRITERSIO_BREAKC:       return "breakc";
 466         case BWRITERSIO_MOVA:         return "mova";
 467         case BWRITERSIO_DEFB:         return "defb";
 468         case BWRITERSIO_DEFI:         return "defi";
 469         case BWRITERSIO_TEXCOORD:     return "texcoord";
 470         case BWRITERSIO_TEXKILL:      return "texkill";
 471         case BWRITERSIO_TEX:          return "tex";
 472         case BWRITERSIO_TEXBEM:       return "texbem";
 473         case BWRITERSIO_TEXBEML:      return "texbeml";
 474         case BWRITERSIO_TEXREG2AR:    return "texreg2ar";
 475         case BWRITERSIO_TEXREG2GB:    return "texreg2gb";
 476         case BWRITERSIO_TEXM3x2PAD:   return "texm3x2pad";
 477         case BWRITERSIO_TEXM3x2TEX:   return "texm3x2tex";
 478         case BWRITERSIO_TEXM3x3PAD:   return "texm3x3pad";
 479         case BWRITERSIO_TEXM3x3TEX:   return "texm3x3tex";
 480         case BWRITERSIO_TEXM3x3SPEC:  return "texm3x3vspec";
 481         case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
 482         case BWRITERSIO_EXPP:         return "expp";
 483         case BWRITERSIO_LOGP:         return "logp";
 484         case BWRITERSIO_CND:          return "cnd";
 485         case BWRITERSIO_DEF:          return "def";
 486         case BWRITERSIO_TEXREG2RGB:   return "texreg2rgb";
 487         case BWRITERSIO_TEXDP3TEX:    return "texdp3tex";
 488         case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
 489         case BWRITERSIO_TEXDP3:       return "texdp3";
 490         case BWRITERSIO_TEXM3x3:      return "texm3x3";
 491         case BWRITERSIO_TEXDEPTH:     return "texdepth";
 492         case BWRITERSIO_CMP:          return "cmp";
 493         case BWRITERSIO_BEM:          return "bem";
 494         case BWRITERSIO_DP2ADD:       return "dp2add";
 495         case BWRITERSIO_DSX:          return "dsx";
 496         case BWRITERSIO_DSY:          return "dsy";
 497         case BWRITERSIO_TEXLDD:       return "texldd";
 498         case BWRITERSIO_SETP:         return "setp";
 499         case BWRITERSIO_TEXLDL:       return "texldl";
 500         case BWRITERSIO_BREAKP:       return "breakp";
 501         case BWRITERSIO_PHASE:        return "phase";
 502
 503         case BWRITERSIO_TEXLDP:       return "texldp";
 504         case BWRITERSIO_TEXLDB:       return "texldb";
 505
 506         default:                      return "unknown";
 507     }
 508 }
 509
 510 void skip_dword_unknown(const char **ptr, unsigned int count)
 511 {
 512     unsigned int i;
 513     DWORD d;
 514
 515     FIXME("Skipping %u unknown DWORDs:\n", count);
 516     for (i = 0; i < count; ++i)
 517     {
 518         d = read_dword(ptr);
 519         FIXME("\t0x%08x\n", d);
 520     }
 521 }
 522
 523 static void write_dword_unknown(char **ptr, DWORD d)
 524 {
 525     FIXME("Writing unknown DWORD 0x%08x\n", d);
 526     write_dword(ptr, d);
 527 }
 528
 529 HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
 530 {
 531     TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
 532
 533     if (dxbc->count >= dxbc->size)
 534     {
 535         struct dxbc_section *new_sections;
 536         DWORD new_size = dxbc->size << 1;
 537
 538         new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
 539         if (!new_sections)
 540         {
 541             ERR("Failed to allocate dxbc section memory\n");
 542             return E_OUTOFMEMORY;
 543         }
 544
 545         dxbc->sections = new_sections;
 546         dxbc->size = new_size;
 547     }
 548
 549     dxbc->sections[dxbc->count].tag = tag;
 550     dxbc->sections[dxbc->count].data_size = data_size;
 551     dxbc->sections[dxbc->count].data = data;
 552     ++dxbc->count;
 553
 554     return S_OK;
 555 }
 556
 557 HRESULT dxbc_init(struct dxbc *dxbc, unsigned int size)
 558 {
 559     TRACE("dxbc %p, size %u.\n", dxbc, size);
 560
 561     /* use a good starting value for the size if none specified */
 562     if (!size) size = 2;
 563
 564     dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
 565     if (!dxbc->sections)
 566     {
 567         ERR("Failed to allocate dxbc section memory\n");
 568         return E_OUTOFMEMORY;
 569     }
 570
 571     dxbc->size = size;
 572     dxbc->count = 0;
 573
 574     return S_OK;
 575 }
 576
 577 HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc)
 578 {
 579     const char *ptr = data;
 580     HRESULT hr;
 581     unsigned int i;
 582     DWORD tag, total_size, chunk_count;
 583
 584     if (!data)
 585     {
 586         WARN("No data supplied.\n");
 587         return E_FAIL;
 588     }
 589
 590     tag = read_dword(&ptr);
 591     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 592
 593     if (tag != TAG_DXBC)
 594     {
 595         WARN("Wrong tag.\n");
 596         return E_FAIL;
 597     }
 598
 599     /* checksum? */
 600     skip_dword_unknown(&ptr, 4);
 601
 602     skip_dword_unknown(&ptr, 1);
 603
 604     total_size = read_dword(&ptr);
 605     TRACE("total size: %#x\n", total_size);
 606
 607     if (data_size != total_size)
 608     {
 609         WARN("Wrong size supplied.\n");
 610         return D3DERR_INVALIDCALL;
 611     }
 612
 613     chunk_count = read_dword(&ptr);
 614     TRACE("chunk count: %#x\n", chunk_count);
 615
 616     hr = dxbc_init(dxbc, chunk_count);
 617     if (FAILED(hr))
 618     {
 619         WARN("Failed to init dxbc\n");
 620         return hr;
 621     }
 622
 623     for (i = 0; i < chunk_count; ++i)
 624     {
 625         DWORD chunk_tag, chunk_size;
 626         const char *chunk_ptr;
 627         DWORD chunk_offset;
 628
 629         chunk_offset = read_dword(&ptr);
 630         TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 631
 632         chunk_ptr = data + chunk_offset;
 633
 634         chunk_tag = read_dword(&chunk_ptr);
 635         chunk_size = read_dword(&chunk_ptr);
 636
 637         hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
 638         if (FAILED(hr))
 639         {
 640             WARN("Failed to add section to dxbc\n");
 641             return hr;
 642         }
 643     }
 644
 645     return hr;
 646 }
 647
 648 void dxbc_destroy(struct dxbc *dxbc)
 649 {
 650     TRACE("dxbc %p.\n", dxbc);
 651
 652     HeapFree(GetProcessHeap(), 0, dxbc->sections);
 653 }
 654
 655 HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob)
 656 {
 657     DWORD size = 32, offset = size + 4 * dxbc->count;
 658     ID3DBlob *object;
 659     HRESULT hr;
 660     char *ptr;
 661     unsigned int i;
 662
 663     TRACE("dxbc %p, blob %p.\n", dxbc, blob);
 664
 665     for (i = 0; i < dxbc->count; ++i)
 666     {
 667         size += 12 + dxbc->sections[i].data_size;
 668     }
 669
 670     hr = D3DCreateBlob(size, &object);
 671     if (FAILED(hr))
 672     {
 673         WARN("Failed to create blob\n");
 674         return hr;
 675     }
 676
 677     ptr = ID3D10Blob_GetBufferPointer(object);
 678
 679     write_dword(&ptr, TAG_DXBC);
 680
 681     /* signature(?) */
 682     write_dword_unknown(&ptr, 0);
 683     write_dword_unknown(&ptr, 0);
 684     write_dword_unknown(&ptr, 0);
 685     write_dword_unknown(&ptr, 0);
 686
 687     /* seems to be always 1 */
 688     write_dword_unknown(&ptr, 1);
 689
 690     /* DXBC size */
 691     write_dword(&ptr, size);
 692
 693     /* chunk count */
 694     write_dword(&ptr, dxbc->count);
 695
 696     /* write the chunk offsets */
 697     for (i = 0; i < dxbc->count; ++i)
 698     {
 699         write_dword(&ptr, offset);
 700         offset += 8 + dxbc->sections[i].data_size;
 701     }
 702
 703     /* write the chunks */
 704     for (i = 0; i < dxbc->count; ++i)
 705     {
 706         write_dword(&ptr, dxbc->sections[i].tag);
 707         write_dword(&ptr, dxbc->sections[i].data_size);
 708         memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
 709         ptr += dxbc->sections[i].data_size;
 710     }
 711
 712     TRACE("Created ID3DBlob %p\n", object);
 713
 714     *blob = object;
 715
 716     return S_OK;
 717 }
 718
 719 void compilation_message(struct compilation_messages *msg, const char *fmt, __ms_va_list args)
 720 {
 721     char* buffer;
 722     int rc, size;
 723
 724     if (msg->capacity == 0)
 725     {
 726         msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE);
 727         if (msg->string == NULL)
 728         {
 729             ERR("Error allocating memory for parser messages\n");
 730             return;
 731         }
 732         msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
 733     }
 734
 735     while (1)
 736     {
 737         rc = vsnprintf(msg->string + msg->size,
 738                 msg->capacity - msg->size, fmt, args);
 739
 740         if (rc < 0 || rc >= msg->capacity - msg->size)
 741         {
 742             size = msg->capacity * 2;
 743             buffer = d3dcompiler_realloc(msg->string, size);
 744             if (buffer == NULL)
 745             {
 746                 ERR("Error reallocating memory for parser messages\n");
 747                 return;
 748             }
 749             msg->string = buffer;
 750             msg->capacity = size;
 751         }
 752         else
 753         {
 754             TRACE("%s", msg->string + msg->size);
 755             msg->size += rc;
 756             return;
 757         }
 758     }
 759 }
 760
 761 #if D3D_COMPILER_VERSION
 762 BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
 763 {
 764     struct hlsl_ir_var *var;
 765
 766     LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
 767     {
 768         if (!strcmp(decl->name, var->name))
 769             return FALSE;
 770     }
 771     if (local_var && scope->upper->upper == hlsl_ctx.globals)
 772     {
 773         /* Check whether the variable redefines a function parameter. */
 774         LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
 775         {
 776             if (!strcmp(decl->name, var->name))
 777                 return FALSE;
 778         }
 779     }
 780
 781     list_add_tail(&scope->vars, &decl->scope_entry);
 782     return TRUE;
 783 }
 784
 785 struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name)
 786 {
 787     struct hlsl_ir_var *var;
 788
 789     LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
 790     {
 791         if (!strcmp(name, var->name))
 792             return var;
 793     }
 794     if (!scope->upper)
 795         return NULL;
 796     return get_variable(scope->upper, name);
 797 }
 798
 799 void free_declaration(struct hlsl_ir_var *decl)
 800 {
 801     d3dcompiler_free((void *)decl->name);
 802     d3dcompiler_free((void *)decl->semantic);
 803     d3dcompiler_free((void *)decl->reg_reservation);
 804     d3dcompiler_free(decl);
 805 }
 806
 807 struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class,
 808         enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
 809 {
 810     struct hlsl_type *type;
 811
 812     type = d3dcompiler_alloc(sizeof(*type));
 813     if (!type)
 814     {
 815         ERR("Out of memory\n");
 816         return NULL;
 817     }
 818     type->name = name;
 819     type->type = type_class;
 820     type->base_type = base_type;
 821     type->dimx = dimx;
 822     type->dimy = dimy;
 823     if (type_class == HLSL_CLASS_MATRIX)
 824         type->reg_size = is_row_major(type) ? dimy : dimx;
 825     else
 826         type->reg_size = 1;
 827
 828     list_add_tail(&hlsl_ctx.types, &type->entry);
 829
 830     return type;
 831 }
 832
 833 struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size)
 834 {
 835     struct hlsl_type *type = new_hlsl_type(NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1);
 836
 837     if (!type)
 838         return NULL;
 839
 840     type->modifiers = basic_type->modifiers;
 841     type->e.array.elements_count = array_size;
 842     type->e.array.type = basic_type;
 843     type->reg_size = basic_type->reg_size * array_size;
 844     type->dimx = basic_type->dimx;
 845     type->dimy = basic_type->dimy;
 846     return type;
 847 }
 848
 849 struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive)
 850 {
 851     struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
 852     if (entry)
 853         return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
 854
 855     if (recursive && scope->upper)
 856         return get_type(scope->upper, name, recursive);
 857     return NULL;
 858 }
 859
 860 BOOL find_function(const char *name)
 861 {
 862     return wine_rb_get(&hlsl_ctx.functions, name) != NULL;
 863 }
 864
 865 unsigned int components_count_type(struct hlsl_type *type)
 866 {
 867     unsigned int count = 0;
 868     struct hlsl_struct_field *field;
 869
 870     if (type->type <= HLSL_CLASS_LAST_NUMERIC)
 871     {
 872         return type->dimx * type->dimy;
 873     }
 874     if (type->type == HLSL_CLASS_ARRAY)
 875     {
 876         return components_count_type(type->e.array.type) * type->e.array.elements_count;
 877     }
 878     if (type->type != HLSL_CLASS_STRUCT)
 879     {
 880         ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
 881         return 0;
 882     }
 883
 884     LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
 885     {
 886         count += components_count_type(field->type);
 887     }
 888     return count;
 889 }
 890
 891 BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
 892 {
 893     if (t1 == t2)
 894         return TRUE;
 895
 896     if (t1->type != t2->type)
 897         return FALSE;
 898     if (t1->base_type != t2->base_type)
 899         return FALSE;
 900     if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
 901         return FALSE;
 902     if ((t1->modifiers & HLSL_MODIFIERS_MAJORITY_MASK)
 903             != (t2->modifiers & HLSL_MODIFIERS_MAJORITY_MASK))
 904         return FALSE;
 905     if (t1->dimx != t2->dimx)
 906         return FALSE;
 907     if (t1->dimy != t2->dimy)
 908         return FALSE;
 909     if (t1->type == HLSL_CLASS_STRUCT)
 910     {
 911         struct list *t1cur, *t2cur;
 912         struct hlsl_struct_field *t1field, *t2field;
 913
 914         t1cur = list_head(t1->e.elements);
 915         t2cur = list_head(t2->e.elements);
 916         while (t1cur && t2cur)
 917         {
 918             t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
 919             t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
 920             if (!compare_hlsl_types(t1field->type, t2field->type))
 921                 return FALSE;
 922             if (strcmp(t1field->name, t2field->name))
 923                 return FALSE;
 924             t1cur = list_next(t1->e.elements, t1cur);
 925             t2cur = list_next(t2->e.elements, t2cur);
 926         }
 927         if (t1cur != t2cur)
 928             return FALSE;
 929     }
 930     if (t1->type == HLSL_CLASS_ARRAY)
 931         return t1->e.array.elements_count == t2->e.array.elements_count
 932                 && compare_hlsl_types(t1->e.array.type, t2->e.array.type);
 933
 934     return TRUE;
 935 }
 936
 937 struct hlsl_type *clone_hlsl_type(struct hlsl_type *old, unsigned int default_majority)
 938 {
 939     struct hlsl_type *type;
 940     struct hlsl_struct_field *old_field, *field;
 941
 942     type = d3dcompiler_alloc(sizeof(*type));
 943     if (!type)
 944     {
 945         ERR("Out of memory\n");
 946         return NULL;
 947     }
 948     if (old->name)
 949     {
 950         type->name = d3dcompiler_strdup(old->name);
 951         if (!type->name)
 952         {
 953             d3dcompiler_free(type);
 954             return NULL;
 955         }
 956     }
 957     type->type = old->type;
 958     type->base_type = old->base_type;
 959     type->dimx = old->dimx;
 960     type->dimy = old->dimy;
 961     type->modifiers = old->modifiers;
 962     if (!(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK))
 963         type->modifiers |= default_majority;
 964     type->sampler_dim = old->sampler_dim;
 965     switch (old->type)
 966     {
 967         case HLSL_CLASS_ARRAY:
 968             type->e.array.type = clone_hlsl_type(old->e.array.type, default_majority);
 969             type->e.array.elements_count = old->e.array.elements_count;
 970             type->reg_size = type->e.array.elements_count * type->e.array.type->reg_size;
 971             break;
 972
 973         case HLSL_CLASS_STRUCT:
 974         {
 975             unsigned int reg_size = 0;
 976
 977             type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
 978             if (!type->e.elements)
 979             {
 980                 d3dcompiler_free((void *)type->name);
 981                 d3dcompiler_free(type);
 982                 return NULL;
 983             }
 984             list_init(type->e.elements);
 985             LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
 986             {
 987                 field = d3dcompiler_alloc(sizeof(*field));
 988                 if (!field)
 989                 {
 990                     LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
 991                     {
 992                         d3dcompiler_free((void *)field->semantic);
 993                         d3dcompiler_free((void *)field->name);
 994                         d3dcompiler_free(field);
 995                     }
 996                     d3dcompiler_free(type->e.elements);
 997                     d3dcompiler_free((void *)type->name);
 998                     d3dcompiler_free(type);
 999                     return NULL;
1000                 }
1001                 field->type = clone_hlsl_type(old_field->type, default_majority);
1002                 field->name = d3dcompiler_strdup(old_field->name);
1003                 if (old_field->semantic)
1004                     field->semantic = d3dcompiler_strdup(old_field->semantic);
1005                 field->modifiers = old_field->modifiers;
1006                 field->reg_offset = reg_size;
1007                 reg_size += field->type->reg_size;
1008                 list_add_tail(type->e.elements, &field->entry);
1009             }
1010             type->reg_size = reg_size;
1011             break;
1012         }
1013
1014         case HLSL_CLASS_MATRIX:
1015             type->reg_size = is_row_major(type) ? type->dimy : type->dimx;
1016             break;
1017
1018         default:
1019             type->reg_size = 1;
1020             break;
1021     }
1022
1023     list_add_tail(&hlsl_ctx.types, &type->entry);
1024     return type;
1025 }
1026
1027 static BOOL convertible_data_type(struct hlsl_type *type)
1028 {
1029     return type->type != HLSL_CLASS_OBJECT;
1030 }
1031
1032 BOOL compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1033 {
1034    if (!convertible_data_type(t1) || !convertible_data_type(t2))
1035         return FALSE;
1036
1037     if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1038     {
1039         /* Scalar vars can be cast to pretty much everything */
1040         if (t1->dimx == 1 && t1->dimy == 1)
1041             return TRUE;
1042
1043         if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1044             return t1->dimx >= t2->dimx;
1045     }
1046
1047     /* The other way around is true too i.e. whatever to scalar */
1048     if (t2->type <= HLSL_CLASS_LAST_NUMERIC && t2->dimx == 1 && t2->dimy == 1)
1049         return TRUE;
1050
1051     if (t1->type == HLSL_CLASS_ARRAY)
1052     {
1053         if (compare_hlsl_types(t1->e.array.type, t2))
1054             /* e.g. float4[3] to float4 is allowed */
1055             return TRUE;
1056
1057         if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
1058             return components_count_type(t1) >= components_count_type(t2);
1059         else
1060             return components_count_type(t1) == components_count_type(t2);
1061     }
1062
1063     if (t1->type == HLSL_CLASS_STRUCT)
1064         return components_count_type(t1) >= components_count_type(t2);
1065
1066     if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
1067         return components_count_type(t1) == components_count_type(t2);
1068
1069     if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1070     {
1071         if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1072             return TRUE;
1073
1074         /* Matrix-vector conversion is apparently allowed if they have the same components count */
1075         if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1076                 && components_count_type(t1) == components_count_type(t2))
1077             return TRUE;
1078         return FALSE;
1079     }
1080
1081     if (components_count_type(t1) >= components_count_type(t2))
1082         return TRUE;
1083     return FALSE;
1084 }
1085
1086 static BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1087 {
1088     if (!convertible_data_type(t1) || !convertible_data_type(t2))
1089         return FALSE;
1090
1091     if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
1092     {
1093         /* Scalar vars can be converted to any other numeric data type */
1094         if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1095             return TRUE;
1096         /* The other way around is true too */
1097         if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1098             return TRUE;
1099     }
1100
1101     if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY)
1102     {
1103         return components_count_type(t1) == components_count_type(t2);
1104     }
1105
1106     if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC)
1107             || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY))
1108     {
1109         /* e.g. float4[3] to float4 is allowed */
1110         if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2))
1111             return TRUE;
1112         if (components_count_type(t1) == components_count_type(t2))
1113             return TRUE;
1114         return FALSE;
1115     }
1116
1117     if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR)
1118     {
1119         if (t1->dimx >= t2->dimx)
1120             return TRUE;
1121         return FALSE;
1122     }
1123
1124     if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1125     {
1126         if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX
1127                 && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1128             return TRUE;
1129
1130         /* Matrix-vector conversion is apparently allowed if they have the same components count */
1131         if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1132                 && components_count_type(t1) == components_count_type(t2))
1133             return TRUE;
1134         return FALSE;
1135     }
1136
1137     if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT)
1138         return compare_hlsl_types(t1, t2);
1139
1140     return FALSE;
1141 }
1142
1143 static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2)
1144 {
1145     if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR)
1146         return FALSE;
1147
1148     /* Scalar vars can be converted to pretty much everything */
1149     if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1))
1150         return TRUE;
1151
1152     if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
1153         return TRUE;
1154
1155     if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
1156     {
1157         /* Matrix-vector conversion is apparently allowed if either they have the same components
1158            count or the matrix is nx1 or 1xn */
1159         if (t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
1160         {
1161             if (components_count_type(t1) == components_count_type(t2))
1162                 return TRUE;
1163
1164             return (t1->type == HLSL_CLASS_MATRIX && (t1->dimx == 1 || t1->dimy == 1))
1165                     || (t2->type == HLSL_CLASS_MATRIX && (t2->dimx == 1 || t2->dimy == 1));
1166         }
1167
1168         /* Both matrices */
1169         if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
1170                 || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy))
1171             return TRUE;
1172     }
1173
1174     return FALSE;
1175 }
1176
1177 static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hlsl_base_type t2)
1178 {
1179     static const enum hlsl_base_type types[] =
1180     {
1181         HLSL_TYPE_BOOL,
1182         HLSL_TYPE_INT,
1183         HLSL_TYPE_UINT,
1184         HLSL_TYPE_HALF,
1185         HLSL_TYPE_FLOAT,
1186         HLSL_TYPE_DOUBLE,
1187     };
1188     int t1_idx = -1, t2_idx = -1, i;
1189
1190     for (i = 0; i < ARRAY_SIZE(types); ++i)
1191     {
1192         /* Always convert away from HLSL_TYPE_HALF */
1193         if (t1 == types[i])
1194             t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i;
1195         if (t2 == types[i])
1196             t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i;
1197
1198         if (t1_idx != -1 && t2_idx != -1)
1199             break;
1200     }
1201     if (t1_idx == -1 || t2_idx == -1)
1202     {
1203         FIXME("Unexpected base type.\n");
1204         return HLSL_TYPE_FLOAT;
1205     }
1206     return t1_idx >= t2_idx ? t1 : t2;
1207 }
1208
1209 static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2,
1210         struct source_location *loc)
1211 {
1212     enum hlsl_type_class type;
1213     enum hlsl_base_type base;
1214     unsigned int dimx, dimy;
1215
1216     if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC)
1217     {
1218         hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "non scalar/vector/matrix data type in expression");
1219         return NULL;
1220     }
1221
1222     if (compare_hlsl_types(t1, t2))
1223         return t1;
1224
1225     if (!expr_compatible_data_types(t1, t2))
1226     {
1227         hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "expression data types are incompatible");
1228         return NULL;
1229     }
1230
1231     if (t1->base_type == t2->base_type)
1232         base = t1->base_type;
1233     else
1234         base = expr_common_base_type(t1->base_type, t2->base_type);
1235
1236     if (t1->dimx == 1 && t1->dimy == 1)
1237     {
1238         type = t2->type;
1239         dimx = t2->dimx;
1240         dimy = t2->dimy;
1241     }
1242     else if (t2->dimx == 1 && t2->dimy == 1)
1243     {
1244         type = t1->type;
1245         dimx = t1->dimx;
1246         dimy = t1->dimy;
1247     }
1248     else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX)
1249     {
1250         type = HLSL_CLASS_MATRIX;
1251         dimx = min(t1->dimx, t2->dimx);
1252         dimy = min(t1->dimy, t2->dimy);
1253     }
1254     else
1255     {
1256         /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
1257         unsigned int max_dim_1, max_dim_2;
1258
1259         max_dim_1 = max(t1->dimx, t1->dimy);
1260         max_dim_2 = max(t2->dimx, t2->dimy);
1261         if (t1->dimx * t1->dimy == t2->dimx * t2->dimy)
1262         {
1263             type = HLSL_CLASS_VECTOR;
1264             dimx = max(t1->dimx, t2->dimx);
1265             dimy = 1;
1266         }
1267         else if (max_dim_1 <= max_dim_2)
1268         {
1269             type = t1->type;
1270             if (type == HLSL_CLASS_VECTOR)
1271             {
1272                 dimx = max_dim_1;
1273                 dimy = 1;
1274             }
1275             else
1276             {
1277                 dimx = t1->dimx;
1278                 dimy = t1->dimy;
1279             }
1280         }
1281         else
1282         {
1283             type = t2->type;
1284             if (type == HLSL_CLASS_VECTOR)
1285             {
1286                 dimx = max_dim_2;
1287                 dimy = 1;
1288             }
1289             else
1290             {
1291                 dimx = t2->dimx;
1292                 dimy = t2->dimy;
1293             }
1294         }
1295     }
1296
1297     if (type == HLSL_CLASS_SCALAR)
1298         return hlsl_ctx.builtin_types.scalar[base];
1299     if (type == HLSL_CLASS_VECTOR)
1300         return hlsl_ctx.builtin_types.vector[base][dimx - 1];
1301     return new_hlsl_type(NULL, type, base, dimx, dimy);
1302 }
1303
1304 struct hlsl_ir_node *add_implicit_conversion(struct list *instrs, struct hlsl_ir_node *node,
1305         struct hlsl_type *dst_type, struct source_location *loc)
1306 {
1307     struct hlsl_type *src_type = node->data_type;
1308     struct hlsl_ir_expr *cast;
1309
1310     if (compare_hlsl_types(src_type, dst_type))
1311         return node;
1312
1313     if (!implicit_compatible_data_types(src_type, dst_type))
1314     {
1315         hlsl_report_message(*loc, HLSL_LEVEL_ERROR, "can't implicitly convert %s to %s",
1316                 debug_hlsl_type(src_type), debug_hlsl_type(dst_type));
1317         return NULL;
1318     }
1319
1320     if (dst_type->dimx * dst_type->dimy < src_type->dimx * src_type->dimy)
1321         hlsl_report_message(*loc, HLSL_LEVEL_WARNING, "implicit truncation of vector type");
1322
1323     TRACE("Implicit conversion from %s to %s.\n", debug_hlsl_type(src_type), debug_hlsl_type(dst_type));
1324
1325     if (!(cast = new_cast(node, dst_type, loc)))
1326         return NULL;
1327     list_add_tail(instrs, &cast->node.entry);
1328     return &cast->node;
1329 }
1330
1331 struct hlsl_ir_expr *add_expr(struct list *instrs, enum hlsl_ir_expr_op op, struct hlsl_ir_node *operands[3],
1332         struct source_location *loc)
1333 {
1334     struct hlsl_ir_expr *expr;
1335     struct hlsl_type *type;
1336     unsigned int i;
1337
1338     type = operands[0]->data_type;
1339     for (i = 1; i <= 2; ++i)
1340     {
1341         if (!operands[i])
1342             break;
1343         type = expr_common_type(type, operands[i]->data_type, loc);
1344         if (!type)
1345             return NULL;
1346     }
1347     for (i = 0; i <= 2; ++i)
1348     {
1349         struct hlsl_ir_expr *cast;
1350
1351         if (!operands[i])
1352             break;
1353         if (compare_hlsl_types(operands[i]->data_type, type))
1354             continue;
1355         TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type));
1356         if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1
1357                 && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy)
1358         {
1359             hlsl_report_message(operands[i]->loc, HLSL_LEVEL_WARNING, "implicit truncation of vector/matrix type");
1360         }
1361
1362         if (!(cast = new_cast(operands[i], type, &operands[i]->loc)))
1363             return NULL;
1364         list_add_after(&operands[i]->entry, &cast->node.entry);
1365         operands[i] = &cast->node;
1366     }
1367
1368     if (!(expr = d3dcompiler_alloc(sizeof(*expr))))
1369         return NULL;
1370     init_node(&expr->node, HLSL_IR_EXPR, type, *loc);
1371     expr->op = op;
1372     for (i = 0; i <= 2; ++i)
1373         hlsl_src_from_node(&expr->operands[i], operands[i]);
1374     list_add_tail(instrs, &expr->node.entry);
1375
1376     return expr;
1377 }
1378
1379 struct hlsl_ir_expr *new_cast(struct hlsl_ir_node *node, struct hlsl_type *type,
1380         struct source_location *loc)
1381 {
1382     struct hlsl_ir_node *cast;
1383
1384     cast = new_unary_expr(HLSL_IR_UNOP_CAST, node, *loc);
1385     if (cast)
1386         cast->data_type = type;
1387     return expr_from_node(cast);
1388 }
1389
1390 static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op)
1391 {
1392     static const enum hlsl_ir_expr_op ops[] =
1393     {
1394         0,
1395         HLSL_IR_BINOP_ADD,
1396         HLSL_IR_BINOP_SUB,
1397         HLSL_IR_BINOP_MUL,
1398         HLSL_IR_BINOP_DIV,
1399         HLSL_IR_BINOP_MOD,
1400         HLSL_IR_BINOP_LSHIFT,
1401         HLSL_IR_BINOP_RSHIFT,
1402         HLSL_IR_BINOP_BIT_AND,
1403         HLSL_IR_BINOP_BIT_OR,
1404         HLSL_IR_BINOP_BIT_XOR,
1405     };
1406
1407     return ops[op];
1408 }
1409
1410 static BOOL invert_swizzle(unsigned int *swizzle, unsigned int *writemask, unsigned int *ret_width)
1411 {
1412     unsigned int i, j, bit = 0, inverted = 0, width, new_writemask = 0, new_swizzle = 0;
1413
1414     /* Apply the writemask to the swizzle to get a new writemask and swizzle. */
1415     for (i = 0; i < 4; ++i)
1416     {
1417         if (*writemask & (1 << i))
1418         {
1419             unsigned int s = (*swizzle >> (i * 2)) & 3;
1420             new_swizzle |= s << (bit++ * 2);
1421             if (new_writemask & (1 << s))
1422                 return FALSE;
1423             new_writemask |= 1 << s;
1424         }
1425     }
1426     width = bit;
1427
1428     /* Invert the swizzle. */
1429     bit = 0;
1430     for (i = 0; i < 4; ++i)
1431     {
1432         for (j = 0; j < width; ++j)
1433         {
1434             unsigned int s = (new_swizzle >> (j * 2)) & 3;
1435             if (s == i)
1436                 inverted |= j << (bit++ * 2);
1437         }
1438     }
1439
1440     *swizzle = inverted;
1441     *writemask = new_writemask;
1442     *ret_width = width;
1443     return TRUE;
1444 }
1445
1446 struct hlsl_ir_node *add_assignment(struct list *instrs, struct hlsl_ir_node *lhs,
1447         enum parse_assign_op assign_op, struct hlsl_ir_node *rhs)
1448 {
1449     struct hlsl_ir_assignment *assign;
1450     struct hlsl_type *lhs_type;
1451     DWORD writemask = 0;
1452
1453     lhs_type = lhs->data_type;
1454     if (lhs_type->type <= HLSL_CLASS_LAST_NUMERIC)
1455     {
1456         writemask = (1 << lhs_type->dimx) - 1;
1457
1458         if (!(rhs = add_implicit_conversion(instrs, rhs, lhs_type, &rhs->loc)))
1459             return NULL;
1460     }
1461
1462     assign = d3dcompiler_alloc(sizeof(*assign));
1463     if (!assign)
1464     {
1465         ERR("Out of memory\n");
1466         return NULL;
1467     }
1468
1469     while (lhs->type != HLSL_IR_LOAD)
1470     {
1471         struct hlsl_ir_node *lhs_inner;
1472
1473         if (lhs->type == HLSL_IR_EXPR && expr_from_node(lhs)->op == HLSL_IR_UNOP_CAST)
1474         {
1475             FIXME("Cast on the lhs.\n");
1476             d3dcompiler_free(assign);
1477             return NULL;
1478         }
1479         else if (lhs->type == HLSL_IR_SWIZZLE)
1480         {
1481             struct hlsl_ir_swizzle *swizzle = swizzle_from_node(lhs);
1482             const struct hlsl_type *swizzle_type = swizzle->node.data_type;
1483             unsigned int width;
1484
1485             if (lhs->data_type->type == HLSL_CLASS_MATRIX)
1486                 FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
1487
1488             lhs_inner = swizzle->val.node;
1489             hlsl_src_remove(&swizzle->val);
1490             list_remove(&lhs->entry);
1491
1492             list_add_after(&rhs->entry, &lhs->entry);
1493             hlsl_src_from_node(&swizzle->val, rhs);
1494             if (!invert_swizzle(&swizzle->swizzle, &writemask, &width))
1495             {
1496                 hlsl_report_message(lhs->loc, HLSL_LEVEL_ERROR, "invalid writemask");
1497                 d3dcompiler_free(assign);
1498                 return NULL;
1499             }
1500             assert(swizzle_type->type == HLSL_CLASS_VECTOR);
1501             if (swizzle_type->dimx != width)
1502                 swizzle->node.data_type = hlsl_ctx.builtin_types.vector[swizzle_type->base_type][width - 1];
1503             rhs = &swizzle->node;
1504         }
1505         else
1506         {
1507             hlsl_report_message(lhs->loc, HLSL_LEVEL_ERROR, "invalid lvalue");
1508             d3dcompiler_free(assign);
1509             return NULL;
1510         }
1511
1512         lhs = lhs_inner;
1513     }
1514
1515     init_node(&assign->node, HLSL_IR_ASSIGNMENT, lhs_type, lhs->loc);
1516     assign->writemask = writemask;
1517     assign->lhs.var = load_from_node(lhs)->src.var;
1518     hlsl_src_from_node(&assign->lhs.offset, load_from_node(lhs)->src.offset.node);
1519     if (assign_op != ASSIGN_OP_ASSIGN)
1520     {
1521         enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
1522         struct hlsl_ir_node *expr;
1523
1524         TRACE("Adding an expression for the compound assignment.\n");
1525         expr = new_binary_expr(op, lhs, rhs);
1526         list_add_after(&rhs->entry, &expr->entry);
1527         rhs = expr;
1528     }
1529     hlsl_src_from_node(&assign->rhs, rhs);
1530     list_add_tail(instrs, &assign->node.entry);
1531
1532     return &assign->node;
1533 }
1534
1535 static int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
1536 {
1537     const char *name = key;
1538     const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry);
1539
1540     if (name == type->name)
1541         return 0;
1542
1543     if (!name || !type->name)
1544     {
1545         ERR("hlsl_type without a name in a scope?\n");
1546         return -1;
1547     }
1548     return strcmp(name, type->name);
1549 }
1550
1551 void push_scope(struct hlsl_parse_ctx *ctx)
1552 {
1553     struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
1554
1555     if (!new_scope)
1556     {
1557         ERR("Out of memory!\n");
1558         return;
1559     }
1560     TRACE("Pushing a new scope\n");
1561     list_init(&new_scope->vars);
1562     wine_rb_init(&new_scope->types, compare_hlsl_types_rb);
1563     new_scope->upper = ctx->cur_scope;
1564     ctx->cur_scope = new_scope;
1565     list_add_tail(&ctx->scopes, &new_scope->entry);
1566 }
1567
1568 BOOL pop_scope(struct hlsl_parse_ctx *ctx)
1569 {
1570     struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
1571     if (!prev_scope)
1572         return FALSE;
1573
1574     TRACE("Popping current scope\n");
1575     ctx->cur_scope = prev_scope;
1576     return TRUE;
1577 }
1578
1579 static int compare_param_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2)
1580 {
1581     if (t1->type != t2->type)
1582     {
1583         if (!((t1->type == HLSL_CLASS_SCALAR && t2->type == HLSL_CLASS_VECTOR)
1584                 || (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_SCALAR)))
1585             return t1->type - t2->type;
1586     }
1587     if (t1->base_type != t2->base_type)
1588         return t1->base_type - t2->base_type;
1589     if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
1590         return t1->sampler_dim - t2->sampler_dim;
1591     if (t1->dimx != t2->dimx)
1592         return t1->dimx - t2->dimx;
1593     if (t1->dimy != t2->dimy)
1594         return t1->dimx - t2->dimx;
1595     if (t1->type == HLSL_CLASS_STRUCT)
1596     {
1597         struct list *t1cur, *t2cur;
1598         struct hlsl_struct_field *t1field, *t2field;
1599         int r;
1600
1601         t1cur = list_head(t1->e.elements);
1602         t2cur = list_head(t2->e.elements);
1603         while (t1cur && t2cur)
1604         {
1605             t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
1606             t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
1607             if ((r = compare_param_hlsl_types(t1field->type, t2field->type)))
1608                 return r;
1609             if ((r = strcmp(t1field->name, t2field->name)))
1610                 return r;
1611             t1cur = list_next(t1->e.elements, t1cur);
1612             t2cur = list_next(t2->e.elements, t2cur);
1613         }
1614         if (t1cur != t2cur)
1615             return t1cur ? 1 : -1;
1616         return 0;
1617     }
1618     if (t1->type == HLSL_CLASS_ARRAY)
1619     {
1620         if (t1->e.array.elements_count != t2->e.array.elements_count)
1621             return t1->e.array.elements_count - t2->e.array.elements_count;
1622         return compare_param_hlsl_types(t1->e.array.type, t2->e.array.type);
1623     }
1624
1625     return 0;
1626 }
1627
1628 static int compare_function_decl_rb(const void *key, const struct wine_rb_entry *entry)
1629 {
1630     const struct list *params = key;
1631     const struct hlsl_ir_function_decl *decl = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function_decl, entry);
1632     int params_count = params ? list_count(params) : 0;
1633     int decl_params_count = decl->parameters ? list_count(decl->parameters) : 0;
1634     int r;
1635     struct list *p1cur, *p2cur;
1636
1637     if (params_count != decl_params_count)
1638         return params_count - decl_params_count;
1639
1640     p1cur = params ? list_head(params) : NULL;
1641     p2cur = decl->parameters ? list_head(decl->parameters) : NULL;
1642     while (p1cur && p2cur)
1643     {
1644         struct hlsl_ir_var *p1, *p2;
1645         p1 = LIST_ENTRY(p1cur, struct hlsl_ir_var, param_entry);
1646         p2 = LIST_ENTRY(p2cur, struct hlsl_ir_var, param_entry);
1647         if ((r = compare_param_hlsl_types(p1->data_type, p2->data_type)))
1648             return r;
1649         p1cur = list_next(params, p1cur);
1650         p2cur = list_next(decl->parameters, p2cur);
1651     }
1652     return 0;
1653 }
1654
1655 static int compare_function_rb(const void *key, const struct wine_rb_entry *entry)
1656 {
1657     const char *name = key;
1658     const struct hlsl_ir_function *func = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function,entry);
1659
1660     return strcmp(name, func->name);
1661 }
1662
1663 void init_functions_tree(struct wine_rb_tree *funcs)
1664 {
1665     wine_rb_init(&hlsl_ctx.functions, compare_function_rb);
1666 }
1667
1668 const char *debug_base_type(const struct hlsl_type *type)
1669 {
1670     const char *name = "(unknown)";
1671
1672     switch (type->base_type)
1673     {
1674         case HLSL_TYPE_FLOAT:        name = "float";         break;
1675         case HLSL_TYPE_HALF:         name = "half";          break;
1676         case HLSL_TYPE_DOUBLE:       name = "double";        break;
1677         case HLSL_TYPE_INT:          name = "int";           break;
1678         case HLSL_TYPE_UINT:         name = "uint";          break;
1679         case HLSL_TYPE_BOOL:         name = "bool";          break;
1680         case HLSL_TYPE_SAMPLER:
1681             switch (type->sampler_dim)
1682             {
1683                 case HLSL_SAMPLER_DIM_GENERIC: name = "sampler";       break;
1684                 case HLSL_SAMPLER_DIM_1D:      name = "sampler1D";     break;
1685                 case HLSL_SAMPLER_DIM_2D:      name = "sampler2D";     break;
1686                 case HLSL_SAMPLER_DIM_3D:      name = "sampler3D";     break;
1687                 case HLSL_SAMPLER_DIM_CUBE:    name = "samplerCUBE";   break;
1688             }
1689             break;
1690         default:
1691             FIXME("Unhandled case %u\n", type->base_type);
1692     }
1693     return name;
1694 }
1695
1696 const char *debug_hlsl_type(const struct hlsl_type *type)
1697 {
1698     const char *name;
1699
1700     if (type->name)
1701         return debugstr_a(type->name);
1702
1703     if (type->type == HLSL_CLASS_STRUCT)
1704         return "<anonymous struct>";
1705
1706     if (type->type == HLSL_CLASS_ARRAY)
1707     {
1708         name = debug_base_type(type->e.array.type);
1709         return wine_dbg_sprintf("%s[%u]", name, type->e.array.elements_count);
1710     }
1711
1712     name = debug_base_type(type);
1713
1714     if (type->type == HLSL_CLASS_SCALAR)
1715         return wine_dbg_sprintf("%s", name);
1716     if (type->type == HLSL_CLASS_VECTOR)
1717         return wine_dbg_sprintf("%s%u", name, type->dimx);
1718     if (type->type == HLSL_CLASS_MATRIX)
1719         return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy);
1720     return "unexpected_type";
1721 }
1722
1723 const char *debug_modifiers(DWORD modifiers)
1724 {
1725     char string[110];
1726
1727     string[0] = 0;
1728     if (modifiers & HLSL_STORAGE_EXTERN)
1729         strcat(string, " extern");                       /* 7 */
1730     if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
1731         strcat(string, " nointerpolation");              /* 16 */
1732     if (modifiers & HLSL_MODIFIER_PRECISE)
1733         strcat(string, " precise");                      /* 8 */
1734     if (modifiers & HLSL_STORAGE_SHARED)
1735         strcat(string, " shared");                       /* 7 */
1736     if (modifiers & HLSL_STORAGE_GROUPSHARED)
1737         strcat(string, " groupshared");                  /* 12 */
1738     if (modifiers & HLSL_STORAGE_STATIC)
1739         strcat(string, " static");                       /* 7 */
1740     if (modifiers & HLSL_STORAGE_UNIFORM)
1741         strcat(string, " uniform");                      /* 8 */
1742     if (modifiers & HLSL_STORAGE_VOLATILE)
1743         strcat(string, " volatile");                     /* 9 */
1744     if (modifiers & HLSL_MODIFIER_CONST)
1745         strcat(string, " const");                        /* 6 */
1746     if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
1747         strcat(string, " row_major");                    /* 10 */
1748     if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
1749         strcat(string, " column_major");                 /* 13 */
1750     if ((modifiers & (HLSL_STORAGE_IN | HLSL_STORAGE_OUT)) == (HLSL_STORAGE_IN | HLSL_STORAGE_OUT))
1751         strcat(string, " inout");                        /* 6 */
1752     else if (modifiers & HLSL_STORAGE_IN)
1753         strcat(string, " in");                           /* 3 */
1754     else if (modifiers & HLSL_STORAGE_OUT)
1755         strcat(string, " out");                          /* 4 */
1756
1757     return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
1758 }
1759
1760 const char *debug_node_type(enum hlsl_ir_node_type type)
1761 {
1762     static const char * const names[] =
1763     {
1764         "HLSL_IR_ASSIGNMENT",
1765         "HLSL_IR_CONSTANT",
1766         "HLSL_IR_EXPR",
1767         "HLSL_IR_IF",
1768         "HLSL_IR_LOAD",
1769         "HLSL_IR_LOOP",
1770         "HLSL_IR_JUMP",
1771         "HLSL_IR_SWIZZLE",
1772     };
1773
1774     if (type >= ARRAY_SIZE(names))
1775         return "Unexpected node type";
1776     return names[type];
1777 }
1778
1779 static void debug_dump_instr(const struct hlsl_ir_node *instr);
1780
1781 static void debug_dump_instr_list(const struct list *list)
1782 {
1783     struct hlsl_ir_node *instr;
1784
1785     LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry)
1786     {
1787         debug_dump_instr(instr);
1788         wine_dbg_printf("\n");
1789     }
1790 }
1791
1792 static void debug_dump_src(const struct hlsl_src *src)
1793 {
1794     if (src->node->index)
1795         wine_dbg_printf("@%u", src->node->index);
1796     else
1797         wine_dbg_printf("%p", src->node);
1798 }
1799
1800 static void debug_dump_ir_var(const struct hlsl_ir_var *var)
1801 {
1802     if (var->modifiers)
1803         wine_dbg_printf("%s ", debug_modifiers(var->modifiers));
1804     wine_dbg_printf("%s %s", debug_hlsl_type(var->data_type), var->name);
1805     if (var->semantic)
1806         wine_dbg_printf(" : %s", debugstr_a(var->semantic));
1807 }
1808
1809 static void debug_dump_deref(const struct hlsl_deref *deref)
1810 {
1811     if (deref->offset.node)
1812         /* Print the variable's type for convenience. */
1813         wine_dbg_printf("(%s %s)", debug_hlsl_type(deref->var->data_type), deref->var->name);
1814     else
1815         wine_dbg_printf("%s", deref->var->name);
1816     if (deref->offset.node)
1817     {
1818         wine_dbg_printf("[");
1819         debug_dump_src(&deref->offset);
1820         wine_dbg_printf("]");
1821     }
1822 }
1823
1824 static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant)
1825 {
1826     struct hlsl_type *type = constant->node.data_type;
1827     unsigned int x;
1828
1829     if (type->dimx != 1)
1830         wine_dbg_printf("{");
1831     for (x = 0; x < type->dimx; ++x)
1832     {
1833         switch (type->base_type)
1834         {
1835             case HLSL_TYPE_FLOAT:
1836                 wine_dbg_printf("%.8e ", constant->value.f[x]);
1837                 break;
1838             case HLSL_TYPE_DOUBLE:
1839                 wine_dbg_printf("%.16e ", constant->value.d[x]);
1840                 break;
1841             case HLSL_TYPE_INT:
1842                 wine_dbg_printf("%d ", constant->value.i[x]);
1843                 break;
1844             case HLSL_TYPE_UINT:
1845                 wine_dbg_printf("%u ", constant->value.u[x]);
1846                 break;
1847             case HLSL_TYPE_BOOL:
1848                 wine_dbg_printf("%s ", constant->value.b[x] ? "true" : "false");
1849                 break;
1850             default:
1851                 wine_dbg_printf("Constants of type %s not supported\n", debug_base_type(type));
1852         }
1853     }
1854     if (type->dimx != 1)
1855         wine_dbg_printf("}");
1856 }
1857
1858 static const char *debug_expr_op(const struct hlsl_ir_expr *expr)
1859 {
1860     static const char * const op_names[] =
1861     {
1862         "~",
1863         "!",
1864         "-",
1865         "abs",
1866         "sign",
1867         "rcp",
1868         "rsq",
1869         "sqrt",
1870         "nrm",
1871         "exp2",
1872         "log2",
1873
1874         "cast",
1875
1876         "fract",
1877
1878         "sin",
1879         "cos",
1880         "sin_reduced",
1881         "cos_reduced",
1882
1883         "dsx",
1884         "dsy",
1885
1886         "sat",
1887
1888         "pre++",
1889         "pre--",
1890         "post++",
1891         "post--",
1892
1893         "+",
1894         "-",
1895         "*",
1896         "/",
1897
1898         "%",
1899
1900         "<",
1901         ">",
1902         "<=",
1903         ">=",
1904         "==",
1905         "!=",
1906
1907         "&&",
1908         "||",
1909
1910         "<<",
1911         ">>",
1912         "&",
1913         "|",
1914         "^",
1915
1916         "dot",
1917         "crs",
1918         "min",
1919         "max",
1920
1921         "pow",
1922
1923         "lerp",
1924
1925         ",",
1926     };
1927
1928     if (expr->op == HLSL_IR_UNOP_CAST)
1929         return debug_hlsl_type(expr->node.data_type);
1930
1931     return op_names[expr->op];
1932 }
1933
1934 /* Dumps the expression in a prefix "operator (operands)" form */
1935 static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr)
1936 {
1937     unsigned int i;
1938
1939     wine_dbg_printf("%s (", debug_expr_op(expr));
1940     for (i = 0; i < 3 && expr->operands[i].node; ++i)
1941     {
1942         debug_dump_src(&expr->operands[i]);
1943         wine_dbg_printf(" ");
1944     }
1945     wine_dbg_printf(")");
1946 }
1947
1948 static const char *debug_writemask(DWORD writemask)
1949 {
1950     static const char components[] = {'x', 'y', 'z', 'w'};
1951     char string[5];
1952     unsigned int i = 0, pos = 0;
1953
1954     assert(!(writemask & ~BWRITERSP_WRITEMASK_ALL));
1955
1956     while (writemask)
1957     {
1958         if (writemask & 1)
1959             string[pos++] = components[i];
1960         writemask >>= 1;
1961         i++;
1962     }
1963     string[pos] = '\0';
1964     return wine_dbg_sprintf(".%s", string);
1965 }
1966
1967 static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign)
1968 {
1969     wine_dbg_printf("= (");
1970     debug_dump_deref(&assign->lhs);
1971     if (assign->writemask != BWRITERSP_WRITEMASK_ALL)
1972         wine_dbg_printf("%s", debug_writemask(assign->writemask));
1973     wine_dbg_printf(" ");
1974     debug_dump_src(&assign->rhs);
1975     wine_dbg_printf(")");
1976 }
1977
1978 static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle *swizzle)
1979 {
1980     unsigned int i;
1981
1982     debug_dump_src(&swizzle->val);
1983     wine_dbg_printf(".");
1984     if (swizzle->val.node->data_type->dimy > 1)
1985     {
1986         for (i = 0; i < swizzle->node.data_type->dimx; ++i)
1987             wine_dbg_printf("_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf);
1988     }
1989     else
1990     {
1991         static const char c[] = {'x', 'y', 'z', 'w'};
1992
1993         for (i = 0; i < swizzle->node.data_type->dimx; ++i)
1994             wine_dbg_printf("%c", c[(swizzle->swizzle >> i * 2) & 0x3]);
1995     }
1996 }
1997
1998 static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump)
1999 {
2000     switch (jump->type)
2001     {
2002         case HLSL_IR_JUMP_BREAK:
2003             wine_dbg_printf("break");
2004             break;
2005         case HLSL_IR_JUMP_CONTINUE:
2006             wine_dbg_printf("continue");
2007             break;
2008         case HLSL_IR_JUMP_DISCARD:
2009             wine_dbg_printf("discard");
2010             break;
2011         case HLSL_IR_JUMP_RETURN:
2012             wine_dbg_printf("return");
2013             break;
2014     }
2015 }
2016
2017 static void debug_dump_ir_if(const struct hlsl_ir_if *if_node)
2018 {
2019     wine_dbg_printf("if (");
2020     debug_dump_src(&if_node->condition);
2021     wine_dbg_printf(")\n{\n");
2022     debug_dump_instr_list(&if_node->then_instrs);
2023     wine_dbg_printf("}\nelse\n{\n");
2024     debug_dump_instr_list(&if_node->else_instrs);
2025     wine_dbg_printf("}\n");
2026 }
2027
2028 static void debug_dump_ir_loop(const struct hlsl_ir_loop *loop)
2029 {
2030     wine_dbg_printf("for (;;)\n{\n");
2031     debug_dump_instr_list(&loop->body);
2032     wine_dbg_printf("}\n");
2033 }
2034
2035 static void debug_dump_instr(const struct hlsl_ir_node *instr)
2036 {
2037     if (instr->index)
2038         wine_dbg_printf("%4u: ", instr->index);
2039     else
2040         wine_dbg_printf("%p: ", instr);
2041
2042     wine_dbg_printf("%10s | ", instr->data_type ? debug_hlsl_type(instr->data_type) : "");
2043
2044     switch (instr->type)
2045     {
2046         case HLSL_IR_EXPR:
2047             debug_dump_ir_expr(expr_from_node(instr));
2048             break;
2049         case HLSL_IR_LOAD:
2050             debug_dump_deref(&load_from_node(instr)->src);
2051             break;
2052         case HLSL_IR_CONSTANT:
2053             debug_dump_ir_constant(constant_from_node(instr));
2054             break;
2055         case HLSL_IR_ASSIGNMENT:
2056             debug_dump_ir_assignment(assignment_from_node(instr));
2057             break;
2058         case HLSL_IR_SWIZZLE:
2059             debug_dump_ir_swizzle(swizzle_from_node(instr));
2060             break;
2061         case HLSL_IR_JUMP:
2062             debug_dump_ir_jump(jump_from_node(instr));
2063             break;
2064         case HLSL_IR_IF:
2065             debug_dump_ir_if(if_from_node(instr));
2066             break;
2067         case HLSL_IR_LOOP:
2068             debug_dump_ir_loop(loop_from_node(instr));
2069             break;
2070         default:
2071             wine_dbg_printf("<No dump function for %s>", debug_node_type(instr->type));
2072     }
2073 }
2074
2075 void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl *func)
2076 {
2077     struct hlsl_ir_var *param;
2078
2079     TRACE("Dumping function %s.\n", debugstr_a(func->func->name));
2080     TRACE("Function parameters:\n");
2081     LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, param_entry)
2082     {
2083         debug_dump_ir_var(param);
2084         wine_dbg_printf("\n");
2085     }
2086     if (func->semantic)
2087         TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
2088     if (func->body)
2089     {
2090         debug_dump_instr_list(func->body);
2091     }
2092 }
2093
2094 void free_hlsl_type(struct hlsl_type *type)
2095 {
2096     struct hlsl_struct_field *field, *next_field;
2097
2098     d3dcompiler_free((void *)type->name);
2099     if (type->type == HLSL_CLASS_STRUCT)
2100     {
2101         LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
2102         {
2103             d3dcompiler_free((void *)field->name);
2104             d3dcompiler_free((void *)field->semantic);
2105             d3dcompiler_free(field);
2106         }
2107     }
2108     d3dcompiler_free(type);
2109 }
2110
2111 void free_instr_list(struct list *list)
2112 {
2113     struct hlsl_ir_node *node, *next_node;
2114
2115     if (!list)
2116         return;
2117     /* Iterate in reverse, to avoid use-after-free when unlinking sources from
2118      * the "uses" list. */
2119     LIST_FOR_EACH_ENTRY_SAFE_REV(node, next_node, list, struct hlsl_ir_node, entry)
2120         free_instr(node);
2121     d3dcompiler_free(list);
2122 }
2123
2124 static void free_ir_constant(struct hlsl_ir_constant *constant)
2125 {
2126     d3dcompiler_free(constant);
2127 }
2128
2129 static void free_ir_load(struct hlsl_ir_load *load)
2130 {
2131     hlsl_src_remove(&load->src.offset);
2132     d3dcompiler_free(load);
2133 }
2134
2135 static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle)
2136 {
2137     hlsl_src_remove(&swizzle->val);
2138     d3dcompiler_free(swizzle);
2139 }
2140
2141 static void free_ir_expr(struct hlsl_ir_expr *expr)
2142 {
2143     unsigned int i;
2144
2145     for (i = 0; i < ARRAY_SIZE(expr->operands); ++i)
2146         hlsl_src_remove(&expr->operands[i]);
2147     d3dcompiler_free(expr);
2148 }
2149
2150 static void free_ir_assignment(struct hlsl_ir_assignment *assignment)
2151 {
2152     hlsl_src_remove(&assignment->rhs);
2153     hlsl_src_remove(&assignment->lhs.offset);
2154     d3dcompiler_free(assignment);
2155 }
2156
2157 static void free_ir_if(struct hlsl_ir_if *if_node)
2158 {
2159     struct hlsl_ir_node *node, *next_node;
2160
2161     LIST_FOR_EACH_ENTRY_SAFE(node, next_node, &if_node->then_instrs, struct hlsl_ir_node, entry)
2162         free_instr(node);
2163     LIST_FOR_EACH_ENTRY_SAFE(node, next_node, &if_node->else_instrs, struct hlsl_ir_node, entry)
2164         free_instr(node);
2165     hlsl_src_remove(&if_node->condition);
2166     d3dcompiler_free(if_node);
2167 }
2168
2169 static void free_ir_loop(struct hlsl_ir_loop *loop)
2170 {
2171     struct hlsl_ir_node *node, *next_node;
2172
2173     LIST_FOR_EACH_ENTRY_SAFE(node, next_node, &loop->body, struct hlsl_ir_node, entry)
2174         free_instr(node);
2175     d3dcompiler_free(loop);
2176 }
2177
2178 static void free_ir_jump(struct hlsl_ir_jump *jump)
2179 {
2180     d3dcompiler_free(jump);
2181 }
2182
2183 void free_instr(struct hlsl_ir_node *node)
2184 {
2185     switch (node->type)
2186     {
2187         case HLSL_IR_CONSTANT:
2188             free_ir_constant(constant_from_node(node));
2189             break;
2190         case HLSL_IR_LOAD:
2191             free_ir_load(load_from_node(node));
2192             break;
2193         case HLSL_IR_SWIZZLE:
2194             free_ir_swizzle(swizzle_from_node(node));
2195             break;
2196         case HLSL_IR_EXPR:
2197             free_ir_expr(expr_from_node(node));
2198             break;
2199         case HLSL_IR_ASSIGNMENT:
2200             free_ir_assignment(assignment_from_node(node));
2201             break;
2202         case HLSL_IR_IF:
2203             free_ir_if(if_from_node(node));
2204             break;
2205         case HLSL_IR_LOOP:
2206             free_ir_loop(loop_from_node(node));
2207             break;
2208         case HLSL_IR_JUMP:
2209             free_ir_jump(jump_from_node(node));
2210             break;
2211         default:
2212             FIXME("Unsupported node type %s\n", debug_node_type(node->type));
2213     }
2214 }
2215
2216 static void free_function_decl(struct hlsl_ir_function_decl *decl)
2217 {
2218     d3dcompiler_free((void *)decl->semantic);
2219     d3dcompiler_free(decl->parameters);
2220     free_instr_list(decl->body);
2221     d3dcompiler_free(decl);
2222 }
2223
2224 static void free_function_decl_rb(struct wine_rb_entry *entry, void *context)
2225 {
2226     free_function_decl(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry));
2227 }
2228
2229 static void free_function(struct hlsl_ir_function *func)
2230 {
2231     wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL);
2232     d3dcompiler_free((void *)func->name);
2233     d3dcompiler_free(func);
2234 }
2235
2236 void free_function_rb(struct wine_rb_entry *entry, void *context)
2237 {
2238     free_function(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry));
2239 }
2240
2241 void add_function_decl(struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, BOOL intrinsic)
2242 {
2243     struct hlsl_ir_function *func;
2244     struct wine_rb_entry *func_entry, *old_entry;
2245
2246     func_entry = wine_rb_get(funcs, name);
2247     if (func_entry)
2248     {
2249         func = WINE_RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry);
2250         if (intrinsic != func->intrinsic)
2251         {
2252             if (intrinsic)
2253             {
2254                 ERR("Redeclaring a user defined function as an intrinsic.\n");
2255                 return;
2256             }
2257             TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name));
2258             func->intrinsic = intrinsic;
2259             wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL);
2260             wine_rb_init(&func->overloads, compare_function_decl_rb);
2261         }
2262         decl->func = func;
2263         if ((old_entry = wine_rb_get(&func->overloads, decl->parameters)))
2264         {
2265             struct hlsl_ir_function_decl *old_decl =
2266                     WINE_RB_ENTRY_VALUE(old_entry, struct hlsl_ir_function_decl, entry);
2267
2268             if (!decl->body)
2269             {
2270                 free_function_decl(decl);
2271                 d3dcompiler_free(name);
2272                 return;
2273             }
2274             wine_rb_remove(&func->overloads, old_entry);
2275             free_function_decl(old_decl);
2276         }
2277         wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
2278         d3dcompiler_free(name);
2279         return;
2280     }
2281     func = d3dcompiler_alloc(sizeof(*func));
2282     func->name = name;
2283     wine_rb_init(&func->overloads, compare_function_decl_rb);
2284     decl->func = func;
2285     wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
2286     func->intrinsic = intrinsic;
2287     wine_rb_put(funcs, func->name, &func->entry);
2288 }
2289 #endif