impact_check.c

Go to the documentation of this file.

/*
 
  $Id: impact_check.c 23065 2016-03-02 09:05:50Z 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 "local.h"
#include "prettyprint.h"
 
#define DEP_FLOW 0
#define DEP_ANTI 1
#define DEP_OUTP 2
 
#define MUST_APPROXIMATION 0
#define MAY_APPROXIMATION 1
#define NOT_APPROXIMATION 2
 
/* We want to keep track of the current statement inside the recurse */
/*DEFINE_LOCAL_STACK(current_stmt, statement)*/
 
static statement mod_stat = statement_undefined;
static entity current_mod = entity_undefined;
static graph dg = NULL; /* data dependence graph */
static entity alias_ent1 = entity_undefined;
static entity alias_ent2 = entity_undefined;
static list stat_reads1 = NIL; /* list of statement_approximation_p */
static list stat_writes1 = NIL; /* list of statement_approximation_p */
static list stat_reads2 = NIL; /* list of statement_approximation_p */
static list stat_writes2 = NIL; /* list of statement_approximation_p */
 
static list current_path = NIL;
/* This list tells us if two variables have been checked dynamically or not */
static list l_dynamic_check = NIL;
static int statement_in_caller_ordering = 0;
static statement statement_in_caller = statement_undefined;
static const char* caller_name;
static call current_call = call_undefined;
static int number_of_processed_modules = 0;
static int number_of_impact_alias = 0;
 
static void display_impact_alias_statistics()
{
  user_log("\n Number of processed modules: %d", number_of_processed_modules);
  user_log("\n Number of impact alias: %d\n", number_of_impact_alias);
}
 
// DUPLICATED FUNCTIONS also instrumentation/alias_check.c
// some alias-utils is missing?
 
static bool same_call_site_p(call_site cs1, call_site cs2)
{
  entity f1 = call_site_function(cs1);
  entity f2 = call_site_function(cs2);
  int o1 = call_site_ordering(cs1);
  int o2 = call_site_ordering(cs2);
  return (same_entity_p(f1,f2) && (o1==o2));
}
 
// function also in instrumentation/alias_check.c
static bool included_call_chain_p(list l1, list l2)
{
  while (!ENDP(l1) && !ENDP(l2))
    {
      call_site cs1 = CALL_SITE(CAR(l1));
      call_site cs2 = CALL_SITE(CAR(l2));
      if (!same_call_site_p(cs1,cs2))  return false;
      l1 = CDR(l1);
      l2 = CDR(l2);
    }
  return true;
}
 
/****************************************************************************
 
 This function returns true if l1 = conc(cs,l2)
 
*****************************************************************************/
 
static bool tail_call_path_p(call_site cs, list l1, list l2)
{
  if (gen_length(l1) == gen_length(l2)+1)
    {
      call_site cs1 = CALL_SITE(CAR(l1));
      return (same_call_site_p(cs,cs1) && included_call_chain_p(l2,CDR(l1)));
    }
  return false;
}
 
/*****************************************************************************
 
   This function computes the offset of a storage ram variable :
   offset = initial_offset + subscript_value_stride
 
*****************************************************************************/
 
static expression storage_ram_offset(storage s,expression subval)
{
  ram r = storage_ram(s);
  int initial_off = ram_offset(r);
  expression exp = int_to_expression(initial_off);
  if (!expression_equal_integer_p(subval,0))
    {
      if (initial_off == 0)
        exp = copy_expression(subval);
      else
        exp = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                          int_to_expression(initial_off),
                                          copy_expression(subval));
    }
  return exp;
}
 
/****************************************************************************
 
   This function computes the offset of a formal storage variable :
   offset = initial_offset + subscript_value_stride
 
   initial_offset is from alias_association with path' = path - {cs}
 
*****************************************************************************/
 
static expression storage_formal_offset(call_site cs,entity actual_var,
                                        expression subval,list path)
{
  list l_caller_aliases = alias_associations_list((alias_associations)
        db_get_memory_resource(DBR_ALIAS_ASSOCIATIONS,caller_name,true));
  expression exp = expression_undefined;
  MAP(ALIAS_ASSOCIATION, aa,
  {
    entity caller_var = alias_association_variable(aa);
    list caller_path = alias_association_call_chain(aa);
    if (same_entity_p(caller_var,actual_var) && tail_call_path_p(cs,caller_path,path))
      {
        expression initial_off = alias_association_offset(aa);
        if (!expression_undefined_p(initial_off))
          {
            if (expression_equal_integer_p(subval,0))
              exp = copy_expression(initial_off);
            else
              exp = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                copy_expression(initial_off),
                                                copy_expression(subval));
          }
        return exp;
      }
  },
      l_caller_aliases);
  return exp;
}
 
 
/*****************************************************************************
 
 If e is a formal parameter, find its rank in the formal parameter list of
 current module in order to find out the corresponding actual argument and
 then its offset
 
 If e is a common variable in the current module, offset of e is constant
 
*****************************************************************************/
 
static expression offset_in_caller(entity e, call_site cs, list path)
{
  ram ra ;
  if (formal_parameter_p(e))
    {
      formal f = storage_formal(entity_storage(e));
      int rank = formal_offset(f);
      list l_args = call_arguments(current_call);
      expression actual_arg = find_ith_argument(l_args,rank);
      reference actual_ref = expression_reference(actual_arg);
      entity actual_var = reference_variable(actual_ref);
      list l_actual_inds = reference_indices(actual_ref);
      /* compute the subscript value, return expression_undefined if
         if the actual argument is a scalar variable or array name*/
      expression subval = subscript_value_stride(actual_var,l_actual_inds);
      storage s = entity_storage(actual_var);
      ifdebug(3)
        fprintf(stderr, " \n Current actual argument %s",entity_name(actual_var));
      if (storage_ram_p(s))
        /* The actual argument has a ram storage */
        return storage_ram_offset(s,subval);
      if (storage_formal_p(s))
        /* The actual argument is a formal parameter of the current caller,
           we must take the alias_associations of the caller */
        return storage_formal_offset(cs,actual_var,subval,path);
    }
  // common variable
  ra = storage_ram(entity_storage(e));
  return int_to_expression(ram_offset(ra));
}
 
