Subversion Repositories Kolibri OS

/*

 * Copyright © 2010 Luca Barbieri

 *

 * 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.

 */

/**

 * \file lower_jumps.cpp

 *

 * This pass lowers jumps (break, continue, and return) to if/else structures.

 *

 * It can be asked to:

 * 1. Pull jumps out of ifs where possible

 * 2. Remove all "continue"s, replacing them with an "execute flag"

 * 3. Replace all "break" with a single conditional one at the end of the loop

 * 4. Replace all "return"s with a single return at the end of the function,

 *    for the main function and/or other functions

 *

 * Applying this pass gives several benefits:

 * 1. All functions can be inlined.

 * 2. nv40 and other pre-DX10 chips without "continue" can be supported

 * 3. nv30 and other pre-DX10 chips with no control flow at all are better

 *    supported

 *

 * Continues are lowered by adding a per-loop "execute flag", initialized to

 * true, that when cleared inhibits all execution until the end of the loop.

 *

 * Breaks are lowered to continues, plus setting a "break flag" that is checked

 * at the end of the loop, and trigger the unique "break".

 *

 * Returns are lowered to breaks/continues, plus adding a "return flag" that

 * causes loops to break again out of their enclosing loops until all the

 * loops are exited: then the "execute flag" logic will ignore everything

 * until the end of the function.

 *

 * Note that "continue" and "return" can also be implemented by adding

 * a dummy loop and using break.

 * However, this is bad for hardware with limited nesting depth, and

 * prevents further optimization, and thus is not currently performed.

 */

#include "glsl_types.h"

#include 

#include "ir.h"

/**

 * Enum recording the result of analyzing how control flow might exit

 * an IR node.

 *

 * Each possible value of jump_strength indicates a strictly stronger

 * guarantee on control flow than the previous value.

 *

 * The ordering of strengths roughly reflects the way jumps are

 * lowered: jumps with higher strength tend to be lowered to jumps of

 * lower strength.  Accordingly, strength is used as a heuristic to

 * determine which lowering to perform first.

 *

 * This enum is also used by get_jump_strength() to categorize

 * instructions as either break, continue, return, or other.  When

 * used in this fashion, strength_always_clears_execute_flag is not

 * used.

 *

 * The control flow analysis made by this optimization pass makes two

 * simplifying assumptions:

 *

 * - It ignores discard instructions, since they are lowered by a

 *   separate pass (lower_discard.cpp).

 *

 * - It assumes it is always possible for control to flow from a loop

 *   to the instruction immediately following it.  Technically, this

 *   is not true (since all execution paths through the loop might

 *   jump back to the top, or return from the function).

 *

 * Both of these simplifying assumtions are safe, since they can never

 * cause reachable code to be incorrectly classified as unreachable;

 * they can only do the opposite.

 */

enum jump_strength

{

   /**

    * Analysis has produced no guarantee on how control flow might

    * exit this IR node.  It might fall out the bottom (with or

    * without clearing the execute flag, if present), or it might

    * continue to the top of the innermost enclosing loop, break out

    * of it, or return from the function.

    */

   strength_none,

   /**

    * The only way control can fall out the bottom of this node is

    * through a code path that clears the execute flag.  It might also

    * continue to the top of the innermost enclosing loop, break out

    * of it, or return from the function.

    */

   strength_always_clears_execute_flag,

   /**

    * Control cannot fall out the bottom of this node.  It might

    * continue to the top of the innermost enclosing loop, break out

    * of it, or return from the function.

    */

   strength_continue,

   /**

    * Control cannot fall out the bottom of this node, or continue the

    * top of the innermost enclosing loop.  It can only break out of

    * it or return from the function.

    */

   strength_break,

   /**

    * Control cannot fall out the bottom of this node, continue to the

    * top of the innermost enclosing loop, or break out of it.  It can

    * only return from the function.

    */

   strength_return

};

namespace {

struct block_record

{

   /* minimum jump strength (of lowered IR, not pre-lowering IR)

    *

    * If the block ends with a jump, must be the strength of the jump.

    * Otherwise, the jump would be dead and have been deleted before)

    *

    * If the block doesn't end with a jump, it can be different than strength_none if all paths before it lead to some jump

    * (e.g. an if with a return in one branch, and a break in the other, while not lowering them)

    * Note that identical jumps are usually unified though.

    */

