#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "alias_private.h"
#include "database.h"
#include "pipsdbm.h"
#include "resources.h"
#include "misc.h"
#include "properties.h"
#include "effects-generic.h"
#include "instrumentation.h"
#include "text-util.h"

Include dependency graph for alias_check.c:

Data Structures
struct	alias_context_t

Macros
#define	PREFIX1 "$ALIAS_CHECK"
	TO AMELIORATE : for the moment, we only use trivial_expression_p to compare offsets + array sizes CAN TAKE MORE INFORMATION from array declarations, A(l:u) => u>l not precondtitions (corrupted) More...

#define	PREFIX2 "$ALIAS_CHECK_END"

#define	ALIAS_FLAG "ALIAS_FLAG"

#define	ALIAS_FUNCTION "DYNAMIC_ALIAS_CHECK"

Typedefs
typedef struct alias_context_t *	alias_context_p

Functions
expression	simplify_relational_expression (expression e)
	alias_check.c More...

static void	display_alias_check_statistics ()

static void	initialize_dynamic_check_list ()

static bool	dynamic_checked_p (entity e1, entity e2)

static void	set_dynamic_checked (entity e1, entity e2)

static bool	same_call_site_p (call_site cs1, call_site cs2)

bool	included_call_chain_p (list l1, list l2)

static bool	tail_call_path_p (call_site cs, list l1, list l2)

static string	print_call_path (list path)
	This function prints the call path , including names of caller functions and orderings of call sites in their corresponding functions. More...

void	print_alias_association (alias_association aa)

void	print_list_of_alias_associations (list l)

static expression	array_size_stride (entity ent)

static void	insert_test_before_statement (expression flags, expression condition, statement s, entity e1, entity e2, list path)

static void	insert_flag_before_call_site (list flags, list path)

static void	insert_test_before_caller (expression condition, expression e_flag)

static list	make_list_of_flags (list path)

bool	functional_call_p (call c)
	This function returns true if c is an user-defined function/subroutine. More...

static bool	variable_is_written_by_statement_flt (statement s)
	This function returns true if the variable is written directly in the current module, not by its callees (do not take into account the effects on X,Y of statement like CALL FOO(X,Y)) More...

static bool	variable_is_written_p (entity ent)

static void	insert_check_alias_before_statement (entity e1, expression subval, entity e2, expression size, statement s)

static bool	dynamic_alias_check_flt (statement s, alias_context_p context)

static bool	alias_check_scalar_variable_in_module_flt (statement s, alias_context_p context)

static bool	alias_check_array_and_scalar_variable_in_module_flt (statement s, alias_context_p context)

static bool	alias_check_array_variable_in_module_flt (statement s, alias_context_p context)

