effects.c File Reference

#include <stdio.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "properties.h"
#include "effects-util.h"
#include "text.h"
#include "text-util.h"

Include dependency graph for effects.c:

Go to the source code of this file.

Functions
entity	effect_entity (effect e)
	Created by B. More...
entity	cell_entity (cell c)
list	cell_indices (cell c)
reference	cell_any_reference (cell c)
	API for reference. More...
bool	memory_dereferencing_p (reference r)
	Does the set of locations referenced by r depend on a pointer dereferencing? More...
effects	list_to_effects (list l_eff)
	Future API for GAP, Generic Access Path. More...
list	effects_to_list (effects efs)
statement_mapping	listmap_to_effectsmap (statement_mapping l_map)
statement_mapping	effectsmap_to_listmap (statement_mapping efs_map)
bool	statement_has_a_module_formal_argument_write_effect_p (statement s, entity module, statement_mapping effects_list_map)
	Return true if the statement has a write effect on at least one of the argument (formal parameter) of the module. More...
bool	cell_abstract_location_p (cell c)
bool	effect_abstract_location_p (effect eff)
bool	effects_abstract_location_p (list el)
	Returns true if at least one effect of effect list el is related to an abstract location. More...
effect	anywhere_effect (action ac)
	Anywhere effect: an effect which can be related to any location of any areas. More...
static bool	generic_anywhere_effect_p (effect e, int kind)
	Is it an anywhere effect (kind=0)? a typed anywhere effect (kind=1) ? or any kind of anywhere effect (kind=2)? More...
bool	anywhere_effect_p (effect e)
	Is it an anywhere effect? ANYMMODULE:ANYWHERE More...
bool	typed_anywhere_effect_p (effect e)
	Is it a typed anywhere effect? ANYMMODULE:ANYWHERE_b0, 1, 2. More...
bool	any_anywhere_effect_p (effect e)
	Is it a typed or untyped anywhere effect? More...
bool	anywhere_cell_p (cell c)
	Is it an anywhere cell? More...
bool	anywhere_reference_p (reference r)
effect	heap_effect (entity m, action ac)
bool	heap_effect_p (effect e)
bool	heap_cell_p (cell c)
	Any heap cell, more or less abstract or typed. More...
bool	all_heap_locations_cell_p (cell c)
bool	nowhere_cell_p (cell c)
	Target of an undefined pointer. More...
bool	null_cell_p (cell c)
bool	malloc_effect_p (effect e)
bool	malloc_cell_p (cell c)
bool	malloc_reference_p (reference r)
bool	io_effect_entity_p (entity e)
bool	io_effect_p (effect e)
bool	io_cell_p (cell c)
bool	io_effects_p (list effects)
bool	std_file_effect_p (effect e)
bool	std_file_cell_p (cell c)
bool	std_file_effects_p (list effects)
bool	FILE_star_effect_reference_p (reference ref)
bool	effect_scalar_p (effect eff)
bool	effect_comparable_p (effect e1, effect e2)
	Can we merge these two effects because they are equal or because they only differ by their approximations and their descriptors? More...
bool	store_independent_effect_p (effect eff)
	Does this effect define the same set of memory locations regardless of the current (environment and) memory state? More...
bool	effect_on_non_local_variable_p (effect eff)
	Test if an effect has a non local effect. More...
bool	effects_on_non_local_variable_p (list effects)
	Test if a list of effects concerns non local variables. More...
bool	effects_interfere_p (effect eff1, effect eff2)
	Two effects interfere if one of them modify the set of locations defined by the other one. More...
effect	effect_to_store_independent (effect eff)
effect	effect_to_pointer_store_independent_effect (effect eff, entity p)
	Modify eff so that the set of memory locations decribed after a write to some pointer p is still in the abstract location set of eff. More...
effect	effect_to_non_pointer_store_independent_effect (effect eff)
	Modify eff so that the set of memory locations decribed after a write to some non pointer variable is still in the abstract location set of eff. More...
effect	effect_interference (effect eff1, effect eff2)
	Modifies effect eff1 to make sure that any memory state modification abstracted by eff2 preserves the correctness of eff1: all memory locations included in eff1 at input are included in the memory locations abstracted by the new eff1 after the abstract state transition. More...
string	action_to_string (action ac)
	Functions dealing with actions. More...
string	full_action_to_string (action ac)
string	full_action_to_short_string (action ac)
string	action_kind_to_string (action_kind ak)
action	make_action_write_memory (void)
	To ease the extension of action with action_kind. More...
action	make_action_read_memory (void)
bool	action_equal_p (action a1, action a2)
action_kind	action_to_action_kind (action a)
	Without the consistency test, this function would certainly be inlined. More...
action_kind	effect_action_kind (effect eff)
bool	store_effect_p (effect e)
bool	environment_effect_p (effect e)
bool	type_declaration_effect_p (effect e)
bool	effects_write_variable_p (list el, entity v)
bool	effects_write_p (list el)
bool	effects_read_variable_p (list el, entity v)
bool	effects_all_read_p (list el)
	Check that all effects in el are read effects. More...
bool	effect_list_can_be_safely_full_freed_p (list el)
	Check if some references might be freed with the effects. More...
tag	approximation_and (tag t1, tag t2)
	tag approximation_and(tag t1, tag t2) input : two approximation tags. More...
tag	approximation_or (tag t1, tag t2)
	tag approximation_or(tag t1, tag t2) input : two approximation tags. More...
bool	cell_equal_p (cell c1, cell c2)
	CELLS. More...
bool	cell_entity_equal_p (cell c1, cell c2)
bool	points_to_reference_included_p (reference r1, reference r2)
	FI->FC/AM: some elements of the lattice must be exploited here... More...
bool	cell_included_p (cell c1, cell c2)
	Check that all memory locations denoted by cell "c1" are included in cell "c2". More...
bool	cell_equivalent_p (cell c1, cell c2)
	Check that memory locations denoted by cell "c1" can be reached by knowing cell "c2" and by using pointer arithmetic or subscripting. More...
reference	cell_to_reference (cell c)
	FI: probably to be moved elsewhere in ri-util. More...
bool	effect_list_consistent_p (list el)
	Debugging. More...
bool	union_compatible_effects_p (effect ef1, effect ef2)
	DO NOT USE ANYMORE: NOT COMPATIBLE WITH ABSTRACT LOCATIONS. More...
entity	effect_to_entity (effect ef)
	Returns the entity corresponding to the mutation. More...
bool	vect_contains_phi_p (Pvecteur v)
	bool vect_contains_phi_p(Pvecteur v) input : a vector output : true if v contains a PHI variable, false otherwise modifies : nothing More...
cell	points_to_cell_add_field_dimension (cell c, entity f)
	Functions about points-to cells - There is no cell.c file. More...
reference	reference_add_field_dimension (reference r, entity f)
	add a field f as a subscript to a reference r if it is meaningful. More...
reference	simple_reference_add_field_dimension (reference r, entity f)
	Do not check anything, just add f as a last subscript. More...
void	points_to_cell_add_fixed_subscripts (cell c, bool zero_p)
	Convert a reference to an array into a reference to its first element. More...
void	points_to_cell_add_zero_subscripts (cell c)
void	points_to_cell_add_zero_subscript (cell c)
void	points_to_cell_complete_with_zero_subscripts (cell c)
void	points_to_cell_add_unbounded_subscripts (cell c)
void	points_to_cell_update_last_subscript (cell c, expression s)
	Transform reference a[i]...[j] and expression s into reference a[i]..[j+s] if j and s are constant integer expressions, and into reference a[i]..[*] otherwise. More...
bool	atomic_effect_p (effect e)
list	recursive_cell_to_pointer_cells (cell c)
list	cell_to_pointer_cells (cell c)
	If the reference in "c" is not a pointer, see if it can be transformed into a pointer reference by adding subscripts, field subscripts or a combination of both... More...

Function Documentation

action_equal_p()

bool action_equal_p	(	action	a1,
		action	a2
	)

action_write_p(a1)

Parameters

a1	1
a2	2

Definition at line 1023 of file effects.c.

{
  bool equal_p = false;
 
  if(action_tag(a1)==action_tag(a2)) {
    if(action_read_p(a1)) {
      action_kind ak1 = action_read(a1);
      action_kind ak2 = action_read(a2);
 
      equal_p = action_kind_tag(ak1)==action_kind_tag(ak2);
    }
    else /* action_write_p(a1) */ {
      action_kind ak1 = action_write(a1);
      action_kind ak2 = action_write(a2);
 
      equal_p = action_kind_tag(ak1)==action_kind_tag(ak2);
    }
  }
  return equal_p;
 
}

References action_kind_tag, action_read, action_read_p, action_tag, and action_write.

Referenced by combinable_regions_p(), and effect_comparable_p().

Here is the caller graph for this function:

action_kind_to_string()

string action_kind_to_string

(

action_kind

ak

)

Parameters

ak

k

Definition at line 995 of file effects.c.

{
  string s = string_undefined;
 
  if(action_kind_store_p(ak))
    s = "S";
  else if(action_kind_environment_p(ak))
    s = "E";
  else if(action_kind_type_declaration_p(ak))
    s = "T";
  else
    pips_internal_error("Unknown action kind.");
  return s;
}

References action_kind_environment_p, action_kind_store_p, action_kind_type_declaration_p, pips_internal_error, and string_undefined.

action_to_action_kind()

action_kind action_to_action_kind

(

action

a

)

Without the consistency test, this function would certainly be inlined.

Macros are avoided to simplify debugging and maintenance.

Definition at line 1048 of file effects.c.

{
    pips_assert("consistent action kind.",action_read_p(a) || action_write_p(a));
    action_kind ak = action_read_p(a) ? action_read(a): action_write(a);
    return ak;
}

References action_read, action_read_p, action_write, action_write_p, and pips_assert.

Referenced by effect_action_kind(), effects_might_conflict_even_read_only_p(), region_sup_difference(), regions_may_convex_hull(), and union_compatible_effects_p().

Here is the caller graph for this function:

action_to_string()

string action_to_string

(

action

ac

)

Functions dealing with actions.

This is correct, but imprecise when action_kinds are taken into account

Parameters

ac

c

Definition at line 936 of file effects.c.

{
  /* This is correct, but imprecise when action_kinds are taken into
     account */
  return action_read_p(ac)? "read" : "write";
}

References action_read_p.

all_heap_locations_cell_p()

bool all_heap_locations_cell_p

(

cell

c

)

Definition at line 432 of file effects.c.

{
  bool heap_p;
  reference r = cell_any_reference(c);
  entity v = reference_variable(r);
 
  heap_p = entity_all_heap_locations_p(v);
 
  return heap_p;
}

References cell_any_reference(), entity_all_heap_locations_p(), and reference_variable.

