svn merge ^/branches/released .

4 files changed, 188 insertions, 184 deletions

diff --git a/mesalib/src/glsl/Makefile b/mesalib/src/glsl/Makefile
index 8059bb472..b63307f53 100644
--- a/mesalib/src/glsl/Makefile
+++ b/mesalib/src/glsl/Makefile
@@ -204,7 +204,7 @@ glcpp/glcpp-parse.c: glcpp/glcpp-parse.y
 	bison -v -o "$@" --defines=glcpp/glcpp-parse.h $<

 

 builtin_compiler: $(GLSL2_OBJECTS) $(OBJECTS) builtin_stubs.o

-	$(APP_CXX) $(INCLUDES) $(CFLAGS) $(LDFLAGS) $(OBJECTS) $(GLSL2_OBJECTS) builtin_stubs.o -o $@

+	$(APP_CXX) $(INCLUDES) $(CXXFLAGS) $(LDFLAGS) $(OBJECTS) $(GLSL2_OBJECTS) builtin_stubs.o -o $@

 

 builtin_function.cpp: builtins/profiles/* builtins/ir/* builtins/tools/generate_builtins.py builtins/tools/texture_builtins.py builtin_compiler

 	@echo Regenerating builtin_function.cpp...

diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index b8a812d94..344d76b57 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -603,7 +603,8 @@ shift_result_type(const struct glsl_type *type_a,
  */

 ir_rvalue *

 validate_assignment(struct _mesa_glsl_parse_state *state,

-		    const glsl_type *lhs_type, ir_rvalue *rhs)

+		    const glsl_type *lhs_type, ir_rvalue *rhs,

+		    bool is_initializer)

 {

    /* If there is already some error in the RHS, just return it.  Anything

     * else will lead to an avalanche of error message back to the user.

@@ -617,12 +618,13 @@ validate_assignment(struct _mesa_glsl_parse_state *state,
       return rhs;

 

    /* If the array element types are the same and the size of the LHS is zero,

-    * the assignment is okay.

+    * the assignment is okay for initializers embedded in variable

+    * declarations.

     *

     * Note: Whole-array assignments are not permitted in GLSL 1.10, but this

     * is handled by ir_dereference::is_lvalue.

     */

-   if (lhs_type->is_array() && rhs->type->is_array()

+   if (is_initializer && lhs_type->is_array() && rhs->type->is_array()

        && (lhs_type->element_type() == rhs->type->element_type())

        && (lhs_type->array_size() == 0)) {

       return rhs;

@@ -639,7 +641,7 @@ validate_assignment(struct _mesa_glsl_parse_state *state,
 

 ir_rvalue *

 do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,

-	      ir_rvalue *lhs, ir_rvalue *rhs,

+	      ir_rvalue *lhs, ir_rvalue *rhs, bool is_initializer,

 	      YYLTYPE lhs_loc)

 {

    void *ctx = state;

@@ -665,7 +667,8 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
       }

    }

 

-   ir_rvalue *new_rhs = validate_assignment(state, lhs->type, rhs);

+   ir_rvalue *new_rhs =

+      validate_assignment(state, lhs->type, rhs, is_initializer);

    if (new_rhs == NULL) {

       _mesa_glsl_error(& lhs_loc, state, "type mismatch");

    } else {

@@ -918,7 +921,7 @@ ast_expression::hir(exec_list *instructions,
       op[0] = this->subexpressions[0]->hir(instructions, state);

       op[1] = this->subexpressions[1]->hir(instructions, state);

 

-      result = do_assignment(instructions, state, op[0], op[1],

+      result = do_assignment(instructions, state, op[0], op[1], false,

 			     this->subexpressions[0]->get_location());

       error_emitted = result->type->is_error();

       type = result->type;

@@ -1245,7 +1248,7 @@ ast_expression::hir(exec_list *instructions,
 						   op[0], op[1]);

 

       result = do_assignment(instructions, state,

-			     op[0]->clone(ctx, NULL), temp_rhs,

+			     op[0]->clone(ctx, NULL), temp_rhs, false,

 			     this->subexpressions[0]->get_location());

       type = result->type;

       error_emitted = (op[0]->type->is_error());

@@ -1271,7 +1274,7 @@ ast_expression::hir(exec_list *instructions,
 					op[0], op[1]);

 

       result = do_assignment(instructions, state,

-			     op[0]->clone(ctx, NULL), temp_rhs,

+			     op[0]->clone(ctx, NULL), temp_rhs, false,

 			     this->subexpressions[0]->get_location());

       type = result->type;

       error_emitted = type->is_error();

@@ -1287,7 +1290,7 @@ ast_expression::hir(exec_list *instructions,
       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],

                                                    type, op[0], op[1]);

       result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),

-                             temp_rhs,

+                             temp_rhs, false,

                              this->subexpressions[0]->get_location());

       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

       break;

@@ -1303,7 +1306,7 @@ ast_expression::hir(exec_list *instructions,
       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],

                                                    type, op[0], op[1]);

       result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),