static bool search_statement_by_ordering_flt(statement s)
{
    if (statement_ordering(s) == statement_in_caller_ordering) {
        statement_in_caller = s;
        return false;
    }
    return true;
}
 
static bool statement_equal_p(statement s1, statement s2)
{
    return (statement_number(s1) == statement_number(s2));
}
 
static vertex statement_to_vertex(statement s, graph g)
{
    MAP(VERTEX, v, {
        statement sv = vertex_to_statement(v);
        if (statement_equal_p(s, sv))
            return v;
    }, graph_vertices(g));
    return vertex_undefined;
}
 
/* Check to see if new dependence is covered by arcs in dependence graph at reference level */
bool find_covering_reference_path(set arcs_processed_set,
                                  statement s_src,
                                  action act_src,
                                  entity ent_src,
                                  statement s_dest,
                                  action act_dest,
                                  entity ent_dest)
{
  if (statement_equal_p(s_src, s_dest))
    {
      if (entities_may_conflict_p(ent_src, ent_dest))
        return (action_write_p(act_dest) || action_read_p(act_src));
      else
        return (action_write_p(act_dest) && action_read_p(act_src));
    }
  else
    {
      vertex ver_src = statement_to_vertex(s_src, dg);
      MAP(SUCCESSOR, su, {
        statement s_tmp = vertex_to_statement(successor_vertex(su));
        dg_arc_label dal = (dg_arc_label) successor_arc_label(su);
        MAP(CONFLICT, c, {
          effect e_tmp_src = conflict_source(c);
          effect e_tmp_dest = conflict_sink(c);
          entity ent_tmp_src = reference_variable(effect_any_reference(e_tmp_src));
          entity ent_tmp_dest = reference_variable(effect_any_reference(e_tmp_dest));
          action act_tmp_src = effect_action(e_tmp_src);
          action act_tmp_dest = effect_action(e_tmp_dest);
          set arcs_processed_tmp_set = set_make(set_pointer);
          if (set_belong_p(arcs_processed_set, (char *)c)) continue;
          arcs_processed_tmp_set = set_add_element(arcs_processed_tmp_set, arcs_processed_set, (char *)c);
          if (entities_may_conflict_p(ent_src, ent_tmp_src))
            {
              if (action_write_p(act_tmp_src) || action_read_p(act_src))
                if (find_covering_reference_path(arcs_processed_tmp_set,
                                                s_tmp, act_tmp_dest, ent_tmp_dest,
                                                s_dest, act_dest, ent_dest)) return true;
            }
          else
            {
              if (action_write_p(act_tmp_src) && action_read_p(act_src))
                if (find_covering_reference_path(arcs_processed_tmp_set,
                                                s_tmp, act_tmp_dest, ent_tmp_dest,
                                                s_dest, act_dest, ent_dest)) return true;
            }
        }, dg_arc_label_conflicts(dal));
      }, vertex_successors(ver_src));
    }
  return false;
}
 
/* Check to see if there is a directed way between 2 statements in the graph specified */
bool check_way_between_two_statements(statement s1, statement s2, graph g)
{
    vertex v1 = statement_to_vertex(s1, g);
    list vertex_processed_list = NIL;
    list vertex_rest_list = NIL;
    ADD_ELEMENT_TO_LIST(vertex_rest_list, VERTEX, v1);
 
    while(!ENDP(vertex_rest_list)) {
        vertex v = VERTEX(CAR(vertex_rest_list));
        POP(vertex_rest_list);
        if (!gen_in_list_p(v, vertex_processed_list)) {
            statement sv = vertex_to_statement(v);
            if (statement_equal_p(sv, s2))
                return true;
            else {
                ADD_ELEMENT_TO_LIST(vertex_processed_list, VERTEX, v);
                MAP(SUCCESSOR, su, {
                    vertex v2 = successor_vertex(su);
                    if (!gen_in_list_p(v2, vertex_processed_list) && !gen_in_list_p(v2, vertex_rest_list))
                        ADD_ELEMENT_TO_LIST(vertex_rest_list, VERTEX, v2);
                }, vertex_successors(v));
            }
        }
    }
    return false;
}
 
/* This function prints the call path , including names of caller functions
   and orderings of call sites in their corresponding functions */
static string print_call_path(list path)
{
  list pc = NIL;
  MAP(CALL_SITE,casi,
  {
    entity casifunc = call_site_function(casi);
    int casiord = call_site_ordering(casi);
    pc = CHAIN_SWORD(pc,"(");
    pc = CHAIN_SWORD(pc,module_local_name(casifunc));
    pc = CHAIN_SWORD(pc,":(");
    pc = CHAIN_SWORD(pc,int2a(ORDERING_NUMBER(casiord)));
    pc = CHAIN_SWORD(pc,",");
    pc = CHAIN_SWORD(pc,int2a(ORDERING_STATEMENT(casiord)));
    pc = CHAIN_SWORD(pc,")) ");
  },path);
  return words_to_string(pc);
}
 
 
static void insert_impact_description_as_comment(statement s1, statement s2, bool impact_must_p, int dep_type)
{
  insert_comments_to_statement(s2, strdup(concatenate("C\t", text_to_string(statement_to_text(s1)), "\n", NULL)));
  switch(dep_type) {
  case DEP_FLOW:
    insert_comments_to_statement(s2, "C\tNew flow-dependence with statement\n");
    break;
  case DEP_ANTI:
    insert_comments_to_statement(s2, "C\tNew anti-dependence with statement\n");
    break;
  case DEP_OUTP:
    insert_comments_to_statement(s2, "C\tNew output-dependence with statement\n");
    break;
  }
  insert_comments_to_statement(s2, strdup(concatenate("C\tAttention: impact alias ",
                                                      impact_must_p ? "MUST":"MAY",
                                                      " at ",
                                                      print_call_path(current_path),
                                                      " between ",
                                                      entity_local_name(alias_ent1),
                                                      " and ",
                                                      entity_local_name(alias_ent2),
                                                      "\n",
                                                      NULL)));
  return;
}
 
