| /* | |
| * Copyright 2008 Stefan Dösinger | |
| * Copyright 2009 Matteo Bruni | |
| * Copyright 2008-2009 Henri Verbeet for CodeWeavers | |
| * Copyright 2010 Rico Schüller | |
| * Copyright 2012 Matteo Bruni for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| * | |
| */ | |
| #include "config.h" | |
| #include "wine/port.h" | |
| #include <stdio.h> | |
| #include "d3dcompiler_private.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler); | |
| #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x | |
| const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c) | |
| { | |
| switch (c) | |
| { | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER); | |
| default: | |
| FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c); | |
| return "unrecognized"; | |
| } | |
| } | |
| const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t) | |
| { | |
| switch (t) | |
| { | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER); | |
| default: | |
| FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t); | |
| return "unrecognized"; | |
| } | |
| } | |
| const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part) | |
| { | |
| switch(part) | |
| { | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS); | |
| WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF); | |
| default: | |
| FIXME("Unrecognized D3D_BLOB_PART %#x\n", part); | |
| return "unrecognized"; | |
| } | |
| } | |
| const char *debug_print_srcmod(DWORD mod) | |
| { | |
| switch (mod) | |
| { | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG); | |
| WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT); | |
| default: | |
| FIXME("Unrecognized source modifier %#x.\n", mod); | |
| return "unrecognized_src_mod"; | |
| } | |
| } | |
| #undef WINE_D3DCOMPILER_TO_STR | |
| const char *debug_print_dstmod(DWORD mod) | |
| { | |
| switch (mod) | |
| { | |
| case 0: | |
| return ""; | |
| case BWRITERSPDM_SATURATE: | |
| return "_sat"; | |
| case BWRITERSPDM_PARTIALPRECISION: | |
| return "_pp"; | |
| case BWRITERSPDM_MSAMPCENTROID: | |
| return "_centroid"; | |
| case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION: | |
| return "_sat_pp"; | |
| case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID: | |
| return "_sat_centroid"; | |
| case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID: | |
| return "_pp_centroid"; | |
| case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID: | |
| return "_sat_pp_centroid"; | |
| default: | |
| return "Unexpected modifier\n"; | |
| } | |
| } | |
| const char *debug_print_shift(DWORD shift) | |
| { | |
| static const char * const shiftstrings[] = | |
| { | |
| "", | |
| "_x2", | |
| "_x4", | |
| "_x8", | |
| "_x16", | |
| "_x32", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "_d16", | |
| "_d8", | |
| "_d4", | |
| "_d2", | |
| }; | |
| return shiftstrings[shift]; | |
| } | |
| static const char *get_regname(const struct shader_reg *reg) | |
| { | |
| switch (reg->type) | |
| { | |
| case BWRITERSPR_TEMP: | |
| return wine_dbg_sprintf("r%u", reg->regnum); | |
| case BWRITERSPR_INPUT: | |
| return wine_dbg_sprintf("v%u", reg->regnum); | |
| case BWRITERSPR_CONST: | |
| return wine_dbg_sprintf("c%u", reg->regnum); | |
| case BWRITERSPR_ADDR: | |
| return wine_dbg_sprintf("a%u", reg->regnum); | |
| case BWRITERSPR_TEXTURE: | |
| return wine_dbg_sprintf("t%u", reg->regnum); | |
| case BWRITERSPR_RASTOUT: | |
| switch (reg->regnum) | |
| { | |
| case BWRITERSRO_POSITION: return "oPos"; | |
| case BWRITERSRO_FOG: return "oFog"; | |
| case BWRITERSRO_POINT_SIZE: return "oPts"; | |
| default: return "Unexpected RASTOUT"; | |
| } | |
| case BWRITERSPR_ATTROUT: | |
| return wine_dbg_sprintf("oD%u", reg->regnum); | |
| case BWRITERSPR_TEXCRDOUT: | |
| return wine_dbg_sprintf("oT%u", reg->regnum); | |
| case BWRITERSPR_OUTPUT: | |
| return wine_dbg_sprintf("o%u", reg->regnum); | |
| case BWRITERSPR_CONSTINT: | |
| return wine_dbg_sprintf("i%u", reg->regnum); | |
| case BWRITERSPR_COLOROUT: | |
| return wine_dbg_sprintf("oC%u", reg->regnum); | |
| case BWRITERSPR_DEPTHOUT: | |
| return "oDepth"; | |
| case BWRITERSPR_SAMPLER: | |
| return wine_dbg_sprintf("s%u", reg->regnum); | |
| case BWRITERSPR_CONSTBOOL: | |
| return wine_dbg_sprintf("b%u", reg->regnum); | |
| case BWRITERSPR_LOOP: | |
| return "aL"; | |
| case BWRITERSPR_MISCTYPE: | |
| switch (reg->regnum) | |
| { | |
| case 0: return "vPos"; | |
| case 1: return "vFace"; | |
| default: return "unexpected misctype"; | |
| } | |
| case BWRITERSPR_LABEL: | |
| return wine_dbg_sprintf("l%u", reg->regnum); | |
| case BWRITERSPR_PREDICATE: | |
| return wine_dbg_sprintf("p%u", reg->regnum); | |
| default: | |
| return wine_dbg_sprintf("unknown regname %#x", reg->type); | |
| } | |
| } | |
| static const char *debug_print_writemask(DWORD mask) | |
| { | |
| char ret[6]; | |
| unsigned char pos = 1; | |
| if(mask == BWRITERSP_WRITEMASK_ALL) return ""; | |
| ret[0] = '.'; | |
| if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x'; | |
| if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y'; | |
| if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z'; | |
| if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w'; | |
| ret[pos] = 0; | |
| return wine_dbg_sprintf("%s", ret); | |
| } | |
| static const char *debug_print_swizzle(DWORD arg) | |
| { | |
| char ret[6]; | |
| unsigned int i; | |
| DWORD swizzle[4]; | |
| switch (arg) | |
| { | |
| case BWRITERVS_NOSWIZZLE: | |
| return ""; | |
| case BWRITERVS_SWIZZLE_X: | |
| return ".x"; | |
| case BWRITERVS_SWIZZLE_Y: | |
| return ".y"; | |
| case BWRITERVS_SWIZZLE_Z: | |
| return ".z"; | |
| case BWRITERVS_SWIZZLE_W: | |
| return ".w"; | |
| } | |
| swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03; | |
| swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03; | |
| swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03; | |
| swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03; | |
| ret[0] = '.'; | |
| for (i = 0; i < 4; ++i) | |
| { | |
| switch (swizzle[i]) | |
| { | |
| case 0: ret[1 + i] = 'x'; break; | |
| case 1: ret[1 + i] = 'y'; break; | |
| case 2: ret[1 + i] = 'z'; break; | |
| case 3: ret[1 + i] = 'w'; break; | |
| } | |
| } | |
| ret[5] = '\0'; | |
| return wine_dbg_sprintf("%s", ret); | |
| } | |
| static const char *debug_print_relarg(const struct shader_reg *reg) | |
| { | |
| const char *short_swizzle; | |
| if (!reg->rel_reg) return ""; | |
| short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle); | |
| if (reg->rel_reg->type == BWRITERSPR_ADDR) | |
| return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle); | |
| else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0) | |
| return wine_dbg_sprintf("[aL%s]", short_swizzle); | |
| else | |
| return "Unexpected relative addressing argument"; | |
| } | |
| const char *debug_print_dstreg(const struct shader_reg *reg) | |
| { | |
| return wine_dbg_sprintf("%s%s%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_writemask(reg->u.writemask)); | |
| } | |
| const char *debug_print_srcreg(const struct shader_reg *reg) | |
| { | |
| switch (reg->srcmod) | |
| { | |
| case BWRITERSPSM_NONE: | |
| return wine_dbg_sprintf("%s%s%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_NEG: | |
| return wine_dbg_sprintf("-%s%s%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_BIAS: | |
| return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_BIASNEG: | |
| return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_SIGN: | |
| return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_SIGNNEG: | |
| return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_COMP: | |
| return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_X2: | |
| return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_X2NEG: | |
| return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_DZ: | |
| return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_DW: | |
| return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_ABS: | |
| return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_ABSNEG: | |
| return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| case BWRITERSPSM_NOT: | |
| return wine_dbg_sprintf("!%s%s%s", get_regname(reg), | |
| debug_print_relarg(reg), | |
| debug_print_swizzle(reg->u.swizzle)); | |
| } | |
| return "Unknown modifier"; | |
| } | |
| const char *debug_print_comp(DWORD comp) | |
| { | |
| switch (comp) | |
| { | |
| case BWRITER_COMPARISON_NONE: return ""; | |
| case BWRITER_COMPARISON_GT: return "_gt"; | |
| case BWRITER_COMPARISON_EQ: return "_eq"; | |
| case BWRITER_COMPARISON_GE: return "_ge"; | |
| case BWRITER_COMPARISON_LT: return "_lt"; | |
| case BWRITER_COMPARISON_NE: return "_ne"; | |
| case BWRITER_COMPARISON_LE: return "_le"; | |
| default: return "_unknown"; | |
| } | |
| } | |
| const char *debug_print_opcode(DWORD opcode) | |
| { | |
| switch (opcode) | |
| { | |
| case BWRITERSIO_NOP: return "nop"; | |
| case BWRITERSIO_MOV: return "mov"; | |
| case BWRITERSIO_ADD: return "add"; | |
| case BWRITERSIO_SUB: return "sub"; | |
| case BWRITERSIO_MAD: return "mad"; | |
| case BWRITERSIO_MUL: return "mul"; | |
| case BWRITERSIO_RCP: return "rcp"; | |
| case BWRITERSIO_RSQ: return "rsq"; | |
| case BWRITERSIO_DP3: return "dp3"; | |
| case BWRITERSIO_DP4: return "dp4"; | |
| case BWRITERSIO_MIN: return "min"; | |
| case BWRITERSIO_MAX: return "max"; | |
| case BWRITERSIO_SLT: return "slt"; | |
| case BWRITERSIO_SGE: return "sge"; | |
| case BWRITERSIO_EXP: return "exp"; | |
| case BWRITERSIO_LOG: return "log"; | |
| case BWRITERSIO_LIT: return "lit"; | |
| case BWRITERSIO_DST: return "dst"; | |
| case BWRITERSIO_LRP: return "lrp"; | |
| case BWRITERSIO_FRC: return "frc"; | |
| case BWRITERSIO_M4x4: return "m4x4"; | |
| case BWRITERSIO_M4x3: return "m4x3"; | |
| case BWRITERSIO_M3x4: return "m3x4"; | |
| case BWRITERSIO_M3x3: return "m3x3"; | |
| case BWRITERSIO_M3x2: return "m3x2"; | |
| case BWRITERSIO_CALL: return "call"; | |
| case BWRITERSIO_CALLNZ: return "callnz"; | |
| case BWRITERSIO_LOOP: return "loop"; | |
| case BWRITERSIO_RET: return "ret"; | |
| case BWRITERSIO_ENDLOOP: return "endloop"; | |
| case BWRITERSIO_LABEL: return "label"; | |
| case BWRITERSIO_DCL: return "dcl"; | |
| case BWRITERSIO_POW: return "pow"; | |
| case BWRITERSIO_CRS: return "crs"; | |
| case BWRITERSIO_SGN: return "sgn"; | |
| case BWRITERSIO_ABS: return "abs"; | |
| case BWRITERSIO_NRM: return "nrm"; | |
| case BWRITERSIO_SINCOS: return "sincos"; | |
| case BWRITERSIO_REP: return "rep"; | |
| case BWRITERSIO_ENDREP: return "endrep"; | |
| case BWRITERSIO_IF: return "if"; | |
| case BWRITERSIO_IFC: return "ifc"; | |
| case BWRITERSIO_ELSE: return "else"; | |
| case BWRITERSIO_ENDIF: return "endif"; | |
| case BWRITERSIO_BREAK: return "break"; | |
| case BWRITERSIO_BREAKC: return "breakc"; | |
| case BWRITERSIO_MOVA: return "mova"; | |
| case BWRITERSIO_DEFB: return "defb"; | |
| case BWRITERSIO_DEFI: return "defi"; | |
| case BWRITERSIO_TEXCOORD: return "texcoord"; | |
| case BWRITERSIO_TEXKILL: return "texkill"; | |
| case BWRITERSIO_TEX: return "tex"; | |
| case BWRITERSIO_TEXBEM: return "texbem"; | |
| case BWRITERSIO_TEXBEML: return "texbeml"; | |
| case BWRITERSIO_TEXREG2AR: return "texreg2ar"; | |
| case BWRITERSIO_TEXREG2GB: return "texreg2gb"; | |
| case BWRITERSIO_TEXM3x2PAD: return "texm3x2pad"; | |
| case BWRITERSIO_TEXM3x2TEX: return "texm3x2tex"; | |
| case BWRITERSIO_TEXM3x3PAD: return "texm3x3pad"; | |
| case BWRITERSIO_TEXM3x3TEX: return "texm3x3tex"; | |
| case BWRITERSIO_TEXM3x3SPEC: return "texm3x3vspec"; | |
| case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec"; | |
| case BWRITERSIO_EXPP: return "expp"; | |
| case BWRITERSIO_LOGP: return "logp"; | |
| case BWRITERSIO_CND: return "cnd"; | |
| case BWRITERSIO_DEF: return "def"; | |
| case BWRITERSIO_TEXREG2RGB: return "texreg2rgb"; | |
| case BWRITERSIO_TEXDP3TEX: return "texdp3tex"; | |
| case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth"; | |
| case BWRITERSIO_TEXDP3: return "texdp3"; | |
| case BWRITERSIO_TEXM3x3: return "texm3x3"; | |
| case BWRITERSIO_TEXDEPTH: return "texdepth"; | |
| case BWRITERSIO_CMP: return "cmp"; | |
| case BWRITERSIO_BEM: return "bem"; | |
| case BWRITERSIO_DP2ADD: return "dp2add"; | |
| case BWRITERSIO_DSX: return "dsx"; | |
| case BWRITERSIO_DSY: return "dsy"; | |
| case BWRITERSIO_TEXLDD: return "texldd"; | |
| case BWRITERSIO_SETP: return "setp"; | |
| case BWRITERSIO_TEXLDL: return "texldl"; | |
| case BWRITERSIO_BREAKP: return "breakp"; | |
| case BWRITERSIO_PHASE: return "phase"; | |
| case BWRITERSIO_TEXLDP: return "texldp"; | |
| case BWRITERSIO_TEXLDB: return "texldb"; | |
| default: return "unknown"; | |
| } | |
| } | |
| void skip_dword_unknown(const char **ptr, unsigned int count) | |
| { | |
| unsigned int i; | |
| DWORD d; | |
| FIXME("Skipping %u unknown DWORDs:\n", count); | |
| for (i = 0; i < count; ++i) | |
| { | |
| read_dword(ptr, &d); | |
| FIXME("\t0x%08x\n", d); | |
| } | |
| } | |
| static void write_dword_unknown(char **ptr, DWORD d) | |
| { | |
| FIXME("Writing unknown DWORD 0x%08x\n", d); | |
| write_dword(ptr, d); | |
| } | |
| HRESULT dxbc_add_section(struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size) | |
| { | |
| TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size); | |
| if (dxbc->count >= dxbc->size) | |
| { | |
| struct dxbc_section *new_sections; | |
| DWORD new_size = dxbc->size << 1; | |
| new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections)); | |
| if (!new_sections) | |
| { | |
| ERR("Failed to allocate dxbc section memory\n"); | |
| return E_OUTOFMEMORY; | |
| } | |
| dxbc->sections = new_sections; | |
| dxbc->size = new_size; | |
| } | |
| dxbc->sections[dxbc->count].tag = tag; | |
| dxbc->sections[dxbc->count].data_size = data_size; | |
| dxbc->sections[dxbc->count].data = data; | |
| ++dxbc->count; | |
| return S_OK; | |
| } | |
| HRESULT dxbc_init(struct dxbc *dxbc, UINT size) | |
| { | |
| TRACE("dxbc %p, size %u.\n", dxbc, size); | |
| /* use a good starting value for the size if none specified */ | |
| if (!size) size = 2; | |
| dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections)); | |
| if (!dxbc->sections) | |
| { | |
| ERR("Failed to allocate dxbc section memory\n"); | |
| return E_OUTOFMEMORY; | |
| } | |
| dxbc->size = size; | |
| dxbc->count = 0; | |
| return S_OK; | |
| } | |
| HRESULT dxbc_parse(const char *data, SIZE_T data_size, struct dxbc *dxbc) | |
| { | |
| const char *ptr = data; | |
| HRESULT hr; | |
| unsigned int i; | |
| DWORD tag, total_size, chunk_count; | |
| if (!data) | |
| { | |
| WARN("No data supplied.\n"); | |
| return E_FAIL; | |
| } | |
| read_dword(&ptr, &tag); | |
| TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4)); | |
| if (tag != TAG_DXBC) | |
| { | |
| WARN("Wrong tag.\n"); | |
| return E_FAIL; | |
| } | |
| /* checksum? */ | |
| skip_dword_unknown(&ptr, 4); | |
| skip_dword_unknown(&ptr, 1); | |
| read_dword(&ptr, &total_size); | |
| TRACE("total size: %#x\n", total_size); | |
| if (data_size != total_size) | |
| { | |
| WARN("Wrong size supplied.\n"); | |
| return D3DERR_INVALIDCALL; | |
| } | |
| read_dword(&ptr, &chunk_count); | |
| TRACE("chunk count: %#x\n", chunk_count); | |
| hr = dxbc_init(dxbc, chunk_count); | |
| if (FAILED(hr)) | |
| { | |
| WARN("Failed to init dxbc\n"); | |
| return hr; | |
| } | |
| for (i = 0; i < chunk_count; ++i) | |
| { | |
| DWORD chunk_tag, chunk_size; | |
| const char *chunk_ptr; | |
| DWORD chunk_offset; | |
| read_dword(&ptr, &chunk_offset); | |
| TRACE("chunk %u at offset %#x\n", i, chunk_offset); | |
| chunk_ptr = data + chunk_offset; | |
| read_dword(&chunk_ptr, &chunk_tag); | |
| read_dword(&chunk_ptr, &chunk_size); | |
| hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size); | |
| if (FAILED(hr)) | |
| { | |
| WARN("Failed to add section to dxbc\n"); | |
| return hr; | |
| } | |
| } | |
| return hr; | |
| } | |
| void dxbc_destroy(struct dxbc *dxbc) | |
| { | |
| TRACE("dxbc %p.\n", dxbc); | |
| HeapFree(GetProcessHeap(), 0, dxbc->sections); | |
| } | |
| HRESULT dxbc_write_blob(struct dxbc *dxbc, ID3DBlob **blob) | |
| { | |
| DWORD size = 32, offset = size + 4 * dxbc->count; | |
| ID3DBlob *object; | |
| HRESULT hr; | |
| char *ptr; | |
| unsigned int i; | |
| TRACE("dxbc %p, blob %p.\n", dxbc, blob); | |
| for (i = 0; i < dxbc->count; ++i) | |
| { | |
| size += 12 + dxbc->sections[i].data_size; | |
| } | |
| hr = D3DCreateBlob(size, &object); | |
| if (FAILED(hr)) | |
| { | |
| WARN("Failed to create blob\n"); | |
| return hr; | |
| } | |
| ptr = ID3D10Blob_GetBufferPointer(object); | |
| write_dword(&ptr, TAG_DXBC); | |
| /* signature(?) */ | |
| write_dword_unknown(&ptr, 0); | |
| write_dword_unknown(&ptr, 0); | |
| write_dword_unknown(&ptr, 0); | |
| write_dword_unknown(&ptr, 0); | |
| /* seems to be always 1 */ | |
| write_dword_unknown(&ptr, 1); | |
| /* DXBC size */ | |
| write_dword(&ptr, size); | |
| /* chunk count */ | |
| write_dword(&ptr, dxbc->count); | |
| /* write the chunk offsets */ | |
| for (i = 0; i < dxbc->count; ++i) | |
| { | |
| write_dword(&ptr, offset); | |
| offset += 8 + dxbc->sections[i].data_size; | |
| } | |
| /* write the chunks */ | |
| for (i = 0; i < dxbc->count; ++i) | |
| { | |
| write_dword(&ptr, dxbc->sections[i].tag); | |
| write_dword(&ptr, dxbc->sections[i].data_size); | |
| memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size); | |
| ptr += dxbc->sections[i].data_size; | |
| } | |
| TRACE("Created ID3DBlob %p\n", object); | |
| *blob = object; | |
| return S_OK; | |
| } | |
| void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args) | |
| { | |
| char* buffer; | |
| int rc, size; | |
| if (msg->capacity == 0) | |
| { | |
| msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE); | |
| if (msg->string == NULL) | |
| { | |
| ERR("Error allocating memory for parser messages\n"); | |
| return; | |
| } | |
| msg->capacity = MESSAGEBUFFER_INITIAL_SIZE; | |
| } | |
| while (1) | |
| { | |
| rc = vsnprintf(msg->string + msg->size, | |
| msg->capacity - msg->size, fmt, args); | |
| if (rc < 0 || rc >= msg->capacity - msg->size) | |
| { | |
| size = msg->capacity * 2; | |
| buffer = d3dcompiler_realloc(msg->string, size); | |
| if (buffer == NULL) | |
| { | |
| ERR("Error reallocating memory for parser messages\n"); | |
| return; | |
| } | |
| msg->string = buffer; | |
| msg->capacity = size; | |
| } | |
| else | |
| { | |
| TRACE("%s", msg->string + msg->size); | |
| msg->size += rc; | |
| return; | |
| } | |
| } | |
| } | |
| BOOL add_declaration(struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var) | |
| { | |
| struct hlsl_ir_var *var; | |
| LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry) | |
| { | |
| if (!strcmp(decl->name, var->name)) | |
| return FALSE; | |
| } | |
| if (local_var && scope->upper->upper == hlsl_ctx.globals) | |
| { | |
| /* Check whether the variable redefines a function parameter. */ | |
| LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry) | |
| { | |
| if (!strcmp(decl->name, var->name)) | |
| return FALSE; | |
| } | |
| } | |
| list_add_tail(&scope->vars, &decl->scope_entry); | |
| return TRUE; | |
| } | |
| struct hlsl_ir_var *get_variable(struct hlsl_scope *scope, const char *name) | |
| { | |
| struct hlsl_ir_var *var; | |
| LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry) | |
| { | |
| if (!strcmp(name, var->name)) | |
| return var; | |
| } | |
| if (!scope->upper) | |
| return NULL; | |
| return get_variable(scope->upper, name); | |
| } | |
| void free_declaration(struct hlsl_ir_var *decl) | |
| { | |
| d3dcompiler_free((void *)decl->name); | |
| d3dcompiler_free((void *)decl->semantic); | |
| d3dcompiler_free((void *)decl->reg_reservation); | |
| d3dcompiler_free(decl); | |
| } | |
| struct hlsl_type *new_hlsl_type(const char *name, enum hlsl_type_class type_class, | |
| enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) | |
| { | |
| struct hlsl_type *type; | |
| type = d3dcompiler_alloc(sizeof(*type)); | |
| if (!type) | |
| { | |
| ERR("Out of memory\n"); | |
| return NULL; | |
| } | |
| type->name = name; | |
| type->type = type_class; | |
| type->base_type = base_type; | |
| type->dimx = dimx; | |
| type->dimy = dimy; | |
| list_add_tail(&hlsl_ctx.types, &type->entry); | |
| return type; | |
| } | |
| struct hlsl_type *new_array_type(struct hlsl_type *basic_type, unsigned int array_size) | |
| { | |
| struct hlsl_type *type = new_hlsl_type(NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1); | |
| if (!type) | |
| return NULL; | |
| type->modifiers = basic_type->modifiers; | |
| type->e.array.elements_count = array_size; | |
| type->e.array.type = basic_type; | |
| return type; | |
| } | |
| struct hlsl_type *get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) | |
| { | |
| struct wine_rb_entry *entry = wine_rb_get(&scope->types, name); | |
| if (entry) | |
| return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry); | |
| if (recursive && scope->upper) | |
| return get_type(scope->upper, name, recursive); | |
| return NULL; | |
| } | |
| BOOL find_function(const char *name) | |
| { | |
| return wine_rb_get(&hlsl_ctx.functions, name) != NULL; | |
| } | |
| unsigned int components_count_type(struct hlsl_type *type) | |
| { | |
| unsigned int count = 0; | |
| struct hlsl_struct_field *field; | |
| if (type->type <= HLSL_CLASS_LAST_NUMERIC) | |
| { | |
| return type->dimx * type->dimy; | |
| } | |
| if (type->type == HLSL_CLASS_ARRAY) | |
| { | |
| return components_count_type(type->e.array.type) * type->e.array.elements_count; | |
| } | |
| if (type->type != HLSL_CLASS_STRUCT) | |
| { | |
| ERR("Unexpected data type %s.\n", debug_hlsl_type(type)); | |
| return 0; | |
| } | |
| LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry) | |
| { | |
| count += components_count_type(field->type); | |
| } | |
| return count; | |
| } | |
| BOOL compare_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2) | |
| { | |
| if (t1 == t2) | |
| return TRUE; | |
| if (t1->type != t2->type) | |
| return FALSE; | |
| if (t1->base_type != t2->base_type) | |
| return FALSE; | |
| if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim) | |
| return FALSE; | |
| if ((t1->modifiers & HLSL_MODIFIERS_COMPARISON_MASK) | |
| != (t2->modifiers & HLSL_MODIFIERS_COMPARISON_MASK)) | |
| return FALSE; | |
| if (t1->dimx != t2->dimx) | |
| return FALSE; | |
| if (t1->dimy != t2->dimy) | |
| return FALSE; | |
| if (t1->type == HLSL_CLASS_STRUCT) | |
| { | |
| struct list *t1cur, *t2cur; | |
| struct hlsl_struct_field *t1field, *t2field; | |
| t1cur = list_head(t1->e.elements); | |
| t2cur = list_head(t2->e.elements); | |
| while (t1cur && t2cur) | |
| { | |
| t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry); | |
| t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry); | |
| if (!compare_hlsl_types(t1field->type, t2field->type)) | |
| return FALSE; | |
| if (strcmp(t1field->name, t2field->name)) | |
| return FALSE; | |
| t1cur = list_next(t1->e.elements, t1cur); | |
| t2cur = list_next(t2->e.elements, t2cur); | |
| } | |
| if (t1cur != t2cur) | |
| return FALSE; | |
| } | |
| if (t1->type == HLSL_CLASS_ARRAY) | |
| return t1->e.array.elements_count == t2->e.array.elements_count | |
| && compare_hlsl_types(t1->e.array.type, t2->e.array.type); | |
| return TRUE; | |
| } | |
| struct hlsl_type *clone_hlsl_type(struct hlsl_type *old) | |
| { | |
| struct hlsl_type *type; | |
| struct hlsl_struct_field *old_field, *field; | |
| type = d3dcompiler_alloc(sizeof(*type)); | |
| if (!type) | |
| { | |
| ERR("Out of memory\n"); | |
| return NULL; | |
| } | |
| if (old->name) | |
| { | |
| type->name = d3dcompiler_strdup(old->name); | |
| if (!type->name) | |
| { | |
| d3dcompiler_free(type); | |
| return NULL; | |
| } | |
| } | |
| type->type = old->type; | |
| type->base_type = old->base_type; | |
| type->dimx = old->dimx; | |
| type->dimy = old->dimy; | |
| type->modifiers = old->modifiers; | |
| type->sampler_dim = old->sampler_dim; | |
| switch (old->type) | |
| { | |
| case HLSL_CLASS_ARRAY: | |
| type->e.array.type = old->e.array.type; | |
| type->e.array.elements_count = old->e.array.elements_count; | |
| break; | |
| case HLSL_CLASS_STRUCT: | |
| type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements)); | |
| if (!type->e.elements) | |
| { | |
| d3dcompiler_free((void *)type->name); | |
| d3dcompiler_free(type); | |
| return NULL; | |
| } | |
| list_init(type->e.elements); | |
| LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry) | |
| { | |
| field = d3dcompiler_alloc(sizeof(*field)); | |
| if (!field) | |
| { | |
| LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry) | |
| { | |
| d3dcompiler_free((void *)field->semantic); | |
| d3dcompiler_free((void *)field->name); | |
| d3dcompiler_free(field); | |
| } | |
| d3dcompiler_free(type->e.elements); | |
| d3dcompiler_free((void *)type->name); | |
| d3dcompiler_free(type); | |
| return NULL; | |
| } | |
| field->type = clone_hlsl_type(old_field->type); | |
| field->name = d3dcompiler_strdup(old_field->name); | |
| if (old_field->semantic) | |
| field->semantic = d3dcompiler_strdup(old_field->semantic); | |
| field->modifiers = old_field->modifiers; | |
| list_add_tail(type->e.elements, &field->entry); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| list_add_tail(&hlsl_ctx.types, &type->entry); | |
| return type; | |
| } | |
| static BOOL convertible_data_type(struct hlsl_type *type) | |
| { | |
| return type->type != HLSL_CLASS_OBJECT; | |
| } | |
| BOOL compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2) | |
| { | |
| if (!convertible_data_type(t1) || !convertible_data_type(t2)) | |
| return FALSE; | |
| if (t1->type <= HLSL_CLASS_LAST_NUMERIC) | |
| { | |
| /* Scalar vars can be cast to pretty much everything */ | |
| if (t1->dimx == 1 && t1->dimy == 1) | |
| return TRUE; | |
| if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR) | |
| return t1->dimx >= t2->dimx; | |
| } | |
| /* The other way around is true too i.e. whatever to scalar */ | |
| if (t2->type <= HLSL_CLASS_LAST_NUMERIC && t2->dimx == 1 && t2->dimy == 1) | |
| return TRUE; | |
| if (t1->type == HLSL_CLASS_ARRAY) | |
| { | |
| if (compare_hlsl_types(t1->e.array.type, t2)) | |
| /* e.g. float4[3] to float4 is allowed */ | |
| return TRUE; | |
| if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT) | |
| return components_count_type(t1) >= components_count_type(t2); | |
| else | |
| return components_count_type(t1) == components_count_type(t2); | |
| } | |
| if (t1->type == HLSL_CLASS_STRUCT) | |
| return components_count_type(t1) >= components_count_type(t2); | |
| if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT) | |
| return components_count_type(t1) == components_count_type(t2); | |
| if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX) | |
| { | |
| if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy) | |
| return TRUE; | |
| /* Matrix-vector conversion is apparently allowed if they have the same components count */ | |
| if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR) | |
| && components_count_type(t1) == components_count_type(t2)) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| if (components_count_type(t1) >= components_count_type(t2)) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| static BOOL implicit_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2) | |
| { | |
| if (!convertible_data_type(t1) || !convertible_data_type(t2)) | |
| return FALSE; | |
| if (t1->type <= HLSL_CLASS_LAST_NUMERIC) | |
| { | |
| /* Scalar vars can be converted to any other numeric data type */ | |
| if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC) | |
| return TRUE; | |
| /* The other way around is true too */ | |
| if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC) | |
| return TRUE; | |
| } | |
| if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY) | |
| { | |
| return components_count_type(t1) == components_count_type(t2); | |
| } | |
| if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC) | |
| || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY)) | |
| { | |
| /* e.g. float4[3] to float4 is allowed */ | |
| if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2)) | |
| return TRUE; | |
| if (components_count_type(t1) == components_count_type(t2)) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR) | |
| { | |
| if (t1->dimx >= t2->dimx) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX) | |
| { | |
| if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX | |
| && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy) | |
| return TRUE; | |
| /* Matrix-vector conversion is apparently allowed if they have the same components count */ | |
| if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR) | |
| && components_count_type(t1) == components_count_type(t2)) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT) | |
| return compare_hlsl_types(t1, t2); | |
| return FALSE; | |
| } | |
| static BOOL expr_compatible_data_types(struct hlsl_type *t1, struct hlsl_type *t2) | |
| { | |
| if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR) | |
| return FALSE; | |
| /* Scalar vars can be converted to pretty much everything */ | |
| if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1)) | |
| return TRUE; | |
| if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR) | |
| return TRUE; | |
| if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX) | |
| { | |
| /* Matrix-vector conversion is apparently allowed if either they have the same components | |
| count or the matrix is nx1 or 1xn */ | |
| if (t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR) | |
| { | |
| if (components_count_type(t1) == components_count_type(t2)) | |
| return TRUE; | |
| return (t1->type == HLSL_CLASS_MATRIX && (t1->dimx == 1 || t1->dimy == 1)) | |
| || (t2->type == HLSL_CLASS_MATRIX && (t2->dimx == 1 || t2->dimy == 1)); | |
| } | |
| /* Both matrices */ | |
| if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy) | |
| || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy)) | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| static enum hlsl_base_type expr_common_base_type(enum hlsl_base_type t1, enum hlsl_base_type t2) | |
| { | |
| enum hlsl_base_type types[] = | |
| { | |
| HLSL_TYPE_BOOL, | |
| HLSL_TYPE_INT, | |
| HLSL_TYPE_UINT, | |
| HLSL_TYPE_HALF, | |
| HLSL_TYPE_FLOAT, | |
| HLSL_TYPE_DOUBLE, | |
| }; | |
| int t1_idx = -1, t2_idx = -1, i; | |
| for (i = 0; i < sizeof(types) / sizeof(types[0]); ++i) | |
| { | |
| /* Always convert away from HLSL_TYPE_HALF */ | |
| if (t1 == types[i]) | |
| t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i; | |
| if (t2 == types[i]) | |
| t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i; | |
| if (t1_idx != -1 && t2_idx != -1) | |
| break; | |
| } | |
| if (t1_idx == -1 || t2_idx == -1) | |
| { | |
| FIXME("Unexpected base type.\n"); | |
| return HLSL_TYPE_FLOAT; | |
| } | |
| return t1_idx >= t2_idx ? t1 : t2; | |
| } | |
| static struct hlsl_type *expr_common_type(struct hlsl_type *t1, struct hlsl_type *t2, | |
| struct source_location *loc) | |
| { | |
| enum hlsl_type_class type; | |
| enum hlsl_base_type base; | |
| unsigned int dimx, dimy; | |
| if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC) | |
| { | |
| hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR, | |
| "non scalar/vector/matrix data type in expression"); | |
| return NULL; | |
| } | |
| if (compare_hlsl_types(t1, t2)) | |
| return t1; | |
| if (!expr_compatible_data_types(t1, t2)) | |
| { | |
| hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR, | |
| "expression data types are incompatible"); | |
| return NULL; | |
| } | |
| if (t1->base_type == t2->base_type) | |
| base = t1->base_type; | |
| else | |
| base = expr_common_base_type(t1->base_type, t2->base_type); | |
| if (t1->dimx == 1 && t1->dimy == 1) | |
| { | |
| type = t2->type; | |
| dimx = t2->dimx; | |
| dimy = t2->dimy; | |
| } | |
| else if (t2->dimx == 1 && t2->dimy == 1) | |
| { | |
| type = t1->type; | |
| dimx = t1->dimx; | |
| dimy = t1->dimy; | |
| } | |
| else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX) | |
| { | |
| type = HLSL_CLASS_MATRIX; | |
| dimx = min(t1->dimx, t2->dimx); | |
| dimy = min(t1->dimy, t2->dimy); | |
| } | |
| else | |
| { | |
| /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */ | |
| unsigned int max_dim_1, max_dim_2; | |
| max_dim_1 = max(t1->dimx, t1->dimy); | |
| max_dim_2 = max(t2->dimx, t2->dimy); | |
| if (t1->dimx * t1->dimy == t2->dimx * t2->dimy) | |
| { | |
| type = HLSL_CLASS_VECTOR; | |
| dimx = max(t1->dimx, t2->dimx); | |
| dimy = 1; | |
| } | |
| else if (max_dim_1 <= max_dim_2) | |
| { | |
| type = t1->type; | |
| if (type == HLSL_CLASS_VECTOR) | |
| { | |
| dimx = max_dim_1; | |
| dimy = 1; | |
| } | |
| else | |
| { | |
| dimx = t1->dimx; | |
| dimy = t1->dimy; | |
| } | |
| } | |
| else | |
| { | |
| type = t2->type; | |
| if (type == HLSL_CLASS_VECTOR) | |
| { | |
| dimx = max_dim_2; | |
| dimy = 1; | |
| } | |
| else | |
| { | |
| dimx = t2->dimx; | |
| dimy = t2->dimy; | |
| } | |
| } | |
| } | |
| return new_hlsl_type(NULL, type, base, dimx, dimy); | |
| } | |
| static struct hlsl_ir_node *implicit_conversion(struct hlsl_ir_node *node, struct hlsl_type *type, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *cast; | |
| struct hlsl_ir_node *operands[3]; | |
| if (compare_hlsl_types(node->data_type, type)) | |
| return node; | |
| TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type)); | |
| operands[0] = node; | |
| operands[1] = operands[2] = NULL; | |
| cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc); | |
| if (!cast) | |
| return NULL; | |
| cast->node.data_type = type; | |
| return &cast->node; | |
| } | |
| struct hlsl_ir_expr *new_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr)); | |
| struct hlsl_type *type; | |
| unsigned int i; | |
| if (!expr) | |
| { | |
| ERR("Out of memory\n"); | |
| return NULL; | |
| } | |
| expr->node.type = HLSL_IR_EXPR; | |
| expr->node.loc = *loc; | |
| type = operands[0]->data_type; | |
| for (i = 1; i <= 2; ++i) | |
| { | |
| if (!operands[i]) | |
| break; | |
| type = expr_common_type(type, operands[i]->data_type, loc); | |
| if (!type) | |
| { | |
| d3dcompiler_free(expr); | |
| return NULL; | |
| } | |
| } | |
| for (i = 0; i <= 2; ++i) | |
| { | |
| if (!operands[i]) | |
| break; | |
| if (compare_hlsl_types(operands[i]->data_type, type)) | |
| continue; | |
| TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type)); | |
| if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1 | |
| && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy) | |
| { | |
| hlsl_report_message(operands[i]->loc.file, | |
| operands[i]->loc.line, operands[i]->loc.col, HLSL_LEVEL_WARNING, | |
| "implicit truncation of vector/matrix type"); | |
| } | |
| operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc); | |
| if (!operands[i]) | |
| { | |
| ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type)); | |
| d3dcompiler_free(expr); | |
| return NULL; | |
| } | |
| } | |
| expr->node.data_type = type; | |
| expr->op = op; | |
| expr->operands[0] = operands[0]; | |
| expr->operands[1] = operands[1]; | |
| expr->operands[2] = operands[2]; | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *new_cast(struct hlsl_ir_node *node, struct hlsl_type *type, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *cast; | |
| struct hlsl_ir_node *operands[3]; | |
| operands[0] = node; | |
| operands[1] = operands[2] = NULL; | |
| cast = new_expr(HLSL_IR_UNOP_CAST, operands, loc); | |
| if (cast) | |
| cast->node.data_type = type; | |
| return cast; | |
| } | |
| struct hlsl_ir_expr *hlsl_mul(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_MUL, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_div(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_DIV, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_mod(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_MOD, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_add(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_ADD, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_sub(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_SUB, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_lt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_LESS, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_gt(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_GREATER, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_le(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_LEQUAL, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_ge(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_GEQUAL, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_eq(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_EQUAL, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_expr *hlsl_ne(struct hlsl_ir_node *op1, struct hlsl_ir_node *op2, | |
| struct source_location *loc) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_node *ops[3]; | |
| ops[0] = op1; | |
| ops[1] = op2; | |
| ops[2] = NULL; | |
| expr = new_expr(HLSL_IR_BINOP_NEQUAL, ops, loc); | |
| return expr; | |
| } | |
| struct hlsl_ir_deref *new_var_deref(struct hlsl_ir_var *var) | |
| { | |
| struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref)); | |
| if (!deref) | |
| { | |
| ERR("Out of memory.\n"); | |
| return NULL; | |
| } | |
| deref->node.type = HLSL_IR_DEREF; | |
| deref->node.data_type = var->node.data_type; | |
| deref->type = HLSL_IR_DEREF_VAR; | |
| deref->v.var = var; | |
| return deref; | |
| } | |
| struct hlsl_ir_deref *new_record_deref(struct hlsl_ir_node *record, struct hlsl_struct_field *field) | |
| { | |
| struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref)); | |
| if (!deref) | |
| { | |
| ERR("Out of memory.\n"); | |
| return NULL; | |
| } | |
| deref->node.type = HLSL_IR_DEREF; | |
| deref->node.data_type = field->type; | |
| deref->type = HLSL_IR_DEREF_RECORD; | |
| if (record->type == HLSL_IR_VAR) | |
| deref->v.record.record = &new_var_deref(var_from_node(record))->node; | |
| else | |
| deref->v.record.record = record; | |
| deref->v.record.field = field; | |
| return deref; | |
| } | |
| static enum hlsl_ir_expr_op op_from_assignment(enum parse_assign_op op) | |
| { | |
| static const enum hlsl_ir_expr_op ops[] = | |
| { | |
| 0, | |
| HLSL_IR_BINOP_ADD, | |
| HLSL_IR_BINOP_SUB, | |
| HLSL_IR_BINOP_MUL, | |
| HLSL_IR_BINOP_DIV, | |
| HLSL_IR_BINOP_MOD, | |
| HLSL_IR_BINOP_LSHIFT, | |
| HLSL_IR_BINOP_RSHIFT, | |
| HLSL_IR_BINOP_BIT_AND, | |
| HLSL_IR_BINOP_BIT_OR, | |
| HLSL_IR_BINOP_BIT_XOR, | |
| }; | |
| return ops[op]; | |
| } | |
| struct hlsl_ir_node *make_assignment(struct hlsl_ir_node *left, enum parse_assign_op assign_op, | |
| DWORD writemask, struct hlsl_ir_node *right) | |
| { | |
| struct hlsl_ir_expr *expr; | |
| struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign)); | |
| struct hlsl_type *type; | |
| struct hlsl_ir_node *lhs, *rhs; | |
| if (!assign) | |
| { | |
| ERR("Out of memory\n"); | |
| return NULL; | |
| } | |
| TRACE("Creating proper assignment expression.\n"); | |
| rhs = right; | |
| if (writemask == BWRITERSP_WRITEMASK_ALL) | |
| type = left->data_type; | |
| else | |
| { | |
| unsigned int dimx = 0; | |
| DWORD bitmask; | |
| enum hlsl_type_class type_class; | |
| if (left->data_type->type > HLSL_CLASS_LAST_NUMERIC) | |
| { | |
| hlsl_report_message(left->loc.file, left->loc.line, left->loc.col, HLSL_LEVEL_ERROR, | |
| "writemask on a non scalar/vector/matrix type"); | |
| d3dcompiler_free(assign); | |
| return NULL; | |
| } | |
| bitmask = writemask & ((1 << left->data_type->dimx) - 1); | |
| while (bitmask) | |
| { | |
| if (bitmask & 1) | |
| dimx++; | |
| bitmask >>= 1; | |
| } | |
| if (left->data_type->type == HLSL_CLASS_MATRIX) | |
| FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n"); | |
| if (dimx == 1) | |
| type_class = HLSL_CLASS_SCALAR; | |
| else | |
| type_class = left->data_type->type; | |
| type = new_hlsl_type(NULL, type_class, left->data_type->base_type, dimx, 1); | |
| } | |
| assign->node.type = HLSL_IR_ASSIGNMENT; | |
| assign->node.loc = left->loc; | |
| assign->node.data_type = type; | |
| assign->writemask = writemask; | |
| FIXME("Check for casts in the lhs.\n"); | |
| lhs = left; | |
| if (lhs->type == HLSL_IR_VAR) | |
| { | |
| struct hlsl_ir_deref *lhs_deref = new_var_deref(var_from_node(lhs)); | |
| lhs = &lhs_deref->node; | |
| } | |
| /* FIXME: check for invalid writemasks on the lhs. */ | |
| if (!compare_hlsl_types(type, rhs->data_type)) | |
| { | |
| struct hlsl_ir_node *converted_rhs; | |
| if (!implicit_compatible_data_types(rhs->data_type, type)) | |
| { | |
| hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR, | |
| "can't implicitly convert %s to %s", | |
| debug_hlsl_type(rhs->data_type), debug_hlsl_type(type)); | |
| free_instr(lhs); | |
| free_instr(rhs); | |
| d3dcompiler_free(assign); | |
| return NULL; | |
| } | |
| if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy) | |
| hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING, | |
| "implicit truncation of vector type"); | |
| converted_rhs = implicit_conversion(rhs, type, &rhs->loc); | |
| if (!converted_rhs) | |
| { | |
| ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type)); | |
| free_instr(lhs); | |
| free_instr(rhs); | |
| d3dcompiler_free(assign); | |
| return NULL; | |
| } | |
| rhs = converted_rhs; | |
| } | |
| assign->lhs = lhs; | |
| if (assign_op != ASSIGN_OP_ASSIGN) | |
| { | |
| struct hlsl_ir_node *operands[3]; | |
| enum hlsl_ir_expr_op op = op_from_assignment(assign_op); | |
| if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR) | |
| { | |
| FIXME("LHS expression not supported in compound assignments yet.\n"); | |
| assign->rhs = rhs; | |
| } | |
| else | |
| { | |
| struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref; | |
| TRACE("Adding an expression for the compound assignment.\n"); | |
| new_deref = new_var_deref(lhs_deref->v.var); | |
| operands[0] = &new_deref->node; | |
| operands[1] = rhs; | |
| operands[2] = NULL; | |
| expr = new_expr(op, operands, &left->loc); | |
| assign->rhs = &expr->node; | |
| } | |
| } | |
| else | |
| assign->rhs = rhs; | |
| return &assign->node; | |
| } | |
| static int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry) | |
| { | |
| const char *name = key; | |
| const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry); | |
| if (name == type->name) | |
| return 0; | |
| if (!name || !type->name) | |
| { | |
| ERR("hlsl_type without a name in a scope?\n"); | |
| return -1; | |
| } | |
| return strcmp(name, type->name); | |
| } | |
| void push_scope(struct hlsl_parse_ctx *ctx) | |
| { | |
| struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope)); | |
| if (!new_scope) | |
| { | |
| ERR("Out of memory!\n"); | |
| return; | |
| } | |
| TRACE("Pushing a new scope\n"); | |
| list_init(&new_scope->vars); | |
| wine_rb_init(&new_scope->types, compare_hlsl_types_rb); | |
| new_scope->upper = ctx->cur_scope; | |
| ctx->cur_scope = new_scope; | |
| list_add_tail(&ctx->scopes, &new_scope->entry); | |
| } | |
| BOOL pop_scope(struct hlsl_parse_ctx *ctx) | |
| { | |
| struct hlsl_scope *prev_scope = ctx->cur_scope->upper; | |
| if (!prev_scope) | |
| return FALSE; | |
| TRACE("Popping current scope\n"); | |
| ctx->cur_scope = prev_scope; | |
| return TRUE; | |
| } | |
| struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type, struct list *parameters) | |
| { | |
| struct hlsl_ir_function_decl *decl; | |
| decl = d3dcompiler_alloc(sizeof(*decl)); | |
| if (!decl) | |
| { | |
| ERR("Out of memory.\n"); | |
| return NULL; | |
| } | |
| decl->node.type = HLSL_IR_FUNCTION_DECL; | |
| decl->node.data_type = return_type; | |
| decl->parameters = parameters; | |
| return decl; | |
| } | |
| static int compare_param_hlsl_types(const struct hlsl_type *t1, const struct hlsl_type *t2) | |
| { | |
| if (t1->type != t2->type) | |
| { | |
| if (!((t1->type == HLSL_CLASS_SCALAR && t2->type == HLSL_CLASS_VECTOR) | |
| || (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_SCALAR))) | |
| return t1->type - t2->type; | |
| } | |
| if (t1->base_type != t2->base_type) | |
| return t1->base_type - t2->base_type; | |
| if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim) | |
| return t1->sampler_dim - t2->sampler_dim; | |
| if (t1->dimx != t2->dimx) | |
| return t1->dimx - t2->dimx; | |
| if (t1->dimy != t2->dimy) | |
| return t1->dimx - t2->dimx; | |
| if (t1->type == HLSL_CLASS_STRUCT) | |
| { | |
| struct list *t1cur, *t2cur; | |
| struct hlsl_struct_field *t1field, *t2field; | |
| int r; | |
| t1cur = list_head(t1->e.elements); | |
| t2cur = list_head(t2->e.elements); | |
| while (t1cur && t2cur) | |
| { | |
| t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry); | |
| t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry); | |
| if ((r = compare_param_hlsl_types(t1field->type, t2field->type))) | |
| return r; | |
| if ((r = strcmp(t1field->name, t2field->name))) | |
| return r; | |
| t1cur = list_next(t1->e.elements, t1cur); | |
| t2cur = list_next(t2->e.elements, t2cur); | |
| } | |
| if (t1cur != t2cur) | |
| return t1cur ? 1 : -1; | |
| return 0; | |
| } | |
| if (t1->type == HLSL_CLASS_ARRAY) | |
| { | |
| if (t1->e.array.elements_count != t2->e.array.elements_count) | |
| return t1->e.array.elements_count - t2->e.array.elements_count; | |
| return compare_param_hlsl_types(t1->e.array.type, t2->e.array.type); | |
| } | |
| return 0; | |
| } | |
| static int compare_function_decl_rb(const void *key, const struct wine_rb_entry *entry) | |
| { | |
| const struct list *params = key; | |
| const struct hlsl_ir_function_decl *decl = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function_decl, entry); | |
| int params_count = params ? list_count(params) : 0; | |
| int decl_params_count = decl->parameters ? list_count(decl->parameters) : 0; | |
| int r; | |
| struct list *p1cur, *p2cur; | |
| if (params_count != decl_params_count) | |
| return params_count - decl_params_count; | |
| p1cur = params ? list_head(params) : NULL; | |
| p2cur = decl->parameters ? list_head(decl->parameters) : NULL; | |
| while (p1cur && p2cur) | |
| { | |
| struct hlsl_ir_var *p1, *p2; | |
| p1 = LIST_ENTRY(p1cur, struct hlsl_ir_var, node.entry); | |
| p2 = LIST_ENTRY(p2cur, struct hlsl_ir_var, node.entry); | |
| if ((r = compare_param_hlsl_types(p1->node.data_type, p2->node.data_type))) | |
| return r; | |
| p1cur = list_next(params, p1cur); | |
| p2cur = list_next(decl->parameters, p2cur); | |
| } | |
| return 0; | |
| } | |
| static int compare_function_rb(const void *key, const struct wine_rb_entry *entry) | |
| { | |
| const char *name = key; | |
| const struct hlsl_ir_function *func = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function,entry); | |
| return strcmp(name, func->name); | |
| } | |
| void init_functions_tree(struct wine_rb_tree *funcs) | |
| { | |
| wine_rb_init(&hlsl_ctx.functions, compare_function_rb); | |
| } | |
| static const char *debug_base_type(const struct hlsl_type *type) | |
| { | |
| const char *name = "(unknown)"; | |
| switch (type->base_type) | |
| { | |
| case HLSL_TYPE_FLOAT: name = "float"; break; | |
| case HLSL_TYPE_HALF: name = "half"; break; | |
| case HLSL_TYPE_DOUBLE: name = "double"; break; | |
| case HLSL_TYPE_INT: name = "int"; break; | |
| case HLSL_TYPE_UINT: name = "uint"; break; | |
| case HLSL_TYPE_BOOL: name = "bool"; break; | |
| case HLSL_TYPE_SAMPLER: | |
| switch (type->sampler_dim) | |
| { | |
| case HLSL_SAMPLER_DIM_GENERIC: name = "sampler"; break; | |
| case HLSL_SAMPLER_DIM_1D: name = "sampler1D"; break; | |
| case HLSL_SAMPLER_DIM_2D: name = "sampler2D"; break; | |
| case HLSL_SAMPLER_DIM_3D: name = "sampler3D"; break; | |
| case HLSL_SAMPLER_DIM_CUBE: name = "samplerCUBE"; break; | |
| } | |
| break; | |
| default: | |
| FIXME("Unhandled case %u\n", type->base_type); | |
| } | |
| return name; | |
| } | |
| const char *debug_hlsl_type(const struct hlsl_type *type) | |
| { | |
| const char *name; | |
| if (type->name) | |
| return debugstr_a(type->name); | |
| if (type->type == HLSL_CLASS_STRUCT) | |
| return "<anonymous struct>"; | |
| if (type->type == HLSL_CLASS_ARRAY) | |
| { | |
| name = debug_base_type(type->e.array.type); | |
| return wine_dbg_sprintf("%s[%u]", name, type->e.array.elements_count); | |
| } | |
| name = debug_base_type(type); | |
| if (type->type == HLSL_CLASS_SCALAR) | |
| return wine_dbg_sprintf("%s", name); | |
| if (type->type == HLSL_CLASS_VECTOR) | |
| return wine_dbg_sprintf("%s%u", name, type->dimx); | |
| if (type->type == HLSL_CLASS_MATRIX) | |
| return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy); | |
| return "unexpected_type"; | |
| } | |
| const char *debug_modifiers(DWORD modifiers) | |
| { | |
| char string[110]; | |
| string[0] = 0; | |
| if (modifiers & HLSL_STORAGE_EXTERN) | |
| strcat(string, " extern"); /* 7 */ | |
| if (modifiers & HLSL_STORAGE_NOINTERPOLATION) | |
| strcat(string, " nointerpolation"); /* 16 */ | |
| if (modifiers & HLSL_MODIFIER_PRECISE) | |
| strcat(string, " precise"); /* 8 */ | |
| if (modifiers & HLSL_STORAGE_SHARED) | |
| strcat(string, " shared"); /* 7 */ | |
| if (modifiers & HLSL_STORAGE_GROUPSHARED) | |
| strcat(string, " groupshared"); /* 12 */ | |
| if (modifiers & HLSL_STORAGE_STATIC) | |
| strcat(string, " static"); /* 7 */ | |
| if (modifiers & HLSL_STORAGE_UNIFORM) | |
| strcat(string, " uniform"); /* 8 */ | |
| if (modifiers & HLSL_STORAGE_VOLATILE) | |
| strcat(string, " volatile"); /* 9 */ | |
| if (modifiers & HLSL_MODIFIER_CONST) | |
| strcat(string, " const"); /* 6 */ | |
| if (modifiers & HLSL_MODIFIER_ROW_MAJOR) | |
| strcat(string, " row_major"); /* 10 */ | |
| if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR) | |
| strcat(string, " column_major"); /* 13 */ | |
| if ((modifiers & (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) == (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) | |
| strcat(string, " inout"); /* 6 */ | |
| else if (modifiers & HLSL_MODIFIER_IN) | |
| strcat(string, " in"); /* 3 */ | |
| else if (modifiers & HLSL_MODIFIER_OUT) | |
| strcat(string, " out"); /* 4 */ | |
| return wine_dbg_sprintf("%s", string[0] ? string + 1 : ""); | |
| } | |
| static const char *debug_node_type(enum hlsl_ir_node_type type) | |
| { | |
| static const char * const names[] = | |
| { | |
| "HLSL_IR_VAR", | |
| "HLSL_IR_ASSIGNMENT", | |
| "HLSL_IR_CONSTANT", | |
| "HLSL_IR_CONSTRUCTOR", | |
| "HLSL_IR_DEREF", | |
| "HLSL_IR_EXPR", | |
| "HLSL_IR_FUNCTION_DECL", | |
| "HLSL_IR_IF", | |
| "HLSL_IR_JUMP", | |
| "HLSL_IR_SWIZZLE", | |
| }; | |
| if (type >= sizeof(names) / sizeof(names[0])) | |
| return "Unexpected node type"; | |
| return names[type]; | |
| } | |
| static void debug_dump_instr(const struct hlsl_ir_node *instr); | |
| static void debug_dump_instr_list(const struct list *list) | |
| { | |
| struct hlsl_ir_node *instr; | |
| LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry) | |
| { | |
| debug_dump_instr(instr); | |
| TRACE("\n"); | |
| } | |
| } | |
| static void debug_dump_ir_var(const struct hlsl_ir_var *var) | |
| { | |
| if (var->modifiers) | |
| TRACE("%s ", debug_modifiers(var->modifiers)); | |
| TRACE("%s %s", debug_hlsl_type(var->node.data_type), var->name); | |
| if (var->semantic) | |
| TRACE(" : %s", debugstr_a(var->semantic)); | |
| } | |
| static void debug_dump_ir_deref(const struct hlsl_ir_deref *deref) | |
| { | |
| switch (deref->type) | |
| { | |
| case HLSL_IR_DEREF_VAR: | |
| TRACE("deref("); | |
| debug_dump_ir_var(deref->v.var); | |
| TRACE(")"); | |
| break; | |
| case HLSL_IR_DEREF_ARRAY: | |
| debug_dump_instr(deref->v.array.array); | |
| TRACE("["); | |
| debug_dump_instr(deref->v.array.index); | |
| TRACE("]"); | |
| break; | |
| case HLSL_IR_DEREF_RECORD: | |
| debug_dump_instr(deref->v.record.record); | |
| TRACE(".%s", debugstr_a(deref->v.record.field->name)); | |
| break; | |
| } | |
| } | |
| static void debug_dump_ir_constant(const struct hlsl_ir_constant *constant) | |
| { | |
| struct hlsl_type *type = constant->node.data_type; | |
| unsigned int x, y; | |
| if (type->dimy != 1) | |
| TRACE("{"); | |
| for (y = 0; y < type->dimy; ++y) | |
| { | |
| if (type->dimx != 1) | |
| TRACE("{"); | |
| for (x = 0; x < type->dimx; ++x) | |
| { | |
| switch (type->base_type) | |
| { | |
| case HLSL_TYPE_FLOAT: | |
| TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]); | |
| break; | |
| case HLSL_TYPE_DOUBLE: | |
| TRACE("%g ", constant->v.value.d[y * type->dimx + x]); | |
| break; | |
| case HLSL_TYPE_INT: | |
| TRACE("%d ", constant->v.value.i[y * type->dimx + x]); | |
| break; | |
| case HLSL_TYPE_UINT: | |
| TRACE("%u ", constant->v.value.u[y * type->dimx + x]); | |
| break; | |
| case HLSL_TYPE_BOOL: | |
| TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true"); | |
| break; | |
| default: | |
| TRACE("Constants of type %s not supported\n", debug_base_type(type)); | |
| } | |
| } | |
| if (type->dimx != 1) | |
| TRACE("}"); | |
| } | |
| if (type->dimy != 1) | |
| TRACE("}"); | |
| } | |
| static const char *debug_expr_op(const struct hlsl_ir_expr *expr) | |
| { | |
| static const char * const op_names[] = | |
| { | |
| "~", | |
| "!", | |
| "-", | |
| "abs", | |
| "sign", | |
| "rcp", | |
| "rsq", | |
| "sqrt", | |
| "nrm", | |
| "exp2", | |
| "log2", | |
| "cast", | |
| "fract", | |
| "sin", | |
| "cos", | |
| "sin_reduced", | |
| "cos_reduced", | |
| "dsx", | |
| "dsy", | |
| "sat", | |
| "pre++", | |
| "pre--", | |
| "post++", | |
| "post--", | |
| "+", | |
| "-", | |
| "*", | |
| "/", | |
| "%", | |
| "<", | |
| ">", | |
| "<=", | |
| ">=", | |
| "==", | |
| "!=", | |
| "&&", | |
| "||", | |
| "<<", | |
| ">>", | |
| "&", | |
| "|", | |
| "^", | |
| "dot", | |
| "crs", | |
| "min", | |
| "max", | |
| "pow", | |
| "lerp", | |
| ",", | |
| }; | |
| if (expr->op == HLSL_IR_UNOP_CAST) | |
| return debug_hlsl_type(expr->node.data_type); | |
| return op_names[expr->op]; | |
| } | |
| /* Dumps the expression in a prefix "operator (operands)" form */ | |
| static void debug_dump_ir_expr(const struct hlsl_ir_expr *expr) | |
| { | |
| unsigned int i; | |
| TRACE("%s (", debug_expr_op(expr)); | |
| for (i = 0; i < 3 && expr->operands[i]; ++i) | |
| { | |
| debug_dump_instr(expr->operands[i]); | |
| TRACE(" "); | |
| } | |
| TRACE(")"); | |
| } | |
| static void debug_dump_ir_constructor(const struct hlsl_ir_constructor *constructor) | |
| { | |
| struct hlsl_ir_node *arg; | |
| TRACE("%s (", debug_hlsl_type(constructor->node.data_type)); | |
| LIST_FOR_EACH_ENTRY(arg, constructor->arguments, struct hlsl_ir_node, entry) | |
| { | |
| debug_dump_instr(arg); | |
| TRACE(" "); | |
| } | |
| TRACE(")"); | |
| } | |
| static const char *debug_writemask(DWORD writemask) | |
| { | |
| char string[5], components[] = {'x', 'y', 'z', 'w'}; | |
| unsigned int i = 0, pos = 0; | |
| while (writemask) | |
| { | |
| if (writemask & 1) | |
| string[pos++] = components[i]; | |
| writemask >>= 1; | |
| i++; | |
| } | |
| string[pos] = '\0'; | |
| return wine_dbg_sprintf(".%s", string); | |
| } | |
| static void debug_dump_ir_assignment(const struct hlsl_ir_assignment *assign) | |
| { | |
| TRACE("= ("); | |
| debug_dump_instr(assign->lhs); | |
| if (assign->writemask != BWRITERSP_WRITEMASK_ALL) | |
| TRACE("%s", debug_writemask(assign->writemask)); | |
| TRACE(" "); | |
| debug_dump_instr(assign->rhs); | |
| TRACE(")"); | |
| } | |
| static void debug_dump_ir_swizzle(const struct hlsl_ir_swizzle *swizzle) | |
| { | |
| unsigned int i; | |
| debug_dump_instr(swizzle->val); | |
| TRACE("."); | |
| if (swizzle->val->data_type->dimy > 1) | |
| { | |
| for (i = 0; i < swizzle->node.data_type->dimx; ++i) | |
| TRACE("_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf); | |
| } | |
| else | |
| { | |
| char c[] = {'x', 'y', 'z', 'w'}; | |
| for (i = 0; i < swizzle->node.data_type->dimx; ++i) | |
| TRACE("%c", c[(swizzle->swizzle >> i * 2) & 0x3]); | |
| } | |
| } | |
| static void debug_dump_ir_jump(const struct hlsl_ir_jump *jump) | |
| { | |
| switch (jump->type) | |
| { | |
| case HLSL_IR_JUMP_BREAK: | |
| TRACE("break"); | |
| break; | |
| case HLSL_IR_JUMP_CONTINUE: | |
| TRACE("continue"); | |
| break; | |
| case HLSL_IR_JUMP_DISCARD: | |
| TRACE("discard"); | |
| break; | |
| case HLSL_IR_JUMP_RETURN: | |
| TRACE("return "); | |
| if (jump->return_value) | |
| debug_dump_instr(jump->return_value); | |
| TRACE(";"); | |
| break; | |
| } | |
| } | |
| static void debug_dump_ir_if(const struct hlsl_ir_if *if_node) | |
| { | |
| TRACE("if ("); | |
| debug_dump_instr(if_node->condition); | |
| TRACE(")\n{\n"); | |
| debug_dump_instr_list(if_node->then_instrs); | |
| TRACE("}\n"); | |
| if (if_node->else_instrs) | |
| { | |
| TRACE("else\n{\n"); | |
| debug_dump_instr_list(if_node->else_instrs); | |
| TRACE("}\n"); | |
| } | |
| } | |
| static void debug_dump_instr(const struct hlsl_ir_node *instr) | |
| { | |
| switch (instr->type) | |
| { | |
| case HLSL_IR_EXPR: | |
| debug_dump_ir_expr(expr_from_node(instr)); | |
| break; | |
| case HLSL_IR_DEREF: | |
| debug_dump_ir_deref(deref_from_node(instr)); | |
| break; | |
| case HLSL_IR_CONSTANT: | |
| debug_dump_ir_constant(constant_from_node(instr)); | |
| break; | |
| case HLSL_IR_ASSIGNMENT: | |
| debug_dump_ir_assignment(assignment_from_node(instr)); | |
| break; | |
| case HLSL_IR_SWIZZLE: | |
| debug_dump_ir_swizzle(swizzle_from_node(instr)); | |
| break; | |
| case HLSL_IR_CONSTRUCTOR: | |
| debug_dump_ir_constructor(constructor_from_node(instr)); | |
| break; | |
| case HLSL_IR_JUMP: | |
| debug_dump_ir_jump(jump_from_node(instr)); | |
| break; | |
| case HLSL_IR_IF: | |
| debug_dump_ir_if(if_from_node(instr)); | |
| break; | |
| default: | |
| TRACE("<No dump function for %s>", debug_node_type(instr->type)); | |
| } | |
| } | |
| void debug_dump_ir_function_decl(const struct hlsl_ir_function_decl *func) | |
| { | |
| struct hlsl_ir_var *param; | |
| TRACE("Dumping function %s.\n", debugstr_a(func->func->name)); | |
| TRACE("Function parameters:\n"); | |
| LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, node.entry) | |
| { | |
| debug_dump_ir_var(param); | |
| TRACE("\n"); | |
| } | |
| if (func->semantic) | |
| TRACE("Function semantic: %s\n", debugstr_a(func->semantic)); | |
| if (func->body) | |
| { | |
| debug_dump_instr_list(func->body); | |
| } | |
| } | |
| void free_hlsl_type(struct hlsl_type *type) | |
| { | |
| struct hlsl_struct_field *field, *next_field; | |
| d3dcompiler_free((void *)type->name); | |
| if (type->type == HLSL_CLASS_STRUCT) | |
| { | |
| LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry) | |
| { | |
| d3dcompiler_free((void *)field->name); | |
| d3dcompiler_free((void *)field->semantic); | |
| d3dcompiler_free(field); | |
| } | |
| } | |
| d3dcompiler_free(type); | |
| } | |
| void free_instr_list(struct list *list) | |
| { | |
| struct hlsl_ir_node *node, *next_node; | |
| if (!list) | |
| return; | |
| LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry) | |
| free_instr(node); | |
| d3dcompiler_free(list); | |
| } | |
| static void free_ir_constant(struct hlsl_ir_constant *constant) | |
| { | |
| struct hlsl_type *type = constant->node.data_type; | |
| unsigned int i; | |
| struct hlsl_ir_constant *field, *next_field; | |
| switch (type->type) | |
| { | |
| case HLSL_CLASS_ARRAY: | |
| for (i = 0; i < type->e.array.elements_count; ++i) | |
| free_ir_constant(&constant->v.array_elements[i]); | |
| d3dcompiler_free(constant->v.array_elements); | |
| break; | |
| case HLSL_CLASS_STRUCT: | |
| LIST_FOR_EACH_ENTRY_SAFE(field, next_field, constant->v.struct_elements, struct hlsl_ir_constant, node.entry) | |
| free_ir_constant(field); | |
| break; | |
| default: | |
| break; | |
| } | |
| d3dcompiler_free(constant); | |
| } | |
| static void free_ir_deref(struct hlsl_ir_deref *deref) | |
| { | |
| switch (deref->type) | |
| { | |
| case HLSL_IR_DEREF_VAR: | |
| /* Variables are shared among nodes in the tree. */ | |
| break; | |
| case HLSL_IR_DEREF_ARRAY: | |
| free_instr(deref->v.array.array); | |
| free_instr(deref->v.array.index); | |
| break; | |
| case HLSL_IR_DEREF_RECORD: | |
| free_instr(deref->v.record.record); | |
| break; | |
| } | |
| d3dcompiler_free(deref); | |
| } | |
| static void free_ir_swizzle(struct hlsl_ir_swizzle *swizzle) | |
| { | |
| free_instr(swizzle->val); | |
| d3dcompiler_free(swizzle); | |
| } | |
| static void free_ir_constructor(struct hlsl_ir_constructor *constructor) | |
| { | |
| free_instr_list(constructor->arguments); | |
| d3dcompiler_free(constructor); | |
| } | |
| static void free_ir_expr(struct hlsl_ir_expr *expr) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < 3; ++i) | |
| { | |
| if (!expr->operands[i]) | |
| break; | |
| free_instr(expr->operands[i]); | |
| } | |
| free_instr_list(expr->subexpressions); | |
| d3dcompiler_free(expr); | |
| } | |
| static void free_ir_assignment(struct hlsl_ir_assignment *assignment) | |
| { | |
| free_instr(assignment->lhs); | |
| free_instr(assignment->rhs); | |
| d3dcompiler_free(assignment); | |
| } | |
| static void free_ir_if(struct hlsl_ir_if *if_node) | |
| { | |
| free_instr(if_node->condition); | |
| free_instr_list(if_node->then_instrs); | |
| free_instr_list(if_node->else_instrs); | |
| d3dcompiler_free(if_node); | |
| } | |
| static void free_ir_jump(struct hlsl_ir_jump *jump) | |
| { | |
| if (jump->type == HLSL_IR_JUMP_RETURN) | |
| free_instr(jump->return_value); | |
| d3dcompiler_free(jump); | |
| } | |
| void free_instr(struct hlsl_ir_node *node) | |
| { | |
| switch (node->type) | |
| { | |
| case HLSL_IR_VAR: | |
| /* These are freed later on from the scopes. */ | |
| break; | |
| case HLSL_IR_CONSTANT: | |
| free_ir_constant(constant_from_node(node)); | |
| break; | |
| case HLSL_IR_DEREF: | |
| free_ir_deref(deref_from_node(node)); | |
| break; | |
| case HLSL_IR_SWIZZLE: | |
| free_ir_swizzle(swizzle_from_node(node)); | |
| break; | |
| case HLSL_IR_CONSTRUCTOR: | |
| free_ir_constructor(constructor_from_node(node)); | |
| break; | |
| case HLSL_IR_EXPR: | |
| free_ir_expr(expr_from_node(node)); | |
| break; | |
| case HLSL_IR_ASSIGNMENT: | |
| free_ir_assignment(assignment_from_node(node)); | |
| break; | |
| case HLSL_IR_IF: | |
| free_ir_if(if_from_node(node)); | |
| break; | |
| case HLSL_IR_JUMP: | |
| free_ir_jump(jump_from_node(node)); | |
| break; | |
| default: | |
| FIXME("Unsupported node type %s\n", debug_node_type(node->type)); | |
| } | |
| } | |
| static void free_function_decl(struct hlsl_ir_function_decl *decl) | |
| { | |
| d3dcompiler_free((void *)decl->semantic); | |
| d3dcompiler_free(decl->parameters); | |
| free_instr_list(decl->body); | |
| d3dcompiler_free(decl); | |
| } | |
| static void free_function_decl_rb(struct wine_rb_entry *entry, void *context) | |
| { | |
| free_function_decl(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry)); | |
| } | |
| static void free_function(struct hlsl_ir_function *func) | |
| { | |
| wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL); | |
| d3dcompiler_free((void *)func->name); | |
| d3dcompiler_free(func); | |
| } | |
| void free_function_rb(struct wine_rb_entry *entry, void *context) | |
| { | |
| free_function(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry)); | |
| } | |
| void add_function_decl(struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, BOOL intrinsic) | |
| { | |
| struct hlsl_ir_function *func; | |
| struct wine_rb_entry *func_entry, *old_entry; | |
| func_entry = wine_rb_get(funcs, name); | |
| if (func_entry) | |
| { | |
| func = WINE_RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry); | |
| if (intrinsic != func->intrinsic) | |
| { | |
| if (intrinsic) | |
| { | |
| ERR("Redeclaring a user defined function as an intrinsic.\n"); | |
| return; | |
| } | |
| TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name)); | |
| func->intrinsic = intrinsic; | |
| wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL); | |
| wine_rb_init(&func->overloads, compare_function_decl_rb); | |
| } | |
| decl->func = func; | |
| if ((old_entry = wine_rb_get(&func->overloads, decl->parameters))) | |
| { | |
| struct hlsl_ir_function_decl *old_decl = | |
| WINE_RB_ENTRY_VALUE(old_entry, struct hlsl_ir_function_decl, entry); | |
| if (!decl->body) | |
| { | |
| free_function_decl(decl); | |
| d3dcompiler_free(name); | |
| return; | |
| } | |
| wine_rb_remove(&func->overloads, old_entry); | |
| free_function_decl(old_decl); | |
| } | |
| wine_rb_put(&func->overloads, decl->parameters, &decl->entry); | |
| d3dcompiler_free(name); | |
| return; | |
| } | |
| func = d3dcompiler_alloc(sizeof(*func)); | |
| func->name = name; | |
| wine_rb_init(&func->overloads, compare_function_decl_rb); | |
| decl->func = func; | |
| wine_rb_put(&func->overloads, decl->parameters, &decl->entry); | |
| func->intrinsic = intrinsic; | |
| wine_rb_put(funcs, func->name, &func->entry); | |
| } |