Merge remote-tracking branch 'origin/released'

Conflicts:
	X11/extensions/randr.h
	mesalib/src/glsl/ast_function.cpp
	mesalib/src/glsl/ast_to_hir.cpp
	mesalib/src/glsl/glsl_parser_extras.h
	mesalib/src/glsl/link_functions.cpp
	mesalib/src/glsl/linker.cpp
	mesalib/src/mesa/state_tracker/st_program.c

11 files changed, 382 insertions, 378 deletions

diff --git a/mesalib/src/glsl/ast.h b/mesalib/src/glsl/ast.h
index 6963b83af..850fb2971 100644
--- a/mesalib/src/glsl/ast.h
+++ b/mesalib/src/glsl/ast.h
@@ -734,7 +734,6 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr,
 				 struct _mesa_glsl_parse_state *state);
 
 void
-emit_function(_mesa_glsl_parse_state *state, exec_list *instructions,
-	      ir_function *f);
+emit_function(_mesa_glsl_parse_state *state, ir_function *f);
 
 #endif /* AST_H */
diff --git a/mesalib/src/glsl/ast_function.cpp b/mesalib/src/glsl/ast_function.cpp
index 463db9499..adb88706f 100644
--- a/mesalib/src/glsl/ast_function.cpp
+++ b/mesalib/src/glsl/ast_function.cpp
@@ -125,7 +125,7 @@ match_function_by_name(exec_list *instructions, const char *name,
 	    if (f == NULL) {

 	       f = new(ctx) ir_function(name);

 	       state->symbols->add_global_function(f);

-	       emit_function(state, instructions, f);

+	       emit_function(state, f);

 	    }

 

 	    f->add_signature(sig->clone_prototype(f, NULL));

@@ -199,6 +199,20 @@ match_function_by_name(exec_list *instructions, const char *name,
        */

       ir_call *call = new(ctx) ir_call(sig, actual_parameters);

       if (!sig->return_type->is_void()) {

+         /* If the function call is a constant expression, don't

+          * generate the instructions to call it; just generate an

+          * ir_constant representing the constant value.

+          *

+          * Function calls can only be constant expressions starting

+          * in GLSL 1.20.

+          */

+         if (state->language_version >= 120) {

+            ir_constant *const_val = call->constant_expression_value();

+            if (const_val) {

+               return const_val;

+            }

+         }

+

 	 ir_variable *var;

 	 ir_dereference_variable *deref;

 

@@ -211,8 +225,6 @@ match_function_by_name(exec_list *instructions, const char *name,
 	 deref = new(ctx) ir_dereference_variable(var);

 	 ir_assignment *assign = new(ctx) ir_assignment(deref, call, NULL);

 	 instructions->push_tail(assign);

-	 if (state->language_version >= 120)

-	    var->constant_value = call->constant_expression_value();

 

 	 deref = new(ctx) ir_dereference_variable(var);

 	 return deref;

diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index e16f69018..d4f5065cc 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -66,6 +66,8 @@ _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
 

    state->current_function = NULL;

 

+   state->toplevel_ir = instructions;

+

    /* Section 4.2 of the GLSL 1.20 specification states:

     * "The built-in functions are scoped in a scope outside the global scope

     *  users declare global variables in.  That is, a shader's global scope,

@@ -85,6 +87,8 @@ _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
       ast->hir(instructions, state);

 

    detect_recursion_unlinked(state, instructions);

+

+   state->toplevel_ir = NULL;

 }

 

 

@@ -1765,11 +1769,6 @@ process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size,
       ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);

       YYLTYPE loc = array_size->get_location();

 

-      /* FINISHME: Verify that the grammar forbids side-effects in array

-       * FINISHME: sizes.   i.e., 'vec4 [x = 12] data'

-       */

-      assert(dummy_instructions.is_empty());

-

       if (ir != NULL) {

 	 if (!ir->type->is_integer()) {

 	    _mesa_glsl_error(& loc, state, "array size must be integer type");

@@ -1786,6 +1785,14 @@ process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size,
 	    } else {

 	       assert(size->type == ir->type);

 	       length = size->value.u[0];

+

+               /* If the array size is const (and we've verified that

+                * it is) then no instructions should have been emitted

+                * when we converted it to HIR.  If they were emitted,

+                * then either the array size isn't const after all, or

+                * we are emitting unnecessary instructions.

+                */

+               assert(dummy_instructions.is_empty());

 	    }

 	 }

       }

@@ -2926,23 +2933,16 @@ ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
 

 

 void

-emit_function(_mesa_glsl_parse_state *state, exec_list *instructions,

-	      ir_function *f)

+emit_function(_mesa_glsl_parse_state *state, ir_function *f)

 {

-   /* Emit the new function header */

-   if (state->current_function == NULL) {

-      instructions->push_tail(f);

-   } else {

-      /* IR invariants disallow function declarations or definitions nested

-       * within other function definitions.  Insert the new ir_function

-       * block in the instruction sequence before the ir_function block

-       * containing the current ir_function_signature.

-       */

-      ir_function *const curr =

-	 const_cast<ir_function *>(state->current_function->function());

-

-      curr->insert_before(f);

-   }

+   /* IR invariants disallow function declarations or definitions

+    * nested within other function definitions.  But there is no

+    * requirement about the relative order of function declarations

+    * and definitions with respect to one another.  So simply insert

+    * the new ir_function block at the end of the toplevel instruction

+    * list.

+    */

+   state->toplevel_ir->push_tail(f);

 }

 

 

@@ -3069,7 +3069,7 @@ ast_function::hir(exec_list *instructions,
 	 return NULL;

       }

 

-      emit_function(state, instructions, f);

+      emit_function(state, f);

    }

 

    /* Verify the return type of main() */

diff --git a/mesalib/src/glsl/glsl_parser_extras.h b/mesalib/src/glsl/glsl_parser_extras.h
index 4f77e8ebc..428cd9e36 100644
--- a/mesalib/src/glsl/glsl_parser_extras.h
+++ b/mesalib/src/glsl/glsl_parser_extras.h
@@ -133,6 +133,12 @@ struct _mesa_glsl_parse_state {
     */

    class ir_function_signature *current_function;

 

+   /**

+    * During AST to IR conversion, pointer to the toplevel IR

+    * instruction list being generated.

+    */

+   exec_list *toplevel_ir;

+

    /** Have we found a return statement in this function? */

    bool found_return;

 

diff --git a/mesalib/src/glsl/ir_function.cpp b/mesalib/src/glsl/ir_function.cpp
index 2a4de5b0d..51d32b46f 100644
--- a/mesalib/src/glsl/ir_function.cpp
+++ b/mesalib/src/glsl/ir_function.cpp
@@ -27,7 +27,7 @@
 typedef enum {
    PARAMETER_LIST_NO_MATCH,
    PARAMETER_LIST_EXACT_MATCH,
-   PARAMETER_LIST_INEXACT_MATCH, /*< Match requires implicit conversion. */
+   PARAMETER_LIST_INEXACT_MATCH /*< Match requires implicit conversion. */
 } parameter_list_match_t;
 
 /**
diff --git a/mesalib/src/glsl/link_functions.cpp b/mesalib/src/glsl/link_functions.cpp
index b3a701858..68d5b287b 100644
--- a/mesalib/src/glsl/link_functions.cpp
+++ b/mesalib/src/glsl/link_functions.cpp
@@ -104,10 +104,12 @@ public:
       if (f == NULL) {

 	 f = new(linked) ir_function(name);

 

-	 /* Add the new function to the linked IR.

+	 /* Add the new function to the linked IR.  Put it at the end

+          * so that it comes after any global variable declarations

+          * that it refers to.

 	  */

 	 linked->symbols->add_function(f);

-	 linked->ir->push_head(f);

+	 linked->ir->push_tail(f);

       }

 

       ir_function_signature *linked_sig =

diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp
index cb4083b29..0d4d5d88b 100644
--- a/mesalib/src/glsl/linker.cpp
+++ b/mesalib/src/glsl/linker.cpp
@@ -922,6 +922,14 @@ link_intrastage_shaders(void *mem_ctx,
 

    free(linking_shaders);

 

+#ifdef DEBUG

+   /* At this point linked should contain all of the linked IR, so

+    * validate it to make sure nothing went wrong.

+    */

+   if (linked)

+      validate_ir_tree(linked->ir);

+#endif

+

    /* Make a pass over all variable declarations to ensure that arrays with

     * unspecified sizes have a size specified.  The size is inferred from the

     * max_array_access field.

diff --git a/mesalib/src/glsl/opt_dead_functions.cpp b/mesalib/src/glsl/opt_dead_functions.cpp
index 3c3eb8904..51c77e3b9 100644
--- a/mesalib/src/glsl/opt_dead_functions.cpp
+++ b/mesalib/src/glsl/opt_dead_functions.cpp
@@ -1,164 +1,155 @@
-/*

- * Copyright © 2010 Intel Corporation

- *

- * 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 (including the next

- * paragraph) 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 opt_dead_functions.cpp

- *

- * Eliminates unused functions from the linked program.

- */

-

-#include "ir.h"

-#include "ir_visitor.h"

-#include "ir_expression_flattening.h"

-#include "glsl_types.h"

-

-class signature_entry : public exec_node

-{

-public:

-   signature_entry(ir_function_signature *sig)

-   {

-      this->signature = sig;

-      this->used = false;

-   }

-

-   ir_function_signature *signature;

-   bool used;

-};

-

-class ir_dead_functions_visitor : public ir_hierarchical_visitor {

-public:

-   ir_dead_functions_visitor()

-   {

-      this->mem_ctx = ralloc_context(NULL);

-      this->seen_another_function_signature = false;

-   }

-

-   ~ir_dead_functions_visitor()

-   {

-      ralloc_free(this->mem_ctx);

-   }

-

-   virtual ir_visitor_status visit_enter(ir_function_signature *);

-   virtual ir_visitor_status visit_enter(ir_call *);

-

-   signature_entry *get_signature_entry(ir_function_signature *var);

-

-   bool (*predicate)(ir_instruction *ir);

-

-   bool seen_another_function_signature;

-

-   /* List of signature_entry */

-   exec_list signature_list;

-   void *mem_ctx;

-};

-

-

-signature_entry *

-ir_dead_functions_visitor::get_signature_entry(ir_function_signature *sig)

-{

-   foreach_iter(exec_list_iterator, iter, this->signature_list) {

-      signature_entry *entry = (signature_entry *)iter.get();

-      if (entry->signature == sig)

-	 return entry;

-   }

-

-   signature_entry *entry = new(mem_ctx) signature_entry(sig);

-   this->signature_list.push_tail(entry);

-   return entry;

-}

-

-

-ir_visitor_status

-ir_dead_functions_visitor::visit_enter(ir_function_signature *ir)

-{

-   signature_entry *entry = this->get_signature_entry(ir);

-

-   if (strcmp(ir->function_name(), "main") == 0) {

-      entry->used = true;

-   }

-

-   /* If this is the first signature to look at, no need to descend to see

-    * if it has calls to another function signature.

-    */

-   if (!this->seen_another_function_signature) {

-      this->seen_another_function_signature = true;

-      return visit_continue_with_parent;

-   }

-

-   return visit_continue;

-}

-

-

-ir_visitor_status

-ir_dead_functions_visitor::visit_enter(ir_call *ir)

-{

-   signature_entry *entry = this->get_signature_entry(ir->get_callee());

-

-   entry->used = true;

-

-   return visit_continue;

-}

-

-bool

-do_dead_functions(exec_list *instructions)

-{

-   ir_dead_functions_visitor v;

-   bool progress = false;

-

-   visit_list_elements(&v, instructions);

-

-   /* Now that we've figured out which function signatures are used, remove

-    * the unused ones, and remove function definitions that have no more

-    * signatures.

-    */

-    foreach_iter(exec_list_iterator, iter, v.signature_list) {

-      signature_entry *entry = (signature_entry *)iter.get();

-

-      if (!entry->used) {

-	 entry->signature->remove();

-	 delete entry->signature;

-	 progress = true;

-      }

-      delete(entry);

-   }

-

-   /* We don't just do this above when we nuked a signature because of

-    * const pointers.

-    */

-   foreach_iter(exec_list_iterator, iter, *instructions) {

-      ir_instruction *ir = (ir_instruction *)iter.get();

-      ir_function *func = ir->as_function();

-

-      if (func && func->signatures.is_empty()) {

-	 /* At this point (post-linking), the symbol table is no

-	  * longer in use, so not removing the function from the

-	  * symbol table should be OK.

-	  */

-	 func->remove();

-	 delete func;

-	 progress = true;

-      }

-   }

-

-   return progress;

-}

+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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 opt_dead_functions.cpp
+ *
+ * Eliminates unused functions from the linked program.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_expression_flattening.h"
+#include "glsl_types.h"
+
+class signature_entry : public exec_node
+{
+public:
+   signature_entry(ir_function_signature *sig)
+   {
+      this->signature = sig;
+      this->used = false;
+   }
+
+   ir_function_signature *signature;
+   bool used;
+};
+
+class ir_dead_functions_visitor : public ir_hierarchical_visitor {
+public:
+   ir_dead_functions_visitor()
+   {
+      this->mem_ctx = ralloc_context(NULL);
+   }
+
+   ~ir_dead_functions_visitor()
+   {
+      ralloc_free(this->mem_ctx);
+   }
+
+   virtual ir_visitor_status visit_enter(ir_function_signature *);
+   virtual ir_visitor_status visit_enter(ir_call *);
+
+   signature_entry *get_signature_entry(ir_function_signature *var);
+
+   bool (*predicate)(ir_instruction *ir);
+
+   /* List of signature_entry */
+   exec_list signature_list;
+   void *mem_ctx;
+};
+
+
+signature_entry *
+ir_dead_functions_visitor::get_signature_entry(ir_function_signature *sig)
+{
+   foreach_iter(exec_list_iterator, iter, this->signature_list) {
+      signature_entry *entry = (signature_entry *)iter.get();
+      if (entry->signature == sig)
+	 return entry;
+   }
+
+   signature_entry *entry = new(mem_ctx) signature_entry(sig);
+   this->signature_list.push_tail(entry);
+   return entry;
+}
+
+
+ir_visitor_status
+ir_dead_functions_visitor::visit_enter(ir_function_signature *ir)
+{
+   signature_entry *entry = this->get_signature_entry(ir);
+
+   if (strcmp(ir->function_name(), "main") == 0) {
+      entry->used = true;
+   }
+
+
+
+   return visit_continue;
+}
+
+
+ir_visitor_status
+ir_dead_functions_visitor::visit_enter(ir_call *ir)
+{
+   signature_entry *entry = this->get_signature_entry(ir->get_callee());
+
+   entry->used = true;
+
+   return visit_continue;
+}
+
+bool
+do_dead_functions(exec_list *instructions)
+{
+   ir_dead_functions_visitor v;
+   bool progress = false;
+
+   visit_list_elements(&v, instructions);
+
+   /* Now that we've figured out which function signatures are used, remove
+    * the unused ones, and remove function definitions that have no more
+    * signatures.
+    */
+    foreach_iter(exec_list_iterator, iter, v.signature_list) {
+      signature_entry *entry = (signature_entry *)iter.get();
+
+      if (!entry->used) {
+	 entry->signature->remove();
+	 delete entry->signature;
+	 progress = true;
+      }
+      delete(entry);
+   }
+
+   /* We don't just do this above when we nuked a signature because of
+    * const pointers.
+    */
+   foreach_iter(exec_list_iterator, iter, *instructions) {
+      ir_instruction *ir = (ir_instruction *)iter.get();
+      ir_function *func = ir->as_function();
+
+      if (func && func->signatures.is_empty()) {
+	 /* At this point (post-linking), the symbol table is no
+	  * longer in use, so not removing the function from the
+	  * symbol table should be OK.
+	  */
+	 func->remove();
+	 delete func;
+	 progress = true;
+      }
+   }
+
+   return progress;
+}
diff --git a/mesalib/src/mesa/program/prog_parameter.h b/mesalib/src/mesa/program/prog_parameter.h
index f858cf0fa..1a5ed3439 100644
--- a/mesalib/src/mesa/program/prog_parameter.h
+++ b/mesalib/src/mesa/program/prog_parameter.h
@@ -46,16 +46,19 @@
 #define PROG_PARAM_BIT_CYL_WRAP  0x10  /**< XXX gallium debug */
 /*@}*/
 
+
 /**
  * Actual data for constant values of parameters.
  */
-typedef union gl_constant_value {
-	GLfloat f;
-	GLboolean b;
-	GLint i;
-	GLuint u;
+typedef union gl_constant_value
+{
+   GLfloat f;
+   GLboolean b;
+   GLint i;
+   GLuint u;
 } gl_constant_value;
 
+
 /**
  * Program parameter.
  * Used by shaders/programs for uniforms, constants, varying vars, etc.
diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c
index f879c42c1..090e9a4f6 100644
--- a/mesalib/src/mesa/state_tracker/st_program.c
+++ b/mesalib/src/mesa/state_tracker/st_program.c
@@ -416,151 +416,6 @@ st_get_vp_variant(struct st_context *st,
    return vpv;

 }

 

-/**

- * Translate Mesa fragment shader attributes to TGSI attributes.

- * \return GL_TRUE if color output should be written to all render targets, 

- *         GL_FALSE if not

- */

-GLboolean

-st_prepare_fragment_program(struct gl_context *ctx,

-                            struct st_fragment_program *stfp)

-{

-   GLuint attr;

-   const GLbitfield inputsRead = stfp->Base.Base.InputsRead;

-   GLboolean write_all = GL_FALSE;

-

-   /*

-    * Convert Mesa program inputs to TGSI input register semantics.

-    */

-   for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {

-      if (inputsRead & (1 << attr)) {

-         const GLuint slot = stfp->num_inputs++;

-

-         stfp->input_to_index[attr] = slot;

-

-         switch (attr) {

-         case FRAG_ATTRIB_WPOS:

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

-            stfp->input_semantic_index[slot] = 0;

-            stfp->interp_mode[slot] = TGSI_INTERPOLATE_LINEAR;

-            break;

-         case FRAG_ATTRIB_COL0:

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

-            stfp->input_semantic_index[slot] = 0;

-            stfp->interp_mode[slot] = TGSI_INTERPOLATE_LINEAR;

-            break;

-         case FRAG_ATTRIB_COL1:

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

-            stfp->input_semantic_index[slot] = 1;

-            stfp->interp_mode[slot] = TGSI_INTERPOLATE_LINEAR;

-            break;

-         case FRAG_ATTRIB_FOGC:

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;

-            stfp->input_semantic_index[slot] = 0;

-            stfp->interp_mode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

-            break;

-         case FRAG_ATTRIB_FACE:

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_FACE;

-            stfp->input_semantic_index[slot] = 0;

-            stfp->interp_mode[slot] = TGSI_INTERPOLATE_CONSTANT;

-            break;

-            /* In most cases, there is nothing special about these

-             * inputs, so adopt a convention to use the generic

-             * semantic name and the mesa FRAG_ATTRIB_ number as the

-             * index. 

-             * 

-             * All that is required is that the vertex shader labels

-             * its own outputs similarly, and that the vertex shader

-             * generates at least every output required by the

-             * fragment shader plus fixed-function hardware (such as

-             * BFC).

-             * 

-             * There is no requirement that semantic indexes start at

-             * zero or be restricted to a particular range -- nobody

-             * should be building tables based on semantic index.

-             */

-         case FRAG_ATTRIB_PNTC:

-         case FRAG_ATTRIB_TEX0:

-         case FRAG_ATTRIB_TEX1:

-         case FRAG_ATTRIB_TEX2:

-         case FRAG_ATTRIB_TEX3:

-         case FRAG_ATTRIB_TEX4:

-         case FRAG_ATTRIB_TEX5:

-         case FRAG_ATTRIB_TEX6:

-         case FRAG_ATTRIB_TEX7:

-         case FRAG_ATTRIB_VAR0:

-         default:

-            /* Actually, let's try and zero-base this just for

-             * readability of the generated TGSI.

-             */

-            assert(attr >= FRAG_ATTRIB_TEX0);

-            stfp->input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);

-            stfp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

-            if (attr == FRAG_ATTRIB_PNTC)

-               stfp->interp_mode[slot] = TGSI_INTERPOLATE_LINEAR;

-            else

-               stfp->interp_mode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

-            break;

-         }

-      }

-      else {

-         stfp->input_to_index[attr] = -1;

-      }

-   }

-

-   /*

-    * Semantics and mapping for outputs

-    */

-   {

-      uint numColors = 0;

-      GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;

-

-      /* if z is written, emit that first */

-      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {

-         stfp->output_semantic_name[stfp->num_outputs] = TGSI_SEMANTIC_POSITION;

-         stfp->output_semantic_index[stfp->num_outputs] = 0;

-         stfp->result_to_output[FRAG_RESULT_DEPTH] = stfp->num_outputs;

-         stfp->num_outputs++;

-         outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);

-      }

-

-      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {

-         stfp->output_semantic_name[stfp->num_outputs] = TGSI_SEMANTIC_STENCIL;

-         stfp->output_semantic_index[stfp->num_outputs] = 0;

-         stfp->result_to_output[FRAG_RESULT_STENCIL] = stfp->num_outputs;

-         stfp->num_outputs++;

-         outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);

-      }

-

-      /* handle remaning outputs (color) */

-      for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {

-         if (outputsWritten & BITFIELD64_BIT(attr)) {

-            switch (attr) {

-            case FRAG_RESULT_DEPTH:

-            case FRAG_RESULT_STENCIL:

-               /* handled above */

-               assert(0);

-               break;

-            case FRAG_RESULT_COLOR:

-               write_all = GL_TRUE; /* fallthrough */

-            default:

-               assert(attr == FRAG_RESULT_COLOR ||

-                      (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));

-               stfp->output_semantic_name[stfp->num_outputs] = TGSI_SEMANTIC_COLOR;

-               stfp->output_semantic_index[stfp->num_outputs] = numColors;

-               stfp->result_to_output[attr] = stfp->num_outputs;

-               numColors++;

-               break;

-            }

-

-            stfp->num_outputs++;

-         }

-      }

-   }

-   

-   return write_all;

-}

-

 

 /**

  * Translate a Mesa fragment shader into a TGSI shader using extra info in

@@ -613,12 +468,155 @@ st_translate_fragment_program(struct st_context *st,
 

    if (!stfp->tgsi.tokens) {

       /* need to translate Mesa instructions to TGSI now */

+      GLuint outputMapping[FRAG_RESULT_MAX];

+      GLuint inputMapping[FRAG_ATTRIB_MAX];

+      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */

+      GLuint attr;

+      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;

       struct ureg_program *ureg;

-      GLboolean write_all = st_prepare_fragment_program(st->ctx, stfp);

+

+      GLboolean write_all = GL_FALSE;

+

+      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];

