instrumentation.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
string	int_to_dimension (int)
	Warning! Do not modify this file that is automatically generated! More...
bool	array_need_bound_check_p (entity)
	This function returns true, if the array needs bound checks false, otherwise. More...
expression	subscript_value (entity, list)
string	print_variables (expression)
statement	emit_message_and_stop (string)
bool	array_bound_check_bottom_up (const char *)
string	bool_to_bound (bool)
	array_bound_check_top_down.c More...
bool	array_bound_check_top_down (const char *)
statement	array_bound_check_display (void)
	array_bound_check_instrumentation.c More...
bool	old_array_bound_check_instrumentation (const char *)
bool	array_bound_check_instrumentation (const char *)
bool	array_bound_check_interprocedural (const char *)
	array_bound_check_interprocedural.c More...
expression	translate_to_module_frame (entity, entity, expression, call)
	alias_propagation.c More...
bool	alias_propagation (char *)
expression	simplify_relational_expression (expression)
	alias_check.c More...
bool	included_call_chain_p (list, list)
void	print_alias_association (alias_association)
void	print_list_of_alias_associations (list)
bool	functional_call_p (call)
	This function returns true if c is an user-defined function/subroutine. More...
bool	alias_check (char *)
bool	used_before_set (const char *)
	used_before_set.c More...
bool	add_control_counters (const string)
	control_counters.c More...

Function Documentation

add_control_counters()

bool add_control_counters

(

const string

module_name

)

control_counters.c

control_counters.c

Parameters

module_name

odule_name

Definition at line 137 of file control_counters.c.

{
  // get resources from database
  entity module = module_name_to_entity(module_name);
  statement stat =
    (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  set_current_module_entity(module);
  set_current_module_statement(stat);
 
  // do the job
  add_counters(module, stat);
 
  // reset unique identifier for each statement
  module_reorder(stat);
 
  // update resource
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stat);
 
  // cleanup
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References add_counters(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, module, module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

alias_check()

bool alias_check

(

char *

module_name

)

File instrument.out is used to store alias checks and flags

We do not add the line "INCLUDE alias_flags.h" into code_decls_text because of repeated bug for module with ENTRY. 09/11/2001 : do not add INCLUDE any more, because there are modules that do not need this INCLUDE => use script: if a module is modified => add INCLUDE line fprintf(out, "AC: %s (%d,%d)\n",module_local_name(current_mod),0,1); fprintf(out," INCLUDE 'alias_flags.h'\n"); fprintf(out, "ACEND \n");

if the list of alias associations of module is NIL, do nothing

Compute the list of direct and indirect callees of current module

Get the proper and cumulated effects of the module, we have to take both kinds of effects because of their difference for an elementary statement: V(I) = I => cumulated effect : <may be written> V(*) => proper effect : <must be written> V(I) If a cumulated effect for elementary statements = proper effect => we need only cumulated effect

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

Looking for common variables in module or callee of modules to check for alias violation ...

For this moment, only for common variable of module ========> add for chain of callees

Check for write on common variables in callee, keep call path also => to insert test

formal parameter has a same section with other common variable

If u1 is defined (different to -1) and u1<l2, there is no alias violation The same for: l1 is defined (different to -1) and u2<l1

The common variable always have a good offset off2

Parameters

module_name

odule_name

Definition at line 1994 of file alias_check.c.

{
  /* File instrument.out is used to store alias checks and flags*/
  string dir_name = db_get_current_workspace_directory();
  string instrument_file = strdup(concatenate(dir_name, "/instrument.out", NULL));
  free(dir_name), dir_name = NULL;
  out = safe_fopen(instrument_file, "a");  
  number_of_processed_modules++;
  current_mod = local_name_to_top_level_entity(module_name);
  /* We do not add the line "INCLUDE alias_flags.h" into code_decls_text because of
     repeated bug for module with ENTRY.
     09/11/2001 : do not add INCLUDE any more, because there are modules that do not 
     need this INCLUDE => use script: if a module is modified => add INCLUDE line
     fprintf(out, "AC: %s (%d,%d)\n",module_local_name(current_mod),0,1);
     fprintf(out,"      INCLUDE 'alias_flags.h'\n");
     fprintf(out, "ACEND \n");*/
  debug_on("ALIAS_CHECK_DEBUG_LEVEL");
  ifdebug(1)
    fprintf(stderr, " \n Begin alias_check for %s \n", module_name); 
  l_module_aliases = alias_associations_list((alias_associations)
                 db_get_memory_resource(DBR_ALIAS_ASSOCIATIONS,module_name,true)); 
  /* if the list of alias associations of module is NIL, do nothing*/
  if (l_module_aliases != NIL)
    {
      /* Compute the list of direct and indirect callees of current module */
      // list l_callees = compute_all_callees(current_mod);             
      string alias_flag_name = strdup(concatenate(TOP_LEVEL_MODULE_NAME,
                                                  MODULE_SEP_STRING,ALIAS_FLAG,NULL));
      string alias_function_name = strdup(concatenate(TOP_LEVEL_MODULE_NAME,
                                                      MODULE_SEP_STRING,ALIAS_FUNCTION,NULL));
      alias_flag = gen_find_tabulated(alias_flag_name,entity_domain);
      if (entity_undefined_p(alias_flag))
        alias_flag = make_entity(alias_flag_name, 
                                 make_type(is_type_variable,
                                           make_variable(make_basic_logical(4),NIL,NIL)),
                                 storage_undefined, value_undefined);
      alias_function = gen_find_tabulated(alias_function_name,entity_domain);
      if (entity_undefined_p(alias_function))
        alias_function = make_empty_subroutine(ALIAS_FUNCTION,copy_language(module_language(current_mod)));
      module_statement = (statement) db_get_memory_resource(DBR_CODE,module_name,true);
      ifdebug(2)
        {
          fprintf(stderr, " \n The list of alias associations for module %s is:\n", module_name); 
          print_list_of_alias_associations(l_module_aliases);
        }
      set_current_module_entity(current_mod);
      set_ordering_to_statement(module_statement);  
      /* Get the proper and cumulated effects of the module, we have to take both kinds of 
         effects because of their difference for an elementary statement: 
         V(I) = I  => cumulated effect : <may be written> V(*)
                   => proper effect : <must be written> V(I) 
         If a cumulated effect for elementary statements = proper effect => we need only 
         cumulated effect */
      set_cumulated_rw_effects((statement_effects) 
                               db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true)); 
      set_proper_rw_effects((statement_effects) 
                            db_get_memory_resource(DBR_PROPER_EFFECTS,module_name,true));
      initialize_dynamic_check_list();
      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);
                /*
                  Special cases : no alias u1 < l2, u2 <l1, u1< o1, u2 < o1, 
                  o2 + s2 < l1, o1 + s1 < l2
                  So easiest case: If u1,l2 are defined (different to -1) and u1<l2, 
                  there is no alias violation
                  The same for: u2,l1 are defined (different to -1) and u2<l1*/
                if (((u1==-1)||(u1>=l2))&&((u2==-1)||(u2>=l1)))
                  {
                    expression off2 = alias_association_offset(aa2);
                    ifdebug(2) 
                      fprintf(stderr, "\nFound two may be aliased formal parameters: %s, %s. Let's check !\n",
                              entity_name(e1),entity_name(e2));
                    if (gen_length(path1) < gen_length(path2))
                      alias_check_two_variables(e1,e2,off1,off2,path2);
                    else 
                      alias_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 violation ...*/
          
          /* For this moment, only for common variable of module 
             ========> add for chain of callees
 
             Check for write on common variables in callee, keep call path also
             => to insert test*/
          
          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 violation
                       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 */
                        ifdebug(2) 
                          fprintf(stderr,"\n Found may be aliased formal and common variable :%s, %s. Let's check ! \n",
                                  entity_name(e1), entity_name(e2));
                        alias_check_two_variables(e1,e2,off1,off2,path1);
                      }
                  }
              }
          },
              code_declarations(entity_code(current_mod))); 
        }
      l_dynamic_check = NIL;
      reset_proper_rw_effects();
      reset_cumulated_rw_effects();
      DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name,module_statement);
      reset_ordering_to_statement();
      reset_current_module_entity();
      module_statement = statement_undefined;
      // free(alias_flag_name), alias_flag_name = NULL;
      // free(alias_function_name), alias_function_name = NULL;
    }
  else
    user_log("\n No alias for this module \n"); 
 
  safe_fclose(out,instrument_file);
  free(instrument_file), instrument_file= NULL;
  display_alias_check_statistics();
  pips_debug(1, "end\n");
  debug_off();
  l_module_aliases = NIL;
  current_mod = entity_undefined;
  return true;
}