static void	alias_check_two_scalar_variables_in_module (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_scalar_and_array_variables_in_module (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_two_array_variables_in_module (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_in_module (entity e1, entity e2, expression off1, expression off2, list path)

static bool	alias_check_scalar_variable_in_caller_flt (statement s, alias_context_p context)

static bool	alias_check_array_and_scalar_variable_in_caller_flt (statement s, alias_context_p context)

static bool	alias_check_array_variable_in_caller_flt (statement s, alias_context_p context)

static void	alias_check_two_scalar_variables_in_caller (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_scalar_and_array_variables_in_caller (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_two_array_variables_in_caller (entity e1, entity e2, expression off1, expression off2, list path)

static void	alias_check_in_caller (entity e1, entity e2, expression off1, expression off2, list path)

static expression	storage_ram_offset (storage s, expression subval)

static expression	storage_formal_offset (call_site cs, entity actual_var, expression subval, list path)

static expression	offset_in_caller (entity e, call_site cs, list path)

static bool	search_statement_by_ordering_flt (statement s)

static void	alias_check_two_variables (entity e1, entity e2, expression off1, expression off2, list path)

bool	alias_check (char *module_name)

Variables
static entity	current_mod = entity_undefined

static entity	current_caller = entity_undefined

static const char *	caller_name

static call	current_call = call_undefined

static list	l_module_aliases = NIL

static statement	module_statement = statement_undefined

static statement	current_statement = statement_undefined

static int	current_ordering = 0

static FILE *	out

static entity	alias_flag = entity_undefined

static entity	alias_function = entity_undefined

static list	l_dynamic_check = NIL
	This list tells us if two variables have been checked dynamically or not. More...

static int	unique_flag_number = 0

static int	number_of_tests = 0

static int	number_of_calls = 0

static int	number_of_processed_modules = 0

static bool	written = false

static entity	current_entity = entity_undefined

Macro Definition Documentation

◆ ALIAS_FLAG

#define ALIAS_FLAG "ALIAS_FLAG"

Definition at line 104 of file alias_check.c.

◆ ALIAS_FUNCTION

#define ALIAS_FUNCTION "DYNAMIC_ALIAS_CHECK"

Definition at line 105 of file alias_check.c.

◆ PREFIX1

#define PREFIX1 "$ALIAS_CHECK"

TO AMELIORATE : for the moment, we only use trivial_expression_p to compare offsets + array sizes CAN TAKE MORE INFORMATION from array declarations, A(l:u) => u>l not precondtitions (corrupted)

for words_to_string

Definition at line 102 of file alias_check.c.

◆ PREFIX2

#define PREFIX2 "$ALIAS_CHECK_END"

Definition at line 103 of file alias_check.c.

Typedef Documentation

◆ alias_context_p

typedef struct alias_context_t * alias_context_p

Function Documentation

◆ 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_check_array_and_scalar_variable_in_caller_flt()

static bool alias_check_array_and_scalar_variable_in_caller_flt	(	statement	s,
		alias_context_p	context
	)

static

Attention : <may be written> V(*,*) => what kind of indices ???

Translate subval2 to the frame of caller, in order to compare with offsets

off1 == ref2 is false => Okay, no write on aliased variable

k = 0 or 1

We can not translate subval to the frame of caller => use dynamic check

The variable is not in the list of write effects => OK

Definition at line 1231 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 list l_inds = reference_indices(r);
                 /* Attention : <may be written> V(*,*) => what kind of indices ???*/
                 expression subval2 = subscript_value_stride(context->first_entity,l_inds);
                 /* Translate subval2 to the frame of caller, in order to compare with offsets*/
                 expression new_subval2 = translate_to_module_frame(current_mod,current_caller,subval2,current_call);
                 if (!expression_undefined_p(new_subval2))
                   { 
                     expression diff;
                     int k;
                     if (same_expression_p(context->offset1,context->offset2))
                       diff = eq_expression(int_to_expression(0),new_subval2);
                     else
                       {
                         expression ref2;
                         if (expression_equal_integer_p(context->offset2,0))
                           ref2 = copy_expression(new_subval2);
                         else
                           ref2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,context->offset2,new_subval2);
                         diff = eq_expression(context->offset1,ref2);
                       }
                     clean_all_normalized(diff);
                     k = trivial_expression_p(diff);
                     switch(k){
                     case -1: 
                       /* off1 == ref2 is false =>  Okay, no write on aliased variable */
                       return false;
                     default:
                       {
                         /* k = 0 or 1*/
                         expression e_flag = reference_to_expression(make_reference(alias_flag,
                                      CONS(EXPRESSION,int_to_expression(++unique_flag_number),NIL)));
                         ifdebug(2)
                           {
                             fprintf(stderr, "\n New flag expression: \n");
                             print_expression(e_flag);
                           }
                         if (true_expression_p(context->flags))
                           insert_test_before_statement(e_flag,make_true_expression(),s,
                                                        context->first_entity,context->second_entity,
                                                        context->path);
                         else
                           insert_test_before_statement(and_expression(e_flag,context->flags),
                                                        make_true_expression(),s,
                                                        context->first_entity,context->second_entity,
                                                        context->path);
                         if (k==0)
                           insert_test_before_caller(simplify_relational_expression(diff),e_flag);
                         else 
                           insert_test_before_caller(make_true_expression(),e_flag);
                         context->insert = true;
                         return false;
                       }
                     }
                   }
                 else
                   {
                     /* We can not translate subval to the frame of caller => use dynamic check*/
                     insert_check_alias_before_statement(context->first_entity,subval2,
                                                         context->second_entity,int_to_expression(0),s);
                     return false;
                     //user_log("\n Warning : Can not translate writing reference to frame of caller \n");
                   }
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, alias_flag, and_expression, approximation_exact_p, binary_intrinsic_expression, clean_all_normalized(), CONS, copy_expression(), current_call, current_caller, current_mod, EFFECT, effect_action, effect_any_reference, effect_approximation, eq_expression, EXPRESSION, expression_equal_integer_p(), expression_undefined_p, fprintf(), ifdebug, insert_check_alias_before_statement(), insert_test_before_caller(), insert_test_before_statement(), int_to_expression(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), make_reference(), make_true_expression(), MAP, NIL, PLUS_OPERATOR_NAME, print_expression(), reference_indices, reference_to_expression(), reference_variable, same_entity_p(), same_expression_p(), simplify_relational_expression(), statement_call_p(), subscript_value_stride(), translate_to_module_frame(), trivial_expression_p(), true_expression_p(), and unique_flag_number.

Referenced by alias_check_scalar_and_array_variables_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_array_and_scalar_variable_in_module_flt()

static bool alias_check_array_and_scalar_variable_in_module_flt	(	statement	s,
		alias_context_p	context
	)

static

Attention : <may be written> V(*,*) => what kind of indices ???

off1 == ref2 is false => Okay, no write on aliased variable

k = 0 or 1

The variable is not in the list of write effects => OK

Definition at line 696 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 list l_inds = reference_indices(r);
                 /* Attention : <may be written> V(*,*) => what kind of indices ???*/
                 expression subval2 = subscript_value_stride(context->first_entity,l_inds);
                 expression diff;
                 int k;
                 if (same_expression_p(context->offset1,context->offset2))
                   diff = eq_expression(int_to_expression(0),subval2);
                 else
                   {
                     expression ref2;
                     if (expression_equal_integer_p(context->offset2,0))
                       ref2 = copy_expression(subval2);
                     else
                       ref2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,context->offset2,subval2);
                     diff = eq_expression(context->offset1,ref2);
                   }
                 clean_all_normalized(diff);
                 k = trivial_expression_p(diff);
                 switch(k){
                 case -1: 
                   /* off1 == ref2 is false =>  Okay, no write on aliased variable */
                   return false;
                 default:
                   {
                     /* k = 0 or 1*/
                     if (k==0)
                       insert_test_before_statement(context->flags,simplify_relational_expression(diff),s,
                                                    context->first_entity,context->second_entity,
                                                    context->path);
                     else 
                       insert_test_before_statement(context->flags,make_true_expression(),s,
                                                    context->first_entity,context->second_entity,
                                                    context->path);
                     
                     context->insert = true;
                     return false;              
                   }
                 }
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, approximation_exact_p, binary_intrinsic_expression, clean_all_normalized(), copy_expression(), EFFECT, effect_action, effect_any_reference, effect_approximation, eq_expression, expression_equal_integer_p(), insert_test_before_statement(), int_to_expression(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), make_true_expression(), MAP, NIL, PLUS_OPERATOR_NAME, reference_indices, reference_variable, same_entity_p(), same_expression_p(), simplify_relational_expression(), statement_call_p(), subscript_value_stride(), and trivial_expression_p().

Referenced by alias_check_scalar_and_array_variables_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_array_variable_in_caller_flt()

static bool alias_check_array_variable_in_caller_flt	(	statement	s,
		alias_context_p	context
	)

static

REATED ? CASE READ *,ARRAY

Attention : <may be written> V(*,*) => what kind of indices ???

Translate subval1 to the frame of caller, in order to compare with offsets

off2 <= ref1 is false => Okay, no write on aliased variable

Test of assumed-size array has been carried out before Translate size2 to the frame of caller, in order to compare with offsets

ref1 <= off2+size_stride2 is false => Okay, no write on aliased variable

k1 = 0 or 1, k2 = 0 or 1

We can not translate size2 to the frame of caller => create new common variable

We can not translate subval1 to the frame of caller => use dynamic check

The variable is not in the list of write effects => OK

Definition at line 1331 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
  
                 /*TREATED ? CASE READ *,ARRAY */
  
                 list l_inds = reference_indices(r);
                 /* Attention : <may be written> V(*,*) => what kind of indices ???*/
                 expression subval1 = subscript_value_stride(context->first_entity,l_inds);
                 /* Translate subval1 to the frame of caller, in order to compare with offsets*/
                 expression new_subval1 = translate_to_module_frame(current_mod,current_caller,
                                                                    subval1,current_call);
                 if (!expression_undefined_p(new_subval1))
                   {
                     expression diff1 = expression_undefined;
                     int k1;
                     expression ref1 = expression_undefined;
                     if (same_expression_p(context->offset1,context->offset2))
                       diff1 = ge_expression(new_subval1,int_to_expression(0));
                     else
                       {
                         if (expression_equal_integer_p(context->offset1,0))
                           ref1 = copy_expression(new_subval1);
                         else
                           ref1 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,context->offset1,new_subval1);
                         diff1 = ge_expression(ref1,context->offset2);
                       }
                     clean_all_normalized(diff1);
                     k1 = trivial_expression_p(diff1);
                     switch(k1){
                     case -1: 
                       /* off2 <= ref1 is false =>  Okay, no write on aliased variable */
                       break;
                     default:
                       {
                         expression size2 = array_size_stride(context->second_entity);
                         /* Test of assumed-size array has been carried out before 
                            Translate size2 to the frame of caller, in order to compare with offsets*/
                         size2 =  translate_to_module_frame(current_mod,current_caller,size2,current_call);
                         if (!expression_undefined_p(size2))
                           {
                             expression diff2;
                             int k2;
                             if (same_expression_p(context->offset1,context->offset2))
                               diff2 = le_expression(new_subval1,size2);
                             else
                               {
                                 expression sum2;
                                 if (expression_equal_integer_p(context->offset2,0))
                                   sum2 = copy_expression(size2);
                                 else
                                   sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,context->offset2,size2);
                                 diff2 = le_expression(ref1,sum2);
                               }
                             clean_all_normalized(diff2);
                             k2 = trivial_expression_p(diff2);
                             switch(k2){
                             case -1: 
                               /* ref1 <= off2+size_stride2 is false =>  Okay, no write on aliased variable */
                               break;
                             default:
                               {
                                 /* k1 = 0 or 1, k2 = 0 or 1*/
                                 expression e_flag = reference_to_expression(make_reference(alias_flag,
                                             CONS(EXPRESSION,int_to_expression(++unique_flag_number),NIL)));
                                 ifdebug(2)
                                   {
                                     fprintf(stderr, "\n New flag expression: \n");
                                     print_expression(e_flag);
                                   }
                                 if (true_expression_p(context->flags))
                                   insert_test_before_statement(e_flag,make_true_expression(),s,
                                                                context->first_entity,context->second_entity,
                                                                context->path);
                                 else
                                   insert_test_before_statement(and_expression(e_flag,context->flags),
                                                                make_true_expression(),s,
                                                                context->first_entity,context->second_entity,
                                                                context->path);
                                 if (k1+k2==0) // k1=k2=0
                                   insert_test_before_caller(and_expression(simplify_relational_expression(diff1),
                                                                            simplify_relational_expression(diff2)),e_flag);
                                 else 
                                   {
                                     if (k1+k2==2) // k1=k2=1
                                       insert_test_before_caller(make_true_expression(),e_flag);
                                     else
                                       {
                                         if (k1==0) // k1=0, k2=1
                                           insert_test_before_caller(simplify_relational_expression(diff1),e_flag);
                                         else // k2=0, k1=1
                                           insert_test_before_caller(simplify_relational_expression(diff2),e_flag);
                                       }
                                   }
                                 context->insert = true;
                                 break;
                               }
                             }
                           }
                         else
                           /* We can not translate size2 to the frame of caller => create new common variable*/
                           pips_user_warning("\nCan not translate size of array to frame of caller \n");
                         break;
                       }
                     }
                   }
                 else
                   {
                     /* We can not translate subval1 to the frame of caller => use dynamic check*/
                     expression size2 = array_size_stride(context->second_entity);
                     insert_check_alias_before_statement(context->first_entity,subval1,
                                                         context->second_entity,size2,s);
                   }
                 return false;
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, alias_flag, and_expression, approximation_exact_p, array_size_stride(), binary_intrinsic_expression, clean_all_normalized(), CONS, copy_expression(), current_call, current_caller, current_mod, EFFECT, effect_action, effect_any_reference, effect_approximation, EXPRESSION, expression_equal_integer_p(), expression_undefined, expression_undefined_p, fprintf(), ge_expression, ifdebug, insert_check_alias_before_statement(), insert_test_before_caller(), insert_test_before_statement(), int_to_expression(), k1, k2, le_expression, load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), make_reference(), make_true_expression(), MAP, NIL, pips_user_warning, PLUS_OPERATOR_NAME, print_expression(), reference_indices, reference_to_expression(), reference_variable, same_entity_p(), same_expression_p(), simplify_relational_expression(), statement_call_p(), subscript_value_stride(), translate_to_module_frame(), trivial_expression_p(), true_expression_p(), and unique_flag_number.

Referenced by alias_check_two_array_variables_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_array_variable_in_module_flt()

static bool alias_check_array_variable_in_module_flt	(	statement	s,
		alias_context_p	context
	)

static

Attention : <may be written> V(*,*) => what kind of indices ???

off2 <= ref1 is false => Okay, no write on aliased variable