+      ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];

+      uint fs_num_inputs = 0;

+

+      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];

+      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];

+      uint fs_num_outputs = 0;

       

       if (!stfp->glsl_to_tgsi)

          _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);

 

+      /*

+       * Convert Mesa program inputs to TGSI input register semantics.

+       */

+      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {

+         if (inputsRead & (1 << attr)) {

+            const GLuint slot = fs_num_inputs++;

+

+            inputMapping[attr] = slot;

+

+            switch (attr) {

+            case FRAG_ATTRIB_WPOS:

+               input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_COL0:

+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_COL1:

+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+               input_semantic_index[slot] = 1;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_FOGC:

+               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

+               break;

+            case FRAG_ATTRIB_FACE:

+               input_semantic_name[slot] = TGSI_SEMANTIC_FACE;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;

+               break;

+               /* In most cases, there is nothing special about these

+                * inputs, so adopt a convention to use the generic

+                * semantic name and the mesa FRAG_ATTRIB_ number as the

+                * index. 

+                * 

+                * All that is required is that the vertex shader labels

+                * its own outputs similarly, and that the vertex shader

+                * generates at least every output required by the

+                * fragment shader plus fixed-function hardware (such as

+                * BFC).

+                * 

+                * There is no requirement that semantic indexes start at

+                * zero or be restricted to a particular range -- nobody

+                * should be building tables based on semantic index.

+                */

+            case FRAG_ATTRIB_PNTC:

+            case FRAG_ATTRIB_TEX0:

+            case FRAG_ATTRIB_TEX1:

+            case FRAG_ATTRIB_TEX2:

+            case FRAG_ATTRIB_TEX3:

+            case FRAG_ATTRIB_TEX4:

+            case FRAG_ATTRIB_TEX5:

+            case FRAG_ATTRIB_TEX6:

+            case FRAG_ATTRIB_TEX7:

+            case FRAG_ATTRIB_VAR0:

+            default:

+               /* Actually, let's try and zero-base this just for

+                * readability of the generated TGSI.

+                */

+               assert(attr >= FRAG_ATTRIB_TEX0);

+               input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);

+               input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+               if (attr == FRAG_ATTRIB_PNTC)

+                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               else

+                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

+               break;

+            }

+         }