References ALIAS_ASSOCIATION, alias_association_call_chain, alias_association_lower_offset, alias_association_offset, alias_association_section, alias_association_upper_offset, alias_association_variable, alias_associations_list, alias_check_two_variables(), ALIAS_FLAG, alias_flag, ALIAS_FUNCTION, alias_function, array_entity_p(), CAR, CDR, code_declarations, concatenate(), copy_language(), current_mod, db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, display_alias_check_statistics(), dynamic_checked_p(), ENDP, ENTITY, entity_code(), entity_domain, entity_name, entity_storage, entity_type, entity_undefined, entity_undefined_p, fprintf(), free(), gen_find_tabulated(), gen_length(), ifdebug, included_call_chain_p(), initialize_dynamic_check_list(), int_to_expression(), is_type_variable, l_dynamic_check, l_module_aliases, local_name_to_top_level_entity(), make_basic_logical(), make_empty_subroutine(), make_entity, make_type(), make_variable(), MAP, module_language, module_name(), MODULE_SEP_STRING, module_statement, NIL, number_of_processed_modules, out, pips_debug, print_list_of_alias_associations(), ram_offset, ram_section, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_ordering_to_statement(), reset_proper_rw_effects(), safe_fclose(), safe_fopen(), same_entity_p(), set_cumulated_rw_effects(), set_current_module_entity(), set_ordering_to_statement(), set_proper_rw_effects(), SizeOfArray(), SizeOfElements(), statement_undefined, storage_ram, storage_undefined, strdup(), TOP_LEVEL_MODULE_NAME, type_variable, user_log(), value_undefined, variable_basic, and variable_in_common_p().

Here is the call graph for this function:

alias_propagation()

bool alias_propagation

(

char *

module_name

)

No alias for main program

If the current module is never called by the main program => don't need to compute aliases for this module

search for formal parameters in the declaration list

if there is no formal parameter, do nothing

Take the list of callers, if there is no caller, do nothing

The module has no caller => don't need to compute aliases for this module

save to resource

Parameters

module_name

odule_name

Definition at line 903 of file alias_propagation.c.

{
  list l_aliases = NIL;
  current_mod = local_name_to_top_level_entity(module_name);
  set_current_module_entity(current_mod);       
  //  number_of_alias_associations = 0;
  number_of_processed_modules++;
  debug_on("ALIAS_PROPAGATION_DEBUG_LEVEL");
  pips_debug(1,"\nBegin alias propagation for module %s \n", module_name); 
  /* No alias for main program*/
  if (!entity_main_module_p(current_mod))
    {
      if (get_bool_property("ALIAS_CHECKING_USING_MAIN_PROGRAM") &&
          (!module_is_called_by_main_program_p(current_mod)))
        /* If the current module is never called by the main program => 
           don't need to compute aliases for this module*/
        pips_user_warning("Module %s is not called by the main program \n",module_name);
      else 
        {
          list l_decls = code_declarations(entity_code(current_mod)); 
          list l_formals = 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);
          /* if there is no formal parameter, do nothing */
          if (l_formals != NIL)
            {
              /* Take the list of callers, if there is no caller, do nothing */
              callees callers = (callees) db_get_memory_resource(DBR_CALLERS,module_name,true);
              list l_callers = callees_callees(callers);                      
              if (l_callers != NIL)
                {
                  ifdebug(2)
                    {
                      fprintf(stderr,"The list of formal parameters:");
                      print_entities(l_formals);
                      fprintf(stderr,"\nThe list of callers: ");
                      MAP(STRING, caller_name, {
                        (void) fprintf(stderr, "%s, ", caller_name);
                      }, l_callers);
                      (void) fprintf(stderr, "\n");     
                    }
                  l_aliases = alias_propagation_callers(l_callers); 
                }
              else 
                /* The module has no caller => don't need to compute aliases for this module*/
                pips_user_warning("\n Module %s has no caller \n",module_name );
            }
        }
    }
  /* save to resource */
  DB_PUT_MEMORY_RESOURCE(DBR_ALIAS_ASSOCIATIONS,module_name,make_alias_associations(l_aliases));  
  display_alias_propagation_statistics();
  reset_current_module_entity();
  current_mod = entity_undefined;
  debug_off();  
  return true;
}

References alias_propagation_callers(), callees_callees, caller_name, code_declarations, CONS, current_mod, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, display_alias_propagation_statistics(), ENTITY, entity_code(), entity_main_module_p(), entity_undefined, formal_parameter_p(), fprintf(), gen_nconc(), get_bool_property(), ifdebug, local_name_to_top_level_entity(), make_alias_associations(), MAP, module_is_called_by_main_program_p(), module_name(), NIL, number_of_processed_modules, pips_debug, pips_user_warning, print_entities(), reset_current_module_entity(), set_current_module_entity(), and STRING.

Here is the call graph for this function:

array_bound_check_bottom_up()

bool array_bound_check_bottom_up

(

const char *

module_name

)

Begin the dynamic array bound checking phase. Get the code from dbm (true resource)

Reorder the module, because the bound checks have been added

Parameters

module_name

odule_name

Definition at line 1093 of file array_bound_check_bottom_up.c.

