xserver and mesa git update 28-12-2010

1 files changed, 262 insertions, 262 deletions

diff --git a/mesalib/src/glsl/link_functions.cpp b/mesalib/src/glsl/link_functions.cpp
index 78c8b48cf..98aa34a19 100644
--- a/mesalib/src/glsl/link_functions.cpp
+++ b/mesalib/src/glsl/link_functions.cpp
@@ -1,262 +1,262 @@
-/*
- * 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 <cstdlib>
-#include <cstdio>
-#include <cstdarg>
-
-extern "C" {
-#include <talloc.h>
-}
-
-#include "main/core.h"
-#include "glsl_symbol_table.h"
-#include "glsl_parser_extras.h"
-#include "ir.h"
-#include "program.h"
-#include "program/hash_table.h"
-#include "linker.h"
-
-static ir_function_signature *
-find_matching_signature(const char *name, const exec_list *actual_parameters,
-			gl_shader **shader_list, unsigned num_shaders);
-
-class call_link_visitor : public ir_hierarchical_visitor {
-public:
-   call_link_visitor(gl_shader_program *prog, gl_shader *linked,
-		     gl_shader **shader_list, unsigned num_shaders)
-   {
-      this->prog = prog;
-      this->shader_list = shader_list;
-      this->num_shaders = num_shaders;
-      this->success = true;
-      this->linked = linked;
-
-      this->locals = hash_table_ctor(0, hash_table_pointer_hash,
-				     hash_table_pointer_compare);
-   }
-
-   ~call_link_visitor()
-   {
-      hash_table_dtor(this->locals);
-   }
-
-   virtual ir_visitor_status visit(ir_variable *ir)
-   {
-      hash_table_insert(locals, ir, ir);
-      return visit_continue;
-   }
-
-   virtual ir_visitor_status visit_enter(ir_call *ir)
-   {
-      /* If ir is an ir_call from a function that was imported from another
-       * shader callee will point to an ir_function_signature in the original
-       * shader.  In this case the function signature MUST NOT BE MODIFIED.
-       * Doing so will modify the original shader.  This may prevent that
-       * shader from being linkable in other programs.
-       */
-      const ir_function_signature *const callee = ir->get_callee();
-      assert(callee != NULL);
-      const char *const name = callee->function_name();
-
-      /* Determine if the requested function signature already exists in the
-       * final linked shader.  If it does, use it as the target of the call.
-       */
-      ir_function_signature *sig =
-	 find_matching_signature(name, &callee->parameters, &linked, 1);
-      if (sig != NULL) {
-	 ir->set_callee(sig);
-	 return visit_continue;
-      }
-
-      /* Try to find the signature in one of the other shaders that is being
-       * linked.  If it's not found there, return an error.
-       */
-      sig = find_matching_signature(name, &ir->actual_parameters, shader_list,
-				    num_shaders);
-      if (sig == NULL) {
-	 /* FINISHME: Log the full signature of unresolved function.
-	  */
-	 linker_error_printf(this->prog, "unresolved reference to function "
-			     "`%s'\n", name);
-	 this->success = false;
-	 return visit_stop;
-      }
-
-      /* Find the prototype information in the linked shader.  Generate any
-       * details that may be missing.
-       */
-      ir_function *f = linked->symbols->get_function(name);
-      if (f == NULL)
-	 f = new(linked) ir_function(name);
-
-      ir_function_signature *linked_sig =
-	 f->exact_matching_signature(&callee->parameters);
-      if (linked_sig == NULL) {
-	 linked_sig = new(linked) ir_function_signature(callee->return_type);
-	 f->add_signature(linked_sig);
-      }
-
-      /* At this point linked_sig and called may be the same.  If ir is an
-       * ir_call from linked then linked_sig and callee will be
-       * ir_function_signatures that have no definitions (is_defined is false).
-       */
-      assert(!linked_sig->is_defined);
-      assert(linked_sig->body.is_empty());
-
-      /* Create an in-place clone of the function definition.  This multistep
-       * process introduces some complexity here, but it has some advantages.
-       * The parameter list and the and function body are cloned separately.
-       * The clone of the parameter list is used to prime the hashtable used
-       * to replace variable references in the cloned body.
-       *
-       * The big advantage is that the ir_function_signature does not change.
-       * This means that we don't have to process the rest of the IR tree to
-       * patch ir_call nodes.  In addition, there is no way to remove or
-       * replace signature stored in a function.  One could easily be added,
-       * but this avoids the need.
-       */
-      struct hash_table *ht = hash_table_ctor(0, hash_table_pointer_hash,
-					      hash_table_pointer_compare);
-      exec_list formal_parameters;
-      foreach_list_const(node, &sig->parameters) {
-	 const ir_instruction *const original = (ir_instruction *) node;
-	 assert(const_cast<ir_instruction *>(original)->as_variable());
-
-	 ir_instruction *copy = original->clone(linked, ht);
-	 formal_parameters.push_tail(copy);
-      }
-
-      linked_sig->replace_parameters(&formal_parameters);
-
-      foreach_list_const(node, &sig->body) {
-	 const ir_instruction *const original = (ir_instruction *) node;
-
-	 ir_instruction *copy = original->clone(linked, ht);
-	 linked_sig->body.push_tail(copy);
-      }
-
-      linked_sig->is_defined = true;
-      hash_table_dtor(ht);
-
-      /* Patch references inside the function to things outside the function
-       * (i.e., function calls and global variables).
-       */
-      linked_sig->accept(this);
-
-      ir->set_callee(linked_sig);
-
-      return visit_continue;
-   }
-
-   virtual ir_visitor_status visit(ir_dereference_variable *ir)
-   {
-      if (hash_table_find(locals, ir->var) == NULL) {
-	 /* The non-function variable must be a global, so try to find the
-	  * variable in the shader's symbol table.  If the variable is not
-	  * found, then it's a global that *MUST* be defined in the original
-	  * shader.
-	  */
-	 ir_variable *var = linked->symbols->get_variable(ir->var->name);
-	 if (var == NULL) {
-	    /* Clone the ir_variable that the dereference already has and add
-	     * it to the linked shader.
-	     */
-	    var = ir->var->clone(linked, NULL);
-	    linked->symbols->add_variable(var->name, var);
-	    linked->ir->push_head(var);
-	 }
-
-	 ir->var = var;
-      }
-
-      return visit_continue;
-   }
-
-   /** Was function linking successful? */
-   bool success;
-
-private:
-   /**
-    * Shader program being linked
-    *
-    * This is only used for logging error messages.
-    */
-   gl_shader_program *prog;
-
-   /** List of shaders available for linking. */
-   gl_shader **shader_list;
-
-   /** Number of shaders available for linking. */
-   unsigned num_shaders;
-
-   /**
-    * Final linked shader
-    *
-    * This is used two ways.  It is used to find global variables in the
-    * linked shader that are accessed by the function.  It is also used to add
-    * global variables from the shader where the function originated.
-    */
-   gl_shader *linked;
-
-   /**
-    * Table of variables local to the function.
-    */
-   hash_table *locals;
-};
-
-
-/**
- * Searches a list of shaders for a particular function definition
- */
-ir_function_signature *
-find_matching_signature(const char *name, const exec_list *actual_parameters,
-			gl_shader **shader_list, unsigned num_shaders)
-{
-   for (unsigned i = 0; i < num_shaders; i++) {
-      ir_function *const f = shader_list[i]->symbols->get_function(name);
-
-      if (f == NULL)
-	 continue;
-
-      ir_function_signature *sig = f->matching_signature(actual_parameters);
-
-      if ((sig == NULL) || !sig->is_defined)
-	 continue;
-
-      return sig;
-   }
-
-   return NULL;
-}
-
-
-bool
-link_function_calls(gl_shader_program *prog, gl_shader *main,
-		    gl_shader **shader_list, unsigned num_shaders)
-{
-   call_link_visitor v(prog, main, shader_list, num_shaders);
-
-   v.run(main->ir);
-   return v.success;
-}
+/*

+ * 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 <cstdlib>

+#include <cstdio>

+#include <cstdarg>

+

+extern "C" {

+#include <talloc.h>

+}

+

+#include "main/core.h"

+#include "glsl_symbol_table.h"

+#include "glsl_parser_extras.h"

+#include "ir.h"

+#include "program.h"

+#include "program/hash_table.h"

+#include "linker.h"

+

+static ir_function_signature *

+find_matching_signature(const char *name, const exec_list *actual_parameters,

+			gl_shader **shader_list, unsigned num_shaders);

+

+class call_link_visitor : public ir_hierarchical_visitor {

+public:

+   call_link_visitor(gl_shader_program *prog, gl_shader *linked,

+		     gl_shader **shader_list, unsigned num_shaders)

+   {

+      this->prog = prog;

+      this->shader_list = shader_list;

+      this->num_shaders = num_shaders;

+      this->success = true;

+      this->linked = linked;

+

+      this->locals = hash_table_ctor(0, hash_table_pointer_hash,

+				     hash_table_pointer_compare);

+   }

+

+   ~call_link_visitor()

+   {

+      hash_table_dtor(this->locals);

+   }

+

+   virtual ir_visitor_status visit(ir_variable *ir)

+   {

+      hash_table_insert(locals, ir, ir);

+      return visit_continue;

+   }

+

+   virtual ir_visitor_status visit_enter(ir_call *ir)

+   {

+      /* If ir is an ir_call from a function that was imported from another

+       * shader callee will point to an ir_function_signature in the original

+       * shader.  In this case the function signature MUST NOT BE MODIFIED.

+       * Doing so will modify the original shader.  This may prevent that

+       * shader from being linkable in other programs.

+       */

