Macros
#define	make_sdfi_effect(e)
	copies an effect with no subcript expression More...

Enumerations
enum	simple_effects_actions_interpretations { act_rw , act_inout , act_live_in , act_live_out , act_rw , act_inout , act_live_in , act_live_out }
	Warning! Do not modify this file that is automatically generated! More...

Functions
list	ReferenceUnion (list, list, bool(*)(effect, effect))
	cproto-generated files More...

list	ReferenceTestUnion (list, list, bool(*)(effect, effect))

list	EffectsMayUnion (list, list, bool(*)(effect, effect))
	list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, may union of the two initial lists modifies : l1 and l2 and their effects. More...

list	ProperEffectsMustUnion (list, list, bool(*)(effect, effect))
	list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...

list	EffectsMustUnion (list, list, bool(*)(effect, effect))
	list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...

list	effects_may_union (effect, effect)

list	effects_must_union (effect, effect)

effect	effect_may_union (effect, effect)
	Preserve store independent information as long as you can. More...

effect	effect_must_union (effect, effect)
	computes the must union of two combinable effects More...

list	EffectsSupDifference (list, list, bool(*)(effect, effect))
	list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the sup_difference of the initial effects. More...

list	EffectsInfDifference (list, list, bool(*)(effect, effect))
	list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the inf_difference of the initial effects. More...

effect	proper_to_summary_simple_effect (effect)
	FI: the goal is to get rid of array subscripts to handle the arrays atomically. More...

bool	simple_cells_intersection_p (cell, descriptor, cell, descriptor, bool *)

bool	simple_cells_inclusion_p (cell, descriptor, cell, descriptor, bool *)

bool	cumulated_references (const string)
	interface.c More...

bool	proper_references (const string)

bool	proper_pointer_effects (const string)

bool	summary_pointer_effects (const string)

bool	cumulated_pointer_effects (const string)

bool	cumulated_pointer_effects_with_points_to (const string)

bool	cumulated_pointer_effects_with_pointer_values (const string)

bool	proper_effects (const string)

bool	proper_effects_with_points_to (const string)

bool	proper_effects_with_pointer_values (const string)

bool	summary_effects (const string)

bool	cumulated_effects (const string)

bool	cumulated_effects_with_points_to (const string)

bool	cumulated_effects_with_pointer_values (const string)

bool	in_summary_effects (const string)

bool	out_summary_effects (const string)

bool	in_effects (const string)

bool	out_effects (const string)

bool	print_code_proper_pointer_effects (const string)

bool	print_code_cumulated_pointer_effects (const string)

bool	print_code_proper_effects (const string)

bool	print_code_cumulated_effects (const string)

bool	print_code_proper_references (const string)

bool	print_code_cumulated_references (const string)

bool	print_code_in_effects (const string)

bool	print_code_out_effects (const string)

bool	print_source_proper_effects (const string)

bool	print_source_cumulated_effects (const string)

bool	print_source_in_effects (const string)

bool	print_source_out_effects (const string)

bool	print_code_as_a_graph_proper_effects (const string)

bool	print_code_as_a_graph_cumulated_effects (const string)

text	get_text_proper_pointer_effects (const string)

text	get_text_cumulated_pointer_effects (const string)

text	get_text_proper_effects (const string)

text	get_text_cumulated_effects (const string)

list	proper_effects_of_expression (expression)

list	expression_to_proper_effects (expression)

list	proper_constant_path_effects_of_any_expression (expression, bool)

list	proper_constant_path_effects_of_expression (expression)

list	proper_constant_path_effects_of_lhs_expression (expression)

list	expression_to_proper_constant_path_effects (expression)

list	lhs_expression_to_proper_constant_path_effects (expression)

bool	expression_with_side_effect_p (expression)

list	proper_constant_path_effects_of_expression_with_points_to (expression, statement)

list	expression_to_proper_constant_path_effects_with_points_to (expression, statement)

list	proper_effects_of_range (range)

bool	expression_invariant_wrt_effects (expression, list)

void	rproper_effects_of_statement (statement)

void	rcumulated_effects_of_statement (statement)

list	statement_to_effects (statement)

bool	full_simple_proper_effects (const char *, statement)

bool	simple_cumulated_effects (const char *, statement)

bool	live_paths (const string)

bool	live_in_summary_paths (const string)

bool	live_out_summary_paths (const string)

bool	print_code_live_in_paths (const string)

bool	print_code_live_out_paths (const string)

bool	update_loops_locals (const char *, statement)

bool	is_implied_do_index (entity, instruction)

list	get_list_of_variable_to_filter (void)

bool	print_icfg_with_proper_effects (const string)

bool	print_icfg_with_cumulated_effects (const string)

bool	print_icfg_with_loops_proper_effects (const string)

bool	print_icfg_with_loops_cumulated_effects (const string)

bool	print_icfg_with_control_proper_effects (const string)

bool	print_icfg_with_control_cumulated_effects (const string)

bool	print_icfg_with_filtered_proper_effects (const string)

bool	print_dvicfg_with_filtered_proper_effects (const string)

void	set_methods_for_proper_references (void)
	methods.c More...

void	set_methods_for_cumulated_references (void)

void	set_default_methods_for_proper_simple_effects (void)

void	set_methods_for_proper_simple_effects (void)

void	set_methods_for_proper_simple_pointer_effects (void)

void	set_methods_for_simple_effects (void)

void	set_methods_for_simple_pointer_effects (void)

void	set_methods_for_inout_effects (const char *)

void	set_methods_for_live_paths (const char *)

void	reset_methods_for_inout_effects (void)

void	set_methods_for_rw_effects_prettyprint (const char *)

void	set_methods_for_inout_effects_prettyprint (const char *)

void	set_methods_for_live_in_paths_prettyprint (const char *)

void	set_methods_for_live_out_paths_prettyprint (const char *)

void	reset_methods_for_effects_prettyprint (const char *)

bool	add_points_to_subscript_lists (list *, list, list)
	translation.c More...

bool	simple_cell_reference_with_address_of_cell_reference_translation_fi (reference, descriptor, reference, descriptor, int, reference , descriptor , bool *)

void	simple_cell_reference_with_address_of_cell_reference_translation (reference, descriptor, reference, descriptor, int, reference , descriptor , bool *)

void	simple_cell_reference_with_value_of_cell_reference_translation (reference, descriptor, reference, descriptor, int, reference , descriptor , bool *)

void	simple_cell_with_address_of_cell_translation (cell, descriptor, cell, descriptor, int, cell , descriptor , bool *)

void	simple_cell_with_value_of_cell_translation (cell, descriptor, cell, descriptor, int, cell , descriptor , bool *)

void	simple_effects_translation_init (entity, list, bool)
	interprocedural.c More...

void	simple_effects_translation_end (void)

void	simple_effect_descriptor_interprocedural_translation (effect)

list	simple_effects_backward_translation (entity, list, list, transformer)

effect	translate_effect_to_sdfi_effect (effect)

list	effects_dynamic_elim (list)

list	make_unknown_subscript (int)

list	summary_effect_to_proper_effect (call, effect)

void	check_user_call_site (entity, list)

list	fortran_summary_to_proper_effects (entity, list, list)

list	c_simple_effects_on_formal_parameter_backward_translation (list, expression, transformer)

list	c_summary_effect_to_proper_effects (effect, expression)

list	c_summary_to_proper_effects (entity, list, list)

list	summary_to_proper_effects (entity, list, list)

list	simple_effects_forward_translation (entity, list, list, transformer)

list	c_simple_effects_on_actual_parameter_forward_translation (entity, expression, entity, list, transformer)

