svn merge ^/branches/released .

15 files changed, 564 insertions, 529 deletions

diff --git a/mesalib/src/glsl/ast_expr.cpp b/mesalib/src/glsl/ast_expr.cpp
index c45d60757..974beb9f6 100644
--- a/mesalib/src/glsl/ast_expr.cpp
+++ b/mesalib/src/glsl/ast_expr.cpp
@@ -1,96 +1,98 @@
-/*

- * 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.

- */

-#include <cstdio>

-#include <cassert>

-#include "ast.h"

-

-const char *

-ast_expression::operator_string(enum ast_operators op)

-{

-   static const char *const operators[] = {

-      "=",

-      "+",

-      "-",

-      "+",

-      "-",

-      "*",

-      "/",

-      "%",

-      "<<",

-      ">>",

-      "<",

-      ">",

-      "<=",

-      ">=",

-      "==",

-      "!=",

-      "&",

-      "^",

-      "|",

-      "~",

-      "&&",

-      "^^",

-      "||",

-      "!",

-

-      "*=",

-      "/=",

-      "%=",

-      "+=",

-      "-=",

-      "<<=",

-      ">>=",

-      "&=",

-      "^=",

-      "|=",

-

-      "?:",

-

-      "++",

-      "--",

-      "++",

-      "--",

-      ".",

-   };

-

-   assert((unsigned int)op < sizeof(operators) / sizeof(operators[0]));

-

-   return operators[op];

-}

-

-

-ast_expression_bin::ast_expression_bin(int oper, ast_expression *ex0,

-				       ast_expression *ex1) :

-   ast_expression(oper, ex0, ex1, NULL)

-{

-   assert((oper >= ast_plus) && (oper <= ast_logic_not));

-}

-

-

-void

-ast_expression_bin::print(void) const

-{

-   subexpressions[0]->print();

-   printf("%s ", operator_string(oper));

-   subexpressions[1]->print();

-}

+/*
+ * 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.
+ */
+#include <cstdio>
+#include <cassert>
+#include "ast.h"
+
+using std::printf;
+
+const char *
+ast_expression::operator_string(enum ast_operators op)
+{
+   static const char *const operators[] = {
+      "=",
+      "+",
+      "-",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "<<",
+      ">>",
+      "<",
+      ">",
+      "<=",
+      ">=",
+      "==",
+      "!=",
+      "&",
+      "^",
+      "|",
+      "~",
+      "&&",
+      "^^",
+      "||",
+      "!",
+
+      "*=",
+      "/=",
+      "%=",
+      "+=",
+      "-=",
+      "<<=",
+      ">>=",
+      "&=",
+      "^=",
+      "|=",
+
+      "?:",
+
+      "++",
+      "--",
+      "++",
+      "--",
+      ".",
+   };
+
+   assert((unsigned int)op < sizeof(operators) / sizeof(operators[0]));
+
+   return operators[op];
+}
+
+
+ast_expression_bin::ast_expression_bin(int oper, ast_expression *ex0,
+				       ast_expression *ex1) :
+   ast_expression(oper, ex0, ex1, NULL)
+{
+   assert((oper >= ast_plus) && (oper <= ast_logic_not));
+}
+
+
+void
+ast_expression_bin::print(void) const
+{
+   subexpressions[0]->print();
+   printf("%s ", operator_string(oper));
+   subexpressions[1]->print();
+}
diff --git a/mesalib/src/glsl/ast_type.cpp b/mesalib/src/glsl/ast_type.cpp
index d14077473..5ddfeec87 100644
--- a/mesalib/src/glsl/ast_type.cpp
+++ b/mesalib/src/glsl/ast_type.cpp
@@ -27,6 +27,8 @@ extern "C" {
 #include "program/symbol_table.h"
 }
 