{
  statement module_statement;
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  /* Begin the dynamic array bound checking phase.
   * Get the code from dbm (true resource) */
  module_statement= (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  set_current_module_statement(module_statement);
  set_ordering_to_statement(module_statement);
  debug_on("ARRAY_BOUND_CHECK_BOTTOM_UP_DEBUG_LEVEL");
  ifdebug(1)
    {
      debug(1, "Array bound check","Begin for %s\n", module_name);
      pips_assert("Statement is consistent ...", statement_consistent_p(module_statement));
    }
  initialize_bottom_up_abc_statistics();
  bottom_up_abc_statement(module_statement);
  display_bottom_up_abc_statistics();
  /* Reorder the module, because the bound checks have been added */
  module_reorder(module_statement);
  ifdebug(1)
    {
      pips_assert("Statement is consistent ...", statement_consistent_p(module_statement));
      debug(1, "array bound check","End for %s\n", module_name);
    }
  debug_off();
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name,module_statement);
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  return true;
}

References bottom_up_abc_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, display_bottom_up_abc_statistics(), ifdebug, initialize_bottom_up_abc_statistics(), local_name_to_top_level_entity(), module_name(), module_reorder(), module_statement, pips_assert, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), and statement_consistent_p().

Here is the call graph for this function:

array_bound_check_display()

statement array_bound_check_display

(

void

)

array_bound_check_instrumentation.c

Attention : no strdup => newgen error

Definition at line 158 of file array_bound_check_instrumentation.c.

{ 
  string message = "      PRINT *,\'Number of bound checks:\', ARRAY_BOUND_CHECK_COUNT\n" ;
  /* Attention : no strdup => newgen error */
  //  statement retour = make_call_statement(CONTINUE_FUNCTION_NAME,
  //                             NIL,entity_undefined,message);
  return  make_call_statement(CONTINUE_FUNCTION_NAME,
                              NIL,entity_undefined,strdup(message));
}

References CONTINUE_FUNCTION_NAME, entity_undefined, make_call_statement(), NIL, and strdup().

Referenced by initial_code_abc_statement_rwt(), and pips_code_abc_statement_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

array_bound_check_instrumentation()

bool array_bound_check_instrumentation

(

const char *

module_name

)

ser_log("*\n%d variable in %s *\n",gen_length(l),entity_name(sec)); number_of_variables = number_of_variables + gen_length(l);

Eliminate 4 special variables : MAIN000:DYNAMIC, MAIN000:STATIC,MAIN000:HEAP, MAIN000:STACK

Parameters

module_name

odule_name

Definition at line 557 of file array_bound_check_instrumentation.c.

{
  entity mod = local_name_to_top_level_entity(module_name);
  list d = code_declarations(value_code(entity_initial(mod))); 
  MAP(ENTITY,ent,
  {
    if (!formal_parameter_p(ent))
      {
        if (variable_in_common_p(ent))
          {
            entity sec = ram_section(storage_ram(entity_storage(ent))); 
            if (!entity_in_list_p(sec,l_commons)) 
              {
                area a = type_area(entity_type(sec));
                list l = area_layout(a);
                /*user_log("*\n%d variable in %s *\n",gen_length(l),entity_name(sec));
                  number_of_variables = number_of_variables + gen_length(l);*/
                MAP(ENTITY, e, 
                {
                  type t = entity_type(e);
                  if (type_variable_p(t))
                    {
                      if (entity_scalar_p(e))
                        {
                          user_log("*\nCommon and scalar variable %s *\n",entity_name(e));
                          number_of_scalar_variables++;
                        }
                      else
                        {
                          user_log("*\nCommon and array variable %s *\n",entity_name(e));
                          number_of_array_variables++;
                        }
                    }
                },l);
                l_commons = gen_nconc(l_commons,CONS(ENTITY,sec,NIL));
              }
          }
        else 
          {
            if (local_entity_of_module_p(ent,mod))
              {         
                type t = entity_type(ent);
                user_log("*\nLocal variable %s of type %d *\n",entity_name(ent),type_tag(t));
                if (type_variable_p(t))
                  {
                    if (entity_scalar_p(ent))
                      {
                        user_log("*\nLocal and scalar variable %s *\n",entity_name(ent));
                        number_of_scalar_variables++;
                      }
                    else
                      {
                        user_log("*\nLocal and array variable %s *\n",entity_name(ent));
                        number_of_array_variables++;
                      }
                  }
              }
          }
      }
  },d);
  /* Eliminate 4 special variables : MAIN000:*DYNAMIC*, MAIN000:*STATIC*,MAIN000:*HEAP*, MAIN000:*STACK* **/
  user_log("*\nNumber of scalar variables :%d *\n", number_of_scalar_variables);
  user_log("*\nNumber of array variables :%d *\n", number_of_array_variables);
  return true;
} 

References area_layout, code_declarations, CONS, ENTITY, entity_in_list_p(), entity_initial, entity_name, entity_scalar_p(), entity_storage, entity_type, formal_parameter_p(), gen_nconc(), l_commons, local_entity_of_module_p(), local_name_to_top_level_entity(), MAP, module_name(), NIL, number_of_array_variables, number_of_scalar_variables, ram_section, storage_ram, type_area, type_tag, type_variable_p, user_log(), value_code, and variable_in_common_p().

Here is the call graph for this function:

array_bound_check_interprocedural()

bool array_bound_check_interprocedural

(

const char *

module_name

)

array_bound_check_interprocedural.c

s bound checks are added

Parameters

module_name

odule_name

Definition at line 749 of file array_bound_check_interprocedural.c.