text	simple_rw_effects_to_text (list)
	prettyprint.c More...

text	simple_inout_effects_to_text (list)

text	simple_live_in_paths_to_text (list)

text	simple_live_out_paths_to_text (list)

string	effect_to_string (effect)

list	words_effect_generic (effect, bool)

list	words_effect (effect)

list	words_effect_without_approximation (effect)

void	print_effect (effect)

void	print_effects (list)

void	print_memory_effects (list)

bool	print_call_graph_with_proper_effects (const string)

bool	print_call_graph_with_cumulated_effects (const string)

effect	reference_to_simple_effect (reference, action, bool)
	unary_operators.c More...

void	simple_effect_add_expression_dimension (effect, expression)

void	simple_effect_change_ith_dimension_expression (effect, expression, int)

effect	simple_effect_field_to_rank_conversion (effect)

effect	simple_effect_dup (effect)

effect	reference_to_reference_effect (reference, action, bool)

list	simple_effects_union_over_range (list, entity, range, descriptor)

reference	simple_reference_to_store_independent_reference (reference, bool *)

cell	simple_cell_to_store_independent_cell (cell, bool *)

list	effect_to_store_independent_sdfi_list (effect, bool)

list	effect_to_may_sdfi_list (effect)

list	effect_to_sdfi_list (effect)

void	simple_effects_descriptor_normalize (list)

list	simple_effects_composition_with_effect_transformer (list, transformer)

list	old_effects_composition_with_effect_transformer (list, transformer)

bool	filter_proper_effects (const char *)
	filter_proper_effects.c More...

bool	simple_cell_reference_preceding_p (reference, descriptor, reference, descriptor, transformer, bool, bool *)
	eval.c More...

bool	simple_cell_preceding_p (cell, descriptor, cell, descriptor, transformer, bool, bool *)

bool	path_preceding_p (effect, effect, transformer, bool, bool *)

void	simple_reference_to_simple_reference_conversion (reference, reference , descriptor )

void	simple_cell_to_simple_cell_conversion (cell, cell , descriptor )

list	eval_simple_cell_with_points_to (cell, descriptor, list, bool *, transformer)

list	simple_effect_to_constant_path_effects_with_pointer_values (effect)

list	effect_to_constant_path_effects_with_points_to (effect, statement, transformer)

list	simple_effect_to_constant_path_effects_with_points_to (effect)

list	eval_cell_with_points_to (cell, list, bool *)
	for backward compatibility More...

Macro Definition Documentation

◆ make_sdfi_effect

#define make_sdfi_effect ( e )

Value:

 (reference_indices(effect_any_reference(e)) == NIL) ? \
  make_simple_effect(make_reference(reference_variable(effect_any_reference(e)), NIL),\
     copy_action(effect_action(e)), \
     make_approximation(approximation_tag(effect_approximation(e)), UU)) : \
  make_simple_effect(make_reference(reference_variable(effect_any_reference(e)), NIL), \
              copy_action(effect_action(e)), \
              make_approximation(is_approximation_may, UU))

copies an effect with no subcript expression

Definition at line 38 of file effects-simple.h.

Enumeration Type Documentation

◆ simple_effects_actions_interpretations

enum simple_effects_actions_interpretations

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

Modify src/Libs/effects-simple/effects-simple-local.h instead, to add your own modifications. header file built by cproto effects_simple-local.h actions interpretation for simple effects prettyprinting

Enumerator
act_rw
act_inout
act_live_in
act_live_out
act_rw
act_inout
act_live_in
act_live_out

Definition at line 34 of file effects-simple.h.

34 {act_rw, act_inout, act_live_in, act_live_out}

act_inout

@ act_inout

Definition: effects-simple.h:34

act_live_out

@ act_live_out

Definition: effects-simple.h:34

act_rw

@ act_rw

Definition: effects-simple.h:34

act_live_in

@ act_live_in

Definition: effects-simple.h:34

Function Documentation

◆ add_points_to_subscript_lists()

bool add_points_to_subscript_lists	(	list *	,
		list	,
		list
	)

translation.c

◆ c_simple_effects_on_actual_parameter_forward_translation()

list c_simple_effects_on_actual_parameter_forward_translation	(	entity	,
		expression	,
		entity	,
		list	,
		transformer
	)

◆ c_simple_effects_on_formal_parameter_backward_translation()

list c_simple_effects_on_formal_parameter_backward_translation	(	list	,
		expression	,
		transformer
	)

◆ c_summary_effect_to_proper_effects()

list c_summary_effect_to_proper_effects	(	effect	,
		expression
	)

◆ c_summary_to_proper_effects()

list c_summary_to_proper_effects	(	entity	,
		list	,
		list
	)

◆ check_user_call_site()

void check_user_call_site	(	entity	,
		list
	)

◆ cumulated_effects()

bool cumulated_effects ( const string )

Parameters

string odule_name

Referenced by do_kernelize().

Here is the caller graph for this function:

◆ cumulated_effects_with_pointer_values()

bool cumulated_effects_with_pointer_values ( const string )

Parameters

string odule_name

◆ cumulated_effects_with_points_to()

bool cumulated_effects_with_points_to ( const string )

Parameters

string odule_name

◆ cumulated_pointer_effects()

bool cumulated_pointer_effects ( const string )

Parameters

string odule_name

◆ cumulated_pointer_effects_with_pointer_values()

bool cumulated_pointer_effects_with_pointer_values ( const string )

Parameters

string odule_name

◆ cumulated_pointer_effects_with_points_to()

bool cumulated_pointer_effects_with_points_to ( const string )

Parameters

string odule_name

◆ cumulated_references()

bool cumulated_references ( const string )

interface.c

Parameters

string odule_name

◆ effect_may_union()

effect effect_may_union	(	effect	eff1,
		effect	eff2
	)

Preserve store independent information as long as you can.

I should have some order on references to absorb, for instance, x[1] by x[*].

computes the may union of two combinable effects

Parameters

[in]	eff1	effect
[in]	eff2

See also: effects_combinable_p

Returns: a new effect with no sharing with the input effects

Abstract locations cases

In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);

new_ent = entity_locations_max(e1, e2);

eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }

but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))

concrete locations cases

it's a preference : we change for a reference cell

let us check the indices

Parameters

eff1	ff1
eff2	ff2