Referenced by points_to_cell_types_compatibility(), points_to_function_projection(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

any_anywhere_effect_p()

bool any_anywhere_effect_p

(

effect

e

)

Is it a typed or untyped anywhere effect?

Definition at line 358 of file effects.c.

{
  return generic_anywhere_effect_p(e, 2);
}

References generic_anywhere_effect_p().

Here is the call graph for this function:

anywhere_cell_p()

bool anywhere_cell_p

(

cell

c

)

Is it an anywhere cell?

Are typed anywhere celles taken into account?

Definition at line 367 of file effects.c.

{
  bool anywhere_p;
  reference r = cell_any_reference(c);
  entity v = reference_variable(r);
 
  anywhere_p =  entity_all_locations_p(v);
 
  return anywhere_p;
}

References cell_any_reference(), entity_all_locations_p(), and reference_variable.

Referenced by binary_intrinsic_call_to_points_to_sinks(), check_type_of_points_to_cells(), compute_points_to_binded_set(), compute_points_to_gen_set(), dereferencing_subscript_to_points_to(), freed_list_to_points_to(), freed_pointer_to_points_to(), null_equal_condition_to_points_to(), offset_cell(), offset_cells(), offset_points_to_cell(), points_to_cell_types_compatibility(), points_to_source_to_translations(), points_to_with_stripped_sink(), print_or_dump_points_to(), process_casted_sinks(), process_casted_sources(), source_to_sinks(), subscript_to_points_to_sinks(), and unique_location_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

anywhere_effect()

effect anywhere_effect

(

action

ac

)

Anywhere effect: an effect which can be related to any location of any areas.

Allocate a new anywhere effect, and the anywhere entity on demand which may not be best if we want to express it's aliasing with all module areas. In the later case, the anywhere entity should be generated by bootstrap and be updated each time new areas are declared by the parsers. I do not use a persistant anywhere reference to avoid trouble with convex-effect nypassing of the persistant pointer.

Action a is integrated in the new effect (aliasing). NOT GENERIC AT ALL. USE make_anywhere_effect INSTEAD (BC).

Parameters

ac

c

Definition at line 317 of file effects.c.

{
  entity anywhere = entity_all_locations();
  effect any = effect_undefined;
 
  any = make_effect(make_cell_reference(make_reference(anywhere, NIL)),
                    ac,
                    make_approximation_may(),
                    make_descriptor_none());
 
  return any;
}

References effect_undefined, entity_all_locations(), make_approximation_may(), make_cell_reference(), make_descriptor_none(), make_effect(), make_reference(), and NIL.

Referenced by effect_to_pointer_store_independent_effect(), and effect_to_store_independent().

Here is the call graph for this function:

Here is the caller graph for this function:

anywhere_effect_p()

bool anywhere_effect_p

(

effect

e

)

Is it an anywhere effect? ANYMMODULE:ANYWHERE

Definition at line 346 of file effects.c.

{
  return generic_anywhere_effect_p(e, 0);
}

References generic_anywhere_effect_p().

Referenced by anymodule_anywhere_region_p(), binary_arithmetic_operator_to_post_pv(), c_convex_effects_on_formal_parameter_backward_translation(), effect_interference(), effects_interfere_p(), generic_effect_find_aliases_with_simple_pointer_values(), guess_potential_reduction(), kill_pointer_value(), multiple_pointer_assignment_to_post_pv(), old_effects_conflict_p(), potential_out_effects_p(), region_entities_intersection(), region_inf_difference(), region_intersection(), region_sup_difference(), regions_dynamic_elim(), single_pointer_assignment_to_post_pv(), step_translate_and_map(), store_independent_effect_p(), and update_operator_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

anywhere_reference_p()

bool anywhere_reference_p

(

reference

r

)

Definition at line 378 of file effects.c.

{
  bool anywhere_p;
  entity v = reference_variable(r);
 
  anywhere_p =  entity_all_locations_p(v);
 
  return anywhere_p;
}

References entity_all_locations_p(), and reference_variable.

Referenced by any_assign_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

approximation_and()

tag approximation_and	(	tag	t1,
		tag	t2
	)

tag approximation_and(tag t1, tag t2) input : two approximation tags.

output : the tag representing their "logical and", assuming that must = true and may = false. modifies : nothing

Parameters

t1	1
t2	2

Definition at line 1198 of file effects.c.

{
    if ((t1 == is_approximation_exact) && (t2 == is_approximation_exact))
        return(is_approximation_exact);
    else
        return(is_approximation_may);
}

References is_approximation_exact, and is_approximation_may.

Referenced by effect_may_union(), effect_must_union(), make_simple_pv_from_simple_effects(), region_intersection(), region_union(), and regions_may_convex_hull().

Here is the caller graph for this function:

approximation_or()

tag approximation_or	(	tag	t1,
		tag	t2
	)

tag approximation_or(tag t1, tag t2) input : two approximation tags.

output : the tag representing their "logical or", assuming that must = true and may = false. modifies : nothing

Parameters

t1	1
t2	2

Definition at line 1213 of file effects.c.

{
    if ((t1 == is_approximation_exact) || (t2 == is_approximation_exact))
        return(is_approximation_exact);
    else
        return(is_approximation_may);
}

References is_approximation_exact, and is_approximation_may.

Referenced by effect_must_union(), region_union(), and regions_must_convex_hull().

Here is the caller graph for this function:

atomic_effect_p()

bool atomic_effect_p

(

effect

e

)

Maybe it is an effect on a structure field

Definition at line 1668 of file effects.c.

{
  bool atomic_p = effect_scalar_p(e);
  if(!atomic_p) {
    /* Maybe it is an effect on a structure field */
    cell c = effect_cell(e);
    atomic_p = atomic_points_to_cell_p(c);
  }
  return atomic_p;
}

References atomic_points_to_cell_p(), effect_cell, and effect_scalar_p().

Here is the call graph for this function:

cell_abstract_location_p()

bool cell_abstract_location_p

(

cell

c

)

Definition at line 273 of file effects.c.

{
  pips_assert("cell is not a GAP", !cell_gap_p(c));
 
  return (entity_abstract_location_p(reference_variable(cell_any_reference(c))));
}

References cell_any_reference(), cell_gap_p, entity_abstract_location_p(), pips_assert, and reference_variable.

Referenced by cells_to_read_or_write_effects(), convex_cells_inclusion_p(), convex_cells_intersection_p(), effect_abstract_location_p(), simple_cells_inclusion_p(), simple_cells_intersection_p(), and upgrade_approximations_in_points_to_set().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_any_reference()

reference cell_any_reference

(

cell

c

)

API for reference.

Definition at line 77 of file effects.c.

{
  if (cell_gap_p(c)) return reference_undefined;
 
  return (cell_reference_p(c)) ? cell_reference(c) :
    preference_reference(cell_preference(c));
}

References cell_gap_p, cell_preference, cell_reference, cell_reference_p, preference_reference, and reference_undefined.

Referenced by aliased_translation_p(), all_heap_locations_cell_p(), any_assign_to_transformer(), anywhere_cell_p(), anywhere_source_to_sinks(), array_formal_parameter_to_stub_points_to(), atomic_constant_path_p(), atomic_points_to_cell_p(), binary_intrinsic_call_to_points_to_sinks(), cell_abstract_location_p(), cell_entity(), cell_equivalent_p(), cell_included_p(), cell_indices(), cell_is_xxx_p(), cell_to_pointer_cells(), cell_typed_anywhere_locations_p(), cells_to_read_or_write_effects(), check_type_of_points_to_cells(), compute_points_to_binded_set(), compute_points_to_gen_set(), compute_points_to_kill_set(), consistent_points_to_arc_p(), convex_cell_preceding_p(), create_pointer_to_array_stub_points_to(), create_stub_points_to(), dereferencing_subscript_to_points_to(), dereferencing_to_sinks(), derived_formal_parameter_to_stub_points_to(), equal_must_vreference(), expand_points_to_domain(), expression_to_points_to_cells(), extended_source_to_sinks(), filter_formal_context_according_to_actual_context(), filter_formal_out_context_according_to_formal_in_context(), find_points_to_subscript_for_type(), formal_parameter_points_to_cell_p(), formal_source_to_sinks(), fprint_points_to_cell(), freeable_points_to_cells(), freed_list_to_points_to(), gen_may_constant_paths(), gen_may_set(), gen_must_constant_paths(), gen_must_set(), generic_apply_effects_to_transformer(), generic_atomic_points_to_cell_p(), generic_points_to_cells_translation(), generic_points_to_set_to_stub_cell_list(), generic_remove_unreachable_vertices_in_points_to_graph(), generic_stub_source_to_sinks(), generic_transform_sink_cells_from_matching_list(), generic_unary_operation_to_transformer(), global_source_to_sinks(), heap_cell_p(), io_cell_p(), k_limit_points_to(), lhs_expression_to_transformer(), list_assignment_to_points_to(), malloc_to_points_to_sinks(), max_module(), module_to_value_mappings(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), new_filter_formal_context_according_to_actual_context(), nowhere_cell_p(), nowhere_source_to_sinks(), null_cell_p(), null_source_to_sinks(), offset_cell(), offset_points_to_cell(), opkill_may_constant_path(), opkill_may_module(), opkill_may_name(), opkill_may_vreference(), opkill_must_constant_path(), opkill_must_module(), opkill_must_name(), opkill_must_reference(), opkill_must_vreference(), pointer_arithmetic_to_points_to(), pointer_source_to_sinks(), pointer_subscript_to_expression(), points_to_anywhere_typed(), points_to_binding(), points_to_cell_add_fixed_subscripts(), points_to_cell_add_zero_subscript(), points_to_cell_complete_with_zero_subscripts(), points_to_cell_equal_p(), points_to_cell_to_number_of_unbounded_dimensions(), points_to_cell_to_string(), points_to_cell_to_type(), points_to_cell_to_upper_bound_points_to_cells(), points_to_cell_translation(), points_to_cell_types_compatibility(), points_to_cell_update_last_subscript(), points_to_cells_intersect_p(), points_to_function_projection(), points_to_reference_to_translation(), points_to_set_block_projection(), points_to_set_sharing_p(), points_to_source_projection(), points_to_source_to_translations(), points_to_translation_mapping_is_typed_p(), points_to_translation_of_formal_parameters(), points_to_with_stripped_sink(), potential_to_effective_memory_leaks(), print_points_to_cells(), process_casted_sinks(), process_casted_sources(), pv_cells_mergeable_p(), reduce_cell_to_pointer_type(), reference_to_points_to_translations(), refine_points_to_cell_subscripts(), related_points_to_cell_in_list_p(), related_points_to_cells_p(), relevant_translation_pair_p(), simple_cell_preceding_p(), simple_cell_to_convex_cell_conversion(), simple_pv_may_union(), simple_pv_must_union(), sinks_fully_matches_source_p(), source_to_sinks(), struct_assignment_to_points_to(), struct_initialization_to_points_to(), struct_reference_assignment_or_equality_to_transformer(), struct_variable_to_pointer_subscripts(), stub_points_to_cell_p(), stub_source_to_sinks(), subscript_to_points_to_sinks(), subscripted_reference_to_points_to(), substitute_stubs_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), type_compatible_super_cell(), type_compatible_with_points_to_cell_p(), typedef_formal_parameter_to_stub_points_to(), unique_location_cell_p(), user_call_to_points_to_sinks(), and variable_to_sinks().

cell_entity()

entity cell_entity

(

cell

c

)

Definition at line 57 of file effects.c.

{
  if (cell_gap_p(c)) return entity_undefined;
 
  else return(reference_variable(cell_any_reference(c)));
}

References cell_any_reference(), cell_gap_p, entity_undefined, and reference_variable.

Referenced by abstract_pointer_value_cell_p(), convex_cells_inclusion_p(), convex_cells_intersection_p(), effect_entity(), generic_effect_find_aliases_with_simple_pointer_values(), malloc_cell_p(), pv_cells_mergeable_p(), pvs_union_combinable_p(), simple_cells_inclusion_p(), simple_cells_intersection_p(), simple_pv_may_union(), simple_pv_must_union(), and std_file_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_entity_equal_p()

bool cell_entity_equal_p	(	cell	c1,
		cell	c2
	)

Has to be extended for GAPs

Parameters

c1	1
c2	2

Definition at line 1234 of file effects.c.

{
  /* Has to be extended for GAPs */
  reference r1 = cell_to_reference(c1);
  reference r2 = cell_to_reference(c2);
  return reference_variable(r1)==reference_variable(r2);
}

References cell_to_reference(), and reference_variable.

Referenced by points_to_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_equal_p()

bool cell_equal_p	(	cell	c1,
		cell	c2
	)

CELLS.

test if two cells are equal; cells are supposed to be references.

Has to be extended for GAPs

Parameters

c1	1
c2	2

Definition at line 1226 of file effects.c.

{
  /* Has to be extended for GAPs */
  reference r1 = cell_to_reference(c1);
  reference r2 = cell_to_reference(c2);
  return reference_equal_p(r1, r2);
}

References cell_to_reference(), and reference_equal_p().

Referenced by cell_must_point_to_nowhere_sink_in_set_p(), cell_points_to_non_null_sink_in_set_p(), cell_points_to_nowhere_sink_in_set_p(), cell_points_to_null_sink_in_set_p(), find_arc_in_points_to_set(), generic_points_to_source_to_sinks(), locations_equal_p(), node_in_points_to_path_p(), points_to_binding(), points_to_cell_in_list_p(), points_to_cell_source_projection(), points_to_cells_intersect_p(), points_to_sink_to_points_to(), points_to_sink_to_sources(), points_to_source_alias(), points_to_source_to_arcs(), remove_arcs_from_pt_map(), sink_in_set_p(), source_in_set_p(), source_subset_in_set_p(), and user_call_to_points_to_intraprocedural().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_equivalent_p()

