static_controlize.c

Go to the documentation of this file.

/*
 
  $Id: static_controlize.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
/* Name      :  static_controlize.c
 * package   :  static_controlize
 * Author    :  Arnauld LESERVOT
 * Date      :  May 93
 * Modified  :
 * Documents :  "Implementation du Data Flow Graph dans Pips"
 * Comments  :
 */
 
/* Ansi includes        */
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* Newgen includes      */
#include "genC.h"
#include "boolean.h"
 
/* C3 includes          */
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "properties.h"
#include "matrix.h"
 
/* Pips includes        */
#include "ri.h"
/* Types arc_label and vertex_label must be defined although they are
   not used */
typedef void * arc_label;
typedef void * vertex_label;
#include "graph.h"
#include "paf_ri.h"
#include "database.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "prettyprint.h"
#include "constants.h"
#include "misc.h"
#include "control.h"
#include "text-util.h"
#include "pipsdbm.h"
#include "resources.h"
#include "paf-util.h"
#include "static_controlize.h"
 
/* Global Variables     */
list                    Gstructure_parameters;
static list                     Genclosing_loops;
static list                     Genclosing_tests;
static list                     Gscalar_written_forward;
static hash_table               Gforward_substitute_table;
//static set io_functions_set;
statement_mapping       Gstatic_control_map;
 
 
/*=================================================================*/
/* static_control static_controlize_call( (call) c )            AL 05/93
 * It computes now just a static-control assignement if it is
 * an ASSIGN statement.
 */
static_control static_controlize_call(call c)
{
        static_control sc;
 
        pips_debug( 3, "begin CALL\n");
        pips_debug( 7,
                    "call : %s\n", entity_local_name( call_function(c) ) );
        entity e = call_function(c);
        tag tt;
            if ((tt = value_intrinsic_p(entity_initial(e))))
              {
                sc = make_static_control(false,
                                         sc_list_of_entity_dup( Gstructure_parameters ),
                                         /* _list_of_loop_dup(
                                            Genclosing_loops ),*/
                                         copy_loops( Genclosing_loops ),
                                         sc_list_of_exp_dup( Genclosing_tests ));
                static_control_yes( sc ) = splc_linear_access_to_arrays_p
                  (call_arguments(c),&Genclosing_loops);
              } 
            else
              {
                bool b = splc_linear_access_to_arrays_p(call_arguments(c),
                                                   &Genclosing_loops);
                
                sc = make_static_control(b,
                                         sc_list_of_entity_dup( Gstructure_parameters ),
                                         /* _list_of_loop_dup(
                                            Genclosing_loops ),*/
                                         copy_loops( Genclosing_loops ),
                                         sc_list_of_exp_dup( Genclosing_tests ));
              }
            pips_debug( 3, "end CALL\n");
            return sc;
}
 
/*==================================================================*/
/* static_control static_controlize_loop( (loop) l )
 * It computes the loop's static_control.
 */
static_control static_controlize_loop(loop l)
{
  static_control        sc;
        expression      low, up;
 
        pips_debug(3, "begin LOOP\n");
 
        low = range_lower( loop_range( l ) );
        up  = range_upper( loop_range( l ) );
        ADD_ELEMENT_TO_LIST(Genclosing_loops, LOOP, l);
        sc = static_controlize_statement( loop_body( l ) );
        if (       !constant_step_loop_p(l)
                || !splc_feautrier_expression_p(low, &Genclosing_loops)
                || !splc_feautrier_expression_p(up, &Genclosing_loops)  ) {
                static_control_yes( sc ) = false;
        }
        SET_STATEMENT_MAPPING(Gstatic_control_map, loop_body(l), sc);
        gen_remove( &Genclosing_loops, l );
 
        pips_debug(3, "end LOOP\n");
        return( sc );
}
 
 
 
 
/*==================================================================*/
/* static_control static_controlize_forloop( (forloop) fl )
 * It computes the forloop's static_control.
 */
static_control static_controlize_forloop(forloop fl)
{
  static_control        sc;
 
  pips_debug(3, "begin FORLOOP\n");
 
 
  sc = static_controlize_statement( forloop_body( fl ) );
  static_control_yes( sc ) = false;
 
  SET_STATEMENT_MAPPING(Gstatic_control_map, forloop_body(fl), sc);
 
  pips_debug(3, "end FORLOOP\n");
  return( sc );
}
 