/*
list union_list(list l1, list l2) {
    MAP(STATEMENT, s, {
        if (!gen_in_list_p(s, l1))
          ADD_ELEMENT_TO_LIST(l1, STATEMENT, s);
    }, l2);
    return l1;
}
*/
 
/* Union is not typed... */
list union_list(list l1, list l2) {
  list cl = list_undefined;
 
  for(cl=l2; !ENDP(cl); POP(cl)) {
    gen_chunk * gcp = CHUNK(CAR(cl));
        if(!gen_in_list_p(gcp , l1))
          l1 = gen_nconc(l1, gen_cons(gcp, NIL));
  }
 
  return l1;
}
 
static effect get_effect_read_of_statement_on_variable(statement s, entity var)
{
  MAP(EFFECT, eff, {
    entity e = reference_variable(effect_any_reference(eff));
    if (entities_may_conflict_p(e, var) && action_read_p(effect_action(eff)))
      return eff;
  }, statement_to_effects(s));
  return NULL;
}
 
static effect get_effect_write_of_statement_on_variable(statement s, entity var)
{
  MAP(EFFECT, eff, {
    entity e = reference_variable(effect_any_reference(eff));
    if (entities_may_conflict_p(e, var) && action_write_p(effect_action(eff)))
      return eff;
  }, statement_to_effects(s));
  return NULL;
}
 
static int __attribute__ ((unused)) expression_approximation(statement s, expression ex)
{
  normalized n = NORMALIZE_EXPRESSION(ex);
  transformer pre = load_statement_precondition(s);
  Psysteme precondition_ps = predicate_system(transformer_relation(pre));
  if (normalized_linear_p(n))
    {
      Pvecteur pv = vect_dup(normalized_linear(n));
      Pcontrainte volatile pc = contrainte_make(pv);
      /* Automatic variables read in a CATCH block need to be declared volatile as
       * specified by the documentation*/
      Psysteme volatile ps = sc_dup(precondition_ps);
      sc_add_ineg(ps, pc);
      CATCH(overflow_error) {
        sc_rm(ps);
        return MAY_APPROXIMATION;
      }
      TRY {
        bool n_positif, n_negatif;
        n_negatif = sc_rational_feasibility_ofl_ctrl(ps,FWD_OFL_CTRL,true);
        (void) vect_chg_sgn(pv);
        n_positif = sc_rational_feasibility_ofl_ctrl(ps,FWD_OFL_CTRL,true);
        fprintf(stderr, "n_negatif : %s\n", n_negatif ? "TRUE" : "FALSE");
        fprintf(stderr, "n_positif : %s\n", n_positif ? "TRUE" : "FALSE");
        UNCATCH(overflow_error);
      }
      sc_rm(ps);
    }
  return MAY_APPROXIMATION;
}
 
static int loop_executed_approximation(statement s)
{
  range rg = loop_range(statement_loop(s));
  normalized
    n_m1 = NORMALIZE_EXPRESSION(range_lower(rg)),
    n_m2 = NORMALIZE_EXPRESSION(range_upper(rg)),
    n_m3 = NORMALIZE_EXPRESSION(range_increment(rg));
 
  transformer pre = load_statement_precondition(s);
  Psysteme precondition_ps = predicate_system(transformer_relation(pre));
 
  if (normalized_linear_p(n_m1) && normalized_linear_p(n_m2) && normalized_linear_p(n_m3))
    {
      bool m3_negatif, m3_positif;
      /* Tester le signe de l'incrï¿œment en fonction des prï¿œconditions : */
      Pvecteur pv3 = vect_dup(normalized_linear(n_m3));
      Pcontrainte pc3 = contrainte_make(pv3);
      /* Automatic variables read in a CATCH block need to be declared volatile as
       * specified by the documentation*/
      Psysteme volatile ps = sc_dup(precondition_ps);
      sc_add_ineg(ps, pc3);
      CATCH(overflow_error) {
        sc_rm(ps);
        return MAY_APPROXIMATION;
      }
      TRY {
        m3_negatif = sc_rational_feasibility_ofl_ctrl(ps,FWD_OFL_CTRL,true);
        (void) vect_chg_sgn(pv3);
        m3_positif = sc_rational_feasibility_ofl_ctrl(ps,FWD_OFL_CTRL,true);
        UNCATCH(overflow_error);
      }
      pips_debug(2, "loop_increment_value positif = %d, negatif = %d\n",
                 m3_positif, m3_negatif);
 
      /* Vire aussi pv3 & pc3 : */
      sc_rm(ps);
 
      /* le signe est dￜterminￜ et diffￜrent de 0 */
      if (m3_positif ^ m3_negatif)
        {
          Pvecteur pv1, pv2, pv, pv_inverse;
          Pcontrainte c, c_inverse;
 
          pv1 = normalized_linear(n_m1);
          pv2 = normalized_linear(n_m2);
 
          /* pv = m1 - m2 */
          pv = vect_substract(pv1, pv2);
          pv_inverse = vect_dup(pv);
          /* pv_inverse = m2 - m1 */
          (void)vect_chg_sgn(pv_inverse);
 
          c = contrainte_make(pv);
          c_inverse = contrainte_make(pv_inverse);
 
          /* ??? on overflows, go next ... */
          if(ineq_redund_with_sc_p(precondition_ps, c)) {
            contrainte_free(c);
            return (m3_positif ? MUST_APPROXIMATION : NOT_APPROXIMATION);
          }
          contrainte_free(c);
 
          /* ??? on overflows, should assume MAY_BE_EXECUTED... */
          if(ineq_redund_with_sc_p(precondition_ps, c_inverse)) {
            contrainte_free(c_inverse);
            return (m3_positif ? NOT_APPROXIMATION : MUST_APPROXIMATION);
          }
          contrainte_free(c_inverse);
          return MAY_APPROXIMATION;
        }
    }
  return MAY_APPROXIMATION;
}
 