ref1 <= off2+size_stride2 is false => Okay, no write on aliased variable

k1 = 0 or 1, k2 = 0 or 1

The variable is not in the list of write effects => OK

Definition at line 773 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 list l_inds = reference_indices(r);
                 /* Attention : <may be written> V(*,*) => what kind of indices ???*/
                 expression subval1 = subscript_value_stride(context->first_entity,l_inds);
                 expression diff1;
                 int k1;
                 expression ref1;
                 if (expression_equal_integer_p(context->offset1,0))
                   ref1 = copy_expression(subval1);
                 else
                   ref1 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                      context->offset1,subval1);
                 if (same_expression_p(context->offset1,context->offset2))
                   diff1 = ge_expression(subval1,int_to_expression(0));
                 else
                   diff1 = ge_expression(ref1,context->offset2);
                 clean_all_normalized(diff1);
                 k1 = trivial_expression_p(diff1);
                 switch(k1){
                 case -1: 
                   /* off2 <= ref1 is false =>  Okay, no write on aliased variable */
                   return false;
                 default:
                   {
                     expression size2 = array_size_stride(context->second_entity);
                     // test of assumed-size array is carried out before
                     expression diff2;
                     int k2;
                     if (same_expression_p(context->offset1,context->offset2))
                       diff2 = le_expression(subval1,size2);
                     else
                       {
                         expression sum2;
                         if (expression_equal_integer_p(context->offset2,0))
                           sum2 = copy_expression(size2);
                         else
                           sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                              context->offset2,size2);
                         diff2 = le_expression(ref1,sum2);
                       }
                     clean_all_normalized(diff2);
                     k2 = trivial_expression_p(diff2);
                     switch(k2){
                     case -1: 
                       /* ref1 <= off2+size_stride2 is false =>  Okay, no write on aliased variable */
                       return false;
                     default:
                       {
                         /* k1 = 0 or 1, k2 = 0 or 1*/
                         if (k1+k2==0) // k1=k2=0
                           insert_test_before_statement(context->flags,
                                                        and_expression(simplify_relational_expression(diff1),
                                                                       simplify_relational_expression(diff2)),
                                                        s,context->first_entity,context->second_entity,
                                                        context->path);
                         else 
                           {
                             if (k1+k2==2) // k1=k2=1
                               insert_test_before_statement(context->flags,make_true_expression(),s,
                                                            context->first_entity,context->second_entity,
                                                            context->path);
                             else
                               {
                                 if (k1==0) // k1=0, k2=1
                                   insert_test_before_statement(context->flags,
                                                                simplify_relational_expression(diff1),s,
                                                                context->first_entity,context->second_entity,
                                                                context->path);
                                 else // k2=0, k1=1
                                   insert_test_before_statement(context->flags,
                                                                simplify_relational_expression(diff2),s,
                                                                context->first_entity,context->second_entity,
                                                                context->path);
                               }
                           }
                         context->insert = true;
                         return false;
                       }
                     }
                     return false;
                   }
                 }
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, and_expression, approximation_exact_p, array_size_stride(), binary_intrinsic_expression, clean_all_normalized(), copy_expression(), EFFECT, effect_action, effect_any_reference, effect_approximation, expression_equal_integer_p(), ge_expression, insert_test_before_statement(), int_to_expression(), k1, k2, le_expression, load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), make_true_expression(), MAP, NIL, PLUS_OPERATOR_NAME, reference_indices, reference_variable, same_entity_p(), same_expression_p(), simplify_relational_expression(), statement_call_p(), subscript_value_stride(), and trivial_expression_p().

Referenced by alias_check_two_array_variables_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_in_caller()

static void alias_check_in_caller	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

Definition at line 1788 of file alias_check.c.

 {
  if (entity_scalar_p(e1) && entity_scalar_p(e2))
     alias_check_two_scalar_variables_in_caller(e1,e2,off1,off2,path);
   
   if (entity_scalar_p(e1) && !entity_scalar_p(e2))
     alias_check_scalar_and_array_variables_in_caller(e1,e2,off1,off2,path);
   
   if (!entity_scalar_p(e1) && entity_scalar_p(e2))
     alias_check_scalar_and_array_variables_in_caller(e2,e1,off2,off1,path);
  
   if (!entity_scalar_p(e1) && !entity_scalar_p(e2))
     alias_check_two_array_variables_in_caller(e1,e2,off1,off2,path);
 }

References alias_check_scalar_and_array_variables_in_caller(), alias_check_two_array_variables_in_caller(), alias_check_two_scalar_variables_in_caller(), and entity_scalar_p().

Referenced by alias_check_two_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_in_module()

static void alias_check_in_module	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

There are 3 cases:

Case 1: e1 and e2 are scalar variables
Case 2: e1 is a scalar variable, e2 is an array variable or vice-versa
Case 3: e1 and e2 are array variables

Definition at line 1161 of file alias_check.c.

 {
   /* There are 3 cases:
      - Case 1: e1 and e2 are scalar variables
      - Case 2: e1 is a scalar variable, e2 is an array variable or vice-versa
      - Case 3: e1 and e2 are array variables */
  
   if (entity_scalar_p(e1) && entity_scalar_p(e2))
     alias_check_two_scalar_variables_in_module(e1,e2,off1,off2,path);
   
   if (entity_scalar_p(e1) && !entity_scalar_p(e2))
     alias_check_scalar_and_array_variables_in_module(e1,e2,off1,off2,path);
   
   if (!entity_scalar_p(e1) && entity_scalar_p(e2))
     alias_check_scalar_and_array_variables_in_module(e2,e1,off2,off1,path);
  
   if (!entity_scalar_p(e1) && !entity_scalar_p(e2))
     alias_check_two_array_variables_in_module(e1,e2,off1,off2,path);
 }

References alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_module(), alias_check_two_scalar_variables_in_module(), and entity_scalar_p().

Referenced by alias_check_two_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_scalar_and_array_variables_in_caller()

static void alias_check_scalar_and_array_variables_in_caller	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

off2 <= off1 is false => Okay, no alias between these 2 variables

Translate size2 to the frame of caller, in order to compare with offsets

off1 <= off2+size_stride2 is false => Okay, no alias between these 2 variables

k1 = 0 or 1, k2 = 0 or 1 insert flag before each call site in call path and for the current caller, we add the condition

Attention: there are differences between scalar and array variables when adding test/flag before current statement and current caller. For array variable, we must take into account the ref (reference), it must be sure if this reference is written or not. So new flag is inserted to guarantee if the reference is written.

Assumed-size or pointer-type array, the size of dummy array can be derived from the size of actual argument, as we have the corresponding call chain

Definition at line 1546 of file alias_check.c.

 {
   expression diff1 = le_expression(off2,off1);
   int k1;
   clean_all_normalized(diff1);
   k1 = trivial_expression_p(diff1);
   ifdebug(2)
     fprintf(stderr,"\n Check in caller, scalar and array variables \n");
   switch(k1){
   case -1: 
     /* off2 <= off1 is false => Okay, no alias between these 2 variables */
     return;
   default:
     {
       expression size2 = array_size_stride(e2);
       if (!expression_undefined_p(size2))
         {
           /* Translate size2 to the frame of caller, in order to compare with offsets*/
           size2 = translate_to_module_frame(current_mod,current_caller,size2,current_call);
           if (!expression_undefined_p(size2))
             {
               expression diff2;
               int k2;
               if (same_expression_p(off1,off2))
                 diff2 = le_expression(int_to_expression(0),size2);
               else
                 {
                   expression sum2;
                   if (expression_equal_integer_p(off2,0))
                     sum2 = copy_expression(size2);
                   else
                     sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off2,size2);
                   diff2 = le_expression(off1,sum2);
                 }
               clean_all_normalized(diff2);
               k2 = trivial_expression_p(diff2);
               switch(k2){
               case -1: 
                 /* off1 <= off2+size_stride2 is false => Okay, no alias between these 2 variables */
                 return;
               default:
                 {
                   /* k1 = 0 or 1, k2 = 0 or 1
                      insert flag before each call site in call path and for the current caller, 
                      we add the condition */
                   list l_flags = make_list_of_flags(path);
                   alias_context_t context;
                   context.insert = false;
                   context.path = path;
                   context.flags = expression_list_to_conjonction(l_flags);
                   context.first_entity = e1;
                   context.second_entity = e2;
                   gen_context_recurse(module_statement,&context, statement_domain, 
                                       alias_check_scalar_variable_in_caller_flt, gen_null2);
  
                   /* Attention: there are differences between scalar and array variables 
                      when adding test/flag before current statement and current caller. 
                      For array variable, we must take into account the ref (reference),
                      it must be sure if this reference is written or not. So new flag
                      is inserted to guarantee if the reference is written. */
  
                   if (ENDP(CDR(l_flags)))
                     context.flags = make_true_expression();
                   else
                     context.flags = expression_list_to_conjonction(CDR(l_flags));
                   context.offset1 = off1;
                   context.offset2 = off2;
                   context.first_entity = e2;
                   context.second_entity = e1;
                   gen_context_recurse(module_statement,&context, statement_domain, 
                                       alias_check_array_and_scalar_variable_in_caller_flt, gen_null2);
                   
                   if (context.insert)
                     {
                       insert_flag_before_call_site(CDR(l_flags),CDR(path));
                       if (variable_is_written_p(e1))
                         {
                           expression e_flag = EXPRESSION(CAR(l_flags));
                           if (k1+k2==0) // k1=k2=0
                             insert_test_before_caller(and_expression(simplify_relational_expression(diff1),
                                                                      simplify_relational_expression(diff2)),e_flag);
                           else 
                             {
                               if (k1+k2==2) // k1=k2=1
                                 insert_test_before_caller(make_true_expression(),e_flag);
                               else
                                 {
                                   if (k1==0) // k1=0, k2=1
                                     insert_test_before_caller(simplify_relational_expression(diff1),e_flag);
                                   else // k2=0, k1=1
                                     insert_test_before_caller(simplify_relational_expression(diff2),e_flag);
                                 }
                             }
                         }
                     }
                   context.first_entity = entity_undefined;
                   context.second_entity = entity_undefined;
                   context.offset1 = expression_undefined;
                   context.offset2 = expression_undefined;
                   context.condition = expression_undefined;
                   context.flags = expression_undefined;
                   context.path = NIL;
                 }
               }
             }
           else
             pips_user_warning("\nCan not translate size of array to frame of caller");
         }
       else
         /* Assumed-size or pointer-type array, the size of dummy array can be 
            derived from the size of actual argument, as we have the corresponding call chain*/
         pips_user_warning("\nAssumed-size or pointer-type array \n");  
     }
   }
 }

References alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_scalar_variable_in_caller_flt(), and_expression, array_size_stride(), binary_intrinsic_expression, CAR, CDR, clean_all_normalized(), copy_expression(), current_call, current_caller, current_mod, ENDP, entity_undefined, EXPRESSION, expression_equal_integer_p(), expression_list_to_conjonction(), expression_undefined, expression_undefined_p, fprintf(), gen_context_recurse, gen_null2(), ifdebug, insert_flag_before_call_site(), insert_test_before_caller(), int_to_expression(), k1, k2, le_expression, make_list_of_flags(), make_true_expression(), module_statement, NIL, pips_user_warning, PLUS_OPERATOR_NAME, same_expression_p(), simplify_relational_expression(), statement_domain, translate_to_module_frame(), trivial_expression_p(), and variable_is_written_p().

Referenced by alias_check_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_scalar_and_array_variables_in_module()

static void alias_check_scalar_and_array_variables_in_module	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

off2 <= off1 is false => Okay, no alias between these 2 variables

off1 <= off2+size_stride2 is false => Okay, no alias between these 2 variables

k1 = 0 or 1, k2 = 0 or 1 insert flags before each call site in call path

Assumed-size or pointer-type array, the size of dummy array can be derived from the size of actual argument, as we have the corresponding call chain

Definition at line 955 of file alias_check.c.

 {
   expression diff1 = le_expression(off2,off1);
   int k1;
   clean_all_normalized(diff1);
   k1 = trivial_expression_p(diff1);
   ifdebug(2)
     fprintf(stderr,"\n Check in module, scalar and array variables \n");
   switch(k1){
   case -1: 
     /* off2 <= off1 is false => Okay, no alias between these 2 variables */
     return;
   default:
     {
       expression size2 = array_size_stride(e2);
       if (!expression_undefined_p(size2)) // not assumed-size array
         {
           expression diff2;
           int k2;
           if (same_expression_p(off1,off2))
             diff2 = le_expression(int_to_expression(0),size2);
           else
             {
               expression sum2;
               if (expression_equal_integer_p(off2,0))
                 sum2 = copy_expression(size2);
               else
                 sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off2,size2);
               diff2 = le_expression(off1,sum2);
             }
           clean_all_normalized(diff2);
           k2 = trivial_expression_p(diff2);
           switch(k2){
           case -1: 
             /* off1 <= off2+size_stride2 is false => Okay, no alias between these 2 variables */
             return;
           default:
             {
               /* k1 = 0 or 1, k2 = 0 or 1
                  insert flags before each call site in call path*/
               list l_flags = make_list_of_flags(path);
               alias_context_t context;
               context.insert = false;
               context.path = path;
               context.flags = expression_list_to_conjonction(l_flags);
               if (k1+k2==0) // k1=k2=0
                 context.condition = and_expression(simplify_relational_expression(diff1),
                                                    simplify_relational_expression(diff2));
               else 
                 {
                   if (k1+k2==2) // k1=k2=1
                     context.condition = make_true_expression();
                   else
                     {
                       if (k1==0) // k1=0, k2=1
                         context.condition = simplify_relational_expression(diff1); 
                       else // k2=0, k1=1
                         context.condition = simplify_relational_expression(diff2);
                     }
                 }
               context.first_entity = e1;
               context.second_entity = e2;
               gen_context_recurse(module_statement,&context, statement_domain,
                                   alias_check_scalar_variable_in_module_flt,gen_null2);
               context.offset1 = off1;
               context.offset2 = off2;
               context.first_entity = e2;
               context.second_entity = e1;
               gen_context_recurse(module_statement,&context, statement_domain,
                                   alias_check_array_and_scalar_variable_in_module_flt,gen_null2);
               if (context.insert)
                 insert_flag_before_call_site(l_flags,path);
               context.first_entity = entity_undefined;
               context.second_entity = entity_undefined;
               context.offset1 = expression_undefined;
               context.offset2 = expression_undefined;
               context.condition = expression_undefined;
               context.flags = expression_undefined;
               context.path = NIL;
             }
           }
         }
       else
         /* Assumed-size or pointer-type array, the size of dummy array can be 
          derived from the size of actual argument, as we have the corresponding call chain*/
         pips_user_warning("\nAssumed-size or pointer-type array \n");
     }
   }
 }

References alias_check_array_and_scalar_variable_in_module_flt(), alias_check_scalar_variable_in_module_flt(), and_expression, array_size_stride(), binary_intrinsic_expression, clean_all_normalized(), copy_expression(), entity_undefined, expression_equal_integer_p(), expression_list_to_conjonction(), expression_undefined, expression_undefined_p, fprintf(), gen_context_recurse, gen_null2(), ifdebug, insert_flag_before_call_site(), int_to_expression(), k1, k2, le_expression, make_list_of_flags(), make_true_expression(), module_statement, NIL, pips_user_warning, PLUS_OPERATOR_NAME, same_expression_p(), simplify_relational_expression(), statement_domain, and trivial_expression_p().

Referenced by alias_check_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_scalar_variable_in_caller_flt()

static bool alias_check_scalar_variable_in_caller_flt	(	statement	s,
		alias_context_p	context
	)

static

The variable is not in the list of write effects => OK

Definition at line 1190 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 insert_test_before_statement(context->flags,make_true_expression(),s,
                                              context->first_entity,context->second_entity,
                                              context->path);
                 context->insert = true;
                 return false;
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, approximation_exact_p, EFFECT, effect_action, effect_any_reference, effect_approximation, insert_test_before_statement(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), make_true_expression(), MAP, NIL, reference_variable, same_entity_p(), and statement_call_p().

Referenced by alias_check_scalar_and_array_variables_in_caller(), and alias_check_two_scalar_variables_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_scalar_variable_in_module_flt()

static bool alias_check_scalar_variable_in_module_flt	(	statement	s,
		alias_context_p	context
	)

static

The variable is not in the list of write effects => OK

Definition at line 654 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 insert_test_before_statement(context->flags,context->condition,s,
                                              context->first_entity,context->second_entity,
                                              context->path);
                 context->insert = true;
                 return false;
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, approximation_exact_p, EFFECT, effect_action, effect_any_reference, effect_approximation, insert_test_before_statement(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), MAP, NIL, reference_variable, same_entity_p(), and statement_call_p().

Referenced by alias_check_scalar_and_array_variables_in_module(), and alias_check_two_scalar_variables_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_two_array_variables_in_caller()

static void alias_check_two_array_variables_in_caller	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

Translate size2 to the frame of caller, in order to compare with offsets

off1>off2+size_stride2 is true => Okay, no alias between these 2 variables

Translate size1 to the frame of caller, in order to compare with offsets

off2 > off1+size_stride1 is true => Okay, no alias between these 2 variables

insert flag before each call site in call path

Assumed-size or pointer-type array, the size of dummy array can be derived from the size of actual argument, as we have the corresponding call chain