{ 
  statement module_statement;  
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  module_statement= (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  set_precondition_map((statement_mapping)
                       db_get_memory_resource(DBR_PRECONDITIONS,module_name,true));
  set_ordering_to_statement(module_statement);
  debug_on("ARRAY_BOUND_CHECK_INTERPROCEDURAL_DEBUG_LEVEL");
  ifdebug(1)
    {
      debug(1, "Interprocedural array bound check","Begin for %s\n", module_name);
      pips_assert("Statement is consistent ...", statement_consistent_p(module_statement));
    }      
  initialize_interprocedural_abc_statistics();
  interprocedural_abc_statement(module_statement);
  display_interprocedural_abc_statistics();
  user_log("* The total number of added tests is %d *\n", 
           total_number_of_added_tests );
  user_log("* The total number of bound violation is %d *\n", 
           total_number_of_bound_violations );
  module_reorder(module_statement); /*as bound checks are added*/
  ifdebug(1)
    {
      pips_assert("Statement is consistent ...", statement_consistent_p(module_statement));
      debug(1, "Interprocedural array bound check","End for %s\n", module_name);
    }
  debug_off(); 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name,module_statement);
  reset_ordering_to_statement();
  reset_precondition_map();
  reset_current_module_entity();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, display_interprocedural_abc_statistics(), ifdebug, initialize_interprocedural_abc_statistics(), interprocedural_abc_statement(), local_name_to_top_level_entity(), module_name(), module_reorder(), module_statement, pips_assert, reset_current_module_entity(), reset_ordering_to_statement(), reset_precondition_map(), set_current_module_entity(), set_ordering_to_statement(), set_precondition_map(), statement_consistent_p(), total_number_of_added_tests, total_number_of_bound_violations, and user_log().

Here is the call graph for this function:

array_bound_check_top_down()

bool array_bound_check_top_down

(

const char *

module_name

)

set and get the current properties concerning regions

Get the code of the module.

Get the READ and WRITE regions of the module

Reorder the module, because the bound checks have been added

Parameters

module_name

odule_name

Definition at line 1129 of file array_bound_check_top_down.c.

{
  statement module_statement;
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  if (!same_string_p(rule_phase(find_rule_by_resource("REGIONS")),
                     "MUST_REGIONS"))
    pips_user_warning("\n MUST REGIONS not selected - "
                      "\n Do not expect wonderful results\n");
  /* set and get the current properties concerning regions */
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
  /* Get the code of the module. */
  module_statement= (statement) db_get_memory_resource(DBR_CODE,
                                                       module_name,
                                                       true);
  set_current_module_statement(module_statement);
  set_ordering_to_statement(module_statement);
  /* Get the READ and WRITE regions of the module */
  set_rw_effects((statement_effects)
                 db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_proper_rw_effects((statement_effects)
                        db_get_memory_resource(DBR_PROPER_EFFECTS,
                                               module_name,true));
  debug_on("ARRAY_BOUND_CHECK_TOP_DOWN_DEBUG_LEVEL");
  pips_debug(1, " Region based ABC, Begin for %s\n", module_name);
  pips_assert("Statement is consistent ...",
              statement_consistent_p(module_statement));
  initialize_top_down_abc_statistics();
  top_down_abc_statement(module_statement);
  display_top_down_abc_statistics();
  /* Reorder the module, because the bound checks have been added */
  module_reorder(module_statement);
  pips_debug(1, "end\n");
  debug_off();
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name, module_statement);
  reset_ordering_to_statement();
  reset_current_module_entity();
  reset_current_module_statement();
  reset_proper_rw_effects();
  reset_rw_effects();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, display_top_down_abc_statistics(), find_rule_by_resource(), get_regions_properties(), initialize_top_down_abc_statistics(), local_name_to_top_level_entity(), module_name(), module_reorder(), module_statement, pips_assert, pips_debug, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), reset_rw_effects(), rule_phase, same_string_p, set_bool_property(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), set_rw_effects(), statement_consistent_p(), and top_down_abc_statement().

Here is the call graph for this function:

array_need_bound_check_p()

bool array_need_bound_check_p

(

entity

e

)

This function returns true, if the array needs bound checks false, otherwise.

If the arrays are not created by user, for example the arrays of Logical Units : LUNS, END_LUNS, ERR_LUNS, ... in the IO_EFFECTS_PACKAGE_NAME, we don't have to check array references for those arrays. Maybe we have to add other kinds of arrays, not only those in IO_EFFECTS

Definition at line 196 of file array_bound_check_bottom_up.c.

{
  const char* s = entity_module_name(e);
  if (strcmp(s,IO_EFFECTS_PACKAGE_NAME)==0)
    return false;
  return true;
}

References entity_module_name(), and IO_EFFECTS_PACKAGE_NAME.

Referenced by bottom_up_abc_reference(), bottom_up_abc_reference_implied_do(), initial_code_abc_reference(), and top_down_abc_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

bool_to_bound()

string bool_to_bound

(

bool

b

)

array_bound_check_top_down.c

Definition at line 115 of file array_bound_check_top_down.c.

{
  if (b)
    return ", lower bound, ";
  return ", upper bound, ";
}

Referenced by make_bottom_up_abc_tests(), and top_down_abc_array().

Here is the caller graph for this function:

emit_message_and_stop()

statement emit_message_and_stop

(

string

stop_message

)

Must be the C version

Parameters

stop_message

top_message

Definition at line 837 of file array_bound_check_bottom_up.c.

{
  statement smt = statement_undefined;
 
  if(fortran_module_p(get_current_module_entity())) {
    //return make_stop_statement(message);
    smt  = make_stop_statement(stop_message);
  }
  else {
    /* Must be the C version */
    smt  = make_exit_statement(1, stop_message);
  }
  return smt;
}

References fortran_module_p(), get_current_module_entity(), make_exit_statement(), make_stop_statement(), and statement_undefined.

Referenced by make_bottom_up_abc_tests(), and make_c_stop_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

functional_call_p()

bool functional_call_p

(

call

c

)

This function returns true if c is an user-defined function/subroutine.

Definition at line 506 of file alias_check.c.

{
  entity fun = call_function(c);
  return entity_module_p(fun);
}

References call_function, and entity_module_p().

Referenced by variable_is_written_by_statement_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

included_call_chain_p()

bool included_call_chain_p	(	list	l1,
		list	l2
	)

Parameters

l1	1
l2	2

Definition at line 246 of file alias_check.c.

{
  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;
}

References CALL_SITE, CAR, CDR, ENDP, and same_call_site_p().

Referenced by alias_check(), same_section_formal_variable_in_list_p(), and tail_call_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

int_to_dimension()

string int_to_dimension

(

int

i

)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/instrumentation/instrumentation-local.h instead, to add your own modifications. header file built by cproto instrumentation-local.h cproto-generated files array_bound_check_bottom_up.c

Definition at line 162 of file array_bound_check_bottom_up.c.

{
  switch(i)
    {
    case 0 :
      return "wrt common size";
    case 1 :
      return "1st dimension";
    case 2 :
      return "2nd dimension";
    case 3 :
      return "3rd dimension";
    case 4 :
      return "4th dimension";
    case 5 :
      return "5th dimension";
    case 6 :
      return "6th dimension";
    case 7 :
      return "7th dimension";
    default:
      return "Over 7!!!";
    }
}

Referenced by make_bottom_up_abc_tests(), and top_down_abc_array().

Here is the caller graph for this function:

old_array_bound_check_instrumentation()

bool old_array_bound_check_instrumentation

(

const char *

module_name

)

add COMMON ARRAY_BOUND_CHECK_COUNT to the declaration if main program : DATA ARRAY_BOUND_CHECK_COUNT 0

Begin the array bound check instrumentation phase. Get the code from dbm (true resource)

Before running the array_bound_check phase, for the implied-DO expression (in statement READ, WRITE of Fortran), we will create new Pips' loops before the READ/WRITE statement, it means that instead of checking array references for implied-DO statement (which is not true if we do it like other statements), we will check array references in new loops added

Reorder the module, because new loops have been added

Reorder the module, because new statements have been added

Parameters

module_name

odule_name

Definition at line 466 of file array_bound_check_instrumentation.c.

{ 
  statement module_statement;  
  /* add COMMON ARRAY_BOUND_CHECK_COUNT to the declaration
     if main program : DATA ARRAY_BOUND_CHECK_COUNT 0*/
  string new_decl = 
    "      INTEGER*8 ARRAY_BOUND_CHECK_COUNT\n"
    "      COMMON /ARRAY_BOUND_CHECK/ ARRAY_BOUND_CHECK_COUNT\n";
  string new_decl_init = 
    "      DATA ARRAY_BOUND_CHECK_COUNT /0/\n";
  string old_decl;
  basic b = make_basic_int(8);
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  mod_ent =  get_current_module_entity();
  abccount = make_scalar_entity(ABC_COUNT,module_name,b);
  old_decl = code_decls_text(entity_code(mod_ent));
  // user_log("Old declaration = %s\n", code_decls_text(entity_code(mod_ent)));  
  if (entity_main_module_p(mod_ent))
    // MAIN PROGRAM 
    code_decls_text(entity_code(mod_ent))
      = strdup(concatenate(old_decl, new_decl, new_decl_init,NULL));
  else 
    code_decls_text(entity_code(mod_ent)) 
      = strdup(concatenate(old_decl, new_decl, NULL));  
  free(old_decl), old_decl = NULL; 
  // user_log("New declaration = %s\n", code_decls_text(entity_code(mod_ent)));  
  //   fprintf(stderr, "NEW = %s\n", code_decls_text(entity_code(mod_ent)));  
  /* Begin the array bound check instrumentation phase. 
   * Get the code from dbm (true resource) */  
  module_statement= (statement) 
    db_get_memory_resource(DBR_CODE, module_name, true);  
  set_current_module_statement(module_statement); 
  set_ordering_to_statement(module_statement);      
  debug_on("ARRAY_BOUND_CHECK_INSTRUMENTATION_DEBUG_LEVEL");  
  if (get_bool_property("INITIAL_CODE_ARRAY_BOUND_CHECK_INSTRUMENTATION"))   
    {
      // instrument the initial code 
      // Rewrite Implied_DO code 
 
      /* Before running the array_bound_check phase, 
       * for the implied-DO expression (in statement 
       * READ, WRITE of Fortran), we will create new Pips' loops 
       * before the READ/WRITE statement, 
       * it means that instead of checking array references 
       * for implied-DO statement (which is not 
       * true if we do it like other statements), we will check 
       * array references in new loops added*/
      
      // rewrite_implied_do(module_statement);     
      /* Reorder the module, because new loops have been added */      
      // module_reorder(module_statement);
      ifdebug(1)
        {
          debug(1, " Initial code array bound check instrumentation",
                "Begin for %s\n", module_name);
          pips_assert("Statement is consistent ...", 
                      statement_consistent_p(module_statement));
        }       
      initial_code_abc_statement(module_statement);
    }
  if (get_bool_property("PIPS_CODE_ARRAY_BOUND_CHECK_INSTRUMENTATION"))
    {
      ifdebug(1)
        {
          debug(1, "PIPS code array bound check instrumentation ",
                "Begin for %s\n", module_name);
          pips_assert("Statement is consistent ...", 
                      statement_consistent_p(module_statement));
        }      
      
      pips_code_abc_statement(module_statement);
    }  
  /* Reorder the module, because new statements have been added */  
  module_reorder(module_statement);  
  ifdebug(1)
    {
      pips_assert("Statement is consistent ...", 
                  statement_consistent_p(module_statement));
      debug(1, "Array bound check instrumentation","End for %s\n", module_name);
    }
  debug_off(); 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,module_name,module_statement);
  reset_ordering_to_statement();
  reset_current_module_statement();
  reset_current_module_entity();
  return true;
}