   jump_strength min_strength;

   /* can anything clear the execute flag? */

   bool may_clear_execute_flag;

   block_record()

   {

      this->min_strength = strength_none;

      this->may_clear_execute_flag = false;

   }

};

struct loop_record

{

   ir_function_signature* signature;

   ir_loop* loop;

   /* used to avoid lowering the break used to represent lowered breaks */

   unsigned nesting_depth;

   bool in_if_at_the_end_of_the_loop;

   bool may_set_return_flag;

   ir_variable* break_flag;

   ir_variable* execute_flag; /* cleared to emulate continue */

   loop_record(ir_function_signature* p_signature = 0, ir_loop* p_loop = 0)

   {

      this->signature = p_signature;

      this->loop = p_loop;

      this->nesting_depth = 0;

      this->in_if_at_the_end_of_the_loop = false;

      this->may_set_return_flag = false;

      this->break_flag = 0;

      this->execute_flag = 0;

   }

   ir_variable* get_execute_flag()

   {

      /* also supported for the "function loop" */

      if(!this->execute_flag) {

         exec_list& list = this->loop ? this->loop->body_instructions : signature->body;

         this->execute_flag = new(this->signature) ir_variable(glsl_type::bool_type, "execute_flag", ir_var_temporary);

         list.push_head(new(this->signature) ir_assignment(new(this->signature) ir_dereference_variable(execute_flag), new(this->signature) ir_constant(true), 0));

         list.push_head(this->execute_flag);

      }

      return this->execute_flag;

   }

   ir_variable* get_break_flag()

   {

      assert(this->loop);

      if(!this->break_flag) {

         this->break_flag = new(this->signature) ir_variable(glsl_type::bool_type, "break_flag", ir_var_temporary);

         this->loop->insert_before(this->break_flag);

         this->loop->insert_before(new(this->signature) ir_assignment(new(this->signature) ir_dereference_variable(break_flag), new(this->signature) ir_constant(false), 0));

      }

      return this->break_flag;

   }

};

struct function_record

{

   ir_function_signature* signature;

   ir_variable* return_flag; /* used to break out of all loops and then jump to the return instruction */

   ir_variable* return_value;

   bool lower_return;

   unsigned nesting_depth;

   function_record(ir_function_signature* p_signature = 0,

                   bool lower_return = false)

   {

      this->signature = p_signature;

      this->return_flag = 0;

      this->return_value = 0;

      this->nesting_depth = 0;

      this->lower_return = lower_return;

   }

   ir_variable* get_return_flag()

   {

      if(!this->return_flag) {

         this->return_flag = new(this->signature) ir_variable(glsl_type::bool_type, "return_flag", ir_var_temporary);

         this->signature->body.push_head(new(this->signature) ir_assignment(new(this->signature) ir_dereference_variable(return_flag), new(this->signature) ir_constant(false), 0));

         this->signature->body.push_head(this->return_flag);

      }

      return this->return_flag;

   }

   ir_variable* get_return_value()

   {

      if(!this->return_value) {

         assert(!this->signature->return_type->is_void());

         return_value = new(this->signature) ir_variable(this->signature->return_type, "return_value", ir_var_temporary);

         this->signature->body.push_head(this->return_value);

      }

      return this->return_value;

   }

};

struct ir_lower_jumps_visitor : public ir_control_flow_visitor {

   /* Postconditions: on exit of any visit() function:

    *

    * ANALYSIS: this->block.min_strength,

    * this->block.may_clear_execute_flag, and

    * this->loop.may_set_return_flag are updated to reflect the

    * characteristics of the visited statement.

    *

    * DEAD_CODE_ELIMINATION: If this->block.min_strength is not

    * strength_none, the visited node is at the end of its exec_list.

    * In other words, any unreachable statements that follow the

    * visited statement in its exec_list have been removed.

    *

    * CONTAINED_JUMPS_LOWERED: If the visited statement contains other

    * statements, then should_lower_jump() is false for all of the

    * return, break, or continue statements it contains.

    *

    * Note that visiting a jump does not lower it.  That is the

    * responsibility of the statement (or function signature) that

    * contains the jump.

    */