Definition at line 1678 of file alias_check.c.

 {
   expression size2 = array_size_stride(e2);
   if (!expression_undefined_p(size2))
     {
       /* Translate size2 to the frame of caller, in order to compare with offsets*/
       size2 = translate_to_module_frame(current_mod,current_caller,size2,current_call);
       if (!expression_undefined_p(size2))
         {
           expression sum2,diff1;
           int k1;
           if (expression_equal_integer_p(off2,0))
             sum2 = copy_expression(size2);
           else
             sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off2,size2);
           diff1 = gt_expression(off1,sum2);
           clean_all_normalized(diff1);
           k1 = trivial_expression_p(diff1);
           ifdebug(2) 
             fprintf(stderr,"\n Check in caller, 2 array variables \n");
           switch(k1){
           case 1: 
             /* off1>off2+size_stride2 is true => Okay, no alias between these 2 variables */
             return;
           default:
             { 
               expression size1 = array_size_stride(e1);
               if (!expression_undefined_p(size1))
                 {
                   /* Translate size1 to the frame of caller, in order to compare with offsets*/
                   size1 = translate_to_module_frame(current_mod,current_caller,size1,current_call);
                   if (!expression_undefined_p(size1))
                     {
                       expression sum1,diff2;
                       int k2;
                       if (expression_equal_integer_p(off1,0))
                         sum1 = copy_expression(size1);
                       else
                         sum1 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off1,size1);
                       diff2 = gt_expression(off2,sum1);
                       clean_all_normalized(diff2);
                       k2 = trivial_expression_p(diff2);
                       switch(k2){
                       case 1: 
                         /* off2 > off1+size_stride1 is true => Okay, no alias between these 2 variables */
                         return;
                       default:
                         {
                           /* insert flag before each call site in call path */
                           list l_flags = NIL;
                           alias_context_t context;
                           context.insert = false;
                           context.path = path;
                           if (ENDP(CDR(path)))
                             context.flags = make_true_expression();
                           else
                             {
                               l_flags = make_list_of_flags(CDR(path));
                               context.flags = expression_list_to_conjonction(l_flags);
                             }
                           context.first_entity = e1;
                           context.second_entity = e2;
                           context.offset1 = off1;
                           context.offset2 = off2;
                           gen_context_recurse(module_statement,&context, statement_domain, 
                                               alias_check_array_variable_in_caller_flt, gen_null2);
                           context.first_entity = e2;
                           context.second_entity = e1;
                           context.offset1 = off2;
                           context.offset2 = off1;
                           gen_context_recurse(module_statement,&context, statement_domain,
                                               alias_check_array_variable_in_caller_flt, gen_null2);
  
                           if (context.insert)
                             insert_flag_before_call_site(l_flags,CDR(path));
                           context.first_entity = entity_undefined;
                           context.second_entity = entity_undefined;
                           context.offset1 = expression_undefined;
                           context.offset2 = expression_undefined;
                           context.condition = expression_undefined;
                           context.flags = expression_undefined;
                           context.path = NIL;
                         }
                       }
                     }
                   else
                     pips_user_warning("\nCan not translate size of array to frame of caller");
                 }
               else 
                 /* Assumed-size or pointer-type array, the size of dummy array can be 
                    derived from the size of actual argument, as we have the corresponding call chain*/
                 pips_user_warning("\nAssumed-size or pointer-type array \n");  
             }
           }
         }
       else
         pips_user_warning("\nCan not translate size of array to frame of caller");
     }
   else 
     /* Assumed-size or pointer-type array, the size of dummy array can be 
        derived from the size of actual argument, as we have the corresponding call chain*/
     pips_user_warning("\nAssumed-size or pointer-type array \n");      
 }

References alias_check_array_variable_in_caller_flt(), array_size_stride(), binary_intrinsic_expression, CDR, clean_all_normalized(), copy_expression(), current_call, current_caller, current_mod, ENDP, entity_undefined, expression_equal_integer_p(), expression_list_to_conjonction(), expression_undefined, expression_undefined_p, fprintf(), gen_context_recurse, gen_null2(), gt_expression, ifdebug, insert_flag_before_call_site(), k1, k2, make_list_of_flags(), make_true_expression(), module_statement, NIL, pips_user_warning, PLUS_OPERATOR_NAME, statement_domain, translate_to_module_frame(), and trivial_expression_p().

Referenced by alias_check_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_two_array_variables_in_module()

static void alias_check_two_array_variables_in_module	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

off1> off2+size_stride2 is true => Okay, no alias between these 2 variables

off2 > off1+size_stride1 is true => Okay, no alias between these 2 variables

insert flags before each call site in call path

Assumed-size or pointer-type array, the size of dummy array can be derived from the size of actual argument, as we have the corresponding call chain

Definition at line 1062 of file alias_check.c.

 {
   expression size2 = array_size_stride(e2);
   if (!expression_undefined_p(size2)) // not assumed-size array
     {
       expression sum2,diff1;
       int k1;
       if (expression_equal_integer_p(off2,0))
         sum2 = copy_expression(size2);
       else
         sum2 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off2,size2);
       diff1 = gt_expression(off1,sum2);
       clean_all_normalized(diff1);
       k1 = trivial_expression_p(diff1);
       ifdebug(2)
         fprintf(stderr,"\n Check in module, 2 array variables \n");
       switch(k1){
       case 1: 
         {
           ifdebug(3) 
             fprintf(stderr,"\n off1> off2+size_stride2 is true => Okay, no alias between these 2 variables \n");
           /* off1> off2+size_stride2 is true => Okay, no alias between these 2 variables */
           return;
         }
       default:
         { 
           expression size1 = array_size_stride(e1);
           if (!expression_undefined_p(size1)) // not assumed-size array
             {
               expression sum1,diff2;
               int k2;
               if (expression_equal_integer_p(off1,0))
                 sum1 = copy_expression(size1);
               else
                 sum1 = binary_intrinsic_expression(PLUS_OPERATOR_NAME,off1,size1);
               diff2 = gt_expression(off2,sum1);
               clean_all_normalized(diff2);
               k2 = trivial_expression_p(diff2);
               switch(k2){
               case 1: 
                 {
                   ifdebug(3) 
                     fprintf(stderr,"\n  off2 > off1+size_stride1 is true => Okay, no alias between these 2 variables \n");
                   /* off2 > off1+size_stride1 is true => Okay, no alias between these 2 variables */
                   return;
                 }
               default:
                 {
                   /* insert flags before each call site in call path*/
                   list l_flags = make_list_of_flags(path);
                   alias_context_t context;
                   context.insert = false;
                   context.path = path;
                   context.flags = expression_list_to_conjonction(l_flags);
                   context.first_entity = e1;
                   context.second_entity = e2;
                   context.offset1 = off1;
                   context.offset2 = off2;
                   gen_context_recurse(module_statement,&context, statement_domain,
                                       alias_check_array_variable_in_module_flt, gen_null2);
                   context.first_entity = e2;
                   context.second_entity = e1;
                   context.offset1 = off2;
                   context.offset2 = off1;
                   gen_context_recurse(module_statement,&context, statement_domain,
                                       alias_check_array_variable_in_module_flt, gen_null2);
                   if (context.insert)
                     insert_flag_before_call_site(l_flags,path);
                   context.first_entity = entity_undefined;
                   context.second_entity = entity_undefined;
                   context.offset1 = expression_undefined;
                   context.offset2 = expression_undefined;
                   context.condition = expression_undefined;
                   context.flags = expression_undefined;
                   context.path = NIL;
                 }
               }
             }
           else 
             /* Assumed-size or pointer-type array, the size of dummy array can be 
                derived from the size of actual argument, as we have the corresponding call chain*/
             pips_user_warning("\nAssumed-size or pointer-type array \n");
         }
       }
     }
   else 
     /* Assumed-size or pointer-type array, the size of dummy array can be 
        derived from the size of actual argument, as we have the corresponding call chain*/
     pips_user_warning("\nAssumed-size or pointer-type array \n");
 }

References alias_check_array_variable_in_module_flt(), array_size_stride(), binary_intrinsic_expression, clean_all_normalized(), copy_expression(), entity_undefined, expression_equal_integer_p(), expression_list_to_conjonction(), expression_undefined, expression_undefined_p, fprintf(), gen_context_recurse, gen_null2(), gt_expression, ifdebug, insert_flag_before_call_site(), k1, k2, make_list_of_flags(), module_statement, NIL, pips_user_warning, PLUS_OPERATOR_NAME, statement_domain, and trivial_expression_p().

Referenced by alias_check_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_two_scalar_variables_in_caller()

static void alias_check_two_scalar_variables_in_caller	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

Should we use also formal and actual binding / precondition ???

off1 != off2 => Okay, no alias between these 2 variables

insert flags before each call site in call path and for the current caller, we add the condition

Definition at line 1481 of file alias_check.c.

 {
   expression diff = eq_expression(off1,off2);
   int k;
   clean_all_normalized(diff);
   k = trivial_expression_p(diff);
   /* Should we use also formal and actual binding / precondition ??? */
   ifdebug(2)
     fprintf(stderr,"\n Check in caller, 2 scalar variables \n");
   switch(k){
   case -1: 
     /* off1 != off2 => Okay, no alias between these 2 variables */
     return;
   default:
     {
       /* insert flags before each call site in call path and for the
          current caller, we add the condition */
       list l_flags = make_list_of_flags(path);
       alias_context_t context;
       context.insert = false;
       context.path = path;
       context.flags = expression_list_to_conjonction(l_flags);
       context.first_entity = e1;
       context.second_entity = e2;
       gen_context_recurse(module_statement,&context, statement_domain, 
                           alias_check_scalar_variable_in_caller_flt, gen_null2);
       context.first_entity = e2;
       context.second_entity = e1;
       gen_context_recurse(module_statement,&context, statement_domain, 
                           alias_check_scalar_variable_in_caller_flt, gen_null2);
       if (context.insert)
         {
           expression e_flag = EXPRESSION(CAR(l_flags));
           insert_flag_before_call_site(CDR(l_flags),CDR(path));
           if (k==1)
             insert_test_before_caller(make_true_expression(),e_flag);
           else
             insert_test_before_caller(simplify_relational_expression(diff),e_flag);
         }
       context.first_entity = entity_undefined;
       context.second_entity = entity_undefined;
       context.offset1 = expression_undefined;
       context.offset2 = expression_undefined;
       context.condition = expression_undefined;
       context.flags = expression_undefined;
       context.path = NIL;
     }
   }
 }

References alias_check_scalar_variable_in_caller_flt(), CAR, CDR, clean_all_normalized(), entity_undefined, eq_expression, EXPRESSION, expression_list_to_conjonction(), expression_undefined, fprintf(), gen_context_recurse, gen_null2(), ifdebug, insert_flag_before_call_site(), insert_test_before_caller(), make_list_of_flags(), make_true_expression(), module_statement, NIL, simplify_relational_expression(), statement_domain, and trivial_expression_p().

Referenced by alias_check_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_two_scalar_variables_in_module()

static void alias_check_two_scalar_variables_in_module	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

Should we use also formal and actual binding / precondition ???

off1 != off2 => Okay, no alias between these 2 variables

insert flags before each call site in call path

Definition at line 894 of file alias_check.c.

 {
   expression diff = eq_expression(off1,off2);
   int k;
   clean_all_normalized(diff);
   k = trivial_expression_p(diff);
   /* Should we use also formal and actual binding / precondition ??? */
   ifdebug(2)
     fprintf(stderr,"\n Check in module, 2 scalar variables \n");
   switch(k){
   case -1: 
     /* off1 != off2 => Okay, no alias between these 2 variables */
     return;
   default:
     {
       /* insert flags before each call site in call path*/
       list l_flags = make_list_of_flags(path);
       alias_context_t context;
       context.insert = false;
       context.path = path;
       context.flags = expression_list_to_conjonction(l_flags);    
       if (k==1)
         context.condition = make_true_expression();
       else   
         context.condition = simplify_relational_expression(diff);
       context.first_entity = e1;
       context.second_entity = e2;
       gen_context_recurse(module_statement,&context, statement_domain, 
                           alias_check_scalar_variable_in_module_flt, gen_null2);
       context.first_entity = e2;
       context.second_entity = e1;
       gen_context_recurse(module_statement,&context, statement_domain, 
                           alias_check_scalar_variable_in_module_flt, gen_null2);
       if (context.insert) 
         insert_flag_before_call_site(l_flags,path);
       context.first_entity = entity_undefined;
       context.second_entity = entity_undefined;
       context.offset1 = expression_undefined;
       context.offset2 = expression_undefined;
       context.condition = expression_undefined;
       context.flags = expression_undefined;
       context.path = NIL;
     }
   }
 }

References alias_check_scalar_variable_in_module_flt(), clean_all_normalized(), entity_undefined, eq_expression, expression_list_to_conjonction(), expression_undefined, fprintf(), gen_context_recurse, gen_null2(), ifdebug, insert_flag_before_call_site(), make_list_of_flags(), make_true_expression(), module_statement, NIL, simplify_relational_expression(), statement_domain, and trivial_expression_p().

Referenced by alias_check_in_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_check_two_variables()

static void alias_check_two_variables	(	entity	e1,
		entity	e2,
		expression	off1,
		expression	off2,
		list	path
	)

static

e1 or e2 is written => check for alias violation

As we do not have exact offsets of variables, we have to go to the caller's frame to check for alias violations. 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.

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

Definition at line 1918 of file alias_check.c.

 {
   if (variable_is_written_p(e1) || variable_is_written_p(e2))
     {
       /* e1 or e2 is written => check for alias violation*/
       if (!expression_undefined_p(off1) && !expression_undefined_p(off2))
         alias_check_in_module(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 violations. 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;
           current_caller = call_site_function(cs);
           current_ordering = call_site_ordering(cs);
           caller_name = module_local_name(current_caller);
           caller_statement = (statement)db_get_memory_resource(DBR_CODE,caller_name,true);
           current_statement = statement_undefined;
           
           gen_recurse(caller_statement,statement_domain,
                       search_statement_by_ordering_flt,gen_null);
       
           if (!statement_undefined_p(current_statement) && statement_call_p(current_statement))
             {
               expression new_off1, new_off2;
               current_call = statement_call(current_statement);
               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))
                 alias_check_in_caller(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*/
                   alias_context_t context;
                   context.first_entity = e1;
                   context.second_entity = e2;
                   gen_context_recurse(module_statement,&context,statement_domain,
                                       dynamic_alias_check_flt,gen_null2);
                   context.first_entity = e2;
                   context.second_entity = e1;
                   gen_context_recurse(module_statement,&context,statement_domain,
                                       dynamic_alias_check_flt,gen_null2);
                   context.first_entity = entity_undefined;
                   context.second_entity = entity_undefined;
                   set_dynamic_checked(e1,e2);
                 }
               current_call = call_undefined;
             }
           else 
             pips_user_warning("Problem with statement ordering *\n"); 
           current_statement = statement_undefined;
           current_ordering = 0;
           current_caller = entity_undefined;
         }
     }
 }

References alias_check_in_caller(), alias_check_in_module(), CALL_SITE, call_site_function, call_site_ordering, call_undefined, caller_name, CAR, current_call, current_caller, current_ordering, current_statement, db_get_memory_resource(), dynamic_alias_check_flt(), entity_undefined, expression_undefined_p, gen_context_recurse, gen_null(), gen_null2(), gen_recurse, module_local_name(), module_statement, offset_in_caller(), pips_user_warning, search_statement_by_ordering_flt(), set_dynamic_checked(), statement_call(), statement_call_p(), statement_domain, statement_undefined, statement_undefined_p, and variable_is_written_p().

Referenced by alias_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ array_size_stride()

static expression array_size_stride ( entity ent )

static

else return expression_undefined with assumed-size or pointer-type array

Definition at line 338 of file alias_check.c.

 {
   expression exp = expression_undefined;
   if (!assumed_size_array_p(ent) && !pointer_type_array_p(ent))
     {
       variable var = type_variable(entity_type(ent));   
       list l_dims = variable_dimensions(var);
       int num_dim = gen_length(l_dims),j;
       basic b = variable_basic(type_variable(entity_type(ent)));
       expression e_size = int_to_expression(SizeOfElements(b));
       for (j=1; j<= num_dim; j++)
         {
           dimension dim_j = find_ith_dimension(l_dims,j);
           expression lower_j = dimension_lower(dim_j);
           expression upper_j = dimension_upper(dim_j);
           expression size_j;
           if (expression_constant_p(lower_j) && (expression_to_int(lower_j)==1))
             size_j = copy_expression(upper_j);
           else 
             {
               size_j = binary_intrinsic_expression(MINUS_OPERATOR_NAME,upper_j,lower_j);
               size_j =  binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                                     copy_expression(size_j),int_to_expression(1));
             }
           if (expression_undefined_p(exp))
             exp = copy_expression(size_j);
           else
             exp = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                               copy_expression(exp),size_j);  
         }
       exp = binary_intrinsic_expression(MINUS_OPERATOR_NAME,copy_expression(exp),int_to_expression(1));
       exp = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,copy_expression(exp),e_size);
       ifdebug(2)
         {
           fprintf(stderr, "\n Stride of array size : \n");
           print_expression(exp);
         }
     }
   /* else return expression_undefined with assumed-size or pointer-type array*/
   return exp;
 }

