freeze_variables.c

Go to the documentation of this file.

/*
 
  $Id: freeze_variables.c 23495 2018-10-24 09:19: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/>.
 
*/
 
// do not compile unless required
#include "phases.h"
#ifdef BUILDER_FREEZE_VARIABLES
 
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "genC.h"
#include "linear.h"
 
#include "misc.h"
#include "pipsdbm.h"
 
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
 
#include "effects-generic.h" // used
#include "control.h" // module_reorder
 
typedef struct { list old, new; } entity_lists;
 
static bool  rw_effect_on_variable_p(list efs, entity var, bool b)
{
  bool readeff = false;
  list le = NIL;
 
  for( le =efs ; !ENDP(le ) && !readeff ; POP(le) ) {
    effect e= EFFECT(CAR(le));
    reference r = effect_any_reference(e);
    entity v = reference_variable(r); 
    if ((v==var) &&  
        ((b && action_read_p(effect_action(e))) || 
         (!b && action_write_p(effect_action(e)))))
        readeff= true;
  }
  return readeff;
}  
 
static bool  entity_in_call_arguments_p(entity ent,  call c)
{
  list le=call_arguments(c);
  bool seen=false;
  for( ; !ENDP(le ) && !seen ; POP(le) ) {
    expression e= EXPRESSION(CAR(le));
    if (expression_reference_p(e) 
        && (reference_variable(expression_reference(e)) == ent))
      seen = true;
  }
  return seen; 
}
 
 
static void substitute_entity_in_call_arguments(entity old, entity new, call c)
{
        
      list args = call_arguments(c);
      list tempargs = NIL;
      while (!ENDP(args))
        {
          expression exp = EXPRESSION(CAR(args));
          expression temp = substitute_entity_in_expression(old,new,exp);
          tempargs = gen_nconc(tempargs,CONS(EXPRESSION,temp,NIL));
          args = CDR(args);
        }
      call_arguments(c) = tempargs;
}
 
static void freeze_variables_in_statement(statement s, entity_lists * el)
{
  list efs = load_proper_rw_effects_list(s);
  bool read_eff_on_var_already_seen = false;
  bool READ_EFF = true;
  list new_entl = el->new;
  list old_entl = el->old;
  list first_st = NIL;
  list  last_st = NIL;
  bool st_to_insert_before= false;
  bool one_entity_in_args = false;
  if (statement_call_p(s))
  {  
    entity lb = statement_label(s); 
 
    // scan the lists of entities to freeze
    // some memory leaks should be fixed... FC.
    for (; !ENDP(old_entl) && !ENDP(new_entl);POP(old_entl), POP(new_entl)) 
    { 
      entity ent = ENTITY(CAR(old_entl)); 
      entity new_ent  = ENTITY(CAR(new_entl));
      bool this_entity_in_args = false;
      string strg = 
        strdup(concatenate("'Frozen variable ", 
                           entity_local_name(ent), 
                           " in ", 
                           get_current_module_name(),
                           " changed'",(char *) NULL));
      one_entity_in_args = one_entity_in_args ||
        (this_entity_in_args =
         entity_in_call_arguments_p(ent, 
                     instruction_call(statement_instruction(s))));
      read_eff_on_var_already_seen=false;
      if (this_entity_in_args) {
        MAP(EFFECT, eff, {
          reference r = effect_any_reference(eff);
          entity v = reference_variable(r);  
          if (v == ent) {
            if (action_write_p(effect_action(eff))) {
              call c1=call_undefined;
              test t1=test_undefined; 
              expression e1= expression_undefined;
              expression e2= expression_undefined;
              expression e3= expression_undefined;
              instruction i1 = instruction_undefined;
              statement s1=statement_undefined;
              if (read_eff_on_var_already_seen 
                  || rw_effect_on_variable_p(efs,ent,READ_EFF)) {
                /* if call  and READ effect on ent, initialize new_ent=ent*/   
                e1 = reference_to_expression(make_reference(new_ent, NIL));
                e2 = reference_to_expression(copy_reference(r));
                i1 = make_assign_instruction(e1,e2);
                s1=instruction_to_statement(i1);
                statement_label(s)= entity_empty_label();
                first_st=CONS(STATEMENT,s1, first_st);
                st_to_insert_before = true;
              }
              /* subtitute ent with new_ent in assignment or call */
              c1 = instruction_call(statement_instruction(s));
              substitute_entity_in_call_arguments(ent, new_ent,c1);
              
              /* insert after: if (new_ent.NE.ent) STOP */
              e1 = reference_to_expression(make_reference(new_ent, NIL));
              e2 = reference_to_expression(copy_reference(r));
              c1 = make_call(entity_intrinsic(NON_EQUAL_OPERATOR_NAME),
                  make_expression_list(e1,e2));
              
              e3 = make_expression(make_syntax(is_syntax_call, c1), 
                                   normalized_undefined);
              t1 =  make_test(e3, 
                              make_stop_statement(strg),
                              make_block_statement(NIL));
              s1 =test_to_statement(t1);
              last_st=CONS(STATEMENT,s1, last_st);          
            }
            else  read_eff_on_var_already_seen = true;
          } 
        }, efs);
      }
    }
    if (one_entity_in_args){
      if (st_to_insert_before) {
        MAPL(st, {
          insert_statement(s, STATEMENT(CAR(st)),true);
          if (ENDP(CDR(st))) statement_label(STATEMENT(CAR(st)))=lb;
        }, first_st);
      }
      MAPL(st, {
        insert_statement(s, STATEMENT(CAR(st)),false);
      }, last_st);
    }
    
  }
}
 