Definition at line 163 of file binary_operators.c.

 {
   effect eff;
   tag app1 = effect_approximation_tag(eff1);
   tag app2 = effect_approximation_tag(eff2);
  
   bool al1_p = effect_abstract_location_p(eff1);
   bool al2_p = effect_abstract_location_p(eff2);
  
   /* Abstract locations cases */
   /* In fact, we could have :
        if (al1_p || al_2_p)
        {
          entity e1 = effect_entity(e1);
          entity e2 = effect_entity(e2);
  
          new_ent = entity_locations_max(e1, e2);
  
          eff = make_simple_effect(make_reference(new_ent, NIL),
                           copy_action(effect_action(eff1)),
                           make_approximation(approximation_and(app1,app2), UU));
        }
  
        but entity_locations_max involves string manipulations, which are always costly.
        So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because
        we already know that the abstract location is the max of both locations
        (because they are combinable (see effects_combinable_p))
  
    */
   if (al1_p && al2_p)
   {
     entity e1 = effect_entity(eff1);
     entity e2 = effect_entity(eff2);
  
     entity new_ent = entity_locations_max(e1, e2);
  
     eff = make_simple_effect(make_reference(new_ent, NIL),
         copy_action(effect_action(eff1)),
         make_approximation(approximation_and(app1,app2), UU));
   }
   else if (al1_p) {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff1);
   }
   else if (al2_p) {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff2);
   }
  
   /* concrete locations cases */
   else if (effect_scalar_p(eff1))
   {
     eff = make_simple_effect(make_reference(effect_entity(eff1), NIL),
         copy_action(effect_action(eff1)),
         make_approximation(approximation_and(app1,app2), UU));
   }
   else
   {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff1);
     cell eff_c = effect_cell(eff);
  
     if (cell_preference_p(eff_c))
     {
       /* it's a preference : we change for a reference cell */
       pips_debug(8, "It's a preference\n");
       reference ref = copy_reference(preference_reference(cell_preference(eff_c)));
       free_cell(eff_c);
       effect_cell(eff) = make_cell_reference(ref);
     }
  
     /* let us check the indices */
     list l1 = reference_indices(effect_any_reference(eff));
     list l2 = reference_indices(effect_any_reference(eff2));
  
     tag app_tag =  approximation_and(app1,app2);
  
     for(; !ENDP(l1); POP(l1), POP(l2))
     {
       expression exp1 = EXPRESSION(CAR(l1));
       expression exp2 = EXPRESSION(CAR(l2));
       if (!expression_equal_p(exp1, exp2))
       {
         EXPRESSION_(CAR(l1)) =  make_unbounded_expression();
         app_tag = is_approximation_may;
       }
     }
  
     approximation_tag(effect_approximation(eff)) = app_tag;
   }
   return(eff);
 }

References approximation_and(), approximation_tag, CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.

Referenced by effects_may_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effect_must_union()

effect effect_must_union	(	effect	eff1,
		effect	eff2
	)

computes the must union of two combinable effects

Parameters

[in]	eff1	effect
[in]	eff2

See also: effects_combinable_p

Returns: a new effect with no sharing with the input effects

Abstract locations cases

In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);

new_ent = entity_locations_max(e1, e2);

eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }

but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))

concrete locations cases

it's a preference : we change for a reference cell

let us check the indices

Parameters

eff1	ff1
eff2	ff2

Definition at line 272 of file binary_operators.c.

 {
   effect eff;
   tag app1 = effect_approximation_tag(eff1);
   tag app2 = effect_approximation_tag(eff2);
  
   bool al1_p = effect_abstract_location_p(eff1);
   bool al2_p = effect_abstract_location_p(eff2);
  
   /* Abstract locations cases */
   /* In fact, we could have :
        if (al1_p || al_2_p)
        {
          entity e1 = effect_entity(e1);
          entity e2 = effect_entity(e2);
  
          new_ent = entity_locations_max(e1, e2);
  
          eff = make_simple_effect(make_reference(new_ent, NIL),
                           copy_action(effect_action(eff1)),
                           make_approximation(approximation_and(app1,app2), UU));
        }
  
        but entity_locations_max involves string manipulations, which are always costly.
        So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because
        we already know that the abstract location is the max of both locations
        (because they are combinable (see effects_combinable_p))
  
    */
   if (al1_p && al2_p)
   {
     entity e1 = effect_entity(eff1);
     entity e2 = effect_entity(eff2);
  
     entity new_ent = entity_locations_max(e1, e2);
  
     eff = make_simple_effect(make_reference(new_ent, NIL),
         copy_action(effect_action(eff1)),
         make_approximation(approximation_and(app1,app2), UU));
   }
   else if (al1_p) {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff1);
   }
   else if (al2_p) {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff2);
   }
  
   /* concrete locations cases */
   else if (effect_scalar_p(eff1))
   {
     eff = make_simple_effect(make_reference(effect_entity(eff1), NIL),
         copy_action(effect_action(eff1)),
         make_approximation(approximation_or(app1,app2), UU));
   }
   else
   {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     eff = (*effect_dup_func)(eff1);
     cell eff_c = effect_cell(eff);
     if (cell_preference_p(eff_c))
     {
       /* it's a preference : we change for a reference cell */
       pips_debug(8, "It's a preference\n");
       reference ref = copy_reference(preference_reference(cell_preference(eff_c)));
       free_cell(eff_c);
       effect_cell(eff) = make_cell_reference(ref);
     }
  
     /* let us check the indices */
     list l1 = reference_indices(effect_any_reference(eff));
     list l2 = reference_indices(effect_any_reference(eff2));
  
     tag app_tag = approximation_or(app1,app2);
  
     for(; !ENDP(l1); POP(l1), POP(l2))
     {
       expression exp1 = EXPRESSION(CAR(l1));
       expression exp2 = EXPRESSION(CAR(l2));
       if (!expression_equal_p(exp1, exp2))
       {
         EXPRESSION_(CAR(l1)) =  make_unbounded_expression();
         app_tag = is_approximation_may;
       }
     }
  
     effect_approximation_tag(eff) = app_tag;
   }
   return(eff);
 }

References approximation_and(), approximation_or(), CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.

Referenced by effects_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effect_to_constant_path_effects_with_points_to()

list effect_to_constant_path_effects_with_points_to	(	effect	eff,
		statement	s,
		transformer	context
	)

We have not found any equivalent constant path : it may point anywhere

We should maybe contract these effects later. Is it done by the callers ?

make the resulting effects action to the current effect action

This is dead code: no effects, do not modify le

Parameters

eff	ff
context	ontext

Definition at line 284 of file eval.c.

 {
   list le = NIL;
   bool exact_p;
   reference ref = effect_any_reference(eff);
  
   pips_debug_effect(5, "input effect", eff);
  
   points_to_list ptl = load_pt_to_list(s);
   if(!points_to_list_bottom(ptl)) {
     if (effect_reference_dereferencing_p(ref, &exact_p))
     {
       pips_debug(8, "dereferencing case \n");
       bool exact_p = false;
 #if false
       transformer context;
       if (effects_private_current_context_empty_p())
         context = transformer_undefined;
       else {
         context = effects_private_current_context_head();
       }
 #endif
  
       list l_eval = eval_simple_cell_with_points_to(effect_cell(eff), effect_descriptor(eff),
           points_to_list_list(ptl),
           &exact_p, context);
       if (ENDP(l_eval))
       {
         pips_debug(8, "no equivalent constant path found -> anywhere effect\n");
         /* We have not found any equivalent constant path : it may point anywhere */
         /* We should maybe contract these effects later. Is it done by the callers ? */
         // le = CONS(EFFECT, make_anywhere_effect(copy_action(effect_action(eff))), le);
         le = NIL; // A translation failure means an execution
         // failure, at least according to the standard
       }
       else
       {
         /* make the resulting effects action to the current effect action */
         // list l_eval_eff = cells_to_effects_according_to_effect(l_eval, eff, exact_p);
  
         if (effect_read_p(eff))
           effects_to_read_effects(l_eval);
         if (effect_may_p(eff))
           effects_to_may_effects(l_eval);
         le = gen_nconc(l_eval,le);
       }
     }
     else
       le = CONS(EFFECT, copy_effect(eff), le);
   }
   else {
     /* This is dead code: no effects, do not modify le */
     ;
   }
   return le;
  
 }

References CONS, copy_effect(), EFFECT, effect_any_reference, effect_cell, effect_descriptor, effect_may_p, effect_read_p, effect_reference_dereferencing_p(), effects_private_current_context_empty_p(), effects_private_current_context_head(), effects_to_may_effects(), effects_to_read_effects(), ENDP, eval_simple_cell_with_points_to(), gen_nconc(), load_pt_to_list(), NIL, pips_debug, pips_debug_effect, points_to_list_bottom, points_to_list_list, ref, and transformer_undefined.