static set create_or_get_a_set_from_control(control c,
                                            hash_table control_to_set_of_dominators)
{
  if (!hash_defined_p(control_to_set_of_dominators, (char *)c))
    {
      set dominator = set_make(set_pointer);
      hash_put(control_to_set_of_dominators, (char *)c, (char *)dominator);
      return dominator;
    }
  else
    return (set) hash_get(control_to_set_of_dominators, (char *)c);
}
 
static void __attribute__ ((unused)) computing_dominators(hash_table control_to_set_of_dominators, control n0)
{
  bool change = true;
  list blocs = NIL;
  int count = 0;
  control c_count = NULL;
  set set_N;
  set dominator_dn = create_or_get_a_set_from_control(n0, control_to_set_of_dominators);
  set_add_element(dominator_dn, dominator_dn, (char *)n0);
 
  /* compute the set N of nodes in flowgraph */
  set_N = set_make(set_pointer);
  CONTROL_MAP(n, set_add_element(set_N, set_N, (char *)n), n0, blocs);
  gen_free_list(blocs);
  blocs = NIL;
 
  /* Initialization D(n) = N */
  CONTROL_MAP(n, {
    if (n == n0) continue;
    dominator_dn = create_or_get_a_set_from_control(n, control_to_set_of_dominators);
    set_assign(dominator_dn, set_N);
  }, n0, blocs);
  gen_free_list(blocs);
  blocs = NIL;
  set_free(set_N);
 
  while (change)
    {
      list sub_blocs = NIL;
      change = false;
      CONTROL_MAP(n, {
        set dominator_dp = NULL;
        if (n == n0) continue;
        count++;
        dominator_dn = set_make(set_pointer);
        set_add_element(dominator_dn, dominator_dn, (char *)n);
 
        BACKWARD_CONTROL_MAP(pred, {
          if (dominator_dp == NULL)
            {
              dominator_dp = set_make(set_pointer);
              set_assign(dominator_dp,
                         create_or_get_a_set_from_control(pred, control_to_set_of_dominators));
            } else
              set_intersection(dominator_dp, dominator_dp,
                               create_or_get_a_set_from_control(pred, control_to_set_of_dominators));
        }, n, sub_blocs);
        gen_free_list(sub_blocs);
        sub_blocs = NIL;
 
        set_union(dominator_dn, dominator_dn, dominator_dp);
 
        if (!set_equal_p(dominator_dn,
                        create_or_get_a_set_from_control(n, control_to_set_of_dominators)))
          {
            change = true;
            hash_update(control_to_set_of_dominators, (char *)n, dominator_dn);
          }
        if (count == 11)
          c_count = n;
 
      }, n0, blocs);
      gen_free_list(blocs);
      blocs = NIL;
    }
  dominator_dn = create_or_get_a_set_from_control(c_count, control_to_set_of_dominators);
  fprintf(stderr, "dominators of statement\n");
  safe_print_statement(control_statement(c_count));
  count = 0;
  SET_MAP(dom, {
    control c = (control) dom;
    fprintf(stderr, "#%d : ", ++count);
    safe_print_statement(control_statement(c));
  }, dominator_dn);
}
 
static int __attribute__ ((unused)) control_approximation_between_statement_p(statement s1, statement s2)
{
  /* control_graph does not work until load_ctrl_graph is called
   * control
   *  c1 = unstructured_control(control_graph(s1)),
   *  c2 = unstructured_control(control_graph(s2));
   *
   * load_ctrl_graph work only if full_control_graph is called before
   * and clean_ctrl_graph is called after
   */
  control
    c1 = load_ctrl_graph(s1),
    c2 = load_ctrl_graph(s2);
  list blocs = NIL;
  statement s;
  int
    statement_exec_appro = MUST_APPROXIMATION,
    statement_exec_appro1 = MUST_APPROXIMATION,
    statement_exec_appro2 = MUST_APPROXIMATION;
 
  BACKWARD_CONTROL_MAP(pred, {
    s = control_statement(pred);
    if (gen_length(control_successors(pred)) <= 1) continue;
    switch (instruction_tag(statement_instruction(s))) {
    case is_instruction_test:
      /*fprintf(stderr, "TEST......\n");*/
      return false;
      break;
    case is_instruction_loop:
      statement_exec_appro = loop_executed_approximation(s);
      break;
    case is_instruction_whileloop:
      /*fprintf(stderr, "START.....\n");
      safe_print_statement(s1);
      safe_print_statement(s);
      statement_exec_appro = expression_approximation(s, whileloop_condition(instruction_whileloop(statement_instruction(s))));*/
      break;
    case is_instruction_call:
      /* consideration of parameters here */
      break;
    case is_instruction_unstructured:
    case is_instruction_block:
    case is_instruction_goto:
    default:
      break;
    }
 
    switch (statement_exec_appro) {
    case MUST_APPROXIMATION:
      break;
    case MAY_APPROXIMATION:
      statement_exec_appro1 = statement_exec_appro;
      break;
    case NOT_APPROXIMATION:
      return NOT_APPROXIMATION;
    }
 
  }, c1, blocs);
  gen_free_list(blocs);
 
  blocs = NIL;
  BACKWARD_CONTROL_MAP(pred, {
    s = control_statement(pred);
    if (gen_length(control_successors(pred)) <= 1) continue;
    switch (instruction_tag(statement_instruction(s))) {
    case is_instruction_test:
      /*fprintf(stderr, "TEST......\n");*/
      return false;
      break;
    case is_instruction_loop:
      statement_exec_appro = loop_executed_approximation(s);
      break;
    case is_instruction_whileloop:
      /*fprintf(stderr, "START.....\n");
      safe_print_statement(s2);
      safe_print_statement(s);
      statement_exec_appro = expression_approximation(s, whileloop_condition(instruction_whileloop(statement_instruction(s))));*/
      break;
    case is_instruction_call:
      /* consideration of parameters here */
      break;
    case is_instruction_unstructured:
    case is_instruction_block:
    case is_instruction_goto:
    default:
      break;
    }
 
    switch (statement_exec_appro) {
    case MUST_APPROXIMATION:
      break;
    case MAY_APPROXIMATION:
      statement_exec_appro2 = statement_exec_appro;
      break;
    case NOT_APPROXIMATION:
      return NOT_APPROXIMATION;
    }
 
  }, c2, blocs);
  gen_free_list(blocs);
 
  return ((statement_exec_appro1 ==  MUST_APPROXIMATION) && (statement_exec_appro2 == MUST_APPROXIMATION))
    ? MUST_APPROXIMATION : MAY_APPROXIMATION;
}
 
