dowhile_to_while.c

Go to the documentation of this file.

/*
 
  $Id: dowhile_to_while.c 23470 2018-06-02 13:39:47Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
#include "control.h"
#include "pipsdbm.h"
#include "resources.h"
 
/************************************************** SWITCH DO-WHILE TO WHILE */
 
static void dowhile_to_while_walker(statement stmt, bool * changed)
{
        instruction instr = statement_instruction(stmt);
        if ( instruction_whileloop_p(instr) )
        {
                whileloop wl = instruction_whileloop(instr);
 
                // is it a do-while loop?
                if ( evaluation_after_p(whileloop_evaluation(wl) ) )
                {
      // we did something!
      *changed = true;
 
                        // do-while -> while-do
                        free_evaluation(whileloop_evaluation(wl));
                        whileloop_evaluation(wl) = make_evaluation_before();
 
                        // push while-do instruction
                        statement duplicated_stat = make_empty_statement();
 
                        // duplicate while-do body statements and push it
      // BUG: it seems that clone does not handle "unstructured"
                        clone_context cc = make_clone_context(
                                        get_current_module_entity(),
                                        get_current_module_entity(),
          NIL,
                                        duplicated_stat
                        );
      statement dup = clone_statement(whileloop_body(wl), cc);
                        free_clone_context(cc);
 
      insert_statement(duplicated_stat, dup, false);
      insert_statement(duplicated_stat, instruction_to_statement(instr), false);
 
                        // see how elegant is the patching ?
      statement_instruction(stmt)=instruction_undefined;
      update_statement_instruction
        (stmt,
         make_instruction_block(CONS(statement, duplicated_stat, NIL))
          );
                }
        }
}
 
bool dowhile_to_while(const char* module_name)
{
        // prelude
  debug_on("CONTROL_DEBUG_LEVEL");
        set_current_module_entity( module_name_to_entity(module_name) );
        set_current_module_statement(
    (statement) db_get_memory_resource(DBR_CODE, module_name, true)
    );
 
  // whether anything was changed
  bool changed = false;
 
        // actual transformation
  gen_context_recurse(get_current_module_statement(), &changed,
                      statement_domain, gen_true2, dowhile_to_while_walker);
 
        // postlude
  if (changed)
  {
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,
                           get_current_module_statement());
  }
 
        reset_current_module_statement();
        reset_current_module_entity();
  debug_off();
        return true;
}
 
/************************************************* LOOP TRANSFORMATION UTILS */
 
/* converts a doloop to a while loop, in place */
void do_loop_to_while_loop(statement sl)
{
  pips_assert("statement is a loop",statement_loop_p(sl));
  loop l =statement_loop(sl);
  range r = loop_range(l);
 
  /* convert the loop to a while loop :
   * fst the body
   */
  list statements = make_statement_list(
    copy_statement(loop_body(l)),
    make_assign_statement(
      entity_to_expression(loop_index(l)),
      MakeBinaryCall(
        entity_intrinsic(PLUS_OPERATOR_NAME),
        entity_to_expression(loop_index(l)),
        range_increment(r)
        )
      )
    );
  /* then the whileloop */
  whileloop wl = make_whileloop(
    MakeBinaryCall(
      entity_intrinsic(LESS_OR_EQUAL_OPERATOR_NAME),
      entity_to_expression(loop_index(l)),
      range_upper(r)
      ),
    make_block_statement(statements),
    entity_empty_label(),
    make_evaluation_before());
 
  /* and the prelude */
  sequence seq = make_sequence(
    make_statement_list(
      make_assign_statement(entity_to_expression(loop_index(l)),
                            range_lower(r)),
      instruction_to_statement(make_instruction_whileloop(wl))
      )
    );
  range_upper(r)=expression_undefined;
  range_lower(r)=expression_undefined;
  range_increment(r)=expression_undefined;
 
  update_statement_instruction(sl,make_instruction_sequence(seq));
}
 
/* converts a doloop to a for loop, in place */
void do_loop_to_for_loop(statement sl)
{
  pips_assert("statement is a loop",statement_loop_p(sl));
  loop l =statement_loop(sl);
  range r = loop_range(l);
 
  forloop fl = make_forloop(
    make_assign_expression(entity_to_expression(loop_index(l)),
                           copy_expression(range_lower(r))),
    MakeBinaryCall(entity_intrinsic(LESS_OR_EQUAL_OPERATOR_NAME),
                   entity_to_expression(loop_index(l)),
                   copy_expression(range_upper(r))),
    MakeBinaryCall(entity_intrinsic(PLUS_UPDATE_OPERATOR_NAME),
                   entity_to_expression(loop_index(l)),
                   copy_expression(range_increment(r))),
    copy_statement(loop_body(l)));
  update_statement_instruction(sl, make_instruction_forloop(fl));
}