Referenced by add_values_for_simple_effects_of_statement(), c_user_call_to_transformer(), and simple_effect_to_constant_path_effects_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effect_to_may_sdfi_list()

list effect_to_may_sdfi_list ( effect )

Referenced by EffectsMayUnion().

Here is the caller graph for this function:

◆ effect_to_sdfi_list()

list effect_to_sdfi_list ( effect )

Referenced by EffectsMustUnion().

Here is the caller graph for this function:

◆ effect_to_store_independent_sdfi_list()

list effect_to_store_independent_sdfi_list	(	effect	,
		bool
	)

◆ effect_to_string()

string effect_to_string ( effect )

Referenced by single_pointer_assignment_to_post_pv(), step_compute_CHAINS_DG_remove_summary_regions(), and true_dependence_with_entity_p().

Here is the caller graph for this function:

◆ effects_dynamic_elim()

list effects_dynamic_elim ( list )

◆ effects_may_union()

list effects_may_union	(	effect	eff1,
		effect	eff2
	)

Parameters

eff1	ff1
eff2	ff2

Definition at line 138 of file binary_operators.c.

 {
     list l_res = NIL;
     l_res = CONS(EFFECT, effect_may_union(eff1,eff2), NIL);
     return(l_res);
 }

References CONS, EFFECT, effect_may_union(), and NIL.

Referenced by EffectsMayUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effects_must_union()

list effects_must_union	(	effect	eff1,
		effect	eff2
	)

Parameters

eff1	ff1
eff2	ff2

Definition at line 145 of file binary_operators.c.

 {
     list l_res = NIL;
     l_res = CONS(EFFECT, effect_must_union(eff1,eff2), NIL);
     return(l_res);
 }

References CONS, EFFECT, effect_must_union(), and NIL.

Referenced by EffectsMustUnion(), and ProperEffectsMustUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EffectsInfDifference()

list EffectsInfDifference	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	difference_combinable_p
	)

list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the inf_difference of the initial effects.

modifies : the effects of l2 may be freed. comment : we keep the effects of l1 that are not combinable with those of l2, but we don't keep the effects of l2 that are not combinable with those of l_reg1.

Parameters

l1	1
l2	2

Definition at line 462 of file binary_operators.c.

 {
     list l_res = NIL;
  
     debug(3, "EffectsInfDifference", "begin\n");
     l_res = list_of_effects_generic_inf_difference_op(l1, l2,
                                            difference_combinable_p,
                                            effect_inf_difference);
     debug(3, "EffectsInfDifference", "end\n");
  
     return l_res;
 }

References debug(), effect_inf_difference(), list_of_effects_generic_inf_difference_op(), and NIL.

Here is the call graph for this function:

◆ EffectsMayUnion()

list EffectsMayUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, may union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.nothing (no sharing introduced).

Parameters

l1	1
l2	2

Definition at line 87 of file binary_operators.c.

 {
     list lr;
  
     lr = list_of_effects_generic_union_op(l1, l2,
                                            union_combinable_p,
                                            effects_may_union,
                                            effect_to_may_sdfi_list);
     return(lr);
 }

References effect_to_may_sdfi_list(), effects_may_union(), and list_of_effects_generic_union_op().

Referenced by unstructured_to_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EffectsMustUnion()

list EffectsMustUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.

Parameters

l1	1
l2	2

Definition at line 126 of file binary_operators.c.

 {
     list lr;
  
     lr = list_of_effects_generic_union_op(l1, l2,
                                            union_combinable_p,
                                            effects_must_union,
                                            effect_to_sdfi_list);
     return(lr);
 }

References effect_to_sdfi_list(), effects_must_union(), and list_of_effects_generic_union_op().

Here is the call graph for this function:

◆ EffectsSupDifference()

list EffectsSupDifference	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	difference_combinable_p
	)

list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the sup_difference of the initial effects.

modifies : the effects of l2 may be freed. comment : we keep the effects of l1 that are not combinable with those of l2, but we don't keep the effects of l2 that are not combinable with those of l_reg1.

Parameters

l1	1
l2	2

Definition at line 438 of file binary_operators.c.

 {
     list l_res = NIL;
  
     debug(3, "EffectsSupDifference", "begin\n");
     l_res = list_of_effects_generic_sup_difference_op(l1, l2,
                                            difference_combinable_p,
                                            effect_sup_difference);
     debug(3, "EffectsSupDifference", "end\n");
  
     return l_res;
 }

References debug(), effect_sup_difference(), list_of_effects_generic_sup_difference_op(), and NIL.

Here is the call graph for this function:

◆ eval_cell_with_points_to()

list eval_cell_with_points_to	(	cell	c,
		list	ptl,
		bool *	exact_p
	)

for backward compatibility

Parameters

ptl	tl
exact_p	xact_p

Definition at line 352 of file eval.c.

 {
   list l_eff = eval_simple_cell_with_points_to(c, descriptor_undefined, ptl, exact_p, transformer_undefined);
   list l = NIL;
  
   FOREACH(EFFECT,eff, l_eff)
     {
       l = CONS(CELL, effect_cell(eff), l);
       effect_cell(eff) = cell_undefined;
     }
   gen_full_free_list(l_eff);
   return l;
 }

References CELL, cell_undefined, CONS, descriptor_undefined, EFFECT, effect_cell, eval_simple_cell_with_points_to(), FOREACH, gen_full_free_list(), NIL, and transformer_undefined.

Here is the call graph for this function:

◆ eval_simple_cell_with_points_to()

list eval_simple_cell_with_points_to	(	cell	,
		descriptor	,
		list	,
		bool *	,
		transformer
	)

◆ expression_invariant_wrt_effects()

bool expression_invariant_wrt_effects	(	expression	,
		list
	)

◆ expression_to_proper_constant_path_effects()

list expression_to_proper_constant_path_effects ( expression )

Referenced by add_loop_index_initialization(), any_user_call_site_to_transformer(), c_user_function_call_to_transformer(), call_to_postcondition(), condition_to_transformer(), expression_effects_to_transformer(), expression_to_postcondition(), expression_to_transformer(), fortran_user_call_to_transformer(), fortran_user_function_call_to_transformer(), loop_initialization_to_transformer(), safe_any_expression_to_transformer(), and safe_expression_to_transformer().

Here is the caller graph for this function:

◆ expression_to_proper_constant_path_effects_with_points_to()

list expression_to_proper_constant_path_effects_with_points_to	(	expression	,
		statement
	)

◆ expression_to_proper_effects()

list expression_to_proper_effects ( expression e )

Definition at line 131 of file gfc2pips-stubs.c.

                                                   {
   STUB_ERROR();
 }

References STUB_ERROR.

Referenced by expr_has_write_eff_ref_p(), regenerate_call(), simd_supported_stat_p(), and statement_clean_declarations_helper().

Here is the caller graph for this function:

◆ expression_with_side_effect_p()

bool expression_with_side_effect_p ( expression )

Referenced by copy_n_reference().

Here is the caller graph for this function:

◆ filter_proper_effects()

bool filter_proper_effects ( const char * module_name )

filter_proper_effects.c

gets what is needed from PIPS DBM

returns the result to the DBM...

Parameters

module_name odule_name