static void check_for_effected_statement(statement s, list le)
{
  set arcs_processed_set = set_make(set_pointer);
  list stat_reads1_old = gen_copy_seq(stat_reads1);
  list stat_writes1_old = gen_copy_seq(stat_writes1);
  list stat_reads2_old = gen_copy_seq(stat_reads2);
  list stat_writes2_old = gen_copy_seq(stat_writes2);
 
  MAP(EFFECT, eff, {
    entity ent_dest = reference_variable(effect_any_reference(eff));
    action act_dest = effect_action(eff);
    bool impact_must_p = false; /* default value of dependence : MAY */
    effect eff_tmp;
 
    if (entities_may_conflict_p(ent_dest, alias_ent1)) {
      if (action_read_p(act_dest)) {
        gen_free_list(stat_reads1);
        /* used for remember to rebuild the list of read statements for alias_ent1 */
        stat_reads1 = CONS(STATEMENT, s, NIL);
        MAP(STATEMENT, sw2, {
          if (!statement_undefined_p(sw2)) { /* new flow-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sw2, make_action_write_memory(), alias_ent2,
                                              s, act_dest, alias_ent1))
              {
                number_of_impact_alias++;
                /*switch (control_approximation_between_statement_p(sw2, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_write_of_statement_on_variable(sw2, alias_ent2);
                  if (!effect_undefined_p(eff_tmp))
                    impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sw2, s, impact_must_p, DEP_FLOW);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sw2, s, false, DEP_FLOW);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so no impact alias*/
                  break;
                }
              }
          }
        }, stat_writes2_old);
      } else {
        gen_free_list(stat_writes1);
        /* used for remember to rebuild the list of write statements for alias_ent1 */
        stat_writes1 = CONS(STATEMENT, s, NIL);
        MAP(STATEMENT, sr2, {
          if (!statement_undefined_p(sr2)) { /* new anti-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sr2, make_action_read_memory(), alias_ent2,
                                              s, act_dest, alias_ent1))
              {
                number_of_impact_alias++;
                /*switch (control_approximation_between_statement_p(sr2, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_read_of_statement_on_variable(sr2, alias_ent2);
                  if (!effect_undefined_p(eff_tmp))
                    impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sr2, s, impact_must_p, DEP_ANTI);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sr2, s, false, DEP_ANTI);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so don't the impact alias*/
                  break;
                }
              }
          }
        }, stat_reads2_old);
        MAP(STATEMENT, sw2, {
          if (!statement_undefined_p(sw2)) { /* new output-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sw2, make_action_write_memory(), alias_ent2,
                                              s, act_dest, alias_ent1))
              {
                number_of_impact_alias++;
                /*switch (control_approximation_between_statement_p(sw2, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_write_of_statement_on_variable(sw2, alias_ent2);
                  if (!effect_undefined_p(eff_tmp))
                    impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sw2, s, impact_must_p, DEP_OUTP);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sw2, s, false, DEP_OUTP);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so don't the impact alias*/
                  break;
                }
              }
          }
        }, stat_writes2_old);
      }
    }
    if (entities_may_conflict_p(ent_dest, alias_ent2)) {
      if (action_read_p(act_dest)) {
        gen_free_list(stat_reads2);
        /* rebuild the list of read statements for alias_ent2 */
        stat_reads2 = CONS(STATEMENT, s, NIL);
        MAP(STATEMENT, sw1, {
          if (!statement_undefined_p(sw1)) { /* new flow-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sw1, make_action_write_memory(), alias_ent1,
                                              s, act_dest, alias_ent2))
              {
                number_of_impact_alias++;
                /*switch (control_approximation_between_statement_p(sw1, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_write_of_statement_on_variable(sw1, alias_ent1);
                  if (!effect_undefined_p(eff_tmp))
                    impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sw1, s, impact_must_p, DEP_FLOW);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sw1, s, false, DEP_FLOW);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so don't the impact alias*/
                  break;
                }
              }
          }
        }, stat_writes1_old);
      } else {
        gen_free_list(stat_writes2);
        /* rebuild the list of write statements for alias_ent2 */
        stat_writes2 = CONS(STATEMENT, s, NIL);
        MAP(STATEMENT, sr1, {
          if (!statement_undefined_p(sr1)) { /* new anti-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sr1, make_action_read_memory(), alias_ent1,
                                              s, act_dest, alias_ent2))
              {
                number_of_impact_alias++;
                /*switch(control_approximation_between_statement_p(sr1, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_read_of_statement_on_variable(sr1, alias_ent1);
                  if (!effect_undefined_p(eff_tmp))
                  impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sr1, s, impact_must_p, DEP_ANTI);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sr1, s, false, DEP_ANTI);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so don't the impact alias*/
                  break;
                }
              }
          }
        }, stat_reads1_old);
        MAP(STATEMENT, sw1, {
          if (!statement_undefined_p(sw1)) { /* new output-dependence created */
            set_clear(arcs_processed_set);
            if (!find_covering_reference_path(arcs_processed_set,
                                              sw1, make_action_write_memory(), alias_ent1,
                                              s, act_dest, alias_ent2))
              {
                number_of_impact_alias++;
                /*switch (control_approximation_between_statement_p(sw1, s)) {*/
                switch(MUST_APPROXIMATION) {
                case MUST_APPROXIMATION:
                  eff_tmp = get_effect_write_of_statement_on_variable(sw1, alias_ent1);
                  if (!effect_undefined_p(eff_tmp))
                    impact_must_p = approximation_exact_p(effect_approximation(eff_tmp));
                  impact_must_p = impact_must_p &&
                    approximation_exact_p(effect_approximation(eff));
                  insert_impact_description_as_comment(sw1, s, impact_must_p, DEP_OUTP);
                  break;
                case MAY_APPROXIMATION:
                  insert_impact_description_as_comment(sw1, s, false, DEP_OUTP);
                  break;
                case NOT_APPROXIMATION:
                  /* dependence does not exist so don't the impact alias*/
                  break;
                }
              }
          }
        }, stat_writes1_old);
      }
    }
  }, le);
  set_free(arcs_processed_set);
  gen_free_list(stat_reads1_old);
  gen_free_list(stat_writes1_old);
  gen_free_list(stat_reads2_old);
  gen_free_list(stat_writes2_old);
  return;
}
 
