reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-29 22:50:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8f60f8f34b
wine/dlls/d3dcompiler_43/utils.c

2284 lines
68 KiB
C
Raw Blame History

/*
* 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(decl);
}
BOOL add_func_parameter(struct list *list, struct parse_parameter *param, const struct source_location *loc)
{
struct hlsl_ir_var *decl = d3dcompiler_alloc(sizeof(*decl));
if (!decl)
{
ERR("Out of memory.\n");
return FALSE;
}
decl->node.type = HLSL_IR_VAR;
decl->node.data_type = param->type;
decl->node.loc = *loc;
decl->name = param->name;
decl->semantic = param->semantic;
decl->modifiers = param->modifiers;
if (!add_declaration(hlsl_ctx.cur_scope, decl, FALSE))
{
free_declaration(decl);
return FALSE;
}
list_add_tail(list, &decl->node.entry);
return TRUE;
}
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)
{
FIXME("stub.\n");
return NULL;
}
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)
{
struct hlsl_ir_function_decl *func;
LIST_FOR_EACH_ENTRY(func, &hlsl_ctx.functions, struct hlsl_ir_function_decl, node.entry)
{
if (!strcmp(func->name, name))
return TRUE;
}
return FALSE;
}
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;
}
static 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;
}
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 *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;
}
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
{
FIXME("Assignments with writemasks not supported yet.\n");
type = NULL;
}
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);
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);
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;
}
int compare_hlsl_types_rb(const void *key, const struct wine_rb_entry *entry)
{
const char *name = (const char *)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);
}
static inline void *d3dcompiler_alloc_rb(size_t size)
{
return d3dcompiler_alloc(size);
}
static inline void *d3dcompiler_realloc_rb(void *ptr, size_t size)
{
return d3dcompiler_realloc(ptr, size);
}
static inline void d3dcompiler_free_rb(void *ptr)
{
d3dcompiler_free(ptr);
}
static const struct wine_rb_functions hlsl_type_rb_funcs =
{
d3dcompiler_alloc_rb,
d3dcompiler_realloc_rb,
d3dcompiler_free_rb,
compare_hlsl_types_rb,
};
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);
if (wine_rb_init(&new_scope->types, &hlsl_type_rb_funcs) == -1)
{
ERR("Failed to initialize types rbtree.\n");
d3dcompiler_free(new_scope);
return;
}
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(const char *name, 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->name = name;
decl->parameters = parameters;
return decl;
}
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>";
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)
{
const char *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));
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 *op_names[] =
{
"~",
"!",
"-",
"abs",
"sign",
"rcp",
"rsq",
"sqrt",
"nrm",
"exp2",
"log2",
"cast",
"fract",
"sin",
"cos",
"sin_reduced",
"cos_reduced",
"dsx",
"dsy",
"sat",
"+",
"-",
"*",
"/",
"%",
"<",
">",
"<=",
">=",
"==",
"!=",
"&&",
"||",
"<<",
">>",
"&",
"|",
"^",
"dot",
"crs",
"min",
"max",
"pow",
"pre++",
"pre--",
"post++",
"post--",
"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\n", debug_node_type(instr->type));
}
}
void debug_dump_ir_function(const struct hlsl_ir_function_decl *func)
{
struct hlsl_ir_var *param;
TRACE("Dumping function %s.\n", debugstr_a(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);
}
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);
d3dcompiler_free((void *)deref->v.record.field);
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));
}
}
void free_function(struct hlsl_ir_function_decl *func)
{
struct hlsl_ir_var *param, *next_param;
d3dcompiler_free((void *)func->name);
d3dcompiler_free((void *)func->semantic);
LIST_FOR_EACH_ENTRY_SAFE(param, next_param, func->parameters, struct hlsl_ir_var, node.entry)
d3dcompiler_free(param);
d3dcompiler_free(func->parameters);
free_instr_list(func->body);
d3dcompiler_free(func->body);
}
Reference in New Issue View Git Blame Copy Permalink