bool cell_equivalent_p	(	cell	c1,
		cell	c2
	)

Check that memory locations denoted by cell "c1" can be reached by knowing cell "c2" and by using pointer arithmetic or subscripting.

In other words, the two cells only differ by their subscripts... Which might be reducible to "based on the same entity".

FI: experimental...

Has to be extended for GAPs

Parameters

c1	1
c2	2

Definition at line 1311 of file effects.c.

{
  /* Has to be extended for GAPs */
  reference r1 = cell_any_reference(c1);
  reference r2 = cell_any_reference(c2);
  entity v1 = reference_variable(r1);
  entity v2 = reference_variable(r2);
  return v1==v2;
}

References cell_any_reference(), and reference_variable.

Referenced by points_to_sink_to_sources().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_included_p()

bool cell_included_p	(	cell	c1,
		cell	c2
	)

Check that all memory locations denoted by cell "c1" are included in cell "c2".

Has to be extended for GAPs

Parameters

c1	1
c2	2

Definition at line 1294 of file effects.c.

{
  /* Has to be extended for GAPs */
  reference r1 = cell_any_reference(c1);
  reference r2 = cell_any_reference(c2);
  return points_to_reference_included_p(r1, r2);
}

References cell_any_reference(), and points_to_reference_included_p().

Referenced by generic_points_to_source_to_sinks(), points_to_sink_to_sources(), and source_subset_in_set_p().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_indices()

list cell_indices

(

cell

c

)

Definition at line 64 of file effects.c.

{
  list l_res = NIL;
  if (cell_gap_p(c))
    pips_internal_error("GAPs not implemented yet\n");
  else
    l_res = reference_indices(cell_any_reference(c));
  return l_res;
}

References cell_any_reference(), cell_gap_p, NIL, pips_internal_error, and reference_indices.

Referenced by c_convex_effects_on_actual_parameter_forward_translation(), generic_effect_find_aliases_with_simple_pointer_values(), simple_cells_inclusion_p(), and simple_cells_intersection_p().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_to_pointer_cells()

list cell_to_pointer_cells

(

cell

c

)

If the reference in "c" is not a pointer, see if it can be transformed into a pointer reference by adding subscripts, field subscripts or a combination of both...

The "children" list is built with new cells. No sharing is created between "c" and "children".

Definition at line 1739 of file effects.c.

{
  list children = NIL;
  pips_assert("Cell \"c\" has no subscripts.",
              ENDP(reference_indices(cell_any_reference(c))));
 
  children = recursive_cell_to_pointer_cells(c);
 
  pips_assert("Cell \"c\" has children, "
              "or this function would not have been called.", !ENDP(children));
  return children;
}

References cell_any_reference(), ENDP, NIL, pips_assert, recursive_cell_to_pointer_cells(), and reference_indices.

Here is the call graph for this function:

cell_to_reference()

reference cell_to_reference

(

cell

c

)

FI: probably to be moved elsewhere in ri-util.

Here, we only know how to cope (for the time being) with cell_reference and cell_preference, not with cell_gap and other future fields. A bit safer than macro cell_any_reference().

Definition at line 1326 of file effects.c.

                                    {
  reference r = reference_undefined;
 
  if (cell_reference_p(c))
    r = cell_reference(c);
  else if (cell_preference_p(c))
    r = preference_reference(cell_preference(c));
  else
    pips_internal_error("GAPs not implemented yet or unexpected cell tag.\n");
 
  return r;
}

References cell_preference, cell_preference_p, cell_reference, cell_reference_p, pips_internal_error, preference_reference, and reference_undefined.

Referenced by cell_entity_equal_p(), cell_equal_p(), cell_out_of_scope_p(), compute_points_to_kill_set(), first_cell_certainly_includes_second_cell_p(), formal_points_to_parameter(), generic_eval_cell_with_points_to(), generic_reference_to_points_to_matching_list(), generic_transform_sink_cells_from_matching_list(), location_entity(), points_to_cell_name(), points_to_cell_translation(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), points_to_name(), points_to_rank(), points_to_set_block_projection(), points_to_source_projection(), print_or_dump_points_to(), and word_points_to().

Here is the caller graph for this function:

effect_abstract_location_p()

bool effect_abstract_location_p

(

effect

eff

)

Parameters

eff

ff

Definition at line 280 of file effects.c.

{
  return cell_abstract_location_p(effect_cell(eff));
}

References cell_abstract_location_p(), and effect_cell.

Referenced by effect_may_union(), effect_must_union(), effects_abstract_location_p(), and region_union().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_action_kind()

action_kind effect_action_kind

(

effect

eff

)

Parameters

eff

ff

Definition at line 1055 of file effects.c.

{
  action ac = effect_action(eff);
  return action_to_action_kind(ac);
}

References action_to_action_kind(), and effect_action.

Referenced by entity_written_p(), functionnal_on_effects(), no_write_effects_on_var(), and some_conflicts_between().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_comparable_p()

bool effect_comparable_p	(	effect	e1,
		effect	e2
	)

Can we merge these two effects because they are equal or because they only differ by their approximations and their descriptors?

Check the subscript lists because p and p[0] do not refer the same memory locations at all

Parameters

e1	1
e2	2

Definition at line 587 of file effects.c.

{
  bool comparable_p = false;
  reference r1 = effect_any_reference(e1);
  reference r2 = effect_any_reference(e2);
  entity v1 = reference_variable(r1);
  entity v2 = reference_variable(r2);
 
  if(v1==v2) {
    action a1 = effect_action(e1);
    action a2 = effect_action(e2);
    if(action_equal_p(a1, a2))
      {
 
        /* Check the subscript lists because p and p[0] do not refer
           the same memory locations at all */
        list sl1 = reference_indices(r1);
        list sl2 = reference_indices(r2);
        if(gen_length(sl1)==gen_length(sl2))
          {
            list csl1 = list_undefined;
            list csl2 = list_undefined;
            bool equal_p = true;
 
            for(csl1=sl1, csl2=sl2; !ENDP(csl1) && equal_p; POP(csl1), POP(csl2))
              {
                expression e1 = EXPRESSION(CAR(csl1));
                expression e2 = EXPRESSION(CAR(csl2));
                equal_p = expression_equal_p(e1, e2);
              }
            comparable_p = equal_p;
          }
 
      }
  }
 
  return comparable_p;
}

References action_equal_p(), CAR, effect_action, effect_any_reference, ENDP, EXPRESSION, expression_equal_p(), gen_length(), list_undefined, POP, reference_indices, and reference_variable.

Referenced by concerned_entity_p(), and step_get_comparable_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_entity()

entity effect_entity

(

effect

e

)

Created by B.

cproto-generated files

Apvrille, april 11th, 1994 functions related to types effects and effect, cell, reference and gap include"mapping.h" functions for entity

Definition at line 52 of file effects.c.

{
  return(cell_entity(effect_cell(e)));
}

References cell_entity(), and effect_cell.

Referenced by add_conflicts(), check_loop_distribution_feasability(), code_has_write_eff_ref_p(), convex_effect_to_constant_path_effects_with_pointer_values(), effect_may_union(), effect_must_union(), effects_read_variable_p(), effects_write_variable_p(), expr_has_write_eff_ref_p(), free_to_post_pv(), generic_effect_find_aliases_with_simple_pointer_values(), guard_expanded_statement_if_needed(), interference_on(), loop_variant_list(), malloc_effect_p(), pushnew_conflict(), region_union(), same_reg(), same_reg_ignore_action(), simple_effect_to_constant_path_effects_with_pointer_values(), stat_has_write_eff_ref_p(), std_file_effect_p(), step_get_comparable_effects(), text_comp_regions(), true_dependence_with_entity_p(), and update_sesam_tasks_buffers().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_interference()

effect effect_interference	(	effect	eff1,
		effect	eff2
	)

Modifies effect eff1 to make sure that any memory state modification abstracted by eff2 preserves the correctness of eff1: all memory locations included in eff1 at input are included in the memory locations abstracted by the new eff1 after the abstract state transition.

FI: seems to extend naturally to new kinds of effects...

default value

nothing to worry about

pointer-dependence write, indexed or not

The base address for the write is constant, the indices should be be checked

The write effect is a direct effet, the other effect may be direct or indirect, indexed or not.

FI: should be very similar to reference_with_store_independent_indices()?

Does the write impact some indices of the read?

May be shared because of persistant references

Parameters

eff1	ff1
eff2	ff2

Definition at line 863 of file effects.c.

{
  //action ac1 = effect_action(eff1);
  action ac2 = effect_action(eff2);
  effect n_eff1 = eff1; /* default value */
 
  ifdebug(1) {
    pips_assert("The new effect is consistent", effect_consistent_p(eff1));
    pips_assert("The new effect is consistent", effect_consistent_p(eff2));
  }
 
  if(store_independent_effect_p(eff1)) {
    /* nothing to worry about */
    ;
  }
  else if(action_write_p(ac2)) {
    if(anywhere_effect_p(eff2)) {
      // free_effect(eff1);
      n_eff1 = effect_to_store_independent(eff1);
    }
    else {
      reference r2 = effect_any_reference(eff2);
      entity v2 = reference_variable(r2);
      type t2 = ultimate_type(entity_type(v2));
 
      if(pointer_type_p(t2)) {
        /* pointer-dependence write, indexed or not */
        n_eff1 = effect_to_pointer_store_independent_effect(eff1, v2);
      }
      else {
        /* The base address for the write is constant, the indices should be be checked */
        /* The write effect is a direct effet, the other effect may be
           direct or indirect, indexed or not. */
        reference r1 = effect_any_reference(eff1);
        list ind1 = reference_indices(r1);
        list cind1 = list_undefined;
 
        /* FI: should be very similar to reference_with_store_independent_indices()? */
 
        /* Does the write impact some indices of the read? */
        for(cind1 = ind1; !ENDP(ind1); POP(ind1)) {
          expression s = EXPRESSION(CAR(cind1));
          list rl = NIL;
          list crl = list_undefined;
          bool interfere_p = false;
 
          rl = expression_to_reference_list(s, rl);
          for(crl=rl; !ENDP(rl); POP(rl)) {
            reference r = REFERENCE(CAR(crl));
            entity v = reference_variable(r);
            if(v2==v) {
              interfere_p = true;
              break;
            }
          }
 
          if(interfere_p) {
            pips_debug(8, "Interference detected\n");
            /* May be shared because of persistant references */
            //free_expression(s);
            EXPRESSION_(CAR(ind1)) = make_unbounded_expression();
          }
        }
      }
    }
  }
  ifdebug(1)
    pips_assert("The new effect is consistent", effect_consistent_p(n_eff1));
  return n_eff1;
}

References action_write_p, anywhere_effect_p(), CAR, effect_action, effect_any_reference, effect_consistent_p(), effect_to_pointer_store_independent_effect(), effect_to_store_independent(), ENDP, entity_type, EXPRESSION, EXPRESSION_, expression_to_reference_list(), ifdebug, list_undefined, make_unbounded_expression(), NIL, pips_assert, pips_debug, pointer_type_p(), POP, REFERENCE, reference_indices, reference_variable, store_independent_effect_p(), and ultimate_type().

Here is the call graph for this function:

effect_list_can_be_safely_full_freed_p()

bool effect_list_can_be_safely_full_freed_p

(

list

el

)

Check if some references might be freed with the effects.

This may lead to disaster if the references are part of another PIPS data structure. This information is not fully accurate, but conservative.

The free is very likely to be unsafe

Is it a possible C reference or is it a synthetic reference generated by the effect analysis? Hard to decide...

Parameters

el

l

Definition at line 1159 of file effects.c.