Definition at line 201 of file filter_proper_effects.c.

 {
   debug_on("FILTER_PROPER_EFFECTS_DEBUG_LEVEL");
   pips_debug(1, "considering module %s\n", module_name);
  
   /* gets what is needed from PIPS DBM
    */
   set_current_module_entity(local_name_to_top_level_entity(module_name));
   set_current_module_statement((statement)
             db_get_memory_resource(DBR_CODE, module_name, true));
   set_proper_rw_effects((statement_effects)
             db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  
   variables_to_filter = get_variables_to_filter();
  
   if (variables_to_filter)
     gen_recurse(get_current_module_statement(),
                 statement_domain, stmt_flt, gen_null);
  
   gen_free_list(variables_to_filter);
   variables_to_filter = NIL;
   
   /* returns the result to the DBM... */
   DB_PUT_MEMORY_RESOURCE
     (DBR_FILTERED_PROPER_EFFECTS, module_name, NULL);
   
   reset_proper_rw_effects();
   reset_current_module_entity();
   reset_current_module_statement();
   
   debug_off();
   return true;
 }

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_free_list(), gen_null(), gen_recurse, get_current_module_statement(), get_variables_to_filter(), local_name_to_top_level_entity(), module_name(), NIL, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), statement_domain, stmt_flt(), and variables_to_filter.

Here is the call graph for this function:

◆ fortran_summary_to_proper_effects()

list fortran_summary_to_proper_effects	(	entity	,
		list	,
		list
	)

◆ full_simple_proper_effects()

bool full_simple_proper_effects	(	const char *	,
		statement
	)

Referenced by perform_icm_association().

Here is the caller graph for this function:

◆ get_list_of_variable_to_filter()

list get_list_of_variable_to_filter ( void )

Referenced by make_filtered_dg_or_dvdg().

Here is the caller graph for this function:

◆ get_text_cumulated_effects()

text get_text_cumulated_effects ( const string )

Parameters

string odule_name

◆ get_text_cumulated_pointer_effects()

text get_text_cumulated_pointer_effects ( const string )

Parameters

string odule_name

◆ get_text_proper_effects()

text get_text_proper_effects ( const string )

Parameters

string odule_name

◆ get_text_proper_pointer_effects()

text get_text_proper_pointer_effects ( const string )

Parameters

string odule_name

◆ in_effects()

bool in_effects ( const string )

Parameters

string odule_name

◆ in_summary_effects()

bool in_summary_effects ( const string )

Parameters

string odule_name

◆ is_implied_do_index()

bool is_implied_do_index	(	entity	,
		instruction
	)

Referenced by quick_privatize_statement_pair().

Here is the caller graph for this function:

◆ lhs_expression_to_proper_constant_path_effects()

list lhs_expression_to_proper_constant_path_effects ( expression )

◆ live_in_summary_paths()

bool live_in_summary_paths ( const string )

Parameters

string odule_name

◆ live_out_summary_paths()

bool live_out_summary_paths ( const string )

Parameters

string odule_name

◆ live_paths()

bool live_paths ( const string )

Parameters

string odule_name

◆ make_unknown_subscript()

list make_unknown_subscript ( int )

◆ old_effects_composition_with_effect_transformer()

list old_effects_composition_with_effect_transformer	(	list	,
		transformer
	)

◆ out_effects()

bool out_effects ( const string )

Parameters

string odule_name

Referenced by potential_out_effects_p().

Here is the caller graph for this function:

◆ out_summary_effects()

bool out_summary_effects ( const string )

Parameters

string odule_name

◆ path_preceding_p()

bool path_preceding_p	(	effect	eff1,
		effect	eff2,
		transformer	current_precondition,
		bool	strict_p,
		bool *	exact_p
	)

Parameters

eff1	ff1
eff2	ff2
current_precondition	urrent_precondition
strict_p	trict_p
exact_p	xact_p

Definition at line 132 of file eval.c.

 {
   reference r1 = effect_any_reference(eff1);
   descriptor d1 = effect_descriptor(eff1);
   reference r2 = effect_any_reference(eff2);
   descriptor d2 = effect_descriptor(eff2);
  
   return simple_cell_reference_preceding_p(r1, d1, r2, d2, current_precondition,
                                            strict_p, exact_p);
 }

References current_precondition, effect_any_reference, effect_descriptor, and simple_cell_reference_preceding_p().

Referenced by c_convex_effects_on_actual_parameter_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_call_graph_with_cumulated_effects()

bool print_call_graph_with_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_call_graph_with_proper_effects()

bool print_call_graph_with_proper_effects ( const string )

Parameters

string odule_name

◆ print_code_as_a_graph_cumulated_effects()

bool print_code_as_a_graph_cumulated_effects ( const string )

Parameters

string od_name

◆ print_code_as_a_graph_proper_effects()

bool print_code_as_a_graph_proper_effects ( const string )

Parameters

string od_name

◆ print_code_cumulated_effects()

bool print_code_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_code_cumulated_pointer_effects()

bool print_code_cumulated_pointer_effects ( const string )

Parameters

string odule_name

◆ print_code_cumulated_references()

bool print_code_cumulated_references ( const string )

Parameters

string odule_name

◆ print_code_in_effects()

bool print_code_in_effects ( const string )

Parameters

string odule_name

◆ print_code_live_in_paths()

bool print_code_live_in_paths ( const string )

Parameters

string odule_name

◆ print_code_live_out_paths()

bool print_code_live_out_paths ( const string )

Parameters

string odule_name

◆ print_code_out_effects()

bool print_code_out_effects ( const string )

Parameters

string odule_name

◆ print_code_proper_effects()

bool print_code_proper_effects ( const string )

Parameters

string odule_name

◆ print_code_proper_pointer_effects()

bool print_code_proper_pointer_effects ( const string )

Parameters

string odule_name

◆ print_code_proper_references()

bool print_code_proper_references ( const string )

Parameters

string odule_name

◆ print_dvicfg_with_filtered_proper_effects()

bool print_dvicfg_with_filtered_proper_effects ( const string )

Parameters

string odule_name

◆ print_effect()

void print_effect ( effect )

◆ print_effects()

void print_effects ( list )

◆ print_icfg_with_control_cumulated_effects()

bool print_icfg_with_control_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_control_proper_effects()

bool print_icfg_with_control_proper_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_cumulated_effects()

bool print_icfg_with_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_filtered_proper_effects()

bool print_icfg_with_filtered_proper_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_loops_cumulated_effects()

bool print_icfg_with_loops_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_loops_proper_effects()

bool print_icfg_with_loops_proper_effects ( const string )

Parameters

string odule_name

◆ print_icfg_with_proper_effects()

bool print_icfg_with_proper_effects ( const string )

Parameters

string odule_name

◆ print_memory_effects()

void print_memory_effects ( list )

◆ print_source_cumulated_effects()

bool print_source_cumulated_effects ( const string )

Parameters

string odule_name

◆ print_source_in_effects()

bool print_source_in_effects ( const string )

Parameters

string odule_name

◆ print_source_out_effects()

bool print_source_out_effects ( const string )

Parameters

string odule_name

◆ print_source_proper_effects()

bool print_source_proper_effects ( const string )

Parameters

string odule_name

◆ proper_constant_path_effects_of_any_expression()

list proper_constant_path_effects_of_any_expression	(	expression	,
		bool
	)

◆ proper_constant_path_effects_of_expression()

list proper_constant_path_effects_of_expression ( expression )

◆ proper_constant_path_effects_of_expression_with_points_to()

list proper_constant_path_effects_of_expression_with_points_to	(	expression	,
		statement
	)

◆ proper_constant_path_effects_of_lhs_expression()

list proper_constant_path_effects_of_lhs_expression ( expression )

◆ proper_effects()

bool proper_effects ( const string )

Parameters

string odule_name

Referenced by do_kernelize().

Here is the caller graph for this function:

◆ proper_effects_of_expression()

list proper_effects_of_expression ( expression )