   bool progress;

   struct function_record function;

   struct loop_record loop;

   struct block_record block;

   bool pull_out_jumps;

   bool lower_continue;

   bool lower_break;

   bool lower_sub_return;

   bool lower_main_return;

   ir_lower_jumps_visitor()

      : progress(false),

        pull_out_jumps(false),

        lower_continue(false),

        lower_break(false),

        lower_sub_return(false),

        lower_main_return(false)

   {

   }

   void truncate_after_instruction(exec_node *ir)

   {

      if (!ir)

         return;

      while (!ir->get_next()->is_tail_sentinel()) {

         ((ir_instruction *)ir->get_next())->remove();

         this->progress = true;

      }

   }

   void move_outer_block_inside(ir_instruction *ir, exec_list *inner_block)

   {

      while (!ir->get_next()->is_tail_sentinel()) {

         ir_instruction *move_ir = (ir_instruction *)ir->get_next();

         move_ir->remove();

         inner_block->push_tail(move_ir);

      }

   }

   /**

    * Insert the instructions necessary to lower a return statement,

    * before the given return instruction.

    */

   void insert_lowered_return(ir_return *ir)

   {

      ir_variable* return_flag = this->function.get_return_flag();

      if(!this->function.signature->return_type->is_void()) {

         ir_variable* return_value = this->function.get_return_value();

         ir->insert_before(

            new(ir) ir_assignment(

               new (ir) ir_dereference_variable(return_value),

               ir->value));

      }

      ir->insert_before(

         new(ir) ir_assignment(

            new (ir) ir_dereference_variable(return_flag),

            new (ir) ir_constant(true)));

      this->loop.may_set_return_flag = true;

   }

   /**

    * If the given instruction is a return, lower it to instructions

    * that store the return value (if there is one), set the return

    * flag, and then break.

    *

    * It is safe to pass NULL to this function.

    */

   void lower_return_unconditionally(ir_instruction *ir)

   {

      if (get_jump_strength(ir) != strength_return) {

         return;

      }

      insert_lowered_return((ir_return*)ir);

      ir->replace_with(new(ir) ir_loop_jump(ir_loop_jump::jump_break));

   }

   /**

    * Create the necessary instruction to replace a break instruction.

    */

   ir_instruction *create_lowered_break()

   {

      void *ctx = this->function.signature;

      return new(ctx) ir_assignment(

          new(ctx) ir_dereference_variable(this->loop.get_break_flag()),

          new(ctx) ir_constant(true),

          0);

   }

   /**

    * If the given instruction is a break, lower it to an instruction

    * that sets the break flag, without consulting

    * should_lower_jump().

    *

    * It is safe to pass NULL to this function.

    */

   void lower_break_unconditionally(ir_instruction *ir)

   {

      if (get_jump_strength(ir) != strength_break) {

         return;

      }

      ir->replace_with(create_lowered_break());

   }

   /**

    * If the block ends in a conditional or unconditional break, lower

    * it, even though should_lower_jump() says it needn't be lowered.

    */

   void lower_final_breaks(exec_list *block)

   {

      ir_instruction *ir = (ir_instruction *) block->get_tail();

      lower_break_unconditionally(ir);

      ir_if *ir_if = ir->as_if();

      if (ir_if) {

          lower_break_unconditionally(

              (ir_instruction *) ir_if->then_instructions.get_tail());

          lower_break_unconditionally(

              (ir_instruction *) ir_if->else_instructions.get_tail());

      }

   }

   virtual void visit(class ir_loop_jump * ir)

   {

      /* Eliminate all instructions after each one, since they are

       * unreachable.  This satisfies the DEAD_CODE_ELIMINATION

       * postcondition.

       */

      truncate_after_instruction(ir);

      /* Set this->block.min_strength based on this instruction.  This

       * satisfies the ANALYSIS postcondition.  It is not necessary to

       * update this->block.may_clear_execute_flag or

       * this->loop.may_set_return_flag, because an unlowered jump

       * instruction can't change any flags.

       */

      this->block.min_strength = ir->is_break() ? strength_break : strength_continue;

      /* The CONTAINED_JUMPS_LOWERED postcondition is already

       * satisfied, because jump statements can't contain other

       * statements.

       */

   }