{
  bool safe_p = true;
  FOREACH(EFFECT, e, el) {
    cell c = effect_cell(e);
    if(cell_reference_p(c)) {
      reference r = cell_reference(c);
      list inds = reference_indices(r);
 
      if(ENDP(inds)) {
        /* The free is very likely to be unsafe */
        //entity v = reference_variable(r);
        safe_p = false;
        //fprintf(stderr, "cell_reference for %s", entity_name(v));
      }
      else {
        /* Is it a possible C reference or is it a synthetic reference
           generated by the effect analysis? Hard to decide... */
        //entity v = reference_variable(r);
        //fprintf(stderr, "cell_reference for %s", entity_name(v));
        //print_reference(r);
      }
      break;
    }
  }
  return safe_p;
}

References cell_reference, cell_reference_p, EFFECT, effect_cell, ENDP, FOREACH, and reference_indices.

Referenced by safe_any_expression_to_transformer().

Here is the caller graph for this function:

effect_list_consistent_p()

bool effect_list_consistent_p

(

list

el

)

Debugging.

Parameters

el

l

Definition at line 1340 of file effects.c.

{
  bool ok_p = true;
 
  FOREACH(EFFECT, e, el)
    ok_p = ok_p && effect_consistent_p(e);
 
  return ok_p;
}

References EFFECT, effect_consistent_p(), and FOREACH.

Here is the call graph for this function:

effect_on_non_local_variable_p()

bool effect_on_non_local_variable_p

(

effect

eff

)

Test if an effect has a non local effect.

Parameters

[in]

eff

is the effect to analyse

Returns

true if the effect is on a non local effect

Parameters

eff

ff

Definition at line 674 of file effects.c.

                                                {
  return !same_string_p(
            entity_module_name(reference_variable(effect_any_reference(eff))),
            get_current_module_name()
            );
}

References effect_any_reference, entity_module_name(), get_current_module_name(), reference_variable, and same_string_p.

Referenced by effects_on_non_local_variable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_scalar_p()

bool effect_scalar_p

(

effect

eff

)

Parameters

eff

ff

Definition at line 567 of file effects.c.

{
  bool scalar_p = false;
  reference r = effect_any_reference(eff);
  list sl = reference_indices(r);
  if(ENDP(sl)) {
    entity v = reference_variable(r);
    type t = entity_type(v); // basic_concrete_type?
    int d = type_depth(t);
    if(d==0)
      scalar_p = true;
    else {
      scalar_p = pointer_type_p(t);
    }
  }
  return scalar_p;
}

References effect_any_reference, ENDP, entity_type, pointer_type_p(), reference_indices, reference_variable, and type_depth().

Referenced by atomic_effect_p(), effect_may_union(), effect_must_union(), first_effect_certainly_includes_second_effect_p(), first_exact_scalar_effect_certainly_includes_second_effect_p(), kill_effects(), and proper_to_summary_simple_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_to_entity()

entity effect_to_entity

(

effect

ef

)

Returns the entity corresponding to the mutation.

It could be called effect_to_variable(), but effects are sometimes summarized with abstract locations, i.e. sets of locations.

FI unlikely to work with GAPs

Parameters

ef

f

Definition at line 1413 of file effects.c.

{
  /* FI unlikely to work with GAPs */
  reference r = effect_any_reference(ef);
  entity e = reference_variable(r);
 
  return e;
}

References effect_any_reference, and reference_variable.

Referenced by add_conflicts().

Here is the caller graph for this function:

effect_to_non_pointer_store_independent_effect()

effect effect_to_non_pointer_store_independent_effect

(

effect

eff

)

Modify eff so that the set of memory locations decribed after a write to some non pointer variable is still in the abstract location set of eff.

\n_eff i = ...; \ eff of stmt s: p[j], q[i],.. s;

Parameters

eff

ff

Definition at line 844 of file effects.c.

{
  reference r = effect_any_reference(eff);
  //entity v = reference_variable(r);
  //type t = ultimate_type(entity_type(v));
 
  r = reference_with_store_independent_indices(r);
 
  return eff;
}

References effect_any_reference, and reference_with_store_independent_indices().

Here is the call graph for this function:

effect_to_pointer_store_independent_effect()

effect effect_to_pointer_store_independent_effect	(	effect	eff,
		entity	p
	)

Modify eff so that the set of memory locations decribed after a write to some pointer p is still in the abstract location set of eff.

\n_eff p = ...; \ eff of stmt s s;

If p is undefined, assumed that any pointer may have been updated.

As a pointer could be used in indexing, the current implementation is not correct/sufficient

p[i][j] cannot be preserved

No problem: direct scalar reference

Parameters

eff

ff

Definition at line 815 of file effects.c.

{
  reference r = effect_any_reference(eff);
  entity v = reference_variable(r);
  //type t = ultimate_type(entity_type(v));
 
  if(entity_undefined_p(p) || v==p) {
    if(!ENDP(reference_indices(r))) {
      /* p[i][j] cannot be preserved */
      effect n_eff = anywhere_effect(copy_action(effect_action(eff)));
      free_effect(eff);
      eff = n_eff;
    }
    else {
      /* No problem: direct scalar reference */
      ;
    }
  }
  return eff;
}

References anywhere_effect(), copy_action(), effect_action, effect_any_reference, ENDP, entity_undefined_p, free_effect(), reference_indices, and reference_variable.

Referenced by effect_interference().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_to_store_independent()

effect effect_to_store_independent

(

effect

eff

)

Parameters

eff

ff

Definition at line 772 of file effects.c.

{
  reference r = effect_any_reference(eff);
  entity v = reference_variable(r);
  type t = ultimate_type(entity_type(v));
 
  if(pointer_type_p(t)) {
    effect n_eff = anywhere_effect(copy_action(effect_action(eff)));
    free_effect(eff);
    eff = n_eff;
  }
  else{
    list ind = reference_indices(r);
    list cind = list_undefined;
 
    for(cind = ind; !ENDP(cind); POP(cind)) {
      expression e = EXPRESSION(CAR(cind));
 
      if(!unbounded_expression_p(e)) {
        if(!extended_integer_constant_expression_p(e)) {
          free_expression(e);
          EXPRESSION_(CAR(cind)) = make_unbounded_expression();
        }
      }
    }
  }
 
  return eff;
}

References anywhere_effect(), CAR, copy_action(), effect_action, effect_any_reference, ENDP, entity_type, EXPRESSION, EXPRESSION_, extended_integer_constant_expression_p(), free_effect(), free_expression(), list_undefined, make_unbounded_expression(), pointer_type_p(), POP, reference_indices, reference_variable, ultimate_type(), and unbounded_expression_p().

Referenced by effect_interference().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_abstract_location_p()

bool effects_abstract_location_p

(

list

el

)

Returns true if at least one effect of effect list el is related to an abstract location.

Parameters

el

l

Definition at line 288 of file effects.c.

{
  bool abstract_p = false;
 
  FOREACH(EFFECT, e, el) {
    if(effect_abstract_location_p(e)) {
      abstract_p = true;
      break;
    }
  }
  return abstract_p;
}

References EFFECT, effect_abstract_location_p(), and FOREACH.

Referenced by statement_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_all_read_p()

bool effects_all_read_p

(

list

el

)

Check that all effects in el are read effects.

Parameters

el

l

Definition at line 1141 of file effects.c.

{
  bool result = true;
  FOREACH(EFFECT, e, el) {
    action a  = effect_action(e);
    //entity ev = effect_entity(e);
    if (action_write_p(a)) {
      result = false;
      break;
    }
  }
  return result;
}

References action_write_p, EFFECT, effect_action, and FOREACH.

Referenced by regenerate_call().

Here is the caller graph for this function:

effects_interfere_p()

bool effects_interfere_p	(	effect	eff1,
		effect	eff2
	)

Two effects interfere if one of them modify the set of locations defined by the other one.

For instance, an index or a pointer may be used by one effect and changed by the other one.

If a subscript expression is changed, the corresponding subscript must be replaced by an unbounded expression.

If a pointer is written, any indirect effect thru this pointer must be changed into a read or write anywhere.

This function is conservative: it is always correct to declare an interference.

FI: I'm not sure what you can do when you know two effects interfere...

dealing with standard effects

start with complex cases

The write effect is a direct effet, the other effect may be direct or indirect, indexed or not.

Does the write impact the indices of the read?

Parameters

eff1	ff1
eff2	ff2

Definition at line 714 of file effects.c.

{
  action ac1 = effect_action(eff1);
  action ac2 = effect_action(eff2);
  bool interfere_p = false;
 
  if(action_write_p(ac1)||action_write_p(ac2)) {
    if(anywhere_effect_p(eff1) && action_write_p(ac1)) {
      interfere_p = !store_independent_effect_p(eff2);
    }
    else if(anywhere_effect_p(eff2) && action_write_p(ac2)) {
      interfere_p = !store_independent_effect_p(eff1);
    }
    else { /* dealing with standard effects */
 
      /* start with complex cases */
      /* The write effect is a direct effet, the other effect may be
         direct or indirect, indexed or not. */
      reference wr = reference_undefined;
      entity wv = entity_undefined;
      reference rr = reference_undefined;
 
      list rind = list_undefined;
 
      if(action_write_p(ac1)) {
        wr = effect_any_reference(eff1);
        rr = effect_any_reference(eff2);
      }
      else {
        wr = effect_any_reference(eff2);
        rr = effect_any_reference(eff1);
      }
 
      wv = reference_variable(wr);
      rind = reference_indices(rr);
 
      /* Does the write impact the indices of the read? */
      MAP(EXPRESSION, s, {
          list rl = NIL;
 
          rl = expression_to_reference_list(s, rl);
          MAP(REFERENCE, r, {
              entity v = reference_variable(r);
              if(wv==v) {
                interfere_p = true;
                break;
              }
            }, rl);
          if(interfere_p)
            break;
        }, rind);
 
      //interfere_p = true;
    }
  }
  return interfere_p;
}

References action_write_p, anywhere_effect_p(), effect_action, effect_any_reference, entity_undefined, EXPRESSION, expression_to_reference_list(), list_undefined, MAP, NIL, REFERENCE, reference_indices, reference_undefined, reference_variable, and store_independent_effect_p().

Here is the call graph for this function:

effects_on_non_local_variable_p()

bool effects_on_non_local_variable_p

(

list

effects

)

Test if a list of effects concerns non local variables.

Parameters

[in]

effects

is the effect list to scan

Returns

true if there is an effect on a global variable

Definition at line 687 of file effects.c.

                                                   {
  FOREACH(EFFECT,eff,effects)
    if (effect_on_non_local_variable_p(eff)) {
      //char * seffect = effect_to_string(eff);
      //pips_user_warning("effect on non local variable: %s\n",seffect);
      //free(seffect);
      return true;
    }
  return false;
}

References EFFECT, effect_on_non_local_variable_p(), and FOREACH.

Here is the call graph for this function:

effects_read_variable_p()

bool effects_read_variable_p	(	list	el,
		entity	v
	)

Parameters

el

l

Definition at line 1123 of file effects.c.

{
  bool result = false;
  if(v) {
    FOREACH(EFFECT, e, el) {
      action a  = effect_action(e);
      entity ev = effect_entity(e);
      if (action_read_p(a) && store_effect_p(e)
          && entities_may_conflict_p(ev,v) ) {
        result = true;
        break;
      }
    }
  }
  return result;
}

References action_read_p, EFFECT, effect_action, effect_entity(), entities_may_conflict_p(), FOREACH, and store_effect_p().

Referenced by entity_used_somewhere_walker(), graph_to_live_writes(), loop_annotate(), and vertex_to_chains().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_to_list()

list effects_to_list

(

effects

efs

)

Parameters

efs

fs

Definition at line 209 of file effects.c.

{
    list l_res = effects_effects(efs);
    return l_res;
}

References effects_effects.

Referenced by add_classes_for_this_callee(), add_common_variables_to_hash_table(), check_call_mode_consistency(), do_check_isolate_statement_preconditions_on_call(), effectsmap_to_listmap(), generic_module_name_to_transformers(), in_alias_pairs(), in_regions_of_external(), load_summary_effects(), module_name_to_total_preconditions(), out_alias_pairs(), print_crough(), program_precondition(), regions_of_external(), regions_to_loops(), and remove_common_variables_from_hash_table().

Here is the caller graph for this function:

effects_write_p()

bool effects_write_p

(

list

el

)

Parameters

el

l

Definition at line 1108 of file effects.c.

