glsl/loops: Remove unnecessary list walk from loop_control_visitor.

When loop_control_visitor::visit_leave(ir_loop *) is analyzing a loop
terminator that acts on a certain ir_variable, it doesn't need to walk
the list of induction variables to find the loop_variable entry
corresponding to the variable.  It can just look it up in the
loop_variable_state hashtable and verify that the loop_variable entry
represents an induction variable.

Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>

diff --git a/src/glsl/loop_analysis.h b/src/glsl/loop_analysis.h
index 961ea40..8e57dac 100644 (file)
--- a/src/glsl/loop_analysis.h
+++ b/src/glsl/loop_analysis.h
@@ -189,6 +189,15 @@ public:
    ir_rvalue *increment;
 
 
+   inline bool is_induction_var() const
+   {
+      /* Induction variables always have a non-null increment, and vice
+       * versa.
+       */
+      return this->increment != NULL;
+   }
+
+
    inline bool is_loop_constant() const
    {
       const bool is_const = (this->num_assignments == 0)

diff --git a/src/glsl/loop_controls.cpp b/src/glsl/loop_controls.cpp
index a1dc20e..ce05e09 100644 (file)
--- a/src/glsl/loop_controls.cpp
+++ b/src/glsl/loop_controls.cpp
@@ -237,39 +237,36 @@ loop_control_visitor::visit_leave(ir_loop *ir)
 
         ir_rvalue *init = find_initial_value(ir, var);
 
-        foreach_list(iv_node, &ls->induction_variables) {
-           loop_variable *lv = (loop_variable *) iv_node;
-
-           if (lv->var == var) {
-              const int iterations = calculate_iterations(init, limit,
-                                                          lv->increment,
-                                                          cmp);
-              if (iterations >= 0) {
-                 /* If the new iteration count is lower than the previously
-                  * believed iteration count, then add a normative bound to
-                  * this loop.
-                  */
-                 if ((unsigned) iterations < max_iterations) {
-                     ir->normative_bound = iterations;
-
-                    max_iterations = iterations;
-                 }
-
-                 /* Remove the conditional break statement.  The loop
-                  * controls are now set such that the exit condition will be
-                  * satisfied.
-                  */
-                 if_stmt->remove();
-
-                 assert(ls->num_loop_jumps > 0);
-                 ls->num_loop_jumps--;
-
-                 this->progress = true;
-              }
-
-              break;
-           }
-        }
+         loop_variable *lv = ls->get(var);
+         if (lv != NULL && lv->is_induction_var()) {
+            const int iterations = calculate_iterations(init, limit,
+                                                        lv->increment,
+                                                        cmp);
+            if (iterations >= 0) {
+               /* If the new iteration count is lower than the previously
+                * believed iteration count, then add a normative bound to
+                * this loop.
+                */
+               if ((unsigned) iterations < max_iterations) {
+                  ir->normative_bound = iterations;
+
+                  max_iterations = iterations;
+               }
+
+               /* Remove the conditional break statement.  The loop
+                * controls are now set such that the exit condition will be
+                * satisfied.
+                */
+               if_stmt->remove();
+
+               assert(ls->num_loop_jumps > 0);
+               ls->num_loop_jumps--;
+
+               this->progress = true;
+            }
+
+            break;
+         }
         break;
       }