/*==================================================================*/
/* static_control static_controlize_whileloop( (whileloop) l )
 * It computes the whileloop's static_control.
 */
static_control static_controlize_whileloop(whileloop wl)
{
  static_control        sc;
 
  pips_debug(3, "begin WHILELOOP\n");
 
 
  sc = static_controlize_statement( whileloop_body( wl ) );
  static_control_yes( sc ) = false;
 
  SET_STATEMENT_MAPPING(Gstatic_control_map, whileloop_body(wl), sc);
 
  pips_debug(3, "end WHILELOOP\n");
  return( sc );
}
 
/*==================================================================*/
/* static_control static_controlize_statement((statement) s)    AL 05/93
 * Computes s's static_control
 */
 
// Global variables added in order to avoid changing the definition of several functions
list assigned_var = NIL;
 
static_control static_controlize_statement(statement s)
{
  // Update of the list containing the variables assigned directly or indirectly by an array
  get_reference_assignments(s, &assigned_var);
  
  bool          is_static = true, static_test = false;
  instruction   inst = statement_instruction(s);
  static_control  sc, sc1, sc2;
  expression    exp, exp1, exp2;
 
  pips_debug(3, "begin STATEMENT\n");
  pips_debug(7, "statement_ordering = %zd \n", statement_ordering(s));
 
  switch(instruction_tag(inst))
    {
    case is_instruction_block :
      {
        FOREACH(STATEMENT, local_stmt, instruction_block(inst)) {
          sc1 = static_controlize_statement( local_stmt );
          SET_STATEMENT_MAPPING( Gstatic_control_map, local_stmt, sc1);
          //printf("s=%p, sc=%p\n", local_stmt, sc1);
          is_static = ( is_static && static_control_yes( sc1 ));
        }
        break;
      }
    case is_instruction_test :
      {
        test t = instruction_test(inst);
        forward_substitute_in_exp( &test_condition( t ),
                                   Gforward_substitute_table);
        
        /* We put condition under a normal disjunctive form */
        if ((exp = sc_conditional(test_condition(t), &Genclosing_loops)) !=
            expression_undefined || sp_feautrier_expression_p(test_condition(t))) {
          //DK, don't change the structure of conditions
          //test_condition( t ) = exp ;
          static_test = true;
        }
        ADD_ELEMENT_TO_LIST( Genclosing_tests, EXPRESSION, test_condition(t) );
        sc1 = static_controlize_statement(test_true(t));
        SET_STATEMENT_MAPPING( Gstatic_control_map, test_true( t ), sc1);
        gen_remove( &Genclosing_tests, (void*) test_condition( t ));
 
        exp1 = MakeUnaryCall( ENTITY_NOT, copy_expression( test_condition(t) ));
        if ( (exp2 = sc_conditional(exp1, &Genclosing_loops)) ==
             expression_undefined) {
          exp2 = exp1;
        }
        ADD_ELEMENT_TO_LIST( Genclosing_tests, EXPRESSION, exp2 );
        sc2 = static_controlize_statement(test_false(t));
        SET_STATEMENT_MAPPING( Gstatic_control_map, test_false( t ), sc2);
        gen_remove( &Genclosing_tests, (void *) exp2 );
        is_static = (  static_control_yes( sc1 )
                       && static_control_yes( sc2 )
                       && static_test );
        break;
      }
    case is_instruction_loop :
      {
        loop the_loop = instruction_loop( inst );
        forward_substitute_in_anyloop( instruction_loop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_loop( the_loop );
        is_static = static_control_yes( sc1 );
        break;
      }
    case is_instruction_forloop :
      {
        forloop forl = instruction_forloop( inst );
        forward_substitute_in_anyloop( instruction_forloop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_forloop( forl );
        is_static = static_control_yes( sc1 );
        break;
      }
    case  is_instruction_whileloop :
      {
        whileloop whilel = instruction_whileloop( inst );
        forward_substitute_in_anyloop( instruction_whileloop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_whileloop( whilel );
        is_static = static_control_yes( sc1 );
        break;
      }
    case is_instruction_call :
      {
        if (!(/*continue_statement_p(s) ||*/ declaration_statement_p(s)))
          {
            call the_call = instruction_call( inst);
            forward_substitute_in_call( &the_call, Gforward_substitute_table );
            is_static = static_control_yes(static_controlize_call( the_call ));
          }
        else
          is_static = false;
        if (!get_bool_property("STATIC_CONTROLIZE_ACROSS_USER_CALLS"))
          {
            if (statement_contains_user_call_p(s)
                || io_intrinsic_p((call_function(instruction_call( inst)))))
              is_static = false;
          }
        break;
      }
 
    case is_instruction_goto :
      {
        pips_internal_error("No goto in code ressource\n");
        is_static = false;
        break;
      }
    case is_instruction_expression :
      {
        is_static = true;
        break;
      }
    case is_instruction_unstructured :
      {
        unstructured local_un = instruction_unstructured( inst );
        is_static =
          static_control_yes(static_controlize_unstructured( local_un ));
        break;
      }
    default :
      {
        pips_internal_error("Ill. instruction tag");
      }
    }
  //if (!(continue_statement_p(s) || declaration_statement_p(s)))
    sc = make_static_control(is_static,
                             sc_list_of_entity_dup(Gstructure_parameters),
                             sc_list_of_loop_dup(Genclosing_loops),
                             sc_list_of_exp_dup(Genclosing_tests) );
 
  pips_debug(7,
             " Returning static_control : \n bool   : %s \n params : %s \n loops  : %zd \n tests  : %zd \n ",
             ((is_static)?"TRUE":"FALSE"),
             print_structurals( Gstructure_parameters ),
             gen_length( Genclosing_loops ),
             gen_length( Genclosing_tests ) );
  pips_debug(3, "end STATEMENT\n");
           
  return sc;
 
}
 
 
/*==================================================================*/
/* static_control static_controlize_unstructered((unstructured) u)  AL 05/93
 * Computes an unstructured's static_control
 */
static_control static_controlize_unstructured(u)
unstructured u;
{
        bool            is_static = true;
        list            blocs = NIL;
        static_control  sc, ret_sc = static_control_undefined;
 
        pips_debug(3, "begin UNSTRUCTURED\n");
        control_map_get_blocs(unstructured_control(u), &blocs ) ;
        blocs = gen_nreverse( blocs ) ;
 
        FOREACH(CONTROL, ctl, blocs) {
          statement stmt = control_statement(ctl);
          sc    = static_controlize_statement( stmt );
          pips_assert("stmt is consistent", statement_consistent_p(stmt));
          SET_STATEMENT_MAPPING( Gstatic_control_map, stmt, sc );
          //fprintf(stdout, "stmt=%p, sharing=%p\n", stmt, sc);
          is_static = is_static && static_control_yes( sc );
        }
 
        gen_free_list(blocs);
        ret_sc = make_static_control( is_static,
                                sc_list_of_entity_dup(Gstructure_parameters),
                                sc_list_of_loop_dup(Genclosing_loops),
                                sc_list_of_exp_dup(Genclosing_tests) );
 
        pips_debug(7,
"\n Returning static_control : \n bool   : %s \n params : %s \n loops  : %zd \n tests  : %zd \n ",
                 ((is_static)?"TRUE":"FALSE"),
                 print_structurals( Gstructure_parameters ),
                 gen_length( Genclosing_loops ),
                 gen_length( Genclosing_tests ) );
 
        pips_debug(3, "end UNSTRUCTURED\n");
        return( ret_sc );
}
 
 
 
 /* the following data structure describes an io intrinsic function: its
    name */
 
typedef struct IOIntrinsicDescriptor {
    string name;
} IOIntrinsicDescriptor;
 
static IOIntrinsicDescriptor IOIntrinsicDescriptorTable[] = {
    {"WRITE"},
    {"REWIND"},
    {"BACKSPACE"},
    {"OPEN"},
    {"CLOSE"},
    {"READ"},
    {"BUFFERIN"},
    {"BUFFEROUT"},
    {"ENDFILE"},
    {"INQUIRE"},
    {IMPLIED_DO_NAME},
 
    {NULL}
};
 
 
/*=======================================================================*/
/* bool io_filter(st)
 *
 * Tests if the statement is a call to an IO function. In such a case, we
 * put the statement inside a comment.
 *
 * AP, oct 9th 1995
 */
 
static bool io_filter(st)
statement st;
{
  bool res_b;
  instruction ins;
 
  res_b = true;
  ins = statement_instruction(st);
 
  if(instruction_tag(ins) == is_instruction_call) {
    call ca = instruction_call(ins);
    entity e = call_function(ca);
 
    /* There can be no statement inside a call, so gen_recurse() do not
       need to go further. */
    res_b = false;
 
    if(value_tag(entity_initial(e)) == is_value_intrinsic) {
      const char* s = entity_local_name(e);
      IOIntrinsicDescriptor *pid = IOIntrinsicDescriptorTable;
      bool found = false;
 
      while ((pid->name != NULL) && (!found)) {
        if (strcmp(pid->name, s) == 0) {
          char         *comment;
          statement    stat;
          list lstat;
 
          // BUG: missing overflow checks
          comment = (char*) malloc(64);
          sprintf(comment, "C %s\n",
                  words_to_string(Words_Call(ca, 0, true, true)));
 
          pips_assert("no buffer overflow", strlen(comment)<64);
 
          stat = make_statement(entity_empty_label(),
                                STATEMENT_NUMBER_UNDEFINED,
                                STATEMENT_ORDERING_UNDEFINED,
                                comment,
                                make_instruction_block(NIL),
                                NIL, // No local declarations
                                NULL, // null or empty string...
                                empty_extensions (), make_synchronization_none());
          lstat = CONS(STATEMENT, stat, NIL);
 
          statement_instruction(st) = make_instruction_block(lstat);
          /* Do not forget to move forbidden information associated with
             block: */
          fix_sequence_statement_attributes(st);
 
          found = true;
        }
        pid += 1;
      }
    }
  }
 
  return(res_b);
}
 
 
/*==================================================================*/
/* void static_controlize((char*) mod_name)                     AL 05/93
 * Computes the static_control attached to module-name : mod_name.
 */
bool static_controlize(string mod_name)
{
        statement       mod_stat;
        instruction     mod_inst;
        entity          ent;
        list            formal_integers;
        static_control  sc;
 
        debug_on("STATIC_CONTROLIZE_DEBUG_LEVEL");
 
        ifdebug(2)
          user_log("\n\n *** STATIC CONTROLIZE CODE for %s\n", mod_name);
 
        /*
         * Set the current language
         */
        entity module = module_name_to_entity(mod_name);
 
 
        value mv = entity_initial(module);
        if(value_code_p(mv)) {
          code c = value_code(mv);
          set_prettyprint_language_from_property(language_tag(code_language(c)));
        }
 
        Gcount_nsp = 0;
        Gcount_nub = 0;
        Gstructure_parameters   = (list) NIL;
        Genclosing_loops        = (list) NIL;
        Genclosing_tests        = (list) NIL;
        Gscalar_written_forward = (list) NIL;
        Gforward_substitute_table = hash_table_make( hash_pointer, 0 );
        hash_warn_on_redefinition();
        Gstatic_control_map = MAKE_STATEMENT_MAPPING();
 
        ent = local_name_to_top_level_entity(mod_name);
        set_current_module_entity(ent);
        formal_integers = sc_entity_to_formal_integer_parameters( ent );
        pips_debug(7, "\n formal integers : %s \n",
                print_structurals( formal_integers ));
 
        mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
        mod_inst = statement_instruction( mod_stat );
 
        /* HAS TO BE REMOVED AS SOON AS POSSIBLE: as the IOs are not
           treated as they would, all the instructions containing IOs are
           put inside comments. AP, oct 9th 1995 */
        gen_recurse(mod_inst, statement_domain, io_filter, gen_null);
        /* Normalization of all loops */
        /* Modification: loop_normalize_of_statement is used instead of */
        /* loop_normalize_of_unstructured since we cannot ensure that */
        /* mod_inst is an unstructured --11th Dec 1995, DB */
 
        /***
           D.K desactivate  the normalization of loops to preserve the
           original code
        */
 
        /*loop_normalize_of_statement(mod_stat,
                                       Gforward_substitute_table,
                                       &Genclosing_loops,
                                       &Genclosing_tests,
                                       &Gscalar_written_forward,
                                       &Gcount_nlc);
        */
 
 
 
 
        /* The code has been modified, so the orderings are recomputed. */
        module_reorder( mod_stat );
        verify_structural_parameters(formal_integers,
                                     &Gscalar_written_forward);
 
        Genclosing_loops      = (list) NIL;
        Genclosing_tests      = (list) NIL;
 
        /* We compute the static control infos for each instruction. */
        /* Same remark as before --DB */
 
        sc = static_controlize_statement(mod_stat);
        pips_assert("controlized statement mod_stat is consistent",
                    statement_consistent_p(mod_stat));
        pips_assert("static_control sc is consistent",
                    static_control_consistent_p(sc));
 
        stco_renumber_code( mod_stat, 0 );
 
        SET_STATEMENT_MAPPING( Gstatic_control_map, mod_stat, sc );
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(mod_name), (char*) mod_stat);
        DB_PUT_MEMORY_RESOURCE(DBR_STATIC_CONTROL, strdup(mod_name),
                        (char*) Gstatic_control_map);
 
        ifdebug(2)
          user_log("\n\n *** STATIC CONTROLIZE CODE done\n");
 
        reset_current_module_entity();
 
        debug_off();
        // Reset of the assigned_var list after the phase is complete
        gen_free_list(assigned_var);
        assigned_var = NIL;
 
        return(true);
}
 
/*==================================================================*/
 
 
 
 
 
/*==================================================================*/
/* list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl,
 * *swfl, int *Gcount_nlc) AL 04/93
 *
 * FI/SG Question: why change the loop index when it is not necessary?
 * To have a uniform behavior when it is necessary?
 */
list loop_normalize_of_loop( l, fst, ell, etl, swfl, Gcount_nlc)
loop l;
hash_table fst; /* forward substitute table */
list *ell,  /* enclosing loops list */
     *etl,  /* enclosing tests list */
     *swfl; /* scalar written forward list */
int *Gcount_nlc;
{
  entity          index, nlc_ent, max_ent;
  expression      rl, ru, ri, nub, nlc_exp, exp_plus;
  expression    nub2, nub3, index_exp, new_index_exp;
  expression      exp_max = expression_undefined;
  range           lr;
  statement       before_stmt = make_continue_statement(entity_empty_label());
  statement       end_stmt = statement_undefined;
  list            stmt_list = NIL;
 
  pips_debug(4, "begin LOOP\n");
 
  loop_label( l ) = entity_empty_label();
  /* loop_body( l ) = make_block_with_stmt( loop_body( l ));*/
  loop_body( l ) = make_block_with_stmt_if_not_already( loop_body( l ));
  index = loop_index( l );
 
  /* If it is not a constant step, we just normalize the loop body */
  if(!normalizable_loop_p(l)) {
    ADD_ELEMENT_TO_LIST(*swfl, ENTITY, index);
    (void) loop_normalize_of_statement(loop_body( l ), fst, ell,
                    etl, swfl, Gcount_nlc);
    return( make_undefined_list() );
  }
 
  lr = loop_range( l );
  rl = range_lower( lr );
  ru = range_upper( lr );
  ri = range_increment( lr );
 
  /* new upper bound, or at least iteration count */
  nub =   make_op_exp(DIVIDE_OPERATOR_NAME,
                      make_op_exp(PLUS_OPERATOR_NAME,
                                  make_op_exp(MINUS_OPERATOR_NAME,
                                              copy_expression(ru),
                                              copy_expression(rl)),
                                  copy_expression(ri)),
                      copy_expression(ri));
  nub2 = copy_expression(nub);
 
  ADD_ELEMENT_TO_LIST( stmt_list, STATEMENT, before_stmt );
 
  /* Generate the new loop index and the new loop bounds */
  nlc_ent = make_nlc_entity(Gcount_nlc);
  ADD_ELEMENT_TO_LIST(*swfl, ENTITY, nlc_ent);
  nlc_exp = make_entity_expression( nlc_ent, NIL);
  loop_index( l ) = nlc_ent;
  if(fortran_module_p(get_current_module_entity())) {
    range_lower( lr ) = int_to_expression( 1 );
    range_upper( lr ) = nub2;
  }
  else {
    /* assume C */
    range_lower( lr ) = int_to_expression( 0 );
    range_upper( lr ) = make_op_exp(MINUS_OPERATOR_NAME, nub2,
                                    int_to_expression(1));
  }
  range_increment( lr ) = int_to_expression( 1 );
 
  /* Generate the change of basis expression: the new index starts at
     0 in C and 1 in Fortran:
 
     old_index = rl + (new_index * ri) // C
 
     old_index = rl + (new_index * ri) - ri // Fortran
 
 */
  new_index_exp = make_op_exp(MULTIPLY_OPERATOR_NAME,
                              copy_expression(ri),
                              nlc_exp);
  if(fortran_module_p(get_current_module_entity())) {
    new_index_exp = make_op_exp(MINUS_OPERATOR_NAME,
                                new_index_exp,
                                copy_expression(ri));
  }
  new_index_exp = make_op_exp(PLUS_OPERATOR_NAME,
                              new_index_exp,
                              copy_expression(rl));
  hash_put(fst, (char*) index, (char*) new_index_exp);
 
  /* Compute the value of the index when the loop is exited: exp_max */
  nub3 = copy_expression( nub );
  if ( expression_constant_p( nub3 )) {
    int upper = expression_to_int( nub3 );
    if ( upper > 0 )
      /* nub3 is not used any longer */
      exp_max = int_to_expression( upper );
  }
  else {
    max_ent = gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                      MAX_OPERATOR_NAME),
                                 entity_domain);
    /* FI: Why copy nub? it does not seem used anywhere else. */
    exp_max = make_max_exp(max_ent, copy_expression( nub ),
                           int_to_expression( 0 ));
  }
  if ( exp_max == expression_undefined )
    exp_plus = copy_expression( rl );
  else
    exp_plus = make_op_exp(PLUS_OPERATOR_NAME,
                           make_op_exp( MULTIPLY_OPERATOR_NAME,
                                       copy_expression( ri ),
                                       exp_max),
                           copy_expression( rl ));
  index_exp = make_entity_expression( index, NIL );
  end_stmt = make_assign_statement(copy_expression(index_exp), exp_plus );
  ADD_ELEMENT_TO_LIST( stmt_list, STATEMENT, end_stmt);
 
  loop_normalize_of_statement(loop_body(l), fst , ell, etl, swfl, Gcount_nlc);
 
  hash_del(fst, (char*) index );
  pips_debug(4, "end LOOP\n");
  return( stmt_list );
}
 
 
/*==================================================================*/
/* list loop_normalize_of_statement(statement s, hash_table fst, list
 * *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.
 *
 * Before walking down the statements, we forward-substitute the
 * new-loop-counters on each type of statements.
 * We then return a list of two statements to be put
 * before and after statement 's'. These two new statements
 * are generated by loops when they are treated.
 * See document for more detail, section : "Normalisation des boucles".
 */