References ABC_COUNT, abccount, code_decls_text, concatenate(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, entity_code(), entity_main_module_p(), free(), get_bool_property(), get_current_module_entity(), ifdebug, initial_code_abc_statement(), local_name_to_top_level_entity(), make_basic_int(), make_scalar_entity(), mod_ent, module_name(), module_reorder(), module_statement, pips_assert, pips_code_abc_statement(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

print_alias_association()

void print_alias_association

(

alias_association

aa

)

Parameters

aa

a

Definition at line 301 of file alias_check.c.

{
  entity e = alias_association_variable(aa);
  entity sec = alias_association_section(aa);
  expression exp = alias_association_offset(aa);
  list path = alias_association_call_chain(aa);
  int l = alias_association_lower_offset(aa);
  int u = alias_association_upper_offset(aa);
  fprintf(stderr,"\n Alias association :");
  fprintf(stderr,"\n Formal variable %s with",entity_name(e));
  fprintf(stderr, "\n section :%s", entity_name(sec));
  fprintf(stderr, "\n offset :");
  print_expression(exp);
  fprintf(stderr, "lower offset :%d, upper offset: %d \n",l,u);
  fprintf(stderr, "call path :%s \n", print_call_path(path)); 
}

References alias_association_call_chain, alias_association_lower_offset, alias_association_offset, alias_association_section, alias_association_upper_offset, alias_association_variable, entity_name, exp, fprintf(), print_call_path(), and print_expression().

Referenced by formal_variable_add_aliases(), print_list_of_alias_associations(), ram_variable_add_aliases(), and same_or_equivalence_argument_add_aliases().

Here is the call graph for this function:

Here is the caller graph for this function:

print_list_of_alias_associations()

void print_list_of_alias_associations

(

list

l

)

Definition at line 324 of file alias_check.c.

{
  MAP(ALIAS_ASSOCIATION, aa,{
    print_alias_association(aa);
  },l);    
}

References ALIAS_ASSOCIATION, MAP, and print_alias_association().

Referenced by alias_check().

Here is the call graph for this function:

Here is the caller graph for this function:

print_variables()

string print_variables

(

expression

e

)

Definition at line 804 of file array_bound_check_bottom_up.c.

{
  syntax s = expression_syntax(e);
  tag t = syntax_tag(s);
  string retour = "";
  switch (t){
  case is_syntax_range:
    break;
  case is_syntax_call:
    {
      call c = syntax_call(s);
      list args = call_arguments(c);
      MAP(EXPRESSION,exp,
      {
        retour = strdup(concatenate(retour,print_variables(exp),NULL));
      },args);
      break;
    }
  case is_syntax_reference:
    {
      reference ref = syntax_reference(s);
      retour = strdup(concatenate(retour,", \', ",reference_to_string(ref)," =\',",
                                  reference_to_string(ref),NULL));
      break;
    }
  default:
    {
      pips_internal_error("Unexpected expression tag %d ", t );
      break;
    }
  }
  return retour;
}

References call_arguments, concatenate(), exp, EXPRESSION, expression_syntax, is_syntax_call, is_syntax_range, is_syntax_reference, MAP, pips_internal_error, ref, reference_to_string(), strdup(), syntax_call, syntax_reference, and syntax_tag.

Referenced by make_bottom_up_abc_tests(), and make_interprocedural_abc_tests().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_relational_expression()

expression simplify_relational_expression

(

expression

e

)

alias_check.c

If e is a relational expression

Definition at line 139 of file alias_check.c.

{  
  if (relational_expression_p(e))
    {
      /* If e is a relational expression*/
      list args = call_arguments(syntax_call(expression_syntax(e)));
      expression e1 =  EXPRESSION(CAR(args));
      expression e2 = EXPRESSION(CAR(CDR(args)));    
      if (!expression_undefined_p(e1) && !expression_undefined_p(e2))
        {
          normalized n1 = NORMALIZE_EXPRESSION(e1);
          normalized n2 = NORMALIZE_EXPRESSION(e2);
          if (normalized_linear_p(n1) && normalized_linear_p(n2))
            {
              entity op = call_function(syntax_call(expression_syntax(e)));
              Pvecteur v1 = normalized_linear(n1);
              Pvecteur v2 = normalized_linear(n2);
              Pvecteur v = vect_substract(v1,v2);
              expression new_exp;
              vect_normalize(v);
              new_exp = Pvecteur_to_expression(v);
              return binary_intrinsic_expression(entity_local_name(op),new_exp,int_to_expression(0));
            }
        }
    }
  return e;
}

References binary_intrinsic_expression, call_arguments, call_function, CAR, CDR, entity_local_name(), EXPRESSION, expression_syntax, expression_undefined_p, int_to_expression(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, Pvecteur_to_expression(), relational_expression_p(), syntax_call, vect_normalize(), and vect_substract().

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_scalar_variables_in_caller(), and alias_check_two_scalar_variables_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

subscript_value()

expression subscript_value	(	entity	arr,
		list	l_inds
	)

Parameters

arr	rr
l_inds	_inds

Definition at line 276 of file array_bound_check_bottom_up.c.

{
  expression retour = int_to_expression(1);
  if (!ENDP(l_inds))
    {
      variable var = type_variable(entity_type(arr));
      expression prod = expression_undefined;
      list l_dims = variable_dimensions(var);
      int num_dim = gen_length(l_inds),i;
      for (i=1; i<= num_dim; i++)
        {
          dimension dim_i = find_ith_dimension(l_dims,i);
          expression lower_i = dimension_lower(dim_i);
          expression sub_i = find_ith_argument(l_inds,i);
          expression upper_i = dimension_upper(dim_i);
          expression size_i;
          if ( expression_constant_p(lower_i) && (expression_to_int(lower_i)==1))
            size_i = copy_expression(upper_i);
          else
            {
              size_i = binary_intrinsic_expression(MINUS_OPERATOR_NAME,upper_i,lower_i);
              size_i = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                   copy_expression(size_i),int_to_expression(1));
            }
          if (!same_expression_p(sub_i,lower_i))
            {
              expression sub_low_i = binary_intrinsic_expression(MINUS_OPERATOR_NAME,
                                                                 sub_i,lower_i);
              expression elem_i;
              if (expression_undefined_p(prod))
                elem_i = copy_expression(sub_low_i);
              else
                elem_i = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                                     sub_low_i,prod);
              retour = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                   retour, elem_i);
            }
          if (expression_undefined_p(prod))
            prod = copy_expression(size_i);
          else
            prod = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                               prod,size_i);
        }
    }
  ifdebug(4)
    {
      pips_debug(4,"\nSubscript value:");
      print_expression(retour);
    }
  return retour;
}