+         else {

+            inputMapping[attr] = -1;

+         }

+      }

+

+      /*

+       * Semantics and mapping for outputs

+       */

+      {

+         uint numColors = 0;

+         GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;

+

+         /* if z is written, emit that first */

+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {

+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;

+            fs_output_semantic_index[fs_num_outputs] = 0;

+            outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;

+            fs_num_outputs++;

+            outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);

+         }

+

+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {

+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;

+            fs_output_semantic_index[fs_num_outputs] = 0;

+            outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;

+            fs_num_outputs++;

+            outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);

+         }

+

+         /* handle remaning outputs (color) */

+         for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {

+            if (outputsWritten & BITFIELD64_BIT(attr)) {

+               switch (attr) {

+               case FRAG_RESULT_DEPTH:

+               case FRAG_RESULT_STENCIL:

+                  /* handled above */

+                  assert(0);

+                  break;

+               case FRAG_RESULT_COLOR:

+                  write_all = GL_TRUE; /* fallthrough */

+               default:

+                  assert(attr == FRAG_RESULT_COLOR ||

+                         (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));

+                  fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;

+                  fs_output_semantic_index[fs_num_outputs] = numColors;

+                  outputMapping[attr] = fs_num_outputs;

+                  numColors++;

+                  break;

+               }

+

+               fs_num_outputs++;

+            }

+         }