list loop_normalize_of_statement(s, fst, ell, etl, swfl, Gcount_nlc)
statement s;
hash_table fst; /* forward substitute table */
list *ell,  /* enclosing loops list */
     *etl,  /* enclosing tests list */
     *swfl; /* scalar written forward list */
int *Gcount_nlc;
{
  instruction   inst = statement_instruction(s);
  list          return_list = NIL;
 
  pips_assert("statement s is consistent\n", statement_consistent_p(s));
 
  pips_debug(3, "begin STATEMENT\n");
  return_list = make_undefined_list();
 
  switch(instruction_tag(inst))
    {
    case is_instruction_block :
      {
        list tail, head;
 
        tail = instruction_block(inst);
        for(head = NIL ; tail != NIL; )
          {
            statement stmt, before_stmt, after_stmt;
            list        insert_stmt;
 
            stmt = STATEMENT(CAR(tail));
            insert_stmt = loop_normalize_of_statement(stmt, fst, ell,
                                                      etl, swfl, Gcount_nlc);
            before_stmt = STATEMENT(CAR( insert_stmt ));
            after_stmt  = STATEMENT(CAR(CDR( insert_stmt )));
 
            if( before_stmt != statement_undefined)
              ADD_ELEMENT_TO_LIST( head, STATEMENT, before_stmt);
            ADD_ELEMENT_TO_LIST( head, STATEMENT, stmt );
            if (after_stmt != statement_undefined )
              ADD_ELEMENT_TO_LIST( head, STATEMENT, after_stmt );
 
            tail = CDR(tail);
          }
        instruction_block(inst) = head;
        break;
      }
    case is_instruction_test :
      {
        test t = instruction_test(inst);
        (void) forward_substitute_in_exp(&test_condition(t), fst);
        ADD_ELEMENT_TO_LIST(*etl, EXPRESSION, test_condition(t) );
        /*test_true(t) = make_block_with_stmt( test_true(t) );*/
        test_true(t) = make_block_with_stmt_if_not_already(test_true(t));
        /* test_false(t) = make_block_with_stmt( test_false(t) );*/
        test_false(t) = make_block_with_stmt_if_not_already( test_false(t) );
        loop_normalize_of_statement(test_true(t), fst, ell,
                                    etl, swfl, Gcount_nlc);
        loop_normalize_of_statement(test_false(t), fst, ell,
                                    etl, swfl, Gcount_nlc);
        gen_remove(etl, (gen_chunk*) test_condition( t ));
        break;
      }
    case is_instruction_loop :
      {
        (void) forward_substitute_in_anyloop(instruction_loop(inst), fst);
        ADD_ELEMENT_TO_LIST(*ell, LOOP, instruction_loop( inst ));
        return_list = loop_normalize_of_loop(instruction_loop(inst), fst, ell,
                                             etl, swfl, Gcount_nlc);
        gen_remove(ell, (gen_chunk*) instruction_loop( inst ));
        break;
      }
    case is_instruction_call :
      {
        (void) forward_substitute_in_call(&instruction_call(inst), fst);
        scalar_written_in_call( instruction_call( inst ), ell,
                                etl, swfl);
        break;
      }
    case is_instruction_goto : break;
    case is_instruction_unstructured :
      {
        loop_normalize_of_unstructured(instruction_unstructured(inst), fst, ell,
                                       etl, swfl, Gcount_nlc);
        break;
      }
    default : pips_internal_error("Bad instruction tag");
    }
  pips_debug(3, "end STATEMENT\n");
  return( return_list );
}
 
 
/*==================================================================*/
/* void loop_normalize_of_unstructured(unstructured u, fst): Normalization
 * of an unstructured instruction.
 */