-                             temp_rhs,

+                             temp_rhs, false,

                              this->subexpressions[0]->get_location());

       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

       break;

@@ -1419,7 +1422,7 @@ ast_expression::hir(exec_list *instructions,
 					op[0], op[1]);

 

       result = do_assignment(instructions, state,

-			     op[0]->clone(ctx, NULL), temp_rhs,

+			     op[0]->clone(ctx, NULL), temp_rhs, false,

 			     this->subexpressions[0]->get_location());

       type = result->type;

       error_emitted = op[0]->type->is_error();

@@ -1448,7 +1451,7 @@ ast_expression::hir(exec_list *instructions,
       result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));

 

       (void)do_assignment(instructions, state,

-			  op[0]->clone(ctx, NULL), temp_rhs,

+			  op[0]->clone(ctx, NULL), temp_rhs, false,

 			  this->subexpressions[0]->get_location());

 

       type = result->type;

@@ -2234,7 +2237,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
     */

    if (type->qualifier.flags.q.constant

        || type->qualifier.flags.q.uniform) {

-      ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs);

+      ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs, true);

       if (new_rhs != NULL) {

 	 rhs = new_rhs;

 

@@ -2276,7 +2279,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
       const glsl_type *initializer_type;

       if (!type->qualifier.flags.q.uniform) {

 	 result = do_assignment(initializer_instructions, state,

-				lhs, rhs,

+				lhs, rhs, true,

 				type->get_location());

 	 initializer_type = result->type;

       } else

diff --git a/mesalib/src/glsl/glsl_symbol_table.cpp b/mesalib/src/glsl/glsl_symbol_table.cpp
index 9714384eb..fa6458df5 100644
--- a/mesalib/src/glsl/glsl_symbol_table.cpp
+++ b/mesalib/src/glsl/glsl_symbol_table.cpp
@@ -1,168 +1,169 @@
-/* -*- c++ -*- */
-/*
- * 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 "glsl_symbol_table.h"
-
-class symbol_table_entry {
-public:
-   /* Callers of this ralloc-based new need not call delete. It's
-    * easier to just ralloc_free 'ctx' (or any of its ancestors). */
-   static void* operator new(size_t size, void *ctx)
-   {
-      void *entry = ralloc_size(ctx, size);
-      assert(entry != NULL);
-      return entry;
-   }
-
-   /* If the user *does* call delete, that's OK, we will just ralloc_free. */
-   static void operator delete(void *entry, void *ctx)
-   {
-      ralloc_free(entry);
-   }
-   static void operator delete(void *entry)
-   {
-      ralloc_free(entry);
-   }
-
-   symbol_table_entry(ir_variable *v)                     : v(v), f(0), t(0) {}
-   symbol_table_entry(ir_function *f)                     : v(0), f(f), t(0) {}
-   symbol_table_entry(const glsl_type *t)                 : v(0), f(0), t(t) {}
-
-   ir_variable *v;
-   ir_function *f;
-   const glsl_type *t;
-};
-
-glsl_symbol_table::glsl_symbol_table()
-{
-   this->language_version = 120;
-   this->table = _mesa_symbol_table_ctor();
-   this->mem_ctx = ralloc_context(NULL);
-}
-
-glsl_symbol_table::~glsl_symbol_table()
-{
-   _mesa_symbol_table_dtor(table);
-   ralloc_free(mem_ctx);
-}
-
-void glsl_symbol_table::push_scope()
-{
-   _mesa_symbol_table_push_scope(table);
-}
-
-void glsl_symbol_table::pop_scope()
-{
-   _mesa_symbol_table_pop_scope(table);
-}
-
-bool glsl_symbol_table::name_declared_this_scope(const char *name)
-{
-   return _mesa_symbol_table_symbol_scope(table, -1, name) == 0;
-}
-
-bool glsl_symbol_table::add_variable(ir_variable *v)
-{
-   if (this->language_version == 110) {
-      /* In 1.10, functions and variables have separate namespaces. */
-      symbol_table_entry *existing = get_entry(v->name);
-      if (name_declared_this_scope(v->name)) {
-	 /* If there's already an existing function (not a constructor!) in
-	  * the current scope, just update the existing entry to include 'v'.
-	  */
-	 if (existing->v == NULL && existing->t == NULL) {
-	    existing->v = v;
-	    return true;
-	 }
-      } else {
-	 /* If not declared at this scope, add a new entry.  But if an existing
-	  * entry includes a function, propagate that to this block - otherwise
-	  * the new variable declaration would shadow the function.
-	  */
-	 symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);
-	 if (existing != NULL)
-	    entry->f = existing->f;
-	 int added = _mesa_symbol_table_add_symbol(table, -1, v->name, entry);
-	 assert(added == 0);
-	 (void)added;
-	 return true;
-      }
-      return false;
-   }
-
-   /* 1.20+ rules: */
-   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);
-   return _mesa_symbol_table_add_symbol(table, -1, v->name, entry) == 0;
-}
-
-bool glsl_symbol_table::add_type(const char *name, const glsl_type *t)
-{
-   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(t);
-   return _mesa_symbol_table_add_symbol(table, -1, name, entry) == 0;
-}
-
-bool glsl_symbol_table::add_function(ir_function *f)
-{
-   if (this->language_version == 110 && name_declared_this_scope(f->name)) {
-      /* In 1.10, functions and variables have separate namespaces. */
-      symbol_table_entry *existing = get_entry(f->name);
-      if ((existing->f == NULL) && (existing->t == NULL)) {
-	 existing->f = f;
-	 return true;
-      }
-   }
-   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);
-   return _mesa_symbol_table_add_symbol(table, -1, f->name, entry) == 0;
-}
-
-void glsl_symbol_table::add_global_function(ir_function *f)
-{
-   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);
-   int added = _mesa_symbol_table_add_global_symbol(table, -1, f->name, entry);
-   assert(added == 0);
-}
-
-ir_variable *glsl_symbol_table::get_variable(const char *name)
-{
-   symbol_table_entry *entry = get_entry(name);
-   return entry != NULL ? entry->v : NULL;
-}
-
-const glsl_type *glsl_symbol_table::get_type(const char *name)
-{
-   symbol_table_entry *entry = get_entry(name);
-   return entry != NULL ? entry->t : NULL;
-}
-
-ir_function *glsl_symbol_table::get_function(const char *name)
-{
-   symbol_table_entry *entry = get_entry(name);
-   return entry != NULL ? entry->f : NULL;
-}
-
-symbol_table_entry *glsl_symbol_table::get_entry(const char *name)
-{
-   return (symbol_table_entry *)
-      _mesa_symbol_table_find_symbol(table, -1, name);
-}
+/* -*- c++ -*- */