static void check_new_arc_for_structured_statement(statement s)
{
    instruction istat;
    list /* of effects */ le = NIL;
    list /* of effects */ l = NIL;
    list blocs = NIL;
 
    if ((statement_undefined_p(s)) || (s == NULL)) return;
 
    /* precondition is used to determine if the statement is executed */
    /*if (!statement_feasible_p(s)) return;*/
 
    istat = statement_instruction(s);
 
    switch(instruction_tag(istat)) {
    case is_instruction_block:
        MAP(STATEMENT, s,
            check_new_arc_for_structured_statement(s),
            instruction_block(istat));
        break;
    case is_instruction_test:
      {
        list stat_reads1_true = NIL;
        list stat_reads2_true = NIL;
        list stat_writes1_true = NIL;
        list stat_writes2_true = NIL;
 
        list stat_reads1_old = NIL;
        list stat_reads2_old = NIL;
        list stat_writes1_old = NIL;
        list stat_writes2_old = NIL;
 
        le = proper_effects_of_expression(test_condition(instruction_test(istat)));
        check_for_effected_statement(s, le);
 
        /* save the old read, write statements */
        stat_reads1_old = gen_copy_seq(stat_reads1);
        stat_reads2_old = gen_copy_seq(stat_reads2);
        stat_writes1_old = gen_copy_seq(stat_writes1);
        stat_writes2_old = gen_copy_seq(stat_writes2);
 
        /* read, write statements may be modified after the line below */
        check_new_arc_for_structured_statement(test_true(instruction_test(istat)));
 
        /* store the new version */
        stat_reads1_true = stat_reads1;
        stat_reads2_true = stat_reads2;
        stat_writes1_true = stat_writes1;
        stat_writes2_true = stat_writes2;
 
        /* restore the old version */
        stat_reads1 = stat_reads1_old;
        stat_reads2 = stat_reads2_old;
        stat_writes1 = stat_writes1_old;
        stat_writes2 = stat_writes2_old;
 
        stat_reads1_old = NIL;
        stat_reads2_old = NIL;
        stat_writes1_old = NIL;
        stat_writes2_old = NIL;
 
        /* read, write statements may be modified after the line below */
        check_new_arc_for_structured_statement(test_false(instruction_test(istat)));
 
        stat_reads1 = union_list(stat_reads1, stat_reads1_true);
        stat_reads2 = union_list(stat_reads2, stat_reads2_true);
        stat_writes1 = union_list(stat_writes1, stat_writes1_true);
        stat_writes2 = union_list(stat_writes2, stat_writes2_true);
 
        gen_free_list(stat_reads1_true);
        gen_free_list(stat_reads2_true);
        gen_free_list(stat_writes1_true);
        gen_free_list(stat_writes2_true);
 
        break;
      }
    case is_instruction_loop:
      /*safe_print_statement(s);
        switch (loop_executed_approximation(s)) {
        case MUST_BE_EXECUTED:
          fprintf(stderr, "MUST_BE_EXECUTED\n");
          break;
        case MAY_BE_EXECUTED:
          fprintf(stderr, "MAY_BE_EXECUTED\n");
          break;
        case MUST_NOT_BE_EXECUTED:
          fprintf(stderr, "MUST_NOT_BE_EXECUTED\n");
          break;
          }*/
        le = proper_effects_of_expression(range_lower(loop_range(instruction_loop(istat))));
        l = proper_effects_of_expression(range_upper(loop_range(instruction_loop(istat))));
        le = union_list(le, l);
        l = proper_effects_of_expression(range_increment(loop_range(instruction_loop(istat))));
        le = union_list(le, l);
        check_for_effected_statement(s, le);
        check_new_arc_for_structured_statement(loop_body(instruction_loop(istat)));
        break;
    case is_instruction_whileloop:
        le = proper_effects_of_expression(whileloop_condition(instruction_whileloop(istat)));
        check_for_effected_statement(s, le);
        check_new_arc_for_structured_statement(whileloop_body(instruction_whileloop(istat)));
        break;
    case is_instruction_goto:
        check_new_arc_for_structured_statement(instruction_goto(istat));
        break;
    case is_instruction_unstructured:
        CONTROL_MAP(c, {
          fprintf(stderr, "i am here UNSTRUCTURED ");
          safe_print_statement(control_statement(c));
          check_new_arc_for_structured_statement(control_statement(c));
        }, unstructured_control(instruction_unstructured(istat)), blocs);
        gen_free_list(blocs);
        break;
    case is_instruction_call:
        /* consideration of parameters here */
        check_for_effected_statement(s, statement_to_effects(s));
        break;
    default:
        pips_internal_error("case default reached");
        break;
    }
}
 