{
  bool result = false;
 
  FOREACH(EFFECT, e, el) {
    action a  = effect_action(e);
    if (action_write_p(a) && store_effect_p(e)) {
      result = true;
      break;
    }
  }
 
  return result;
}

References action_write_p, EFFECT, effect_action, FOREACH, and store_effect_p().

Here is the call graph for this function:

effects_write_variable_p()

bool effects_write_variable_p	(	list	el,
		entity	v
	)

Parameters

el

l

Definition at line 1091 of file effects.c.

{
  bool result = false;
  if(v) {
    FOREACH(EFFECT, e, el) {
      action a  = effect_action(e);
      entity ev = effect_entity(e);
      if (action_write_p(a) && store_effect_p(e)
          && entities_may_conflict_p(ev,v) ) {
        result = true;
        break;
      }
    }
  }
  return result;
}

References action_write_p, EFFECT, effect_action, effect_entity(), entities_may_conflict_p(), FOREACH, and store_effect_p().

Referenced by block_to_complexity(), graph_to_live_writes(), prune_non_constant(), and vertex_to_chains().

Here is the call graph for this function:

Here is the caller graph for this function:

effectsmap_to_listmap()

statement_mapping effectsmap_to_listmap

(

statement_mapping

efs_map

)

Parameters

efs_map

fs_map

Definition at line 228 of file effects.c.

{
    statement_mapping l_map = MAKE_STATEMENT_MAPPING();
 
    STATEMENT_MAPPING_MAP(s,val,{
        hash_put((hash_table) l_map, (char *) s, (char *) effects_to_list((effects) val));
    }, efs_map);
 
    return l_map;
}

References effects_to_list(), hash_put(), MAKE_STATEMENT_MAPPING, and STATEMENT_MAPPING_MAP.

Here is the call graph for this function:

environment_effect_p()

bool environment_effect_p

(

effect

e

)

Definition at line 1071 of file effects.c.

{
  action a = effect_action(e);
  action_kind ak = action_read_p(a)? action_read(a) : action_write(a);
  bool env_p = action_kind_environment_p(ak);
 
  return env_p;
}

References action_kind_environment_p, action_read, action_read_p, action_write, and effect_action.

Referenced by find_effect_actions_for_entity().

Here is the caller graph for this function:

FILE_star_effect_reference_p()

bool FILE_star_effect_reference_p

(

reference

ref

)

Parameters

ref

ef

Definition at line 536 of file effects.c.

{
  bool res = false;
  type t = entity_basic_concrete_type(reference_variable(ref));
  pips_debug(8, "begin with type %s\n", string_of_type(t));
  if (type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      if (basic_pointer_p(b))
        {
          t = basic_pointer(b);
           if (type_variable_p(t))
             {
                basic b = variable_basic(type_variable(t));
                if (basic_derived_p(b))
                  {
                    entity te = basic_derived(b);
                    if (same_string_p(entity_user_name(te), "_IO_FILE"))
                      {
                        res = true;
                      }
                  }
             }
        }
    }
  pips_debug(8, "end with : %s\n", res? "true":"false");
  return res;
}

References basic_derived, basic_derived_p, basic_pointer, basic_pointer_p, entity_basic_concrete_type(), entity_user_name(), pips_debug, ref, reference_variable, same_string_p, string_of_type(), type_variable, type_variable_p, and variable_basic.

Referenced by create_step_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

full_action_to_short_string()

string full_action_to_short_string

(

action

ac

)

Parameters

ac

c

Definition at line 969 of file effects.c.

{
  string s = string_undefined;
  if(action_read_p(ac)) {
    action_kind ak = action_read(ac);
 
    if(action_kind_store_p(ak))
      s = "R";
    else if(action_kind_environment_p(ak))
      s = "RE";
    else if(action_kind_type_declaration_p(ak))
      s = "RT";
  }
  else {
    action_kind ak = action_write(ac);
 
    if(action_kind_store_p(ak))
      s = "W";
    else if(action_kind_environment_p(ak))
      s = "WE";
    else if(action_kind_type_declaration_p(ak))
      s = "WT";
  }
  return s;
}

References action_kind_environment_p, action_kind_store_p, action_kind_type_declaration_p, action_read, action_read_p, action_write, and string_undefined.

Referenced by conflicts_sort_callback(), prettyprint_dependence_graph(), and prettyprint_dot_dependence_graph().

Here is the caller graph for this function:

full_action_to_string()

string full_action_to_string

(

action

ac

)

Parameters

ac

c

Definition at line 943 of file effects.c.

{
  string s = string_undefined;
  if(action_read_p(ac)) {
    action_kind ak = action_read(ac);
 
    if(action_kind_store_p(ak))
      s = "read memory";
    else if(action_kind_environment_p(ak))
      s = "read environment";
    else if(action_kind_type_declaration_p(ak))
      s = "read type";
  }
  else {
    action_kind ak = action_write(ac);
 
    if(action_kind_store_p(ak))
      s = "write memory";
    else if(action_kind_environment_p(ak))
      s = "write environment";
    else if(action_kind_type_declaration_p(ak))
      s = "write type";
  }
  return s;
}

References action_kind_environment_p, action_kind_store_p, action_kind_type_declaration_p, action_read, action_read_p, action_write, and string_undefined.

generic_anywhere_effect_p()

static bool generic_anywhere_effect_p ( effect  e, int  kind  )

static

Is it an anywhere effect (kind=0)? a typed anywhere effect (kind=1) ? or any kind of anywhere effect (kind=2)?

Definition at line 333 of file effects.c.

{
  bool anywhere_p;
  reference r = effect_any_reference(e);
  entity v = reference_variable(r);
 
  anywhere_p =  (entity_all_locations_p(v) && (kind==0||kind==2))
    || (entity_typed_anywhere_locations_p(v) && (kind==1||kind==2));
 
  return anywhere_p;
}

References effect_any_reference, entity_all_locations_p(), entity_typed_anywhere_locations_p(), and reference_variable.

Referenced by any_anywhere_effect_p(), anywhere_effect_p(), and typed_anywhere_effect_p().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_cell_p()

bool heap_cell_p

(

cell

c

)

Any heap cell, more or less abstract or typed.

Definition at line 420 of file effects.c.

{
  bool heap_p;
  reference r = cell_any_reference(c);
  entity v = reference_variable(r);
 
  heap_p = (strstr(entity_local_name(v), HEAP_AREA_LOCAL_NAME)
            ==entity_local_name(v));
 
  return heap_p;
}

References cell_any_reference(), entity_local_name(), HEAP_AREA_LOCAL_NAME, and reference_variable.

Referenced by binary_intrinsic_call_to_points_to_sinks(), compute_points_to_binded_set(), compute_points_to_gen_set(), compute_points_to_kill_set(), freeable_points_to_cells(), freed_list_to_points_to(), freed_pointer_to_points_to(), list_assignment_to_points_to(), memory_leak_to_more_memory_leaks(), points_to_cell_translation(), points_to_cell_types_compatibility(), points_to_function_projection(), points_to_set_block_projection(), points_to_source_projection(), points_to_with_stripped_sink(), remove_points_to_cell(), and unique_location_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_effect()

effect heap_effect	(	entity	m,
		action	ac
	)

Parameters

ac

c

Definition at line 391 of file effects.c.

{
  entity heap = FindEntity(entity_local_name(m), HEAP_AREA_LOCAL_NAME );
  effect any = effect_undefined;
 
  if(entity_undefined_p(heap)) {
    pips_internal_error("Heap for module \"%s\" not found", entity_name(m));
  }
 
  any = make_effect(make_cell_reference(make_reference(heap, NIL)),
                    ac,
                    make_approximation_may(),
                    make_descriptor_none());
 
  return any;
}

References effect_undefined, entity_local_name(), entity_name, entity_undefined_p, FindEntity(), HEAP_AREA_LOCAL_NAME, make_approximation_may(), make_cell_reference(), make_descriptor_none(), make_effect(), make_reference(), NIL, and pips_internal_error.

Here is the call graph for this function:

heap_effect_p()

bool heap_effect_p

(

effect

e

)

Definition at line 408 of file effects.c.

{
  bool heap_p;
  reference r = effect_any_reference(e);
  entity v = reference_variable(r);
 
  heap_p = same_string_p(entity_local_name(v), HEAP_AREA_LOCAL_NAME);
 
  return heap_p;
}

References effect_any_reference, entity_local_name(), HEAP_AREA_LOCAL_NAME, reference_variable, and same_string_p.

Here is the call graph for this function:

io_cell_p()

bool io_cell_p

(

cell

c

)

Definition at line 506 of file effects.c.

{
  return io_effect_entity_p(reference_variable(cell_any_reference(c)));
}

References cell_any_reference(), io_effect_entity_p(), and reference_variable.

Here is the call graph for this function:

io_effect_entity_p()

bool io_effect_entity_p

(

entity

e

)

Definition at line 496 of file effects.c.

{
    return io_luns_entity_p(e);
}

References io_luns_entity_p().

Referenced by io_cell_p(), io_effect_p(), io_efficient_compile(), pure_function_p(), and safe_effects_for_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

io_effect_p()

bool io_effect_p

(

effect

e

)

Definition at line 501 of file effects.c.

{
  return io_effect_entity_p(reference_variable(effect_any_reference(e)));
}

References effect_any_reference, io_effect_entity_p(), and reference_variable.

Referenced by create_step_regions(), do_check_isolate_statement_preconditions_on_call(), effects_to_dma(), guard_expanded_statement_if_needed(), io_effects_p(), and potential_out_effects_p().

Here is the call graph for this function:

Here is the caller graph for this function:

io_effects_p()

bool io_effects_p

(

list

effects

)

Definition at line 512 of file effects.c.

{
    FOREACH(EFFECT,eff,effects)
        if(io_effect_p(eff)) return true;
    return false;
}

References EFFECT, FOREACH, and io_effect_p().

Here is the call graph for this function:

list_to_effects()

effects list_to_effects

(

list

l_eff

)

Future API for GAP, Generic Access Path.

---

list-effects conversion functions

---

Parameters

l_eff

_eff

Definition at line 202 of file effects.c.

{
    effects res = make_effects(l_eff);
    return res;
}

References make_effects().

Referenced by listmap_to_effectsmap().

Here is the call graph for this function:

Here is the caller graph for this function:

listmap_to_effectsmap()

statement_mapping listmap_to_effectsmap

(

statement_mapping

l_map

)

Parameters

l_map

_map

Definition at line 216 of file effects.c.

{
    statement_mapping efs_map = MAKE_STATEMENT_MAPPING();
 
    STATEMENT_MAPPING_MAP(s,val,{
        hash_put((hash_table) efs_map, (char *) s, (char *) list_to_effects((list) val));
    }, l_map);
 
    return efs_map;
}

References hash_put(), list_to_effects(), MAKE_STATEMENT_MAPPING, and STATEMENT_MAPPING_MAP.

Here is the call graph for this function:

make_action_read_memory()

action make_action_read_memory

(

void

)

Definition at line 1017 of file effects.c.

{
  action a = make_action_read(make_action_kind_store());
  return a;
}

References make_action_kind_store(), and make_action_read().

Referenced by c_convex_effects_on_formal_parameter_backward_translation(), call_to_post_pv(), cells_to_read_or_write_effects(), check_for_effected_statement(), create_step_regions(), expression_to_post_pv(), live_out_paths_from_loop_to_body(), and real_regions_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

make_action_write_memory()

action make_action_write_memory

(

void

)

To ease the extension of action with action_kind.

Definition at line 1011 of file effects.c.

{
  action a = make_action_write(make_action_kind_store());
  return a;
}

References make_action_kind_store(), and make_action_write().

Referenced by array_must_fully_written_by_regions_p(), c_convex_effects_on_actual_parameter_forward_translation(), c_convex_effects_on_formal_parameter_backward_translation(), cells_to_read_or_write_effects(), check_for_effected_statement(), convex_cell_reference_preceding_p(), create_step_regions(), expression_to_post_pv(), external_call_to_post_pv(), forloop_to_post_pv(), free_to_post_pv(), generic_effect_find_aliases_with_simple_pointer_values(), generic_eval_cell_with_points_to(), generic_transform_sink_cells_from_matching_list(), heap_intrinsic_to_post_pv(), loop_initialization_to_transformer(), loop_to_post_pv(), module_initial_parameter_pv(), multiple_pointer_assignment_to_post_pv(), safe_intrinsic_to_post_pv(), simple_reference_to_convex_reference_conversion(), single_pointer_assignment_to_post_pv(), summary_to_proper_reference(), use_default_sink_cell(), and whileloop_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