Referenced by check_new_arc_for_structured_statement(), DistArraysEffects(), do_atomize_call(), do_symbolic_tiling(), expr_level_of(), invariant_expression_p(), loop_annotate(), other_cool_enough_for_a_last_substitution(), and two_addresses_code_generator().

Here is the caller graph for this function:

◆ proper_effects_of_range()

list proper_effects_of_range ( range )

Referenced by quick_privatize_statement_pair().

Here is the caller graph for this function:

◆ proper_effects_with_pointer_values()

bool proper_effects_with_pointer_values ( const string )

Parameters

string odule_name

◆ proper_effects_with_points_to()

bool proper_effects_with_points_to ( const string )

Parameters

string odule_name

◆ proper_pointer_effects()

bool proper_pointer_effects ( const string )

Parameters

string odule_name

◆ proper_references()

bool proper_references ( const string )

Parameters

string odule_name

◆ proper_to_summary_simple_effect()

effect proper_to_summary_simple_effect ( effect eff )

FI: the goal is to get rid of array subscripts to handle the arrays atomically.

This is not possible with pointer indexing. For instance, p[0] is reduced the Fortran way into p, which is wrong. It could be reduced to p[*] and lead to an anywhere effects. Or we must preserve constant indices (store independent), which is the way to go with C since we transform lots of scalar accesses into array accesses.

FI: I do not understand the mix of side effects on eff, free and alloc conditionnaly for some fields. To be checked.

it's a preference : we change for a reference cell

it's a reference : let'us modify it

it may still be a field entity

Parameters

eff ff

Definition at line 488 of file binary_operators.c.

 {
   if (!effect_scalar_p(eff)) {
     cell eff_c = effect_cell(eff);
     bool may_p = false;
     reference ref = reference_undefined;
  
     if (cell_preference_p(eff_c))
     {
       /* it's a preference : we change for a reference cell */
       pips_debug(8, "It's a preference\n");
       ref = copy_reference(preference_reference(cell_preference(eff_c)));
       free_cell(eff_c);
       effect_cell(eff) = make_cell_reference(ref);
     }
     else
     {
       /* it's a reference : let'us modify it */
       ref = cell_reference(eff_c);
     }
  
     ifdebug(8) {
       pips_debug(8, "Proper effect %p with reference %p: %s\n", eff, ref,
           words_to_string(words_effect(eff)));
     }
  
     list inds = reference_indices(ref);
     list cind = list_undefined;
     for(cind = inds; !ENDP(cind); POP(cind)) {
       expression se = EXPRESSION(CAR(cind));
  
       ifdebug(8) {
         pips_debug(8, "Subscript expression :\n");
         print_expression(se);
       }
  
       if(!extended_integer_constant_expression_p(se)) {
         if(!unbounded_expression_p(se))
         {
           /* it may still be a field entity */
           if (!(expression_reference_p(se) &&
               entity_field_p(expression_variable(se))))
           {
             may_p = true;
             free_expression(se);
             EXPRESSION_(CAR(cind)) = make_unbounded_expression();
           }
         }
       }
     }
  
     if(may_p)
       effect_approximation_tag(eff) = is_approximation_may;
  
     ifdebug(8) {
       pips_debug(8, "Summary simple effect %p with reference %p: %s\n", eff, ref,
           words_to_string(words_effect(eff)));
     }
  
     /*
     if(!reference_with_constant_indices_p(r)) {
       reference nr = pointer_type_p(ut)?
         make_reference(e, CONS(EXPRESSION, make_unbounded_expression(), NIL))
         : make_reference(e, NIL);
       free_reference(effect_any_reference(eff));
       if(cell_preference_p(c)) {
         preference p = cell_preference(c);
         preference_reference(p) = nr;
       }
       else {
         cell_reference(c) = nr;
       }
     }
      */
   }
   return(eff);
 }

References CAR, cell_preference, cell_preference_p, cell_reference, copy_reference(), effect_approximation_tag, effect_cell, effect_scalar_p(), ENDP, entity_field_p(), EXPRESSION, EXPRESSION_, expression_reference_p(), expression_variable(), extended_integer_constant_expression_p(), free_cell(), free_expression(), ifdebug, is_approximation_may, list_undefined, make_cell_reference(), make_unbounded_expression(), pips_debug, POP, preference_reference, print_expression(), ref, reference_indices, reference_undefined, unbounded_expression_p(), words_effect(), and words_to_string().

Here is the call graph for this function:

◆ ProperEffectsMustUnion()

list ProperEffectsMustUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.

Parameters

l1	1
l2	2

Definition at line 107 of file binary_operators.c.

 {
     list lr;
  
     lr = list_of_effects_generic_union_op(l1, l2,
                                            union_combinable_p,
                                            effects_must_union,
                                            effect_to_list);
     return(lr);
 }

References effect_to_list(), effects_must_union(), and list_of_effects_generic_union_op().

Here is the call graph for this function:

◆ rcumulated_effects_of_statement()

void rcumulated_effects_of_statement ( statement )

◆ reference_to_reference_effect()

effect reference_to_reference_effect	(	reference	,
		action	,
		bool
	)

Referenced by add_values_for_simple_effects_of_statement().

Here is the caller graph for this function:

◆ reference_to_simple_effect()

effect reference_to_simple_effect	(	reference	,
		action	,
		bool
	)

unary_operators.c

◆ ReferenceTestUnion()

list ReferenceTestUnion	(	list	,
		list	,
		bool(*)(effect, effect)
	)

◆ ReferenceUnion()

list ReferenceUnion	(	list	,
		list	,
		bool(*)(effect, effect)
	)

cproto-generated files

binary_operators.c

◆ reset_methods_for_effects_prettyprint()

void reset_methods_for_effects_prettyprint ( const char * )

Referenced by sesam_buffers_processing().

Here is the caller graph for this function:

◆ reset_methods_for_inout_effects()

void reset_methods_for_inout_effects ( void )

◆ rproper_effects_of_statement()

void rproper_effects_of_statement ( statement )

◆ set_default_methods_for_proper_simple_effects()

void set_default_methods_for_proper_simple_effects ( void )

◆ set_methods_for_cumulated_references()

void set_methods_for_cumulated_references ( void )

◆ set_methods_for_inout_effects()

void set_methods_for_inout_effects ( const char * )

◆ set_methods_for_inout_effects_prettyprint()

void set_methods_for_inout_effects_prettyprint ( const char * )

◆ set_methods_for_live_in_paths_prettyprint()

void set_methods_for_live_in_paths_prettyprint ( const char * )

◆ set_methods_for_live_out_paths_prettyprint()

void set_methods_for_live_out_paths_prettyprint ( const char * )

◆ set_methods_for_live_paths()

void set_methods_for_live_paths ( const char * )

◆ set_methods_for_proper_references()

void set_methods_for_proper_references ( void )

methods.c

◆ set_methods_for_proper_simple_effects()

void set_methods_for_proper_simple_effects ( void )

Referenced by array_to_constant_paths(), c_convex_effects_on_actual_parameter_forward_translation(), derived_formal_parameter_to_stub_points_to(), drop_dummy_loops(), equal_must_vreference(), gen_must_constant_paths(), and typedef_formal_parameter_to_stub_points_to().

Here is the caller graph for this function:

◆ set_methods_for_proper_simple_pointer_effects()

void set_methods_for_proper_simple_pointer_effects ( void )

◆ set_methods_for_rw_effects_prettyprint()

void set_methods_for_rw_effects_prettyprint ( const char * )

Referenced by sesam_buffers_processing().

Here is the caller graph for this function:

◆ set_methods_for_simple_effects()