+      }

+

       ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );

       if (ureg == NULL)

          return NULL;

@@ -638,32 +636,32 @@ st_translate_fragment_program(struct st_context *st,
                               stfp->glsl_to_tgsi,

                               &stfp->Base.Base,

                               /* inputs */

-                              stfp->num_inputs,

-                              stfp->input_to_index,

-                              stfp->input_semantic_name,

-                              stfp->input_semantic_index,

-                              stfp->interp_mode,

+                              fs_num_inputs,

+                              inputMapping,

+                              input_semantic_name,

+                              input_semantic_index,

+                              interpMode,

                               /* outputs */

-                              stfp->num_outputs,

-                              stfp->result_to_output,

-                              stfp->output_semantic_name,

-                              stfp->output_semantic_index, FALSE );

+                              fs_num_outputs,

+                              outputMapping,

+                              fs_output_semantic_name,

+                              fs_output_semantic_index, FALSE );

       else

          st_translate_mesa_program(st->ctx,

                                    TGSI_PROCESSOR_FRAGMENT,

                                    ureg,

                                    &stfp->Base.Base,

                                    /* inputs */

-                                   stfp->num_inputs,

-                                   stfp->input_to_index,

-                                   stfp->input_semantic_name,

-                                   stfp->input_semantic_index,

-                                   stfp->interp_mode,

+                                   fs_num_inputs,

+                                   inputMapping,

+                                   input_semantic_name,

+                                   input_semantic_index,

+                                   interpMode,

                                    /* outputs */

-                                   stfp->num_outputs,

-                                   stfp->result_to_output,

-                                   stfp->output_semantic_name,

-                                   stfp->output_semantic_index, FALSE );