static bool initialized_variable_p(entity e)
{
  return variable_static_p(e);
}
 
bool freeze_variables(char *mod_name) 
{
  entity module;
  list frozen_entities = NIL;
  list cumu_eff=NIL;
  string names="";
  string rep="";
  bool WRITE_EFF = false;
  entity_lists new_le = {NIL,NIL};
  statement mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
  /* INITIALISATION */
  if (!statement_undefined_p(mod_stmt)) {
    set_current_module_statement(mod_stmt);
    module =module_name_to_entity(mod_name);
    set_current_module_entity(module);
    set_proper_rw_effects((statement_effects)
                          db_get_memory_resource(DBR_PROPER_EFFECTS,
                                                 mod_name,
                                                 true));
    set_cumulated_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                               mod_name,
                                                    true));
    
    cumu_eff = load_cumulated_rw_effects_list(mod_stmt);
    /* USER REQUEST */
    rep = user_request("Which variables do you want to freeze?\n",mod_name);
    if (rep[0] == '\0') {
      user_log("No variable to freeze\n");
      return false;
    }
    else names=rep;
    frozen_entities = string_to_entity_list(mod_name,names);
    
    /*  build the list of scalar entities to freeze in the module*/
    MAP(ENTITY,ent, {  
            if (rw_effect_on_variable_p(cumu_eff,ent,WRITE_EFF)) {
              basic b=basic_undefined;
              pips_assert("entity to freeze is a scalar variable",
                          (type_variable_p(entity_type(ent)) || 
                           variable_dimensions(type_variable(entity_type(ent))) == NIL)); 
              if (!variable_in_common_p(ent))
                user_log("Variable %s to freeze is not in a COMMON \n",
                         entity_local_name(ent)); 
                  if (!initialized_variable_p(ent))
                user_log("Variable %s to freeze is not  present in a DATA \n",
                         entity_local_name(ent));
              b = variable_basic(type_variable(entity_type(ent)));
              new_le.old= CONS(ENTITY, ent,  new_le.old);    
              new_le.new = CONS(ENTITY, 
                                make_new_scalar_variable(module,b), 
                                new_le.new);
            }
    },
        frozen_entities);
    
    /* recurse on  module statements */
    if (!ENDP(new_le.old))
      gen_context_recurse(mod_stmt, &new_le, 
          statement_domain, gen_true2, freeze_variables_in_statement);
    
    gen_free_list(new_le.new);
    pips_assert("Statement is consistent after FREEZING VARIABLES", 
                statement_consistent_p(mod_stmt));
    
  /* Reorder the module, because new statements have been added */  
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name,mod_stmt);
    reset_proper_rw_effects();
    reset_cumulated_rw_effects();
    reset_current_module_statement();
    reset_current_module_entity();
  }
  return true;
}
 
#endif // BUILDER_FREEZE_VARIABLES