   virtual void visit(class ir_return * ir)

   {

      /* Eliminate all instructions after each one, since they are

       * unreachable.  This satisfies the DEAD_CODE_ELIMINATION

       * postcondition.

       */

      truncate_after_instruction(ir);

      /* Set this->block.min_strength based on this instruction.  This

       * satisfies the ANALYSIS postcondition.  It is not necessary to

       * update this->block.may_clear_execute_flag or

       * this->loop.may_set_return_flag, because an unlowered return

       * instruction can't change any flags.

       */

      this->block.min_strength = strength_return;

      /* The CONTAINED_JUMPS_LOWERED postcondition is already

       * satisfied, because jump statements can't contain other

       * statements.

       */

   }

   virtual void visit(class ir_discard * ir)

   {

      /* Nothing needs to be done.  The ANALYSIS and

       * DEAD_CODE_ELIMINATION postconditions are already satisfied,

       * because discard statements are ignored by this optimization

       * pass.  The CONTAINED_JUMPS_LOWERED postcondition is already

       * satisfied, because discard statements can't contain other

       * statements.

       */

      (void) ir;

   }

   enum jump_strength get_jump_strength(ir_instruction* ir)

   {

      if(!ir)

         return strength_none;

      else if(ir->ir_type == ir_type_loop_jump) {

         if(((ir_loop_jump*)ir)->is_break())

            return strength_break;

         else

            return strength_continue;

      } else if(ir->ir_type == ir_type_return)

         return strength_return;

      else

         return strength_none;

   }

   bool should_lower_jump(ir_jump* ir)

   {

      unsigned strength = get_jump_strength(ir);

      bool lower;

      switch(strength)

      {

      case strength_none:

         lower = false; /* don't change this, code relies on it */

         break;

      case strength_continue:

         lower = lower_continue;

         break;

      case strength_break:

         assert(this->loop.loop);

         /* never lower "canonical break" */

         if(ir->get_next()->is_tail_sentinel() && (this->loop.nesting_depth == 0

               || (this->loop.nesting_depth == 1 && this->loop.in_if_at_the_end_of_the_loop)))

            lower = false;

         else

            lower = lower_break;

         break;

      case strength_return:

         /* never lower return at the end of a this->function */

         if(this->function.nesting_depth == 0 && ir->get_next()->is_tail_sentinel())

            lower = false;

         else

            lower = this->function.lower_return;

         break;

      }

      return lower;

   }

   block_record visit_block(exec_list* list)

   {

      /* Note: since visiting a node may change that node's next

       * pointer, we can't use visit_exec_list(), because

       * visit_exec_list() caches the node's next pointer before

       * visiting it.  So we use foreach_in_list() instead.

       *

       * foreach_in_list() isn't safe if the node being visited gets

       * removed, but fortunately this visitor doesn't do that.

       */

      block_record saved_block = this->block;

      this->block = block_record();

      foreach_in_list(ir_instruction, node, list) {

         node->accept(this);

      }

      block_record ret = this->block;

      this->block = saved_block;

      return ret;

   }

   virtual void visit(ir_if *ir)