void loop_normalize_of_unstructured(u, fst, ell, etl, swfl, Gcount_nlc)
unstructured u;
hash_table fst; /* forward substitute table */
list *ell,  /* enclosing loops list */
     *etl,  /* enclosing tests list */
     *swfl; /* scalar written forward list */
int *Gcount_nlc;
{
        list blocs = NIL, lc;
        list insert_stmts;
 
        pips_debug(2, "begin UNSTRUCTURED\n");
        control_map_get_blocs(unstructured_control(u), &blocs ) ;
        blocs = gen_nreverse( blocs ) ;
 
        for(lc = blocs; lc != NIL; lc = CDR(lc)) {
                list            head = NIL;
                control         ctl;
                statement       before_stmt, after_stmt, stmt;
 
                ctl             = CONTROL(CAR( lc ));
                stmt            = control_statement( ctl );
                insert_stmts    = loop_normalize_of_statement(stmt, fst,
                                                              ell, etl,
                                                              swfl,
                                                              Gcount_nlc);
                before_stmt     = STATEMENT(CAR( insert_stmts ));
                after_stmt      = STATEMENT(CAR(CDR( insert_stmts )));
 
           if (!undefined_statement_list_p( insert_stmts )) {
                if( before_stmt != statement_undefined)
                        ADD_ELEMENT_TO_LIST( head, STATEMENT, before_stmt );
                ADD_ELEMENT_TO_LIST( head, STATEMENT, stmt );
                if (after_stmt != statement_undefined )
                        ADD_ELEMENT_TO_LIST( head, STATEMENT, after_stmt );
                /*stmt = make_block_with_stmt( stmt );*/
                stmt = make_block_with_stmt_if_not_already(stmt);
                instruction_block(statement_instruction( stmt )) = head;
                head = NIL;
           }
        }
 
        gen_free_list(blocs);
        pips_debug(2, "end UNSTRUCTURED\n");
}