Enable compact TGSI dump.

2 files changed, 794 insertions, 430 deletions

diff --git a/src/mesa/pipe/tgsi/core/tgsi_dump.c b/src/mesa/pipe/tgsi/core/tgsi_dump.c
index 3e2eb4999f4..68b81b7ffe9 100644
--- a/src/mesa/pipe/tgsi/core/tgsi_dump.c
+++ b/src/mesa/pipe/tgsi/core/tgsi_dump.c
@@ -124,15 +124,15 @@ text_dump_untab(
    --dump->tabs;
 }
 
-#define TXT(S)          text_dump_str( &dump, S )
-#define CHR(C)          text_dump_chr( &dump, C )
-#define UIX(I)          text_dump_uix( &dump, I )
-#define UID(I)          text_dump_uid( &dump, I )
-#define SID(I)          text_dump_sid( &dump, I )
-#define FLT(F)          text_dump_flt( &dump, F )
-#define TAB()           text_dump_tab( &dump )
-#define UNT()           text_dump_untab( &dump )
-#define ENM(E,ENUMS)    text_dump_enum( &dump, E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
+#define TXT(S)          text_dump_str( dump, S )
+#define CHR(C)          text_dump_chr( dump, C )
+#define UIX(I)          text_dump_uix( dump, I )
+#define UID(I)          text_dump_uid( dump, I )
+#define SID(I)          text_dump_sid( dump, I )
+#define FLT(F)          text_dump_flt( dump, F )
+#define TAB()           text_dump_tab( dump )
+#define UNT()           text_dump_untab( dump )
+#define ENM(E,ENUMS)    text_dump_enum( dump, E, ENUMS, sizeof( ENUMS ) / sizeof( *ENUMS ) )
 
 static const char *TGSI_PROCESSOR_TYPES[] =
 {
@@ -167,6 +167,18 @@ static const char *TGSI_FILES[] =
    "FILE_IMMEDIATE"
 };
 
+static const char *TGSI_FILES_SHORT[] =
+{
+   "NULL",
+   "CONST",
+   "IN",
+   "OUT",
+   "TEMP",
+   "SAMP",
+   "ADDR",
+   "IMM"
+};
+
 static const char *TGSI_DECLARES[] =
 {
    "DECLARE_RANGE",
@@ -180,11 +192,23 @@ static const char *TGSI_INTERPOLATES[] =
    "INTERPOLATE_PERSPECTIVE"
 };
 
+static const char *TGSI_INTERPOLATES_SHORT[] =
+{
+   "CONSTANT",
+   "LINEAR",
+   "PERSPECTIVE"
+};
+
 static const char *TGSI_IMMS[] =
 {
    "IMM_FLOAT32"
 };
 
+static const char *TGSI_IMMS_SHORT[] =
+{
+   "FLT32"
+};
+
 static const char *TGSI_OPCODES[] =
 {
    "OPCODE_ARL",
@@ -296,6 +320,117 @@ static const char *TGSI_OPCODES[] =
    "OPCODE_NOP"
 };
 
+static const char *TGSI_OPCODES_SHORT[] =
+{
+   "ARL",
+   "MOV",
+   "LIT",
+   "RCP",
+   "RSQ",
+   "EXP",
+   "LOG",
+   "MUL",
+   "ADD",
+   "DP3",
+   "DP4",
+   "DST",
+   "MIN",
+   "MAX",
+   "SLT",
+   "SGE",
+   "MAD",
+   "SUB",
+   "LERP",
+   "CND",
+   "CND0",
+   "DOT2ADD",
+   "INDEX",
+   "NEGATE",
+   "FRAC",
+   "CLAMP",
+   "FLOOR",
+   "ROUND",
+   "EXPBASE2",
+   "LOGBASE2",
+   "POWER",
+   "CROSSPRODUCT",
+   "MULTIPLYMATRIX",
+   "ABS",
+   "RCC",
+   "DPH",
+   "COS",
+   "DDX",
+   "DDY",
+   "KIL",
+   "PK2H",
+   "PK2US",
+   "PK4B",
+   "PK4UB",
+   "RFL",
+   "SEQ",
+   "SFL",
+   "SGT",
+   "SIN",
+   "SLE",
+   "SNE",
+   "STR",
+   "TEX",
+   "TXD",
+   "UP2H",
+   "UP2US",
+   "UP4B",
+   "UP4UB",
+   "X2D",
+   "ARA",
+   "ARR",
+   "BRA",
+   "CAL",
+   "RET",
+   "SSG",
+   "CMP",
+   "SCS",
+   "TXB",
+   "NRM",
+   "DIV",
+   "DP2",
+   "TXL",
+   "BRK",
+   "IF",
+   "LOOP",
+   "REP",
+   "ELSE",
+   "ENDIF",
+   "ENDLOOP",
+   "ENDREP",
+   "PUSHA",
+   "POPA",
+   "CEIL",
+   "I2F",
+   "NOT",
+   "TRUNC",
+   "SHL",
+   "SHR",
+   "AND",
+   "OR",
+   "MOD",
+   "XOR",
+   "SAD",
+   "TXF",
+   "TXQ",
+   "CONT",
+   "EMIT",
+   "ENDPRIM",
+   "BGNLOOP2",
+   "BGNSUB",
+   "ENDLOOP2",
+   "ENDSUB",
+   "NOISE1",
+   "NOISE2",
+   "NOISE3",
+   "NOISE4",
+   "NOP"
+};
+
 static const char *TGSI_SATS[] =
 {
    "SAT_NONE",
@@ -339,6 +474,14 @@ static const char *TGSI_SWIZZLES[] =
    "SWIZZLE_W"
 };
 
+static const char *TGSI_SWIZZLES_SHORT[] =
+{
+   "x",
+   "y",
+   "z",
+   "w"
+};
+
 static const char *TGSI_TEXTURES[] =
 {
    "TEXTURE_UNKNOWN",
@@ -405,12 +548,592 @@ static const char *TGSI_MODULATES[] =
    "MODULATE_EIGHTH"
 };
 