+using std::printf;
+
 void
 ast_type_specifier::print(void) const
 {
diff --git a/mesalib/src/glsl/hir_field_selection.cpp b/mesalib/src/glsl/hir_field_selection.cpp
index 3c33127b5..995f284fa 100644
--- a/mesalib/src/glsl/hir_field_selection.cpp
+++ b/mesalib/src/glsl/hir_field_selection.cpp
@@ -27,6 +27,8 @@
 #include "ast.h"
 #include "glsl_types.h"
 
+using std::strcmp;
+
 ir_rvalue *
 _mesa_ast_field_selection_to_hir(const ast_expression *expr,
 				 exec_list *instructions,
diff --git a/mesalib/src/glsl/ir_print_visitor.cpp b/mesalib/src/glsl/ir_print_visitor.cpp
index 82ccc722f..be76945a2 100644
--- a/mesalib/src/glsl/ir_print_visitor.cpp
+++ b/mesalib/src/glsl/ir_print_visitor.cpp
@@ -25,6 +25,9 @@
 #include "glsl_types.h"
 #include "glsl_parser_extras.h"
 
+using std::printf;
+using std::strncmp;
+
 static void print_type(const glsl_type *t);
 
 void
diff --git a/mesalib/src/glsl/ir_validate.cpp b/mesalib/src/glsl/ir_validate.cpp
index 44d7549ea..b0dd6c21f 100644
--- a/mesalib/src/glsl/ir_validate.cpp
+++ b/mesalib/src/glsl/ir_validate.cpp
@@ -39,6 +39,9 @@
 #include "program/hash_table.h"
 #include "glsl_types.h"
 
+using std::abort;
+using std::printf;
+
 class ir_validate : public ir_hierarchical_visitor {
 public:
    ir_validate()
diff --git a/mesalib/src/glsl/lower_mat_op_to_vec.cpp b/mesalib/src/glsl/lower_mat_op_to_vec.cpp
index 8cbbfa713..bdc53a1f8 100644
--- a/mesalib/src/glsl/lower_mat_op_to_vec.cpp
+++ b/mesalib/src/glsl/lower_mat_op_to_vec.cpp
@@ -35,6 +35,9 @@
 #include "ir_expression_flattening.h"
 #include "glsl_types.h"
 
+using std::abort;
+using std::printf;
+
 class ir_mat_op_to_vec_visitor : public ir_hierarchical_visitor {
 public:
    ir_mat_op_to_vec_visitor()
diff --git a/mesalib/src/glsl/opt_constant_propagation.cpp b/mesalib/src/glsl/opt_constant_propagation.cpp
index e1f68892f..1fff71753 100644
--- a/mesalib/src/glsl/opt_constant_propagation.cpp
+++ b/mesalib/src/glsl/opt_constant_propagation.cpp
@@ -41,6 +41,8 @@
 #include "ir_optimization.h"
 #include "glsl_types.h"
 
+using std::memset;
+
 class acp_entry : public exec_node
 {
 public:
diff --git a/mesalib/src/glsl/opt_constant_variable.cpp b/mesalib/src/glsl/opt_constant_variable.cpp
index fedae851f..1f51da6e4 100644
--- a/mesalib/src/glsl/opt_constant_variable.cpp
+++ b/mesalib/src/glsl/opt_constant_variable.cpp
@@ -1,198 +1,201 @@
-/*

- * 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_constant_variable.cpp

- *

- * Marks variables assigned a single constant value over the course

- * of the program as constant.

- *

- * The goal here is to trigger further constant folding and then dead

- * code elimination.  This is common with vector/matrix constructors

- * and calls to builtin functions.

- */

-

-#include "ir.h"

-#include "ir_visitor.h"

-#include "ir_optimization.h"

-#include "glsl_types.h"

-

-struct assignment_entry {

-   exec_node link;

-   int assignment_count;

-   ir_variable *var;

-   ir_constant *constval;

-   bool our_scope;

-};

-

-class ir_constant_variable_visitor : public ir_hierarchical_visitor {

-public:

-   virtual ir_visitor_status visit_enter(ir_dereference_variable *);

-   virtual ir_visitor_status visit(ir_variable *);

-   virtual ir_visitor_status visit_enter(ir_assignment *);

-   virtual ir_visitor_status visit_enter(ir_call *);

-

-   exec_list list;

-};

-

-static struct assignment_entry *

-get_assignment_entry(ir_variable *var, exec_list *list)

-{

-   struct assignment_entry *entry;

-

-   foreach_list_typed(struct assignment_entry, entry, link, list) {

-      if (entry->var == var)

-	 return entry;

-   }

-

-   entry = (struct assignment_entry *)calloc(1, sizeof(*entry));

-   entry->var = var;

-   list->push_head(&entry->link);

-   return entry;

-}

-

-ir_visitor_status

-ir_constant_variable_visitor::visit(ir_variable *ir)

-{

-   struct assignment_entry *entry = get_assignment_entry(ir, &this->list);

-   entry->our_scope = true;

-   return visit_continue;

-}

-

-/* Skip derefs of variables so that we can detect declarations. */

-ir_visitor_status

-ir_constant_variable_visitor::visit_enter(ir_dereference_variable *ir)

-{

-   (void)ir;

-   return visit_continue_with_parent;

-}

-

-ir_visitor_status

-ir_constant_variable_visitor::visit_enter(ir_assignment *ir)

-{

-   ir_constant *constval;

-   struct assignment_entry *entry;

-

-   entry = get_assignment_entry(ir->lhs->variable_referenced(), &this->list);

-   assert(entry);

-   entry->assignment_count++;

-

-   /* If it's already constant, don't do the work. */

-   if (entry->var->constant_value)

-      return visit_continue;

-

-   /* OK, now find if we actually have all the right conditions for

-    * this to be a constant value assigned to the var.

-    */

-   if (ir->condition) {

-      constval = ir->condition->constant_expression_value();

-      if (!constval || !constval->value.b[0])

-	 return visit_continue;

-   }

-

-   ir_variable *var = ir->whole_variable_written();

-   if (!var)

-      return visit_continue;

-

-   constval = ir->rhs->constant_expression_value();

-   if (!constval)

-      return visit_continue;

-

-   /* Mark this entry as having a constant assignment (if the

-    * assignment count doesn't go >1).  do_constant_variable will fix

-    * up the variable with the constant value later.

-    */

-   entry->constval = constval;

-

-   return visit_continue;

-}

-

-ir_visitor_status

-ir_constant_variable_visitor::visit_enter(ir_call *ir)

-{

-   exec_list_iterator sig_iter = ir->get_callee()->parameters.iterator();

-   foreach_iter(exec_list_iterator, iter, *ir) {

-      ir_rvalue *param_rval = (ir_rvalue *)iter.get();

-      ir_variable *param = (ir_variable *)sig_iter.get();

-

-      if (param->mode == ir_var_out ||

-	  param->mode == ir_var_inout) {

-	 ir_variable *var = param_rval->variable_referenced();

-	 struct assignment_entry *entry;

-

-	 assert(var);

-	 entry = get_assignment_entry(var, &this->list);

-	 entry->assignment_count++;

-      }

-      sig_iter.next();

-   }

-   return visit_continue;

-}

-

-/**

- * Does a copy propagation pass on the code present in the instruction stream.

- */

-bool

-do_constant_variable(exec_list *instructions)

-{

-   bool progress = false;

-   ir_constant_variable_visitor v;

-

-   v.run(instructions);

-

-   while (!v.list.is_empty()) {

-

-      struct assignment_entry *entry;

-      entry = exec_node_data(struct assignment_entry, v.list.head, link);

-

-      if (entry->assignment_count == 1 && entry->constval && entry->our_scope) {

-	 entry->var->constant_value = entry->constval;

-	 progress = true;

-      }

-      entry->link.remove();

-      free(entry);

-   }

-

-   return progress;

-}

-

-bool

-do_constant_variable_unlinked(exec_list *instructions)

-{

-   bool progress = false;

-

-   foreach_iter(exec_list_iterator, iter, *instructions) {

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

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

-      if (f) {

-	 foreach_iter(exec_list_iterator, sigiter, *f) {

-	    ir_function_signature *sig =

-	       (ir_function_signature *) sigiter.get();

-	    if (do_constant_variable(&sig->body))

-	       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_constant_variable.cpp
+ *
+ * Marks variables assigned a single constant value over the course
+ * of the program as constant.
+ *
+ * The goal here is to trigger further constant folding and then dead
+ * code elimination.  This is common with vector/matrix constructors
+ * and calls to builtin functions.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_optimization.h"
+#include "glsl_types.h"
+
+using std::calloc;
+using std::free;
+
+struct assignment_entry {
+   exec_node link;
+   int assignment_count;
+   ir_variable *var;
+   ir_constant *constval;
+   bool our_scope;
+};
+
+class ir_constant_variable_visitor : public ir_hierarchical_visitor {
+public:
+   virtual ir_visitor_status visit_enter(ir_dereference_variable *);
+   virtual ir_visitor_status visit(ir_variable *);
+   virtual ir_visitor_status visit_enter(ir_assignment *);
+   virtual ir_visitor_status visit_enter(ir_call *);
+
+   exec_list list;
+};
+
+static struct assignment_entry *
+get_assignment_entry(ir_variable *var, exec_list *list)
+{
+   struct assignment_entry *entry;
+
+   foreach_list_typed(struct assignment_entry, entry, link, list) {
+      if (entry->var == var)
+	 return entry;
+   }
+
+   entry = (struct assignment_entry *)calloc(1, sizeof(*entry));
+   entry->var = var;
+   list->push_head(&entry->link);
+   return entry;
+}
+
+ir_visitor_status
+ir_constant_variable_visitor::visit(ir_variable *ir)
+{
+   struct assignment_entry *entry = get_assignment_entry(ir, &this->list);
+   entry->our_scope = true;
+   return visit_continue;
+}
+
+/* Skip derefs of variables so that we can detect declarations. */
+ir_visitor_status
+ir_constant_variable_visitor::visit_enter(ir_dereference_variable *ir)
+{
+   (void)ir;
+   return visit_continue_with_parent;
+}
+
+ir_visitor_status
+ir_constant_variable_visitor::visit_enter(ir_assignment *ir)
+{
+   ir_constant *constval;
+   struct assignment_entry *entry;
+
+   entry = get_assignment_entry(ir->lhs->variable_referenced(), &this->list);
+   assert(entry);
+   entry->assignment_count++;
+
+   /* If it's already constant, don't do the work. */
+   if (entry->var->constant_value)
+      return visit_continue;
+
+   /* OK, now find if we actually have all the right conditions for
+    * this to be a constant value assigned to the var.
+    */
+   if (ir->condition) {
+      constval = ir->condition->constant_expression_value();
+      if (!constval || !constval->value.b[0])
+	 return visit_continue;
+   }
+
+   ir_variable *var = ir->whole_variable_written();
+   if (!var)
+      return visit_continue;
+
+   constval = ir->rhs->constant_expression_value();
+   if (!constval)
+      return visit_continue;
+
+   /* Mark this entry as having a constant assignment (if the
+    * assignment count doesn't go >1).  do_constant_variable will fix
+    * up the variable with the constant value later.
+    */
+   entry->constval = constval;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_constant_variable_visitor::visit_enter(ir_call *ir)
+{
+   exec_list_iterator sig_iter = ir->get_callee()->parameters.iterator();
+   foreach_iter(exec_list_iterator, iter, *ir) {
+      ir_rvalue *param_rval = (ir_rvalue *)iter.get();
+      ir_variable *param = (ir_variable *)sig_iter.get();
+
+      if (param->mode == ir_var_out ||
+	  param->mode == ir_var_inout) {
+	 ir_variable *var = param_rval->variable_referenced();
+	 struct assignment_entry *entry;
+
+	 assert(var);
+	 entry = get_assignment_entry(var, &this->list);
+	 entry->assignment_count++;
+      }
+      sig_iter.next();
+   }
+   return visit_continue;
+}
+
+/**
+ * Does a copy propagation pass on the code present in the instruction stream.
+ */
+bool
+do_constant_variable(exec_list *instructions)
+{
+   bool progress = false;
+   ir_constant_variable_visitor v;
+
+   v.run(instructions);
+
+   while (!v.list.is_empty()) {
+
+      struct assignment_entry *entry;
+      entry = exec_node_data(struct assignment_entry, v.list.head, link);
+
+      if (entry->assignment_count == 1 && entry->constval && entry->our_scope) {
+	 entry->var->constant_value = entry->constval;
+	 progress = true;
+      }
+      entry->link.remove();
+      free(entry);
+   }
+
+   return progress;
+}
+
+bool
+do_constant_variable_unlinked(exec_list *instructions)
+{
+   bool progress = false;
+
+   foreach_iter(exec_list_iterator, iter, *instructions) {
+      ir_instruction *ir = (ir_instruction *)iter.get();
+      ir_function *f = ir->as_function();
+      if (f) {
+	 foreach_iter(exec_list_iterator, sigiter, *f) {
+	    ir_function_signature *sig =
+	       (ir_function_signature *) sigiter.get();
+	    if (do_constant_variable(&sig->body))
+	       progress = true;
+	 }
+      }
+   }
+
+   return progress;
+}
diff --git a/mesalib/src/glsl/opt_dead_code.cpp b/mesalib/src/glsl/opt_dead_code.cpp
index 492ba73a1..f47b9613e 100644
--- a/mesalib/src/glsl/opt_dead_code.cpp
+++ b/mesalib/src/glsl/opt_dead_code.cpp
@@ -1,142 +1,144 @@
-/*

- * 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_code.cpp

- *

- * Eliminates dead assignments and variable declarations from the code.

- */

-

-#include "ir.h"

-#include "ir_visitor.h"

-#include "ir_variable_refcount.h"

-#include "glsl_types.h"

-

-static bool debug = false;

-

-/**

- * Do a dead code pass over instructions and everything that instructions

- * references.

- *

- * Note that this will remove assignments to globals, so it is not suitable

- * for usage on an unlinked instruction stream.

- */

-bool

-do_dead_code(exec_list *instructions)

-{

-   ir_variable_refcount_visitor v;

-   bool progress = false;

-

-   v.run(instructions);

-

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

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

-

-      /* Since each assignment is a reference, the refereneced count must be

-       * greater than or equal to the assignment count.  If they are equal,

-       * then all of the references are assignments, and the variable is

-       * dead.

-       *

-       * Note that if the variable is neither assigned nor referenced, both

-       * counts will be zero and will be caught by the equality test.

-       */

-      assert(entry->referenced_count >= entry->assigned_count);

-

-      if (debug) {

-	 printf("%s@%p: %d refs, %d assigns, %sdeclared in our scope\n",

-		entry->var->name, (void *) entry->var,

-		entry->referenced_count, entry->assigned_count,

-		entry->declaration ? "" : "not ");

-      }

-

-      if ((entry->referenced_count > entry->assigned_count)

-	  || !entry->declaration)

-	 continue;

-

-      if (entry->assign) {

-	 /* Remove a single dead assignment to the variable we found.

-	  * Don't do so if it's a shader output, though.

-	  */

-	 if (entry->var->mode != ir_var_out &&

-	     entry->var->mode != ir_var_inout &&

-	     !ir_has_call(entry->assign)) {

-	    entry->assign->remove();

-	    progress = true;

-

-	    if (debug) {

-	       printf("Removed assignment to %s@%p\n",

-		      entry->var->name, (void *) entry->var);

-	    }

-	 }

-      } else {

-	 /* If there are no assignments or references to the variable left,

-	  * then we can remove its declaration.

-	  */

-

-	 /* uniform initializers are precious, and could get used by another

-	  * stage.

-	  */

-	 if (entry->var->mode == ir_var_uniform &&

-	     entry->var->constant_value)

-	    continue;

-

-	 entry->var->remove();

-	 progress = true;

-

-	 if (debug) {

-	    printf("Removed declaration of %s@%p\n",

-		   entry->var->name, (void *) entry->var);

-	 }

-      }

-   }

-

-   return progress;

-}

-

-/**

- * Does a dead code pass on the functions present in the instruction stream.

- *

- * This is suitable for use while the program is not linked, as it will

- * ignore variable declarations (and the assignments to them) for variables

- * with global scope.

- */

-bool

-do_dead_code_unlinked(exec_list *instructions)

-{

-   bool progress = false;

-

-   foreach_iter(exec_list_iterator, iter, *instructions) {

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

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

-      if (f) {

-	 foreach_iter(exec_list_iterator, sigiter, *f) {

-	    ir_function_signature *sig =

-	       (ir_function_signature *) sigiter.get();

-	    if (do_dead_code(&sig->body))

-	       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_code.cpp
+ *
+ * Eliminates dead assignments and variable declarations from the code.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_variable_refcount.h"
+#include "glsl_types.h"
+
+using std::printf;
+
+static bool debug = false;
+
+/**
+ * Do a dead code pass over instructions and everything that instructions
+ * references.
+ *
+ * Note that this will remove assignments to globals, so it is not suitable
+ * for usage on an unlinked instruction stream.
+ */
+bool
+do_dead_code(exec_list *instructions)
+{
+   ir_variable_refcount_visitor v;
+   bool progress = false;
+
+   v.run(instructions);
+
+   foreach_iter(exec_list_iterator, iter, v.variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+
+      /* Since each assignment is a reference, the refereneced count must be
+       * greater than or equal to the assignment count.  If they are equal,
+       * then all of the references are assignments, and the variable is
+       * dead.
+       *
+       * Note that if the variable is neither assigned nor referenced, both
+       * counts will be zero and will be caught by the equality test.
+       */
+      assert(entry->referenced_count >= entry->assigned_count);
+
+      if (debug) {
+	 printf("%s@%p: %d refs, %d assigns, %sdeclared in our scope\n",
+		entry->var->name, (void *) entry->var,
+		entry->referenced_count, entry->assigned_count,
+		entry->declaration ? "" : "not ");
+      }
+
+      if ((entry->referenced_count > entry->assigned_count)
+	  || !entry->declaration)
+	 continue;
+
+      if (entry->assign) {
+	 /* Remove a single dead assignment to the variable we found.
+	  * Don't do so if it's a shader output, though.
+	  */
+	 if (entry->var->mode != ir_var_out &&
+	     entry->var->mode != ir_var_inout &&
+	     !ir_has_call(entry->assign)) {
+	    entry->assign->remove();
+	    progress = true;
+
+	    if (debug) {
+	       printf("Removed assignment to %s@%p\n",
+		      entry->var->name, (void *) entry->var);
+	    }
+	 }
+      } else {
+	 /* If there are no assignments or references to the variable left,
+	  * then we can remove its declaration.
+	  */
+
+	 /* uniform initializers are precious, and could get used by another
+	  * stage.
+	  */
+	 if (entry->var->mode == ir_var_uniform &&
+	     entry->var->constant_value)
+	    continue;
+
+	 entry->var->remove();
+	 progress = true;
+
+	 if (debug) {
+	    printf("Removed declaration of %s@%p\n",
+		   entry->var->name, (void *) entry->var);
+	 }
+      }
+   }
+
+   return progress;
+}
+
+/**
+ * Does a dead code pass on the functions present in the instruction stream.
+ *
+ * This is suitable for use while the program is not linked, as it will
+ * ignore variable declarations (and the assignments to them) for variables
+ * with global scope.
+ */
+bool
+do_dead_code_unlinked(exec_list *instructions)
+{
+   bool progress = false;
+
+   foreach_iter(exec_list_iterator, iter, *instructions) {
+      ir_instruction *ir = (ir_instruction *)iter.get();
+      ir_function *f = ir->as_function();
+      if (f) {
+	 foreach_iter(exec_list_iterator, sigiter, *f) {
+	    ir_function_signature *sig =
+	       (ir_function_signature *) sigiter.get();
+	    if (do_dead_code(&sig->body))
+	       progress = true;
+	 }
+      }
+   }
+
+   return progress;
+}
diff --git a/mesalib/src/glsl/opt_dead_code_local.cpp b/mesalib/src/glsl/opt_dead_code_local.cpp
index 2610b6981..88dcdc251 100644
--- a/mesalib/src/glsl/opt_dead_code_local.cpp
+++ b/mesalib/src/glsl/opt_dead_code_local.cpp
@@ -38,6 +38,8 @@
 #include "ir_optimization.h"
 #include "glsl_types.h"
 
+using std::printf;
+
 static bool debug = false;
 
 class assignment_entry : public exec_node
diff --git a/mesalib/src/glsl/opt_dead_functions.cpp b/mesalib/src/glsl/opt_dead_functions.cpp
index ceb79080a..d72eb6115 100644
--- a/mesalib/src/glsl/opt_dead_functions.cpp
+++ b/mesalib/src/glsl/opt_dead_functions.cpp
@@ -32,6 +32,8 @@
  #include "ir_expression_flattening.h"
  #include "glsl_types.h"
 
+ using std::strcmp;
+
  class signature_entry : public exec_node
  {
  public:
diff --git a/mesalib/src/glsl/opt_structure_splitting.cpp b/mesalib/src/glsl/opt_structure_splitting.cpp
index 014407c0b..8686da06a 100644
--- a/mesalib/src/glsl/opt_structure_splitting.cpp
+++ b/mesalib/src/glsl/opt_structure_splitting.cpp
@@ -38,6 +38,9 @@
 #include "ir_rvalue_visitor.h"
 #include "glsl_types.h"
 
+using std::printf;
+using std::strcmp;
+
 static bool debug = false;
 
 // XXX using variable_entry2 here to avoid collision (MSVC multiply-defined
diff --git a/mesalib/src/glsl/opt_swizzle_swizzle.cpp b/mesalib/src/glsl/opt_swizzle_swizzle.cpp
index e23655240..8d0e1051d 100644
--- a/mesalib/src/glsl/opt_swizzle_swizzle.cpp
+++ b/mesalib/src/glsl/opt_swizzle_swizzle.cpp
@@ -1,93 +1,95 @@
-/*

- * 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_swizzle_swizzle.cpp

- *

- * Eliminates the second swizzle in a swizzle chain.

- */

-

-#include "ir.h"

-#include "ir_visitor.h"

-#include "ir_optimization.h"

-#include "glsl_types.h"

-

-class ir_swizzle_swizzle_visitor : public ir_hierarchical_visitor {

-public:

-   ir_swizzle_swizzle_visitor()

-   {

-      progress = false;

-   }

-

-   virtual ir_visitor_status visit_enter(ir_swizzle *);

-

-   bool progress;

-};

-

-ir_visitor_status

-ir_swizzle_swizzle_visitor::visit_enter(ir_swizzle *ir)

-{

-   int mask2[4];

-

-   ir_swizzle *swiz2 = ir->val->as_swizzle();

-   if (!swiz2)

-      return visit_continue;

-

-   memset(&mask2, 0, sizeof(mask2));

-   if (swiz2->mask.num_components >= 1)

-      mask2[0] = swiz2->mask.x;

-   if (swiz2->mask.num_components >= 2)

-      mask2[1] = swiz2->mask.y;

-   if (swiz2->mask.num_components >= 3)

-      mask2[2] = swiz2->mask.z;

-   if (swiz2->mask.num_components >= 4)

-      mask2[3] = swiz2->mask.w;

-

-   if (ir->mask.num_components >= 1)

-      ir->mask.x = mask2[ir->mask.x];

-   if (ir->mask.num_components >= 2)

-      ir->mask.y = mask2[ir->mask.y];

-   if (ir->mask.num_components >= 3)

-      ir->mask.z = mask2[ir->mask.z];

-   if (ir->mask.num_components >= 4)

-      ir->mask.w = mask2[ir->mask.w];

-

-   ir->val = swiz2->val;

-

-   this->progress = true;

-

-   return visit_continue;

-}

-

-/**

- * Does a copy propagation pass on the code present in the instruction stream.

- */

-bool

-do_swizzle_swizzle(exec_list *instructions)

-{

-   ir_swizzle_swizzle_visitor v;

-

-   v.run(instructions);

-

-   return v.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_swizzle_swizzle.cpp
+ *
+ * Eliminates the second swizzle in a swizzle chain.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_optimization.h"
+#include "glsl_types.h"
+
+using std::memset;
+
+class ir_swizzle_swizzle_visitor : public ir_hierarchical_visitor {
+public:
+   ir_swizzle_swizzle_visitor()
+   {
+      progress = false;
+   }
+
+   virtual ir_visitor_status visit_enter(ir_swizzle *);
+
+   bool progress;
+};
+
+ir_visitor_status
+ir_swizzle_swizzle_visitor::visit_enter(ir_swizzle *ir)
+{
+   int mask2[4];
+
+   ir_swizzle *swiz2 = ir->val->as_swizzle();
+   if (!swiz2)
+      return visit_continue;
+
+   memset(&mask2, 0, sizeof(mask2));
+   if (swiz2->mask.num_components >= 1)
+      mask2[0] = swiz2->mask.x;
+   if (swiz2->mask.num_components >= 2)
+      mask2[1] = swiz2->mask.y;
+   if (swiz2->mask.num_components >= 3)
+      mask2[2] = swiz2->mask.z;
+   if (swiz2->mask.num_components >= 4)
+      mask2[3] = swiz2->mask.w;
+
+   if (ir->mask.num_components >= 1)
+      ir->mask.x = mask2[ir->mask.x];
+   if (ir->mask.num_components >= 2)
+      ir->mask.y = mask2[ir->mask.y];
+   if (ir->mask.num_components >= 3)
+      ir->mask.z = mask2[ir->mask.z];
+   if (ir->mask.num_components >= 4)
+      ir->mask.w = mask2[ir->mask.w];
+
+   ir->val = swiz2->val;
+
+   this->progress = true;
+
+   return visit_continue;
+}
+
+/**
+ * Does a copy propagation pass on the code present in the instruction stream.
+ */
+bool
+do_swizzle_swizzle(exec_list *instructions)
+{
+   ir_swizzle_swizzle_visitor v;
+
+   v.run(instructions);
+
+   return v.progress;
+}
diff --git a/mesalib/src/glsl/opt_tree_grafting.cpp b/mesalib/src/glsl/opt_tree_grafting.cpp
index 1ef940f9c..a85ba8234 100644
--- a/mesalib/src/glsl/opt_tree_grafting.cpp
+++ b/mesalib/src/glsl/opt_tree_grafting.cpp
@@ -54,6 +54,8 @@
 #include "ir_optimization.h"
 #include "glsl_types.h"
 
+using std::printf;
+
 static bool debug = false;
 
 class ir_tree_grafting_visitor : public ir_hierarchical_visitor {
diff --git a/mesalib/src/glsl/ralloc.c b/mesalib/src/glsl/ralloc.c
index 3ba5d86cd..6a5eac6b9 100644
--- a/mesalib/src/glsl/ralloc.c
+++ b/mesalib/src/glsl/ralloc.c
@@ -403,6 +403,8 @@ printf_length(const char *fmt, va_list untouched_args)
 #endif
    assert(size >= 0);
 
+   va_end(args);
+
    return size;
 }