| /********************************************************** |
| * Copyright 2008-2009 VMware, Inc. All rights reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person |
| * obtaining a copy of this software and associated documentation |
| * files (the "Software"), to deal in the Software without |
| * restriction, including without limitation the rights to use, copy, |
| * modify, merge, publish, distribute, sublicense, and/or sell copies |
| * of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| * |
| **********************************************************/ |
| |
| /** |
| * @file |
| * SVGA Shader Dump Facilities |
| * |
| * @author Michal Krol <michal@vmware.com> |
| */ |
| |
| #include "svga_shader.h" |
| #include "svga_shader_dump.h" |
| #include "svga_shader_op.h" |
| #include "util/u_debug.h" |
| |
| #include "../svga_hw_reg.h" |
| #include "svga3d_shaderdefs.h" |
| |
| struct dump_info |
| { |
| uint32 version; |
| boolean is_ps; |
| int indent; |
| }; |
| |
| #define DUMP_MAX_OP_SRC 4 |
| |
| struct dump_op |
| { |
| struct sh_op op; |
| struct sh_dstreg dst; |
| struct sh_srcreg dstind; |
| struct sh_srcreg src[DUMP_MAX_OP_SRC]; |
| struct sh_srcreg srcind[DUMP_MAX_OP_SRC]; |
| struct sh_srcreg p0; |
| }; |
| |
| static void |
| dump_indent(int indent) |
| { |
| int i; |
| |
| for (i = 0; i < indent; ++i) { |
| _debug_printf(" "); |
| } |
| } |
| |
| static void dump_op( struct sh_op op, const char *mnemonic ) |
| { |
| assert( op.is_reg == 0 ); |
| |
| if (op.predicated) { |
| _debug_printf("(p0) "); |
| } |
| if (op.coissue) |
| _debug_printf( "+" ); |
| _debug_printf( "%s", mnemonic ); |
| |
| switch (op.opcode) { |
| case SVGA3DOP_TEX: |
| switch (op.control) { |
| case 0: |
| break; |
| case 1 /* PROJECT */: |
| _debug_printf("p"); |
| break; |
| case 2 /* BIAS */: |
| _debug_printf("b"); |
| break; |
| default: |
| assert(0); |
| } |
| break; |
| |
| case SVGA3DOP_IFC: |
| case SVGA3DOP_BREAKC: |
| case SVGA3DOP_SETP: |
| switch (op.control) { |
| case SVGA3DOPCOMP_GT: |
| _debug_printf("_gt"); |
| break; |
| case SVGA3DOPCOMP_EQ: |
| _debug_printf("_eq"); |
| break; |
| case SVGA3DOPCOMP_GE: |
| _debug_printf("_ge"); |
| break; |
| case SVGA3DOPCOMP_LT: |
| _debug_printf("_lt"); |
| break; |
| case SVGA3DOPCOMPC_NE: |
| _debug_printf("_ne"); |
| break; |
| case SVGA3DOPCOMP_LE: |
| _debug_printf("_le"); |
| break; |
| default: |
| assert(0); |
| } |
| break; |
| |
| default: |
| assert(op.control == 0); |
| } |
| } |
| |
| static void |
| format_reg(const char *name, |
| const struct sh_reg reg, |
| const struct sh_srcreg *indreg) |
| { |
| if (reg.relative) { |
| assert(indreg); |
| |
| if (sh_srcreg_type(*indreg) == SVGA3DREG_LOOP) { |
| _debug_printf("%s[aL+%u]", name, reg.number); |
| } else { |
| _debug_printf("%s[a%u.x+%u]", name, indreg->number, reg.number); |
| } |
| } else { |
| _debug_printf("%s%u", name, reg.number); |
| } |
| } |
| |
| static void dump_reg( struct sh_reg reg, struct sh_srcreg *indreg, const struct dump_info *di ) |
| { |
| assert( reg.is_reg == 1 ); |
| |
| switch (sh_reg_type( reg )) { |
| case SVGA3DREG_TEMP: |
| format_reg("r", reg, NULL); |
| break; |
| |
| case SVGA3DREG_INPUT: |
| format_reg("v", reg, indreg); |
| break; |
| |
| case SVGA3DREG_CONST: |
| format_reg("c", reg, indreg); |
| break; |
| |
| case SVGA3DREG_ADDR: /* VS */ |
| /* SVGA3DREG_TEXTURE */ /* PS */ |
| assert(!reg.relative); |
| if (di->is_ps) { |
| format_reg("t", reg, NULL); |
| } else { |
| format_reg("a", reg, NULL); |
| } |
| break; |
| |
| case SVGA3DREG_RASTOUT: |
| assert(!reg.relative); |
| switch (reg.number) { |
| case 0 /*POSITION*/: |
| _debug_printf( "oPos" ); |
| break; |
| case 1 /*FOG*/: |
| _debug_printf( "oFog" ); |
| break; |
| case 2 /*POINT_SIZE*/: |
| _debug_printf( "oPts" ); |
| break; |
| default: |
| assert( 0 ); |
| _debug_printf( "???" ); |
| } |
| break; |
| |
| case SVGA3DREG_ATTROUT: |
| assert( reg.number < 2 ); |
| format_reg("oD", reg, NULL); |
| break; |
| |
| case SVGA3DREG_TEXCRDOUT: /* VS */ |
| /* SVGA3DREG_OUTPUT */ /* VS3.0+ */ |
| if (!di->is_ps && di->version >= SVGA3D_VS_30) { |
| format_reg("o", reg, indreg); |
| } else { |
| format_reg("oT", reg, NULL); |
| } |
| break; |
| |
| case SVGA3DREG_COLOROUT: |
| format_reg("oC", reg, NULL); |
| break; |
| |
| case SVGA3DREG_DEPTHOUT: |
| assert(!reg.relative); |
| assert(reg.number == 0); |
| _debug_printf("oDepth"); |
| break; |
| |
| case SVGA3DREG_SAMPLER: |
| format_reg("s", reg, NULL); |
| break; |
| |
| case SVGA3DREG_CONSTBOOL: |
| format_reg("b", reg, NULL); |
| break; |
| |
| case SVGA3DREG_CONSTINT: |
| format_reg("i", reg, NULL); |
| break; |
| |
| case SVGA3DREG_LOOP: |
| assert(!reg.relative); |
| assert( reg.number == 0 ); |
| _debug_printf( "aL" ); |
| break; |
| |
| case SVGA3DREG_MISCTYPE: |
| assert(!reg.relative); |
| switch (reg.number) { |
| case SVGA3DMISCREG_POSITION: |
| _debug_printf("vPos"); |
| break; |
| case SVGA3DMISCREG_FACE: |
| _debug_printf("vFace"); |
| break; |
| default: |
| assert(0); |
| _debug_printf("???"); |
| } |
| break; |
| |
| case SVGA3DREG_LABEL: |
| format_reg("l", reg, NULL); |
| break; |
| |
| case SVGA3DREG_PREDICATE: |
| format_reg("p", reg, NULL); |
| break; |
| |
| default: |
| assert( 0 ); |
| _debug_printf( "???" ); |
| } |
| } |
| |
| static void dump_cdata( struct sh_cdata cdata ) |
| { |
| _debug_printf( "%f, %f, %f, %f", cdata.xyzw[0], cdata.xyzw[1], cdata.xyzw[2], cdata.xyzw[3] ); |
| } |
| |
| static void dump_idata( struct sh_idata idata ) |
| { |
| _debug_printf( "%d, %d, %d, %d", idata.xyzw[0], idata.xyzw[1], idata.xyzw[2], idata.xyzw[3] ); |
| } |
| |
| static void dump_bdata( boolean bdata ) |
| { |
| _debug_printf( bdata ? "TRUE" : "FALSE" ); |
| } |
| |
| static void |
| dump_sampleinfo(struct sh_sampleinfo sampleinfo) |
| { |
| assert( sampleinfo.is_reg == 1 ); |
| |
| switch (sampleinfo.texture_type) { |
| case SVGA3DSAMP_2D: |
| _debug_printf( "_2d" ); |
| break; |
| case SVGA3DSAMP_CUBE: |
| _debug_printf( "_cube" ); |
| break; |
| case SVGA3DSAMP_VOLUME: |
| _debug_printf( "_volume" ); |
| break; |
| default: |
| assert( 0 ); |
| } |
| } |
| |
| static void |
| dump_semantic(uint usage, |
| uint usage_index) |
| { |
| switch (usage) { |
| case SVGA3D_DECLUSAGE_POSITION: |
| _debug_printf("_position"); |
| break; |
| case SVGA3D_DECLUSAGE_BLENDWEIGHT: |
| _debug_printf("_blendweight"); |
| break; |
| case SVGA3D_DECLUSAGE_BLENDINDICES: |
| _debug_printf("_blendindices"); |
| break; |
| case SVGA3D_DECLUSAGE_NORMAL: |
| _debug_printf("_normal"); |
| break; |
| case SVGA3D_DECLUSAGE_PSIZE: |
| _debug_printf("_psize"); |
| break; |
| case SVGA3D_DECLUSAGE_TEXCOORD: |
| _debug_printf("_texcoord"); |
| break; |
| case SVGA3D_DECLUSAGE_TANGENT: |
| _debug_printf("_tangent"); |
| break; |
| case SVGA3D_DECLUSAGE_BINORMAL: |
| _debug_printf("_binormal"); |
| break; |
| case SVGA3D_DECLUSAGE_TESSFACTOR: |
| _debug_printf("_tessfactor"); |
| break; |
| case SVGA3D_DECLUSAGE_POSITIONT: |
| _debug_printf("_positiont"); |
| break; |
| case SVGA3D_DECLUSAGE_COLOR: |
| _debug_printf("_color"); |
| break; |
| case SVGA3D_DECLUSAGE_FOG: |
| _debug_printf("_fog"); |
| break; |
| case SVGA3D_DECLUSAGE_DEPTH: |
| _debug_printf("_depth"); |
| break; |
| case SVGA3D_DECLUSAGE_SAMPLE: |
| _debug_printf("_sample"); |
| break; |
| default: |
| assert(!"Unknown usage"); |
| _debug_printf("_???"); |
| } |
| |
| if (usage_index) { |
| _debug_printf("%u", usage_index); |
| } |
| } |
| |
| static void |
| dump_dstreg(struct sh_dstreg dstreg, |
| struct sh_srcreg *indreg, |
| const struct dump_info *di) |
| { |
| union { |
| struct sh_reg reg; |
| struct sh_dstreg dstreg; |
| } u; |
| |
| memset(&u, 0, sizeof(u)); |
| |
| assert( (dstreg.modifier & (SVGA3DDSTMOD_SATURATE | SVGA3DDSTMOD_PARTIALPRECISION)) == dstreg.modifier ); |
| |
| if (dstreg.modifier & SVGA3DDSTMOD_SATURATE) |
| _debug_printf( "_sat" ); |
| if (dstreg.modifier & SVGA3DDSTMOD_PARTIALPRECISION) |
| _debug_printf( "_pp" ); |
| switch (dstreg.shift_scale) { |
| case 0: |
| break; |
| case 1: |
| _debug_printf( "_x2" ); |
| break; |
| case 2: |
| _debug_printf( "_x4" ); |
| break; |
| case 3: |
| _debug_printf( "_x8" ); |
| break; |
| case 13: |
| _debug_printf( "_d8" ); |
| break; |
| case 14: |
| _debug_printf( "_d4" ); |
| break; |
| case 15: |
| _debug_printf( "_d2" ); |
| break; |
| default: |
| assert( 0 ); |
| } |
| _debug_printf( " " ); |
| |
| u.dstreg = dstreg; |
| dump_reg( u.reg, indreg, di); |
| if (dstreg.write_mask != SVGA3DWRITEMASK_ALL) { |
| _debug_printf( "." ); |
| if (dstreg.write_mask & SVGA3DWRITEMASK_0) |
| _debug_printf( "x" ); |
| if (dstreg.write_mask & SVGA3DWRITEMASK_1) |
| _debug_printf( "y" ); |
| if (dstreg.write_mask & SVGA3DWRITEMASK_2) |
| _debug_printf( "z" ); |
| if (dstreg.write_mask & SVGA3DWRITEMASK_3) |
| _debug_printf( "w" ); |
| } |
| } |
| |
| static void dump_srcreg( struct sh_srcreg srcreg, struct sh_srcreg *indreg, const struct dump_info *di ) |
| { |
| switch (srcreg.modifier) { |
| case SVGA3DSRCMOD_NEG: |
| case SVGA3DSRCMOD_BIASNEG: |
| case SVGA3DSRCMOD_SIGNNEG: |
| case SVGA3DSRCMOD_X2NEG: |
| case SVGA3DSRCMOD_ABSNEG: |
| _debug_printf( "-" ); |
| break; |
| case SVGA3DSRCMOD_COMP: |
| _debug_printf( "1-" ); |
| break; |
| case SVGA3DSRCMOD_NOT: |
| _debug_printf( "!" ); |
| } |
| dump_reg( *(struct sh_reg *) &srcreg, indreg, di ); |
| switch (srcreg.modifier) { |
| case SVGA3DSRCMOD_NONE: |
| case SVGA3DSRCMOD_NEG: |
| case SVGA3DSRCMOD_COMP: |
| case SVGA3DSRCMOD_NOT: |
| break; |
| case SVGA3DSRCMOD_BIAS: |
| case SVGA3DSRCMOD_BIASNEG: |
| _debug_printf( "_bias" ); |
| break; |
| case SVGA3DSRCMOD_SIGN: |
| case SVGA3DSRCMOD_SIGNNEG: |
| _debug_printf( "_bx2" ); |
| break; |
| case SVGA3DSRCMOD_X2: |
| case SVGA3DSRCMOD_X2NEG: |
| _debug_printf( "_x2" ); |
| break; |
| case SVGA3DSRCMOD_DZ: |
| _debug_printf( "_dz" ); |
| break; |
| case SVGA3DSRCMOD_DW: |
| _debug_printf( "_dw" ); |
| break; |
| case SVGA3DSRCMOD_ABS: |
| case SVGA3DSRCMOD_ABSNEG: |
| _debug_printf("_abs"); |
| break; |
| default: |
| assert( 0 ); |
| } |
| if (srcreg.swizzle_x != 0 || srcreg.swizzle_y != 1 || srcreg.swizzle_z != 2 || srcreg.swizzle_w != 3) { |
| _debug_printf( "." ); |
| if (srcreg.swizzle_x == srcreg.swizzle_y && srcreg.swizzle_y == srcreg.swizzle_z && srcreg.swizzle_z == srcreg.swizzle_w) { |
| _debug_printf( "%c", "xyzw"[srcreg.swizzle_x] ); |
| } |
| else { |
| _debug_printf( "%c", "xyzw"[srcreg.swizzle_x] ); |
| _debug_printf( "%c", "xyzw"[srcreg.swizzle_y] ); |
| _debug_printf( "%c", "xyzw"[srcreg.swizzle_z] ); |
| _debug_printf( "%c", "xyzw"[srcreg.swizzle_w] ); |
| } |
| } |
| } |
| |
| static void |
| parse_op(struct dump_info *di, |
| const uint **token, |
| struct dump_op *op, |
| uint num_dst, |
| uint num_src) |
| { |
| uint i; |
| |
| assert(num_dst <= 1); |
| assert(num_src <= DUMP_MAX_OP_SRC); |
| |
| op->op = *(struct sh_op *)*token; |
| *token += sizeof(struct sh_op) / sizeof(uint); |
| |
| if (num_dst >= 1) { |
| op->dst = *(struct sh_dstreg *)*token; |
| *token += sizeof(struct sh_dstreg) / sizeof(uint); |
| if (op->dst.relative && |
| (!di->is_ps && di->version >= SVGA3D_VS_30)) { |
| op->dstind = *(struct sh_srcreg *)*token; |
| *token += sizeof(struct sh_srcreg) / sizeof(uint); |
| } |
| } |
| |
| if (op->op.predicated) { |
| op->p0 = *(struct sh_srcreg *)*token; |
| *token += sizeof(struct sh_srcreg) / sizeof(uint); |
| } |
| |
| for (i = 0; i < num_src; ++i) { |
| op->src[i] = *(struct sh_srcreg *)*token; |
| *token += sizeof(struct sh_srcreg) / sizeof(uint); |
| if (op->src[i].relative && |
| ((!di->is_ps && di->version >= SVGA3D_VS_20) || |
| (di->is_ps && di->version >= SVGA3D_PS_30))) { |
| op->srcind[i] = *(struct sh_srcreg *)*token; |
| *token += sizeof(struct sh_srcreg) / sizeof(uint); |
| } |
| } |
| } |
| |
| static void |
| dump_inst(struct dump_info *di, |
| const unsigned **assem, |
| struct sh_op op, |
| const struct sh_opcode_info *info) |
| { |
| struct dump_op dop; |
| boolean not_first_arg = FALSE; |
| uint i; |
| |
| assert(info->num_dst <= 1); |
| |
| di->indent -= info->pre_dedent; |
| dump_indent(di->indent); |
| di->indent += info->post_indent; |
| |
| dump_op(op, info->mnemonic); |
| |
| parse_op(di, assem, &dop, info->num_dst, info->num_src); |
| if (info->num_dst > 0) { |
| dump_dstreg(dop.dst, &dop.dstind, di); |
| not_first_arg = TRUE; |
| } |
| |
| for (i = 0; i < info->num_src; i++) { |
| if (not_first_arg) { |
| _debug_printf(", "); |
| } else { |
| _debug_printf(" "); |
| } |
| dump_srcreg(dop.src[i], &dop.srcind[i], di); |
| not_first_arg = TRUE; |
| } |
| |
| _debug_printf("\n"); |
| } |
| |
| void |
| svga_shader_dump( |
| const unsigned *assem, |
| unsigned dwords, |
| unsigned do_binary ) |
| { |
| boolean finished = FALSE; |
| struct dump_info di; |
| |
| di.version = *assem++; |
| di.is_ps = (di.version & 0xFFFF0000) == 0xFFFF0000; |
| di.indent = 0; |
| |
| _debug_printf( |
| "%s_%u_%u\n", |
| di.is_ps ? "ps" : "vs", |
| (di.version >> 8) & 0xff, |
| di.version & 0xff ); |
| |
| while (!finished) { |
| struct sh_op op = *(struct sh_op *) assem; |
| |
| switch (op.opcode) { |
| case SVGA3DOP_DCL: |
| { |
| struct sh_dcl dcl = *(struct sh_dcl *) assem; |
| |
| _debug_printf( "dcl" ); |
| switch (sh_dstreg_type(dcl.reg)) { |
| case SVGA3DREG_INPUT: |
| if ((di.is_ps && di.version >= SVGA3D_PS_30) || |
| (!di.is_ps && di.version >= SVGA3D_VS_30)) { |
| dump_semantic(dcl.u.semantic.usage, |
| dcl.u.semantic.usage_index); |
| } |
| break; |
| case SVGA3DREG_TEXCRDOUT: |
| if (!di.is_ps && di.version >= SVGA3D_VS_30) { |
| dump_semantic(dcl.u.semantic.usage, |
| dcl.u.semantic.usage_index); |
| } |
| break; |
| case SVGA3DREG_SAMPLER: |
| dump_sampleinfo( dcl.u.sampleinfo ); |
| break; |
| } |
| dump_dstreg(dcl.reg, NULL, &di); |
| _debug_printf( "\n" ); |
| assem += sizeof( struct sh_dcl ) / sizeof( unsigned ); |
| } |
| break; |
| |
| case SVGA3DOP_DEFB: |
| { |
| struct sh_defb defb = *(struct sh_defb *) assem; |
| |
| _debug_printf( "defb " ); |
| dump_reg( defb.reg, NULL, &di ); |
| _debug_printf( ", " ); |
| dump_bdata( defb.data ); |
| _debug_printf( "\n" ); |
| assem += sizeof( struct sh_defb ) / sizeof( unsigned ); |
| } |
| break; |
| |
| case SVGA3DOP_DEFI: |
| { |
| struct sh_defi defi = *(struct sh_defi *) assem; |
| |
| _debug_printf( "defi " ); |
| dump_reg( defi.reg, NULL, &di ); |
| _debug_printf( ", " ); |
| dump_idata( defi.idata ); |
| _debug_printf( "\n" ); |
| assem += sizeof( struct sh_defi ) / sizeof( unsigned ); |
| } |
| break; |
| |
| case SVGA3DOP_TEXCOORD: |
| { |
| struct sh_opcode_info info = *svga_opcode_info(op.opcode); |
| |
| assert(di.is_ps); |
| if (di.version > SVGA3D_PS_13) { |
| assert(info.num_src == 0); |
| |
| info.num_src = 1; |
| } |
| |
| dump_inst(&di, &assem, op, &info); |
| } |
| break; |
| |
| case SVGA3DOP_TEX: |
| { |
| struct sh_opcode_info info = *svga_opcode_info(op.opcode); |
| |
| assert(di.is_ps); |
| if (di.version > SVGA3D_PS_13) { |
| assert(info.num_src == 0); |
| |
| if (di.version > SVGA3D_PS_14) { |
| info.num_src = 2; |
| info.mnemonic = "texld"; |
| } else { |
| info.num_src = 1; |
| } |
| } |
| |
| dump_inst(&di, &assem, op, &info); |
| } |
| break; |
| |
| case SVGA3DOP_DEF: |
| { |
| struct sh_def def = *(struct sh_def *) assem; |
| |
| _debug_printf( "def " ); |
| dump_reg( def.reg, NULL, &di ); |
| _debug_printf( ", " ); |
| dump_cdata( def.cdata ); |
| _debug_printf( "\n" ); |
| assem += sizeof( struct sh_def ) / sizeof( unsigned ); |
| } |
| break; |
| |
| case SVGA3DOP_SINCOS: |
| { |
| struct sh_opcode_info info = *svga_opcode_info(op.opcode); |
| |
| if ((di.is_ps && di.version >= SVGA3D_PS_30) || |
| (!di.is_ps && di.version >= SVGA3D_VS_30)) { |
| assert(info.num_src == 3); |
| |
| info.num_src = 1; |
| } |
| |
| dump_inst(&di, &assem, op, &info); |
| } |
| break; |
| |
| case SVGA3DOP_PHASE: |
| _debug_printf( "phase\n" ); |
| assem += sizeof( struct sh_op ) / sizeof( unsigned ); |
| break; |
| |
| case SVGA3DOP_COMMENT: |
| { |
| struct sh_comment comment = *(struct sh_comment *)assem; |
| |
| /* Ignore comment contents. */ |
| assem += sizeof(struct sh_comment) / sizeof(unsigned) + comment.size; |
| } |
| break; |
| |
| case SVGA3DOP_END: |
| finished = TRUE; |
| break; |
| |
| default: |
| { |
| const struct sh_opcode_info *info = svga_opcode_info(op.opcode); |
| |
| dump_inst(&di, &assem, op, info); |
| } |
| } |
| } |
| } |
