i965/vec4/tcs: Return NULL instead of false in brw_compile_tcs()

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

diff --git a/src/glsl/opt_function_inlining.cpp b/src/glsl/opt_function_inlining.cpp
index 2ae18c14f537b44600b40e04da12e8a53d2e024a..84a9e4fa0933d910bea5da697e272ea9e1af5b53 100644 (file)
--- a/src/glsl/opt_function_inlining.cpp
+++ b/src/glsl/opt_function_inlining.cpp
@@ -100,27 +100,23 @@ ir_call::generate_inline(ir_instruction *next_ir)
 {
    void *ctx = ralloc_parent(this);
    ir_variable **parameters;
-   int num_parameters;
+   unsigned num_parameters;
    int i;
    struct hash_table *ht;
 
    ht = hash_table_ctor(0, hash_table_pointer_hash, hash_table_pointer_compare);
 
-   num_parameters = 0;
-   foreach_list(n, &this->callee->parameters)
-      num_parameters++;
-
+   num_parameters = this->callee->parameters.length();
    parameters = new ir_variable *[num_parameters];
 
    /* Generate the declarations for the parameters to our inlined code,
     * and set up the mapping of real function body variables to ours.
     */
    i = 0;
-   exec_list_iterator sig_param_iter = this->callee->parameters.iterator();
-   exec_list_iterator param_iter = this->actual_parameters.iterator();
-   for (i = 0; i < num_parameters; i++) {
-      ir_variable *sig_param = (ir_variable *) sig_param_iter.get();
-      ir_rvalue *param = (ir_rvalue *) param_iter.get();
+   foreach_two_lists(formal_node, &this->callee->parameters,
+                     actual_node, &this->actual_parameters) {
+      ir_variable *sig_param = (ir_variable *) formal_node;
+      ir_rvalue *param = (ir_rvalue *) actual_node;
 
       /* Generate a new variable for the parameter. */
       if (sig_param->type->contains_opaque()) {
@@ -134,7 +130,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
         parameters[i] = sig_param->clone(ctx, ht);
         parameters[i]->data.mode = ir_var_auto;
 
-        /* Remove the read-only decoration becuase we're going to write
+        /* Remove the read-only decoration because we're going to write
          * directly to this variable.  If the cloned variable is left
          * read-only and the inlined function is inside a loop, the loop
          * analysis code will get confused.
@@ -154,15 +150,13 @@ ir_call::generate_inline(ir_instruction *next_ir)
         next_ir->insert_before(assign);
       }
 
-      sig_param_iter.next();
-      param_iter.next();
+      ++i;
    }
 
    exec_list new_instructions;
 
    /* Generate the inlined body of the function to a new list */
-   foreach_list(n, &callee->body) {
-      ir_instruction *ir = (ir_instruction *) n;
+   foreach_in_list(ir_instruction, ir, &callee->body) {
       ir_instruction *new_ir = ir->clone(ctx, ht);
 
       new_instructions.push_tail(new_ir);
@@ -172,11 +166,10 @@ ir_call::generate_inline(ir_instruction *next_ir)
    /* If any opaque types were passed in, replace any deref of the
     * opaque variable with a deref of the argument.
     */
-   param_iter = this->actual_parameters.iterator();
-   sig_param_iter = this->callee->parameters.iterator();
-   for (i = 0; i < num_parameters; i++) {
-      ir_instruction *const param = (ir_instruction *) param_iter.get();
-      ir_variable *sig_param = (ir_variable *) sig_param_iter.get();
+   foreach_two_lists(formal_node, &this->callee->parameters,
+                     actual_node, &this->actual_parameters) {
+      ir_rvalue *const param = (ir_rvalue *) actual_node;
+      ir_variable *sig_param = (ir_variable *) formal_node;
 
       if (sig_param->type->contains_opaque()) {
         ir_dereference *deref = param->as_dereference();
@@ -184,8 +177,6 @@ ir_call::generate_inline(ir_instruction *next_ir)
         assert(deref);
         do_variable_replacement(&new_instructions, sig_param, deref);
       }
-      param_iter.next();
-      sig_param_iter.next();
    }
 
    /* Now push those new instructions in. */
@@ -195,11 +186,10 @@ ir_call::generate_inline(ir_instruction *next_ir)
     * variables to our own.
     */
    i = 0;
-   param_iter = this->actual_parameters.iterator();
-   sig_param_iter = this->callee->parameters.iterator();
-   for (i = 0; i < num_parameters; i++) {
-      ir_instruction *const param = (ir_instruction *) param_iter.get();
-      const ir_variable *const sig_param = (ir_variable *) sig_param_iter.get();
+   foreach_two_lists(formal_node, &this->callee->parameters,
+                     actual_node, &this->actual_parameters) {
+      ir_rvalue *const param = (ir_rvalue *) actual_node;
+      const ir_variable *const sig_param = (ir_variable *) formal_node;
 
       /* Move our param variable into the actual param if it's an 'out' type. */
       if (parameters[i] && (sig_param->data.mode == ir_var_function_out ||
@@ -212,8 +202,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
         next_ir->insert_before(assign);
       }
 
-      param_iter.next();
-      sig_param_iter.next();
+      ++i;
    }
 
    delete [] parameters;
@@ -349,8 +338,7 @@ ir_variable_replacement_visitor::visit_leave(ir_dereference_record *ir)
 ir_visitor_status
 ir_variable_replacement_visitor::visit_leave(ir_call *ir)
 {
-   foreach_list_safe(n, &ir->actual_parameters) {
-      ir_rvalue *param = (ir_rvalue *) n;
+   foreach_in_list_safe(ir_rvalue, param, &ir->actual_parameters) {
       ir_rvalue *new_param = param;
       replace_rvalue(&new_param);