+      const ir_function_signature *const callee = ir->get_callee();

+      assert(callee != NULL);

+      const char *const name = callee->function_name();

+

+      /* Determine if the requested function signature already exists in the

+       * final linked shader.  If it does, use it as the target of the call.

+       */

+      ir_function_signature *sig =

+	 find_matching_signature(name, &callee->parameters, &linked, 1);

+      if (sig != NULL) {

+	 ir->set_callee(sig);

+	 return visit_continue;

+      }

+

+      /* Try to find the signature in one of the other shaders that is being

+       * linked.  If it's not found there, return an error.

+       */

+      sig = find_matching_signature(name, &ir->actual_parameters, shader_list,

+				    num_shaders);

+      if (sig == NULL) {

+	 /* FINISHME: Log the full signature of unresolved function.

+	  */

+	 linker_error_printf(this->prog, "unresolved reference to function "

+			     "`%s'\n", name);

+	 this->success = false;

+	 return visit_stop;

+      }

+

+      /* Find the prototype information in the linked shader.  Generate any

+       * details that may be missing.

+       */

+      ir_function *f = linked->symbols->get_function(name);

+      if (f == NULL)

+	 f = new(linked) ir_function(name);

+

+      ir_function_signature *linked_sig =

+	 f->exact_matching_signature(&callee->parameters);