malloc_cell_p()

bool malloc_cell_p

(

cell

c

)

Definition at line 483 of file effects.c.

{
  return malloc_effect_entity_p(cell_entity(c));
}

References cell_entity(), and malloc_effect_entity_p().

Here is the call graph for this function:

malloc_effect_p()

bool malloc_effect_p

(

effect

e

)

Definition at line 478 of file effects.c.

{
  return malloc_effect_entity_p(effect_entity(e));
}

References effect_entity(), and malloc_effect_entity_p().

Referenced by set_add_scalars().

Here is the call graph for this function:

Here is the caller graph for this function:

malloc_reference_p()

bool malloc_reference_p

(

reference

r

)

Definition at line 488 of file effects.c.

{
  return malloc_effect_entity_p(reference_variable(r));
}

References malloc_effect_entity_p(), and reference_variable.

Here is the call graph for this function:

memory_dereferencing_p()

bool memory_dereferencing_p

(

reference

r

)

Does the set of locations referenced by r depend on a pointer dereferencing?

Let's hope that all Fortran 77 references will return false...

See effect_reference_dereferencing_p()

Get rid of simple Fortran-like array accesses

This is a simple array access

cycle with alias-classes library: import explictly

entity_heap_variable_p(v)

Heap modelization is behind

Let's walk the subscript list and see if the type associated to the nth subscript is a pointer type and if the (n+1)th subscript is a zero.

Since it is subscripted, there is dereferencing

No dereferencing

Definition at line 92 of file effects.c.

{
  bool dereferencing_p = false;
  entity v = reference_variable(r);
  type vt = entity_type(v);
  type uvt = entity_basic_concrete_type(v);
  list sl = reference_indices(r); // subscript list
 
  // FI: constant string such as "hello world" are used ni reference
  // although they are 0-ary functions
  if(! type_functional_p(vt)) {
 
    /* Get rid of simple Fortran-like array accesses */
    if(gen_length(sl)==gen_length(variable_dimensions(type_variable(vt)))) {
      /* This is a simple array access */
      dereferencing_p = false;
    }
    else if(!ENDP(sl)) {
      /* cycle with alias-classes library: import explictly */
      bool entity_abstract_location_p(entity);
      if(entity_abstract_location_p(v)) {
        pips_internal_error("Do we want to subscript abstract locations?");
      }
      else if(false /* entity_heap_variable_p(v)*/) {
        /* Heap modelization is behind*/
      }
      else if(entity_variable_p(v)) {
        /* Let's walk the subscript list and see if the type associated
         * to the nth subscript is a pointer type and if the (n+1)th
         * subscript is a zero.
         */
        list csl = sl; // current subscript list
        type ct = uvt; // current type
        if(pointer_type_p(uvt)) {
          /* Since it is subscripted, there is dereferencing */
          dereferencing_p = true;
          csl = NIL;
        }
        else if(array_type_p(uvt)) {
          variable v = type_variable(uvt);
          int d = (int) gen_length(variable_dimensions(v));
          int sn = (int) gen_length(sl);
          if(sn<=d) {
            dereferencing_p = false;
            csl = NIL;
          }
          else {
            ct = array_type_to_element_type(uvt);
            int i;
            for(i=1;i<=d;i++)
              POP(csl);
          }
        }
        else if(struct_type_p(uvt)) {
          int sn = (int) gen_length(sl);
          if(sn<=1) {
            dereferencing_p = false;
            csl = NIL;
          }
          else {
            expression s = EXPRESSION(CAR(sl));
            ct = points_to_expression_to_concrete_type(s);
            POP(csl);
          } 
        }
        else {
          ; // FI: do nothing but acceleration possible with struct_type_p()
        }
        while(!dereferencing_p && !ENDP(csl)) {
          expression se = EXPRESSION(CAR(csl));
          ct = ultimate_type(subscripted_type_to_type(ct, se));
          if(pointer_type_p(ct) && !ENDP(CDR(csl))) {
            dereferencing_p = true;
          }
          else if(array_type_p(ct)) {
            int n = (int) array_type_dimension(ct);
            for(int i = 0; i<n && !ENDP(csl); i++) {
              POP(csl);
              if(i>0) {
                // Update ct
                expression se = EXPRESSION(CAR(csl));
                ct = ultimate_type(subscripted_type_to_type(ct, se));
              }
            }
          }
          else {
            POP(csl);
          }
        }
      }
      else {
        pips_internal_error("Unexpected entity kind \"%s\"", entity_name(v));
      }
    }
    else {
      /* No dereferencing */
      ;
    }
  }
 
  return dereferencing_p;
}

References array_type_dimension(), array_type_p(), array_type_to_element_type(), CAR, CDR, ENDP, entity_abstract_location_p(), entity_basic_concrete_type(), entity_name, entity_type, entity_variable_p, EXPRESSION, gen_length(), int, NIL, pips_internal_error, pointer_type_p(), points_to_expression_to_concrete_type(), POP, reference_indices, reference_variable, struct_type_p(), subscripted_type_to_type(), type_functional_p, type_variable, ultimate_type(), and variable_dimensions.

Referenced by consistent_points_to_arc_p().

Here is the call graph for this function:

Here is the caller graph for this function:

nowhere_cell_p()

bool nowhere_cell_p

(

cell

c

)

Target of an undefined pointer.

Definition at line 455 of file effects.c.

{
  bool nowhere_p;
  reference r = cell_any_reference(c);
  entity v = reference_variable(r);
 
  nowhere_p = entity_typed_nowhere_locations_p(v);
 
  return nowhere_p;
}

References cell_any_reference(), entity_typed_nowhere_locations_p(), and reference_variable.

Referenced by atomic_points_to_cell_p(), binary_intrinsic_call_to_points_to_sinks(), cell_must_point_to_nowhere_sink_in_set_p(), cell_points_to_non_null_sink_in_set_p(), cell_points_to_nowhere_sink_in_set_p(), cells_may_not_point_to_null_p(), cells_to_read_or_write_effects(), check_type_of_points_to_cells(), compute_points_to_gen_set(), dereferencing_to_sinks(), equal_condition_to_points_to(), extended_source_to_sinks(), filter_formal_context_according_to_actual_context(), filter_formal_out_context_according_to_formal_in_context(), freed_list_to_points_to(), fuse_points_to_sink_cells(), generic_points_to_source_to_sinks(), generic_reference_to_points_to_matching_list(), internal_pointer_assignment_to_points_to(), intrinsic_call_to_points_to(), list_assignment_to_points_to(), merge_actual_and_formal_sinks(), new_filter_formal_context_according_to_actual_context(), new_recursive_filter_formal_context_according_to_actual_context_for_pointer_pair(), non_equal_condition_to_points_to(), offset_cell(), offset_points_to_cell(), pointer_arithmetic_to_points_to(), points_to_binding_arguments(), points_to_cell_types_compatibility(), points_to_function_projection(), points_to_reference_to_translation(), points_to_source_cell_compatible_p(), points_to_source_to_translations(), points_to_with_stripped_sink(), print_or_dump_points_to(), process_casted_sinks(), process_casted_sources(), recursive_filter_formal_context_according_to_actual_context(), reference_dereferencing_to_points_to(), reference_to_points_to_translations(), remove_impossible_arcs_to_null(), source_to_sinks(), subscript_to_points_to_sinks(), and words_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

null_cell_p()

bool null_cell_p

(

cell

c

)

Definition at line 466 of file effects.c.

{
  bool null_p;
  reference r = cell_any_reference(c);
  entity v = reference_variable(r);
 
  null_p = entity_null_locations_p(v);
 
  return null_p;
}

References cell_any_reference(), entity_null_locations_p(), and reference_variable.