+                                   fs_num_outputs,

+                                   outputMapping,

+                                   fs_output_semantic_name,

+                                   fs_output_semantic_index, FALSE );

 

       stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );

       ureg_destroy( ureg );

diff --git a/mesalib/src/mesa/state_tracker/st_program.h b/mesalib/src/mesa/state_tracker/st_program.h
index 67723de6d..699b6e8cc 100644
--- a/mesalib/src/mesa/state_tracker/st_program.h
+++ b/mesalib/src/mesa/state_tracker/st_program.h
@@ -85,21 +85,6 @@ struct st_fragment_program
 {
    struct gl_fragment_program Base;
    struct glsl_to_tgsi_visitor* glsl_to_tgsi;
-   
-   /** maps a Mesa FRAG_ATTRIB_x to a packed TGSI input index */
-   GLuint input_to_index[FRAG_ATTRIB_MAX];
-   /** maps a TGSI input index back to a Mesa FRAG_ATTRIB_x */
-   GLuint index_to_input[PIPE_MAX_SHADER_INPUTS];
-   ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
-   ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
-   GLuint num_inputs;
-   GLuint interp_mode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
-
-   /** Maps FRAG_RESULT_x to slot */
-   GLuint result_to_output[FRAG_RESULT_MAX];
-   ubyte output_semantic_name[FRAG_RESULT_MAX];
-   ubyte output_semantic_index[FRAG_RESULT_MAX];
-   GLuint num_outputs;
 
    struct pipe_shader_state tgsi;