+static void
+dump_declaration_short(
+   struct text_dump *dump,
+   struct tgsi_full_declaration *decl )
+{
+   TXT( "\nDCL " );
+   ENM( decl->Declaration.File, TGSI_FILES_SHORT );
+
+   switch( decl->Declaration.Declare ) {
+   case TGSI_DECLARE_RANGE:
+      CHR( '[' );
+      UID( decl->u.DeclarationRange.First );
+      if( decl->u.DeclarationRange.First != decl->u.DeclarationRange.Last ) {
+         TXT( ".." );
+         UID( decl->u.DeclarationRange.Last );
+      }
+      CHR( ']' );
+      break;
+   default:
+      assert( 0 );
+   }
+
+   if( decl->Declaration.Interpolate ) {
+      TXT( ", " );
+      ENM( decl->Interpolation.Interpolate, TGSI_INTERPOLATES_SHORT );
+   }
+}
+
+static void
+dump_declaration_verbose(
+   struct text_dump *dump,
+   struct tgsi_full_declaration *decl,
+   GLuint ignored,
+   GLuint deflt,
+   struct tgsi_full_declaration *fd )
+{
+   TXT( "\nFile       : " );
+   ENM( decl->Declaration.File, TGSI_FILES );
+   TXT( "\nDeclare    : " );
+   ENM( decl->Declaration.Declare, TGSI_DECLARES );
+   if( deflt || fd->Declaration.Interpolate != decl->Declaration.Interpolate ) {
+      TXT( "\nInterpolate: " );
+      UID( decl->Declaration.Interpolate );
+   }
+   if( ignored ) {
+      TXT( "\nPadding    : " );
+      UIX( decl->Declaration.Padding );
+   }
+
+   CHR( '\n' );
+   switch( decl->Declaration.Declare ) {
+   case TGSI_DECLARE_RANGE:
+      TXT( "\nFirst: " );
+      UID( decl->u.DeclarationRange.First );
+      TXT( "\nLast : " );
+      UID( decl->u.DeclarationRange.Last );
+      break;
+
+   case TGSI_DECLARE_MASK:
+      TXT( "\nMask: " );
+      UIX( decl->u.DeclarationMask.Mask );
+      break;
+
+   default:
+      assert( 0 );
+   }
+
+   if( decl->Declaration.Interpolate ) {
+      CHR( '\n' );
+      TXT( "\nInterpolate: " );
+      ENM( decl->Interpolation.Interpolate, TGSI_INTERPOLATES );
+      if( ignored ) {
+         TXT( "\nPadding    : " );
+         UIX( decl->Interpolation.Padding );
+      }
+   }
+}
+
+static void
+dump_immediate_short(
+   struct text_dump *dump,
+   struct tgsi_full_immediate *imm )
+{
+   GLuint i;
+
+   TXT( "\nIMM " );
+   ENM( imm->Immediate.DataType, TGSI_IMMS_SHORT );
+
+   TXT( " { " );
+   for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
+      switch( imm->Immediate.DataType ) {
+      case TGSI_IMM_FLOAT32:
+         FLT( imm->u.ImmediateFloat32[i].Float );
+         break;
+
+      default:
+         assert( 0 );
+      }
+
+      if( i < imm->Immediate.Size - 2 ) {
+         TXT( ", " );
+      }
+   }
+   TXT( " }" );
+}
+
+static void
+dump_immediate_verbose(
+   struct text_dump *dump,
+   struct tgsi_full_immediate *imm,
+   GLuint ignored )
+{
+   GLuint i;
+
+   TXT( "\nDataType   : " );
+   ENM( imm->Immediate.DataType, TGSI_IMMS );
+   if( ignored ) {
+      TXT( "\nPadding    : " );
+      UIX( imm->Immediate.Padding );
+   }
+
+   for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
+      CHR( '\n' );
+      switch( imm->Immediate.DataType ) {
+      case TGSI_IMM_FLOAT32:
+         TXT( "\nFloat: " );
+         FLT( imm->u.ImmediateFloat32[i].Float );
+         break;
+
+      default:
+         assert( 0 );
+      }
+   }
+}
+
+static void
+dump_instruction_short(
+   struct text_dump *dump,
+   struct tgsi_full_instruction *inst )
+{
+   GLuint i;
+   GLboolean first_reg = GL_TRUE;
+
+   CHR( '\n' );
+   ENM( inst->Instruction.Opcode, TGSI_OPCODES_SHORT );
+
+   switch( inst->Instruction.Saturate ) {
+   case TGSI_SAT_NONE:
+      break;
+   case TGSI_SAT_ZERO_ONE:
+      TXT( "_SAT" );
+      break;
+   case TGSI_SAT_MINUS_PLUS_ONE:
+      TXT( "_SAT[-1,1]" );
+      break;
+   default:
+      assert( 0 );
+   }
+
+   for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
+      struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
+
+      if( !first_reg ) {
+         CHR( ',' );
+      }
+      CHR( ' ' );
+
+      ENM( dst->DstRegister.File, TGSI_FILES_SHORT );
+
+      CHR( '[' );
+      SID( dst->DstRegister.Index );
+      CHR( ']' );
+
+      if( dst->DstRegister.WriteMask != TGSI_WRITEMASK_XYZW ) {
+         CHR( '.' );
+         if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_X ) {
+            CHR( 'x' );
+         }
+         if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_Y ) {
+            CHR( 'y' );
+         }
+         if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_Z ) {
+            CHR( 'z' );
+         }
+         if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_W ) {
+            CHR( 'w' );
+         }
+      }
+
+      first_reg = GL_FALSE;
+   }
+
+   for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
+      struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
+
+      if( !first_reg ) {
+         CHR( ',' );
+      }
+      CHR( ' ' );
+
+      if( src->SrcRegisterExtMod.Negate  ) {
+         CHR( '-' );
+      }
+      if( src->SrcRegisterExtMod.Absolute ) {
+         CHR( '|' );
+      }
+      if( src->SrcRegister.Negate ) {
+         CHR( '-' );
+      }
+
+      ENM( src->SrcRegister.File, TGSI_FILES_SHORT );
+
+      CHR( '[' );
+      SID( src->SrcRegister.Index );
+      CHR( ']' );
+
+      if( src->SrcRegister.SwizzleX != TGSI_SWIZZLE_X ||
+            src->SrcRegister.SwizzleY != TGSI_SWIZZLE_Y ||
+            src->SrcRegister.SwizzleZ != TGSI_SWIZZLE_Z ||
+            src->SrcRegister.SwizzleW != TGSI_SWIZZLE_W ) {
+         CHR( '.' );
+         ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES_SHORT );
+         ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES_SHORT );
+         ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES_SHORT );
+         ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES_SHORT );
+      }
+
+      if( src->SrcRegisterExtMod.Absolute ) {
+         CHR( '|' );
+      }
+
+      first_reg = GL_FALSE;
+   }
+}
+
+static void
+dump_instruction_verbose(
+   struct text_dump *dump,
+   struct tgsi_full_instruction *inst,
+   GLuint ignored,
+   GLuint deflt,
+   struct tgsi_full_instruction *fi )
+{
+   GLuint i;
+
+   TXT( "\nOpcode     : " );
+   ENM( inst->Instruction.Opcode, TGSI_OPCODES );
+   if( deflt || fi->Instruction.Saturate != inst->Instruction.Saturate ) {
+      TXT( "\nSaturate   : " );
+      ENM( inst->Instruction.Saturate, TGSI_SATS );
+   }
+   if( deflt || fi->Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
+      TXT( "\nNumDstRegs : " );
+      UID( inst->Instruction.NumDstRegs );
+   }
+   if( deflt || fi->Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
+      TXT( "\nNumSrcRegs : " );
+      UID( inst->Instruction.NumSrcRegs );
+   }
+   if( ignored ) {
+      TXT( "\nPadding    : " );
+      UIX( inst->Instruction.Padding );
+   }
+
+   if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi->InstructionExtNv ) ) {
+      CHR( '\n' );
+      TXT( "\nType          : " );
+      ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
+      if( deflt || fi->InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
+         TXT( "\nPrecision     : " );
+         ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
+      }
+      if( deflt || fi->InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
+         TXT( "\nCondDstIndex  : " );
+         UID( inst->InstructionExtNv.CondDstIndex );
+      }
+      if( deflt || fi->InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
+         TXT( "\nCondFlowIndex : " );
+         UID( inst->InstructionExtNv.CondFlowIndex );
+      }
+      if( deflt || fi->InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
+         TXT( "\nCondMask      : " );
+         ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
+      }
+      if( deflt || fi->InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
+         TXT( "\nCondSwizzleX  : " );
+         ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
+      }
+      if( deflt || fi->InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
+         TXT( "\nCondSwizzleY  : " );
+         ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
+      }
+      if( deflt || fi->InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
+         TXT( "\nCondSwizzleZ  : " );
+         ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
+      }
+      if( deflt || fi->InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
+         TXT( "\nCondSwizzleW  : " );
+         ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
+      }
+      if( deflt || fi->InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
+         TXT( "\nCondDstUpdate : " );
+         UID( inst->InstructionExtNv.CondDstUpdate );
+      }
+      if( deflt || fi->InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
+         TXT( "\nCondFlowEnable: " );
+         UID( inst->InstructionExtNv.CondFlowEnable );
+      }
+      if( ignored ) {
+         TXT( "\nPadding       : " );
+         UIX( inst->InstructionExtNv.Padding );
+         if( deflt || fi->InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
+            TXT( "\nExtended      : " );
+            UID( inst->InstructionExtNv.Extended );
+         }
+      }
+   }
+
+   if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi->InstructionExtLabel ) ) {
+      CHR( '\n' );
+      TXT( "\nType    : " );
+      ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
+      if( deflt || fi->InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
+         TXT( "\nLabel   : " );
+         UID( inst->InstructionExtLabel.Label );
+      }
+      if( ignored ) {
+         TXT( "\nPadding : " );
+         UIX( inst->InstructionExtLabel.Padding );
+         if( deflt || fi->InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
+            TXT( "\nExtended: " );
+            UID( inst->InstructionExtLabel.Extended );
+         }
+      }
+   }
+
+   if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi->InstructionExtTexture ) ) {
+      CHR( '\n' );
+      TXT( "\nType    : " );
+      ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
+      if( deflt || fi->InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
+         TXT( "\nTexture : " );
+         ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
+      }
+      if( ignored ) {
+         TXT( "\nPadding : " );
+         UIX( inst->InstructionExtTexture.Padding );
+         if( deflt || fi->InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
+            TXT( "\nExtended: " );
+            UID( inst->InstructionExtTexture.Extended );
+         }
+      }
+   }
+
+   for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
+      struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
+      struct tgsi_full_dst_register *fd = &fi->FullDstRegisters[i];
+
+      CHR( '\n' );
+      TXT( "\nFile     : " );
+      ENM( dst->DstRegister.File, TGSI_FILES );
+      if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
+         TXT( "\nWriteMask: " );
+         ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
+      }
+      if( ignored ) {
+         if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
+            TXT( "\nIndirect : " );
+            UID( dst->DstRegister.Indirect );
+         }
+         if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
+            TXT( "\nDimension: " );
+            UID( dst->DstRegister.Dimension );
+         }
+      }
+      if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
+         TXT( "\nIndex    : " );
+         SID( dst->DstRegister.Index );
+      }
+      if( ignored ) {
+         TXT( "\nPadding  : " );
+         UIX( dst->DstRegister.Padding );
+         if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
+            TXT( "\nExtended : " );
+            UID( dst->DstRegister.Extended );
+         }
+      }
+
+      if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
+         CHR( '\n' );
+         TXT( "\nType        : " );
+         ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
+         if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
+            TXT( "\nCondMask    : " );
+            ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
+         }
+         if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
+            TXT( "\nCondSwizzleX: " );
+            ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
+         }
+         if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
+            TXT( "\nCondSwizzleY: " );
+            ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
+         }
+         if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
+            TXT( "\nCondSwizzleZ: " );
+            ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
+         }
+         if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
+            TXT( "\nCondSwizzleW: " );
+            ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
+         }
+         if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
+            TXT( "\nCondSrcIndex: " );
+            UID( dst->DstRegisterExtConcode.CondSrcIndex );
+         }
+         if( ignored ) {
+            TXT( "\nPadding     : " );
+            UIX( dst->DstRegisterExtConcode.Padding );
+            if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
+               TXT( "\nExtended    : " );
+               UID( dst->DstRegisterExtConcode.Extended );
+            }
+         }
+      }
+
+      if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
+         CHR( '\n' );
+         TXT( "\nType    : " );
+         ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
+         if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
+            TXT( "\nModulate: " );
+            ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
+         }
+         if( ignored ) {
+            TXT( "\nPadding : " );
+            UIX( dst->DstRegisterExtModulate.Padding );
+            if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
+               TXT( "\nExtended: " );
+               UID( dst->DstRegisterExtModulate.Extended );
+            }
+         }
+      }
+   }
+
+   for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
+      struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
+      struct tgsi_full_src_register *fs = &fi->FullSrcRegisters[i];
+
+      CHR( '\n' );
+      TXT( "\nFile     : ");
+      ENM( src->SrcRegister.File, TGSI_FILES );
+      if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
+         TXT( "\nSwizzleX : " );
+         ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
+      }
+      if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
+         TXT( "\nSwizzleY : " );
+         ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
+      }
+      if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
+         TXT( "\nSwizzleZ : " );
+         ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
+      }
+      if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
+         TXT( "\nSwizzleW : " );
+         ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
+      }
+      if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
+         TXT( "\nNegate   : " );
+         UID( src->SrcRegister.Negate );
+      }
+      if( ignored ) {
+         if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
+            TXT( "\nIndirect : " );
+            UID( src->SrcRegister.Indirect );
+         }
+         if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
+            TXT( "\nDimension: " );
+            UID( src->SrcRegister.Dimension );
+         }
+      }
+      if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
+         TXT( "\nIndex    : " );
+         SID( src->SrcRegister.Index );
+      }
+      if( ignored ) {
+         if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
+            TXT( "\nExtended : " );
+            UID( src->SrcRegister.Extended );
+         }
+      }
+
+      if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
+         CHR( '\n' );
+         TXT( "\nType       : " );
+         ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
+         if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
+            TXT( "\nExtSwizzleX: " );
+            ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
+            TXT( "\nExtSwizzleY: " );
+            ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
+            TXT( "\nExtSwizzleZ: " );
+            ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
+            TXT( "\nExtSwizzleW: " );
+            ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
+            TXT( "\nNegateX   : " );
+            UID( src->SrcRegisterExtSwz.NegateX );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
+            TXT( "\nNegateY   : " );
+            UID( src->SrcRegisterExtSwz.NegateY );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
+            TXT( "\nNegateZ   : " );
+            UID( src->SrcRegisterExtSwz.NegateZ );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
+            TXT( "\nNegateW   : " );
+            UID( src->SrcRegisterExtSwz.NegateW );
+         }
+         if( deflt || fs->SrcRegisterExtSwz.ExtDivide != src->SrcRegisterExtSwz.ExtDivide ) {
+            TXT( "\nExtDivide  : " );
+            ENM( src->SrcRegisterExtSwz.ExtDivide, TGSI_EXTSWIZZLES );
+         }
+         if( ignored ) {
+            TXT( "\nPadding   : " );
+            UIX( src->SrcRegisterExtSwz.Padding );
+            if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
+               TXT( "\nExtended   : " );
+               UID( src->SrcRegisterExtSwz.Extended );
+            }
+         }
+      }
+
+      if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
+         CHR( '\n' );
+         TXT( "\nType     : " );
+         ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
+         if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
+            TXT( "\nComplement: " );
+            UID( src->SrcRegisterExtMod.Complement );
+         }
+         if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
+            TXT( "\nBias     : " );
+            UID( src->SrcRegisterExtMod.Bias );
+         }
+         if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
+            TXT( "\nScale2X   : " );
+            UID( src->SrcRegisterExtMod.Scale2X );
+         }
+         if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
+            TXT( "\nAbsolute  : " );
+            UID( src->SrcRegisterExtMod.Absolute );
+         }
+         if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
+            TXT( "\nNegate   : " );
+            UID( src->SrcRegisterExtMod.Negate );
+         }
+         if( ignored ) {
+            TXT( "\nPadding   : " );
+            UIX( src->SrcRegisterExtMod.Padding );
+            if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
+               TXT( "\nExtended  : " );
+               UID( src->SrcRegisterExtMod.Extended );
+            }
+         }
+      }
+   }
+}
+
 void
 tgsi_dump(
    const struct tgsi_token *tokens,
    GLuint flags )
 {
-   struct text_dump dump;
+   struct text_dump _dump;
+   struct text_dump *dump = &_dump;
    struct tgsi_parse_context parse;
    struct tgsi_full_instruction fi;
    struct tgsi_full_declaration fd;
@@ -424,10 +1147,10 @@ tgsi_dump(
       char buffer[64];
 
       sprintf( buffer, "tgsi-dump-%.4u.txt", counter++ );
-      dump.file = fopen( buffer, "wt" );
+      dump->file = fopen( buffer, "wt" );
 #else
-      dump.file = stderr;
-      dump.tabs = 0;
+      dump->file = stderr;
+      dump->tabs = 0;
 #endif
    }
 
@@ -436,7 +1159,7 @@ tgsi_dump(
 
    tgsi_parse_init( &parse, tokens );
 
-   TXT( "tgsi-dump begin" );
+   TXT( "tgsi-dump begin -----------------" );
 
    CHR( '\n' );
    ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES_SHORT );
@@ -446,459 +1169,100 @@ tgsi_dump(
    UID( parse.FullVersion.Version.MinorVersion );
 
    if( verbose ) {
-      CHR( '\n' );
       TXT( "\nMajorVersion: " );
       UID( parse.FullVersion.Version.MajorVersion );
       TXT( "\nMinorVersion: " );
       UID( parse.FullVersion.Version.MinorVersion );
-
       CHR( '\n' );
+
       TXT( "\nHeaderSize: " );
       UID( parse.FullHeader.Header.HeaderSize );
       TXT( "\nBodySize  : " );
       UID( parse.FullHeader.Header.BodySize );
       TXT( "\nProcessor : " );
       ENM( parse.FullHeader.Processor.Processor, TGSI_PROCESSOR_TYPES );
+      CHR( '\n' );
    }
 
    fi = tgsi_default_full_instruction();
    fd = tgsi_default_full_declaration();
 
    while( !tgsi_parse_end_of_tokens( &parse ) ) {
-      GLuint i;
-
       tgsi_parse_token( &parse );
 
-      CHR( '\n' );
-      TXT( "\nType       : " );
-      ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
-      if( ignored ) {
-         TXT( "\nSize       : " );
-         UID( parse.FullToken.Token.Size );
-         if( deflt || parse.FullToken.Token.Extended ) {
-            TXT( "\nExtended   : " );
-            UID( parse.FullToken.Token.Extended );
-         }
-      }
-
       switch( parse.FullToken.Token.Type ) {
       case TGSI_TOKEN_TYPE_DECLARATION:
-         {
-            struct tgsi_full_declaration *decl = &parse.FullToken.FullDeclaration;
-
-            TXT( "\nFile       : " );
-            ENM( decl->Declaration.File, TGSI_FILES );
-            TXT( "\nDeclare    : " );
-            ENM( decl->Declaration.Declare, TGSI_DECLARES );
-            if( deflt || fd.Declaration.Interpolate != decl->Declaration.Interpolate ) {
-               TXT( "\nInterpolate: " );
-               UID( decl->Declaration.Interpolate );
-            }
-            if( ignored ) {
-               TXT( "\nPadding    : " );
-               UIX( decl->Declaration.Padding );
-            }
-
-            CHR( '\n' );
-            switch( decl->Declaration.Declare ) {
-            case TGSI_DECLARE_RANGE:
-               TXT( "\nFirst: " );
-               UID( decl->u.DeclarationRange.First );
-               TXT( "\nLast : " );
-               UID( decl->u.DeclarationRange.Last );
-               break;
-
-            case TGSI_DECLARE_MASK:
-               TXT( "\nMask: " );
-               UIX( decl->u.DeclarationMask.Mask );
-               break;
-
-            default:
-               assert( 0 );
-            }
-
-            if( decl->Declaration.Interpolate ) {
-               CHR( '\n' );
-               TXT( "\nInterpolate: " );
-               ENM( decl->Interpolation.Interpolate, TGSI_INTERPOLATES );
-               if( ignored ) {
-                  TXT( "\nPadding    : " );
-                  UIX( decl->Interpolation.Padding );
-               }
-            }
-         }
+         dump_declaration_short(
+            dump,
+            &parse.FullToken.FullDeclaration );
          break;
 
       case TGSI_TOKEN_TYPE_IMMEDIATE:
-         TXT( "\nDataType   : " );
-         ENM( parse.FullToken.FullImmediate.Immediate.DataType, TGSI_IMMS );
-         if( ignored ) {
-            TXT( "\nPadding    : " );
-            UIX( parse.FullToken.FullImmediate.Immediate.Padding );
-         }
-
-         for( i = 0; i < parse.FullToken.FullImmediate.Immediate.Size - 1; i++ ) {
-            CHR( '\n' );
-            switch( parse.FullToken.FullImmediate.Immediate.DataType ) {
-            case TGSI_IMM_FLOAT32:
-               TXT( "\nFloat: " );
-               FLT( parse.FullToken.FullImmediate.u.ImmediateFloat32[i].Float );
-               break;
-
-            default:
-               assert( 0 );
-            }
-         }
+         dump_immediate_short(
+            dump,
+            &parse.FullToken.FullImmediate );
          break;
 
       case TGSI_TOKEN_TYPE_INSTRUCTION:
-         {
-            struct tgsi_full_instruction *inst = &parse.FullToken.FullInstruction;
-
-            TXT( "\nOpcode     : " );
-            ENM( inst->Instruction.Opcode, TGSI_OPCODES );
-            if( deflt || fi.Instruction.Saturate != inst->Instruction.Saturate ) {
-               TXT( "\nSaturate   : " );
-               ENM( inst->Instruction.Saturate, TGSI_SATS );
-            }
-            if( deflt || fi.Instruction.NumDstRegs != inst->Instruction.NumDstRegs ) {
-               TXT( "\nNumDstRegs : " );
-               UID( inst->Instruction.NumDstRegs );
-            }
-            if( deflt || fi.Instruction.NumSrcRegs != inst->Instruction.NumSrcRegs ) {
-               TXT( "\nNumSrcRegs : " );
-               UID( inst->Instruction.NumSrcRegs );
-            }
-            if( ignored ) {
-               TXT( "\nPadding    : " );
-               UIX( inst->Instruction.Padding );
-            }
-
-            if( deflt || tgsi_compare_instruction_ext_nv( inst->InstructionExtNv, fi.InstructionExtNv)) {
-               CHR( '\n' );
-               TXT( "\nType          : " );
-               ENM( inst->InstructionExtNv.Type, TGSI_INSTRUCTION_EXTS );
-               if( deflt || fi.InstructionExtNv.Precision != inst->InstructionExtNv.Precision ) {
-                  TXT( "\nPrecision     : " );
-                  ENM( inst->InstructionExtNv.Precision, TGSI_PRECISIONS );
-               }
-               if( deflt || fi.InstructionExtNv.CondDstIndex != inst->InstructionExtNv.CondDstIndex ) {
-                  TXT( "\nCondDstIndex  : " );
-                  UID( inst->InstructionExtNv.CondDstIndex );
-               }
-               if( deflt || fi.InstructionExtNv.CondFlowIndex != inst->InstructionExtNv.CondFlowIndex ) {
-                  TXT( "\nCondFlowIndex : " );
-                  UID( inst->InstructionExtNv.CondFlowIndex );
-               }
-               if( deflt || fi.InstructionExtNv.CondMask != inst->InstructionExtNv.CondMask ) {
-                  TXT( "\nCondMask      : " );
-                  ENM( inst->InstructionExtNv.CondMask, TGSI_CCS );
-               }
-               if( deflt || fi.InstructionExtNv.CondSwizzleX != inst->InstructionExtNv.CondSwizzleX ) {
-                  TXT( "\nCondSwizzleX  : " );
-                  ENM( inst->InstructionExtNv.CondSwizzleX, TGSI_SWIZZLES );
-               }
-               if( deflt || fi.InstructionExtNv.CondSwizzleY != inst->InstructionExtNv.CondSwizzleY ) {
-                  TXT( "\nCondSwizzleY  : " );
-                  ENM( inst->InstructionExtNv.CondSwizzleY, TGSI_SWIZZLES );
-               }
-               if( deflt || fi.InstructionExtNv.CondSwizzleZ != inst->InstructionExtNv.CondSwizzleZ ) {
-                  TXT( "\nCondSwizzleZ  : " );
-                  ENM( inst->InstructionExtNv.CondSwizzleZ, TGSI_SWIZZLES );
-               }
-               if( deflt || fi.InstructionExtNv.CondSwizzleW != inst->InstructionExtNv.CondSwizzleW ) {
-                  TXT( "\nCondSwizzleW  : " );
-                  ENM( inst->InstructionExtNv.CondSwizzleW, TGSI_SWIZZLES );
-               }
-               if( deflt || fi.InstructionExtNv.CondDstUpdate != inst->InstructionExtNv.CondDstUpdate ) {
-                  TXT( "\nCondDstUpdate : " );
-                  UID( inst->InstructionExtNv.CondDstUpdate );
-               }
-               if( deflt || fi.InstructionExtNv.CondFlowEnable != inst->InstructionExtNv.CondFlowEnable ) {
-                  TXT( "\nCondFlowEnable: " );
-                  UID( inst->InstructionExtNv.CondFlowEnable );
-               }
-               if( ignored ) {
-                  TXT( "\nPadding       : " );
-                  UIX( inst->InstructionExtNv.Padding );
-                  if( deflt || fi.InstructionExtNv.Extended != inst->InstructionExtNv.Extended ) {
-                     TXT( "\nExtended      : " );
-                     UID( inst->InstructionExtNv.Extended );
-                  }
-               }
-            }
-
-            if( deflt || tgsi_compare_instruction_ext_label( inst->InstructionExtLabel, fi.InstructionExtLabel ) ) {
-               CHR( '\n' );
-               TXT( "\nType    : " );
-               ENM( inst->InstructionExtLabel.Type, TGSI_INSTRUCTION_EXTS );
-               if( deflt || fi.InstructionExtLabel.Label != inst->InstructionExtLabel.Label ) {
-                  TXT( "\nLabel   : " );
-                  UID( inst->InstructionExtLabel.Label );
-               }
-               if( ignored ) {
-                  TXT( "\nPadding : " );
-                  UIX( inst->InstructionExtLabel.Padding );
-                  if( deflt || fi.InstructionExtLabel.Extended != inst->InstructionExtLabel.Extended ) {
-                     TXT( "\nExtended: " );
-                     UID( inst->InstructionExtLabel.Extended );
-                  }
-               }
-            }
+         dump_instruction_short(
+            dump,
+            &parse.FullToken.FullInstruction );
+         break;
 
-            if( deflt || tgsi_compare_instruction_ext_texture( inst->InstructionExtTexture, fi.InstructionExtTexture ) ) {
-               CHR( '\n' );
-               TXT( "\nType    : " );
-               ENM( inst->InstructionExtTexture.Type, TGSI_INSTRUCTION_EXTS );
-               if( deflt || fi.InstructionExtTexture.Texture != inst->InstructionExtTexture.Texture ) {
-                  TXT( "\nTexture : " );
-                  ENM( inst->InstructionExtTexture.Texture, TGSI_TEXTURES );
-               }
-               if( ignored ) {
-                  TXT( "\nPadding : " );
-                  UIX( inst->InstructionExtTexture.Padding );
-                  if( deflt || fi.InstructionExtTexture.Extended != inst->InstructionExtTexture.Extended ) {
-                     TXT( "\nExtended: " );
-                     UID( inst->InstructionExtTexture.Extended );
-                  }
-               }
-            }
+      default:
+         assert( 0 );
+      }
 
-            for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) {
-               struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
-               struct tgsi_full_dst_register *fd = &fi.FullDstRegisters[i];
-
-               CHR( '\n' );
-               TXT( "\nFile     : " );
-               ENM( dst->DstRegister.File, TGSI_FILES );
-               if( deflt || fd->DstRegister.WriteMask != dst->DstRegister.WriteMask ) {
-                  TXT( "\nWriteMask: " );
-                  ENM( dst->DstRegister.WriteMask, TGSI_WRITEMASKS );
-               }
-               if( ignored ) {
-                  if( deflt || fd->DstRegister.Indirect != dst->DstRegister.Indirect ) {
-                     TXT( "\nIndirect : " );
-                     UID( dst->DstRegister.Indirect );
-                  }
-                  if( deflt || fd->DstRegister.Dimension != dst->DstRegister.Dimension ) {
-                     TXT( "\nDimension: " );
-                     UID( dst->DstRegister.Dimension );
-                  }
-               }
-               if( deflt || fd->DstRegister.Index != dst->DstRegister.Index ) {
-                  TXT( "\nIndex    : " );
-                  SID( dst->DstRegister.Index );
-               }
-               if( ignored ) {
-                  TXT( "\nPadding  : " );
-                  UIX( dst->DstRegister.Padding );
-                  if( deflt || fd->DstRegister.Extended != dst->DstRegister.Extended ) {
-                     TXT( "\nExtended : " );
-                     UID( dst->DstRegister.Extended );
-                  }
-               }
-
-               if( deflt || tgsi_compare_dst_register_ext_concode( dst->DstRegisterExtConcode, fd->DstRegisterExtConcode ) ) {
-                  CHR( '\n' );
-                  TXT( "\nType        : " );
-                  ENM( dst->DstRegisterExtConcode.Type, TGSI_DST_REGISTER_EXTS );
-                  if( deflt || fd->DstRegisterExtConcode.CondMask != dst->DstRegisterExtConcode.CondMask ) {
-                     TXT( "\nCondMask    : " );
-                     ENM( dst->DstRegisterExtConcode.CondMask, TGSI_CCS );
-                  }
-                  if( deflt || fd->DstRegisterExtConcode.CondSwizzleX != dst->DstRegisterExtConcode.CondSwizzleX ) {
-                     TXT( "\nCondSwizzleX: " );
-                     ENM( dst->DstRegisterExtConcode.CondSwizzleX, TGSI_SWIZZLES );
-                  }
-                  if( deflt || fd->DstRegisterExtConcode.CondSwizzleY != dst->DstRegisterExtConcode.CondSwizzleY ) {
-                     TXT( "\nCondSwizzleY: " );
-                     ENM( dst->DstRegisterExtConcode.CondSwizzleY, TGSI_SWIZZLES );
-                  }
-                  if( deflt || fd->DstRegisterExtConcode.CondSwizzleZ != dst->DstRegisterExtConcode.CondSwizzleZ ) {
-                     TXT( "\nCondSwizzleZ: " );
-                     ENM( dst->DstRegisterExtConcode.CondSwizzleZ, TGSI_SWIZZLES );
-                  }
-                  if( deflt || fd->DstRegisterExtConcode.CondSwizzleW != dst->DstRegisterExtConcode.CondSwizzleW ) {
-                     TXT( "\nCondSwizzleW: " );
-                     ENM( dst->DstRegisterExtConcode.CondSwizzleW, TGSI_SWIZZLES );
-                  }
-                  if( deflt || fd->DstRegisterExtConcode.CondSrcIndex != dst->DstRegisterExtConcode.CondSrcIndex ) {
-                     TXT( "\nCondSrcIndex: " );
-                     UID( dst->DstRegisterExtConcode.CondSrcIndex );
-                  }
-                  if( ignored ) {
-                     TXT( "\nPadding     : " );
-                     UIX( dst->DstRegisterExtConcode.Padding );
-                     if( deflt || fd->DstRegisterExtConcode.Extended != dst->DstRegisterExtConcode.Extended ) {
-                        TXT( "\nExtended    : " );
-                        UID( dst->DstRegisterExtConcode.Extended );
-                     }
-                  }
-               }
-
-               if( deflt || tgsi_compare_dst_register_ext_modulate( dst->DstRegisterExtModulate, fd->DstRegisterExtModulate ) ) {
-                  CHR( '\n' );
-                  TXT( "\nType    : " );
-                  ENM( dst->DstRegisterExtModulate.Type, TGSI_DST_REGISTER_EXTS );
-                  if( deflt || fd->DstRegisterExtModulate.Modulate != dst->DstRegisterExtModulate.Modulate ) {
-                     TXT( "\nModulate: " );
-                     ENM( dst->DstRegisterExtModulate.Modulate, TGSI_MODULATES );
-                  }
-                  if( ignored ) {
-                     TXT( "\nPadding : " );
-                     UIX( dst->DstRegisterExtModulate.Padding );
-                     if( deflt || fd->DstRegisterExtModulate.Extended != dst->DstRegisterExtModulate.Extended ) {
-                        TXT( "\nExtended: " );
-                        UID( dst->DstRegisterExtModulate.Extended );
-                     }
-                  }
-               }
+      if( verbose ) {
+         TXT( "\nType       : " );
+         ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
+         if( ignored ) {
+            TXT( "\nSize       : " );
+            UID( parse.FullToken.Token.Size );
+            if( deflt || parse.FullToken.Token.Extended ) {
+               TXT( "\nExtended   : " );
+               UID( parse.FullToken.Token.Extended );
             }
+         }
 
-            for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) {
-               struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
-               struct tgsi_full_src_register *fs = &fi.FullSrcRegisters[i];
-
-               CHR( '\n' );
-               TXT( "\nFile     : ");
-               ENM( src->SrcRegister.File, TGSI_FILES );
-               if( deflt || fs->SrcRegister.SwizzleX != src->SrcRegister.SwizzleX ) {
-                  TXT( "\nSwizzleX : " );
-                  ENM( src->SrcRegister.SwizzleX, TGSI_SWIZZLES );
-               }
-               if( deflt || fs->SrcRegister.SwizzleY != src->SrcRegister.SwizzleY ) {
-                  TXT( "\nSwizzleY : " );
-                  ENM( src->SrcRegister.SwizzleY, TGSI_SWIZZLES );
-               }
-               if( deflt || fs->SrcRegister.SwizzleZ != src->SrcRegister.SwizzleZ ) {
-                  TXT( "\nSwizzleZ : " );
-                  ENM( src->SrcRegister.SwizzleZ, TGSI_SWIZZLES );
-               }
-               if( deflt || fs->SrcRegister.SwizzleW != src->SrcRegister.SwizzleW ) {
-                  TXT( "\nSwizzleW : " );
-                  ENM( src->SrcRegister.SwizzleW, TGSI_SWIZZLES );
-               }
-               if( deflt || fs->SrcRegister.Negate != src->SrcRegister.Negate ) {
-                  TXT( "\nNegate   : " );
-                  UID( src->SrcRegister.Negate );
-               }
-               if( ignored ) {
-                  if( deflt || fs->SrcRegister.Indirect != src->SrcRegister.Indirect ) {
-                     TXT( "\nIndirect : " );
-                     UID( src->SrcRegister.Indirect );
-                  }
-                  if( deflt || fs->SrcRegister.Dimension != src->SrcRegister.Dimension ) {
-                     TXT( "\nDimension: " );
-                     UID( src->SrcRegister.Dimension );
-                  }
-               }
-               if( deflt || fs->SrcRegister.Index != src->SrcRegister.Index ) {
-                  TXT( "\nIndex    : " );
-                  SID( src->SrcRegister.Index );
-               }
-               if( ignored ) {
-                  if( deflt || fs->SrcRegister.Extended != src->SrcRegister.Extended ) {
-                     TXT( "\nExtended : " );
-                     UID( src->SrcRegister.Extended );
-                  }
-               }
-
-               if( deflt || tgsi_compare_src_register_ext_swz( src->SrcRegisterExtSwz, fs->SrcRegisterExtSwz ) ) {
-                  CHR( '\n' );
-                  TXT( "\nType       : " );
-                  ENM( src->SrcRegisterExtSwz.Type, TGSI_SRC_REGISTER_EXTS );
-                  if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleX != src->SrcRegisterExtSwz.ExtSwizzleX ) {
-                     TXT( "\nExtSwizzleX: " );
-                     ENM( src->SrcRegisterExtSwz.ExtSwizzleX, TGSI_EXTSWIZZLES );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleY != src->SrcRegisterExtSwz.ExtSwizzleY ) {
-                     TXT( "\nExtSwizzleY: " );
-                     ENM( src->SrcRegisterExtSwz.ExtSwizzleY, TGSI_EXTSWIZZLES );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleZ != src->SrcRegisterExtSwz.ExtSwizzleZ ) {
-                     TXT( "\nExtSwizzleZ: " );
-                     ENM( src->SrcRegisterExtSwz.ExtSwizzleZ, TGSI_EXTSWIZZLES );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.ExtSwizzleW != src->SrcRegisterExtSwz.ExtSwizzleW ) {
-                     TXT( "\nExtSwizzleW: " );
-                     ENM( src->SrcRegisterExtSwz.ExtSwizzleW, TGSI_EXTSWIZZLES );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.NegateX != src->SrcRegisterExtSwz.NegateX ) {
-                     TXT( "\nNegateX   : " );
-                     UID( src->SrcRegisterExtSwz.NegateX );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.NegateY != src->SrcRegisterExtSwz.NegateY ) {
-                     TXT( "\nNegateY   : " );
-                     UID( src->SrcRegisterExtSwz.NegateY );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.NegateZ != src->SrcRegisterExtSwz.NegateZ ) {
-                     TXT( "\nNegateZ   : " );
-                     UID( src->SrcRegisterExtSwz.NegateZ );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.NegateW != src->SrcRegisterExtSwz.NegateW ) {
-                     TXT( "\nNegateW   : " );
-                     UID( src->SrcRegisterExtSwz.NegateW );
-                  }
-                  if( deflt || fs->SrcRegisterExtSwz.ExtDivide != src->SrcRegisterExtSwz.ExtDivide ) {
-                     TXT( "\nExtDivide  : " );
-                     ENM( src->SrcRegisterExtSwz.ExtDivide, TGSI_EXTSWIZZLES );
-                  }
-                  if( ignored ) {
-                     TXT( "\nPadding   : " );
-                     UIX( src->SrcRegisterExtSwz.Padding );
-                     if( deflt || fs->SrcRegisterExtSwz.Extended != src->SrcRegisterExtSwz.Extended ) {
-                        TXT( "\nExtended   : " );
-                        UID( src->SrcRegisterExtSwz.Extended );
-                     }
-                  }
-               }
-
-               if( deflt || tgsi_compare_src_register_ext_mod( src->SrcRegisterExtMod, fs->SrcRegisterExtMod ) ) {
-                  CHR( '\n' );
-                  TXT( "\nType     : " );
-                  ENM( src->SrcRegisterExtMod.Type, TGSI_SRC_REGISTER_EXTS );
-                  if( deflt || fs->SrcRegisterExtMod.Complement != src->SrcRegisterExtMod.Complement ) {
-                     TXT( "\nComplement: " );
-                     UID( src->SrcRegisterExtMod.Complement );
-                  }
-                  if( deflt || fs->SrcRegisterExtMod.Bias != src->SrcRegisterExtMod.Bias ) {
-                     TXT( "\nBias     : " );
-                     UID( src->SrcRegisterExtMod.Bias );
-                  }
-                  if( deflt || fs->SrcRegisterExtMod.Scale2X != src->SrcRegisterExtMod.Scale2X ) {
-                     TXT( "\nScale2X   : " );
-                     UID( src->SrcRegisterExtMod.Scale2X );
-                  }
-                  if( deflt || fs->SrcRegisterExtMod.Absolute != src->SrcRegisterExtMod.Absolute ) {
-                     TXT( "\nAbsolute  : " );
-                     UID( src->SrcRegisterExtMod.Absolute );
-                  }
-                  if( deflt || fs->SrcRegisterExtMod.Negate != src->SrcRegisterExtMod.Negate ) {
-                     TXT( "\nNegate   : " );
-                     UID( src->SrcRegisterExtMod.Negate );
-                  }
-                  if( ignored ) {
-                     TXT( "\nPadding   : " );
-                     UIX( src->SrcRegisterExtMod.Padding );
-                     if( deflt || fs->SrcRegisterExtMod.Extended != src->SrcRegisterExtMod.Extended ) {
-                        TXT( "\nExtended  : " );
-                        UID( src->SrcRegisterExtMod.Extended );
-                     }
-                  }
-               }
-            }
+         switch( parse.FullToken.Token.Type ) {
+         case TGSI_TOKEN_TYPE_DECLARATION:
+            dump_declaration_verbose(
+               dump,
+               &parse.FullToken.FullDeclaration,
+               ignored,
+               deflt,
+               &fd );
+            break;
+
+         case TGSI_TOKEN_TYPE_IMMEDIATE:
+            dump_immediate_verbose(
+               dump,
+               &parse.FullToken.FullImmediate,
+               ignored );
+            break;
+
+         case TGSI_TOKEN_TYPE_INSTRUCTION:
+            dump_instruction_verbose(
+               dump,
+               &parse.FullToken.FullInstruction,
+               ignored,
+               deflt,
+               &fi );
+            break;
+
+         default:
+            assert( 0 );
          }
-         break;
 
-      default:
-         assert( 0 );
+         CHR( '\n' );
       }
    }
 
-   TXT( "\ntgsi-dump end\n" );
+   TXT( "\ntgsi-dump end -------------------\n" );
 
    tgsi_parse_free( &parse );
 
-   fclose( dump.file );
+   fclose( dump->file );
 }
 
diff --git a/src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.c b/src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.c
index 47fd5791e11..15f4d1e197d 100644
--- a/src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.c
+++ b/src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.c
@@ -569,7 +569,7 @@ tgsi_mesa_compile_fp_program(
          assert( i == program->Base.NumInstructions - 1 );

          tgsi_dump(

             tokens,

-            TGSI_DUMP_NO_IGNORED | TGSI_DUMP_NO_DEFAULT );

+            0/*TGSI_DUMP_VERBOSE | TGSI_DUMP_NO_IGNORED | TGSI_DUMP_NO_DEFAULT*/ );

          break;

       }