[PATCH 2/5] wined3d: Use a wined3d_string_buffer to dump the intermediate shader code.
Henri Verbeet
hverbeet at codeweavers.com
Fri Feb 12 11:52:21 CST 2016
Instead of abusing TRACE. There's probably still some room for improvement.
There may also be value in dumping things in a format that's compatible with
D3D shader assembly, but I don't think it's a priority.
Signed-off-by: Henri Verbeet <hverbeet at codeweavers.com>
---
dlls/wined3d/shader.c | 481 ++++++++++++++++++++++-------------------
dlls/wined3d/shader_sm1.c | 2 -
dlls/wined3d/wined3d_private.h | 4 -
3 files changed, 263 insertions(+), 224 deletions(-)
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index 8ec8a8e..f577647 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -216,6 +216,9 @@ sysval_semantic_names[] =
{WINED3D_SV_SAMPLEINDEX, "SV_SampleIndex"},
};
+static void shader_dump_src_param(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version);
+
const char *debug_d3dshaderinstructionhandler(enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx)
{
if (handler_idx >= sizeof(shader_opcode_names) / sizeof(*shader_opcode_names))
@@ -1231,27 +1234,27 @@ unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_map
return wined3d_log2i(map);
}
-static void shader_dump_global_flags(DWORD global_flags)
+static void shader_dump_global_flags(struct wined3d_string_buffer *buffer, DWORD global_flags)
{
if (global_flags & WINED3DSGF_REFACTORING_ALLOWED)
{
- TRACE("refactoringAllowed");
+ shader_addline(buffer, "refactoringAllowed");
global_flags &= ~WINED3DSGF_REFACTORING_ALLOWED;
if (global_flags)
- TRACE(" | ");
+ shader_addline(buffer, " | ");
}
if (global_flags & WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS)
{
- TRACE("enableRawAndStructuredBuffers");
+ shader_addline(buffer, "enableRawAndStructuredBuffers");
global_flags &= ~WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS;
}
if (global_flags)
- TRACE("unknown_flags(%#x)", global_flags);
+ shader_addline(buffer, "unknown_flags(%#x)", global_flags);
}
-static void shader_dump_sysval_semantic(enum wined3d_sysval_semantic semantic)
+static void shader_dump_sysval_semantic(struct wined3d_string_buffer *buffer, enum wined3d_sysval_semantic semantic)
{
unsigned int i;
@@ -1259,185 +1262,190 @@ static void shader_dump_sysval_semantic(enum wined3d_sysval_semantic semantic)
{
if (sysval_semantic_names[i].sysval_semantic == semantic)
{
- TRACE("%s", sysval_semantic_names[i].sysval_name);
+ shader_addline(buffer, "%s", sysval_semantic_names[i].sysval_name);
return;
}
}
- TRACE("unknown_sysval_semantic(%#x)", semantic);
+ shader_addline(buffer, "unknown_sysval_semantic(%#x)", semantic);
}
-static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
- const struct wined3d_shader_version *shader_version)
+static void shader_dump_decl_usage(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_semantic *semantic, const struct wined3d_shader_version *shader_version)
{
- TRACE("dcl");
+ shader_addline(buffer, "dcl");
if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
{
switch (semantic->resource_type)
{
case WINED3D_SHADER_RESOURCE_TEXTURE_2D:
- TRACE("_2d");
+ shader_addline(buffer, "_2d");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_3D:
- TRACE("_3d");
+ shader_addline(buffer, "_3d");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE:
- TRACE("_cube");
+ shader_addline(buffer, "_cube");
break;
default:
- TRACE("_unknown_ttype(0x%08x)", semantic->resource_type);
+ shader_addline(buffer, "_unknown_resource_type(%#x)", semantic->resource_type);
break;
}
}
else if (semantic->reg.reg.type == WINED3DSPR_RESOURCE)
{
- TRACE("_resource_");
+ shader_addline(buffer, "_resource_");
switch (semantic->resource_type)
{
case WINED3D_SHADER_RESOURCE_BUFFER:
- TRACE("buffer");
+ shader_addline(buffer, "buffer");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_1D:
- TRACE("texture1d");
+ shader_addline(buffer, "texture1d");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_2D:
- TRACE("texture2d");
+ shader_addline(buffer, "texture2d");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_2DMS:
- TRACE("texture2dms");
+ shader_addline(buffer, "texture2dms");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_3D:
- TRACE("texture3d");
+ shader_addline(buffer, "texture3d");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE:
- TRACE("texturecube");
+ shader_addline(buffer, "texturecube");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY:
- TRACE("texture1darray");
+ shader_addline(buffer, "texture1darray");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY:
- TRACE("texture2darray");
+ shader_addline(buffer, "texture2darray");
break;
case WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY:
- TRACE("texture2dmsarray");
+ shader_addline(buffer, "texture2dmsarray");
break;
default:
- TRACE("unknown");
+ shader_addline(buffer, "unknown");
break;
}
switch (semantic->resource_data_type)
{
case WINED3D_DATA_FLOAT:
- TRACE(" (float)");
+ shader_addline(buffer, " (float)");
break;
case WINED3D_DATA_INT:
- TRACE(" (int)");
+ shader_addline(buffer, " (int)");
break;
case WINED3D_DATA_UINT:
- TRACE(" (uint)");
+ shader_addline(buffer, " (uint)");
break;
case WINED3D_DATA_UNORM:
- TRACE(" (unorm)");
+ shader_addline(buffer, " (unorm)");
break;
case WINED3D_DATA_SNORM:
- TRACE(" (snorm)");
+ shader_addline(buffer, " (snorm)");
break;
default:
- TRACE(" (unknown)");
+ shader_addline(buffer, " (unknown)");
break;
}
}
else
{
/* Pixel shaders 3.0 don't have usage semantics. */
- if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL) return;
- else TRACE("_");
+ if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL)
+ return;
+ else
+ shader_addline(buffer, "_");
switch (semantic->usage)
{
case WINED3D_DECL_USAGE_POSITION:
- TRACE("position%u", semantic->usage_idx);
+ shader_addline(buffer, "position%u", semantic->usage_idx);
break;
case WINED3D_DECL_USAGE_BLEND_INDICES:
- TRACE("blend");
+ shader_addline(buffer, "blend");
break;
case WINED3D_DECL_USAGE_BLEND_WEIGHT:
- TRACE("weight");
+ shader_addline(buffer, "weight");
break;
case WINED3D_DECL_USAGE_NORMAL:
- TRACE("normal%u", semantic->usage_idx);
+ shader_addline(buffer, "normal%u", semantic->usage_idx);
break;
case WINED3D_DECL_USAGE_PSIZE:
- TRACE("psize");
+ shader_addline(buffer, "psize");
break;
case WINED3D_DECL_USAGE_COLOR:
- if (!semantic->usage_idx) TRACE("color");
- else TRACE("specular%u", (semantic->usage_idx - 1));
+ if (!semantic->usage_idx)
+ shader_addline(buffer, "color");
+ else
+ shader_addline(buffer, "specular%u", (semantic->usage_idx - 1));
break;
case WINED3D_DECL_USAGE_TEXCOORD:
- TRACE("texture%u", semantic->usage_idx);
+ shader_addline(buffer, "texture%u", semantic->usage_idx);
break;
case WINED3D_DECL_USAGE_TANGENT:
- TRACE("tangent");
+ shader_addline(buffer, "tangent");
break;
case WINED3D_DECL_USAGE_BINORMAL:
- TRACE("binormal");
+ shader_addline(buffer, "binormal");
break;
case WINED3D_DECL_USAGE_TESS_FACTOR:
- TRACE("tessfactor");
+ shader_addline(buffer, "tessfactor");
break;
case WINED3D_DECL_USAGE_POSITIONT:
- TRACE("positionT%u", semantic->usage_idx);
+ shader_addline(buffer, "positionT%u", semantic->usage_idx);
break;
case WINED3D_DECL_USAGE_FOG:
- TRACE("fog");
+ shader_addline(buffer, "fog");
break;
case WINED3D_DECL_USAGE_DEPTH:
- TRACE("depth");
+ shader_addline(buffer, "depth");
break;
case WINED3D_DECL_USAGE_SAMPLE:
- TRACE("sample");
+ shader_addline(buffer, "sample");
break;
default:
+ shader_addline(buffer, "<unknown_semantic(%#x)>", semantic->usage);
FIXME("unknown_semantics(0x%08x)", semantic->usage);
}
}
}
-static void shader_dump_register(const struct wined3d_shader_register *reg,
- const struct wined3d_shader_version *shader_version)
+static void shader_dump_register(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version)
{
static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
static const char * const misctype_reg_names[] = {"vPos", "vFace"};
@@ -1446,129 +1454,136 @@ static void shader_dump_register(const struct wined3d_shader_register *reg,
switch (reg->type)
{
case WINED3DSPR_TEMP:
- TRACE("r");
+ shader_addline(buffer, "r");
break;
case WINED3DSPR_INPUT:
- TRACE("v");
+ shader_addline(buffer, "v");
break;
case WINED3DSPR_CONST:
case WINED3DSPR_CONST2:
case WINED3DSPR_CONST3:
case WINED3DSPR_CONST4:
- TRACE("c");
+ shader_addline(buffer, "c");
offset = shader_get_float_offset(reg->type, offset);
break;
case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
- TRACE("%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
+ shader_addline(buffer, "%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
break;
case WINED3DSPR_RASTOUT:
- TRACE("%s", rastout_reg_names[offset]);
+ shader_addline(buffer, "%s", rastout_reg_names[offset]);
break;
case WINED3DSPR_COLOROUT:
- TRACE("oC");
+ shader_addline(buffer, "oC");
break;
case WINED3DSPR_DEPTHOUT:
- TRACE("oDepth");
+ shader_addline(buffer, "oDepth");
break;
case WINED3DSPR_ATTROUT:
- TRACE("oD");
+ shader_addline(buffer, "oD");
break;
case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0 use general purpose output registers
* (WINED3DSPR_OUTPUT), which can include an address token. */
- if (shader_version->major >= 3) TRACE("o");
- else TRACE("oT");
+ if (shader_version->major >= 3)
+ shader_addline(buffer, "o");
+ else
+ shader_addline(buffer, "oT");
break;
case WINED3DSPR_CONSTINT:
- TRACE("i");
+ shader_addline(buffer, "i");
break;
case WINED3DSPR_CONSTBOOL:
- TRACE("b");
+ shader_addline(buffer, "b");
break;
case WINED3DSPR_LABEL:
- TRACE("l");
+ shader_addline(buffer, "l");
break;
case WINED3DSPR_LOOP:
- TRACE("aL");
+ shader_addline(buffer, "aL");
break;
case WINED3DSPR_SAMPLER:
- TRACE("s");
+ shader_addline(buffer, "s");
break;
case WINED3DSPR_MISCTYPE:
if (offset > 1)
+ {
FIXME("Unhandled misctype register %u.\n", offset);
+ shader_addline(buffer, "<unhandled misctype %#x>", offset);
+ }
else
- TRACE("%s", misctype_reg_names[offset]);
+ {
+ shader_addline(buffer, "%s", misctype_reg_names[offset]);
+ }
break;
case WINED3DSPR_PREDICATE:
- TRACE("p");
+ shader_addline(buffer, "p");
break;
case WINED3DSPR_IMMCONST:
- TRACE("l");
+ shader_addline(buffer, "l");
break;
case WINED3DSPR_CONSTBUFFER:
- TRACE("cb");
+ shader_addline(buffer, "cb");
break;
case WINED3DSPR_IMMCONSTBUFFER:
- TRACE("icb");
+ shader_addline(buffer, "icb");
break;
case WINED3DSPR_PRIMID:
- TRACE("primID");
+ shader_addline(buffer, "primID");
break;
case WINED3DSPR_NULL:
- TRACE("null");
+ shader_addline(buffer, "null");
break;
case WINED3DSPR_RESOURCE:
- TRACE("t");
+ shader_addline(buffer, "t");
break;
default:
- TRACE("unhandled_rtype(%#x)", reg->type);
+ shader_addline(buffer, "<unhandled_rtype(%#x)>", reg->type);
break;
}
if (reg->type == WINED3DSPR_IMMCONST)
{
- TRACE("(");
+ shader_addline(buffer, "(");
switch (reg->immconst_type)
{
case WINED3D_IMMCONST_SCALAR:
switch (reg->data_type)
{
case WINED3D_DATA_FLOAT:
- TRACE("%.8e", *(const float *)reg->immconst_data);
+ shader_addline(buffer, "%.8e", *(const float *)reg->immconst_data);
break;
case WINED3D_DATA_INT:
- TRACE("%d", reg->immconst_data[0]);
+ shader_addline(buffer, "%d", reg->immconst_data[0]);
break;
case WINED3D_DATA_RESOURCE:
case WINED3D_DATA_SAMPLER:
case WINED3D_DATA_UINT:
- TRACE("%u", reg->immconst_data[0]);
+ shader_addline(buffer, "%u", reg->immconst_data[0]);
break;
default:
- TRACE("<unhandled data type %#x>", reg->data_type);
+ shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
break;
}
break;
@@ -1577,83 +1592,87 @@ static void shader_dump_register(const struct wined3d_shader_register *reg,
switch (reg->data_type)
{
case WINED3D_DATA_FLOAT:
- TRACE("%.8e, %.8e, %.8e, %.8e",
+ shader_addline(buffer, "%.8e, %.8e, %.8e, %.8e",
*(const float *)®->immconst_data[0], *(const float *)®->immconst_data[1],
*(const float *)®->immconst_data[2], *(const float *)®->immconst_data[3]);
break;
case WINED3D_DATA_INT:
- TRACE("%d, %d, %d, %d",
+ shader_addline(buffer, "%d, %d, %d, %d",
reg->immconst_data[0], reg->immconst_data[1],
reg->immconst_data[2], reg->immconst_data[3]);
break;
case WINED3D_DATA_RESOURCE:
case WINED3D_DATA_SAMPLER:
case WINED3D_DATA_UINT:
- TRACE("%u, %u, %u, %u",
+ shader_addline(buffer, "%u, %u, %u, %u",
reg->immconst_data[0], reg->immconst_data[1],
reg->immconst_data[2], reg->immconst_data[3]);
break;
default:
- TRACE("<unhandled data type %#x>", reg->data_type);
+ shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
break;
}
break;
default:
- TRACE("<unhandled immconst_type %#x>", reg->immconst_type);
+ shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type);
break;
}
- TRACE(")");
+ shader_addline(buffer, ")");
}
else if (reg->type != WINED3DSPR_RASTOUT
&& reg->type != WINED3DSPR_MISCTYPE
&& reg->type != WINED3DSPR_NULL)
{
- if (offset != ~0U)
+ if (offset != ~0u)
{
- TRACE("[");
+ shader_addline(buffer, "[");
if (reg->idx[0].rel_addr)
{
- shader_dump_src_param(reg->idx[0].rel_addr, shader_version);
- TRACE(" + ");
+ shader_dump_src_param(buffer, reg->idx[0].rel_addr, shader_version);
+ shader_addline(buffer, " + ");
}
- TRACE("%u]", offset);
+ shader_addline(buffer, "%u]", offset);
- if (reg->idx[1].offset != ~0U)
+ if (reg->idx[1].offset != ~0u)
{
- TRACE("[");
+ shader_addline(buffer, "[");
if (reg->idx[1].rel_addr)
{
- shader_dump_src_param(reg->idx[1].rel_addr, shader_version);
- TRACE(" + ");
+ shader_dump_src_param(buffer, reg->idx[1].rel_addr, shader_version);
+ shader_addline(buffer, " + ");
}
- TRACE("%u]", reg->idx[1].offset);
+ shader_addline(buffer, "%u]", reg->idx[1].offset);
}
}
}
}
-void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
- const struct wined3d_shader_version *shader_version)
+static void shader_dump_dst_param(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_dst_param *param, const struct wined3d_shader_version *shader_version)
{
DWORD write_mask = param->write_mask;
- shader_dump_register(¶m->reg, shader_version);
+ shader_dump_register(buffer, ¶m->reg, shader_version);
if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL)
{
static const char write_mask_chars[] = "xyzw";
- TRACE(".");
- if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
- if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
- if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
- if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
+ shader_addline(buffer, ".");
+ if (write_mask & WINED3DSP_WRITEMASK_0)
+ shader_addline(buffer, "%c", write_mask_chars[0]);
+ if (write_mask & WINED3DSP_WRITEMASK_1)
+ shader_addline(buffer, "%c", write_mask_chars[1]);
+ if (write_mask & WINED3DSP_WRITEMASK_2)
+ shader_addline(buffer, "%c", write_mask_chars[2]);
+ if (write_mask & WINED3DSP_WRITEMASK_3)
+ shader_addline(buffer, "%c", write_mask_chars[3]);
}
}
-void shader_dump_src_param(const struct wined3d_shader_src_param *param,
- const struct wined3d_shader_version *shader_version)
+static void shader_dump_src_param(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version)
{
enum wined3d_shader_src_modifier src_modifier = param->modifiers;
DWORD swizzle = param->swizzle;
@@ -1663,34 +1682,34 @@ void shader_dump_src_param(const struct wined3d_shader_src_param *param,
|| src_modifier == WINED3DSPSM_SIGNNEG
|| src_modifier == WINED3DSPSM_X2NEG
|| src_modifier == WINED3DSPSM_ABSNEG)
- TRACE("-");
+ shader_addline(buffer, "-");
else if (src_modifier == WINED3DSPSM_COMP)
- TRACE("1-");
+ shader_addline(buffer, "1-");
else if (src_modifier == WINED3DSPSM_NOT)
- TRACE("!");
+ shader_addline(buffer, "!");
if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
- TRACE("abs(");
+ shader_addline(buffer, "abs(");
- shader_dump_register(¶m->reg, shader_version);
+ shader_dump_register(buffer, ¶m->reg, shader_version);
switch (src_modifier)
{
case WINED3DSPSM_NONE: break;
case WINED3DSPSM_NEG: break;
case WINED3DSPSM_NOT: break;
- case WINED3DSPSM_BIAS: TRACE("_bias"); break;
- case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
- case WINED3DSPSM_SIGN: TRACE("_bx2"); break;
- case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
+ case WINED3DSPSM_BIAS: shader_addline(buffer, "_bias"); break;
+ case WINED3DSPSM_BIASNEG: shader_addline(buffer, "_bias"); break;
+ case WINED3DSPSM_SIGN: shader_addline(buffer, "_bx2"); break;
+ case WINED3DSPSM_SIGNNEG: shader_addline(buffer, "_bx2"); break;
case WINED3DSPSM_COMP: break;
- case WINED3DSPSM_X2: TRACE("_x2"); break;
- case WINED3DSPSM_X2NEG: TRACE("_x2"); break;
- case WINED3DSPSM_DZ: TRACE("_dz"); break;
- case WINED3DSPSM_DW: TRACE("_dw"); break;
- case WINED3DSPSM_ABSNEG: TRACE(")"); break;
- case WINED3DSPSM_ABS: TRACE(")"); break;
- default: TRACE("_unknown_modifier(%#x)", src_modifier);
+ case WINED3DSPSM_X2: shader_addline(buffer, "_x2"); break;
+ case WINED3DSPSM_X2NEG: shader_addline(buffer, "_x2"); break;
+ case WINED3DSPSM_DZ: shader_addline(buffer, "_dz"); break;
+ case WINED3DSPSM_DW: shader_addline(buffer, "_dw"); break;
+ case WINED3DSPSM_ABSNEG: shader_addline(buffer, ")"); break;
+ case WINED3DSPSM_ABS: shader_addline(buffer, ")"); break;
+ default: shader_addline(buffer, "_unknown_modifier(%#x)", src_modifier);
}
if (swizzle != WINED3DSP_NOSWIZZLE)
@@ -1705,11 +1724,11 @@ void shader_dump_src_param(const struct wined3d_shader_src_param *param,
&& swizzle_x == swizzle_z
&& swizzle_x == swizzle_w)
{
- TRACE(".%c", swizzle_chars[swizzle_x]);
+ shader_addline(buffer, ".%c", swizzle_chars[swizzle_x]);
}
else
{
- TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
+ shader_addline(buffer, ".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
}
}
@@ -1766,100 +1785,103 @@ void shader_generate_main(const struct wined3d_shader *shader, struct wined3d_st
}
}
-static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
+static void shader_dump_ins_modifiers(struct wined3d_string_buffer *buffer,
+ const struct wined3d_shader_dst_param *dst)
{
DWORD mmask = dst->modifiers;
switch (dst->shift)
{
case 0: break;
- case 13: TRACE("_d8"); break;
- case 14: TRACE("_d4"); break;
- case 15: TRACE("_d2"); break;
- case 1: TRACE("_x2"); break;
- case 2: TRACE("_x4"); break;
- case 3: TRACE("_x8"); break;
- default: TRACE("_unhandled_shift(%d)", dst->shift); break;
+ case 13: shader_addline(buffer, "_d8"); break;
+ case 14: shader_addline(buffer, "_d4"); break;
+ case 15: shader_addline(buffer, "_d2"); break;
+ case 1: shader_addline(buffer, "_x2"); break;
+ case 2: shader_addline(buffer, "_x4"); break;
+ case 3: shader_addline(buffer, "_x8"); break;
+ default: shader_addline(buffer, "_unhandled_shift(%d)", dst->shift); break;
}
- if (mmask & WINED3DSPDM_SATURATE) TRACE("_sat");
- if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
- if (mmask & WINED3DSPDM_MSAMPCENTROID) TRACE("_centroid");
+ if (mmask & WINED3DSPDM_SATURATE) shader_addline(buffer, "_sat");
+ if (mmask & WINED3DSPDM_PARTIALPRECISION) shader_addline(buffer, "_pp");
+ if (mmask & WINED3DSPDM_MSAMPCENTROID) shader_addline(buffer, "_centroid");
mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
if (mmask) FIXME("_unrecognized_modifier(%#x)", mmask);
}
-static void shader_dump_primitive_type(enum wined3d_primitive_type primitive_type)
+static void shader_dump_primitive_type(struct wined3d_string_buffer *buffer,
+ enum wined3d_primitive_type primitive_type)
{
switch (primitive_type)
{
case WINED3D_PT_UNDEFINED:
- TRACE("undefined");
+ shader_addline(buffer, "undefined");
break;
case WINED3D_PT_POINTLIST:
- TRACE("pointlist");
+ shader_addline(buffer, "pointlist");
break;
case WINED3D_PT_LINELIST:
- TRACE("linelist");
+ shader_addline(buffer, "linelist");
break;
case WINED3D_PT_LINESTRIP:
- TRACE("linestrip");
+ shader_addline(buffer, "linestrip");
break;
case WINED3D_PT_TRIANGLELIST:
- TRACE("trianglelist");
+ shader_addline(buffer, "trianglelist");
break;
case WINED3D_PT_TRIANGLESTRIP:
- TRACE("trianglestrip");
+ shader_addline(buffer, "trianglestrip");
break;
case WINED3D_PT_TRIANGLEFAN:
- TRACE("trianglefan");
+ shader_addline(buffer, "trianglefan");
break;
case WINED3D_PT_LINELIST_ADJ:
- TRACE("linelist_adj");
+ shader_addline(buffer, "linelist_adj");
break;
case WINED3D_PT_LINESTRIP_ADJ:
- TRACE("linestrip_adj");
+ shader_addline(buffer, "linestrip_adj");
break;
case WINED3D_PT_TRIANGLELIST_ADJ:
- TRACE("trianglelist_adj");
+ shader_addline(buffer, "trianglelist_adj");
break;
case WINED3D_PT_TRIANGLESTRIP_ADJ:
- TRACE("trianglestrip_adj");
+ shader_addline(buffer, "trianglestrip_adj");
break;
default:
- TRACE("<unrecognized_primitive_type %#x>", primitive_type);
+ shader_addline(buffer, "<unrecognized_primitive_type %#x>", primitive_type);
break;
}
}
-static void shader_dump_interpolation_mode(enum wined3d_shader_interpolation_mode interpolation_mode)
+static void shader_dump_interpolation_mode(struct wined3d_string_buffer *buffer,
+ enum wined3d_shader_interpolation_mode interpolation_mode)
{
switch (interpolation_mode)
{
case WINED3DSIM_CONSTANT:
- TRACE("constant");
+ shader_addline(buffer, "constant");
break;
case WINED3DSIM_LINEAR:
- TRACE("linear");
+ shader_addline(buffer, "linear");
break;
case WINED3DSIM_LINEAR_CENTROID:
- TRACE("linear centroid");
+ shader_addline(buffer, "linear centroid");
break;
case WINED3DSIM_LINEAR_NOPERSPECTIVE:
- TRACE("linear noperspective");
+ shader_addline(buffer, "linear noperspective");
break;
case WINED3DSIM_LINEAR_SAMPLE:
- TRACE("linear sample");
+ shader_addline(buffer, "linear sample");
break;
case WINED3DSIM_LINEAR_NOPERSPECTIVE_CENTROID:
- TRACE("linear noperspective centroid");
+ shader_addline(buffer, "linear noperspective centroid");
break;
case WINED3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE:
- TRACE("linear noperspective sample");
+ shader_addline(buffer, "linear noperspective sample");
break;
default:
- TRACE("<unrecognized_interpolation_mode %#x>", interpolation_mode);
+ shader_addline(buffer, "<unrecognized_interpolation_mode %#x>", interpolation_mode);
break;
}
}
@@ -1867,10 +1889,18 @@ static void shader_dump_interpolation_mode(enum wined3d_shader_interpolation_mod
static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *byte_code)
{
struct wined3d_shader_version shader_version;
+ struct wined3d_string_buffer buffer;
const DWORD *ptr = byte_code;
const char *type_prefix;
+ const char *p, *q;
DWORD i;
+ if (!string_buffer_init(&buffer))
+ {
+ ERR("Failed to initialize string buffer.\n");
+ return;
+ }
+
TRACE("Parsing %p.\n", byte_code);
fe->shader_read_header(fe_data, &ptr, &shader_version);
@@ -1895,7 +1925,7 @@ static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe
break;
}
- TRACE("%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
+ shader_addline(&buffer, "%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
while (!fe->shader_is_end(fe_data, &ptr))
{
@@ -1904,94 +1934,96 @@ static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe
fe->shader_read_instruction(fe_data, &ptr, &ins);
if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
{
- TRACE("Skipping unrecognized instruction.\n");
+ WARN("Skipping unrecognized instruction.\n");
+ shader_addline(&buffer, "<unrecognized instruction>\n");
continue;
}
if (ins.handler_idx == WINED3DSIH_DCL)
{
- shader_dump_decl_usage(&ins.declaration.semantic, &shader_version);
- shader_dump_ins_modifiers(&ins.declaration.semantic.reg);
- TRACE(" ");
- shader_dump_dst_param(&ins.declaration.semantic.reg, &shader_version);
+ shader_dump_decl_usage(&buffer, &ins.declaration.semantic, &shader_version);
+ shader_dump_ins_modifiers(&buffer, &ins.declaration.semantic.reg);
+ shader_addline(&buffer, " ");
+ shader_dump_dst_param(&buffer, &ins.declaration.semantic.reg, &shader_version);
}
else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_src_param(&ins.declaration.src, &shader_version);
- TRACE(", %s", ins.flags & WINED3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed");
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_src_param(&buffer, &ins.declaration.src, &shader_version);
+ shader_addline(&buffer, ", %s",
+ ins.flags & WINED3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed");
}
else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_global_flags(ins.flags);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_global_flags(&buffer, ins.flags);
}
else if (ins.handler_idx == WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER)
{
- TRACE("%s {\n", shader_opcode_names[ins.handler_idx]);
+ shader_addline(&buffer, "%s {\n", shader_opcode_names[ins.handler_idx]);
for (i = 0; i < ins.declaration.icb->element_count / 4; ++i)
{
- TRACE("{ 0x%08x, 0x%08x, 0x%08x, 0x%08x },\n",
+ shader_addline(&buffer, " {0x%08x, 0x%08x, 0x%08x, 0x%08x},\n",
ins.declaration.icb->data[4 * i + 0],
ins.declaration.icb->data[4 * i + 1],
ins.declaration.icb->data[4 * i + 2],
ins.declaration.icb->data[4 * i + 3]);
}
- TRACE("}");
+ shader_addline(&buffer, "}");
}
else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_interpolation_mode(ins.flags);
- TRACE(" ");
- shader_dump_dst_param(&ins.declaration.dst, &shader_version);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_interpolation_mode(&buffer, ins.flags);
+ shader_addline(&buffer, " ");
+ shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
}
else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SGV
|| ins.handler_idx == WINED3DSIH_DCL_INPUT_SGV
|| ins.handler_idx == WINED3DSIH_DCL_INPUT_SIV
|| ins.handler_idx == WINED3DSIH_DCL_OUTPUT_SIV)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_dst_param(&ins.declaration.register_semantic.reg, &shader_version);
- TRACE(", ");
- shader_dump_sysval_semantic(ins.declaration.register_semantic.sysval_semantic);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version);
+ shader_addline(&buffer, ", ");
+ shader_dump_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic);
}
else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SIV)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_interpolation_mode(ins.flags);
- TRACE(" ");
- shader_dump_dst_param(&ins.declaration.register_semantic.reg, &shader_version);
- TRACE(", ");
- shader_dump_sysval_semantic(ins.declaration.register_semantic.sysval_semantic);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_interpolation_mode(&buffer, ins.flags);
+ shader_addline(&buffer, " ");
+ shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version);
+ shader_addline(&buffer, ", ");
+ shader_dump_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic);
}
else if (ins.handler_idx == WINED3DSIH_DCL_INPUT
|| ins.handler_idx == WINED3DSIH_DCL_OUTPUT)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_dst_param(&ins.declaration.dst, &shader_version);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
}
else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE
|| ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_primitive_type(ins.declaration.primitive_type);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_primitive_type(&buffer, ins.declaration.primitive_type);
}
else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER)
{
- TRACE("%s ", shader_opcode_names[ins.handler_idx]);
- shader_dump_dst_param(&ins.declaration.dst, &shader_version);
+ shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
+ shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
if (ins.flags == WINED3DSI_SAMPLER_COMPARISON_MODE)
- TRACE(", comparisonMode");
+ shader_addline(&buffer, ", comparisonMode");
}
else if (ins.handler_idx == WINED3DSIH_DCL_TEMPS
|| ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
{
- TRACE("%s %u", shader_opcode_names[ins.handler_idx], ins.declaration.count);
+ shader_addline(&buffer, "%s %u", shader_opcode_names[ins.handler_idx], ins.declaration.count);
}
else if (ins.handler_idx == WINED3DSIH_DEF)
{
- TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(ins.dst[0].reg.type,
+ shader_addline(&buffer, "def c%u = %.8e, %.8e, %.8e, %.8e", shader_get_float_offset(ins.dst[0].reg.type,
ins.dst[0].reg.idx[0].offset),
*(const float *)&ins.src[0].reg.immconst_data[0],
*(const float *)&ins.src[0].reg.immconst_data[1],
@@ -2000,7 +2032,7 @@ static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe
}
else if (ins.handler_idx == WINED3DSIH_DEFI)
{
- TRACE("defi i%u = %d, %d, %d, %d", ins.dst[0].reg.idx[0].offset,
+ shader_addline(&buffer, "defi i%u = %d, %d, %d, %d", ins.dst[0].reg.idx[0].offset,
ins.src[0].reg.immconst_data[0],
ins.src[0].reg.immconst_data[1],
ins.src[0].reg.immconst_data[2],
@@ -2008,69 +2040,82 @@ static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe
}
else if (ins.handler_idx == WINED3DSIH_DEFB)
{
- TRACE("defb b%u = %s", ins.dst[0].reg.idx[0].offset, ins.src[0].reg.immconst_data[0] ? "true" : "false");
+ shader_addline(&buffer, "defb b%u = %s",
+ ins.dst[0].reg.idx[0].offset, ins.src[0].reg.immconst_data[0] ? "true" : "false");
}
else
{
if (ins.predicate)
{
- TRACE("(");
- shader_dump_src_param(ins.predicate, &shader_version);
- TRACE(") ");
+ shader_addline(&buffer, "(");
+ shader_dump_src_param(&buffer, ins.predicate, &shader_version);
+ shader_addline(&buffer, ") ");
}
/* PixWin marks instructions with the coissue flag with a '+' */
- if (ins.coissue) TRACE("+");
+ if (ins.coissue)
+ shader_addline(&buffer, "+");
- TRACE("%s", shader_opcode_names[ins.handler_idx]);
+ shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]);
if (ins.handler_idx == WINED3DSIH_IFC
|| ins.handler_idx == WINED3DSIH_BREAKC)
{
switch (ins.flags)
{
- case WINED3D_SHADER_REL_OP_GT: TRACE("_gt"); break;
- case WINED3D_SHADER_REL_OP_EQ: TRACE("_eq"); break;
- case WINED3D_SHADER_REL_OP_GE: TRACE("_ge"); break;
- case WINED3D_SHADER_REL_OP_LT: TRACE("_lt"); break;
- case WINED3D_SHADER_REL_OP_NE: TRACE("_ne"); break;
- case WINED3D_SHADER_REL_OP_LE: TRACE("_le"); break;
- default: TRACE("_(%u)", ins.flags);
+ case WINED3D_SHADER_REL_OP_GT: shader_addline(&buffer, "_gt"); break;
+ case WINED3D_SHADER_REL_OP_EQ: shader_addline(&buffer, "_eq"); break;
+ case WINED3D_SHADER_REL_OP_GE: shader_addline(&buffer, "_ge"); break;
+ case WINED3D_SHADER_REL_OP_LT: shader_addline(&buffer, "_lt"); break;
+ case WINED3D_SHADER_REL_OP_NE: shader_addline(&buffer, "_ne"); break;
+ case WINED3D_SHADER_REL_OP_LE: shader_addline(&buffer, "_le"); break;
+ default: shader_addline(&buffer, "_(%u)", ins.flags);
}
}
else if (ins.handler_idx == WINED3DSIH_TEX
&& shader_version.major >= 2
&& (ins.flags & WINED3DSI_TEXLD_PROJECT))
{
- TRACE("p");
+ shader_addline(&buffer, "p");
}
else if (ins.handler_idx == WINED3DSIH_RESINFO
&& ins.flags)
{
switch (ins.flags)
{
- case WINED3DSI_RESINFO_RCP_FLOAT: TRACE("_rcpFloat"); break;
- case WINED3DSI_RESINFO_UINT: TRACE("_uint"); break;
- default: TRACE("_unrecognized(%#x)", ins.flags);
+ case WINED3DSI_RESINFO_RCP_FLOAT: shader_addline(&buffer, "_rcpFloat"); break;
+ case WINED3DSI_RESINFO_UINT: shader_addline(&buffer, "_uint"); break;
+ default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags);
}
}
for (i = 0; i < ins.dst_count; ++i)
{
- shader_dump_ins_modifiers(&ins.dst[i]);
- TRACE(!i ? " " : ", ");
- shader_dump_dst_param(&ins.dst[i], &shader_version);
+ shader_dump_ins_modifiers(&buffer, &ins.dst[i]);
+ shader_addline(&buffer, !i ? " " : ", ");
+ shader_dump_dst_param(&buffer, &ins.dst[i], &shader_version);
}
/* Other source tokens */
for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
{
- TRACE(!i ? " " : ", ");
- shader_dump_src_param(&ins.src[i - ins.dst_count], &shader_version);
+ shader_addline(&buffer, !i ? " " : ", ");
+ shader_dump_src_param(&buffer, &ins.src[i - ins.dst_count], &shader_version);
}
}
- TRACE("\n");
+ shader_addline(&buffer, "\n");
}
+
+ for (p = buffer.buffer; *p; p = q)
+ {
+ if (!(q = strstr(p, "\n")))
+ q = p + strlen(p);
+ else
+ ++q;
+ TRACE(" %.*s", (int)(q - p), p);
+ }
+
+ string_buffer_free(&buffer);
}
static void shader_cleanup(struct wined3d_shader *shader)
diff --git a/dlls/wined3d/shader_sm1.c b/dlls/wined3d/shader_sm1.c
index 3d84975..8c48d19 100644
--- a/dlls/wined3d/shader_sm1.c
+++ b/dlls/wined3d/shader_sm1.c
@@ -518,14 +518,12 @@ static int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const D
struct wined3d_shader_dst_param dst;
shader_parse_dst_param(token, token & WINED3D_SM1_ADDRESS_MODE_RELATIVE ? &rel_addr : NULL, &dst);
- shader_dump_dst_param(&dst, &priv->shader_version);
}
else
{
struct wined3d_shader_src_param src;
shader_parse_src_param(token, token & WINED3D_SM1_ADDRESS_MODE_RELATIVE ? &rel_addr : NULL, &src);
- shader_dump_src_param(&src, &priv->shader_version);
}
FIXME("\n");
++i;
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 2df8cd3..b1b112d 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -3133,10 +3133,6 @@ void find_vs_compile_args(const struct wined3d_state *state, const struct wined3
void string_buffer_clear(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
BOOL string_buffer_init(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
void string_buffer_free(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
-void shader_dump_src_param(const struct wined3d_shader_src_param *param,
- const struct wined3d_shader_version *shader_version) DECLSPEC_HIDDEN;
-void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
- const struct wined3d_shader_version *shader_version) DECLSPEC_HIDDEN;
unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps,
unsigned int max) DECLSPEC_HIDDEN;
void shader_generate_main(const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer,
--
2.1.4
More information about the wine-patches
mailing list