void set_methods_for_simple_effects ( void )

Referenced by generic_module_name_to_transformers(), initial_simple_pointer_values(), module_name_to_preconditions(), program_simple_pointer_values(), and simple_pointer_values().

Here is the caller graph for this function:

◆ set_methods_for_simple_pointer_effects()

void set_methods_for_simple_pointer_effects ( void )

◆ simple_cell_preceding_p()

bool simple_cell_preceding_p	(	cell	c1,
		descriptor	d1,
		cell	c2,
		descriptor	d2,
		transformer	current_precondition,
		bool	strict_p,
		bool *	exact_p
	)

Parameters

c1	1
d1	1
c2	2
d2	2
current_precondition	urrent_precondition
strict_p	trict_p
exact_p	xact_p

Definition at line 119 of file eval.c.

 {
   reference r1 = cell_any_reference(c1);
   reference r2 = cell_any_reference(c2);
  
   return simple_cell_reference_preceding_p(r1, d1, r2, d2, current_precondition,
                                            strict_p, exact_p);
 }

References cell_any_reference(), current_precondition, and simple_cell_reference_preceding_p().

Referenced by effect_find_aliased_paths_with_pointer_values(), and make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_cell_reference_preceding_p()

bool simple_cell_reference_preceding_p	(	reference	,
		descriptor	,
		reference	,
		descriptor	,
		transformer	,
		bool	,
		bool *
	)

eval.c

Referenced by kill_pointer_value(), and make_simple_pv_from_simple_effects().

Here is the caller graph for this function:

◆ simple_cell_reference_with_address_of_cell_reference_translation()

void simple_cell_reference_with_address_of_cell_reference_translation	(	reference	,
		descriptor	,
		reference	,
		descriptor	,
		int	,
		reference *	,
		descriptor *	,
		bool *
	)

Referenced by eval_simple_cell_with_points_to(), make_simple_pv_context(), and simple_pv_translate().

Here is the caller graph for this function:

◆ simple_cell_reference_with_address_of_cell_reference_translation_fi()

bool simple_cell_reference_with_address_of_cell_reference_translation_fi	(	reference	,
		descriptor	,
		reference	,
		descriptor	,
		int	,
		reference *	,
		descriptor *	,
		bool *
	)

◆ simple_cell_reference_with_value_of_cell_reference_translation()

void simple_cell_reference_with_value_of_cell_reference_translation	(	reference	,
		descriptor	,
		reference	,
		descriptor	,
		int	,
		reference *	,
		descriptor *	,
		bool *
	)

Referenced by make_simple_pv_context(), and simple_pv_translate().

Here is the caller graph for this function:

◆ simple_cell_to_simple_cell_conversion()

void simple_cell_to_simple_cell_conversion	(	cell	input_cell,
		cell *	output_cell,
		descriptor *	output_desc
	)

Parameters

input_cell	nput_cell
output_cell	utput_cell
output_desc	utput_desc

Definition at line 154 of file eval.c.

 {
   *output_cell = input_cell;
   *output_desc = make_descriptor(is_descriptor_none,UU);
 }

References is_descriptor_none, make_descriptor(), and UU.

Referenced by effect_find_aliased_paths_with_pointer_values(), and effect_find_equivalent_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_cell_to_store_independent_cell()

cell simple_cell_to_store_independent_cell	(	cell	,
		bool *
	)

Referenced by array_to_constant_paths(), equal_must_vreference(), gen_must_constant_paths(), make_simple_pv_from_simple_effects(), points_to_independent_store(), and simple_pv_composition_with_transformer().

Here is the caller graph for this function:

◆ simple_cell_with_address_of_cell_translation()

void simple_cell_with_address_of_cell_translation	(	cell	,
		descriptor	,
		cell	,
		descriptor	,
		int	,
		cell *	,
		descriptor *	,
		bool *
	)

Referenced by effect_find_aliased_paths_with_pointer_values().

Here is the caller graph for this function:

◆ simple_cell_with_value_of_cell_translation()

void simple_cell_with_value_of_cell_translation	(	cell	,
		descriptor	,
		cell	,
		descriptor	,
		int	,
		cell *	,
		descriptor *	,
		bool *
	)

Referenced by effect_find_aliased_paths_with_pointer_values().

Here is the caller graph for this function:

◆ simple_cells_inclusion_p()

bool simple_cells_inclusion_p	(	cell	,
		descriptor	,
		cell	,
		descriptor	,
		bool *
	)

◆ simple_cells_intersection_p()

bool simple_cells_intersection_p	(	cell	,
		descriptor	,
		cell	,
		descriptor	,
		bool *
	)

◆ simple_cumulated_effects()

bool simple_cumulated_effects	(	const char *	,
		statement
	)

◆ simple_effect_add_expression_dimension()

void simple_effect_add_expression_dimension	(	effect	,
		expression
	)

◆ simple_effect_change_ith_dimension_expression()

void simple_effect_change_ith_dimension_expression	(	effect	,
		expression	,
		int
	)

◆ simple_effect_descriptor_interprocedural_translation()

void simple_effect_descriptor_interprocedural_translation ( effect )

◆ simple_effect_dup()

effect simple_effect_dup ( effect )

Referenced by set_generic_effects_as_needed().

Here is the caller graph for this function:

◆ simple_effect_field_to_rank_conversion()

effect simple_effect_field_to_rank_conversion ( effect )

◆ simple_effect_to_constant_path_effects_with_pointer_values()

list simple_effect_to_constant_path_effects_with_pointer_values ( effect eff )

it should be a union here. However, we expect the caller to perform the contraction afterwards.

Parameters

eff ff

Definition at line 206 of file eval.c.

 {
   list le = NIL;
   bool exact_p;
   reference ref = effect_any_reference(eff);
  
   if (effect_reference_dereferencing_p(ref, &exact_p))
   {
     pips_debug(8, "dereferencing case \n");
     bool exact_p = false;
     list l_pv = cell_relations_list( load_pv(effects_private_current_stmt_head()) );
     pv_context ctxt = make_simple_pv_context();
     list l_aliased = effect_find_aliased_paths_with_pointer_values(eff, l_pv, &ctxt);
     pips_debug_effects(8, "aliased effects\n", l_aliased);
     reset_pv_context(&ctxt);
  
     FOREACH(EFFECT, eff_alias, l_aliased)
     {
       entity ent_alias = effect_entity(eff_alias);
       if (undefined_pointer_value_entity_p(ent_alias)
           || null_pointer_value_entity_p(ent_alias))
       {
         // currently interpret them as anywhere effects since these values
         // are not yet well integrated in abstract locations lattice
         // and in effects computations
         // to be FIXED later.
         le = CONS(EFFECT, make_anywhere_effect(copy_action(effect_action(eff_alias))), le);
         free_effect(eff_alias);
       }
       else if (entity_abstract_location_p(effect_entity(eff_alias))
           || !effect_reference_dereferencing_p(effect_any_reference(eff_alias), &exact_p)) {
         le = CONS(EFFECT, eff_alias, le);
         /* it should be a union here.
          * However, we expect the caller
          * to perform the contraction afterwards. */
       }
       else
         free_effect(eff_alias);
     }
     gen_free_list(l_aliased);
   }
   else {
     // functions that can be pointed by effect_dup_func:
     // simple_effect_dup
     // region_dup
     // copy_effect
     le = CONS(EFFECT, (*effect_dup_func)(eff), le);
   }
  
   return le;
 }