+      if (linked_sig == NULL) {

+	 linked_sig = new(linked) ir_function_signature(callee->return_type);

+	 f->add_signature(linked_sig);

+      }

+

+      /* At this point linked_sig and called may be the same.  If ir is an

+       * ir_call from linked then linked_sig and callee will be

+       * ir_function_signatures that have no definitions (is_defined is false).

+       */

+      assert(!linked_sig->is_defined);

+      assert(linked_sig->body.is_empty());

+

+      /* Create an in-place clone of the function definition.  This multistep

+       * process introduces some complexity here, but it has some advantages.

+       * The parameter list and the and function body are cloned separately.

+       * The clone of the parameter list is used to prime the hashtable used

+       * to replace variable references in the cloned body.

+       *

+       * The big advantage is that the ir_function_signature does not change.

+       * This means that we don't have to process the rest of the IR tree to

+       * patch ir_call nodes.  In addition, there is no way to remove or

+       * replace signature stored in a function.  One could easily be added,

+       * but this avoids the need.

+       */

+      struct hash_table *ht = hash_table_ctor(0, hash_table_pointer_hash,

+					      hash_table_pointer_compare);

+      exec_list formal_parameters;

+      foreach_list_const(node, &sig->parameters) {

+	 const ir_instruction *const original = (ir_instruction *) node;

+	 assert(const_cast<ir_instruction *>(original)->as_variable());

+

+	 ir_instruction *copy = original->clone(linked, ht);

+	 formal_parameters.push_tail(copy);

+      }