Referenced by atomic_points_to_cell_p(), binary_intrinsic_call_to_points_to_sinks(), cell_must_point_to_nowhere_sink_in_set_p(), cell_points_to_non_null_sink_in_set_p(), cell_points_to_nowhere_sink_in_set_p(), cell_points_to_null_sink_in_set_p(), cells_may_not_point_to_null_p(), cells_must_point_to_null_p(), cells_to_read_or_write_effects(), check_type_of_points_to_cells(), compute_points_to_gen_set(), dereferencing_subscript_to_points_to(), dereferencing_to_sinks(), expression_to_points_to_cells(), expression_to_points_to_sources(), extended_source_to_sinks(), filter_formal_context_according_to_actual_context(), freed_list_to_points_to(), freed_pointer_to_points_to(), fuse_points_to_sink_cells(), generic_atomic_points_to_cell_p(), generic_points_to_source_to_sinks(), generic_reference_to_points_to_matching_list(), list_assignment_to_points_to(), merge_actual_and_formal_sinks(), new_filter_formal_context_according_to_actual_context(), new_recursive_filter_formal_context_according_to_actual_context(), null_equal_condition_to_points_to(), null_non_equal_condition_to_points_to(), offset_cell(), offset_cells(), offset_points_to_cell(), pointer_arithmetic_to_points_to(), points_to_binding_arguments(), points_to_cell_types_compatibility(), points_to_reference_to_translation(), points_to_source_cell_compatible_p(), points_to_source_to_translations(), points_to_with_stripped_sink(), print_or_dump_points_to(), process_casted_sinks(), process_casted_sources(), recursive_filter_formal_context_according_to_actual_context(), reduce_cells_to_pointer_type(), reference_dereferencing_to_points_to(), reference_may_points_to_null_p(), reference_must_points_to_null_p(), reference_to_points_to_translations(), remove_impossible_arcs_to_null(), source_to_sinks(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

points_to_cell_add_field_dimension()

cell points_to_cell_add_field_dimension	(	cell	c,
		entity	f
	)

Functions about points-to cells - There is no cell.c file.

add a field to a cell if it is meaningful

FI: should we also add the necessary zero subscripts when the field is an array?

Definition at line 1444 of file effects.c.

{
  if(cell_reference_p(c)) {
    reference r = cell_reference(c);
    cell_reference(c) = reference_add_field_dimension(r, f);
  }
  else if(cell_preference_p(c)) {
    preference pr = cell_preference(c);
    reference r = preference_reference(pr);
    preference_reference(pr) = reference_add_field_dimension(r, f);
  }
  else if(cell_gap_p(c))
    pips_internal_error("Not applicable on gaps.\n");
  else
    pips_internal_error("Unknown kind of cell.\n");
  return c;
}

References cell_gap_p, cell_preference, cell_preference_p, cell_reference, cell_reference_p, f(), pips_internal_error, preference_reference, and reference_add_field_dimension().

Referenced by any_source_to_sinks(), anywhere_source_to_sinks(), binary_intrinsic_call_to_points_to_sinks(), generic_points_to_cell_to_useful_pointer_cells(), new_recursive_filter_formal_context_according_to_actual_context(), points_to_translation_of_struct_formal_parameter(), and recursive_cell_to_pointer_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_add_fixed_subscripts()

void points_to_cell_add_fixed_subscripts	(	cell	c,
		bool	zero_p
	)

Convert a reference to an array into a reference to its first element.

Note: is this unconditional? Do you add the right number of subscripts according to the type?

Parameters

zero_p

ero_p

Definition at line 1594 of file effects.c.

{
  bool to_be_freed = false;
  type t = type_undefined;
  reference r = cell_any_reference(c);
  if(points_to_array_reference_p(r)) {
    //type at = points_to_array_reference_to_type(r);
    //t = array_type_to_element_type(at);
    t = points_to_array_reference_to_type(r);
    // partial memory leak with "at"?
  }
  else
    t = points_to_cell_to_type(c, &to_be_freed);
 
  if(zero_p)
    reference_add_zero_subscripts(r, t);
  else
    reference_add_unbounded_subscripts(r, t);
  if(to_be_freed) free_type(t);
}

References cell_any_reference(), free_type(), points_to_array_reference_p(), points_to_array_reference_to_type(), points_to_cell_to_type(), reference_add_unbounded_subscripts(), reference_add_zero_subscripts(), and type_undefined.

Referenced by points_to_cell_add_unbounded_subscripts(), and points_to_cell_add_zero_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_add_unbounded_subscripts()

void points_to_cell_add_unbounded_subscripts

(

cell

c

)

Definition at line 1632 of file effects.c.

{
  points_to_cell_add_fixed_subscripts(c, false);
}

References points_to_cell_add_fixed_subscripts().

Referenced by any_source_to_sinks(), assignment_to_points_to(), generic_points_to_cell_to_useful_pointer_cells(), generic_stub_source_to_sinks(), internal_pointer_assignment_to_points_to(), new_recursive_filter_formal_context_according_to_actual_context(), points_to_translation_of_struct_formal_parameter(), recursive_cell_to_pointer_cells(), and variable_to_pointer_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_add_zero_subscript()

void points_to_cell_add_zero_subscript

(

cell

c

)

Definition at line 1620 of file effects.c.

{
  reference r = cell_any_reference(c);
  reference_add_zero_subscript(r);
}

References cell_any_reference(), and reference_add_zero_subscript().

Referenced by filter_formal_context_according_to_actual_context(), new_filter_formal_context_according_to_actual_context(), points_to_translation_of_formal_parameters(), and recursive_filter_formal_context_according_to_actual_context().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_add_zero_subscripts()

void points_to_cell_add_zero_subscripts

(

cell

c

)

Definition at line 1615 of file effects.c.

{
  points_to_cell_add_fixed_subscripts(c, true);
}

References points_to_cell_add_fixed_subscripts().

Referenced by binary_intrinsic_call_to_points_to_sinks(), generic_stub_source_to_sinks(), internal_pointer_assignment_to_points_to(), points_to_cell_types_compatibility(), and reference_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_complete_with_zero_subscripts()

void points_to_cell_complete_with_zero_subscripts

(

cell

c

)

Definition at line 1626 of file effects.c.

{
  reference r = cell_any_reference(c);
  reference_complete_with_zero_subscripts(r);
}

References cell_any_reference(), and reference_complete_with_zero_subscripts().

Referenced by filter_formal_context_according_to_actual_context(), and new_filter_formal_context_according_to_actual_context().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_cell_update_last_subscript()

void points_to_cell_update_last_subscript	(	cell	c,
		expression	s
	)

Transform reference a[i]...[j] and expression s into reference a[i]..[j+s] if j and s are constant integer expressions, and into reference a[i]..[*] otherwise.

Cell c is updated by side effect.

This has been implemented in several places...

Definition at line 1643 of file effects.c.

{
  reference r = cell_any_reference(c);
  list sl = reference_indices(r);
  if(ENDP(sl)) {
    // FI: we could do something special for heap abstract locations...
    // entity v = reference_variable(r);
    pips_internal_error("Wrong argument c.\n");
  }
  else {
    list lsl = gen_last(sl);
    expression is = EXPRESSION(CAR(lsl));
    intptr_t c1, c2;
    expression ns = expression_undefined;
    if(expression_integer_value(is, &c1) && expression_integer_value(s, &c2)) {
      ns = int_to_expression((int) c1+c2);
    }
    else {
      ns = make_unbounded_expression();
    }
    EXPRESSION_(CAR(lsl)) = ns;
  }
}

References CAR, cell_any_reference(), ENDP, EXPRESSION, EXPRESSION_, expression_integer_value(), expression_undefined, gen_last(), int_to_expression(), intptr_t, make_unbounded_expression(), pips_internal_error, and reference_indices.

Referenced by subscripted_reference_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_reference_included_p()

bool points_to_reference_included_p	(	reference	r1,
		reference	r2
	)

FI->FC/AM: some elements of the lattice must be exploited here...

Parameters

r1	1
r2	2

Definition at line 1243 of file effects.c.

{
  bool included_p = true;
  entity v1 = reference_variable(r1);
  entity v2 = reference_variable(r2);
 
  list dims1 = reference_indices(r1);
  list dims2 = reference_indices(r2);
 
  if(v1 == v2) {
    if(gen_length(dims1)==gen_length(dims2)) {
      list cdims2 = dims2;
      FOREACH(EXPRESSION, s1, dims1) {
        expression s2 = EXPRESSION(CAR(cdims2));
        if(!expression_equal_p(s1,s2)) {
          if(!unbounded_expression_p(s2)) {
            included_p = false;
            break;
          }
        }
        cdims2 = CDR(cdims2);
      }
    }
    else if(gen_length(dims1)>gen_length(dims2)) {
      list cdims1 = dims1;
      FOREACH(EXPRESSION, s2, dims2) {
        expression s1 = EXPRESSION(CAR(cdims1));
        if(!expression_equal_p(s1,s2)) {
          if(!unbounded_expression_p(s2)) {
            included_p = false;
            break;
          }
        }
        cdims1 = CDR(cdims1);
      }
    }
    else {
      included_p = false;
    }
  }
  else {
    // pips_internal_error("Abstract location lattice not implemented here.\n");
    // FI->AM/FC: you should check the inclusion of abstract_location(v1) and
    // abstract_location(v2)...
    included_p = false;
  }
  return included_p;
}

References CAR, CDR, EXPRESSION, expression_equal_p(), FOREACH, gen_length(), reference_indices, reference_variable, s1, and unbounded_expression_p().

Referenced by cell_included_p().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_cell_to_pointer_cells()

list recursive_cell_to_pointer_cells

(

cell

c

)

Go down if it is an array of pointers or an array of struct

add indices to cell c

Add subscripts to reach array elements

Look for fields that are either pointers, or arrays or structs

Add field subscript to reference

Definition at line 1680 of file effects.c.

{
  list children = NIL;
  // Too strong for recursive calls
  //pips_assert("Cell \"c\" has no subscripts.",
  //          ENDP(reference_indices(cell_any_reference(c))));
  bool to_be_freed;
  type ct = points_to_cell_to_type(c, &to_be_freed);
 
  if(pointer_type_p(ct)) {
    children = CONS(CELL, copy_cell(c), NIL);
  }
  else if(array_type_p(ct)) {
    /* Go down if it is an array of pointers or an array of struct */
    if(array_of_pointers_type_p(ct) || array_of_struct_type_p(ct)) {
      /* add indices to cell c */
      cell n_c = copy_cell(c);
      /* Add subscripts to reach array elements */
      points_to_cell_add_unbounded_subscripts(n_c);
      children = recursive_cell_to_pointer_cells(n_c);
      free_cell(n_c);
    }
    else {
      ; // No children
    }
  }
  else if(struct_type_p(ct)) {
    /* Look for fields that are either pointers, or arrays or structs */
    basic b = variable_basic(type_variable(ct));
    entity dte = basic_derived(b);
    type dt = entity_type(dte);
    list fields = type_struct(dt);
    FOREACH(ENTITY, f, fields) {
      type ft = entity_basic_concrete_type(f);
      if(pointer_type_p(ft)
         || array_type_p(ft)
         || struct_type_p(ft)) {
        cell n_c = copy_cell(c);
        /* Add field subscript to reference */
        points_to_cell_add_field_dimension(n_c, f);
        children = recursive_cell_to_pointer_cells(n_c);
        free_cell(n_c);
      }
    }
  }
 
  // Too strong for recursive calls
  //pips_assert("Cell \"c\" has children, "
  //          "or this function would not have been called.", !ENDP(children));
  return children;
}

References array_of_pointers_type_p(), array_of_struct_type_p(), array_type_p(), basic_derived, CELL, CONS, copy_cell(), ENTITY, entity_basic_concrete_type(), entity_type, f(), FOREACH, free_cell(), NIL, pointer_type_p(), points_to_cell_add_field_dimension(), points_to_cell_add_unbounded_subscripts(), points_to_cell_to_type(), recursive_cell_to_pointer_cells(), struct_type_p(), type_struct, type_variable, and variable_basic.

Referenced by cell_to_pointer_cells(), points_to_binding_arguments(), and recursive_cell_to_pointer_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_add_field_dimension()

reference reference_add_field_dimension	(	reference	r,
		entity	f
	)

add a field f as a subscript to a reference r if it is meaningful.

Leave r unchanged if not.

This function cannot be located in ri-util because it does need to know about abstract locations.

This does not build a standard reference, but a reference used within effects computation. Field accesses are replaced by subscripts.

Note that the reference generated may contain extra 0 subscripts to make it scalar...

No fields can be added to some special abstract locations.

FI: a problem due to typedefs apparently

Take care of special cases

Nothing done when the heap is modeled by a unique entity

This kind of entity cannot support a concrete access path but the type must be updated according to the field "f"

FI: This piece of code should be useless because the all_heap_locations entity is used only when ALIASING_ACROSS_TYPES is true.

Definition at line 1475 of file effects.c.

{
  entity v = reference_variable(r);
 
  /* No fields can be added to some special abstract locations. */
  if(!(entity_anywhere_locations_p(v)
       || entity_typed_anywhere_locations_p(v)
       || entity_nowhere_locations_p(v)
       || entity_typed_nowhere_locations_p(v)
       || entity_null_locations_p(v)
       || entity_all_heap_locations_p(v) // Not typed, hopefully...
       )) {
    bool to_be_freed = false;
    type t = points_to_reference_to_type(r, &to_be_freed);
    //type t = ultimate_type(entity_type(v));
    type ut = compute_basic_concrete_type(t);
 
    if(struct_type_p(ut)) {
      entity ste = basic_derived(variable_basic(type_variable(t)));
      type st = ultimate_type(entity_type(ste)); // FI: should be concrete_basic_type
      list fl = list_undefined;
      /* FI: a problem due to typedefs apparently */
      if(type_struct_p(st))
        fl = type_struct(st);
      else if(struct_type_p(st)) {
        entity nste = basic_derived(variable_basic(type_variable(st)));
        type nst = ultimate_type(entity_type(nste));
        fl = type_struct(nst);
      }
      else
        pips_internal_error("Misunderstanding of struct typing.\n");
      entity nf = find_field_in_field_list(f, fl);
      if(!entity_undefined_p(nf)) {
        expression s = entity_to_expression(nf);
        reference_indices(r) = gen_nconc(reference_indices(r),
                                         CONS(EXPRESSION, s, NIL));
        // FI: in case the field is an array
        reference_add_zero_subscripts(r, entity_basic_concrete_type(f));
      }
      else {
        entity v = reference_variable(r);
        pips_internal_error("No field \"%s\" (\"%s\") for struct \"%s\"(\"%s\")\n",
                            entity_user_name(f), entity_name(f), entity_user_name(v), entity_name(v));
      }
    }
    else {
      /* Take care of special cases */
      if(entity_all_module_heap_locations_p(v)
         || entity_all_heap_locations_p(v)) {
        /* Nothing done when the heap is modeled by a unique entity */
        ; // FI: could be useful for unions as well
      }
      else if(array_of_struct_type_p(ut)) {
        extern bool get_int_property(const char *);
        bool strict_p = get_bool_property("POINTS_TO_STRICT_POINTER_TYPES");
        if(!strict_p) {
          // An implicit 0 subscript should be added
          expression z = int_to_expression(0);
          // FI: This should be guarded as for the other structures
          // Some code should be factorized out
          expression s = entity_to_expression(f);
          pips_assert("No indices yet.\n", ENDP(reference_indices(r)));
          reference_indices(r) = CONS(EXPRESSION, z, CONS(EXPRESSION, s, NIL));
        }
      }
      else if(overloaded_type_p(ut) && entity_typed_anywhere_locations_p(v)) {
        expression s = entity_to_expression(f);
        pips_assert("No indices yet.\n", ENDP(reference_indices(r)));
        reference_indices(r) = CONS(EXPRESSION, s, NIL);
      }
      else
        pips_internal_error("Attempt at adding a field to an object that is not"
                            " a struct.\n");
    }
    if(to_be_freed) free_type(t);
  }
  else if(entity_typed_anywhere_locations_p(v)
       || entity_all_heap_locations_p(v) // Not typed, hopefully...?
       ) {
    /* This kind of entity cannot support a concrete access path but
     * the type must be updated according to the field "f"
     */
    type nt = entity_type(f); // concrete/ultimate_type()?
    if(entity_typed_anywhere_locations_p(v)) {
      entity ne = entity_typed_anywhere_locations(nt);
      reference_variable(r) = ne;
      reference_add_zero_subscripts(r, nt);
    }
    else if(entity_all_heap_locations_p(v)
            && !get_bool_property("ALIASING_ACROSS_TYPES")) {
      /* FI: This piece of code should be useless because the
         all_heap_locations entity is used only when
         ALIASING_ACROSS_TYPES is true. */
      entity ne = entity_all_heap_locations_typed(nt);
      reference_variable(r) = ne;
      reference_add_zero_subscripts(r, nt);
    }
  }
 
  return r;
}

References array_of_struct_type_p(), basic_derived, compute_basic_concrete_type(), CONS, ENDP, entity_all_heap_locations_p(), entity_all_heap_locations_typed(), entity_all_module_heap_locations_p(), entity_anywhere_locations_p(), entity_basic_concrete_type(), entity_name, entity_nowhere_locations_p(), entity_null_locations_p(), entity_to_expression(), entity_type, entity_typed_anywhere_locations(), entity_typed_anywhere_locations_p(), entity_typed_nowhere_locations_p(), entity_undefined_p, entity_user_name(), EXPRESSION, f(), find_field_in_field_list(), free_type(), gen_nconc(), get_bool_property(), get_int_property(), int_to_expression(), list_undefined, NIL, overloaded_type_p(), pips_assert, pips_internal_error, points_to_reference_to_type(), reference_add_zero_subscripts(), reference_indices, reference_variable, struct_type_p(), type_struct, type_struct_p, type_variable, ultimate_type(), and variable_basic.

Referenced by points_to_cell_add_field_dimension(), and struct_assignment_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_reference_add_field_dimension()

reference simple_reference_add_field_dimension	(	reference	r,
		entity	f
	)

Do not check anything, just add f as a last subscript.

See above

Definition at line 1581 of file effects.c.

{
  expression s = entity_to_expression(f);
  reference_indices(r) = gen_nconc(reference_indices(r),
                                   CONS(EXPRESSION, s, NIL));
  return r;
}

References CONS, entity_to_expression(), EXPRESSION, f(), gen_nconc(), NIL, and reference_indices.

Referenced by add_inter_or_intraprocedural_field_entities(), and struct_assignment_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_has_a_module_formal_argument_write_effect_p()

bool statement_has_a_module_formal_argument_write_effect_p	(	statement	s,
		entity	module,
		statement_mapping	effects_list_map
	)

Return true if the statement has a write effect on at least one of the argument (formal parameter) of the module.

Note that the return variable of a function is also considered here as a formal parameter.

Parameters

module	odule
effects_list_map	ffects_list_map

Definition at line 247 of file effects.c.

{
   bool write_effect_on_a_module_argument_found = false;
   list effects_list = (list) GET_STATEMENT_MAPPING(effects_list_map, s);
 
   FOREACH(EFFECT, an_effect, effects_list)
       {
          entity a_variable = reference_variable(effect_any_reference(an_effect));
 
          if (action_write_p(effect_action(an_effect))
              && (variable_return_p(a_variable)
                  || variable_is_a_module_formal_parameter_p(a_variable,
                                                             module))) {
              write_effect_on_a_module_argument_found = true;
             break;
          }
       }
 
   return write_effect_on_a_module_argument_found;
 
}

References a_variable, action_write_p, EFFECT, effect_action, effect_any_reference, FOREACH, GET_STATEMENT_MAPPING, module, reference_variable, variable_is_a_module_formal_parameter_p(), and variable_return_p().

Here is the call graph for this function:

std_file_cell_p()

bool std_file_cell_p

(

cell

c

)

Definition at line 524 of file effects.c.

{
  return(std_file_entity_p(cell_entity(c)));
}

References cell_entity(), and std_file_entity_p().

Here is the call graph for this function:

std_file_effect_p()

bool std_file_effect_p

(

effect

e

)

Definition at line 519 of file effects.c.

{
  return(std_file_entity_p(effect_entity(e)));
}

References effect_entity(), and std_file_entity_p().

Referenced by create_step_regions(), do_check_isolate_statement_preconditions_on_call(), effects_to_dma(), and std_file_effects_p().

Here is the call graph for this function:

Here is the caller graph for this function:

std_file_effects_p()

bool std_file_effects_p

(

list

effects

)

Definition at line 529 of file effects.c.

{
    FOREACH(EFFECT,eff,effects)
        if(std_file_effect_p(eff)) return true;
    return false;
}

References EFFECT, FOREACH, and std_file_effect_p().

Here is the call graph for this function:

store_effect_p()

bool store_effect_p

(

effect

e

)

Definition at line 1062 of file effects.c.

{
  action a = effect_action(e);
  action_kind ak = action_read_p(a)? action_read(a) : action_write(a);
  bool store_p = action_kind_store_p(ak);
 
  return store_p;
}

References action_kind_store_p, action_read, action_read_p, action_write, and effect_action.

Referenced by add_conflicts(), add_values_for_simple_effects_of_statement(), array_must_fully_written_by_regions_p(), c_convex_effects_on_formal_parameter_backward_translation(), create_values_for_simple_effect(), cumul_and_update_effects_of_statement(), DistArraysEffects(), effect_may_read_or_write_memory_paths_from_entity_p(), effects_read_variable_p(), effects_write_p(), effects_write_variable_p(), find_effect_actions_for_entity(), generic_apply_effects_to_transformer(), generic_effects_maymust_read_or_write_scalar_entity_p(), get_written_entities(), invariant_expression_p(), kill_effects(), loop_flt(), loop_regions_normalize(), module_to_value_mappings(), no_other_effects_on_references(), prettyprint_dependence_graph(), project_regions_along_loop_index(), project_regions_along_parameters(), pure_function_p(), region_exact_projection_along_variable(), region_intersection(), region_sup_difference(), region_union(), regions_dynamic_elim(), regions_may_convex_hull(), regions_must_convex_hull(), regions_transformer_apply(), safe_effects_for_reductions(), simple_switch_old_to_new(), update_compatible_reduction(), update_reduction_under_effect(), vars_read_and_written(), written_effect_p(), written_effects_to_dist_arrays_p(), xml_Chain_Graph(), xml_Compute_and_Need(), xml_Region_Parameter(), xml_TaskParameter(), and xml_TaskParameters().

Here is the caller graph for this function:

store_independent_effect_p()

bool store_independent_effect_p

(

effect

eff

)

Does this effect define the same set of memory locations regardless of the current (environment and) memory state?

This function works only for standard references, not for points-to references, but is partially extended to cope with one anywhere...

FI: I do not understand why pointers could be indexed in standard references.

Parameters

eff

ff

Definition at line 636 of file effects.c.

{
  bool independent_p = false;
 
  ifdebug(1) {
    reference r = effect_any_reference(eff);
    pips_assert("Effect eff is consistent", effect_consistent_p(eff));
    pips_assert("The reference is consistent", reference_consistent_p(r));
  }
 
  if(anywhere_effect_p(eff))
    independent_p = true;
  else {
    reference r = effect_any_reference(eff);
    entity v = reference_variable(r);
    type t = entity_basic_concrete_type(v);
 
    if(pointer_type_p(t)) {
      list inds = reference_indices(r);
 
      independent_p = ENDP(inds);
    }
    else {
      pips_assert("The reference is consistent", reference_consistent_p(r));
 
      independent_p = reference_with_constant_indices_p(r);
    }
  }
 
  return independent_p;
}

References anywhere_effect_p(), effect_any_reference, effect_consistent_p(), ENDP, entity_basic_concrete_type(), ifdebug, pips_assert, pointer_type_p(), reference_consistent_p(), reference_indices, reference_variable, and reference_with_constant_indices_p().

Referenced by add_values_for_simple_effects_of_statement(), effect_interference(), and effects_interfere_p().

Here is the call graph for this function:

Here is the caller graph for this function:

type_declaration_effect_p()

bool type_declaration_effect_p

(

effect

e

)

Definition at line 1080 of file effects.c.

{
  action a = effect_action(e);
  action_kind ak = action_read_p(a)? action_read(a) : action_write(a);
  bool decl_p = action_kind_type_declaration_p(ak);
 
  return decl_p;
}

References action_kind_type_declaration_p, action_read, action_read_p, action_write, and effect_action.

typed_anywhere_effect_p()

bool typed_anywhere_effect_p

(

effect

e

)

Is it a typed anywhere effect? ANYMMODULE:ANYWHERE_b0, 1, 2.

Definition at line 352 of file effects.c.

{
  return generic_anywhere_effect_p(e, 1);
}

References generic_anywhere_effect_p().

Here is the call graph for this function:

union_compatible_effects_p()

bool union_compatible_effects_p	(	effect	ef1,
		effect	ef2
	)

DO NOT USE ANYMORE: NOT COMPATIBLE WITH ABSTRACT LOCATIONS.

besides, I do not see the interest after having called effects_compatible_p. BC Check compatibility conditions for effect union

In general, you do not want to union a read and a write, but you might want to do so to generate the set of referenced elements, for instance to generate communications or to allocate memory

You do not want to union an effect on store with an effect on environment or type declaration

Here we know: at1==at2 and akt1==akt2

The code below could be further unified, but it would not make it easier to understand

Beware: that's not true anymore because of abstract locations

For environment and type declaration, the descriptor is useless for the time being

Parameters

ef1	f1
ef2	f2

Definition at line 1354 of file effects.c.

{
  action a1 = effect_action(ef1);
  tag at1 = action_tag(a1);
  action_kind ak1 = action_to_action_kind(a1);
  tag akt1 = action_kind_tag(ak1);
  entity e1 = effect_variable(ef1);
  descriptor d1 = effect_descriptor(ef1);
  action a2 = effect_action(ef2);
  tag at2 = action_tag(a2);
  action_kind ak2 = action_to_action_kind(a2);
  tag akt2 = action_kind_tag(ak2);
  entity e2 = effect_variable(ef2);
  descriptor d2 = effect_descriptor(ef2);
  bool compatible_p = true;
 
  pips_assert("effect e1 is consistent", effect_consistent_p(ef1));
  pips_assert("effect e2 is consistent", effect_consistent_p(ef2));
 
  if(at1!=at2) {
    /* In general, you do not want to union a read and a write, but
       you might want to do so to generate the set of referenced
       elements, for instance to generate communications or to
       allocate memory */
    compatible_p = false;
  }
  else if(akt1!=akt2) {
    /* You do not want to union an effect on store with an effect on
       environment or type declaration */
    compatible_p = false;
  }
  else {
    /* Here we know: at1==at2 and akt1==akt2 */
    /* The code below could be further unified, but it would not make
       it easier to understand */
    if(akt1==is_action_kind_store) {
      if(e1!=e2) /* Beware: that's not true anymore because of abstract locations */
        compatible_p = false;
      else {
        tag dt1 = descriptor_tag(d1);
        tag dt2 = descriptor_tag(d2);
 
        if(dt1!=dt2)
          compatible_p = false;
      }
    }
    else {
      /* For environment and type declaration, the descriptor is
         useless for the time being */
      compatible_p = e1==e2;
    }
  }
 
  return compatible_p;
}

References action_kind_tag, action_tag, action_to_action_kind(), descriptor_tag, effect_action, effect_consistent_p(), effect_descriptor, effect_variable, is_action_kind_store, and pips_assert.

Here is the call graph for this function:

vect_contains_phi_p()

bool vect_contains_phi_p

(

Pvecteur

v

)

bool vect_contains_phi_p(Pvecteur v) input : a vector output : true if v contains a PHI variable, false otherwise modifies : nothing

Definition at line 1427 of file effects.c.

{
    for(; !VECTEUR_NUL_P(v); v = v->succ)
        if (variable_phi_p((entity) var_of(v)))
            return(true);
 
    return(false);
}

References Svecteur::succ, var_of, variable_phi_p, and VECTEUR_NUL_P.

Referenced by constraints_nb_phi_eq(), eq_var_nophi_min_coeff(), eq_var_phi(), some_phi_variable(), text_pointer_value(), text_points_to_relation(), and text_region_no_action().

Here is the caller graph for this function: