src/mesa/shader/prog_print.c - platform/external/mesa3d - Gitiles

 /*
  * Mesa 3-D graphics library
  * Version:  6.5.3
  *
  * Copyright (C) 1999-2007  Brian Paul   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
  * BRIAN PAUL 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 prog_print.c
  * Print vertex/fragment programs - for debugging.
  * \author Brian Paul
  */

 #include "glheader.h"
 #include "context.h"
 #include "imports.h"
 #include "prog_instruction.h"
 #include "prog_parameter.h"
 #include "prog_print.h"
 #include "prog_statevars.h"


 /**
  * Return string name for given program/register file.
  */
 static const char *
 program_file_string(enum register_file f)
 {
    switch (f) {
    case PROGRAM_TEMPORARY:
       return "TEMP";
    case PROGRAM_LOCAL_PARAM:
       return "LOCAL";
    case PROGRAM_ENV_PARAM:
       return "ENV";
    case PROGRAM_STATE_VAR:
       return "STATE";
    case PROGRAM_INPUT:
       return "INPUT";
    case PROGRAM_OUTPUT:
       return "OUTPUT";
    case PROGRAM_NAMED_PARAM:
       return "NAMED";
    case PROGRAM_CONSTANT:
       return "CONST";
    case PROGRAM_UNIFORM:
       return "UNIFORM";
    case PROGRAM_VARYING:
       return "VARYING";
    case PROGRAM_WRITE_ONLY:
       return "WRITE_ONLY";
    case PROGRAM_ADDRESS:
       return "ADDR";
    case PROGRAM_SAMPLER:
       return "SAMPLER";
    default:
       return "Unknown program file!";
    }
 }


 /**
  * Return a string representation of the given swizzle word.
  * If extended is true, use extended (comma-separated) format.
  * \param swizzle  the swizzle field
  * \param negateBase  4-bit negation vector
  * \param extended  if true, also allow 0, 1 values
  */
 static const char *
 swizzle_string(GLuint swizzle, GLuint negateBase, GLboolean extended)
 {
    static const char swz[] = "xyzw01?!";
    static char s[20];
    GLuint i = 0;

    if (!extended && swizzle == SWIZZLE_NOOP && negateBase == 0)
       return ""; /* no swizzle/negation */

    if (!extended)
       s[i++] = '.';

    if (negateBase & 0x1)
       s[i++] = '-';
    s[i++] = swz[GET_SWZ(swizzle, 0)];

    if (extended) {
       s[i++] = ',';
    }

    if (negateBase & 0x2)
       s[i++] = '-';
    s[i++] = swz[GET_SWZ(swizzle, 1)];

    if (extended) {
       s[i++] = ',';
    }

    if (negateBase & 0x4)
       s[i++] = '-';
    s[i++] = swz[GET_SWZ(swizzle, 2)];

    if (extended) {
       s[i++] = ',';
    }

    if (negateBase & 0x8)
       s[i++] = '-';
    s[i++] = swz[GET_SWZ(swizzle, 3)];

    s[i] = 0;
    return s;
 }


 static const char *
 writemask_string(GLuint writeMask)
 {
    static char s[10];
    GLuint i = 0;

    if (writeMask == WRITEMASK_XYZW)
       return "";

    s[i++] = '.';
    if (writeMask & WRITEMASK_X)
       s[i++] = 'x';
    if (writeMask & WRITEMASK_Y)
       s[i++] = 'y';
    if (writeMask & WRITEMASK_Z)
       s[i++] = 'z';
    if (writeMask & WRITEMASK_W)
       s[i++] = 'w';

    s[i] = 0;
    return s;
 }


 static const char *
 condcode_string(GLuint condcode)
 {
    switch (condcode) {
    case COND_GT:  return "GT";
    case COND_EQ:  return "EQ";
    case COND_LT:  return "LT";
    case COND_UN:  return "UN";
    case COND_GE:  return "GE";
    case COND_LE:  return "LE";
    case COND_NE:  return "NE";
    case COND_TR:  return "TR";
    case COND_FL:  return "FL";
    default: return "cond???";
    }
 }


 static void
 print_dst_reg(const struct prog_dst_register *dstReg)
 {
    _mesa_printf(" %s[%d]%s",
                 program_file_string((enum register_file) dstReg->File),
                 dstReg->Index,
                 writemask_string(dstReg->WriteMask));
 }

 static void
 print_src_reg(const struct prog_src_register *srcReg)
 {
    _mesa_printf("%s[%d]%s",
                 program_file_string((enum register_file) srcReg->File),
                 srcReg->Index,
                 swizzle_string(srcReg->Swizzle,
                                srcReg->NegateBase, GL_FALSE));
 }

 static void
 print_comment(const struct prog_instruction *inst)
 {
    if (inst->Comment)
       _mesa_printf(";  # %s\n", inst->Comment);
    else
       _mesa_printf(";\n");
 }


 void
 _mesa_print_alu_instruction(const struct prog_instruction *inst,
 			    const char *opcode_string,
 			    GLuint numRegs)
 {
    GLuint j;

    _mesa_printf("%s", opcode_string);
    if (inst->CondUpdate)
       _mesa_printf(".C");

    /* frag prog only */
    if (inst->SaturateMode == SATURATE_ZERO_ONE)
       _mesa_printf("_SAT");

    if (inst->DstReg.File != PROGRAM_UNDEFINED) {
       print_dst_reg(&inst->DstReg);
    }
    else {
       _mesa_printf(" ???");
    }

    if (numRegs > 0)
       _mesa_printf(", ");

    for (j = 0; j < numRegs; j++) {
       print_src_reg(inst->SrcReg + j);
       if (j + 1 < numRegs)
 	 _mesa_printf(", ");
    }

    print_comment(inst);
 }


 /**
  * Print a single vertex/fragment program instruction.
  */
 GLint
 _mesa_print_instruction(const struct prog_instruction *inst, GLint indent)
 {
    GLuint i;

    if (inst->Opcode == OPCODE_ELSE ||
        inst->Opcode == OPCODE_ENDIF ||
        inst->Opcode == OPCODE_ENDLOOP ||
        inst->Opcode == OPCODE_ENDSUB) {
       indent -= 3;
    }
    assert(indent >= 0);
    for (i = 0; i < indent; i++) {
       _mesa_printf(" ");
    }

    switch (inst->Opcode) {
    case OPCODE_PRINT:
       _mesa_printf("PRINT '%s'", inst->Data);
       if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) {
          _mesa_printf(", ");
          _mesa_printf("%s[%d]%s",
                       program_file_string((enum register_file) inst->SrcReg[0].File),
                       inst->SrcReg[0].Index,
                       swizzle_string(inst->SrcReg[0].Swizzle,
                                      inst->SrcReg[0].NegateBase, GL_FALSE));
       }
       if (inst->Comment)
          _mesa_printf("  # %s", inst->Comment);
       print_comment(inst);
       break;
    case OPCODE_SWZ:
       _mesa_printf("SWZ");
       if (inst->SaturateMode == SATURATE_ZERO_ONE)
          _mesa_printf("_SAT");
       print_dst_reg(&inst->DstReg);
       _mesa_printf("%s[%d], %s",
                    program_file_string((enum register_file) inst->SrcReg[0].File),
                    inst->SrcReg[0].Index,
                    swizzle_string(inst->SrcReg[0].Swizzle,
                                   inst->SrcReg[0].NegateBase, GL_TRUE));
       print_comment(inst);
       break;
    case OPCODE_TEX:
    case OPCODE_TXP:
    case OPCODE_TXB:
       _mesa_printf("%s", _mesa_opcode_string(inst->Opcode));
       if (inst->SaturateMode == SATURATE_ZERO_ONE)
          _mesa_printf("_SAT");
       print_dst_reg(&inst->DstReg);
       _mesa_printf(", ");
       print_src_reg(&inst->SrcReg[0]);
       _mesa_printf(", texture[%d], ", inst->TexSrcUnit);
       switch (inst->TexSrcTarget) {
       case TEXTURE_1D_INDEX:   _mesa_printf("1D");    break;
       case TEXTURE_2D_INDEX:   _mesa_printf("2D");    break;
       case TEXTURE_3D_INDEX:   _mesa_printf("3D");    break;
       case TEXTURE_CUBE_INDEX: _mesa_printf("CUBE");  break;
       case TEXTURE_RECT_INDEX: _mesa_printf("RECT");  break;
       default:
          ;
       }
       print_comment(inst);
       break;
    case OPCODE_ARL:
       _mesa_printf("ARL addr.x, ");
       print_src_reg(&inst->SrcReg[0]);
       print_comment(inst);
       break;
    case OPCODE_BRA:
       _mesa_printf("BRA %u (%s%s)",
                    inst->BranchTarget,
                    condcode_string(inst->DstReg.CondMask),
                    swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
       print_comment(inst);
       break;
    case OPCODE_CAL:
       _mesa_printf("CAL %u", inst->BranchTarget);
       print_comment(inst);
       break;
    case OPCODE_IF:
       _mesa_printf("IF (%s%s)",
                    condcode_string(inst->DstReg.CondMask),
                    swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
       print_comment(inst);
       return indent + 3;
    case OPCODE_ELSE:
       _mesa_printf("ELSE\n");
       return indent + 3;
    case OPCODE_ENDIF:
       _mesa_printf("ENDIF\n");
       break;
    case OPCODE_BGNLOOP:
       _mesa_printf("BGNLOOP\n");
       return indent + 3;
    case OPCODE_ENDLOOP:
       _mesa_printf("ENDLOOP (goto %d)\n", inst->BranchTarget);
       break;
    case OPCODE_BRK:
       /* XXX just like BRA */
       _mesa_printf("BRK %u (%s%s)",
                    inst->BranchTarget,
                    condcode_string(inst->DstReg.CondMask),
                    swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
       print_comment(inst);
       break;
    case OPCODE_BGNSUB:
       _mesa_printf("SUB;\n");
       print_comment(inst);
       return indent + 3;
    case OPCODE_ENDSUB:
       _mesa_printf("ENDSUB;\n");
       print_comment(inst);
       break;
    case OPCODE_END:
       _mesa_printf("END");
       print_comment(inst);
       break;
    case OPCODE_NOP:
       _mesa_printf("NOP");
       print_comment(inst);
       break;
    /* XXX may need other special-case instructions */
    default:
       /* typical alu instruction */
       _mesa_print_alu_instruction(inst,
 				  _mesa_opcode_string(inst->Opcode),
 				  _mesa_num_inst_src_regs(inst->Opcode));
       break;
    }
    return indent;
 }


 /**
  * Print a vertx/fragment program to stdout.
  * XXX this function could be greatly improved.
  */
 void
 _mesa_print_program(const struct gl_program *prog)
 {
    GLuint i, indent = 0;
    for (i = 0; i < prog->NumInstructions; i++) {
       _mesa_printf("%3d: ", i);
       indent = _mesa_print_instruction(prog->Instructions + i, indent);
    }
 }


 /**
  * Print all of a program's parameters.
  */
 void
 _mesa_print_program_parameters(GLcontext *ctx, const struct gl_program *prog)
 {
    _mesa_printf("InputsRead: 0x%x\n", prog->InputsRead);
    _mesa_printf("OutputsWritten: 0x%x\n", prog->OutputsWritten);
    _mesa_printf("NumInstructions=%d\n", prog->NumInstructions);
    _mesa_printf("NumTemporaries=%d\n", prog->NumTemporaries);
    _mesa_printf("NumParameters=%d\n", prog->NumParameters);
    _mesa_printf("NumAttributes=%d\n", prog->NumAttributes);
    _mesa_printf("NumAddressRegs=%d\n", prog->NumAddressRegs);

    _mesa_load_state_parameters(ctx, prog->Parameters);

 #if 0
    _mesa_printf("Local Params:\n");
    for (i = 0; i < MAX_PROGRAM_LOCAL_PARAMS; i++){
       const GLfloat *p = prog->LocalParams[i];
       _mesa_printf("%2d: %f, %f, %f, %f\n", i, p[0], p[1], p[2], p[3]);
    }
 #endif
    _mesa_print_parameter_list(prog->Parameters);
 }


 void
 _mesa_print_parameter_list(const struct gl_program_parameter_list *list)
 {
    GLuint i;
    _mesa_printf("param list %p\n", (void *) list);
    for (i = 0; i < list->NumParameters; i++){
       struct gl_program_parameter *param = list->Parameters + i;
       const GLfloat *v = list->ParameterValues[i];
       _mesa_printf("param[%d] sz=%d %s %s = {%.3f, %.3f, %.3f, %.3f};\n",
                    i, param->Size,
                    program_file_string(list->Parameters[i].Type),
                    param->Name, v[0], v[1], v[2], v[3]);
    }
 }
	/*
	* Mesa 3-D graphics library
	* Version: 6.5.3
	*
	* Copyright (C) 1999-2007 Brian Paul 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
	* BRIAN PAUL 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 prog_print.c
	* Print vertex/fragment programs - for debugging.
	* \author Brian Paul
	*/

	#include "glheader.h"
	#include "context.h"
	#include "imports.h"
	#include "prog_instruction.h"
	#include "prog_parameter.h"
	#include "prog_print.h"
	#include "prog_statevars.h"


	/**
	* Return string name for given program/register file.
	*/
	static const char *
	program_file_string(enum register_file f)
	{
	switch (f) {
	case PROGRAM_TEMPORARY:
	return "TEMP";
	case PROGRAM_LOCAL_PARAM:
	return "LOCAL";
	case PROGRAM_ENV_PARAM:
	return "ENV";
	case PROGRAM_STATE_VAR:
	return "STATE";
	case PROGRAM_INPUT:
	return "INPUT";
	case PROGRAM_OUTPUT:
	return "OUTPUT";
	case PROGRAM_NAMED_PARAM:
	return "NAMED";
	case PROGRAM_CONSTANT:
	return "CONST";
	case PROGRAM_UNIFORM:
	return "UNIFORM";
	case PROGRAM_VARYING:
	return "VARYING";
	case PROGRAM_WRITE_ONLY:
	return "WRITE_ONLY";
	case PROGRAM_ADDRESS:
	return "ADDR";
	case PROGRAM_SAMPLER:
	return "SAMPLER";
	default:
	return "Unknown program file!";
	}
	}


	/**
	* Return a string representation of the given swizzle word.
	* If extended is true, use extended (comma-separated) format.
	* \param swizzle the swizzle field
	* \param negateBase 4-bit negation vector
	* \param extended if true, also allow 0, 1 values
	*/
	static const char *
	swizzle_string(GLuint swizzle, GLuint negateBase, GLboolean extended)
	{
	static const char swz[] = "xyzw01?!";
	static char s[20];
	GLuint i = 0;

	if (!extended && swizzle == SWIZZLE_NOOP && negateBase == 0)
	return ""; /* no swizzle/negation */

	if (!extended)
	s[i++] = '.';

	if (negateBase & 0x1)
	s[i++] = '-';
	s[i++] = swz[GET_SWZ(swizzle, 0)];

	if (extended) {
	s[i++] = ',';
	}

	if (negateBase & 0x2)
	s[i++] = '-';
	s[i++] = swz[GET_SWZ(swizzle, 1)];

	if (extended) {
	s[i++] = ',';
	}

	if (negateBase & 0x4)
	s[i++] = '-';
	s[i++] = swz[GET_SWZ(swizzle, 2)];

	if (extended) {
	s[i++] = ',';
	}

	if (negateBase & 0x8)
	s[i++] = '-';
	s[i++] = swz[GET_SWZ(swizzle, 3)];

	s[i] = 0;
	return s;
	}


	static const char *
	writemask_string(GLuint writeMask)
	{
	static char s[10];
	GLuint i = 0;

	if (writeMask == WRITEMASK_XYZW)
	return "";

	s[i++] = '.';
	if (writeMask & WRITEMASK_X)
	s[i++] = 'x';
	if (writeMask & WRITEMASK_Y)
	s[i++] = 'y';
	if (writeMask & WRITEMASK_Z)
	s[i++] = 'z';
	if (writeMask & WRITEMASK_W)
	s[i++] = 'w';

	s[i] = 0;
	return s;
	}


	static const char *
	condcode_string(GLuint condcode)
	{
	switch (condcode) {
	case COND_GT: return "GT";
	case COND_EQ: return "EQ";
	case COND_LT: return "LT";
	case COND_UN: return "UN";
	case COND_GE: return "GE";
	case COND_LE: return "LE";
	case COND_NE: return "NE";
	case COND_TR: return "TR";
	case COND_FL: return "FL";
	default: return "cond???";
	}
	}


	static void
	print_dst_reg(const struct prog_dst_register *dstReg)
	{
	_mesa_printf(" %s[%d]%s",
	program_file_string((enum register_file) dstReg->File),
	dstReg->Index,
	writemask_string(dstReg->WriteMask));
	}

	static void
	print_src_reg(const struct prog_src_register *srcReg)
	{
	_mesa_printf("%s[%d]%s",
	program_file_string((enum register_file) srcReg->File),
	srcReg->Index,
	swizzle_string(srcReg->Swizzle,
	srcReg->NegateBase, GL_FALSE));
	}

	static void
	print_comment(const struct prog_instruction *inst)
	{
	if (inst->Comment)
	_mesa_printf("; # %s\n", inst->Comment);
	else
	_mesa_printf(";\n");
	}


	void
	_mesa_print_alu_instruction(const struct prog_instruction *inst,
	const char *opcode_string,
	GLuint numRegs)
	{
	GLuint j;

	_mesa_printf("%s", opcode_string);
	if (inst->CondUpdate)
	_mesa_printf(".C");

	/* frag prog only */
	if (inst->SaturateMode == SATURATE_ZERO_ONE)
	_mesa_printf("_SAT");

	if (inst->DstReg.File != PROGRAM_UNDEFINED) {
	print_dst_reg(&inst->DstReg);
	}
	else {
	_mesa_printf(" ???");
	}

	if (numRegs > 0)
	_mesa_printf(", ");

	for (j = 0; j < numRegs; j++) {
	print_src_reg(inst->SrcReg + j);
	if (j + 1 < numRegs)
	_mesa_printf(", ");
	}

	print_comment(inst);
	}


	/**
	* Print a single vertex/fragment program instruction.
	*/
	GLint
	_mesa_print_instruction(const struct prog_instruction *inst, GLint indent)
	{
	GLuint i;

	if (inst->Opcode == OPCODE_ELSE \|\|
	inst->Opcode == OPCODE_ENDIF \|\|
	inst->Opcode == OPCODE_ENDLOOP \|\|
	inst->Opcode == OPCODE_ENDSUB) {
	indent -= 3;
	}
	assert(indent >= 0);
	for (i = 0; i < indent; i++) {
	_mesa_printf(" ");
	}

	switch (inst->Opcode) {
	case OPCODE_PRINT:
	_mesa_printf("PRINT '%s'", inst->Data);
	if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) {
	_mesa_printf(", ");
	_mesa_printf("%s[%d]%s",
	program_file_string((enum register_file) inst->SrcReg[0].File),
	inst->SrcReg[0].Index,
	swizzle_string(inst->SrcReg[0].Swizzle,
	inst->SrcReg[0].NegateBase, GL_FALSE));
	}
	if (inst->Comment)
	_mesa_printf(" # %s", inst->Comment);
	print_comment(inst);
	break;
	case OPCODE_SWZ:
	_mesa_printf("SWZ");
	if (inst->SaturateMode == SATURATE_ZERO_ONE)
	_mesa_printf("_SAT");
	print_dst_reg(&inst->DstReg);
	_mesa_printf("%s[%d], %s",
	program_file_string((enum register_file) inst->SrcReg[0].File),
	inst->SrcReg[0].Index,
	swizzle_string(inst->SrcReg[0].Swizzle,
	inst->SrcReg[0].NegateBase, GL_TRUE));
	print_comment(inst);
	break;
	case OPCODE_TEX:
	case OPCODE_TXP:
	case OPCODE_TXB:
	_mesa_printf("%s", _mesa_opcode_string(inst->Opcode));
	if (inst->SaturateMode == SATURATE_ZERO_ONE)
	_mesa_printf("_SAT");
	print_dst_reg(&inst->DstReg);
	_mesa_printf(", ");
	print_src_reg(&inst->SrcReg[0]);
	_mesa_printf(", texture[%d], ", inst->TexSrcUnit);
	switch (inst->TexSrcTarget) {
	case TEXTURE_1D_INDEX: _mesa_printf("1D"); break;
	case TEXTURE_2D_INDEX: _mesa_printf("2D"); break;
	case TEXTURE_3D_INDEX: _mesa_printf("3D"); break;
	case TEXTURE_CUBE_INDEX: _mesa_printf("CUBE"); break;
	case TEXTURE_RECT_INDEX: _mesa_printf("RECT"); break;
	default:
	;
	}
	print_comment(inst);
	break;
	case OPCODE_ARL:
	_mesa_printf("ARL addr.x, ");
	print_src_reg(&inst->SrcReg[0]);
	print_comment(inst);
	break;
	case OPCODE_BRA:
	_mesa_printf("BRA %u (%s%s)",
	inst->BranchTarget,
	condcode_string(inst->DstReg.CondMask),
	swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
	print_comment(inst);
	break;
	case OPCODE_CAL:
	_mesa_printf("CAL %u", inst->BranchTarget);
	print_comment(inst);
	break;
	case OPCODE_IF:
	_mesa_printf("IF (%s%s)",
	condcode_string(inst->DstReg.CondMask),
	swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
	print_comment(inst);
	return indent + 3;
	case OPCODE_ELSE:
	_mesa_printf("ELSE\n");
	return indent + 3;
	case OPCODE_ENDIF:
	_mesa_printf("ENDIF\n");
	break;
	case OPCODE_BGNLOOP:
	_mesa_printf("BGNLOOP\n");
	return indent + 3;
	case OPCODE_ENDLOOP:
	_mesa_printf("ENDLOOP (goto %d)\n", inst->BranchTarget);
	break;
	case OPCODE_BRK:
	/* XXX just like BRA */
	_mesa_printf("BRK %u (%s%s)",
	inst->BranchTarget,
	condcode_string(inst->DstReg.CondMask),
	swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE));
	print_comment(inst);
	break;
	case OPCODE_BGNSUB:
	_mesa_printf("SUB;\n");
	print_comment(inst);
	return indent + 3;
	case OPCODE_ENDSUB:
	_mesa_printf("ENDSUB;\n");
	print_comment(inst);
	break;
	case OPCODE_END:
	_mesa_printf("END");
	print_comment(inst);
	break;
	case OPCODE_NOP:
	_mesa_printf("NOP");
	print_comment(inst);
	break;
	/* XXX may need other special-case instructions */
	default:
	/* typical alu instruction */
	_mesa_print_alu_instruction(inst,
	_mesa_opcode_string(inst->Opcode),
	_mesa_num_inst_src_regs(inst->Opcode));
	break;
	}
	return indent;
	}


	/**
	* Print a vertx/fragment program to stdout.
	* XXX this function could be greatly improved.
	*/
	void
	_mesa_print_program(const struct gl_program *prog)
	{
	GLuint i, indent = 0;
	for (i = 0; i < prog->NumInstructions; i++) {
	_mesa_printf("%3d: ", i);
	indent = _mesa_print_instruction(prog->Instructions + i, indent);
	}
	}


	/**
	* Print all of a program's parameters.
	*/
	void
	_mesa_print_program_parameters(GLcontext ctx, const struct gl_program prog)
	{
	_mesa_printf("InputsRead: 0x%x\n", prog->InputsRead);
	_mesa_printf("OutputsWritten: 0x%x\n", prog->OutputsWritten);
	_mesa_printf("NumInstructions=%d\n", prog->NumInstructions);
	_mesa_printf("NumTemporaries=%d\n", prog->NumTemporaries);
	_mesa_printf("NumParameters=%d\n", prog->NumParameters);
	_mesa_printf("NumAttributes=%d\n", prog->NumAttributes);
	_mesa_printf("NumAddressRegs=%d\n", prog->NumAddressRegs);

	_mesa_load_state_parameters(ctx, prog->Parameters);

	#if 0
	_mesa_printf("Local Params:\n");
	for (i = 0; i < MAX_PROGRAM_LOCAL_PARAMS; i++){
	const GLfloat *p = prog->LocalParams[i];
	_mesa_printf("%2d: %f, %f, %f, %f\n", i, p[0], p[1], p[2], p[3]);
	}
	#endif
	_mesa_print_parameter_list(prog->Parameters);
	}


	void
	_mesa_print_parameter_list(const struct gl_program_parameter_list *list)
	{
	GLuint i;
	_mesa_printf("param list %p\n", (void *) list);
	for (i = 0; i < list->NumParameters; i++){
	struct gl_program_parameter *param = list->Parameters + i;
	const GLfloat *v = list->ParameterValues[i];
	_mesa_printf("param[%d] sz=%d %s %s = {%.3f, %.3f, %.3f, %.3f};\n",
	i, param->Size,
	program_file_string(list->Parameters[i].Type),
	param->Name, v[0], v[1], v[2], v[3]);
	}
	}