+/*

+ * 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 "glsl_symbol_table.h"

+

+class symbol_table_entry {

+public:

+   /* Callers of this ralloc-based new need not call delete. It's

+    * easier to just ralloc_free 'ctx' (or any of its ancestors). */

+   static void* operator new(size_t size, void *ctx)

+   {

+      void *entry = ralloc_size(ctx, size);

+      assert(entry != NULL);

+      return entry;

+   }

+

+   /* If the user *does* call delete, that's OK, we will just ralloc_free. */

+   static void operator delete(void *entry, void *ctx)

+   {

+      ralloc_free(entry);

+   }

+   static void operator delete(void *entry)

+   {

+      ralloc_free(entry);

+   }

+

+   symbol_table_entry(ir_variable *v)                     : v(v), f(0), t(0) {}

+   symbol_table_entry(ir_function *f)                     : v(0), f(f), t(0) {}

+   symbol_table_entry(const glsl_type *t)                 : v(0), f(0), t(t) {}

+

+   ir_variable *v;

+   ir_function *f;

+   const glsl_type *t;

+};

+

+glsl_symbol_table::glsl_symbol_table()

+{

+   this->language_version = 120;

+   this->table = _mesa_symbol_table_ctor();

+   this->mem_ctx = ralloc_context(NULL);

+}