   {

      if(this->loop.nesting_depth == 0 && ir->get_next()->is_tail_sentinel())

         this->loop.in_if_at_the_end_of_the_loop = true;

      ++this->function.nesting_depth;

      ++this->loop.nesting_depth;

      block_record block_records[2];

      ir_jump* jumps[2];

      /* Recursively lower nested jumps.  This satisfies the

       * CONTAINED_JUMPS_LOWERED postcondition, except in the case of

       * unconditional jumps at the end of ir->then_instructions and

       * ir->else_instructions, which are handled below.

       */

      block_records[0] = visit_block(&ir->then_instructions);

      block_records[1] = visit_block(&ir->else_instructions);

retry: /* we get here if we put code after the if inside a branch */

      /* Determine which of ir->then_instructions and

       * ir->else_instructions end with an unconditional jump.

       */

      for(unsigned i = 0; i < 2; ++i) {

         exec_list& list = i ? ir->else_instructions : ir->then_instructions;

         jumps[i] = 0;

         if(!list.is_empty() && get_jump_strength((ir_instruction*)list.get_tail()))

            jumps[i] = (ir_jump*)list.get_tail();

      }

      /* Loop until we have satisfied the CONTAINED_JUMPS_LOWERED

       * postcondition by lowering jumps in both then_instructions and

       * else_instructions.

       */

      for(;;) {

         /* Determine the types of the jumps that terminate

          * ir->then_instructions and ir->else_instructions.

          */

         jump_strength jump_strengths[2];

         for(unsigned i = 0; i < 2; ++i) {

            if(jumps[i]) {

               jump_strengths[i] = block_records[i].min_strength;

               assert(jump_strengths[i] == get_jump_strength(jumps[i]));

            } else

               jump_strengths[i] = strength_none;

         }

         /* If both code paths end in a jump, and the jumps are the

          * same, and we are pulling out jumps, replace them with a

          * single jump that comes after the if instruction.  The new

          * jump will be visited next, and it will be lowered if

          * necessary by the loop or conditional that encloses it.

          */

         if(pull_out_jumps && jump_strengths[0] == jump_strengths[1]) {

            bool unify = true;

            if(jump_strengths[0] == strength_continue)

               ir->insert_after(new(ir) ir_loop_jump(ir_loop_jump::jump_continue));

            else if(jump_strengths[0] == strength_break)

               ir->insert_after(new(ir) ir_loop_jump(ir_loop_jump::jump_break));

            /* FINISHME: unify returns with identical expressions */

            else if(jump_strengths[0] == strength_return && this->function.signature->return_type->is_void())

               ir->insert_after(new(ir) ir_return(NULL));

	    else

	       unify = false;

            if(unify) {

               jumps[0]->remove();

               jumps[1]->remove();

               this->progress = true;

               /* Update jumps[] to reflect the fact that the jumps

                * are gone, and update block_records[] to reflect the

                * fact that control can now flow to the next

                * instruction.

                */

               jumps[0] = 0;

               jumps[1] = 0;

               block_records[0].min_strength = strength_none;

               block_records[1].min_strength = strength_none;

               /* The CONTAINED_JUMPS_LOWERED postcondition is now

                * satisfied, so we can break out of the loop.

                */

               break;

            }

         }

         /* lower a jump: if both need to lowered, start with the strongest one, so that

          * we might later unify the lowered version with the other one

          */

         bool should_lower[2];

         for(unsigned i = 0; i < 2; ++i)

            should_lower[i] = should_lower_jump(jumps[i]);

         int lower;

         if(should_lower[1] && should_lower[0])

            lower = jump_strengths[1] > jump_strengths[0];

         else if(should_lower[0])

            lower = 0;

         else if(should_lower[1])

            lower = 1;

         else

            /* Neither code path ends in a jump that needs to be

             * lowered, so the CONTAINED_JUMPS_LOWERED postcondition

             * is satisfied and we can break out of the loop.

             */

            break;

         if(jump_strengths[lower] == strength_return) {

            /* To lower a return, we create a return flag (if the

             * function doesn't have one already) and add instructions

             * that: 1. store the return value (if this function has a

             * non-void return) and 2. set the return flag

             */

            insert_lowered_return((ir_return*)jumps[lower]);

            if(this->loop.loop) {

               /* If we are in a loop, replace the return instruction

                * with a break instruction, and then loop so that the

                * break instruction can be lowered if necessary.

                */

               ir_loop_jump* lowered = 0;

               lowered = new(ir) ir_loop_jump(ir_loop_jump::jump_break);

               /* Note: we must update block_records and jumps to

                * reflect the fact that the control path has been

                * altered from a return to a break.

                */

               block_records[lower].min_strength = strength_break;

               jumps[lower]->replace_with(lowered);

               jumps[lower] = lowered;

            } else {

               /* If we are not in a loop, we then proceed as we would

                * for a continue statement (set the execute flag to

                * false to prevent the rest of the function from

                * executing).

                */

               goto lower_continue;

            }

            this->progress = true;

         } else if(jump_strengths[lower] == strength_break) {

            /* To lower a break, we create a break flag (if the loop

             * doesn't have one already) and add an instruction that

             * sets it.

             *

             * Then we proceed as we would for a continue statement

             * (set the execute flag to false to prevent the rest of

             * the loop body from executing).

             *

             * The visit() function for the loop will ensure that the

             * break flag is checked after executing the loop body.

             */

            jumps[lower]->insert_before(create_lowered_break());

            goto lower_continue;

         } else if(jump_strengths[lower] == strength_continue) {

lower_continue:

            /* To lower a continue, we create an execute flag (if the

             * loop doesn't have one already) and replace the continue

             * with an instruction that clears it.

             *

             * Note that this code path gets exercised when lowering

             * return statements that are not inside a loop, so

             * this->loop must be initialized even outside of loops.

             */

            ir_variable* execute_flag = this->loop.get_execute_flag();

            jumps[lower]->replace_with(new(ir) ir_assignment(new (ir) ir_dereference_variable(execute_flag), new (ir) ir_constant(false), 0));

            /* Note: we must update block_records and jumps to reflect

             * the fact that the control path has been altered to an

             * instruction that clears the execute flag.

             */

            jumps[lower] = 0;

            block_records[lower].min_strength = strength_always_clears_execute_flag;

            block_records[lower].may_clear_execute_flag = true;

            this->progress = true;

            /* Let the loop run again, in case the other branch of the

             * if needs to be lowered too.

             */

         }

      }

      /* move out a jump out if possible */

      if(pull_out_jumps) {

         /* If one of the branches ends in a jump, and control cannot

          * fall out the bottom of the other branch, then we can move

          * the jump after the if.

          *

          * Set move_out to the branch we are moving a jump out of.

          */

         int move_out = -1;

         if(jumps[0] && block_records[1].min_strength >= strength_continue)

            move_out = 0;

         else if(jumps[1] && block_records[0].min_strength >= strength_continue)

            move_out = 1;

         if(move_out >= 0)

         {

            jumps[move_out]->remove();

            ir->insert_after(jumps[move_out]);

            /* Note: we must update block_records and jumps to reflect

             * the fact that the jump has been moved out of the if.

             */

            jumps[move_out] = 0;

            block_records[move_out].min_strength = strength_none;

            this->progress = true;

         }

      }

      /* Now satisfy the ANALYSIS postcondition by setting

       * this->block.min_strength and

       * this->block.may_clear_execute_flag based on the

       * characteristics of the two branches.

       */

      if(block_records[0].min_strength < block_records[1].min_strength)

         this->block.min_strength = block_records[0].min_strength;

      else

         this->block.min_strength = block_records[1].min_strength;

      this->block.may_clear_execute_flag = this->block.may_clear_execute_flag || block_records[0].may_clear_execute_flag || block_records[1].may_clear_execute_flag;

      /* Now we need to clean up the instructions that follow the

       * if.

       *

       * If those instructions are unreachable, then satisfy the

       * DEAD_CODE_ELIMINATION postcondition by eliminating them.

       * Otherwise that postcondition is already satisfied.

       */

      if(this->block.min_strength)

         truncate_after_instruction(ir);

      else if(this->block.may_clear_execute_flag)

      {

         /* If the "if" instruction might clear the execute flag, then

          * we need to guard any instructions that follow so that they

          * are only executed if the execute flag is set.

          *

          * If one of the branches of the "if" always clears the

          * execute flag, and the other branch never clears it, then

          * this is easy: just move all the instructions following the

          * "if" into the branch that never clears it.

          */

         int move_into = -1;

         if(block_records[0].min_strength && !block_records[1].may_clear_execute_flag)

            move_into = 1;

         else if(block_records[1].min_strength && !block_records[0].may_clear_execute_flag)

            move_into = 0;

         if(move_into >= 0) {

            assert(!block_records[move_into].min_strength && !block_records[move_into].may_clear_execute_flag); /* otherwise, we just truncated */

            exec_list* list = move_into ? &ir->else_instructions : &ir->then_instructions;

            exec_node* next = ir->get_next();

            if(!next->is_tail_sentinel()) {

               move_outer_block_inside(ir, list);

               /* If any instructions moved, then we need to visit

                * them (since they are now inside the "if").  Since

                * block_records[move_into] is in its default state

                * (see assertion above), we can safely replace

                * block_records[move_into] with the result of this

                * analysis.

                */

               exec_list list;

               list.head = next;

               block_records[move_into] = visit_block(&list);

               /*

                * Then we need to re-start our jump lowering, since one

                * of the instructions we moved might be a jump that

                * needs to be lowered.

                */

               this->progress = true;

               goto retry;

            }

         } else {

            /* If we get here, then the simple case didn't apply; we

             * need to actually guard the instructions that follow.

             *

             * To avoid creating unnecessarily-deep nesting, first

             * look through the instructions that follow and unwrap

             * any instructions that that are already wrapped in the

             * appropriate guard.

             */

            ir_instruction* ir_after;

            for(ir_after = (ir_instruction*)ir->get_next(); !ir_after->is_tail_sentinel();)

            {

               ir_if* ir_if = ir_after->as_if();

               if(ir_if && ir_if->else_instructions.is_empty()) {

                  ir_dereference_variable* ir_if_cond_deref = ir_if->condition->as_dereference_variable();

                  if(ir_if_cond_deref && ir_if_cond_deref->var == this->loop.execute_flag) {

                     ir_instruction* ir_next = (ir_instruction*)ir_after->get_next();

                     ir_after->insert_before(&ir_if->then_instructions);

                     ir_after->remove();

                     ir_after = ir_next;

                     continue;

                  }

               }

               ir_after = (ir_instruction*)ir_after->get_next();

               /* only set this if we find any unprotected instruction */

               this->progress = true;

            }

            /* Then, wrap all the instructions that follow in a single

             * guard.

             */

            if(!ir->get_next()->is_tail_sentinel()) {

               assert(this->loop.execute_flag);

               ir_if* if_execute = new(ir) ir_if(new(ir) ir_dereference_variable(this->loop.execute_flag));

               move_outer_block_inside(ir, &if_execute->then_instructions);

               ir->insert_after(if_execute);

            }

         }

      }

      --this->loop.nesting_depth;

      --this->function.nesting_depth;

   }

