1 files changed, 497 insertions, 496 deletions
diff --git a/mesalib/src/glsl/loop_analysis.cpp b/mesalib/src/glsl/loop_analysis.cpp
index 91e34da0e..f32b91ce8 100644
--- a/mesalib/src/glsl/loop_analysis.cpp
+++ b/mesalib/src/glsl/loop_analysis.cpp
@@ -1,496 +1,497 @@
-/*
- * 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_types.h"
-#include "loop_analysis.h"
-#include "ir_hierarchical_visitor.h"
-
-static bool is_loop_terminator(ir_if *ir);
-
-static bool all_expression_operands_are_loop_constant(ir_rvalue *,
-						      hash_table *);
-
-static ir_rvalue *get_basic_induction_increment(ir_assignment *, hash_table *);
-
-
-loop_state::loop_state()
-{
-   this->ht = hash_table_ctor(0, hash_table_pointer_hash,
-			      hash_table_pointer_compare);
-   this->mem_ctx = talloc_init("loop state");
-}
-
-
-loop_state::~loop_state()
-{
-   hash_table_dtor(this->ht);
-}
-
-
-loop_variable_state *
-loop_state::insert(ir_loop *ir)
-{
-   loop_variable_state *ls = new(this->mem_ctx) loop_variable_state;
-   hash_table_insert(this->ht, ls, ir);
-
-   return ls;
-}
-
-
-loop_variable_state *
-loop_state::get(const ir_loop *ir)
-{
-   return (loop_variable_state *) hash_table_find(this->ht, ir);
-}
-
-
-loop_variable *
-loop_variable_state::get(const ir_variable *ir)
-{
-   return (loop_variable *) hash_table_find(this->var_hash, ir);
-}
-
-
-loop_variable *
-loop_variable_state::insert(ir_variable *var)
-{
-   void *mem_ctx = talloc_parent(this);
-   loop_variable *lv = talloc_zero(mem_ctx, loop_variable);
-
-   lv->var = var;
-
-   hash_table_insert(this->var_hash, lv, lv->var);
-   this->variables.push_tail(lv);
-
-   return lv;
-}
-
-
-loop_terminator *
-loop_variable_state::insert(ir_if *if_stmt)
-{
-   void *mem_ctx = talloc_parent(this);
-   loop_terminator *t = talloc_zero(mem_ctx, loop_terminator);
-
-   t->ir = if_stmt;
-   this->terminators.push_tail(t);
-
-   return t;
-}
-
-
-class loop_analysis : public ir_hierarchical_visitor {
-public:
-   loop_analysis();
-
-   virtual ir_visitor_status visit(ir_loop_jump *);
-   virtual ir_visitor_status visit(ir_dereference_variable *);
-
-   virtual ir_visitor_status visit_enter(ir_loop *);
-   virtual ir_visitor_status visit_leave(ir_loop *);
-   virtual ir_visitor_status visit_enter(ir_assignment *);
-   virtual ir_visitor_status visit_leave(ir_assignment *);
-   virtual ir_visitor_status visit_enter(ir_if *);
-   virtual ir_visitor_status visit_leave(ir_if *);
-
-   loop_state *loops;
-
-   int if_statement_depth;
-
-   ir_assignment *current_assignment;
-
-   exec_list state;
-};
-
-
-loop_analysis::loop_analysis()
-{
-   this->loops = new loop_state;
-
-   this->if_statement_depth = 0;
-   this->current_assignment = NULL;
-}
-
-
-ir_visitor_status
-loop_analysis::visit(ir_loop_jump *ir)
-{
-   (void) ir;
-
-   assert(!this->state.is_empty());
-
-   loop_variable_state *const ls =
-      (loop_variable_state *) this->state.get_head();
-
-   ls->num_loop_jumps++;
-
-   return visit_continue;
-}
-
-
-ir_visitor_status
-loop_analysis::visit(ir_dereference_variable *ir)
-{
-   /* If we're not somewhere inside a loop, there's nothing to do.
-    */
-   if (this->state.is_empty())
-      return visit_continue;
-
-   loop_variable_state *const ls =
-      (loop_variable_state *) this->state.get_head();
-
-   ir_variable *var = ir->variable_referenced();
-   loop_variable *lv = ls->get(var);
-
-   if (lv == NULL) {
-      lv = ls->insert(var);
-      lv->read_before_write = !this->in_assignee;
-   }
-
-   if (this->in_assignee) {
-      assert(this->current_assignment != NULL);
-
-      lv->conditional_assignment = (this->if_statement_depth > 0)
-	 || (this->current_assignment->condition != NULL);
-
-      if (lv->first_assignment == NULL) {
-	 assert(lv->num_assignments == 0);
-
-	 lv->first_assignment = this->current_assignment;
-      }
-
-      lv->num_assignments++;
-   } else if (lv->first_assignment == this->current_assignment) {
-      /* This catches the case where the variable is used in the RHS of an
-       * assignment where it is also in the LHS.
-       */
-      lv->read_before_write = true;
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_enter(ir_loop *ir)
-{
-   loop_variable_state *ls = this->loops->insert(ir);
-   this->state.push_head(ls);
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_leave(ir_loop *ir)
-{
-   loop_variable_state *const ls =
-      (loop_variable_state *) this->state.pop_head();
-
-
-   foreach_list(node, &ir->body_instructions) {
-      /* Skip over declarations at the start of a loop.
-       */
-      if (((ir_instruction *) node)->as_variable())
-	 continue;
-
-      ir_if *if_stmt = ((ir_instruction *) node)->as_if();
-
-      if ((if_stmt != NULL) && is_loop_terminator(if_stmt))
-	 ls->insert(if_stmt);
-      else
-	 break;
-   }
-
-
-   foreach_list_safe(node, &ls->variables) {
-      loop_variable *lv = (loop_variable *) node;
-
-      /* Move variables that are already marked as being loop constant to
-       * a separate list.  These trivially don't need to be tested.
-       */
-      if (lv->is_loop_constant()) {
-	 lv->remove();
-	 ls->constants.push_tail(lv);
-      }
-   }
-
-   /* Each variable assigned in the loop that isn't already marked as being loop
-    * constant might still be loop constant.  The requirements at this point
-    * are:
-    *
-    *    - Variable is written before it is read.
-    *
-    *    - Only one assignment to the variable.
-    *
-    *    - All operands on the RHS of the assignment are also loop constants.
-    *
-    * The last requirement is the reason for the progress loop.  A variable
-    * marked as a loop constant on one pass may allow other variables to be
-    * marked as loop constant on following passes.
-    */
-   bool progress;
-   do {
-      progress = false;
-
-      foreach_list_safe(node, &ls->variables) {
-	 loop_variable *lv = (loop_variable *) node;
-
-	 if (lv->conditional_assignment || (lv->num_assignments > 1))
-	    continue;
-
-	 /* Process the RHS of the assignment.  If all of the variables
-	  * accessed there are loop constants, then add this
-	  */
-	 ir_rvalue *const rhs = lv->first_assignment->rhs;
-	 if (all_expression_operands_are_loop_constant(rhs, ls->var_hash)) {
-	    lv->rhs_clean = true;
-
-	    if (lv->is_loop_constant()) {
-	       progress = true;
-
-	       lv->remove();
-	       ls->constants.push_tail(lv);
-	    }
-	 }
-      }
-   } while (progress);
-
-   /* The remaining variables that are not loop invariant might be loop
-    * induction variables.
-    */
-   foreach_list_safe(node, &ls->variables) {
-      loop_variable *lv = (loop_variable *) node;
-
-      /* If there is more than one assignment to a variable, it cannot be a
-       * loop induction variable.  This isn't strictly true, but this is a
-       * very simple induction variable detector, and it can't handle more
-       * complex cases.
-       */
-      if (lv->num_assignments > 1)
-	 continue;
-
-      /* All of the variables with zero assignments in the loop are loop
-       * invariant, and they should have already been filtered out.
-       */
-      assert(lv->num_assignments == 1);
-      assert(lv->first_assignment != NULL);
-
-      /* The assignmnet to the variable in the loop must be unconditional.
-       */
-      if (lv->conditional_assignment)
-	 continue;
-
-      /* Basic loop induction variables have a single assignment in the loop
-       * that has the form 'VAR = VAR + i' or 'VAR = VAR - i' where i is a
-       * loop invariant.
-       */
-      ir_rvalue *const inc =
-	 get_basic_induction_increment(lv->first_assignment, ls->var_hash);
-      if (inc != NULL) {
-	 lv->iv_scale = NULL;
-	 lv->biv = lv->var;
-	 lv->increment = inc;
-
-	 lv->remove();
-	 ls->induction_variables.push_tail(lv);
-      }
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_enter(ir_if *ir)
-{
-   (void) ir;
-
-   if (!this->state.is_empty())
-      this->if_statement_depth++;
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_leave(ir_if *ir)
-{
-   (void) ir;
-
-   if (!this->state.is_empty())
-      this->if_statement_depth--;
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_enter(ir_assignment *ir)
-{
-   /* If we're not somewhere inside a loop, there's nothing to do.
-    */
-   if (this->state.is_empty())
-      return visit_continue_with_parent;
-
-   this->current_assignment = ir;
-
-   return visit_continue;
-}
-
-ir_visitor_status
-loop_analysis::visit_leave(ir_assignment *ir)
-{
-   /* Since the visit_enter exits with visit_continue_with_parent for this
-    * case, the loop state stack should never be empty here.
-    */
-   assert(!this->state.is_empty());
-
-   assert(this->current_assignment == ir);
-   this->current_assignment = NULL;
-
-   return visit_continue;
-}
-
-
-class examine_rhs : public ir_hierarchical_visitor {
-public:
-   examine_rhs(hash_table *loop_variables)
-   {
-      this->only_uses_loop_constants = true;
-      this->loop_variables = loop_variables;
-   }
-
-   virtual ir_visitor_status visit(ir_dereference_variable *ir)
-   {
-      loop_variable *lv =
-	 (loop_variable *) hash_table_find(this->loop_variables, ir->var);
-
-      assert(lv != NULL);
-
-      if (lv->is_loop_constant()) {
-	 return visit_continue;
-      } else {
-	 this->only_uses_loop_constants = false;
-	 return visit_stop;
-      }
-   }
-
-   hash_table *loop_variables;
-   bool only_uses_loop_constants;
-};
-
-
-bool
-all_expression_operands_are_loop_constant(ir_rvalue *ir, hash_table *variables)
-{
-   examine_rhs v(variables);
-
-   ir->accept(&v);
-
-   return v.only_uses_loop_constants;
-}
-
-
-ir_rvalue *
-get_basic_induction_increment(ir_assignment *ir, hash_table *var_hash)
-{
-   /* The RHS must be a binary expression.
-    */
-   ir_expression *const rhs = ir->rhs->as_expression();
-   if ((rhs == NULL)
-       || ((rhs->operation != ir_binop_add)
-	   && (rhs->operation != ir_binop_sub)))
-      return NULL;
-
-   /* One of the of operands of the expression must be the variable assigned.
-    * If the operation is subtraction, the variable in question must be the
-    * "left" operand.
-    */
-   ir_variable *const var = ir->lhs->variable_referenced();
-
-   ir_variable *const op0 = rhs->operands[0]->variable_referenced();
-   ir_variable *const op1 = rhs->operands[1]->variable_referenced();
-
-   if (((op0 != var) && (op1 != var))
-       || ((op1 == var) && (rhs->operation == ir_binop_sub)))
-      return NULL;
-
-   ir_rvalue *inc = (op0 == var) ? rhs->operands[1] : rhs->operands[0];
-
-   if (inc->as_constant() == NULL) {
-      ir_variable *const inc_var = inc->variable_referenced();
-      if (inc_var != NULL) {
-	 loop_variable *lv =
-	    (loop_variable *) hash_table_find(var_hash, inc_var);
-
-	 if (!lv->is_loop_constant())
-	    inc = NULL;
-      } else
-	 inc = NULL;
-   }
-
-   if ((inc != NULL) && (rhs->operation == ir_binop_sub)) {
-      void *mem_ctx = talloc_parent(ir);
-
-      inc = new(mem_ctx) ir_expression(ir_unop_neg,
-				       inc->type,
-				       inc->clone(mem_ctx, NULL),
-				       NULL);
-   }
-
-   return inc;
-}
-
-
-/**
- * Detect whether an if-statement is a loop terminating condition
- *
- * Detects if-statements of the form
- *
- *  (if (expression bool ...) (break))
- */
-bool
-is_loop_terminator(ir_if *ir)
-{
-   if (!ir->else_instructions.is_empty())
-      return false;
-
-   ir_instruction *const inst =
-      (ir_instruction *) ir->then_instructions.get_head();
-   assert(inst != NULL);
-
-   if (inst->ir_type != ir_type_loop_jump)
-      return false;
-
-   ir_loop_jump *const jump = (ir_loop_jump *) inst;
-   if (jump->mode != ir_loop_jump::jump_break)
-      return false;
-
-   return true;
-}
-
-
-loop_state *
-analyze_loop_variables(exec_list *instructions)
-{
-   loop_analysis v;
-
-   v.run(instructions);
-   return v.loops;
-}
+/*
+ * 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_types.h"
+#include "loop_analysis.h"
+#include "ir_hierarchical_visitor.h"
+
+static bool is_loop_terminator(ir_if *ir);
+
+static bool all_expression_operands_are_loop_constant(ir_rvalue *,
+						      hash_table *);
+
+static ir_rvalue *get_basic_induction_increment(ir_assignment *, hash_table *);
+
+
+loop_state::loop_state()
+{
+   this->ht = hash_table_ctor(0, hash_table_pointer_hash,
+			      hash_table_pointer_compare);
+   this->mem_ctx = talloc_init("loop state");
+}
+
+
+loop_state::~loop_state()
+{
+   hash_table_dtor(this->ht);
+   talloc_free(this->mem_ctx);
+}
+
+
+loop_variable_state *
+loop_state::insert(ir_loop *ir)
+{
+   loop_variable_state *ls = new(this->mem_ctx) loop_variable_state;
+   hash_table_insert(this->ht, ls, ir);
+
+   return ls;
+}
+
+
+loop_variable_state *
+loop_state::get(const ir_loop *ir)
+{
+   return (loop_variable_state *) hash_table_find(this->ht, ir);
+}
+
+
+loop_variable *
+loop_variable_state::get(const ir_variable *ir)
+{
+   return (loop_variable *) hash_table_find(this->var_hash, ir);
+}
+
+
+loop_variable *
+loop_variable_state::insert(ir_variable *var)
+{
+   void *mem_ctx = talloc_parent(this);
+   loop_variable *lv = talloc_zero(mem_ctx, loop_variable);
+
+   lv->var = var;
+
+   hash_table_insert(this->var_hash, lv, lv->var);
+   this->variables.push_tail(lv);
+
+   return lv;
+}
+
+
+loop_terminator *
+loop_variable_state::insert(ir_if *if_stmt)
+{
+   void *mem_ctx = talloc_parent(this);
+   loop_terminator *t = talloc_zero(mem_ctx, loop_terminator);
+
+   t->ir = if_stmt;
+   this->terminators.push_tail(t);
+
+   return t;
+}
+
+
+class loop_analysis : public ir_hierarchical_visitor {
+public:
+   loop_analysis();
+
+   virtual ir_visitor_status visit(ir_loop_jump *);
+   virtual ir_visitor_status visit(ir_dereference_variable *);
+
+   virtual ir_visitor_status visit_enter(ir_loop *);
+   virtual ir_visitor_status visit_leave(ir_loop *);
+   virtual ir_visitor_status visit_enter(ir_assignment *);
+   virtual ir_visitor_status visit_leave(ir_assignment *);
+   virtual ir_visitor_status visit_enter(ir_if *);
+   virtual ir_visitor_status visit_leave(ir_if *);
+
+   loop_state *loops;
+
+   int if_statement_depth;
+
+   ir_assignment *current_assignment;
+
+   exec_list state;
+};
+
+
+loop_analysis::loop_analysis()
+{
+   this->loops = new loop_state;
+
+   this->if_statement_depth = 0;
+   this->current_assignment = NULL;
+}
+
+
+ir_visitor_status
+loop_analysis::visit(ir_loop_jump *ir)
+{
+   (void) ir;
+
+   assert(!this->state.is_empty());
+
+   loop_variable_state *const ls =
+      (loop_variable_state *) this->state.get_head();
+
+   ls->num_loop_jumps++;
+
+   return visit_continue;
+}
+
+
+ir_visitor_status
+loop_analysis::visit(ir_dereference_variable *ir)
+{
+   /* If we're not somewhere inside a loop, there's nothing to do.
+    */
+   if (this->state.is_empty())
+      return visit_continue;
+
+   loop_variable_state *const ls =
+      (loop_variable_state *) this->state.get_head();
+
+   ir_variable *var = ir->variable_referenced();
+   loop_variable *lv = ls->get(var);
+
+   if (lv == NULL) {
+      lv = ls->insert(var);
+      lv->read_before_write = !this->in_assignee;
+   }
+
+   if (this->in_assignee) {
+      assert(this->current_assignment != NULL);
+
+      lv->conditional_assignment = (this->if_statement_depth > 0)
+	 || (this->current_assignment->condition != NULL);
+
+      if (lv->first_assignment == NULL) {
+	 assert(lv->num_assignments == 0);
+
+	 lv->first_assignment = this->current_assignment;
+      }
+
+      lv->num_assignments++;
+   } else if (lv->first_assignment == this->current_assignment) {
+      /* This catches the case where the variable is used in the RHS of an
+       * assignment where it is also in the LHS.
+       */
+      lv->read_before_write = true;
+   }
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_enter(ir_loop *ir)
+{
+   loop_variable_state *ls = this->loops->insert(ir);
+   this->state.push_head(ls);
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_leave(ir_loop *ir)
+{
+   loop_variable_state *const ls =
+      (loop_variable_state *) this->state.pop_head();
+
+
+   foreach_list(node, &ir->body_instructions) {
+      /* Skip over declarations at the start of a loop.
+       */
+      if (((ir_instruction *) node)->as_variable())
+	 continue;
+
+      ir_if *if_stmt = ((ir_instruction *) node)->as_if();
+
+      if ((if_stmt != NULL) && is_loop_terminator(if_stmt))
+	 ls->insert(if_stmt);
+      else
+	 break;
+   }
+
+
+   foreach_list_safe(node, &ls->variables) {
+      loop_variable *lv = (loop_variable *) node;
+
+      /* Move variables that are already marked as being loop constant to
+       * a separate list.  These trivially don't need to be tested.
+       */
+      if (lv->is_loop_constant()) {
+	 lv->remove();
+	 ls->constants.push_tail(lv);
+      }
+   }
+
+   /* Each variable assigned in the loop that isn't already marked as being loop
+    * constant might still be loop constant.  The requirements at this point
+    * are:
+    *
+    *    - Variable is written before it is read.
+    *
+    *    - Only one assignment to the variable.
+    *
+    *    - All operands on the RHS of the assignment are also loop constants.
+    *
+    * The last requirement is the reason for the progress loop.  A variable
+    * marked as a loop constant on one pass may allow other variables to be
+    * marked as loop constant on following passes.
+    */
+   bool progress;
+   do {
+      progress = false;
+
+      foreach_list_safe(node, &ls->variables) {
+	 loop_variable *lv = (loop_variable *) node;
+
+	 if (lv->conditional_assignment || (lv->num_assignments > 1))
+	    continue;
+
+	 /* Process the RHS of the assignment.  If all of the variables
+	  * accessed there are loop constants, then add this
+	  */
+	 ir_rvalue *const rhs = lv->first_assignment->rhs;
+	 if (all_expression_operands_are_loop_constant(rhs, ls->var_hash)) {
+	    lv->rhs_clean = true;
+
+	    if (lv->is_loop_constant()) {
+	       progress = true;
+
+	       lv->remove();
+	       ls->constants.push_tail(lv);
+	    }
+	 }
+      }
+   } while (progress);
+
+   /* The remaining variables that are not loop invariant might be loop
+    * induction variables.
+    */
+   foreach_list_safe(node, &ls->variables) {
+      loop_variable *lv = (loop_variable *) node;
+
+      /* If there is more than one assignment to a variable, it cannot be a
+       * loop induction variable.  This isn't strictly true, but this is a
+       * very simple induction variable detector, and it can't handle more
+       * complex cases.
+       */
+      if (lv->num_assignments > 1)
+	 continue;
+
+      /* All of the variables with zero assignments in the loop are loop
+       * invariant, and they should have already been filtered out.
+       */
+      assert(lv->num_assignments == 1);
+      assert(lv->first_assignment != NULL);
+
+      /* The assignmnet to the variable in the loop must be unconditional.
+       */
+      if (lv->conditional_assignment)
+	 continue;
+
+      /* Basic loop induction variables have a single assignment in the loop
+       * that has the form 'VAR = VAR + i' or 'VAR = VAR - i' where i is a
+       * loop invariant.
+       */
+      ir_rvalue *const inc =
+	 get_basic_induction_increment(lv->first_assignment, ls->var_hash);
+      if (inc != NULL) {
+	 lv->iv_scale = NULL;
+	 lv->biv = lv->var;
+	 lv->increment = inc;
+
+	 lv->remove();
+	 ls->induction_variables.push_tail(lv);
+      }
+   }
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_enter(ir_if *ir)
+{
+   (void) ir;
+
+   if (!this->state.is_empty())
+      this->if_statement_depth++;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_leave(ir_if *ir)
+{
+   (void) ir;
+
+   if (!this->state.is_empty())
+      this->if_statement_depth--;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_enter(ir_assignment *ir)
+{
+   /* If we're not somewhere inside a loop, there's nothing to do.
+    */
+   if (this->state.is_empty())
+      return visit_continue_with_parent;
+
+   this->current_assignment = ir;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+loop_analysis::visit_leave(ir_assignment *ir)
+{
+   /* Since the visit_enter exits with visit_continue_with_parent for this
+    * case, the loop state stack should never be empty here.
+    */
+   assert(!this->state.is_empty());
+
+   assert(this->current_assignment == ir);
+   this->current_assignment = NULL;
+
+   return visit_continue;
+}
+
+
+class examine_rhs : public ir_hierarchical_visitor {
+public:
+   examine_rhs(hash_table *loop_variables)
+   {
+      this->only_uses_loop_constants = true;
+      this->loop_variables = loop_variables;
+   }
+
+   virtual ir_visitor_status visit(ir_dereference_variable *ir)
+   {
+      loop_variable *lv =
+	 (loop_variable *) hash_table_find(this->loop_variables, ir->var);
+
+      assert(lv != NULL);
+
+      if (lv->is_loop_constant()) {
+	 return visit_continue;
+      } else {
+	 this->only_uses_loop_constants = false;
+	 return visit_stop;
+      }
+   }
+
+   hash_table *loop_variables;
+   bool only_uses_loop_constants;
+};
+
+
+bool
+all_expression_operands_are_loop_constant(ir_rvalue *ir, hash_table *variables)
+{
+   examine_rhs v(variables);
+
+   ir->accept(&v);
+
+   return v.only_uses_loop_constants;
+}
+
+
+ir_rvalue *
+get_basic_induction_increment(ir_assignment *ir, hash_table *var_hash)
+{
+   /* The RHS must be a binary expression.
+    */
+   ir_expression *const rhs = ir->rhs->as_expression();
+   if ((rhs == NULL)
+       || ((rhs->operation != ir_binop_add)
+	   && (rhs->operation != ir_binop_sub)))
+      return NULL;
+
+   /* One of the of operands of the expression must be the variable assigned.
+    * If the operation is subtraction, the variable in question must be the
+    * "left" operand.
+    */
+   ir_variable *const var = ir->lhs->variable_referenced();
+
+   ir_variable *const op0 = rhs->operands[0]->variable_referenced();
+   ir_variable *const op1 = rhs->operands[1]->variable_referenced();
+
+   if (((op0 != var) && (op1 != var))
+       || ((op1 == var) && (rhs->operation == ir_binop_sub)))
+      return NULL;
+
+   ir_rvalue *inc = (op0 == var) ? rhs->operands[1] : rhs->operands[0];
+
+   if (inc->as_constant() == NULL) {
+      ir_variable *const inc_var = inc->variable_referenced();
+      if (inc_var != NULL) {
+	 loop_variable *lv =
+	    (loop_variable *) hash_table_find(var_hash, inc_var);
+
+	 if (!lv->is_loop_constant())
+	    inc = NULL;
+      } else
+	 inc = NULL;
+   }
+
+   if ((inc != NULL) && (rhs->operation == ir_binop_sub)) {
+      void *mem_ctx = talloc_parent(ir);
+
+      inc = new(mem_ctx) ir_expression(ir_unop_neg,
+				       inc->type,
+				       inc->clone(mem_ctx, NULL),
+				       NULL);
+   }
+
+   return inc;
+}
+
+
+/**
+ * Detect whether an if-statement is a loop terminating condition
+ *
+ * Detects if-statements of the form
+ *
+ *  (if (expression bool ...) (break))
+ */
+bool
+is_loop_terminator(ir_if *ir)
+{
+   if (!ir->else_instructions.is_empty())
+      return false;
+
+   ir_instruction *const inst =
+      (ir_instruction *) ir->then_instructions.get_head();
+   assert(inst != NULL);
+
+   if (inst->ir_type != ir_type_loop_jump)
+      return false;
+
+   ir_loop_jump *const jump = (ir_loop_jump *) inst;
+   if (jump->mode != ir_loop_jump::jump_break)
+      return false;
+
+   return true;
+}
+
+
+loop_state *
+analyze_loop_variables(exec_list *instructions)
+{
+   loop_analysis v;
+
+   v.run(instructions);
+   return v.loops;
+}