References cell_relations_list, CONS, copy_action(), EFFECT, effect_action, effect_any_reference, effect_dup_func, effect_entity(), effect_find_aliased_paths_with_pointer_values(), effect_reference_dereferencing_p(), effects_private_current_stmt_head(), entity_abstract_location_p(), FOREACH, free_effect(), gen_free_list(), load_pv(), make_anywhere_effect(), make_simple_pv_context(), NIL, null_pointer_value_entity_p(), pips_debug, pips_debug_effects, ref, reset_pv_context(), and undefined_pointer_value_entity_p().

Here is the call graph for this function:

◆ simple_effect_to_constant_path_effects_with_points_to()

list simple_effect_to_constant_path_effects_with_points_to ( effect eff )

Parameters

eff ff

Definition at line 343 of file eval.c.

 {
   statement s = effects_private_current_stmt_head();
   transformer c = effects_private_current_context_head();
   return effect_to_constant_path_effects_with_points_to(eff, s, c);
 }

References effect_to_constant_path_effects_with_points_to(), effects_private_current_context_head(), and effects_private_current_stmt_head().

Here is the call graph for this function:

◆ simple_effects_backward_translation()

list simple_effects_backward_translation	(	entity	,
		list	,
		list	,
		transformer
	)

◆ simple_effects_composition_with_effect_transformer()

list simple_effects_composition_with_effect_transformer	(	list	,
		transformer
	)

◆ simple_effects_descriptor_normalize()

void simple_effects_descriptor_normalize ( list )

◆ simple_effects_forward_translation()

list simple_effects_forward_translation	(	entity	,
		list	,
		list	,
		transformer
	)

◆ simple_effects_translation_end()

void simple_effects_translation_end ( void )

◆ simple_effects_translation_init()

void simple_effects_translation_init	(	entity	,
		list	,
		bool
	)

interprocedural.c

◆ simple_effects_union_over_range()

list simple_effects_union_over_range	(	list	,
		entity	,
		range	,
		descriptor
	)

◆ simple_inout_effects_to_text()

text simple_inout_effects_to_text ( list )

◆ simple_live_in_paths_to_text()

text simple_live_in_paths_to_text ( list )

◆ simple_live_out_paths_to_text()

text simple_live_out_paths_to_text ( list )

◆ simple_reference_to_simple_reference_conversion()

void simple_reference_to_simple_reference_conversion	(	reference	ref,
		reference *	output_ref,
		descriptor *	output_desc
	)

Parameters

ref	ef
output_ref	utput_ref
output_desc	utput_desc

Definition at line 146 of file eval.c.

 {
   *output_ref = ref;
   *output_desc = make_descriptor(is_descriptor_none,UU);
 }

References is_descriptor_none, make_descriptor(), ref, and UU.

Referenced by eval_simple_cell_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_reference_to_store_independent_reference()

reference simple_reference_to_store_independent_reference	(	reference	,
		bool *
	)

◆ simple_rw_effects_to_text()

text simple_rw_effects_to_text ( list )

prettyprint.c

◆ statement_to_effects()

list statement_to_effects ( statement )

Referenced by check_new_arc_for_structured_statement(), get_effect_read_of_statement_on_variable(), get_effect_write_of_statement_on_variable(), and variable_is_written_by_statement_flt().

Here is the caller graph for this function:

◆ summary_effect_to_proper_effect()

list summary_effect_to_proper_effect	(	call	,
		effect
	)

Referenced by summary_to_proper_reference().

Here is the caller graph for this function:

◆ summary_effects()

bool summary_effects ( const string )

Parameters

string odule_name

◆ summary_pointer_effects()

bool summary_pointer_effects ( const string )

Parameters

string odule_name

◆ summary_to_proper_effects()

list summary_to_proper_effects	(	entity	,
		list	,
		list
	)

◆ translate_effect_to_sdfi_effect()

effect translate_effect_to_sdfi_effect ( effect )

◆ update_loops_locals()

bool update_loops_locals	(	const char *	,
		statement
	)

Referenced by do_it().

Here is the caller graph for this function:

◆ words_effect()

list words_effect ( effect )

Referenced by adg_dataflowgraph_with_extremities(), adg_print_graph(), dump_sef(), flint_initialize_statement_def_use_variables(), prettyprint_conflict(), prettyprint_dependence_graph(), prettyprint_dependence_graph_view(), proper_to_summary_simple_effect(), rice_update_dependence_graph(), TestCoupleOfReferences(), and text_comp_region().

Here is the caller graph for this function:

◆ words_effect_generic()

list words_effect_generic	(	effect	,
		bool
	)

◆ words_effect_without_approximation()

list words_effect_without_approximation ( effect )

Macros

Enumerations

Functions

Macro Definition Documentation

◆ make_sdfi_effect

Enumeration Type Documentation

◆ simple_effects_actions_interpretations

Function Documentation

◆ add_points_to_subscript_lists()

◆ c_simple_effects_on_actual_parameter_forward_translation()

◆ c_simple_effects_on_formal_parameter_backward_translation()

◆ c_summary_effect_to_proper_effects()

◆ c_summary_to_proper_effects()

◆ check_user_call_site()

◆ cumulated_effects()

◆ cumulated_effects_with_pointer_values()

◆ cumulated_effects_with_points_to()

◆ cumulated_pointer_effects()

◆ cumulated_pointer_effects_with_pointer_values()

◆ cumulated_pointer_effects_with_points_to()

◆ cumulated_references()

◆ effect_may_union()

◆ effect_must_union()

◆ effect_to_constant_path_effects_with_points_to()

◆ effect_to_may_sdfi_list()

◆ effect_to_sdfi_list()

◆ effect_to_store_independent_sdfi_list()

◆ effect_to_string()

◆ effects_dynamic_elim()

◆ effects_may_union()

◆ effects_must_union()

◆ EffectsInfDifference()

◆ EffectsMayUnion()

◆ EffectsMustUnion()

◆ EffectsSupDifference()

◆ eval_cell_with_points_to()

◆ eval_simple_cell_with_points_to()

◆ expression_invariant_wrt_effects()

◆ expression_to_proper_constant_path_effects()

◆ expression_to_proper_constant_path_effects_with_points_to()

◆ expression_to_proper_effects()

◆ expression_with_side_effect_p()

◆ filter_proper_effects()

◆ fortran_summary_to_proper_effects()

◆ full_simple_proper_effects()

◆ get_list_of_variable_to_filter()

◆ get_text_cumulated_effects()

◆ get_text_cumulated_pointer_effects()

◆ get_text_proper_effects()

◆ get_text_proper_pointer_effects()

◆ in_effects()

◆ in_summary_effects()

◆ is_implied_do_index()

◆ lhs_expression_to_proper_constant_path_effects()

◆ live_in_summary_paths()

◆ live_out_summary_paths()

◆ live_paths()

◆ make_unknown_subscript()

◆ old_effects_composition_with_effect_transformer()

◆ out_effects()

◆ out_summary_effects()

◆ path_preceding_p()

◆ print_call_graph_with_cumulated_effects()

◆ print_call_graph_with_proper_effects()

◆ print_code_as_a_graph_cumulated_effects()

◆ print_code_as_a_graph_proper_effects()

◆ print_code_cumulated_effects()

◆ print_code_cumulated_pointer_effects()

◆ print_code_cumulated_references()

◆ print_code_in_effects()

◆ print_code_live_in_paths()

◆ print_code_live_out_paths()

◆ print_code_out_effects()

◆ print_code_proper_effects()

◆ print_code_proper_pointer_effects()

◆ print_code_proper_references()

◆ print_dvicfg_with_filtered_proper_effects()

◆ print_effect()

◆ print_effects()

◆ print_icfg_with_control_cumulated_effects()