References assumed_size_array_p(), binary_intrinsic_expression, copy_expression(), dimension_lower, dimension_upper, entity_type, exp, expression_constant_p(), expression_to_int(), expression_undefined, expression_undefined_p, find_ith_dimension(), fprintf(), gen_length(), ifdebug, int_to_expression(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, pointer_type_array_p(), print_expression(), SizeOfElements(), type_variable, variable_basic, and variable_dimensions.

Referenced by 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_array_variables_in_caller(), alias_check_two_array_variables_in_module(), and dynamic_alias_check_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ display_alias_check_statistics()

static void display_alias_check_statistics ( )

static

Definition at line 167 of file alias_check.c.

 {
   user_log("\n Number of flags : %d", unique_flag_number); 
   user_log("\n Number of tests : %d", number_of_tests);
   user_log("\n Number of calls : %d", number_of_calls);
   user_log("\n Number of processed modules: %d\n",number_of_processed_modules); 
 }

References number_of_calls, number_of_processed_modules, number_of_tests, unique_flag_number, and user_log().

Referenced by alias_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dynamic_alias_check_flt()

static bool dynamic_alias_check_flt	(	statement	s,
		alias_context_p	context
	)

static

Assumed-size or pointer-type array, the size of dummy array can not be derived from the size of actual argument as we have no corresponding call chain

The variable is not in the list of write effects => OK

Definition at line 603 of file alias_check.c.

 {
   list l_rw = NIL;
   if (statement_call_p(s))
     l_rw = load_proper_rw_effects_list(s);
   else
     l_rw = load_cumulated_rw_effects_list(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,context->first_entity))
           {
             approximation rw = effect_approximation(eff);
             if (approximation_exact_p(rw))
               {
                 list l_inds = reference_indices(r);
                 expression subval = subscript_value_stride(context->first_entity,l_inds);
                 expression size;
                 if (array_entity_p(context->second_entity))
                   size = array_size_stride(context->second_entity);
                 else 
                   size = int_to_expression(0);
                 if (!expression_undefined_p(size)) // not assumed-size array
                   insert_check_alias_before_statement(context->first_entity,subval,
                                                       context->second_entity,size,s);
                 else
                   /* Assumed-size or pointer-type array, the size of dummy array can not be 
                      derived from the size of actual argument as we have no corresponding call chain*/
                   pips_user_warning("\nAssumed-size or pointer-type array \n");
                 return false;
               }
             return true;
           }
       }
   },
       l_rw); 
   return false; /* The variable is not in the list of write effects => OK*/
 }

References action_write_p, approximation_exact_p, array_entity_p(), array_size_stride(), EFFECT, effect_action, effect_any_reference, effect_approximation, expression_undefined_p, insert_check_alias_before_statement(), int_to_expression(), load_cumulated_rw_effects_list(), load_proper_rw_effects_list(), MAP, NIL, pips_user_warning, reference_indices, reference_variable, same_entity_p(), statement_call_p(), and subscript_value_stride().

Referenced by alias_check_two_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dynamic_checked_p()

static bool dynamic_checked_p	(	entity	e1,
		entity	e2
	)

static

Definition at line 209 of file alias_check.c.

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

References DYNAMIC_CHECK, dynamic_check_checked, dynamic_check_first, dynamic_check_second, l_dynamic_check, and MAP.

Referenced by alias_check().

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:

◆ initialize_dynamic_check_list()

static void initialize_dynamic_check_list ( )

static

search for formal parameters in the declaration list

Definition at line 175 of file alias_check.c.

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

References code_declarations, CONS, current_mod, DYNAMIC_CHECK, ENTITY, entity_code(), formal_parameter_p(), gen_nconc(), l_commons, l_dynamic_check, make_dynamic_check(), MAP, NIL, and variable_in_common_p().

Referenced by alias_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_check_alias_before_statement()

static void insert_check_alias_before_statement	(	entity	e1,
		expression	subval,
		entity	e2,
		expression	size,
		statement	s
	)

static

Definition at line 563 of file alias_check.c.

 {
   string message = strdup(concatenate("\'Alias violation in module ",
                                       module_local_name(current_mod),": write on ",
                                       entity_local_name(e1),", aliased with ",
                                       entity_local_name(e2),"\'", NULL));
   list l = CONS(EXPRESSION,size,NIL);
   statement smt;
   int order = statement_ordering(s);
   const char* mod_name = module_local_name(current_mod);
   string user_file = db_get_memory_resource(DBR_USER_FILE,mod_name,true);
   string base_name = pips_basename(user_file, NULL);
   string file_name = strdup(concatenate(db_get_directory_name_for_module(WORKSPACE_SRC_SPACE), "/",base_name,NULL));
   l = CONS(EXPRESSION,entity_to_expression(e2),l);
   l = CONS(EXPRESSION,subval,l);
   l = CONS(EXPRESSION,entity_to_expression(e1),l);
   l = CONS(EXPRESSION,MakeCharacterConstantExpression(message),l);
   smt = call_to_statement(make_call(alias_function,l));
   fprintf(out,"%s\t%s\t%s\t(%d,%d)\n",PREFIX1,file_name,module_local_name(current_mod),
           ORDERING_NUMBER(order),ORDERING_STATEMENT(order));
   fprint_statement(out, smt);
   fprintf(out,"%s\n",PREFIX2);
   number_of_calls++;
   free(file_name), file_name = NULL;
 }

References alias_function, call_to_statement, concatenate(), CONS, current_mod, db_get_directory_name_for_module(), db_get_memory_resource(), entity_local_name(), entity_to_expression(), EXPRESSION, file_name, fprint_statement(), fprintf(), free(), make_call(), MakeCharacterConstantExpression(), module_local_name(), NIL, number_of_calls, ORDERING_NUMBER, ORDERING_STATEMENT, out, pips_basename(), PREFIX1, PREFIX2, statement_ordering, strdup(), user_file, and WORKSPACE_SRC_SPACE.

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_variable_in_caller_flt(), and dynamic_alias_check_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_flag_before_call_site()

static void insert_flag_before_call_site	(	list	flags,
		list	path
	)

static

Definition at line 428 of file alias_check.c.

 {
   while (!ENDP(path))
     {
       call_site cs = CALL_SITE(CAR(path));
       expression e_flag = EXPRESSION(CAR(flags));
       entity caller = call_site_function(cs);
       int order = call_site_ordering(cs);
       statement s_flag = make_assign_statement(e_flag,make_true_expression());
       const char* call_name = module_local_name(caller);
       string user_file = db_get_memory_resource(DBR_USER_FILE,call_name,true);
       string base_name = pips_basename(user_file, NULL);
       string file_name = strdup(concatenate(db_get_directory_name_for_module(WORKSPACE_SRC_SPACE), "/",base_name,NULL));
       fprintf(out,"%s\t%s\t%s\t(%d,%d)\n",PREFIX1,file_name,module_local_name(caller),
               ORDERING_NUMBER(order),ORDERING_STATEMENT(order));
       fprint_statement(out,s_flag);
       fprintf(out, "%s\n",PREFIX2);
       path = CDR(path);
       flags = CDR(flags);
       free(file_name), file_name = NULL;
     }
 }

References CALL_SITE, call_site_function, call_site_ordering, CAR, CDR, concatenate(), db_get_directory_name_for_module(), db_get_memory_resource(), ENDP, EXPRESSION, file_name, fprint_statement(), fprintf(), free(), make_assign_statement(), make_true_expression(), module_local_name(), ORDERING_NUMBER, ORDERING_STATEMENT, out, pips_basename(), PREFIX1, PREFIX2, strdup(), user_file, and WORKSPACE_SRC_SPACE.

Referenced by alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_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:

◆ insert_test_before_caller()

static void insert_test_before_caller	(	expression	condition,
		expression	e_flag
	)

static

Definition at line 458 of file alias_check.c.

 {
   statement s_flag = make_assign_statement(e_flag,make_true_expression());
   string user_file = db_get_memory_resource(DBR_USER_FILE,caller_name,true);
   string base_name = pips_basename(user_file, NULL);
   string file_name = strdup(concatenate(db_get_directory_name_for_module(WORKSPACE_SRC_SPACE), "/",base_name,NULL));
   if (true_expression_p(condition))
     {
       fprintf(out,"%s\t%s\t%s\t(%d,%d)\n",PREFIX1,file_name,module_local_name(current_caller),
               ORDERING_NUMBER(current_ordering),ORDERING_STATEMENT(current_ordering));
       fprint_statement(out,s_flag);
       fprintf(out,"%s\n",PREFIX2);
     }
   else
     {
       statement smt = test_to_statement(make_test(condition, s_flag,
                                                   make_block_statement(NIL)));
       fprintf(out,"%s\t%s\t%s\t(%d,%d)\n",PREFIX1,file_name,module_local_name(current_caller),
               ORDERING_NUMBER(current_ordering),ORDERING_STATEMENT(current_ordering));
       fprint_statement(out,smt);
       fprintf(out,"%s\n",PREFIX2);
       number_of_tests++;
     }
   free(file_name), file_name = NULL;
 }