+

+      linked_sig->replace_parameters(&formal_parameters);

+

+      foreach_list_const(node, &sig->body) {

+	 const ir_instruction *const original = (ir_instruction *) node;

+

+	 ir_instruction *copy = original->clone(linked, ht);

+	 linked_sig->body.push_tail(copy);

+      }

+

+      linked_sig->is_defined = true;

+      hash_table_dtor(ht);

+

+      /* Patch references inside the function to things outside the function

+       * (i.e., function calls and global variables).

+       */

+      linked_sig->accept(this);

+

+      ir->set_callee(linked_sig);

+

+      return visit_continue;

+   }

+

+   virtual ir_visitor_status visit(ir_dereference_variable *ir)

+   {

+      if (hash_table_find(locals, ir->var) == NULL) {

+	 /* The non-function variable must be a global, so try to find the

+	  * variable in the shader's symbol table.  If the variable is not

+	  * found, then it's a global that *MUST* be defined in the original

+	  * shader.

+	  */

+	 ir_variable *var = linked->symbols->get_variable(ir->var->name);

+	 if (var == NULL) {

+	    /* Clone the ir_variable that the dereference already has and add

+	     * it to the linked shader.

+	     */

+	    var = ir->var->clone(linked, NULL);

+	    linked->symbols->add_variable(var);

+	    linked->ir->push_head(var);

+	 }

+

+	 ir->var = var;

+      }

+

+      return visit_continue;

+   }

+

+   /** Was function linking successful? */

+   bool success;

+

+private:

+   /**

+    * Shader program being linked

+    *

+    * This is only used for logging error messages.

+    */

+   gl_shader_program *prog;

+

+   /** List of shaders available for linking. */

+   gl_shader **shader_list;

+

+   /** Number of shaders available for linking. */

+   unsigned num_shaders;

+

+   /**

+    * Final linked shader

+    *

+    * This is used two ways.  It is used to find global variables in the

+    * linked shader that are accessed by the function.  It is also used to add

+    * global variables from the shader where the function originated.

+    */

+   gl_shader *linked;

+

+   /**

+    * Table of variables local to the function.

+    */

+   hash_table *locals;

+};

+

+

+/**

+ * Searches a list of shaders for a particular function definition

+ */

+ir_function_signature *

+find_matching_signature(const char *name, const exec_list *actual_parameters,

+			gl_shader **shader_list, unsigned num_shaders)

+{

+   for (unsigned i = 0; i < num_shaders; i++) {

+      ir_function *const f = shader_list[i]->symbols->get_function(name);

+

+      if (f == NULL)

+	 continue;

+

+      ir_function_signature *sig = f->matching_signature(actual_parameters);

+

+      if ((sig == NULL) || !sig->is_defined)

+	 continue;

+

+      return sig;

+   }

+

+   return NULL;

+}

+

+

+bool

+link_function_calls(gl_shader_program *prog, gl_shader *main,

+		    gl_shader **shader_list, unsigned num_shaders)

+{

+   call_link_visitor v(prog, main, shader_list, num_shaders);

+

+   v.run(main->ir);

+   return v.success;

+}