   virtual void visit(ir_loop *ir)

   {

      /* Visit the body of the loop, with a fresh data structure in

       * this->loop so that the analysis we do here won't bleed into

       * enclosing loops.

       *

       * We assume that all code after a loop is reachable from the

       * loop (see comments on enum jump_strength), so the

       * DEAD_CODE_ELIMINATION postcondition is automatically

       * satisfied, as is the block.min_strength portion of the

       * ANALYSIS postcondition.

       *

       * The block.may_clear_execute_flag portion of the ANALYSIS

       * postcondition is automatically satisfied because execute

       * flags do not propagate outside of loops.

       *

       * The loop.may_set_return_flag portion of the ANALYSIS

       * postcondition is handled below.

       */

      ++this->function.nesting_depth;

      loop_record saved_loop = this->loop;

      this->loop = loop_record(this->function.signature, ir);

      /* Recursively lower nested jumps.  This satisfies the

       * CONTAINED_JUMPS_LOWERED postcondition, except in the case of

       * an unconditional continue or return at the bottom of the

       * loop, which are handled below.

       */

      block_record body = visit_block(&ir->body_instructions);

      /* If the loop ends in an unconditional continue, eliminate it

       * because it is redundant.

       */

      ir_instruction *ir_last

         = (ir_instruction *) ir->body_instructions.get_tail();

      if (get_jump_strength(ir_last) == strength_continue) {

         ir_last->remove();

      }

      /* If the loop ends in an unconditional return, and we are

       * lowering returns, lower it.

       */

      if (this->function.lower_return)

         lower_return_unconditionally(ir_last);

      if(body.min_strength >= strength_break) {

         /* FINISHME: If the min_strength of the loop body is

          * strength_break or strength_return, that means that it

          * isn't a loop at all, since control flow always leaves the

          * body of the loop via break or return.  In principle the

          * loop could be eliminated in this case.  This optimization

          * is not implemented yet.

          */

      }

      if(this->loop.break_flag) {

         /* We only get here if we are lowering breaks */

         assert (lower_break);

         /* If a break flag was generated while visiting the body of

          * the loop, then at least one break was lowered, so we need

          * to generate an if statement at the end of the loop that

          * does a "break" if the break flag is set.  The break we

          * generate won't violate the CONTAINED_JUMPS_LOWERED

          * postcondition, because should_lower_jump() always returns

          * false for a break that happens at the end of a loop.

          *

          * However, if the loop already ends in a conditional or

          * unconditional break, then we need to lower that break,

          * because it won't be at the end of the loop anymore.

          */

         lower_final_breaks(&ir->body_instructions);

         ir_if* break_if = new(ir) ir_if(new(ir) ir_dereference_variable(this->loop.break_flag));

         break_if->then_instructions.push_tail(new(ir) ir_loop_jump(ir_loop_jump::jump_break));

         ir->body_instructions.push_tail(break_if);

      }

      /* If the body of the loop may set the return flag, then at

       * least one return was lowered to a break, so we need to ensure

       * that the return flag is checked after the body of the loop is

       * executed.

       */

      if(this->loop.may_set_return_flag) {

         assert(this->function.return_flag);

         /* Generate the if statement to check the return flag */

         ir_if* return_if = new(ir) ir_if(new(ir) ir_dereference_variable(this->function.return_flag));

         /* Note: we also need to propagate the knowledge that the

          * return flag may get set to the outer context.  This

          * satisfies the loop.may_set_return_flag part of the

          * ANALYSIS postcondition.

          */

         saved_loop.may_set_return_flag = true;

         if(saved_loop.loop)

            /* If this loop is nested inside another one, then the if

             * statement that we generated should break out of that

             * loop if the return flag is set.  Caller will lower that

             * break statement if necessary.

             */

            return_if->then_instructions.push_tail(new(ir) ir_loop_jump(ir_loop_jump::jump_break));

         else

            /* Otherwise, all we need to do is ensure that the

             * instructions that follow are only executed if the

             * return flag is clear.  We can do that by moving those

             * instructions into the else clause of the generated if

             * statement.

             */

            move_outer_block_inside(ir, &return_if->else_instructions);

         ir->insert_after(return_if);

      }

      this->loop = saved_loop;

      --this->function.nesting_depth;

   }

