Split the program.[ch] files into several new files.

1 files changed, 464 insertions, 0 deletions

diff --git a/src/mesa/shader/prog_print.c b/src/mesa/shader/prog_print.c
new file mode 100644
index 00000000000..eded71bbae1
--- /dev/null
+++ b/src/mesa/shader/prog_print.c
@@ -0,0 +1,464 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5.3
+ *
+ * Copyright (C) 1999-2006  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 "macros.h"
+#include "program.h"
+#include "prog_instruction.h"
+#include "prog_parameter.h"
+#include "prog_print.h"
+#include "prog_statevars.h"
+
+
+
+/**
+ * Basic info about each instruction
+ */
+struct instruction_info
+{
+   gl_inst_opcode Opcode;
+   const char *Name;
+   GLuint NumSrcRegs;
+};
+
+/**
+ * Instruction info
+ * \note Opcode should equal array index!
+ */
+static const struct instruction_info InstInfo[MAX_OPCODE] = {
+   { OPCODE_NOP,    "NOP",   0 },
+   { OPCODE_ABS,    "ABS",   1 },
+   { OPCODE_ADD,    "ADD",   2 },
+   { OPCODE_ARA,    "ARA",   1 },
+   { OPCODE_ARL,    "ARL",   1 },
+   { OPCODE_ARL_NV, "ARL",   1 },
+   { OPCODE_ARR,    "ARL",   1 },
+   { OPCODE_BRA,    "BRA",   0 },
+   { OPCODE_CAL,    "CAL",   0 },
+   { OPCODE_CMP,    "CMP",   3 },
+   { OPCODE_COS,    "COS",   1 },
+   { OPCODE_DDX,    "DDX",   1 },
+   { OPCODE_DDY,    "DDY",   1 },
+   { OPCODE_DP3,    "DP3",   2 },
+   { OPCODE_DP4,    "DP4",   2 },
+   { OPCODE_DPH,    "DPH",   2 },
+   { OPCODE_DST,    "DST",   2 },
+   { OPCODE_END,    "END",   0 },
+   { OPCODE_EX2,    "EX2",   1 },
+   { OPCODE_EXP,    "EXP",   1 },
+   { OPCODE_FLR,    "FLR",   1 },
+   { OPCODE_FRC,    "FRC",   1 },
+   { OPCODE_KIL,    "KIL",   1 },
+   { OPCODE_KIL_NV, "KIL",   0 },
+   { OPCODE_LG2,    "LG2",   1 },
+   { OPCODE_LIT,    "LIT",   1 },
+   { OPCODE_LOG,    "LOG",   1 },
+   { OPCODE_LRP,    "LRP",   3 },
+   { OPCODE_MAD,    "MAD",   3 },
+   { OPCODE_MAX,    "MAX",   2 },
+   { OPCODE_MIN,    "MIN",   2 },
+   { OPCODE_MOV,    "MOV",   1 },
+   { OPCODE_MUL,    "MUL",   2 },
+   { OPCODE_PK2H,   "PK2H",  1 },
+   { OPCODE_PK2US,  "PK2US", 1 },
+   { OPCODE_PK4B,   "PK4B",  1 },
+   { OPCODE_PK4UB,  "PK4UB", 1 },
+   { OPCODE_POW,    "POW",   2 },
+   { OPCODE_POPA,   "POPA",  0 },
+   { OPCODE_PRINT,  "PRINT", 1 },
+   { OPCODE_PUSHA,  "PUSHA", 0 },
+   { OPCODE_RCC,    "RCC",   1 },
+   { OPCODE_RCP,    "RCP",   1 },
+   { OPCODE_RET,    "RET",   0 },
+   { OPCODE_RFL,    "RFL",   1 },
+   { OPCODE_RSQ,    "RSQ",   1 },
+   { OPCODE_SCS,    "SCS",   1 },
+   { OPCODE_SEQ,    "SEQ",   2 },
+   { OPCODE_SFL,    "SFL",   0 },
+   { OPCODE_SGE,    "SGE",   2 },
+   { OPCODE_SGT,    "SGT",   2 },
+   { OPCODE_SIN,    "SIN",   1 },
+   { OPCODE_SLE,    "SLE",   2 },
+   { OPCODE_SLT,    "SLT",   2 },
+   { OPCODE_SNE,    "SNE",   2 },
+   { OPCODE_SSG,    "SSG",   1 },
+   { OPCODE_STR,    "STR",   0 },
+   { OPCODE_SUB,    "SUB",   2 },
+   { OPCODE_SWZ,    "SWZ",   1 },
+   { OPCODE_TEX,    "TEX",   1 },
+   { OPCODE_TXB,    "TXB",   1 },
+   { OPCODE_TXD,    "TXD",   3 },
+   { OPCODE_TXL,    "TXL",   1 },
+   { OPCODE_TXP,    "TXP",   1 },
+   { OPCODE_TXP_NV, "TXP",   1 },
+   { OPCODE_UP2H,   "UP2H",  1 },
+   { OPCODE_UP2US,  "UP2US", 1 },
+   { OPCODE_UP4B,   "UP4B",  1 },
+   { OPCODE_UP4UB,  "UP4UB", 1 },
+   { OPCODE_X2D,    "X2D",   3 },
+   { OPCODE_XPD,    "XPD",   2 }
+};
+
+
+/**
+ * Return the number of src registers for the given instruction/opcode.
+ */
+GLuint
+_mesa_num_inst_src_regs(gl_inst_opcode opcode)
+{
+   ASSERT(opcode == InstInfo[opcode].Opcode);
+   ASSERT(OPCODE_XPD == InstInfo[OPCODE_XPD].Opcode);
+   return InstInfo[opcode].NumSrcRegs;
+}
+
+
+/**
+ * Return string name for given program opcode.
+ */
+const char *
+_mesa_opcode_string(gl_inst_opcode opcode)
+{
+   ASSERT(opcode < MAX_OPCODE);
+   return InstInfo[opcode].Name;
+}
+
+/**
+ * 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";
+   default:
+      return "Unknown program file!";
+   }
+}
+
+
+/**
+ * Return a string representation of the given swizzle word.
+ * If extended is true, use extended (comma-separated) format.
+ */
+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 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);
+
+   /* frag prog only */
+   if (inst->SaturateMode == SATURATE_ZERO_ONE)
+      _mesa_printf("_SAT");
+
+   if (inst->DstReg.File != PROGRAM_UNDEFINED) {
+      _mesa_printf(" %s[%d]%s",
+		   program_file_string((enum register_file) inst->DstReg.File),
+		   inst->DstReg.Index,
+		   writemask_string(inst->DstReg.WriteMask));
+   }
+   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(", ");
+   }
+
+   if (inst->Comment)
+      _mesa_printf("  # %s", inst->Comment);
+
+   print_comment(inst);
+}
+
+
+/**
+ * Print a single vertex/fragment program instruction.
+ */
+void
+_mesa_print_instruction(const struct prog_instruction *inst)
+{
+   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");
+      _mesa_printf(" ");
+      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", inst->BranchTarget);
+      print_comment(inst);
+      break;
+   case OPCODE_CAL:
+      _mesa_printf("CAL %u", inst->BranchTarget);
+      print_comment(inst);
+      break;
+   case OPCODE_END:
+      _mesa_printf("END");
+      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;
+   }
+}
+
+
+/**
+ * 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;
+   for (i = 0; i < prog->NumInstructions; i++) {
+      _mesa_printf("%3d: ", i);
+      _mesa_print_instruction(prog->Instructions + i);
+   }
+}
+
+
+/**
+ * Print all of a program's parameters.
+ */
+void
+_mesa_print_program_parameters(GLcontext *ctx, const struct gl_program *prog)
+{
+   GLint i;
+
+   _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	
+
+   for (i = 0; i < prog->Parameters->NumParameters; i++){
+      struct gl_program_parameter *param = prog->Parameters->Parameters + i;
+      const GLfloat *v = prog->Parameters->ParameterValues[i];
+      _mesa_printf("param[%d] %s %s = {%.3f, %.3f, %.3f, %.3f};\n",
+                   i,
+                   program_file_string(prog->Parameters->Parameters[i].Type),
+                   param->Name, v[0], v[1], v[2], v[3]);
+   }
+}