References binary_intrinsic_expression, copy_expression(), dimension_lower, dimension_upper, ENDP, entity_type, expression_constant_p(), expression_to_int(), expression_undefined, expression_undefined_p, find_ith_argument(), find_ith_dimension(), gen_length(), ifdebug, int_to_expression(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, pips_debug, PLUS_OPERATOR_NAME, print_expression(), same_expression_p(), type_variable, and variable_dimensions.

Referenced by abc_with_allocation_size().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_to_module_frame()

expression translate_to_module_frame	(	entity	mod1,
		entity	mod2,
		expression	e1,
		call	c
	)

alias_propagation.c

alias_propagation.c

Common variable in mod1 => return corresponding common variable e2 in mod2 1.2. Special case : e1 is a formal parameter in mod1, mod2 is caller of mod1 => take corresponding actual argument e2 in call c 1.3. From the association information, if we have e1 = e2 where e2 is constant or contains variables of the mod2 => return e2 2.If e1 is a call : 2.1. Storage rom : numerical constant or symbolic value (PARAMETER) => return e1 2.2. Recursive : e1 = ex1 * ey1 ex2 = translate_to_module_frame(mod1,mod2,ex1,c) ey2 = translate_to_module_frame(mod1,mod2,ey1,c)
=> return e2=ex2*ey2 3.If e1 is a range : error

Return expression_undefined if we can not translate

Check if the common variable is also declared in the mod2 or not We can use ram_shared which contains a list of aliased variables with en but it does not work ????
Another way : looking for a variable in the declaration of the mod2 that has the same offset in the same common block

ATTENTION : enti may be an array, such as A(2): COMMON C1,C2,C3,C4,C5 COMMON C1,A(2,2) we must return A(1,1), not A

Special case : e1 is a formal parameter in mod1, mod2 is caller of mod1 miss a check : mod2 = caller of mod1 => can be wrong !!!

Use the association of the call site: Take only the equalities. Project all variables belonging to mod1 , except the current variable e1 there are 2 cases :

1. The projection is not exact , there are over flows Return the SC_UNDEFINED => what to do, like before ?
2. The result is exact, three small cases: 2.1 The system is always false sc_empty => unreachable code ? 2.2 The system is always true sc_rn => we have nothing ? 2.3 The system is parametric =>

Look for equality that contain e1 Delete e1 from the vector Check if the remaining of the vectors contains only constant (TCTS) or variables of mod2 => return

Attention : here the transformer binding_context is consistent but not the system ps_tmp. I do not understand why ? fprintf(stderr, "consistent psystem ps_tmp before"); pips_assert("consistent psystem ps_tmp", sc_consistent_p(ps_tmp));

Take only the equations of the system

he coefficient of e is 1 or -1. Check if the remaining vector contains only constant or variavbles of mod2

Numerical constant or symbolic value (PARAMETER)

e1 is a call, not a constant Recursive : with the arguments of the call As our generated expression e1 is a call with operators : +,-,* only, we treat only these cases

Parameters

mod1	od1
mod2	od2
e1	1

Definition at line 202 of file alias_propagation.c.

{ 
  if (!expression_undefined_p(e1)) {
  syntax syn = expression_syntax(e1);
  tag t = syntax_tag(syn);
  switch(t){  
  case is_syntax_reference: 
    {
      reference ref = syntax_reference(syn);
      entity en = reference_variable(ref);
      normalized ne;
      if (variable_in_common_p(en))
        {
          /* Check if the common variable is also declared in the mod2 or not 
           * We can use ram_shared which contains a list of aliased variables with en 
           * but it does not work ????  
           * Another way : looking for a variable in the declaration of the mod2
           * that has the same offset in the same common block */
          list l_decls = code_declarations(entity_code(mod2));
          MAP(ENTITY, enti,{
            if (same_scalar_location_p(en,enti))
              {
                pips_debug(4,"\nThe common variable %s is translated\n",entity_local_name(en));
                if (array_entity_p(enti))
                  {
                    /* ATTENTION : enti may be an array, such as A(2):
                       COMMON C1,C2,C3,C4,C5
                       COMMON C1,A(2,2)
                       we must return A(1,1), not A */
                    variable varenti = type_variable(entity_type(enti));                      
                    int len =  gen_length(variable_dimensions(varenti));
                    list l_inds = make_list_of_constant(1,len);
                    reference refer = make_reference(enti,l_inds);
                    return reference_to_expression(refer);
                  }
                return entity_to_expression(enti);
              }
          },l_decls);
          // return the common variable although it is not declared in the module !!!!!!
          //      return entity_to_expression(en);
        }
      if (variable_is_a_module_formal_parameter_p(en,mod1)) 
        {
          formal fo = storage_formal(entity_storage(en));
          entity fun = call_function(c);
          if (same_entity_p(fun,mod1))
            {
              /* Special case : e1 is a formal parameter in mod1, mod2 is caller of mod1
                 miss a check : mod2 = caller of mod1 => can be wrong !!!*/
              int off = formal_offset(fo);
              list l_args = call_arguments(c);
              pips_debug(4,"\nThe formal parameter %s is translated to the caller's frame\n", 
                         entity_local_name(en));
              return find_ith_argument(l_args,off);
            }
        }
      /* Use the association of the call site:
         Take only the equalities.
         Project all variables belonging to mod1 , except the current variable e1
         there are 2 cases :
         1. The projection is not exact , there are over flows
         Return the SC_UNDEFINED => what to do, like before ? 
         2. The result is exact, three small cases: 
         2.1 The system is always false sc_empty => unreachable code ?
         2.2 The system is always true sc_rn => we have nothing ?
         2.3 The system is parametric =>
         
         Look for equality that contain e1
         Delete e1 from the vector 
         Check if the remaining of the vectors contains only constant (TCTS) 
         or variables of mod2 => return*/
      if (expression_equal_integer_p(e1,0)) return e1;
      clean_all_normalized(e1);
      ne =  NORMALIZE_EXPRESSION(e1);
      if (normalized_linear_p(ne))
        {
          Pvecteur ve = normalized_linear(ne);
          Variable vare = var_of(ve); 
          transformer binding_context = formal_and_actual_parameters_association(c,transformer_identity());
          Psysteme ps_tmp = predicate_system(transformer_relation(binding_context));
          Pbase b_tmp = ps_tmp->base;
          /* Attention :   here the transformer binding_context is consistent 
             but not the system ps_tmp. I do not understand why ?
             fprintf(stderr, "consistent psystem ps_tmp before");
             pips_assert("consistent psystem ps_tmp", sc_consistent_p(ps_tmp));*/
          if (base_contains_variable_p(b_tmp,vare))
            {
              Psysteme ps = sc_dup(ps_tmp);
              Pbase b = ps->base;
              Pvecteur pv_var = VECTEUR_NUL;      
              for(; !VECTEUR_NUL_P(b); b = b->succ) 
                {
                  Variable var = vecteur_var(b);
                  if ((strcmp(module_local_name(mod1),entity_module_name((entity)var))==0)
                      && (var!=vare))
                    vect_add_elem(&pv_var, var, VALUE_ONE); 
                }
              ps->inegalites = contraintes_free(ps->inegalites);
              ps->nb_ineq = 0;
              ps = sc_system_projection_along_variables(ps, pv_var);       
              vect_rm(pv_var);  
              if (ps != SC_UNDEFINED)
                {
                  // the projection is exact                   
                  Pcontrainte egal, egal1;
                  for (egal = ps->egalites; egal != NULL; egal = egal1) 
                    {
                      /* Take only the equations of the system */
                      Pvecteur vec = egal->vecteur;
                      if (vect_contains_variable_p(vec,vare))
                        {
                          Value vale = vect_coeff(vare,vec);
                          Pvecteur newv = VECTEUR_UNDEFINED; 
                          if (value_one_p(vale) || value_mone_p(vale))
                            newv = vect_del_var(vec,vare);
                          if  (value_one_p(vale))
                            vect_chg_sgn(newv);
                          if (!VECTEUR_UNDEFINED_P(newv))
                            {
                              /*the coefficient of e is 1 or -1.
                                Check if the remaining vector contains only constant 
                                or variavbles of mod2*/
                              Pvecteur v;
                              bool check = true;
                              for (v = newv; (v !=NULL) && (check); v = v->succ)
                                { 
                                  Variable var = v->var;
                                  if ((var != TCST) && 
                                      (strcmp(module_local_name(mod2),entity_module_name((entity)var))!=0))
                                    check = false;
                                }
                              if (check)
                                {
                                  pips_debug(4,"\nThe variable %s is translated by using binding information\n",
                                             entity_local_name(en));
                                  return Pvecteur_to_expression(newv);
                                }
                              vect_rm(newv);
                            }
                        }
                      egal1 = egal->succ;
                    }
                }        
              sc_rm(ps);
            }
        }
      break;
    }
  case is_syntax_call:
    {
      call ca = syntax_call(syn);
      entity fun = call_function(ca);
      list l_args = call_arguments(ca);
      if (l_args==NIL)
        {
          /* Numerical constant or symbolic value (PARAMETER) */
          ifdebug(4)
            {
              pips_debug(4,"\nNumerical constant or symbolic value is translated\n");
              print_expression(e1);
            }
          return e1;
        }
      /* e1 is a call, not a constant 
         Recursive : with the arguments of the call
         As our generated expression e1 is a call with operators : +,-,* only,
         we treat only these cases */
      if (gen_length(l_args)==1)
        {
          expression ex1 = EXPRESSION(CAR(l_args));
          expression ex2 = translate_to_module_frame(mod1, mod2,ex1,c);
          if (!expression_undefined_p(ex2))
            return MakeUnaryCall(fun,ex2);
        }      
      if (gen_length(l_args)==2)
        {
          expression ex1 = EXPRESSION(CAR(l_args));
          expression ey1 = EXPRESSION(CAR(CDR(l_args)));
          expression ex2 = translate_to_module_frame(mod1,mod2,ex1,c);
          expression ey2 = translate_to_module_frame(mod1,mod2,ey1,c);
          if (!expression_undefined_p(ex2) && !expression_undefined_p(ey2))
            return MakeBinaryCall(fun,ex2,ey2);
        }        
      break;
    }
  default:
    pips_internal_error("Abnormal cases ");
    break;
  }}
  return expression_undefined;
}

References array_entity_p(), Ssysteme::base, base_contains_variable_p(), call_arguments, call_function, CAR, CDR, clean_all_normalized(), code_declarations, contraintes_free(), Ssysteme::egalites, ENTITY, entity_code(), entity_local_name(), entity_module_name(), entity_storage, entity_to_expression(), entity_type, EXPRESSION, expression_equal_integer_p(), expression_syntax, expression_undefined, expression_undefined_p, find_ith_argument(), formal_and_actual_parameters_association(), formal_offset, gen_length(), ifdebug, Ssysteme::inegalites, is_syntax_call, is_syntax_reference, make_list_of_constant(), make_reference(), MakeBinaryCall(), MakeUnaryCall(), MAP, module_local_name(), Ssysteme::nb_ineq, NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, pips_internal_error, predicate_system, print_expression(), Pvecteur_to_expression(), ref, reference_to_expression(), reference_variable, same_entity_p(), same_scalar_location_p(), sc_dup(), sc_rm(), storage_formal, Scontrainte::succ, Svecteur::succ, syntax_call, syntax_reference, syntax_tag, TCST, transformer_identity(), transformer_relation, type_variable, value_mone_p, VALUE_ONE, value_one_p, Svecteur::var, var_of, variable_dimensions, variable_in_common_p(), variable_is_a_module_formal_parameter_p(), vect_add_elem(), vect_chg_sgn(), vect_coeff(), vect_contains_variable_p(), vect_del_var(), vect_rm(), Scontrainte::vecteur, VECTEUR_NUL, VECTEUR_NUL_P, VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_variable_in_caller_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_two_array_variables_in_caller(), formal_variable_add_aliases(), interprocedural_abc_arrays(), ram_variable_add_aliases(), and same_or_equivalence_argument_add_aliases().

Here is the call graph for this function:

Here is the caller graph for this function:

used_before_set()

bool used_before_set

(

const char *

module_name

)

used_before_set.c

File instrument.out is used to store ubs checks

Set and get the current properties concerning regions

Get the code of the module

Get IN regions of the module

File xxx.database/Src/initialization.f contains all the initializations of global variables

Common variable in main program

Local variable in main program, but attention, IN regions contain also static variables of other modules !!!

Formal or common variable

Local variable

save to resource

Parameters

module_name

odule_name

Definition at line 1046 of file used_before_set.c.

{ 
  list l_in_regions = NIL;
  ubs module_ubs; 
  string user_file = db_get_memory_resource(DBR_USER_FILE,module_name,true);
  string base_name = pips_basename(user_file, NULL);
  /* File instrument.out is used to store ubs checks*/
  string dir_name = db_get_current_workspace_directory();
  string instrument_file = strdup(concatenate(dir_name, "/instrument.out", NULL));
  out = safe_fopen(instrument_file, "a");  
  file_name = strdup(concatenate(db_get_directory_name_for_module(WORKSPACE_SRC_SPACE), 
                                 "/",base_name,NULL));
  number_of_processed_modules ++;
  if (!same_string_p(rule_phase(find_rule_by_resource("REGIONS")),"MUST_REGIONS"))
    pips_user_warning("\nMUST REGIONS not selected - " "Do not expect wonderful results\n");
  /* Set and get the current properties concerning regions */
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
  current_mod = local_name_to_top_level_entity(module_name);
  set_current_module_entity(current_mod);
  /* Get the code of the module */
  module_statement = (statement) db_get_memory_resource(DBR_CODE,module_name,true);
  set_current_module_statement(module_statement);
  /* Get IN regions of the module */
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS,module_name,true));
  regions_init(); 
  set_ordering_to_statement(module_statement);  
  debug_on("USED_BEFORE_SET_DEBUG_LEVEL");
  l_in_regions = load_statement_in_regions(module_statement);
  ifdebug(2)
    {
      pips_debug(2,"List of IN regions of module %s:",module_name);
      print_inout_regions(l_in_regions);
    }
  fprintf(out,"%s\t%s\t%s\t(0,1)\n",PREFIX1,file_name,module_name);
  fprintf(out,"      EXTERNAL ir_isnan,id_isnan\n");
  fprintf(out,"      LOGICAL*4 ir_isnan,id_isnan\n");
  fprintf(out,"%s\n",PREFIX2);
  if (entity_main_module_p(current_mod))
    {
      /* File xxx.database/Src/initialization.f contains all the initializations of 
         global variables */
      initialization_file = strdup(concatenate(dir_name, "/Src/initialization.f", NULL));
      out2 = safe_fopen(initialization_file, "a");  
      MAP(REGION,reg,
      {
        entity ent = region_entity(reg);
        if (strcmp(entity_module_name(ent),IO_EFFECTS_PACKAGE_NAME)!=0)
          {
            if (variable_in_common_p(ent))
              /* Common variable in main program */
              initialize_and_verify_common_variable(ent,reg);
            else 
              {
                /* Local variable in main program, but attention, 
                   IN regions contain also static variables of other modules !!!*/              
                if (local_name_to_top_level_entity(entity_module_name(ent)) == current_mod)
                  initialize_and_verify_local_variable(ent,reg);
              }
          }
      },l_in_regions);
      safe_fclose(out2,initialization_file);
      free(initialization_file), initialization_file = NULL;
    }
  else
    {    
      callees callers = (callees) db_get_memory_resource(DBR_CALLERS,module_name,true);
      list l_callers = callees_callees(callers); 
      MAP(REGION,reg,
      {
        entity ent = region_entity(reg);
        if (strcmp(entity_module_name(ent),IO_EFFECTS_PACKAGE_NAME)!=0)
          {
            if (formal_parameter_p(ent)||variable_in_common_p(ent))
              /* Formal or common variable */
              verify_formal_and_common_variables(ent,l_callers);
            else 
              {
                /* Local variable */
                if (local_name_to_top_level_entity(entity_module_name(ent)) == current_mod)
                  initialize_and_verify_local_variable(ent,reg);
              }
          }
      },l_in_regions); 
    }
  module_ubs = make_ubs(l_ubs_checks);
  //  message_assert("module ubs is consistent",ubs_consistent_p(module_ubs));
  /* save to resource */
  DB_PUT_MEMORY_RESOURCE(DBR_UBS,module_name,copy_ubs(module_ubs));  
  display_used_before_set_statistics();
  debug_off(); 
  safe_fclose(out,instrument_file);
  free(instrument_file), instrument_file = NULL;
  free(dir_name), dir_name = NULL;
  current_mod = entity_undefined;
  reset_ordering_to_statement();
  regions_end();
  reset_in_effects();
  reset_current_module_statement(); 
  reset_current_module_entity();
  return true;
}

References callees_callees, concatenate(), copy_ubs(), current_mod, db_get_current_workspace_directory(), db_get_directory_name_for_module(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, display_used_before_set_statistics(), entity_main_module_p(), entity_module_name(), entity_undefined, file_name, find_rule_by_resource(), formal_parameter_p(), fprintf(), free(), get_regions_properties(), ifdebug, initialization_file, initialize_and_verify_common_variable(), initialize_and_verify_local_variable(), IO_EFFECTS_PACKAGE_NAME, l_ubs_checks, load_statement_in_regions(), local_name_to_top_level_entity(), make_ubs(), MAP, module_name(), module_statement, NIL, number_of_processed_modules, out, out2, pips_basename(), pips_debug, pips_user_warning, PREFIX1, PREFIX2, print_inout_regions(), REGION, region_entity, regions_end(), regions_init(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), rule_phase, safe_fclose(), safe_fopen(), same_string_p, set_bool_property(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_ordering_to_statement(), strdup(), user_file, variable_in_common_p(), verify_formal_and_common_variables(), and WORKSPACE_SRC_SPACE.

Here is the call graph for this function: