glsl: Remove integer matrix support from ir_dereference_array::constant_expression_value

[mesa.git] / src / compiler / glsl / opt_function_inlining.cpp

diff --git a/src/compiler/glsl/opt_function_inlining.cpp b/src/compiler/glsl/opt_function_inlining.cpp
index 62c1f4b6fc2814a017fef0b66af56fe9ca8caf11..590bd707bee22de592bee6cf8ccc6d899abd204f 100644 (file)
--- a/src/compiler/glsl/opt_function_inlining.cpp
+++ b/src/compiler/glsl/opt_function_inlining.cpp
@@ -89,7 +89,7 @@ replace_return_with_assignment(ir_instruction *ir, void *data)
    if (ret) {
       if (ret->value) {
         ir_rvalue *lhs = orig_deref->clone(ctx, NULL);
-        ret->replace_with(new(ctx) ir_assignment(lhs, ret->value, NULL));
+         ret->replace_with(new(ctx) ir_assignment(lhs, ret->value));
       } else {
         /* un-valued return has to be the last return, or we shouldn't
          * have reached here. (see can_inline()).
@@ -121,7 +121,7 @@ ir_save_lvalue_visitor::visit_enter(ir_dereference_array *deref)
       base_ir->insert_before(index);
 
       assignment = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(index),
-                                          deref->array_index, 0);
+                                          deref->array_index);
       base_ir->insert_before(assignment);
 
       deref->array_index = new(ctx) ir_dereference_variable(index);
@@ -131,6 +131,18 @@ ir_save_lvalue_visitor::visit_enter(ir_dereference_array *deref)
    return visit_stop;
 }
 
+static bool
+should_replace_variable(ir_variable *sig_param, ir_rvalue *param) {
+   /* For opaque types, we want the inlined variable references
+    * referencing the passed in variable, since that will have
+    * the location information, which an assignment of an opaque
+    * variable wouldn't.
+    */
+   return sig_param->type->contains_opaque() &&
+          param->is_dereference() &&
+          sig_param->data.mode == ir_var_function_in;
+}
+
 void
 ir_call::generate_inline(ir_instruction *next_ir)
 {
@@ -140,7 +152,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
    int i;
    struct hash_table *ht;
 
-   ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer, _mesa_key_pointer_equal);
+   ht = _mesa_pointer_hash_table_create(NULL);
 
    num_parameters = this->callee->parameters.length();
    parameters = new ir_variable *[num_parameters];
@@ -155,16 +167,12 @@ ir_call::generate_inline(ir_instruction *next_ir)
       ir_rvalue *param = (ir_rvalue *) actual_node;
 
       /* Generate a new variable for the parameter. */
-      if (sig_param->type->contains_opaque()) {
-        /* For opaque types, we want the inlined variable references
-         * referencing the passed in variable, since that will have
-         * the location information, which an assignment of an opaque
-         * variable wouldn't.  Fix it up below.
-         */
+      if (should_replace_variable(sig_param, param)) {
+         /* Actual replacement happens below */
         parameters[i] = NULL;
       } else {
         parameters[i] = sig_param->clone(ctx, ht);
-        parameters[i]->data.mode = ir_var_auto;
+        parameters[i]->data.mode = ir_var_temporary;
 
         /* Remove the read-only decoration because we're going to write
          * directly to this variable.  If the cloned variable is left
@@ -199,7 +207,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
             ir_assignment *assign;
 
             assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(parameters[i]),
-                                            param, NULL);
+                                            param);
             next_ir->insert_before(assign);
          } else {
             assert(sig_param->data.mode == ir_var_function_out ||
@@ -215,7 +223,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
                ir_assignment *assign;
 
                assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(parameters[i]),
-                                               param->clone(ctx, NULL)->as_rvalue(), NULL);
+                                               param->clone(ctx, NULL)->as_rvalue());
                next_ir->insert_before(assign);
             }
          }
@@ -242,10 +250,9 @@ ir_call::generate_inline(ir_instruction *next_ir)
       ir_rvalue *const param = (ir_rvalue *) actual_node;
       ir_variable *sig_param = (ir_variable *) formal_node;
 
-      if (sig_param->type->contains_opaque()) {
+      if (should_replace_variable(sig_param, param)) {
         ir_dereference *deref = param->as_dereference();
 
-        assert(deref);
         do_variable_replacement(&new_instructions, sig_param, deref);
       }
    }
@@ -268,8 +275,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
         ir_assignment *assign;
 
          assign = new(ctx) ir_assignment(param,
-                                        new(ctx) ir_dereference_variable(parameters[i]),
-                                        NULL);
+                                         new(ctx) ir_dereference_variable(parameters[i]));
         next_ir->insert_before(assign);
       }
 
@@ -352,6 +358,9 @@ public:
    virtual ir_visitor_status visit_leave(ir_dereference_array *);
    virtual ir_visitor_status visit_leave(ir_dereference_record *);
    virtual ir_visitor_status visit_leave(ir_texture *);
+   virtual ir_visitor_status visit_leave(ir_assignment *);
+   virtual ir_visitor_status visit_leave(ir_expression *);
+   virtual ir_visitor_status visit_leave(ir_return *);
 
    void replace_deref(ir_dereference **deref);
    void replace_rvalue(ir_rvalue **rvalue);
@@ -392,6 +401,32 @@ ir_variable_replacement_visitor::visit_leave(ir_texture *ir)
    return visit_continue;
 }
 
+ir_visitor_status
+ir_variable_replacement_visitor::visit_leave(ir_assignment *ir)
+{
+   replace_deref(&ir->lhs);
+   replace_rvalue(&ir->rhs);
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_variable_replacement_visitor::visit_leave(ir_expression *ir)
+{
+   for (uint8_t i = 0; i < ir->num_operands; i++)
+      replace_rvalue(&ir->operands[i]);
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_variable_replacement_visitor::visit_leave(ir_return *ir)
+{
+   replace_rvalue(&ir->value);
+
+   return visit_continue;
+}
+
 ir_visitor_status
 ir_variable_replacement_visitor::visit_leave(ir_dereference_array *ir)
 {