References caller_name, concatenate(), current_caller, current_ordering, db_get_directory_name_for_module(), db_get_memory_resource(), file_name, fprint_statement(), fprintf(), free(), make_assign_statement(), make_block_statement(), make_test(), make_true_expression(), module_local_name(), NIL, number_of_tests, ORDERING_NUMBER, ORDERING_STATEMENT, out, pips_basename(), PREFIX1, PREFIX2, strdup(), test_to_statement, true_expression_p(), user_file, and WORKSPACE_SRC_SPACE.

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(), and alias_check_two_scalar_variables_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_test_before_statement()

static void insert_test_before_statement	(	expression	flags,
		expression	condition,
		statement	s,
		entity	e1,
		entity	e2,
		list	path
	)

static

Definition at line 387 of file alias_check.c.

 {
   expression cond;
   statement smt;
   int order = statement_ordering(s);
   string message = strdup(concatenate("\'Alias violation in module ",
                                       module_local_name(current_mod),": write on ",
                                       entity_local_name(e1),", aliased with ",
                                       entity_local_name(e2)," by call path ",
                                       print_call_path(path),"\'", NULL));
   const char* mod_name = module_local_name(current_mod);
   string user_file = db_get_memory_resource(DBR_USER_FILE,mod_name,true);
   string base_name = pips_basename(user_file, NULL);
   string file_name = strdup(concatenate(db_get_directory_name_for_module(WORKSPACE_SRC_SPACE), "/",base_name,NULL));
   if (true_expression_p(condition))
     cond = copy_expression(flags);
   else
     cond = and_expression(condition,flags);
   if (get_bool_property("PROGRAM_VERIFICATION_WITH_PRINT_MESSAGE"))
     smt = test_to_statement(make_test(cond, make_print_statement(message),
                                       make_block_statement(NIL)));
   else
     smt = test_to_statement(make_test(cond, make_stop_statement(message),
                                       make_block_statement(NIL)));
   fprintf(out,"%s\t%s\t%s\t(%d,%d)\n",PREFIX1,file_name,module_local_name(current_mod),
           ORDERING_NUMBER(order),ORDERING_STATEMENT(order));
   fprint_statement(out, smt);
   fprintf(out,"%s\n",PREFIX2);
   number_of_tests++;
   free(file_name), file_name = NULL;
   free(message), message = NULL;
 }

References and_expression, concatenate(), copy_expression(), current_mod, db_get_directory_name_for_module(), db_get_memory_resource(), entity_local_name(), file_name, fprint_statement(), fprintf(), free(), get_bool_property(), make_block_statement(), make_print_statement(), make_stop_statement(), make_test(), module_local_name(), NIL, number_of_tests, ORDERING_NUMBER, ORDERING_STATEMENT, out, pips_basename(), PREFIX1, PREFIX2, print_call_path(), statement_ordering, strdup(), test_to_statement, true_expression_p(), user_file, and WORKSPACE_SRC_SPACE.

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_variable_in_caller_flt(), and alias_check_scalar_variable_in_module_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_list_of_flags()

static list make_list_of_flags ( list path )

static

Definition at line 484 of file alias_check.c.

 {
   int i;
   list retour = NIL;
   for (i=1;i<=(int)gen_length(path);i++)
     {
       expression e_flag = reference_to_expression(make_reference(alias_flag,
                                    CONS(EXPRESSION,int_to_expression(++unique_flag_number),NIL)));
       ifdebug(2)
         {
           fprintf(stderr, "\n New flag expression: \n");
           print_expression(e_flag);
         }
       if (retour==NIL)
         retour = CONS(EXPRESSION,e_flag,NIL);
       else
         retour = gen_nconc(retour, CONS(EXPRESSION,e_flag,NIL));
     }
   return retour;
 }

References alias_flag, CONS, EXPRESSION, fprintf(), gen_length(), gen_nconc(), ifdebug, int, int_to_expression(), make_reference(), NIL, print_expression(), reference_to_expression(), and unique_flag_number.

Referenced by alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_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:

◆ offset_in_caller()

static expression offset_in_caller	(	entity	e,
		call_site	cs,
		list	path
	)

static

compute the subscript value, return expression_undefined if if the actual argument is a scalar variable or array name

The actual argument has a ram storage

The actual argument is a formal parameter of the current caller, we must take the alias_associations of the caller

Definition at line 1877 of file alias_check.c.

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

References call_arguments, current_call, entity_name, entity_storage, expression_reference(), f(), find_ith_argument(), formal_offset, formal_parameter_p(), fprintf(), ifdebug, int_to_expression(), ram_offset, rank, reference_indices, reference_variable, storage_formal, storage_formal_offset(), storage_formal_p, storage_ram, storage_ram_offset(), storage_ram_p, and subscript_value_stride().

Referenced by alias_check_two_variables().

Here is the call graph for this function:

Here is the caller 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_call_path()

static string print_call_path ( list path )

static

This function prints the call path , including names of caller functions and orderings of call sites in their corresponding functions.

Definition at line 277 of file alias_check.c.

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

References CALL_SITE, call_site_function, call_site_ordering, CHAIN_SWORD, int2a(), MAP, module_local_name(), NIL, ORDERING_NUMBER, ORDERING_STATEMENT, and words_to_string().

Referenced by insert_test_before_statement(), and print_alias_association().

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:

◆ same_call_site_p()

static bool same_call_site_p	(	call_site	cs1,
		call_site	cs2
	)

static

Definition at line 228 of file alias_check.c.

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

References call_site_function, call_site_ordering, f2(), and same_entity_p().

Referenced by included_call_chain_p(), and tail_call_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_statement_by_ordering_flt()

static bool search_statement_by_ordering_flt ( statement s )

static

Definition at line 1908 of file alias_check.c.

 {
   if (statement_ordering(s)==current_ordering)
     {
       current_statement = s;
       return false;
     }
   return true;
 }

References current_ordering, current_statement, and statement_ordering.

Referenced by alias_check_two_variables().

Here is the caller graph for this function:

◆ set_dynamic_checked()

static void set_dynamic_checked	(	entity	e1,
		entity	e2
	)

static

Definition at line 219 of file alias_check.c.

 {
   MAP(DYNAMIC_CHECK,dc,
   { 
     if ((dynamic_check_first(dc)==e1)&&(dynamic_check_second(dc)==e2))
       dynamic_check_checked(dc) = true;
   }, l_dynamic_check);
 }

References DYNAMIC_CHECK, dynamic_check_checked, dynamic_check_first, dynamic_check_second, l_dynamic_check, and MAP.

Referenced by alias_check_two_variables().

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:

◆ storage_formal_offset()

static expression storage_formal_offset	(	call_site	cs,
		entity	actual_var,
		expression	subval,
		list	path
	)

static

Definition at line 1838 of file alias_check.c.

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

References ALIAS_ASSOCIATION, alias_association_call_chain, alias_association_offset, alias_association_variable, alias_associations_list, binary_intrinsic_expression, caller_name, copy_expression(), db_get_memory_resource(), exp, expression_equal_integer_p(), expression_undefined, expression_undefined_p, MAP, PLUS_OPERATOR_NAME, same_entity_p(), and tail_call_path_p().

Referenced by offset_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ storage_ram_offset()

static expression storage_ram_offset	(	storage	s,
		expression	subval
	)

static

Definition at line 1812 of file alias_check.c.

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

References binary_intrinsic_expression, copy_expression(), exp, expression_equal_integer_p(), int_to_expression(), PLUS_OPERATOR_NAME, ram_offset, and storage_ram.

Referenced by offset_in_caller().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tail_call_path_p()

static bool tail_call_path_p	(	call_site	cs,
		list	l1,
		list	l2
	)

static

Definition at line 265 of file alias_check.c.

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

References CALL_SITE, CAR, CDR, gen_length(), included_call_chain_p(), and same_call_site_p().

Referenced by storage_formal_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ variable_is_written_by_statement_flt()

static bool variable_is_written_by_statement_flt ( statement s )

static

This function returns true if the variable is written directly in the current module, not by its callees (do not take into account the effects on X,Y of statement like CALL FOO(X,Y))

Definition at line 518 of file alias_check.c.

 {
   if (statement_call_p(s))
     {   
       if (!functional_call_p(statement_call(s)))
         {
           list l_rw = load_proper_rw_effects_list(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 false;
     }
   return true; 
 }

References action_write_p, current_entity, EFFECT, effect_action, effect_any_reference, entity_name, fprintf(), functional_call_p(), ifdebug, load_proper_rw_effects_list(), MAP, reference_variable, same_entity_p(), statement_call(), statement_call_p(), and written.

Referenced by variable_is_written_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ variable_is_written_p()

static bool variable_is_written_p ( entity ent )

static

Definition at line 553 of file alias_check.c.

 {
   written = false;
   current_entity = ent;
   gen_recurse(module_statement,statement_domain,
               variable_is_written_by_statement_flt,gen_null);
   current_entity = entity_undefined;
   return written;
 }