+

+glsl_symbol_table::~glsl_symbol_table()

+{

+   _mesa_symbol_table_dtor(table);

+   ralloc_free(mem_ctx);

+}

+

+void glsl_symbol_table::push_scope()

+{

+   _mesa_symbol_table_push_scope(table);

+}

+

+void glsl_symbol_table::pop_scope()

+{

+   _mesa_symbol_table_pop_scope(table);

+}

+

+bool glsl_symbol_table::name_declared_this_scope(const char *name)

+{

+   return _mesa_symbol_table_symbol_scope(table, -1, name) == 0;

+}

+

+bool glsl_symbol_table::add_variable(ir_variable *v)

+{

+   if (this->language_version == 110) {

+      /* In 1.10, functions and variables have separate namespaces. */

+      symbol_table_entry *existing = get_entry(v->name);

+      if (name_declared_this_scope(v->name)) {

+	 /* If there's already an existing function (not a constructor!) in

+	  * the current scope, just update the existing entry to include 'v'.

+	  */

+	 if (existing->v == NULL && existing->t == NULL) {

+	    existing->v = v;

+	    return true;

+	 }

+      } else {

+	 /* If not declared at this scope, add a new entry.  But if an existing

+	  * entry includes a function, propagate that to this block - otherwise

+	  * the new variable declaration would shadow the function.

+	  */

+	 symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);

+	 if (existing != NULL)

+	    entry->f = existing->f;

+	 int added = _mesa_symbol_table_add_symbol(table, -1, v->name, entry);

+	 assert(added == 0);

+	 (void)added;

+	 return true;

+      }

+      return false;

+   }

+

+   /* 1.20+ rules: */

+   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);

+   return _mesa_symbol_table_add_symbol(table, -1, v->name, entry) == 0;

+}

+

+bool glsl_symbol_table::add_type(const char *name, const glsl_type *t)

+{

+   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(t);

+   return _mesa_symbol_table_add_symbol(table, -1, name, entry) == 0;

+}

+

+bool glsl_symbol_table::add_function(ir_function *f)

+{

+   if (this->language_version == 110 && name_declared_this_scope(f->name)) {

+      /* In 1.10, functions and variables have separate namespaces. */

+      symbol_table_entry *existing = get_entry(f->name);

+      if ((existing->f == NULL) && (existing->t == NULL)) {

+	 existing->f = f;

+	 return true;

+      }

+   }

+   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);

+   return _mesa_symbol_table_add_symbol(table, -1, f->name, entry) == 0;

+}

+

+void glsl_symbol_table::add_global_function(ir_function *f)

+{

+   symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);

+   int added = _mesa_symbol_table_add_global_symbol(table, -1, f->name, entry);

+   assert(added == 0);

+   (void)added;

+}

+

+ir_variable *glsl_symbol_table::get_variable(const char *name)

+{

+   symbol_table_entry *entry = get_entry(name);

+   return entry != NULL ? entry->v : NULL;

+}

+

+const glsl_type *glsl_symbol_table::get_type(const char *name)

+{

+   symbol_table_entry *entry = get_entry(name);

+   return entry != NULL ? entry->t : NULL;

+}

+

+ir_function *glsl_symbol_table::get_function(const char *name)

+{

+   symbol_table_entry *entry = get_entry(name);

+   return entry != NULL ? entry->f : NULL;

+}

+

+symbol_table_entry *glsl_symbol_table::get_entry(const char *name)

+{

+   return (symbol_table_entry *)

+      _mesa_symbol_table_find_symbol(table, -1, name);

+}

diff --git a/mesalib/src/glsl/ir.cpp b/mesalib/src/glsl/ir.cpp
index ceb989110..7ee07f3c6 100644
--- a/mesalib/src/glsl/ir.cpp
+++ b/mesalib/src/glsl/ir.cpp
@@ -1157,7 +1157,7 @@ ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
    this->sampler = sampler;

    this->type = type;

 

-   assert(sampler->type->sampler_type == type->base_type);

+   assert(sampler->type->sampler_type == (int) type->base_type);

    if (sampler->type->sampler_shadow)

       assert(type->vector_elements == 4 || type->vector_elements == 1);

    else