static void impact_check_two_scalar_variables_in_path(entity e1, entity e2, expression off1, expression off2, list path)
{
    expression diff = eq_expression(off1, off2);
    clean_all_normalized(diff);
    ifdebug(3) {
        fprintf(stderr, "entity1 local name: %s\n", entity_local_name(e1));
        fprintf(stderr, "entity2 local name: %s\n",  entity_local_name(e2));
        print_expression(off1);
        print_expression(off2);
        fprintf(stderr, "call path: %s\n", print_call_path(path));
    }
    if (trivial_expression_p(diff) == -1)
        /* off1 != off2 => Okay, no alias between these 2 variables */
        return;
    else {
        /* alias */
 
        alias_ent1 = e1;
        alias_ent2 = e2;
        current_path = path;
 
        check_new_arc_for_structured_statement(mod_stat);
        /*gen_recurse(mod_stat, statement_domain, check_new_arc_for_structured_statement, gen_null);*/
 
        gen_free_list(stat_reads1);
        gen_free_list(stat_reads2);
        gen_free_list(stat_writes1);
        gen_free_list(stat_writes2);
        stat_reads1 = NIL;
        stat_reads2 = NIL;
        stat_writes1 = NIL;
        stat_writes2 = NIL;
 
        alias_ent1 = entity_undefined;
        alias_ent2 = entity_undefined;
        current_path = NIL;
    }
    return;
}
 
static void impact_check_in_path(entity e1, entity e2, expression off1, expression off2, list path)
{
    if (entity_atomic_reference_p(e1) && entity_atomic_reference_p(e2))
        impact_check_two_scalar_variables_in_path(e1, e2, off1, off2, path);
    if (entity_atomic_reference_p(e1) && !entity_atomic_reference_p(e2))
      {
        fprintf(stderr, "alias entre variable scalaire e1 et variable tableau e2\n");
        impact_check_two_scalar_variables_in_path(e1, e2, off1, off2, path);
      }
    if (!entity_atomic_reference_p(e1) && entity_atomic_reference_p(e2))
      {
        fprintf(stderr, "alias entre variable tableau e1 et variable scalaire e2\n");
        impact_check_two_scalar_variables_in_path(e1, e2, off1, off2, path);
      }
    if (!entity_atomic_reference_p(e1) && !entity_atomic_reference_p(e2))
      {
        fprintf(stderr, "alias entre 2 variables tableau\n");
        impact_check_two_scalar_variables_in_path(e1, e2, off1, off2, path);
      }
}
 
static bool written = false;
static entity current_entity  = entity_undefined;
 
/* This function returns true if the variable is written directly in the current module,
   or by its callees */
static bool variable_is_written_by_statement_flt(statement s)
{
    if (statement_call_p(s)) {
        list l_rw = statement_to_effects(s);
        MAP(EFFECT, eff, {
            action a = effect_action(eff);
            if (action_write_p(a)) {
                reference r = effect_any_reference(eff);
                entity e = reference_variable(r);
                if (same_entity_p(e,current_entity)) {
                    ifdebug(3) {
                        fprintf(stderr,"\n Write on entity %s :\n",entity_name(e));
                        fprintf(stderr,"\n Current entity %s :\n",entity_name(current_entity));
                    }
                    written = true;
                    /* gen_recurse_stop(NULL); */
                    return false;
                }
            }
        }, l_rw);
        return false;
    }
    return true;
}
 
static bool variable_is_written_p(entity ent)
{
    written = false;
    current_entity = ent;
    gen_recurse(mod_stat,statement_domain,
                variable_is_written_by_statement_flt,gen_null);
    current_entity = entity_undefined;
    return written;
}
 
static void set_dynamic_checked(entity e1, entity e2)
{
  MAP(DYNAMIC_CHECK,dc,
  {
    if ((dynamic_check_first(dc)==e1) && (dynamic_check_second(dc)==e2))
      dynamic_check_checked(dc) = true;
  }, l_dynamic_check);
}
 
static bool dynamic_checked_p(entity e1, entity e2)
{
    MAP(DYNAMIC_CHECK, dc, {
        if ((dynamic_check_first(dc)==e1)&&(dynamic_check_second(dc)==e2))
            return dynamic_check_checked(dc);
    }, l_dynamic_check);
    return false;
}
 
static void init_dynamic_check_list(entity current_mod)
{
    list l_decls = code_declarations(entity_code(current_mod));
    list l_formals = NIL;
    list l_commons = NIL;
 
    /* search for formal parameters in the declaration list */
    MAP(ENTITY, e, {
        if (formal_parameter_p(e))
            l_formals = gen_nconc(l_formals,CONS(ENTITY,e,NIL));
    }, l_decls);
 
    MAP(ENTITY, e, {
        if (variable_in_common_p(e))
            l_commons = gen_nconc(l_commons,CONS(ENTITY,e,NIL));
    }, l_decls);
 
    MAP(ENTITY,e1, {
        MAP(ENTITY,e2, {
            dynamic_check dc = make_dynamic_check(e1,e2,false);
            l_dynamic_check = gen_nconc(l_dynamic_check,CONS(DYNAMIC_CHECK,dc,NIL));
        }, l_formals);
 
        MAP(ENTITY,e2, {
            dynamic_check dc = make_dynamic_check(e1,e2,false);
            l_dynamic_check = gen_nconc(l_dynamic_check,CONS(DYNAMIC_CHECK,dc,NIL));
        }, l_commons);
    }, l_formals);
}
 