   virtual void visit(ir_function_signature *ir)

   {

      /* these are not strictly necessary */

      assert(!this->function.signature);

      assert(!this->loop.loop);

      bool lower_return;

      if (strcmp(ir->function_name(), "main") == 0)

         lower_return = lower_main_return;

      else

         lower_return = lower_sub_return;

      function_record saved_function = this->function;

      loop_record saved_loop = this->loop;

      this->function = function_record(ir, lower_return);

      this->loop = loop_record(ir);

      assert(!this->loop.loop);

      /* Visit the body of the function to lower any jumps that occur

       * in it, except possibly an unconditional return statement at

       * the end of it.

       */

      visit_block(&ir->body);

      /* If the body ended in an unconditional return of non-void,

       * then we don't need to lower it because it's the one canonical

       * return.

       *

       * If the body ended in a return of void, eliminate it because

       * it is redundant.

       */

      if (ir->return_type->is_void() &&

          get_jump_strength((ir_instruction *) ir->body.get_tail())) {

         ir_jump *jump = (ir_jump *) ir->body.get_tail();

         assert (jump->ir_type == ir_type_return);

         jump->remove();

      }

      if(this->function.return_value)

         ir->body.push_tail(new(ir) ir_return(new (ir) ir_dereference_variable(this->function.return_value)));

      this->loop = saved_loop;

      this->function = saved_function;

   }

   virtual void visit(class ir_function * ir)

   {

      visit_block(&ir->signatures);

   }

};

} /* anonymous namespace */

bool

do_lower_jumps(exec_list *instructions, bool pull_out_jumps, bool lower_sub_return, bool lower_main_return, bool lower_continue, bool lower_break)

{

   ir_lower_jumps_visitor v;

   v.pull_out_jumps = pull_out_jumps;

   v.lower_continue = lower_continue;

   v.lower_break = lower_break;

   v.lower_sub_return = lower_sub_return;

   v.lower_main_return = lower_main_return;

   bool progress_ever = false;

   do {

      v.progress = false;

      visit_exec_list(instructions, &v);

      progress_ever = v.progress || progress_ever;

   } while (v.progress);

   return progress_ever;

}