static void impact_check_two_variables(entity e1, entity e2, expression off1, expression off2, list path)
{
    if (variable_is_written_p(e1) || variable_is_written_p(e2)) {
        if (!expression_undefined_p(off1) && !expression_undefined_p(off2)) {
            /* good offset --> check */
            impact_check_in_path(e1, e2, off1, off2, path);
        } else {
            /* As we do not have exact offsets of variables, we have to go to the
               caller's frame to check for alias impact. The direct caller is
               CAR(call_path) because of the following concatenation in alias_propagation:
               path = CONS(CALL_SITE,cs,gen_full_copy_list(alias_association_call_chain(aa)));
 
               To find a call site from its ordering, we have to do a gen_recurse
               in the caller module. */
            call_site cs = CALL_SITE(CAR(path));
            statement caller_statement;
            entity current_caller = call_site_function(cs);
            caller_name = module_local_name(current_caller);
            caller_statement = (statement)db_get_memory_resource(DBR_CODE,caller_name,true);
 
            statement_in_caller_ordering = call_site_ordering(cs);
            statement_in_caller = statement_undefined;
            gen_recurse(caller_statement,statement_domain,
                        search_statement_by_ordering_flt,gen_null);
 
            if (!statement_undefined_p(statement_in_caller)
                && statement_call_p(statement_in_caller)) {
                expression new_off1, new_off2;
                current_call = statement_call(statement_in_caller);
                new_off1 = offset_in_caller(e1, cs, path);
                new_off2 = offset_in_caller(e2, cs, path);
                if (!expression_undefined_p(new_off1) && !expression_undefined_p(new_off2)) {
                    /* good offset --> check */
                    impact_check_in_path(e1, e2, new_off1, new_off2, path);
                } else {
                  /* Try with special cases : CALL FOO(R(TR(K)),R(TR(K))) ???????
                     Does this case exist when we create special section + offset
                     for same actual arguments ??? */
                  /* use dynamic alias check*/
                  set_dynamic_checked(e1, e2);
                }
                current_call = call_undefined;
            } else
                pips_user_warning("Problem with statement ordering *\n");
            statement_in_caller = statement_undefined;
            statement_in_caller_ordering = 0;
        }
    }
}
 
bool impact_check(char * module_name)
{
    list l_module_aliases = NIL;
    /*hash_table control_to_set_of_dominators = hash_table_make(hash_pointer, 0);*/
 
    number_of_processed_modules++;
    current_mod = local_name_to_top_level_entity(module_name);
 
    debug_on("RICEDG_DEBUG_LEVEL");
 
 
    l_module_aliases = alias_associations_list((alias_associations)
                                               db_get_memory_resource(DBR_ALIAS_ASSOCIATIONS,
                                                                      module_name, true));
 
    if (l_module_aliases != NIL) {
        dg = (graph) db_get_memory_resource(DBR_DG, module_name, true);
        /*full_control_graph(module_name);*/
        mod_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
        set_current_module_entity(current_mod);
 
        set_ordering_to_statement(mod_stat);
        init_dynamic_check_list(current_mod);
 
        /*computing_dominators(control_to_set_of_dominators, load_ctrl_graph(mod_stat));
 
        set_precondition_map((statement_mapping)
                             db_get_memory_resource(DBR_PRECONDITIONS,
                                                    module_name,
                                                    true));*/
        while (!ENDP(l_module_aliases)) {
            alias_association aa1 = ALIAS_ASSOCIATION(CAR(l_module_aliases));
            entity e1 = alias_association_variable(aa1);
            entity sec1 = alias_association_section(aa1);
            list path1 = alias_association_call_chain(aa1);
            expression off1 = alias_association_offset(aa1);
            int l1 = alias_association_lower_offset(aa1);
            int u1 = alias_association_upper_offset(aa1);
            l_module_aliases = CDR(l_module_aliases);
 
            /* Looking for another formal variable in the list of alias
               associations that has same section and included call path.
               If this variable is checked dynamically with e1 => no need
               to continue */
            MAP(ALIAS_ASSOCIATION, aa2, {
                entity e2 = alias_association_variable(aa2);
                entity sec2 = alias_association_section(aa2);
                list path2 = alias_association_call_chain(aa2);
                if (!same_entity_p(e1,e2) && same_entity_p(sec1,sec2) &&
                    !dynamic_checked_p(e1, e2) && included_call_chain_p(path1,path2)) {
 
                    int l2 = alias_association_lower_offset(aa2);
                    int u2 = alias_association_upper_offset(aa2);
 
                    if (((u1==-1)||(u1>=l2))&&((u2==-1)||(u2>=l1))) {
                        expression off2 = alias_association_offset(aa2);
                        if (gen_length(path1) < gen_length(path2))
                            impact_check_two_variables(e1, e2, off1, off2, path2);
                        else
                            impact_check_two_variables(e1, e2, off1, off2, path1);
                    }
                }
            }, l_module_aliases);
 
            /* Looking for common variables in module or callee of modules
               to check for alias impact ... */
            MAP(ENTITY, e2, {
                if (variable_in_common_p(e2)) {
                    ram ra = storage_ram(entity_storage(e2));
                    entity sec2 = ram_section(ra);
                    if (!dynamic_checked_p(e1, e2) && same_entity_p(sec1,sec2)) {
                        /* formal parameter has a same section with other common variable */
                        int l2 = ram_offset(ra);
                        int u2 = l2;
                        if (array_entity_p(e2))
                          {
                            int tmp;
                            if (SizeOfArray(e2, &tmp))
                              u2 = tmp - SizeOfElements(variable_basic(type_variable(entity_type(e2)))) + l2;
                            else
                              user_log("Varying size of common variable");
                          }
                        /* If u1 is defined (different to -1) and u1<l2, there is no alias impact
                           The same for: l1 is defined (different to -1) and u2<l1 */
                        if (((u1==-1)||(u1>=l2)) && (u2>=l1)) {
                            expression off2 = int_to_expression(l2);
                            /* The common variable always have a good offset off2 */
                            impact_check_two_variables(e1, e2, off1, off2, path1);
                        }
                    }
                }
            }, code_declarations(entity_code(current_mod)));
        }
        l_dynamic_check = NIL;
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name,mod_stat);
 
        /*hash_table_free(control_to_set_of_dominators);*/
        /*clean_ctrl_graph();*/
        reset_current_module_entity();
        reset_ordering_to_statement();
        /*reset_precondition_map();*/
        mod_stat = statement_undefined;
    }
    display_impact_alias_statistics();
    l_module_aliases = NIL;
    current_mod = entity_undefined;
 
    debug_off();
    return true;
}