#include "linear.h"
#include "newgen.h"
#include "ri.h"
#include "effects.h"
#include "points_to_private.h"

Include dependency graph for effects-util.h:

Data Structures
struct	sensitivity_information

Macros
#define	ANY_MODULE_NAME "ANY_MODULE"
	Warning! Do not modify this file that is automatically generated! More...

#define	ANYWHERE_LOCATION "ANYWHERE"

#define	NOWHERE_LOCATION "NOWHERE"

#define	NULL_POINTER_NAME "NULL"

#define	UNDEFINED_LOCATION "UNDEFINED"

#define	UNDEFINED_POINTER_VALUE_NAME "UNDEFINED"

#define	NULL_POINTER_VALUE_NAME "NULL"

#define	PHI_PREFIX "PHI"

#define	PSI_PREFIX "PSI"

#define	RHO_PREFIX "RHO"

#define	BETA_PREFIX "BETA"

#define	PROPER true

#define	SUMMARY false

#define	effect_any_entity(e) effect_to_entity(e)
	some useful SHORTHANDS for EFFECT: More...

#define	effect_action_tag(eff) action_tag(effect_action(eff))

#define	effect_approximation_tag(eff) approximation_tag(effect_approximation(eff))

#define	effect_read_p(eff) (action_tag(effect_action(eff))==is_action_read)
	#define effect_scalar_p(eff) entity_scalar_p(effect_entity(eff)) More...

#define	effect_write_p(eff) (action_tag(effect_action(eff))==is_action_write)

#define	effect_may_p(eff) (approximation_tag(effect_approximation(eff)) == is_approximation_may)

#define	effect_must_p(eff) (approximation_tag(effect_approximation(eff)) == is_approximation_must)

#define	effect_exact_p(eff) (approximation_tag(effect_approximation(eff)) ==is_approximation_exact)

#define	effect_variable(e) reference_variable(effect_any_reference(e))
	For COMPATIBILITY purpose only - DO NOT USE anymore. More...

#define	variable_phi_p(e)
	true if e is a phi variable PHI entities have a name like: REGIONS:PHI#, where # is a number. More...

#define	variable_psi_p(e)

#define	variable_rho_p(e)

#define	variable_beta_p(e)

#define	effect_system(e)

#define	effect_reference(e)
	FI: it would be useful to assert cell_preference_p(effect_cell(e)), but I do not know how to do it in such a way that it works both for left hand sides and right hand sides using commas. More...

#define	effect_any_reference(e) (cell_preference_p(effect_cell(e))? preference_reference(cell_preference(effect_cell(e))) : cell_reference(effect_cell(e)))
	FI: cannot be used as a left hand side. More...

#define	make_preference_simple_effect(reference, action, approximation)

#define	make_reference_simple_effect(reference, action, approximation)

#define	make_simple_effect(reference, action, approximation)

#define	make_convex_effect(reference, action, approximation, system)

#define	cell_relation_first_cell(cr) interpreted_cell_cell(cell_relation_first(cr))

#define	cell_relation_first_interpretation_tag(cr) cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

#define	cell_relation_first_value_of_p(cr) cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

#define	cell_relation_first_address_of_p(cr) cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

#define	cell_relation_second_cell(cr) interpreted_cell_cell(cell_relation_second(cr))

#define	cell_relation_second_interpretation_tag(cr) cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

#define	cell_relation_second_value_of_p(cr) cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

#define	cell_relation_second_address_of_p(cr) cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

#define	cell_relation_approximation_tag(cr) approximation_tag(cell_relation_approximation(cr))

#define	cell_relation_may_p(cr) approximation_tag(cell_relation_approximation(cr))==is_approximation_may

#define	cell_relation_exact_p(cr) approximation_tag(cell_relation_approximation(cr))==is_approximation_exact

#define	pips_debug_pv(level, message, pv)

#define	pips_debug_pvs(level, message, l_pv)

Functions
entity	effect_entity (effect)
	cproto-generated files More...

entity	cell_entity (cell)

list	cell_indices (cell)

reference	cell_any_reference (cell)
	API for reference. More...

bool	memory_dereferencing_p (reference)
	Does the set of locations referenced by r depend on a pointer dereferencing? More...

effects	list_to_effects (list)
	Future API for GAP, Generic Access Path. More...

list	effects_to_list (effects)

statement_mapping	listmap_to_effectsmap (statement_mapping)

statement_mapping	effectsmap_to_listmap (statement_mapping)

bool	statement_has_a_module_formal_argument_write_effect_p (statement, entity, statement_mapping)
	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)

bool	effect_abstract_location_p (effect)

bool	effects_abstract_location_p (list)
	Returns true if at least one effect of effect list el is related to an abstract location. More...

effect	anywhere_effect (action)
	Anywhere effect: an effect which can be related to any location of any areas. More...

bool	anywhere_effect_p (effect)
	Is it an anywhere effect? ANYMMODULE:ANYWHERE More...

bool	typed_anywhere_effect_p (effect)
	Is it a typed anywhere effect? ANYMMODULE:ANYWHERE_b0, 1, 2. More...

bool	any_anywhere_effect_p (effect)
	Is it a typed or untyped anywhere effect? More...

bool	anywhere_cell_p (cell)
	Is it an anywhere cell? More...

bool	anywhere_reference_p (reference)

effect	heap_effect (entity, action)

bool	heap_effect_p (effect)

bool	heap_cell_p (cell)
	Any heap cell, more or less abstract or typed. More...

bool	all_heap_locations_cell_p (cell)

bool	nowhere_cell_p (cell)
	Target of an undefined pointer. More...

bool	null_cell_p (cell)

bool	malloc_effect_p (effect)

bool	malloc_cell_p (cell)

bool	malloc_reference_p (reference)

bool	io_effect_entity_p (entity)

bool	io_effect_p (effect)

bool	io_cell_p (cell)

bool	io_effects_p (list effects)

bool	std_file_effect_p (effect)

bool	std_file_cell_p (cell)

bool	std_file_effects_p (list effects)

bool	FILE_star_effect_reference_p (reference)

bool	effect_scalar_p (effect)

bool	effect_comparable_p (effect, effect)
	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)
	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)
	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, effect)
	Two effects interfere if one of them modify the set of locations defined by the other one. More...

effect	effect_to_store_independent (effect)

effect	effect_to_pointer_store_independent_effect (effect, entity)
	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)
	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, effect)
	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)
	Functions dealing with actions. More...

string	full_action_to_string (action)

string	full_action_to_short_string (action)

string	action_kind_to_string (action_kind)

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, action)

action_kind	action_to_action_kind (action)
	Without the consistency test, this function would certainly be inlined. More...

action_kind	effect_action_kind (effect)

bool	store_effect_p (effect)

bool	environment_effect_p (effect)

bool	type_declaration_effect_p (effect)

bool	effects_write_variable_p (list, entity)

bool	effects_write_p (list)

bool	effects_read_variable_p (list, entity)

bool	effects_all_read_p (list)
	Check that all effects in el are read effects. More...

bool	effect_list_can_be_safely_full_freed_p (list)
	Check if some references might be freed with the effects. More...

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

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

bool	cell_equal_p (cell, cell)
	CELLS. More...

bool	cell_entity_equal_p (cell, cell)

bool	points_to_reference_included_p (reference, reference)
	FI->FC/AM: some elements of the lattice must be exploited here... More...

bool	cell_included_p (cell, cell)
	Check that all memory locations denoted by cell "c1" are included in cell "c2". More...

bool	cell_equivalent_p (cell, cell)
	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)
	FI: probably to be moved elsewhere in ri-util. More...

bool	effect_list_consistent_p (list)
	Debugging. More...

bool	union_compatible_effects_p (effect, effect)
	DO NOT USE ANYMORE: NOT COMPATIBLE WITH ABSTRACT LOCATIONS. More...

entity	effect_to_entity (effect)
	Returns the entity corresponding to the mutation. More...

bool	vect_contains_phi_p (Pvecteur)
	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, entity)
	Functions about points-to cells - There is no cell.c file. More...

reference	reference_add_field_dimension (reference, entity)
	add a field f as a subscript to a reference r if it is meaningful. More...

reference	simple_reference_add_field_dimension (reference, entity)
	Do not check anything, just add f as a last subscript. More...

void	points_to_cell_add_fixed_subscripts (cell, bool)
	Convert a reference to an array into a reference to its first element. More...

void	points_to_cell_add_zero_subscripts (cell)

void	points_to_cell_add_zero_subscript (cell)

void	points_to_cell_complete_with_zero_subscripts (cell)

void	points_to_cell_add_unbounded_subscripts (cell)

void	points_to_cell_update_last_subscript (cell, expression)
	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)

list	recursive_cell_to_pointer_cells (cell)

list	cell_to_pointer_cells (cell)
	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...

entity	entity_all_locations (void)
	anywhere_abstract_locations.c More...

entity	entity_anywhere_locations (void)

bool	entity_all_locations_p (entity)
	test if an entity is the top of the lattice More...

entity	entity_typed_anywhere_locations (type)

entity	generic_entity_typed_anywhere_locations (type)

bool	entity_anywhere_locations_p (entity)
	test if an entity is the bottom of the lattice More...

bool	cell_typed_anywhere_locations_p (cell)
	test if a cell is the bottom of the lattice More...

bool	reference_typed_anywhere_locations_p (reference)
	test if a reference is the bottom of the lattice More...

bool	entity_typed_anywhere_locations_p (entity)
	Test if an entity is the bottom of the lattice. More...

entity	entity_nowhere_locations (void)
	return ANY_MODULE:NOWHERE More...

entity	entity_typed_nowhere_locations (type)

bool	entity_nowhere_locations_p (entity)
	test if an entity is the bottom of the lattice More...

bool	entity_typed_nowhere_locations_p (entity)
	test if an entity is the bottom of the lattice More...

entity	entity_null_locations (void)
	return TOP-LEVEL:NULL_POINTER The NULL pointer should be a global variable, unique for all modules FI: why isn't it called entity_null_location()? More...

bool	entity_null_locations_p (entity)
	test if an entity is the NULL POINTER More...

entity	entity_all_module_locations (entity)
	return m:ANYWHERE Set of all memory locations related to one module. More...

bool	entity_all_module_locations_p (entity)
	test if an entity is the set of locations defined in a module More...

entity	entity_all_module_xxx_locations (entity, const char *)
	return m:xxxANYWHERE Generic set of functions for all kinds of areas More...

entity	entity_all_module_xxx_locations_typed (const char , const char , type)

bool	entity_all_module_xxx_locations_p (entity, string)
	test if an entity is the set of all memory locations in the xxx area of a module. More...

entity	entity_all_xxx_locations (string)
	return ANY_MODULE:xxx More...

entity	entity_all_xxx_locations_typed (string, type)
	FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing... More...

bool	entity_all_xxx_locations_p (entity, string)
	test if an entity is the set of all memory locations in the xxx area of any module. More...

entity	entity_all_module_heap_locations (entity)
	return m:HEAP*ANYWHERE More...

entity	entity_all_module_heap_locations_typed (entity, type)

bool	entity_all_module_heap_locations_p (entity)
	test if an entity is the a heap area More...

entity	entity_all_heap_locations (void)
	return ANY_MODULE:HEAP More...

bool	entity_all_heap_locations_p (entity)
	test if an entity is the set of all heap locations More...

entity	entity_all_heap_locations_typed (type)

entity	entity_all_module_stack_locations (entity)
	return m:STACK*ANYWHERE More...

bool	entity_all_module_stack_locations_p (entity)
	test if an entity is the a stack area More...

entity	entity_all_stack_locations (void)
	return ANY_MODULE:STACK More...

bool	entity_all_stack_locations_p (entity)
	test if an entity is the set of all stack locations More...

entity	entity_all_module_static_locations (entity)
	return m:DYNAMIC*ANYWHERE More...

bool	entity_all_module_static_locations_p (entity)
	test if an entity is the a static area More...

entity	entity_all_static_locations (void)
	return ANY_MODULE:STATIC More...

bool	entity_all_static_locations_p (entity)
	test if an entity is the set of all static locations More...

entity	entity_all_module_dynamic_locations (entity)
	return m:DYNAMIC*ANYWHERE More...

bool	entity_all_module_dynamic_locations_p (entity)
	test if an entity is the a dynamic area More...

entity	entity_all_dynamic_locations (void)
	return ANY_MODULE:DYNAMIC More...

bool	entity_all_dynamic_locations_p (entity)
	test if an entity is the set of all dynamic locations More...

bool	entity_stub_sink_p (entity)
	test if an entity is a stub sink for a formal parameter e.g. More...

bool	stub_entity_of_module_p (entity, entity)

bool	entity_abstract_location_p (entity)

entity	variable_to_abstract_location (entity)
	returns the smallest abstract locations containing the location of variable v. More...

entity	abstract_locations_max (entity, entity)
	eturns the smallest abstract location set greater than or equalt to al1 and al2. More...

entity	entity_locations_max (entity, entity)
	Here, entity al1 and entity al2 can be program variables. More...

entity	entity_locations_dereference (entity)

void	check_abstract_locations (void)
	For debugging the API. More...

bool	abstract_locations_may_conflict_p (entity, entity)
	Do these two abstract locations MAY share some real memory locations ? More...

bool	abstract_locations_must_conflict_p (entity, entity)

reference	make_anywhere_reference (type)
	This function should be located somewhere in effect-util in or near abstract locations. More...

cell	make_anywhere_cell (type)

bool	entity_heap_location_p (entity)
	abstract_location.c More...

entity	entity_flow_or_context_sentitive_heap_location (int, type)

bool	entity_flow_or_context_sentitive_heap_location_p (entity)

type	malloc_arg_to_type (expression)
	generate the type of the allocated area from the malloc argument More...

entity	malloc_type_to_abstract_location (type, sensitivity_information *)
	generate an abstract heap location entity More...

entity	malloc_to_abstract_location (expression, sensitivity_information *)
	generate an abstract heap location entity More...

entity	calloc_to_abstract_location (expression, expression, sensitivity_information *)
	generate an abstract heap location entity More...

reference	original_malloc_to_abstract_location (expression, type, type, expression, entity, statement)

sensitivity_information	make_sensitivity_information (statement, entity, list)

bool	pt_to_list_undefined_p (void)
	points_to.c More...

void	reset_pt_to_list (void)

void	error_reset_pt_to_list (void)

void	set_pt_to_list (statement_points_to)

statement_points_to	get_pt_to_list (void)

void	init_pt_to_list (void)

void	close_pt_to_list (void)

void	store_pt_to_list (statement, points_to_list)

void	update_pt_to_list (statement, points_to_list)

points_to_list	load_pt_to_list (statement)

points_to_list	delete_pt_to_list (statement)

bool	bound_pt_to_list_p (statement)

void	store_or_update_pt_to_list (statement, points_to_list)

cell	make_anywhere_points_to_cell (type)
	Function storing points to information attached to a statement. More...

bool	formal_parameter_points_to_cell_p (cell)

bool	stub_points_to_cell_p (cell)

bool	points_to_cell_in_list_p (cell, list)

list	merge_points_to_cell_lists (list, list)
	Add in "l1" elements of "l2" that are not yet in "l1". More...

bool	related_points_to_cell_in_list_p (cell, list)
	Two cells are related if they are based on the same entity. More...

bool	related_points_to_cells_p (cell, cell)

void	fprint_points_to_cell (FILE *, cell)

void	print_points_to_cell (cell)
	Debug: use stderr. More...

void	print_points_to_cells (list)
	Debug. More...

bool	field_reference_expression_p (expression)
	Check if expression "e" is a reference to a struct field. More...

int	points_to_reference_to_final_dimension (reference)
	Compute the number of array subscript at the end of a points_to_reference. More...

void	points_to_reference_update_final_subscripts (reference, list)
	Substitute the subscripts "sl" in points-to reference "r" just after the last field subscript by "nsl". More...

list	points_to_reference_to_typed_index (reference, type)
	Look for the index in "r" that corresponds to a pointer of type "t" and return the corresponding element list. More...

bool	atomic_points_to_cell_p (cell)
	Is it a unique concrete memory location? More...

bool	generic_atomic_points_to_cell_p (cell, bool)
	Is it a unique concrete memory location? More...

bool	generic_atomic_points_to_reference_p (reference, bool)
	Is it a unique concrete memory location? More...

bool	atomic_points_to_reference_p (reference)

bool	points_to_cells_intersect_p (cell, cell)
	points-to cells use abstract addresses, hence the proper comparison is an intersection. More...

cell	points_to_cells_minimal_upper_bound (list)

entity	points_to_cells_minimal_module_upper_bound (list)

type	points_to_cells_minimal_type_upper_bound (list)

reference	points_to_cells_minimal_reference_upper_bound (entity, type, list)

bool	points_to_array_reference_p (reference)
	Is this a reference to an array or a reference to a pointer? This is not linked to the type of the reference, as a reference may be a pointer, such as "a[10]" when "a" is declared int "a[10][20]". More...

type	points_to_array_reference_to_type (reference)
	If this is an array reference, what is the type of the underlying array type? More...

void	complete_points_to_reference_with_fixed_subscripts (reference, bool)
	Add a set of zero subscripts to a constant memory path reference "r" by side effect. More...

void	complete_points_to_reference_with_zero_subscripts (reference)

bool	cells_must_point_to_null_p (list)

bool	cells_may_not_point_to_null_p (list)

bool	cell_points_to_non_null_sink_in_set_p (cell, set)
	A set of functions called cell_points_to_xxxx(cell s, set pts) where set pts is a points-to relation set. More...

bool	cell_points_to_nowhere_sink_in_set_p (cell, set)

bool	cell_must_point_to_nowhere_sink_in_set_p (cell, set)
	How are array handled in pts? do we have arcs "a->a"? More...

bool	cell_points_to_null_sink_in_set_p (cell, set)

bool	points_to_cell_equal_p (cell, cell)

bool	similar_arc_in_points_to_set_p (points_to, set, approximation *)
	See if an arc like "spt" exists in set "in", regardless of its approximation. More...

list	points_to_cell_to_upper_bound_points_to_cells (cell)
	Return a list of cells that are larger than cell "c" in the points-to cell lattice. More...

list	points_to_cells_to_upper_bound_points_to_cells (list)
	Add to list "l" cells that are upper bound cells of the cells already in list "l" and return list "l". More...

bool	exact_points_to_subscript_list_p (list)
	See if the subscript list sl is precise, i.e. More...

bool	compatible_points_to_subscripts_p (expression, expression)
	Two subscript are compatible if they are equal or if one of them is unbounded. More...

points_to	points_to_with_stripped_sink (points_to, int(*)(void))
	The value of the source can often be expressed with different subscript lists. More...

bool	recursive_store_independent_points_to_reference_p (type, list)

bool	store_independent_points_to_reference_p (reference)
	Functions for points-to references, the kind of references used in points-to cells. More...

bool	constant_points_to_indices_p (list)
	check that the subscript list il is either empty or made of integers or fields. More...

bool	store_independent_points_to_indices_p (list)
	check that the subscript list il is either empty or made of integers or fields or unbounded entity "*". More...

list	cell_relations_generic_binary_op (list, list, bool()(cell_relation, cell_relation), list()(cell_relation, cell_relation), list()(cell_relation), list()(cell_relation), list(*)(list, list))
	cell_relations.c More...

entity	undefined_pointer_value_entity (void)
	pointer_values.c More...

cell	make_undefined_pointer_value_cell (void)

bool	undefined_pointer_value_entity_p (entity)

bool	undefined_pointer_value_cell_p (cell)

entity	null_pointer_value_entity (void)

cell	make_null_pointer_value_cell (void)

bool	null_pointer_value_entity_p (entity)

bool	null_pointer_value_cell_p (cell)

bool	abstract_pointer_value_entity_p (entity)

bool	abstract_pointer_value_cell_p (cell)

cell_relation	make_value_of_pointer_value (cell, cell, tag, descriptor)

cell_relation	make_address_of_pointer_value (cell, cell, tag, descriptor)

bool	pv_cells_syntactically_equal_p (cell_relation, cell_relation)

bool	pv_cells_mergeable_p (cell_relation, cell_relation)

int	cell_reference_compare (reference , reference )
	compare.c More...

int	cell_compare (cell , cell )

int	effect_compare (effect , effect )
	Compares two effects for sorting. More...

int	compare_effect_reference (effect , effect )
	int compare_effect_reference(e1, e2): More...

int	compare_effect_reference_in_common (effect , effect )
	int compare_effect_reference_in_common(e1, e2): More...

int	pointer_value_compare (cell_relation , cell_relation )
	Compares two pointer values for sorting. More...

int	is_inferior_cell_descriptor_pvarval (Pvecteur , Pvecteur )
	weight function for Pvecteur passed as argument to sc_lexicographic_sort in prettyprint functions involving cell descriptors. More...

list	effect_words_reference (reference)
	prettyprint.c More...

string	effect_reference_to_string (reference)

const char *	pips_region_user_name (entity)
	char * pips_region_user_name(entity ent) output : the name of entity. More...

list	words_fictious_reference (reference)
	To modelize the heap locations we manufacture fictious reference, that triggered a bug when it appears as an argument of entity_user_name(). More...

list	points_to_words_reference (reference)
	Specific handling of references appearing in points_to. More...

list	word_points_to (points_to)

int	points_to_compare_cells (const void , const void )
	Comparison of two points-to arcs based on their source and sink nodes. More...

list	points_to_list_sort (list)
	Allocate a copy of ptl and sort it. More...

list	words_points_to_list (string, points_to_list)

list	words_pointer_value (cell_relation)

string	approximation_to_string (approximation)

text	text_pointer_value (cell_relation)
	text text_region(effect reg) input : a region output : a text consisting of several lines of commentaries, representing the region modifies : nothing More...

text	text_pointer_values (list, string)

void	print_pointer_value (cell_relation)

void	print_pointer_values (list)

entity	effect_field_dimension_entity (expression, list)
	type.c More...

bool	effect_reference_contains_pointer_dimension_p (reference, bool *)

bool	effect_reference_dereferencing_p (reference, bool *)

type	cell_reference_to_type (reference, bool *)
	computes the type of a cell reference representing a memory access path. More...

type	cell_to_type (cell, bool *)

type	points_to_reference_to_type (reference, bool *)
	FI: I need more generality than is offered by cell_to_type() More...

type	points_to_expression_to_type (expression, bool *)
	FI: I need more generality than is offered by expression_to_type() because fields are assimilated to subscripts. More...

type	points_to_expression_to_concrete_type (expression)
	The type returned is stored in a hash-table. More...

type	points_to_expression_to_pointed_type (expression)
	Return a new allocated type "t" of the address pointed by expression "e", if expression "e" denotes an address. More...

type	points_to_cell_to_type (cell, bool *)
	FI: I need more generality than is offered by cell_to_type() More...

type	points_to_cell_to_concrete_type (cell)

type	points_to_reference_to_concrete_type (reference)

bool	basic_concrete_types_compatible_for_effects_interprocedural_translation_p (type, type)
	tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms. More...

bool	types_compatible_for_effects_interprocedural_translation_p (type, type)
	tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms. More...

void	points_to_cell_types_compatibility (cell, cell)
	Make sure that cell l can points towards cell r. More...

bool	points_to_source_cell_compatible_p (cell)

bool	points_to_sink_cell_compatible_p (cell)

list	find_points_to_subscript_for_type (cell, type)
	Find the subscript in the reference of cell "c" that would make the reference type be "t" if the subscript list were truncated just after it. More...

bool	adapt_reference_to_type (reference, type, int(*)(void))
	FI: a really stupid function... More...

bool	reference_unbounded_indices_p (reference)
	This function should be at expression.c. More...

bool	strict_constant_path_p (reference)

bool	can_be_constant_path_p (reference)
	TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want to test if r can be a constant path for instance a[i] have to return false (something else?) a[0], a[1], i, j, a[*], var points by formal parameter (_p_0, ...), element of strut (s.id, ...), heap element have to return true. More...

void	set_conflict_testing_properties (void)
	conflicts.c More...

bool	effects_must_conflict_p (effect, effect)
	Intersection tests. More...

bool	effects_might_conflict_even_read_only_p (effect, effect)
	Check if two effect might conflict, even if they are read only @description Two effects may conflict if their abstract two location sets has a non-empty intersection. More...

bool	effects_may_conflict_p (effect, effect)
	Check if two effect may conflict @description Two effects may conflict if their abstract two location sets has a non-empty intersection and if at least one of them is a write. More...

bool	effects_conflict_p (effect, effect)
	Synonym for effects_may_conflict_p(). More...

bool	array_references_may_conflict_p (list, list)
	Check if there may be a conflict between two array references. More...

bool	variable_references_may_conflict_p (entity, list, list)
	FIXME ? More...

bool	references_may_conflict_p (reference, reference)
	Check if two references may conflict. More...

bool	references_must_conflict_p (reference, reference)
	Check if two references may conflict. More...

bool	cells_may_conflict_p (cell, cell)
	Check if two cell may conflict. More...

bool	points_to_cell_lists_may_conflict_p (list, list)
	Same as above, but for lists. More...

bool	cells_must_conflict_p (cell, cell)
	Check if two cell must conflict. More...

bool	points_to_cell_lists_must_conflict_p (list, list)
	Same as above, but for lists. More...

bool	entities_maymust_conflict_p (entity, entity, bool)
	Check if two entities may or must conflict. More...

bool	entities_may_conflict_p (entity, entity)
	Check if two entities may conflict. More...

bool	entities_must_conflict_p (entity, entity)
	Check if two entities must conflict. More...

bool	first_effect_certainly_includes_second_effect_p (effect, effect)
	tests whether first effect certainly includes second one. More...

bool	first_exact_scalar_effect_certainly_includes_second_effect_p (effect, effect)

bool	effect_may_read_or_write_memory_paths_from_entity_p (effect, entity)
	misc functions More...

bool	effects_may_read_or_write_memory_paths_from_entity_p (list, entity)
	tests whether the input effects list may contain effects with a memory path from the input entity e; this is currently a mere syntactic test. More...

bool	generic_effects_maymust_read_or_write_scalar_entity_p (list, entity, bool, bool)

bool	effects_maymust_read_or_write_scalar_entity_p (list, entity, bool)

bool	concrete_effects_maymust_read_or_write_scalar_entity_p (list, entity, bool)

bool	effects_may_read_or_write_scalar_entity_p (list, entity)
	check whether scalar entity e may be read or written by effects fx or cannot be accessed at all More...

bool	concrete_effects_may_read_or_write_scalar_entity_p (list, entity)

bool	effects_must_read_or_write_scalar_entity_p (list, entity)
	check whether scalar entity e must be read or written by any effect of fx or if it simply might be accessed. More...

list	effects_entities_which_may_conflict_with_scalar_entity (list, entity)

list	concrete_effects_entities_which_may_conflict_with_scalar_entity (list, entity)

entity	make_location_entity (reference)
	locations.c More...

entity	constant_memory_access_path_to_location_entity (reference)
	A constant memory access path may not be considered. More...

bool	location_entity_p (entity)

bool	location_entity_of_module_p (entity, entity)

bool	array_location_entity_of_module_p (entity, entity)
	Expanded version of location_entity_of_module_p() More...

list	module_to_analyzed_array_locations (entity)
	m is supposed to be a module entity More...

Macro Definition Documentation

◆ ANY_MODULE_NAME

#define ANY_MODULE_NAME "*ANY_MODULE*"

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

Modify src/Libs/effects-util/effects-util-local.h instead, to add your own modifications. header file built by cproto effects_util-local.h

Definition at line 39 of file effects-util.h.

◆ ANYWHERE_LOCATION

#define ANYWHERE_LOCATION "*ANYWHERE*"

Definition at line 40 of file effects-util.h.

◆ BETA_PREFIX

#define BETA_PREFIX "BETA"

Definition at line 52 of file effects-util.h.

◆ cell_relation_approximation_tag

#define cell_relation_approximation_tag ( cr ) approximation_tag(cell_relation_approximation(cr))

Definition at line 188 of file effects-util.h.

◆ cell_relation_exact_p

#define cell_relation_exact_p ( cr ) approximation_tag(cell_relation_approximation(cr))==is_approximation_exact

Definition at line 194 of file effects-util.h.

◆ cell_relation_first_address_of_p

#define cell_relation_first_address_of_p ( cr ) cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

Definition at line 173 of file effects-util.h.

◆ cell_relation_first_cell

#define cell_relation_first_cell ( cr ) interpreted_cell_cell(cell_relation_first(cr))

Definition at line 164 of file effects-util.h.

◆ cell_relation_first_interpretation_tag

#define cell_relation_first_interpretation_tag ( cr ) cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

Definition at line 167 of file effects-util.h.

◆ cell_relation_first_value_of_p

#define cell_relation_first_value_of_p ( cr ) cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))

Definition at line 170 of file effects-util.h.

◆ cell_relation_may_p

#define cell_relation_may_p ( cr ) approximation_tag(cell_relation_approximation(cr))==is_approximation_may

Definition at line 191 of file effects-util.h.

◆ cell_relation_second_address_of_p

#define cell_relation_second_address_of_p ( cr ) cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

Definition at line 185 of file effects-util.h.

◆ cell_relation_second_cell

#define cell_relation_second_cell ( cr ) interpreted_cell_cell(cell_relation_second(cr))

Definition at line 176 of file effects-util.h.

◆ cell_relation_second_interpretation_tag

#define cell_relation_second_interpretation_tag ( cr ) cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

Definition at line 179 of file effects-util.h.

◆ cell_relation_second_value_of_p

#define cell_relation_second_value_of_p ( cr ) cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))

Definition at line 182 of file effects-util.h.

◆ effect_action_tag

#define effect_action_tag ( eff ) action_tag(effect_action(eff))

Definition at line 60 of file effects-util.h.

◆ effect_any_entity

#define effect_any_entity ( e ) effect_to_entity(e)

some useful SHORTHANDS for EFFECT:

FI: Let's hope this one is not used as lhs!

Definition at line 59 of file effects-util.h.

◆ effect_any_reference

#define effect_any_reference ( e ) (cell_preference_p(effect_cell(e))? preference_reference(cell_preference(effect_cell(e))) : cell_reference(effect_cell(e)))

FI: cannot be used as a left hand side.

Definition at line 139 of file effects-util.h.

◆ effect_approximation_tag

#define effect_approximation_tag ( eff ) approximation_tag(effect_approximation(eff))

Definition at line 61 of file effects-util.h.

◆ effect_exact_p

#define effect_exact_p ( eff ) (approximation_tag(effect_approximation(eff)) ==is_approximation_exact)

Definition at line 86 of file effects-util.h.

◆ effect_may_p

#define effect_may_p ( eff ) (approximation_tag(effect_approximation(eff)) == is_approximation_may)

Definition at line 82 of file effects-util.h.

◆ effect_must_p

#define effect_must_p ( eff ) (approximation_tag(effect_approximation(eff)) == is_approximation_must)

Definition at line 84 of file effects-util.h.

◆ effect_read_p

#define effect_read_p ( eff ) (action_tag(effect_action(eff))==is_action_read)

#define effect_scalar_p(eff) entity_scalar_p(effect_entity(eff))

The semantics of effects_scalar_p() must be refined. If all the indices are constant expressions, we still have a scalar effect, unless they are later replaced by "*", as is the case currently for summary effects.

Potential bug: eff is evaluated twice. Should be copied in a local variable and braces be used.

Definition at line 80 of file effects-util.h.

◆ effect_reference

#define effect_reference ( e )

Value:

  /**DO NOT REMOVE, PREVENT REDEFINITION :)
   * use effect_any_reference instead !
  */ \
    effect_reference_not_defined_anymore()

FI: it would be useful to assert cell_preference_p(effect_cell(e)), but I do not know how to do it in such a way that it works both for left hand sides and right hand sides using commas.

I definitely remove this one : it is too dangerous. #define effect_reference(e) \ preference_reference(cell_preference(effect_cell(e)))

Definition at line 134 of file effects-util.h.

◆ effect_system

#define effect_system ( e )

Value:

(descriptor_convex_p(effect_descriptor(e))? \

descriptor_convex(effect_descriptor(e)) : SC_UNDEFINED)

descriptor_convex_p

#define descriptor_convex_p(x)

Definition: effects.h:599

effect_descriptor

#define effect_descriptor(x)

Definition: effects.h:646

Definition at line 123 of file effects-util.h.

◆ effect_variable

#define effect_variable ( e ) reference_variable(effect_any_reference(e))

For COMPATIBILITY purpose only - DO NOT USE anymore.

Definition at line 94 of file effects-util.h.

◆ effect_write_p

#define effect_write_p ( eff ) (action_tag(effect_action(eff))==is_action_write)

Definition at line 81 of file effects-util.h.

◆ make_convex_effect

#define make_convex_effect	(	reference,
		action,
		approximation,
		system
	)

Value:

  make_effect(make_cell(is_reference, (reference)),                     \
                (action), (approximation),                              \
                make_descriptor(is_descriptor_convex,system))

Definition at line 156 of file effects-util.h.

◆ make_preference_simple_effect

#define make_preference_simple_effect	(	reference,
		action,
		approximation
	)

Value:

    make_effect(make_cell(is_cell_preference, make_preference(reference)),\
                (action), (approximation),      \
                make_descriptor(is_descriptor_none,UU))

Definition at line 141 of file effects-util.h.

◆ make_reference_simple_effect

#define make_reference_simple_effect	(	reference,
		action,
		approximation
	)

Value:

  make_effect(make_cell(is_cell_reference, (reference)),            \
                (action), (approximation),      \
                make_descriptor(is_descriptor_none,UU))

Definition at line 146 of file effects-util.h.

◆ make_simple_effect

#define make_simple_effect	(	reference,
		action,
		approximation
	)

Value:

    make_effect(make_cell(is_cell_preference, make_preference(reference)),\
                (action), (approximation),      \
                make_descriptor(is_descriptor_none,UU))

Definition at line 151 of file effects-util.h.

◆ NOWHERE_LOCATION

#define NOWHERE_LOCATION "*NOWHERE*"

Definition at line 41 of file effects-util.h.

◆ NULL_POINTER_NAME

#define NULL_POINTER_NAME "*NULL*"

Definition at line 43 of file effects-util.h.

◆ NULL_POINTER_VALUE_NAME

#define NULL_POINTER_VALUE_NAME "*NULL*"

Definition at line 47 of file effects-util.h.

◆ PHI_PREFIX

#define PHI_PREFIX "PHI"

Definition at line 49 of file effects-util.h.

◆ pips_debug_pv

#define pips_debug_pv	(	level,
		message,
		pv
	)

Value:

ifdebug(level) { pips_debug(level, "%s\n", message); \

print_pointer_value(pv);}

pips_debug

#define pips_debug

these macros use the GNU extensions that allow variadic macros, including with an empty list.

Definition: misc-local.h:145

level

#define level

ifdebug

#define ifdebug(n)

Definition: sg.c:47

_newgen_struct_message_

Definition: message.h:65

Definition at line 197 of file effects-util.h.

◆ pips_debug_pvs

#define pips_debug_pvs	(	level,
		message,
		l_pv
	)

Value:

ifdebug(level) { pips_debug(level, "%s\n", message); \

print_pointer_values(l_pv);}

Definition at line 201 of file effects-util.h.

◆ PROPER

#define PROPER true

Definition at line 53 of file effects-util.h.

◆ PSI_PREFIX

#define PSI_PREFIX "PSI"

Definition at line 50 of file effects-util.h.

◆ RHO_PREFIX

#define RHO_PREFIX "RHO"

Definition at line 51 of file effects-util.h.

◆ SUMMARY

#define SUMMARY false

Definition at line 54 of file effects-util.h.

◆ UNDEFINED_LOCATION

#define UNDEFINED_LOCATION "*UNDEFINED*"

Definition at line 44 of file effects-util.h.

◆ UNDEFINED_POINTER_VALUE_NAME

#define UNDEFINED_POINTER_VALUE_NAME "*UNDEFINED*"

Definition at line 46 of file effects-util.h.

◆ variable_beta_p

#define variable_beta_p ( e )

Value:

  ((e)!=(entity)NULL && (e)!=entity_undefined && \
    strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
    strstr(entity_name(e), BETA_PREFIX) != NULL)

Definition at line 118 of file effects-util.h.

◆ variable_phi_p

#define variable_phi_p ( e )

Value:

  ((e)!=(entity)NULL && (e)!=entity_undefined && \
    strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
    strstr(entity_name(e), PHI_PREFIX) != NULL)

true if e is a phi variable PHI entities have a name like: REGIONS:PHI#, where # is a number.

takes care if TCST and undefined entities, just in case. FC, 09/12/94

Definition at line 103 of file effects-util.h.

◆ variable_psi_p

#define variable_psi_p ( e )

Value:

  ((e)!=(entity)NULL && (e)!=entity_undefined && \
    strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
    strstr(entity_name(e), PSI_PREFIX) != NULL)

Definition at line 108 of file effects-util.h.

◆ variable_rho_p

#define variable_rho_p ( e )

Value:

  ((e)!=(entity)NULL && (e)!=entity_undefined && \
    strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
    strstr(entity_name(e), RHO_PREFIX) != NULL)

Definition at line 113 of file effects-util.h.

Function Documentation

◆ abstract_locations_max()

entity abstract_locations_max	(	entity	al1,
		entity	al2
	)

eturns the smallest abstract location set greater than or equalt to al1 and al2.

If al1 or al2 is nowhere, then return al2 or al1.

If al1 and al2 are related to the same module, the module can be preserved. Else the anywhere module must be used.

If al1 and al2 are related to the same area, then the area is preserved. Else, the anywhere area is used.

FI: The type part of the abstract location lattice is not implemented... Since the abstract locations are somewhere defined as area, they cannot carry a type. Types are taken care of for heap modelization but not more the abstract locations.

FI: we are in trouble with the NULL pointer... here al1 and al2 must be abstract locations

avoid costly string operations in trivial case

Parameters

al1	l1
al2	l2

Definition at line 766 of file anywhere_abstract_locations.c.

 {
   entity e = entity_undefined;
  
   if (same_entity_p(al1, al2)) /* avoid costly string operations in trivial case */
     e = al1;
   else if(!get_bool_property("ALIASING_ACROSS_TYPES")) {
     type t1 = entity_basic_concrete_type(al1);
     type t2 = entity_basic_concrete_type(al2);
     if(!type_equal_p(t1, t2))
       e = entity_anywhere_locations();
   }
  
   if(entity_undefined_p(e)) {
     // FI: the string based tests are not reliable as there is no link
     // between suffixes and types, even within one module
     const char* ln1 = entity_local_name(al1);
     const char* ln2 = entity_local_name(al2);
     char* mn1 = strdup(entity_module_name(al1));
     char* mn2 = strdup(entity_module_name(al2));
     const char* ln;
     const char* mn;
     static int mc = 0; // Message count: to avoid multiple repetitions
  
     if(mc==0 && !get_bool_property("ALIASING_ACROSS_TYPES")) {
       //pips_internal_error("Option not implemented yet.");
       pips_user_warning("property \"ALIASING_ACROSS_TYPES\" is assumed true"
                         " for abstract locations.\n");
       mc++;
     }
  
     if(strcmp(ln1, ln2)==0)
       ln = ln1;
     else
       ln = ANYWHERE_LOCATION;
  
     if(strcmp(mn1, mn2)==0)
       mn = mn1;
     else 
       mn = ANY_MODULE_NAME;
     e = FindEntity(mn, ln);
  
     if(true || entity_undefined_p(e)) {
       if(get_bool_property("ALIASING_ACROSS_TYPES")) {
         e = entity_anywhere_locations();
       }
       else {
         type t1 = entity_type(al1);
         type t2 = entity_type(al2);
         if(type_equal_p(t1, t2))  
           e = entity_typed_anywhere_locations(t1);
         else
           e = entity_anywhere_locations();
       }
     }
  
     free(mn1);free(mn2);
   }
   return e;
 }

References ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_anywhere_locations(), entity_basic_concrete_type(), entity_local_name(), entity_module_name(), entity_type, entity_typed_anywhere_locations(), entity_undefined, entity_undefined_p, FindEntity(), free(), get_bool_property(), pips_user_warning, same_entity_p(), strdup(), and type_equal_p().

Referenced by abstract_locations_may_conflict_p(), convex_cells_inclusion_p(), entity_locations_max(), and simple_cells_inclusion_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ abstract_locations_may_conflict_p()

bool abstract_locations_may_conflict_p	(	entity	al1,
		entity	al2
	)

Do these two abstract locations MAY share some real memory locations ?

Parameters

al1	l1
al2	l2

Definition at line 989 of file anywhere_abstract_locations.c.

  {
    entity mal = abstract_locations_max(al1, al2); // maximal abstraction location
    bool conflict_p = (mal==al1) || (mal==al2);
  
    return conflict_p;
  }

References abstract_locations_max().

Referenced by add_conflicts(), and entities_maymust_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ abstract_locations_must_conflict_p()

bool abstract_locations_must_conflict_p	(	entity	,
		entity
	)

◆ abstract_pointer_value_cell_p()

bool abstract_pointer_value_cell_p ( cell c )

Definition at line 121 of file pointer_values.c.

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

References abstract_pointer_value_entity_p(), and cell_entity().

Referenced by kill_pointer_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ abstract_pointer_value_entity_p()

bool abstract_pointer_value_entity_p ( entity e )

Definition at line 115 of file pointer_values.c.

 {
   return (undefined_pointer_value_entity_p(e)
           || null_pointer_value_entity_p(e));
 }

References null_pointer_value_entity_p(), and undefined_pointer_value_entity_p().

Referenced by abstract_pointer_value_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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.

◆ adapt_reference_to_type()

bool adapt_reference_to_type	(	reference	r,
		type	et,
		int(*)(void)	line_number_func
	)

FI: a really stupid function...

Why do we add zero subscript right away when building the sink cell to remove them later? Let's now remove the excessive subscripts of "r" with respect to type "at"...

Parameters

et t

Definition at line 1327 of file type.c.

 {
   bool succeed_p = true;
   bool to_be_freed;
   type at = compute_basic_concrete_type(et);
   type rt = points_to_reference_to_type(r, &to_be_freed);
   type t = compute_basic_concrete_type(rt);
   while(!array_pointer_type_equal_p(at, t) && !ENDP(reference_indices(r))) {
     if(to_be_freed) free_type(t);
     list sl = reference_indices(r);
     list last = gen_last(sl);
     expression e = EXPRESSION(CAR(last));
     if(expression_field_p(e))
       break;
     int l1 = (int) gen_length(sl);
     gen_remove_once(&sl, (void *) e);
     int l2 = (int) gen_length(sl);
     if(l1==l2)
       pips_internal_error("gen_remove() is ineffective.\n");
     reference_indices(r) = sl;
     type nrt = points_to_reference_to_type(r, &to_be_freed);
     t = compute_basic_concrete_type(nrt);
   }
   if(!array_pointer_string_type_equal_p(at, t)) {
     // FI: this function used to be in library alias_classes
     // It should be passed as a functional argument.
     //int points_to_context_statement_line_number(void);
     pips_user_warning("There may be a typing error at line %d (e.g. improper malloc call).\n Reference \"%s\" with type \"%s\" cannot be adapted to type \"%s\".\n",
                       // points_to_context_statement_line_number());
                       (*line_number_func)(),
                       reference_to_string(r),
                       type_to_full_string_definition(t),
                       type_to_full_string_definition(at));
     //pips_internal_error("Cell type mismatch.");
     succeed_p = false;
   }
   if(to_be_freed) free_type(t);
   return succeed_p;
 }

References array_pointer_string_type_equal_p(), array_pointer_type_equal_p(), CAR, compute_basic_concrete_type(), ENDP, EXPRESSION, expression_field_p(), free_type(), gen_last(), gen_length(), gen_remove_once(), int, pips_internal_error, pips_user_warning, points_to_reference_to_type(), reference_indices, reference_to_string(), and type_to_full_string_definition().

Referenced by dereferencing_subscript_to_points_to(), expression_to_points_to_cells(), filter_formal_context_according_to_actual_context(), new_filter_formal_context_according_to_actual_context(), points_to_with_stripped_sink(), process_casted_sinks(), process_casted_sources(), subscript_to_points_to_sinks(), and subscripted_reference_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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:

◆ approximation_to_string()

string approximation_to_string ( approximation a )

Definition at line 458 of file prettyprint.c.

 {
   string as = string_undefined;
   if(approximation_may_p(a))
     as = "may";
   else if(approximation_must_p(a))
     as = "must"; // could be "exact"
   else if(approximation_exact_p(a))
     as = "exact";
   else
     pips_internal_error("Unknown approximation tag.\n");
   return as;
 }

References approximation_exact_p, approximation_may_p, approximation_must_p, pips_internal_error, and string_undefined.

Referenced by print_or_dump_points_to().

Here is the caller graph for this function:

◆ array_location_entity_of_module_p()

bool array_location_entity_of_module_p	(	entity	le,
		entity	m
	)

Expanded version of location_entity_of_module_p()

Parameters

le e

Definition at line 374 of file locations.c.

 {
   bool location_p = false;
   if(!entity_undefined_p(le)) {
     value v = entity_initial(le);
     if(!value_undefined_p(v))
       if(value_reference_p(v))
         // FI: could be checked with a pointer equality via the storage field
         if(strcmp(entity_module_name(le), entity_user_name(m))==0) {
           reference r = value_reference(v);
           entity a = reference_variable(r);
           type t = entity_basic_concrete_type(a);
           location_p = array_type_p(t); 
         }
   }
   return location_p;
 }

References array_type_p(), entity_basic_concrete_type(), entity_initial, entity_module_name(), entity_undefined_p, entity_user_name(), reference_variable, value_reference, value_reference_p, and value_undefined_p.

Referenced by module_to_analyzed_array_locations().

Here is the call graph for this function:

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:

◆ atomic_points_to_cell_p()

bool atomic_points_to_cell_p ( cell c )

Is it a unique concrete memory location?

Plus NULL? No doubt about the value of the pointer...

Plus undefined? No doubt about the indeterminate value of the pointer according to C standard...

Definition at line 423 of file points_to.c.

 {
   reference r = cell_any_reference(c);
   bool atomic_p = null_cell_p(c)
     || nowhere_cell_p(c) // FI: added for EffectsWithPointsTo/call30.c
     || atomic_points_to_reference_p(r);
  
   // FI: atomic_p should be false for all abstract locations
   // This is dealt with by atomic_points_to_reference_p()
   /*
   if(atomic_p && (heap_cell_p(c) || all_heap_locations_cell_p(c)))
     atomic_p = false;
  
   if(atomic_p) {
     atomic_p = !cell_abstract_location_p(c);
   }
   */
  
   return atomic_p;
 }

References atomic_points_to_reference_p(), cell_any_reference(), nowhere_cell_p(), and null_cell_p().

Referenced by atomic_effect_p(), compute_points_to_gen_set(), compute_points_to_kill_set(), equal_condition_to_points_to(), freed_list_to_points_to(), non_equal_condition_to_points_to(), null_equal_condition_to_points_to(), and points_to_function_projection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ atomic_points_to_reference_p()

bool atomic_points_to_reference_p ( reference r )

Definition at line 519 of file points_to.c.

 {
   return generic_atomic_points_to_reference_p(r, true);
 }

References generic_atomic_points_to_reference_p().

Referenced by atomic_points_to_cell_p(), and substitute_stubs_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ basic_concrete_types_compatible_for_effects_interprocedural_translation_p()

bool basic_concrete_types_compatible_for_effects_interprocedural_translation_p	(	type	real_ct,
		type	formal_ct
	)

tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms.

Input types are

See also: basic_concrete_type .

safe default result

easiest case

we do not take care of array dimension sizes

well, basic_equal_strict_p is at the same time too restrictive for derived and too optimistic for pointers and arrays because dimensions are skipped

skip same number of array and pointer dimensions until we reach the ultimate basic or there are no more corresponding dimensions

we have a void * as actual argument

translation cannot be accurate

we are sure here that gen_length(formal_dims) != 0

we have a void * as actual argument

translation cannot be accurate

we are sure here that gen_length(real_dims) != 0

store types and not bct becasue bct cannot be equal, since a new type is generated each time. We really need a global table for bcts

It should be a strict type equality here, but I don't think type_equal_p is very robust when types are declared in headers

Parameters

real_ct	eal_ct
formal_ct	ormal_ct

Definition at line 699 of file type.c.

 {
   static list real_structured_types = NIL;
   static list formal_structured_types = NIL;
  
   pips_debug(8,"real_ct : %s \t formal_ct: %s\n",
              string_of_type(real_ct),
              string_of_type(formal_ct));
  
   bool result = false; /* safe default result */
   /* easiest case */
   if (real_ct == formal_ct)
     {
       pips_debug(8, "types are equal\n");
       result = true;
     }
  
   else if (type_tag(real_ct) != type_tag(formal_ct))
     {
       pips_debug(8, "not same type tags\n");
       result = false;
     }
  
   else
     {
       switch(type_tag(real_ct))
         {
         case is_type_void:
           result = true;
           break;
         case is_type_variable:
           {
             pips_debug(8, "variable case\n");
             basic real_b = variable_basic(type_variable(real_ct));
             list real_dims = variable_dimensions(type_variable(real_ct));
             basic formal_b = variable_basic(type_variable(formal_ct));
             list formal_dims = variable_dimensions(type_variable(formal_ct));
  
             bool finished = false;
             /* we do not take care of array dimension sizes */
             while (! finished)
               {
                 if (gen_length(real_dims) == gen_length(formal_dims))
                   {
                     /* well, basic_equal_strict_p is at the same time too restrictive
                        for derived and too optimistic for pointers and arrays because
                        dimensions are skipped
                     */
                     if (basic_pointer_p(real_b) && basic_pointer_p(formal_b))
                       {
                         pips_debug(8, "pointer case\n");
                         result =
                           basic_concrete_types_compatible_for_effects_interprocedural_translation_p
                           (basic_pointer(real_b), basic_pointer(formal_b));
                       }
                     else if (basic_derived_p(real_b) && basic_derived_p(formal_b))
                       {
                         entity real_basic_e = basic_derived(real_b);
                         entity formal_basic_e = basic_derived(formal_b);
                         pips_debug(8, "derived case, real: %s, formal: %s\n",
                                    entity_name(real_basic_e),
                                    entity_name(formal_basic_e));
                         if (same_entity_p(real_basic_e, formal_basic_e))
                           {
                             pips_debug(8, "same entities (1) \n");
                             result = true;
                           }
                         else
                           {
                             type formal_dt = entity_type(formal_basic_e);
                             type real_dt =  entity_type(real_basic_e);
  
                             void * found_formal_t = (type) gen_find_eq(formal_dt,formal_structured_types);
                             void * found_real_t = (type) gen_find_eq(real_dt,real_structured_types);
  
                             if (!gen_chunk_undefined_p(found_formal_t))
                               {
                                 pips_debug(8, "types already encountered (1) \n");
                                 result = gen_position(found_formal_t, formal_structured_types)
                                   == gen_position(found_real_t, real_structured_types);
                               }
                             else
                               {
                                 pips_debug(8, "types not encountered (1) \n");
                                 formal_structured_types = gen_type_cons(formal_dt, formal_structured_types);
                                 real_structured_types = gen_type_cons(real_dt, real_structured_types);
                                 result = basic_concrete_types_compatible_for_effects_interprocedural_translation_p(real_dt, formal_dt);
                                 list old_formal_structured_types = formal_structured_types;
                                 list old_real_structured_types = real_structured_types;
                                 POP(formal_structured_types);
                                 POP(real_structured_types);
                                 CDR(old_formal_structured_types) = NIL;
                                 CDR(old_real_structured_types) = NIL;
                                 gen_free_list(old_formal_structured_types);
                                 gen_free_list(old_real_structured_types);
                               }
                           }
                       }
                     else
                       result = basic_equal_p(real_b, formal_b);
                     finished = true;
                   }
                 else
                   {
                     /* skip same number of array and pointer dimensions until we reach the
                        ultimate basic or there are no more corresponding dimensions
                     */
                     if (basic_pointer_p(real_b) && gen_length(real_dims) == 0)
                       {
                         real_ct = basic_pointer(real_b);
                         if (type_void_p(real_ct))
                           {
                             /* we have a void * as actual argument */
                             /* translation cannot be accurate */
                             finished = true;
                           }
                         else if (type_variable_p(real_ct))
                           {
                             real_b = variable_basic(type_variable(real_ct));
                             real_dims = variable_dimensions(type_variable(real_ct));
                             formal_dims = CDR(formal_dims); /* we are sure here that gen_length(formal_dims) != 0*/
                           }
                         else
                           finished = true;
                       }
                     else if (basic_pointer_p(formal_b) && gen_length(formal_dims) == 0)
                       {
                         formal_ct = basic_pointer(formal_b);
                         if (type_void_p(formal_ct))
                           {
                             /* we have a void * as actual argument */
                             /* translation cannot be accurate */
                             finished = true;
                           }
                         else if (type_variable_p(formal_ct))
                           {
                             formal_b = variable_basic(type_variable(formal_ct));
                             formal_dims = variable_dimensions(type_variable(formal_ct));
                             real_dims = CDR(real_dims); /* we are sure here that gen_length(real_dims) != 0*/
                           }
                         else
                           finished = true;
                       }
                     else
                       finished = true;
                   }
               }
           }
           break;
         case is_type_struct:
         case is_type_union:
         case is_type_enum:
           pips_debug(8, "struct, union or enum case\n");
           list real_fields = type_fields(real_ct);
           list formal_fields = type_fields(formal_ct);
           if (gen_length(real_fields) == gen_length(formal_fields))
             {
               result = true;
               while(result && !ENDP(real_fields))
                 {
                   entity real_fe = ENTITY(CAR(real_fields));
                   entity formal_fe = ENTITY(CAR(formal_fields));
                   pips_debug(8, "fields, real: %s, formal: %s\n",
                              entity_name(real_fe),
                              entity_name(formal_fe));
  
                   if (same_entity_p(real_fe, formal_fe))
                     {
                       pips_debug(8, "same entities (2)\n");
                       result = true;
                     }
                   else
                     {
                       type real_ft = entity_type(real_fe);
                       type formal_ft = entity_type(formal_fe);
  
                       void * found_formal_ft = (type) gen_find_eq(formal_ft,formal_structured_types);
                       void * found_real_ft = (type) gen_find_eq(real_ft,real_structured_types);
  
                       if (!gen_chunk_undefined_p(found_formal_ft))
                         {
                           pips_debug(8, "types already encountered (2)\n");
                           result = gen_position(found_formal_ft, formal_structured_types)
                             == gen_position(found_real_ft, real_structured_types);
                         }
                       else
                         {
                           pips_debug(8, "types not encountered (2)\n");
                           /* store types and not bct becasue bct cannot be equal,
                              since a new type is generated each time.
                              We really need a global table for bcts */
                           formal_structured_types = gen_type_cons(formal_ft, formal_structured_types);
                           real_structured_types = gen_type_cons(real_ft, real_structured_types);
                           type real_fbct = entity_basic_concrete_type(real_fe);
                           type formal_fbct = entity_basic_concrete_type(formal_fe);
                           /* It should be a strict type equality here, but I don't think type_equal_p
                              is very robust when types are declared in headers
                           */
                           result =
                             basic_concrete_types_compatible_for_effects_interprocedural_translation_p
                             (real_fbct, formal_fbct);
  
                           list old_formal_structured_types = formal_structured_types;
                           list old_real_structured_types = real_structured_types;
                           POP(formal_structured_types);
                           POP(real_structured_types);
                           CDR(old_formal_structured_types) = NIL;
                           CDR(old_real_structured_types) = NIL;
                           gen_free_list(old_formal_structured_types);
                           gen_free_list(old_real_structured_types);
                         }
                     }
                   POP(real_fields);
                   POP(formal_fields);
                 }
             }
           break;
         case is_type_functional:
           pips_debug(8, "functional case\n");
           result = true;
           break;
         default:
           pips_internal_error("unexpected function argument type: %s\n", type_to_string(real_ct) );
         }
     }
   pips_debug(8, "returning %s\n", result? "true":"false");
   return result;
 }

References basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), basic_derived, basic_derived_p, basic_equal_p(), basic_pointer, basic_pointer_p, CAR, CDR, ENDP, ENTITY, entity_basic_concrete_type(), entity_name, entity_type, gen_chunk_undefined_p, gen_find_eq(), gen_free_list(), gen_length(), gen_position(), gen_type_cons(), is_type_enum, is_type_functional, is_type_struct, is_type_union, is_type_variable, is_type_void, NIL, pips_debug, pips_internal_error, POP, same_entity_p(), string_of_type(), type_fields(), type_tag, type_to_string(), type_variable, type_variable_p, type_void_p, variable_basic, and variable_dimensions.

Referenced by basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), c_convex_effects_on_actual_parameter_forward_translation(), and types_compatible_for_effects_interprocedural_translation_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bound_pt_to_list_p()

bool bound_pt_to_list_p ( statement )

Referenced by statement_to_points_to().

Here is the caller graph for this function:

◆ calloc_to_abstract_location()

entity calloc_to_abstract_location	(	expression	n,
		expression	size,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

n	is the first argument expression of the call to calloc
size	is the second argument expression of the call to calloc
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns: an abstract heap location entity

Parameters

size	ize
psi	si

Definition at line 414 of file abstract_location.c.

 {
   expression malloc_exp = make_op_exp("*",
                                       copy_expression(n),
                                       copy_expression(size));
   entity e = malloc_to_abstract_location(malloc_exp, psi);
   free_expression(malloc_exp);
   return(e);
 }

References copy_expression(), free_expression(), make_op_exp(), and malloc_to_abstract_location().

Here is the call graph for this function:

◆ can_be_constant_path_p()

bool can_be_constant_path_p ( reference r )

TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want to test if r can be a constant path for instance a[i] have to return false (something else?) a[0], a[1], i, j, a[*], var points by formal parameter (_p_0, ...), element of strut (s.id, ...), heap element have to return true.

!effect_reference_dereferencing_p(r, &exact_p) can return true when it's not a constant path like a[i] (a[i] and not a[*]) can make a side effect for the declaration of variable in parameter (only?), don't know why for instance with Semantics-New/Pointer.sub/memcopy01 void memcopy01([...], char dst[size]) --> void memcopy01([...], char dst[i])
store_independent_reference_p(r) can return false for some cp like a[0], can't permit to treat the array return false for the structure too, can't permit to treat the struct can return true for i, j, ... that can be a constant path but not strictly a constant path param r reference to analyze to see if it's a constant path return true if r can be constant path

This function is not used by the points-to analysis, but by semantics

Definition at line 1492 of file type.c.

 {
   bool constant_path = true;
  
   if (strict_constant_path_p(r))
     constant_path = true;
   else {
     bool exact_p = true;
     if (!effect_reference_dereferencing_p(r, &exact_p)) {
       constant_path = true;
     }
     else {
       constant_path = false;
     }
   }
  
   return constant_path;
 }

References effect_reference_dereferencing_p(), and strict_constant_path_p().

Referenced by update_reflhs_with_rhs_to_transformer().

Here is the call graph for this function:

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

int cell_compare	(	cell *	c1,
		cell *	c2
	)

Parameters

c1	1
c2	2

Definition at line 168 of file compare.c.

 {
   pips_assert("gaps not handled yet (ppv1 first)", !cell_gap_p(*c1));
   pips_assert("gaps not handled yet (ppv2 first)", !cell_gap_p(*c2));
  
   return cell_reference_compare(&cell_reference(*c1), &cell_reference(*c2));
  
 }

References cell_gap_p, cell_reference, cell_reference_compare(), and pips_assert.

Referenced by effect_compare(), pointer_value_compare(), pv_cells_mergeable_p(), pv_cells_syntactically_equal_p(), pvs_union_combinable_p(), simple_pv_may_union(), and simple_pv_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

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

bool cell_must_point_to_nowhere_sink_in_set_p	(	cell	source,
		set	pts
	)

How are array handled in pts? do we have arcs "a->a"?

Parameters

source	ource
pts	ts

Definition at line 870 of file points_to.c.

 {
   bool nowhere_p = false;
   type st = points_to_cell_to_concrete_type(source);
   pips_assert("The cell is a pointer", !array_type_p(st) && pointer_type_p(st));
   //type st = points_to_cell_to_concrete_type(source);
   //if(!array_type_p(st) && pointer_type_p(st)) {
     SET_FOREACH(points_to, pt, pts) {
       cell pt_source = points_to_source(pt);
       if(cell_equal_p(pt_source, source)) {
         //if(cell_equivalent_p(pt_source, source)) {
         cell pt_sink = points_to_sink(pt);
         if(null_cell_p(pt_sink))
           ;
         else if(nowhere_cell_p(pt_sink)) {
           approximation ap = points_to_approximation(pt);
           nowhere_p = approximation_must_p(ap) || approximation_exact_p(ap);
           break;
         }
         else {
           ;
         }
       }
     }
     //}
   return nowhere_p;
 }

References approximation_exact_p, approximation_must_p, array_type_p(), cell_equal_p(), nowhere_cell_p(), null_cell_p(), pips_assert, pointer_type_p(), points_to_approximation, points_to_cell_to_concrete_type(), points_to_sink, points_to_source, and SET_FOREACH.

Referenced by recursive_filter_formal_context_according_to_actual_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_points_to_non_null_sink_in_set_p()

bool cell_points_to_non_null_sink_in_set_p	(	cell	source,
		set	pts
	)

A set of functions called cell_points_to_xxxx(cell s, set pts) where set pts is a points-to relation set.

The definition domain of these functions is key to their use:

if the type of the source s is not a pointer type, should we return false or abort because s is not in the definition domain?
if source s does not appear at all in pts, should we return false or abort because s is not in the definition domain?

If both conditions are selected, the resulting definition domain is the definition domain of the mapping pts.

If a more relaxed definition domain is sometimes useful, then strict and non-strict versions of these functions should be provided, with a clear semantics for their true and false results.

Because cell s may point to one or many cells in pts, which is a relation and not a mapping, the caller may be interested in a may or must point. The information may be convened directly by using distinct function names, cell_must_points_to_xxxx or cell_may_points_to_xxxx, or by adding a pointer to a boolean, exact_p, in the function profiles, which may save time by not looping twice on pts arcs.

This can be implemented using the approximation information of the arcs in pts... if it is trusted. Or recomputed from the arcs in pts.

Flexibility is also introduced by the use of cell_equivalent_p() instead of cell_equal_p(). If the former is used, cells derived from cell s are considered when s if not a pointer. This leads to weird behaviors. For instance, if the source s is a struct, s.f1 and s.f2 will be considered. If s.f1 points to some concrete location and s.f2 points to nowhere (undefined pointer), what result should be returned? The advantage is that the caller does not have to generate s.f1 and s.f2 which are simply found in set pts. Does cell "source" points toward a non null fully defined cell in points-to set pts?

The function name is not well chosen. Something like cell_points_to_defined_cell_p()/

Parameters

source	ource
pts	ts

Definition at line 822 of file points_to.c.

 {
   bool non_null_p = false;
   type st = points_to_cell_to_concrete_type(source);
   pips_assert("The cell is a pointer", !array_type_p(st) && pointer_type_p(st));
   SET_FOREACH(points_to, pt, pts) {
     cell pt_source = points_to_source(pt);
     if(cell_equal_p(pt_source, source)) {
       //if(cell_equivalent_p(pt_source, source)) {
       cell pt_sink = points_to_sink(pt);
       if(null_cell_p(pt_sink))
         ;
       else if(nowhere_cell_p(pt_sink))
         ;
       else {
         non_null_p = true;
         break;
       }
     }
   }
   return non_null_p;
 }

References array_type_p(), cell_equal_p(), nowhere_cell_p(), null_cell_p(), pips_assert, pointer_type_p(), points_to_cell_to_concrete_type(), points_to_sink, points_to_source, and SET_FOREACH.

Referenced by filter_formal_context_according_to_actual_context(), new_filter_formal_context_according_to_actual_context(), 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:

◆ cell_points_to_nowhere_sink_in_set_p()

bool cell_points_to_nowhere_sink_in_set_p	(	cell	source,
		set	pts
	)

Parameters

source	ource
pts	ts

Definition at line 845 of file points_to.c.

 {
   bool nowhere_p = false;
   type st = points_to_cell_to_concrete_type(source);
   pips_assert("The cell is a pointer", !array_type_p(st) && pointer_type_p(st));
   SET_FOREACH(points_to, pt, pts) {
     cell pt_source = points_to_source(pt);
     if(cell_equal_p(pt_source, source)) {
     //if(cell_equivalent_p(pt_source, source)) {
       cell pt_sink = points_to_sink(pt);
       if(null_cell_p(pt_sink))
         ;
       else if(nowhere_cell_p(pt_sink)) {
         nowhere_p = true;
         break;
       }
       else {
         ;
       }
     }
   }
   return nowhere_p;
 }

References array_type_p(), cell_equal_p(), nowhere_cell_p(), null_cell_p(), pips_assert, pointer_type_p(), points_to_cell_to_concrete_type(), points_to_sink, points_to_source, and SET_FOREACH.

Referenced by recursive_filter_formal_context_according_to_actual_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_points_to_null_sink_in_set_p()

bool cell_points_to_null_sink_in_set_p	(	cell	source,
		set	pts
	)

Parameters

source	ource
pts	ts

Definition at line 898 of file points_to.c.

 {
   bool null_p = false;
   type st = points_to_cell_to_concrete_type(source);
   pips_assert("The cell is a pointer", !array_type_p(st) && pointer_type_p(st));
   SET_FOREACH(points_to, pt, pts) {
     cell pt_source = points_to_source(pt);
     if(cell_equal_p(pt_source, source)) {
       cell pt_sink = points_to_sink(pt);
       if(null_cell_p(pt_sink)) {
         null_p = true;
         break;
       }
     }
   }
   return null_p;
 }

References array_type_p(), cell_equal_p(), null_cell_p(), pips_assert, pointer_type_p(), points_to_cell_to_concrete_type(), points_to_sink, points_to_source, and SET_FOREACH.

Referenced by recursive_filter_formal_context_according_to_actual_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_reference_compare()

int cell_reference_compare	(	reference *	pr1,
		reference *	pr2
	)

compare.c

result

same entity, sort on indices values

not same entity, sort on entity name

sort on module name

if same module name: sort on entity local name

else: current module and top_level come first, then others in lexicographic order

Parameters

pr1	r1
pr2	r2

Definition at line 54 of file compare.c.

 {
   int c1_pos = 0; /* result */
   reference r1 = *pr1;
   reference r2 = *pr2;
   entity e1 = reference_variable(r1);
   entity e2 = reference_variable(r2);
  
   if(same_entity_p(e1, e2))
     {
       /* same entity, sort on indices values */
       list dims1 = reference_indices(r1);
       list dims2 = reference_indices(r2);
  
       size_t nb_dims1 = gen_length(dims1);
       size_t nb_dims2 = gen_length(dims2);
  
       for(;!ENDP(dims1) && !ENDP(dims2) && c1_pos == 0; POP(dims1), POP(dims2))
         {
           expression e1 = EXPRESSION(CAR(dims1));
           expression e2 = EXPRESSION(CAR(dims2));
  
           if(unbounded_expression_p(e1))
             if(unbounded_expression_p(e2))
               c1_pos = 0;
             else
               c1_pos = 1;
           else
             if(unbounded_expression_p(e2))
               c1_pos = -1;
             else
               {
                 syntax s1 = expression_syntax(e1);
                 syntax s2 = expression_syntax(e2);
                 if (syntax_reference_p(s1) && syntax_reference_p(s2))
                   {
                     entity e1 = reference_variable(syntax_reference(s1));
                     entity e2 = reference_variable(syntax_reference(s2));
  
                     if (!same_entity_p(e1, e2))
                           c1_pos = strcmp(entity_name(e1),entity_name(e2));
                   }
                 else
                   {
                     intptr_t i1 = 0;
                     intptr_t i2 = 0;
                     intptr_t diff = 0;
  
                     int r1 = expression_integer_value(e1, &i1);
                     int r2 = expression_integer_value(e2, &i2);
  
                     if (r1 && r2)
                       {
                         diff = i1 - i2;
                         c1_pos = diff==0? 0 : (diff>0?1:-1);
                       }
                     else
                       {
                         string ch1 = expression_to_string(e1);
                         string ch2 = expression_to_string(e2);
                         c1_pos = strcmp(ch1, ch2);
                         free(ch1);
                         free(ch2);
                       }
                   }
               }
         }
  
       if (c1_pos == 0)
         c1_pos = (nb_dims1 < nb_dims2) ? -1 : ( (nb_dims1 > nb_dims2) ? 1 : 0);
     }
   else
     {
       /* not same entity, sort on entity name */
       /* sort on module name */
       char * mod1 = strdup(entity_module_name(e1));
       string mod2 = strdup(entity_module_name(e2));
  
       c1_pos = strcmp(mod1, mod2);
       /* if same module name: sort on entity local name */
       if (c1_pos == 0)
         {
           c1_pos = strcmp(entity_user_name(e1), entity_user_name(e2));
         }
       /* else: current module and top_level come first, then others in lexicographic order */
       else
         {
           entity module = get_current_module_entity();
           const char* current_mod = module_local_name(module);
           if (strcmp(current_mod, mod1) == 0)
             {
               if (top_level_entity_p(e2))
                 c1_pos = strcmp(entity_user_name(e1), entity_user_name(e2));
               else
                 c1_pos = -1;
             }
           else if (strcmp(current_mod, mod2) == 0)
             {
               if (top_level_entity_p(e1))
                 c1_pos = strcmp(entity_user_name(e1), entity_user_name(e2));
               else
                 c1_pos = 1;
             }
           else if (top_level_entity_p(e1))
             c1_pos = -1;
           else if (top_level_entity_p(e2))
             c1_pos = 1;
         }
       free(mod1); free(mod2);
     }
  
   return c1_pos;
 }

References CAR, current_mod, ENDP, entity_module_name(), entity_name, entity_user_name(), EXPRESSION, expression_integer_value(), expression_syntax, expression_to_string(), free(), gen_length(), get_current_module_entity(), intptr_t, module, module_local_name(), POP, reference_indices, reference_variable, s1, same_entity_p(), strdup(), syntax_reference, syntax_reference_p, top_level_entity_p(), and unbounded_expression_p().

Referenced by cell_compare(), and compare_effect_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_reference_to_type()

type cell_reference_to_type	(	reference	ref,
		bool *	to_be_freed
	)

computes the type of a cell reference representing a memory access path.

Cell references are not compatible with entity typing: spurious dimensions are added to handle struct fields and the dereferencing operator. BEWARE : does not work if field entity indices have been converted to ranks.

Parameters

ref	is a reference from a cell.

Returns: a newly allocated type corresponding to the type of the memory cells targeted by the access path.

in particular, gets rid of non-store effect references

A reference to a function returns a pointer to a function of the very same time

FI: for some abstract locations that have type unknown instead of type variable, with basic overloaded

Parameters

ref	ef
to_be_freed	o_be_freed

Definition at line 466 of file type.c.

 {
   debug_on("EFFECTS-UTIL_DEBUG_LEVEL");
   type t = type_undefined;
   type ref_type = entity_basic_concrete_type(reference_variable(ref));
   *to_be_freed= false;
  
   pips_debug(6, "input reference: %s \n",  reference_to_string(ref));
  
   if (ENDP(reference_indices(ref))) /* in particular, gets rid of non-store effect references */
     {
       t = ref_type;
     }
   else
     {
       if(type_variable_p(ref_type))
         {
           t = r_cell_reference_to_type(reference_indices(ref), ref_type, to_be_freed);
         }
       else if(type_functional_p(ref_type))
         {
           /* A reference to a function returns a pointer to a function
              of the very same time */
           t = make_type(is_type_variable,
                         make_variable
                         (make_basic(is_basic_pointer, copy_type(ref_type)),
                          NIL, NIL));
           *to_be_freed = true;
         }
       else if(type_unknown_p(ref_type)) {
         /* FI: for some abstract locations that have type unknown
            instead of type variable, with basic overloaded */
         t = ref_type;
         *to_be_freed = false;
       }
       else
         {
           pips_internal_error("Bad reference type tag %d \"%s\" for reference %s",
                               type_tag(ref_type),
                               type_to_string(ref_type),
                               entity_name(reference_variable(ref)));
         }
     }
   debug_off();
   return t;
 }

References copy_type(), debug_off, debug_on, ENDP, entity_basic_concrete_type(), entity_name, is_basic_pointer, is_type_variable, make_basic(), make_type(), make_variable(), NIL, pips_debug, pips_internal_error, r_cell_reference_to_type(), ref, reference_indices, reference_to_string(), reference_variable, type_functional_p, type_tag, type_to_string(), type_undefined, type_unknown_p, and type_variable_p.

Referenced by cell_to_type(), formal_points_to_parameter(), multiple_pointer_assignment_to_post_pv(), points_to_reference_to_type(), and references_may_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_relations_generic_binary_op()

list cell_relations_generic_binary_op	(	list	l1,
		list	l2,
		bool(*)(cell_relation, cell_relation)	cr1_cr2_combinable_p,
		list(*)(cell_relation, cell_relation)	cr1_cr2_binary_op,
		list(*)(cell_relation)	cr1_unary_op,
		list(*)(cell_relation)	cr2_unary_op,
		list(*)(list, list)	union_op
	)

cell_relations.c

beware : modifies l1, l2 and their effects

Parameters

l1	and l2 are two lists of cell_relations.
cr1_cr2_combinable_p	is a bool function that takes two individual cell_relations as arguments and renders true when they are considered as combinable ;
cr1_cr2_binary_op	is a binary operator that combines two individual cell_relations;
cr1_unary_op	is a unary operators that deal with the remnants of l1, that is those cell_relations that are not combinable with any effect of l2;
cr2_unary_op	is a unary operators that deal with the remnants of l2, that is those cell_relations that are not combinable with any effect of l1;

Returns: a list of cell_relations, combination of l1 and l2.

we first deal with the elements of l1 : those that are combinable with the elements of l2, and the others, which we call the remnants of l1

gen_remove(&l2, EFFECT(CAR(l_cr2)));

cr1 belongs to the remnants of l1 : it is combinable with no effects of l2

we must then deal with the remnants of l2

no memory leaks: l1 and l2 won't be used anymore

Parameters

l1	1
l2	2

Definition at line 59 of file cell_relations.c.

 {
   list l_res = NIL;
   list l_cr1 = list_undefined;
   list l_cr2 = list_undefined;
  
   debug_on("CELL_RELATIONS_OPERATORS_DEBUG_LEVEL");
  
   pips_debug_pvs(1, "l1:\n", l1);
   pips_debug_pvs(1, "l2:\n", l2);
  
   /* we first deal with the elements of l1 : those that are combinable with
    * the elements of l2, and the others, which we call the remnants of l1 */
   for(l_cr1 = l1; !ENDP(l_cr1); POP(l_cr1))
     {
       cell_relation cr1 = CELL_RELATION(CAR(l_cr1));
       list prec_l_cr2 = NIL;
       bool combinable = false;
  
       pips_debug_pv(2, "dealing with cr1:\n", cr1);
  
       l_cr2 = l2;
       while(!ENDP(l_cr2))
         {
           cell_relation cr2 = CELL_RELATION(CAR(l_cr2));
  
           pips_debug_pv(2, "considering cr2:\n", cr2);
  
           if ( (*cr1_cr2_combinable_p)(cr1,cr2) )
             {
               pips_debug(2, "combinable\n");
               combinable = true;
               list l_res_tmp = (*cr1_cr2_binary_op)(cr1,cr2);
               l_res = (*union_op)(l_res, l_res_tmp);
  
               /* gen_remove(&l2, EFFECT(CAR(l_cr2))); */
               if (prec_l_cr2 != NIL)
                 CDR(prec_l_cr2) = CDR(l_cr2);
               else
                 l2 = CDR(l_cr2);
  
               free(l_cr2); l_cr2 = NIL;
               /* */
               //free_cell_relation(cr1); cr1=cell_relation_undefined;
               free_cell_relation(cr2); cr2=cell_relation_undefined;
             }
           else
             {
               pips_debug(2, "not combinable\n");
               prec_l_cr2 = l_cr2;
               l_cr2 = CDR(l_cr2);
             }
         }
  
       pips_debug_pvs(2, "intermediate l_res 1:\n", l_res);
  
       if(!combinable)
         {
           /* cr1 belongs to the remnants of l1 : it is combinable
            * with no effects of l2 */
           if ( (*cr1_cr2_combinable_p)(cr1,cell_relation_undefined) )
             l_res = gen_nconc(l_res, (*cr1_unary_op)(cr1));
         }
       else
         {
           free_cell_relation(cr1); cr1=cell_relation_undefined;
         }
     }
  
   pips_debug_pvs(2, "intermediate l_res 2:\n", l_res);
  
   /* we must then deal with the remnants of l2 */
   for(l_cr2 = l2; !ENDP(l_cr2); POP(l_cr2))
     {
       cell_relation cr2 = CELL_RELATION(CAR(l_cr2));
  
       if ( (*cr1_cr2_combinable_p)(cell_relation_undefined,cr2) )
         l_res = gen_nconc(l_res, (*cr2_unary_op)(cr2));
     }
  
   pips_debug_pvs(1, "final pvs:\n", l_res);
  
   /* no memory leaks: l1 and l2 won't be used anymore */
   gen_free_list(l1);
   gen_free_list(l2);
  
   debug_off();
  
   return l_res;
 }

References CAR, CDR, CELL_RELATION, cell_relation_undefined, debug_off, debug_on, ENDP, free(), free_cell_relation(), gen_free_list(), gen_nconc(), list_undefined, NIL, pips_debug, pips_debug_pv, pips_debug_pvs, and POP.

Referenced by simple_pvs_may_union(), and simple_pvs_must_union().

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:

◆ cell_to_type()

type cell_to_type	(	cell	c,
		bool *	to_be_freed
	)

Parameters

to_be_freed o_be_freed

Definition at line 513 of file type.c.

 {
   pips_assert("a cell cannot be a gap yet\n", !cell_gap_p(c));
   reference ref = cell_reference_p(c)? cell_reference(c) : preference_reference(cell_preference(c));
  
   return cell_reference_to_type(ref, to_be_freed);
 }

References cell_gap_p, cell_preference, cell_reference, cell_reference_p, cell_reference_to_type(), pips_assert, preference_reference, and ref.

Referenced by cell_to_nowhere_sink(), external_call_to_post_pv(), generic_stub_source_to_sinks(), k_limit_points_to(), module_initial_parameter_pv(), safe_intrinsic_to_post_pv(), struct_assignment_to_points_to(), type_compatible_super_cell(), and type_compatible_with_points_to_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_typed_anywhere_locations_p()

bool cell_typed_anywhere_locations_p ( cell c )

test if a cell is the bottom of the lattice

Definition at line 133 of file anywhere_abstract_locations.c.

 {
   reference r = cell_any_reference(c);
   bool anywhere_p = reference_typed_anywhere_locations_p(r);
   return anywhere_p;
 }

References cell_any_reference(), and reference_typed_anywhere_locations_p().

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(), freeable_points_to_cells(), freed_pointer_to_points_to(), null_equal_condition_to_points_to(), offset_cells(), offset_points_to_cell(), points_to_with_stripped_sink(), print_or_dump_points_to(), source_to_sinks(), and unique_location_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cells_may_not_point_to_null_p()

bool cells_may_not_point_to_null_p ( list cl )

Parameters

cl l

Definition at line 763 of file points_to.c.

 {
   bool may_not_p = true;
   pips_assert("The input list is not empty", !ENDP(cl));
   FOREACH(CELL, c, cl) {
     if(null_cell_p(c) || nowhere_cell_p(c)) {
       may_not_p = false;
       break;
     }
   }
   return may_not_p;
 }

References CELL, ENDP, FOREACH, nowhere_cell_p(), null_cell_p(), and pips_assert.

Referenced by intrinsic_call_condition_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cells_must_point_to_null_p()

bool cells_must_point_to_null_p ( list cl )

Parameters

cl l

Definition at line 750 of file points_to.c.

 {
   bool must_p = true;
   pips_assert("The input list is not empty", !ENDP(cl));
   FOREACH(CELL, c, cl) {
     if(!null_cell_p(c)) {
       must_p = false;
       break;
     }
   }
   return must_p;
 }

References CELL, ENDP, FOREACH, null_cell_p(), and pips_assert.

Referenced by intrinsic_call_condition_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_abstract_locations()

void check_abstract_locations ( void )

For debugging the API.

top

bottom

null pointer

all locations for a given module

all heap locations for a given module

all stack locations for a given module

all static locations for a given module

all dynamic locations for a given module

all heap locations for an application

all stack locations for an application

all static locations for an application

all dynamic locations for an application

Should/could be extended to check the max computation...

Definition at line 906 of file anywhere_abstract_locations.c.

  {
    entity al = entity_undefined;
    /* top */
    al = entity_all_locations();
    fprintf(stderr, "top: %s is %s\n", entity_name(al),
            entity_all_locations_p(al)?
            "the set of all application locations" : "bug!!!");
  
    /* bottom */
    al = entity_nowhere_locations();
    fprintf(stderr, "bottom: %s is %s\n", entity_name(al),
            entity_nowhere_locations_p(al)?
            "the bottom of the abstract location lattice" : "bug!!!");
  
    /* null pointer */
    al = entity_null_locations();
    fprintf(stderr, "null: %s is %s\n", entity_name(al),
            entity_null_locations_p(al)?
            "the null pointer" : "bug!!!");
  
    /* all locations for a given module */
    al = entity_all_module_locations(get_current_module_entity());
    fprintf(stderr, "all module locations: %s is %s\n", entity_name(al),
            entity_all_module_locations_p(al)?
            "the set of all locations of a module" : "bug!!!");
  
    /* all heap locations for a given module */
    al = entity_all_module_heap_locations(get_current_module_entity());
    fprintf(stderr, "all module heap locations: %s is %s\n", entity_name(al),
            entity_all_module_heap_locations_p(al)?
            "the set of all heap locations of a module" : "bug!!!");
  
    /* all stack locations for a given module */
    al = entity_all_module_stack_locations(get_current_module_entity());
    fprintf(stderr, "all module stack locations: %s is %s\n", entity_name(al),
            entity_all_module_stack_locations_p(al)?
            "the set of all stack locations of a module" : "bug!!!");
  
    /* all static locations for a given module */
    al = entity_all_module_static_locations(get_current_module_entity());
    fprintf(stderr, "all module static locations: %s is %s\n", entity_name(al),
            entity_all_module_static_locations_p(al)?
            "the set of all static locations of a module" : "bug!!!");
  
    /* all dynamic locations for a given module */
    al = entity_all_module_dynamic_locations(get_current_module_entity());
    fprintf(stderr, "all module dynamic locations: %s is %s\n", entity_name(al),
            entity_all_module_dynamic_locations_p(al)?
            "the set of all dynamic locations of a module" : "bug!!!");
  
  
    /* all heap locations for an application */
    al = entity_all_heap_locations();
    fprintf(stderr, "all application heap locations: %s is %s\n", entity_name(al),
            entity_all_heap_locations_p(al)?
            "the set of all heap locations of an application" : "bug!!!");
  
    /* all stack locations for an application */
    al = entity_all_stack_locations();
    fprintf(stderr, "all application stack locations: %s is %s\n", entity_name(al),
            entity_all_stack_locations_p(al)?
            "the set of all stack locations of an application" : "bug!!!");
  
    /* all static locations for an application */
    al = entity_all_static_locations();
    fprintf(stderr, "all application static locations: %s is %s\n", entity_name(al),
            entity_all_static_locations_p(al)?
            "the set of all static locations of an applciation" : "bug!!!");
  
    /* all dynamic locations for an application */
    al = entity_all_dynamic_locations();
    fprintf(stderr, "all module dynamic locations: %s is %s\n", entity_name(al),
            entity_all_dynamic_locations_p(al)?
            "the set of all dynamic locations of an application" : "bug!!!");
  
    /* Should/could be extended to check the max computation... */
  }

Here is the call graph for this function:

◆ close_pt_to_list()

void close_pt_to_list ( void )

◆ compare_effect_reference()

int compare_effect_reference	(	effect *	e1,
		effect *	e2
	)

int compare_effect_reference(e1, e2):

returns -1 if "e1" is before "e2" in the alphabetic order, else +1. "e1" and "e2" are pointers to effect, we compare the names of their reference's entity.

Parameters

e1	1
e2	2

Definition at line 210 of file compare.c.

 {
   reference r1 = effect_any_reference(*e1);
   reference r2 = effect_any_reference(*e2);
   return cell_reference_compare(&r1, &r2);
 }

References cell_reference_compare(), and effect_any_reference.

Referenced by create_step_regions(), and internal_compute_distribution_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_effect_reference_in_common()

int compare_effect_reference_in_common	(	effect *	e1,
		effect *	e2
	)

int compare_effect_reference_in_common(e1, e2):

returns -1 if "e1" is before "e2" in the alphabetic order, else +1. "e1" and "e2" are pointers to effect, we compare the names of their reference's entity with the common name in first if the entity belongs to a common

Parameters

e1	1
e2	2

Definition at line 224 of file compare.c.

 {
   entity v1, v2;
   int n1, n2 ,result;
   string name1, name2;
   v1 = reference_variable(effect_any_reference(*e1));
   v2 = reference_variable(effect_any_reference(*e2));
   n1 = (v1==(entity)NULL),
   n2 = (v2==(entity)NULL);
   name1= strdup((entity_in_common_p(v1)) ?
       (string) entity_and_common_name(v1):
       entity_name(v1));
   name2=  strdup((entity_in_common_p(v2)) ?
       (string) entity_and_common_name(v2):
       entity_name(v2));
  
   result =  (n1 || n2)?  (n2-n1): strcmp(name1,name2);
   free(name1);free(name2);
   return result;
 }

References effect_any_reference, entity_and_common_name(), entity_in_common_p(), entity_name, free(), reference_variable, and strdup().

Here is the call graph for this function:

◆ compatible_points_to_subscripts_p()

bool compatible_points_to_subscripts_p	(	expression	s1,
		expression	s2
	)

Two subscript are compatible if they are equal or if one of them is unbounded.

In the ponts-to context s1 and s2 should be either integer constants or field references.

Parameters

s1	1
s2	2

Definition at line 1041 of file points_to.c.

 {
   bool compatible_p = true;
   bool u1 = unbounded_expression_p(s1);
   if(!u1) {
     bool u2 = unbounded_expression_p(s2);
     if(!u2) {
       /* In the ponts-to context s1 and s2 should be either integer
          constants or field references. */
       compatible_p = expression_equal_p(s1, s2);
     }
   }
   return compatible_p;
 }

References expression_equal_p(), s1, and unbounded_expression_p().

Referenced by points_to_cell_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ complete_points_to_reference_with_fixed_subscripts()

void complete_points_to_reference_with_fixed_subscripts	(	reference	r,
		bool	zero_p
	)

Add a set of zero subscripts to a constant memory path reference "r" by side effect.

Used when a partial array reference must be converted into a reference to the first array element (zero_p==true) or to any element (zero_p==false).

The difficulty lies with field subscripts...

Find the current number of effective subscripts: is there a field subscript somewhere?

FI: this may happen when reference "r" is not a constant memory path

Parameters

zero_p ero_p

Definition at line 696 of file points_to.c.

 {
   type t = type_undefined;
  
   // FI: this assert makes sense within the ri-util framework but is
   // too strong for the kind of references used in effects-util
   // pips_assert("scalar type", ENDP(reference_indices(r)));
  
   /* Find the current number of effective subscripts: is there a field
      subscript somewhere? */
   list sl = reference_indices(r);
   entity v = reference_variable(r);
   list rsl = gen_nreverse(sl); // sl is no longer available
   int i = 0;
   bool field_found_p = false;
  
   FOREACH(EXPRESSION, se, rsl) {
     if(field_expression_p(se)) {
       reference fr = expression_reference(se);
       entity f = reference_variable(fr);
       t = entity_basic_concrete_type(f); 
       field_found_p = true;
       break;
     }
     i++;
   }
  
   if(!field_found_p)
     t = entity_basic_concrete_type(v);
  
   variable vt = type_variable(t);
   list dl = variable_dimensions(vt);
   int d = (int) gen_length(dl);
  
   /* FI: this may happen when reference "r" is not a constant memory path */
   pips_assert("Not too many subscripts wrt the type.\n", i<=d);
  
   list nsl = NIL; // subscript list
   int j;
   for(j=i+1;j<=d;j++) {
     expression s = zero_p? int_to_expression(0) : make_unbounded_expression();
     // reference_indices(r) = CONS(EXPRESSION, s, reference_indices(r));
     nsl = CONS(EXPRESSION, s, nsl);
   }
  
   reference_indices(r) = gen_nreverse(rsl);
   reference_indices(r) = gen_nconc(reference_indices(r), nsl);
 }

References CONS, entity_basic_concrete_type(), EXPRESSION, expression_reference(), f(), field_expression_p(), FOREACH, gen_length(), gen_nconc(), gen_nreverse(), int, int_to_expression(), make_unbounded_expression(), NIL, pips_assert, reference_indices, reference_variable, type_undefined, type_variable, and variable_dimensions.

Referenced by complete_points_to_reference_with_zero_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ complete_points_to_reference_with_zero_subscripts()

void complete_points_to_reference_with_zero_subscripts ( reference r )

Definition at line 745 of file points_to.c.

 {
   complete_points_to_reference_with_fixed_subscripts(r, true);
 }

References complete_points_to_reference_with_fixed_subscripts().

Referenced by dereferencing_subscript_to_points_to(), process_casted_sinks(), process_casted_sources(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constant_memory_access_path_to_location_entity()

entity constant_memory_access_path_to_location_entity ( reference cp )

A constant memory access path may not be considered.

An undefined entity is returned and the caller must handle the issue.

This occurs, for instance, in the semantics analysis when a wider memory effect contain this constant path. E.g. an untyped anwyhere effect.

It also happens when the caller consider a[*] as a constant reference. It is a constant set of references and no entity is returned.

Parameters

cp p

Definition at line 329 of file locations.c.

 {
   entity ecp = entity_undefined;
   reference ncp = constant_reference_to_normalized_constant_reference(cp);
   if(!reference_undefined_p(ncp)) {
     string cp_name = constant_memory_access_path_to_location_name(ncp);
     free_reference(ncp);
  
     // find (or do not create) an entity for the constant path
     // The entity is supposed to have been created earlier explictly
     ecp = gen_find_entity(cp_name);
     if (entity_undefined_p(ecp)) {
       // pips_internal_error("location entity should have been created explictly during an initialization phase\n");
       ; // Let the caller deals with the problem
     }
     free(cp_name);
   }
   return ecp;
 }

References constant_memory_access_path_to_location_name(), constant_reference_to_normalized_constant_reference(), cp, entity_undefined, entity_undefined_p, free(), free_reference(), gen_find_entity(), and reference_undefined_p.

Referenced by apply_concrete_effect_to_transformer(), assign_rhs_to_cp_to_transformer(), forward_substitute_array_location_in_transformer(), generic_apply_effect_to_transformer(), generic_effects_maymust_read_or_write_scalar_entity_p(), generic_reference_to_transformer(), generic_unary_operation_to_transformer(), lhs_expression_to_transformer(), new_array_element_backward_substitution_in_transformer(), perform_array_element_substitutions_in_transformer(), pointer_unary_operation_to_transformer(), substitute_struct_stub_in_transformer(), substitute_stubs_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_apply_field_assignments_or_equalities(), transformer_apply_unknown_field_assignments_or_equalities(), and update_cp_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constant_points_to_indices_p()

bool constant_points_to_indices_p ( list sl )

check that the subscript list il is either empty or made of integers or fields.

Parameters

sl l

Definition at line 1272 of file points_to.c.

 {
   bool constant_p = true;
  
   FOREACH(EXPRESSION, se, sl) {
     if(!extended_integer_constant_expression_p(se)) {
       syntax s = expression_syntax(se);
       if(syntax_reference_p(s)) {
         reference r = syntax_reference(s);
         entity f = reference_variable(r);
         if(!entity_field_p(f)) {
           constant_p = false;
           break;
         }
       }
       else {
         constant_p = false;
         break;
       }
     }
   }
   return constant_p;
 }

References constant_p(), entity_field_p(), EXPRESSION, expression_syntax, extended_integer_constant_expression_p(), f(), FOREACH, reference_variable, syntax_reference, and syntax_reference_p.

Here is the call graph for this function:

◆ delete_pt_to_list()

points_to_list delete_pt_to_list ( statement )

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

int effect_compare	(	effect *	peff1,
		effect *	peff2
	)

Compares two effects for sorting.

The first criterion is based on names. Local entities come first; then they are sorted according to the lexicographic order of the module name, and inside each module name class, according to the local name lexicographic order. Then for a given entity name, a read effect comes before a write effect. It is assumed that there is only one effect of each type per entity. bc.

same paths, sort on action, reads first

Parameters

peff1	eff1
peff2	eff2

Definition at line 187 of file compare.c.

 {
     int eff1_pos = 0;
  
     eff1_pos = cell_compare(&effect_cell(*peff1), &effect_cell(*peff2));
     if (eff1_pos == 0)
       {
         /* same paths, sort on action, reads first */
         if (effect_read_p(*peff1))
           eff1_pos = -1;
         else if (effect_read_p(*peff2))
           eff1_pos = 1;
         else eff1_pos = 0;
       }
     return(eff1_pos);
 }

References cell_compare(), effect_cell, and effect_read_p.

Here is the call graph for this function:

◆ effect_entity()

entity effect_entity ( effect e )

cproto-generated files

effects.c

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_field_dimension_entity()

entity effect_field_dimension_entity	(	expression	exp,
		list	l_fields
	)

type.c

Parameters

exp	is an effect index expression which is either the rank or an entity corresponding to a struct, union or enum field
l_fields	is the list of fields of the corresponding struct, union or enum

Returns: the entity corresponding to the field.

Parameters

exp	xp
l_fields	_fields

Definition at line 51 of file type.c.

 {
   if(expression_constant_p(exp))
     {
       int rank = expression_to_int(exp);
       return ENTITY(gen_nth(rank-1, l_fields));
     }
   else
     {
       return expression_to_entity(exp);
     }
 }

References ENTITY, exp, expression_constant_p(), expression_to_entity(), expression_to_int(), gen_nth(), and rank.

Referenced by effect_indices_first_pointer_dimension_rank().

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_reference_contains_pointer_dimension_p()

bool effect_reference_contains_pointer_dimension_p	(	reference	ref,
		bool *	exact_p
	)

Parameters

ref	is an effect reference
exact_p	is a pointer to a bool, which is set to true if the result is not an approximation.

Returns: false if no index corresponds to a pointer dimension, false if any index may correspond to a pointer dimension. If this information is exact, *exact_p is set to true.

Parameters

ref	ef
exact_p	xact_p

Definition at line 219 of file type.c.

 {
   int pointer_rank;
   pointer_rank = effect_reference_first_pointer_dimension_rank(ref, exact_p);
   return (pointer_rank >= 0);
 }

References effect_reference_first_pointer_dimension_rank(), and ref.

Here is the call graph for this function:

◆ effect_reference_dereferencing_p()

bool effect_reference_dereferencing_p	(	reference	ref,
		bool *	exact_p
	)

Parameters

ref	is an effect reference
exact_p	is a pointer to a bool, which is set to true if the result is not an approximation.

Returns: true if the effect reference may dereference a pointer, false otherwise.

FI: ANY_MODULE:ANYWHERE should not be indexed because any indexing can be eliminated as it results in ANY_MODULE:ANYWHERE

FI: ANY_MODULE:ANYWHERE_b0, 1, 2 should not be indexed because any indexing can be eliminated and the reference replaced by a non-indexed reference to ANY_MODULE:ANYWHERE_bi , j, k depending on the type of the reference.

no dereferencement if scalar reference, in particular, gets rid of non store effect references

Parameters

ref	ef
exact_p	xact_p

Definition at line 233 of file type.c.

 {
   list l_ind = reference_indices(ref);
   bool result;
   int p_rank;
   entity e = reference_variable(ref);
  
   //if (entity_all_locations_p(reference_variable(ref)))
   if (entity_abstract_location_p(e))
     {
       if(ENDP(l_ind)) {
         // result = true;
         result = false;
         *exact_p = false;
       }
       else {
         if(entity_all_locations_p(e)) {
           /* FI: *ANY_MODULE*:*ANYWHERE* should not be indexed because
            * any indexing can be eliminated as it results in
            * *ANY_MODULE*:*ANYWHERE*
            */
           pips_internal_error("Unexpected indexing of an abstract location.\n");
         }
         else if(entity_typed_anywhere_locations_p(e)) {
           /* FI: *ANY_MODULE*:*ANYWHERE*_b0, 1, 2 should not be
            * indexed because any indexing can be eliminated and the
            * reference replaced by a non-indexed reference to
            * *ANY_MODULE*:*ANYWHERE*_bi , j, k depending on the type
            * of the reference.
            */
           pips_internal_error("Unexpected indexing of an abstract location.\n");
         }
         else {
           p_rank = effect_reference_first_pointer_dimension_rank(ref, exact_p);
  
           if (p_rank == -1)
             result = false;
           else
             result = p_rank < (int) gen_length(l_ind);
         }
       }
     }
   else
     {
       if (ENDP(l_ind)) /* no dereferencement if scalar reference, in particular, gets rid
                           of non store effect references */
           p_rank = -1;
       else
         p_rank = effect_reference_first_pointer_dimension_rank(ref, exact_p);
  
       if (p_rank == -1)
         result = false;
       else
         result = p_rank < (int) gen_length(l_ind);
     }
   return result;
 }

References effect_reference_first_pointer_dimension_rank(), ENDP, entity_abstract_location_p(), entity_all_locations_p(), entity_typed_anywhere_locations_p(), gen_length(), int, pips_internal_error, ref, reference_indices, and reference_variable.

Referenced by can_be_constant_path_p(), convex_effect_to_constant_path_effects_with_pointer_values(), convex_effect_to_constant_path_effects_with_points_to(), effect_to_constant_path_effects_with_points_to(), generic_eval_cell_with_points_to(), references_may_conflict_p(), and simple_effect_to_constant_path_effects_with_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effect_reference_to_string()

string effect_reference_to_string ( reference ref )

Parameters

ref ef

Definition at line 155 of file prettyprint.c.

 {
   return words_to_string(effect_words_reference(ref));
 }

References effect_words_reference(), ref, and words_to_string().

Referenced by check_type_of_points_to_cells(), generic_eval_cell_with_points_to(), generic_transform_sink_cells_from_matching_list(), list_assignment_to_points_to(), offset_cell(), points_to_cell_to_string(), reference_dereferencing_to_points_to(), reference_to_points_to_sinks(), references_may_conflict_p(), and references_must_conflict_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:

◆ effect_words_reference()

list effect_words_reference ( reference obj )

prettyprint.c

of string

Parameters

obj bj

Definition at line 68 of file prettyprint.c.

 {
   list pc = NIL;
   string begin_attachment;
   entity e = reference_variable(obj);
  
   if (get_bool_property("PRETTYPRINT_WITH_COMMON_NAMES")
       && entity_in_common_p(e)) {
     pc = CHAIN_SWORD(pc, entity_and_common_name(e));
   } else if (get_bool_property("PRETTYPRINT_EFFECT_WITH_FULL_ENTITY_NAME")) {
     pc = CHAIN_SWORD(pc, entity_name(e));
   } else {
     pc = CHAIN_SWORD(pc, entity_minimal_name(e));
   }
  
   begin_attachment = STRING(CAR(pc));
  
   if (reference_indices(obj) != NIL)
     {
       string before_first_index = string_undefined;
       string before_index = string_undefined;
       string after_index = string_undefined;
       string after_last_index = string_undefined;
       string before_field = string_undefined;
       string after_field = string_undefined;
  
       switch(get_prettyprint_language_tag())
         {
         case is_language_fortran95:
         case is_language_fortran:
           before_first_index = "(";
           before_index = "";
           after_index = ",";
           after_last_index = ")";
           before_field = "";
           after_field = "";
           break;
         case is_language_c:
           before_first_index = "[";
           before_index = "[";
           after_index = "]";
           after_last_index = "]";
           before_field = ".";
           after_field = "";
           break;
         default:
           pips_internal_error("Language unknown !");
           break;
         }
  
       bool first = true;
       for(list pi = reference_indices(obj); !ENDP(pi); POP(pi))
         {
           expression ind_exp = EXPRESSION(CAR(pi));
           syntax s = expression_syntax(ind_exp);
           if (syntax_reference_p(s) &&
               entity_field_p(reference_variable(syntax_reference(s))))
             {
               // add a '.' to disambiguate field names from variable names
               pc = CHAIN_SWORD(pc, before_field);
               pc = gen_nconc(pc, Words_Expression(ind_exp));
               pc = CHAIN_SWORD(pc, after_field);
             }
           else
             {
               if (first)
                 {
                   pc = CHAIN_SWORD(pc,before_first_index);
                   first = false;
                 }
               else
                 pc = CHAIN_SWORD(pc,before_index);
  
               pc = gen_nconc(pc, Words_Expression(ind_exp));
               if (CDR(pi) != NIL)
                 pc = CHAIN_SWORD(pc,after_index);
               else
                 pc = CHAIN_SWORD(pc,after_last_index);
             }
         }
     }
  
   attach_reference_to_word_list(begin_attachment, STRING(CAR(gen_last(pc))),
                                 obj);
   return(pc);
 }

References attach_reference_to_word_list(), CAR, CDR, CHAIN_SWORD, ENDP, entity_and_common_name(), entity_field_p(), entity_in_common_p(), entity_minimal_name(), entity_name, EXPRESSION, expression_syntax, gen_last(), gen_nconc(), get_bool_property(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, NIL, pips_internal_error, POP, reference_indices, reference_variable, STRING, string_undefined, syntax_reference, syntax_reference_p, and Words_Expression().

Referenced by conflicts_sort_callback(), effect_reference_first_pointer_dimension_rank(), effect_reference_to_string(), make_filtered_dg_or_dvdg(), prettyprint_dependence_graph(), prettyprint_dot_dependence_graph(), text_pointer_value(), text_points_to_relation(), text_region_no_action(), words_pointer_value(), and words_points_to().

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:

◆ entity_abstract_location_p()

bool entity_abstract_location_p ( entity al )

Parameters

al l

Definition at line 641 of file anywhere_abstract_locations.c.

 {
 #ifndef NDEBUG
   const char * en = entity_name(al);
   const char * module_sep = strchr(en,MODULE_SEP_CHAR);
   bool abstract_locations_p = (   0 == strncmp(en,ANY_MODULE_NAME,module_sep++ - en) // << FI: this may change in the future and may not be a strong enough condition
                                   ||   0 == strncmp(module_sep, ANYWHERE_LOCATION, sizeof(ANYWHERE_LOCATION)-1)
                                   ||   0 == strncmp(module_sep, STATIC_AREA_LOCAL_NAME, sizeof(STATIC_AREA_LOCAL_NAME)-1)
                                   ||   0 == strncmp(module_sep, DYNAMIC_AREA_LOCAL_NAME, sizeof(DYNAMIC_AREA_LOCAL_NAME)-1)
                                   ||   0 == strncmp(module_sep, STACK_AREA_LOCAL_NAME, sizeof(STACK_AREA_LOCAL_NAME)-1)
                                   ||   0 == strncmp(module_sep, HEAP_AREA_LOCAL_NAME, sizeof(HEAP_AREA_LOCAL_NAME)-1)
                                   ||   0 == strncmp(module_sep, FORMAL_AREA_LOCAL_NAME, sizeof(HEAP_AREA_LOCAL_NAME)-1)
                                   //                              ||   0 == strncmp(module_sep, NULL_POINTER_NAME, sizeof(NULL_POINTER_NAME)-1)
                                   )
     ;
   pips_assert("entity_kind is consistent",abstract_locations_p == ((entity_kind(al)&ABSTRACT_LOCATION)==ABSTRACT_LOCATION));
 #endif
   return (entity_kind(al) & ABSTRACT_LOCATION) ? true : false;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, ANYWHERE_LOCATION, DYNAMIC_AREA_LOCAL_NAME, entity_kind, entity_name, FORMAL_AREA_LOCAL_NAME, HEAP_AREA_LOCAL_NAME, MODULE_SEP_CHAR, pips_assert, STACK_AREA_LOCAL_NAME, STATIC_AREA_LOCAL_NAME, and true.

Referenced by add_conflicts(), add_implicit_interprocedural_write_effects(), atomic_constant_path_p(), cell_abstract_location_p(), convex_effect_to_constant_path_effects_with_pointer_values(), create_values_for_simple_effect(), effect_reference_dereferencing_p(), effects_to_dma(), entities_maymust_conflict_p(), entity_locations_max(), generic_apply_effect_to_transformer(), generic_apply_effects_to_transformer(), generic_effects_entities_which_may_conflict_with_scalar_entity(), generic_effects_maymust_read_or_write_scalar_entity_p(), generic_eval_cell_with_points_to(), generic_transform_sink_cells_from_matching_list(), memory_dereferencing_p(), module_to_value_mappings(), opgen_may_name(), opgen_must_name(), opkill_may_name(), opkill_must_name(), points_to_cell_to_upper_bound_points_to_cells(), points_to_compare_cells(), points_to_compare_ptr_cell(), references_may_conflict_p(), simple_effect_to_constant_path_effects_with_pointer_values(), strict_constant_path_p(), struct_assignment_to_points_to(), and variable_to_abstract_location().

Here is the caller graph for this function:

◆ entity_all_dynamic_locations()

entity entity_all_dynamic_locations ( void )

return ANY_MODULE:DYNAMIC

Definition at line 585 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations(DYNAMIC_AREA_LOCAL_NAME);
 }

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_xxx_locations().

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_dynamic_locations_p()

bool entity_all_dynamic_locations_p ( entity e )

test if an entity is the set of all dynamic locations

Definition at line 591 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_p(e, DYNAMIC_AREA_LOCAL_NAME);
 }

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_xxx_locations_p().

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_heap_locations()

entity entity_all_heap_locations ( void )

return ANY_MODULE:HEAP

FI->AM: I move it to ANY_MODULE:HEAP**ANYWHERE

Not compatible with entity_all_locations_p()...

Definition at line 494 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations(HEAP_AREA_LOCAL_NAME ANYWHERE_LOCATION);
 }

References ANYWHERE_LOCATION, entity_all_xxx_locations(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_heap_locations_p()

bool entity_all_heap_locations_p ( entity e )

test if an entity is the set of all heap locations

We look for "*ANY_MODULE*:*HEAP**ANYWHERE*"... unless it is "foo:*HEAP**ANYWHERE*"

FI->AM: this is not compatible with the entity name ANY-MODULE:HEAP

Definition at line 505 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_p(e, HEAP_AREA_LOCAL_NAME);
 }

References entity_all_xxx_locations_p(), and HEAP_AREA_LOCAL_NAME.

Referenced by all_heap_locations_cell_p(), check_abstract_locations(), entity_heap_location_p(), heap_intrinsic_to_post_pv(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_heap_locations_typed()

entity entity_all_heap_locations_typed ( type t )

Definition at line 510 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_typed(HEAP_AREA_LOCAL_NAME, t);
 }

References entity_all_xxx_locations_typed(), and HEAP_AREA_LOCAL_NAME.

Referenced by malloc_type_to_abstract_location(), and reference_add_field_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_locations()

entity entity_all_locations ( void )

anywhere_abstract_locations.c

FI->aM: it was first decided to make this entity an area, but areas cannot be typed. So the internal representation must be changed to carry a type usable according to ALIAS_ACROSS_TYPES. The top of the location lattice should use overloaded as type, that is the top of the type lattice.

Size and layout are unknown

Definition at line 68 of file anywhere_abstract_locations.c.

 {
   entity anywhere = entity_undefined;
   static const char any_name[] =
     ANY_MODULE_NAME MODULE_SEP_STRING  ANYWHERE_LOCATION;
   anywhere = gen_find_tabulated(any_name, entity_domain);
   if(entity_undefined_p(anywhere)) {
     area a = make_area(0,NIL); /* Size and layout are unknown */
     type t = make_type_area(a);
     anywhere = make_entity(strdup(any_name),
                            t,
                            make_storage_rom(),
                            make_value_unknown());
     entity_kind(anywhere)=ABSTRACT_LOCATION;
   }
  
   return anywhere;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_domain, entity_kind, entity_undefined, entity_undefined_p, gen_find_tabulated(), make_area(), make_entity, make_storage_rom(), make_type_area(), make_value_unknown(), MODULE_SEP_STRING, NIL, and strdup().

Referenced by anywhere_effect(), check_abstract_locations(), entity_anywhere_locations(), entity_anywhere_locations_p(), entity_locations_dereference(), generic_entity_typed_anywhere_locations(), make_anywhere_anywhere_pvs(), make_anywhere_points_to_cell(), max_module(), module_initial_parameter_pv(), and points_to_anywhere_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_locations_p()

bool entity_all_locations_p ( entity e )

test if an entity is the top of the lattice

This test does not take typed anywhere into account. This is consistent with the function name, but may be not with its uses.

It is not consistent with hiding the impact of ALIASING_ACROSS_TYPES from callers.

Definition at line 100 of file anywhere_abstract_locations.c.

 {
  
   bool anywhere_p;
   anywhere_p = same_string_p(entity_local_name(e), ANYWHERE_LOCATION);
   anywhere_p = anywhere_p
     && same_string_p(entity_module_name(e), ANY_MODULE_NAME);
  
   return anywhere_p;
 }

References ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_local_name(), entity_module_name(), and same_string_p.

Referenced by anywhere_cell_p(), anywhere_reference_p(), c_convex_effects_on_formal_parameter_backward_translation(), check_abstract_locations(), effect_reference_dereferencing_p(), entities_maymust_conflict_p(), generic_anywhere_effect_p(), interference_on(), loop_variant_list(), opkill_may_name(), opkill_must_name(), pvs_union_combinable_p(), references_may_conflict_p(), simple_pv_may_union(), simple_pv_must_union(), simple_pv_translate(), strict_constant_path_p(), and TestCoupleOfReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_dynamic_locations()

entity entity_all_module_dynamic_locations ( entity m )

return m:*DYNAMIC**ANYWHERE

Definition at line 573 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations(m, DYNAMIC_AREA_LOCAL_NAME);
 }

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_module_xxx_locations().

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_dynamic_locations_p()

bool entity_all_module_dynamic_locations_p ( entity e )

test if an entity is the a dynamic area

Definition at line 579 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations_p(e, DYNAMIC_AREA_LOCAL_NAME);
 }

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_module_xxx_locations_p().

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_heap_locations()

entity entity_all_module_heap_locations ( entity m )

return m:*HEAP**ANYWHERE

Definition at line 471 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations(m, HEAP_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_heap_locations_p()

bool entity_all_module_heap_locations_p ( entity e )

test if an entity is the a heap area

Definition at line 483 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations_p(e, HEAP_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations_p(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), entity_heap_location_p(), heap_intrinsic_to_post_pv(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_heap_locations_typed()

entity entity_all_module_heap_locations_typed	(	entity	m,
		type	t
	)

Definition at line 476 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations_typed(entity_local_name(m),
                                                HEAP_AREA_LOCAL_NAME, t);
 }

References entity_all_module_xxx_locations_typed(), entity_local_name(), and HEAP_AREA_LOCAL_NAME.

Referenced by malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_locations()

entity entity_all_module_locations ( entity m )

return m:ANYWHERE Set of all memory locations related to one module.

FI: This may prove useless unless the compilation unit is taken into account.

Size and layout are unknown

FI: any_name?

Definition at line 265 of file anywhere_abstract_locations.c.

 {
   entity anywhere = entity_undefined;
   const char* mn = entity_local_name(m);
  
   anywhere = FindEntity(mn,ANYWHERE_LOCATION);
   if(entity_undefined_p(anywhere)) {
     area a = make_area(0,NIL); /* Size and layout are unknown */
     type t = make_type_area(a);
     /* FI: any_name? */
     anywhere = CreateEntity(mn,ANYWHERE_LOCATION);
     entity_type(anywhere)=t;
     entity_storage(anywhere)=make_storage_rom();
     entity_initial(anywhere)=make_value_unknown();
     entity_kind(anywhere)=ABSTRACT_LOCATION;
   }
  
   return anywhere;
 }

References ABSTRACT_LOCATION, ANYWHERE_LOCATION, CreateEntity(), entity_initial, entity_kind, entity_local_name(), entity_storage, entity_type, entity_undefined, entity_undefined_p, FindEntity(), make_area(), make_storage_rom(), make_type_area(), make_value_unknown(), and NIL.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_locations_p()

bool entity_all_module_locations_p ( entity e )

test if an entity is the set of locations defined in a module

Definition at line 286 of file anywhere_abstract_locations.c.

 {
  
   bool all_module_p;
   all_module_p = same_string_p(entity_local_name(e), ANYWHERE_LOCATION);
  
   return all_module_p;
 }

References ANYWHERE_LOCATION, entity_local_name(), and same_string_p.

Referenced by apply_abstract_effect_to_transformer(), check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_stack_locations()

entity entity_all_module_stack_locations ( entity m )

return m:*STACK**ANYWHERE

Definition at line 523 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations(m, STACK_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_stack_locations_p()

bool entity_all_module_stack_locations_p ( entity e )

test if an entity is the a stack area

Definition at line 529 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations_p(e, STACK_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations_p(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_static_locations()

entity entity_all_module_static_locations ( entity m )

return m:*DYNAMIC**ANYWHERE

Definition at line 548 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations(m, STATIC_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_static_locations_p()

bool entity_all_module_static_locations_p ( entity e )

test if an entity is the a static area

Definition at line 554 of file anywhere_abstract_locations.c.

 {
   return entity_all_module_xxx_locations_p(e, STATIC_AREA_LOCAL_NAME);
 }

References entity_all_module_xxx_locations_p(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_xxx_locations()

entity entity_all_module_xxx_locations	(	entity	m,
		const char *	xxx
	)

return m:xxx*ANYWHERE* Generic set of functions for all kinds of areas

Size and layout are unknown

I: more work to be done here...

Parameters

xxx xx

Definition at line 299 of file anywhere_abstract_locations.c.

 {
   entity dynamic = entity_undefined;
   string any_name;
   asprintf(&any_name, "%s" ANYWHERE_LOCATION, xxx);
  
   //dynamic = gen_find_tabulated(any_name, entity_domain);
   dynamic = FindOrCreateEntity(entity_local_name(m), any_name);
   if(storage_undefined_p(entity_storage(dynamic))) {
     area a = make_area(0,NIL); /* Size and layout are unknown */
     type t = make_type_area(a);
     /*FI: more work to be done here... */
     entity_type(dynamic) = t;
     entity_storage(dynamic) = make_storage_rom();
     entity_initial(dynamic) = make_value_unknown();
     entity_kind(dynamic)=ABSTRACT_LOCATION;
   }
   free(any_name);
  
   return dynamic;
 }

References ABSTRACT_LOCATION, ANYWHERE_LOCATION, asprintf, entity_initial, entity_kind, entity_local_name(), entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), free(), make_area(), make_storage_rom(), make_type_area(), make_value_unknown(), NIL, and storage_undefined_p.

Referenced by entity_all_module_dynamic_locations(), entity_all_module_heap_locations(), entity_all_module_stack_locations(), entity_all_module_static_locations(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_xxx_locations_p()

bool entity_all_module_xxx_locations_p	(	entity	e,
		string	xxx
	)

test if an entity is the set of all memory locations in the xxx area of a module.

The module is not checked, so it can be the set of all modules...

Parameters

xxx xx

Definition at line 366 of file anywhere_abstract_locations.c.

 {
   bool dynamic_p;
   string s = concatenate(xxx, ANYWHERE_LOCATION, NULL);
  
   pips_assert("e is defined", !entity_undefined_p(e));
  
   dynamic_p = same_string_p(entity_local_name(e), s);
  
   return dynamic_p;
 }

References ANYWHERE_LOCATION, concatenate(), entity_local_name(), entity_undefined_p, pips_assert, and same_string_p.

Referenced by entity_all_module_dynamic_locations_p(), entity_all_module_heap_locations_p(), entity_all_module_stack_locations_p(), and entity_all_module_static_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_module_xxx_locations_typed()

entity entity_all_module_xxx_locations_typed	(	const char *	mn,
		const char *	xxx,
		type	t
	)

A new entity has been created

I: more work to be done here...

no aliasing

Parameters

mn	n
xxx	xx

Definition at line 321 of file anywhere_abstract_locations.c.

 {
   entity e = entity_undefined;
   int count = 0;
   bool found_p = false; // a break could be used instead
  
   pips_assert("Type t is defined", !type_undefined_p(t));
  
   for(count = 0; !found_p; count++) {
  
     type ot = type_undefined;
     char * local_name;
  
     asprintf(&local_name, "%s_b%d", xxx,count);
     e = FindOrCreateEntity(mn,local_name);
     free(local_name);
     ot = entity_type(e);
     if(type_undefined_p(ot)) {
       /* A new entity has been created */
       //area a = make_area(0,NIL); /* Size and layout are unknown */
       //type t = make_type_area(a);
       /*FI: more work to be done here... */
       entity_type(e) = copy_type(t); /* no aliasing */
       entity_storage(e) = make_storage_rom();
       entity_initial(e) = make_value_unknown();
       found_p = true;
  
     }
     else if(type_equal_p(t, ot))
       found_p = true;
   }
  
   // FI: the debug message should be improved with full information
   // about the type... See get_symbol_table() and isolate the code
   // used to prettyprint the type. Too bad it uses the buffer type...
   pips_debug(8, "New abstract location entity \"%s\" found or created"
              " with type \"%s\"\n", entity_name(e), type_to_string(t));
  
   return e;
 }

References asprintf, copy_type(), count, entity_initial, entity_name, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), free(), local_name(), make_storage_rom(), make_value_unknown(), pips_assert, pips_debug, type_equal_p(), type_to_string(), type_undefined, and type_undefined_p.

Referenced by entity_all_module_heap_locations_typed(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_stack_locations()

entity entity_all_stack_locations ( void )

return ANY_MODULE:STACK

Definition at line 535 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations(STACK_AREA_LOCAL_NAME);
 }

References entity_all_xxx_locations(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_stack_locations_p()

bool entity_all_stack_locations_p ( entity e )

test if an entity is the set of all stack locations

Definition at line 541 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_p(e, STACK_AREA_LOCAL_NAME);
 }

References entity_all_xxx_locations_p(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_static_locations()

entity entity_all_static_locations ( void )

return ANY_MODULE:STATIC

Definition at line 560 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations(STATIC_AREA_LOCAL_NAME);
 }

References entity_all_xxx_locations(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_static_locations_p()

bool entity_all_static_locations_p ( entity e )

test if an entity is the set of all static locations

Definition at line 566 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_p(e, STATIC_AREA_LOCAL_NAME);
 }

References entity_all_xxx_locations_p(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_xxx_locations()

entity entity_all_xxx_locations ( string xxx )

return ANY_MODULE:xxx

I: more work to be done here...

FI: I'd like to make the type variable, overloaded,...

Parameters

xxx xx

Definition at line 379 of file anywhere_abstract_locations.c.

 {
   entity dynamic = entity_undefined;
   dynamic = FindOrCreateEntity(ANY_MODULE_NAME,xxx);
  
   if(type_undefined_p(entity_type(dynamic))) {
     //area a = make_area(0,NIL); /* Size and layout are unknown */
     //type t = make_type_area(a);
     /*FI: more work to be done here... */
     /* FI: I'd like to make the type variable, overloaded,... */
     // entity_type(dynamic) = make_type_unknown();
     basic b = make_basic_overloaded();
     variable v = make_variable(b, NIL, NIL);
     entity_type(dynamic) = make_type_variable(v);
     entity_storage(dynamic) = make_storage_rom();
     entity_initial(dynamic) = make_value_unknown();
     entity_kind(dynamic)=ABSTRACT_LOCATION;
     if(same_string_p(xxx,HEAP_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_HEAP_AREA;
     else if(same_string_p(xxx,STACK_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_STACK_AREA;
     else if(same_string_p(xxx,STATIC_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_STATIC_AREA;
     else if(same_string_p(xxx,DYNAMIC_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_DYNAMIC_AREA;
   }
  
   return dynamic;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, DYNAMIC_AREA_LOCAL_NAME, ENTITY_DYNAMIC_AREA, ENTITY_HEAP_AREA, entity_initial, entity_kind, ENTITY_STACK_AREA, ENTITY_STATIC_AREA, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), HEAP_AREA_LOCAL_NAME, make_basic_overloaded(), make_storage_rom(), make_type_variable(), make_value_unknown(), make_variable(), NIL, same_string_p, STACK_AREA_LOCAL_NAME, STATIC_AREA_LOCAL_NAME, and type_undefined_p.

Referenced by application_to_points_to_sinks(), entity_all_dynamic_locations(), entity_all_heap_locations(), entity_all_stack_locations(), entity_all_static_locations(), make_anywhere_reference(), make_nowhere_cell(), points_to_anywhere(), and user_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_xxx_locations_p()

bool entity_all_xxx_locations_p	(	entity	e,
		string	xxx
	)

test if an entity is the set of all memory locations in the xxx area of any module.

FI->AM: how come w generate HEAP and we check HEAP**ANYWHERE?

Parameters

xxx xx

Definition at line 456 of file anywhere_abstract_locations.c.

 {
   bool dynamic_p;
   string s = concatenate(xxx, ANYWHERE_LOCATION, NULL);
  
   dynamic_p = same_string_p(entity_local_name(e), s);
   dynamic_p = dynamic_p
     && same_string_p(entity_module_name(e), ANY_MODULE_NAME);
  
   return dynamic_p;
 }

References ANY_MODULE_NAME, ANYWHERE_LOCATION, concatenate(), entity_local_name(), entity_module_name(), and same_string_p.

Referenced by entity_all_dynamic_locations_p(), entity_all_heap_locations_p(), entity_all_stack_locations_p(), and entity_all_static_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_all_xxx_locations_typed()

entity entity_all_xxx_locations_typed	(	string	xxx,
		type	t
	)

FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing...

A new entity has been created

I: more work to be done here...

Parameters

xxx xx

Definition at line 406 of file anywhere_abstract_locations.c.

 {
   entity e = entity_undefined;
   int count = 0;
   bool found_p = false; // a break could be used instead
  
   pips_assert("Type t is defined", !type_undefined_p(t));
   pips_assert("Type t is not functional", !type_functional_p(t));
  
   for(count = 0; !found_p; count++) {
     string name = string_undefined;
     type ot = type_undefined;
  
     asprintf(&name, "%s_b%d", xxx, count);
     e = FindOrCreateEntity(ANY_MODULE_NAME, name);
     free(name);
     ot = entity_type(e);
     if(type_undefined_p(ot)) {
       /* A new entity has been created */
       //area a = make_area(0,NIL); /* Size and layout are unknown */
       //type t = make_type_area(a);
       /*FI: more work to be done here... */
       entity_type(e) = copy_type(t);
       entity_storage(e) = make_storage_rom();
       entity_initial(e) = make_value_unknown();
       entity_kind(e) = ABSTRACT_LOCATION;
       found_p = true;
     }
     else if(type_equal_p(t, ot)) // FI: do we want to relax this test?
       found_p = true;
   }
  
   // FI: the debug message should be improved with full information
   // about the type... See get_symbol_table() and isolate the code
   // used to prettyprint the type. Too bad it uses the buffer type...
   ifdebug(8) {
     pips_debug(8, "New abstract location entity \"%s\" found or created"
                " with type ", entity_name(e));
     print_type(t);
     fprintf(stderr, "\n");
   }
  
   return e;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, asprintf, copy_type(), count, entity_initial, entity_kind, entity_name, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), fprintf(), free(), ifdebug, make_storage_rom(), make_value_unknown(), pips_assert, pips_debug, print_type(), string_undefined, type_equal_p(), type_functional_p, type_undefined, and type_undefined_p.

Referenced by application_to_points_to_sinks(), entity_all_heap_locations_typed(), entity_typed_anywhere_locations(), entity_typed_nowhere_locations(), generic_entity_typed_anywhere_locations(), make_anywhere_points_to_cell(), make_anywhere_reference(), make_typed_nowhere_cell(), points_to_anywhere_typed(), and user_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_anywhere_locations()

entity entity_anywhere_locations ( void )

Definition at line 87 of file anywhere_abstract_locations.c.

 {
   return entity_all_locations();
 }

References entity_all_locations().

Referenced by abstract_locations_max(), anywhere_source_to_sinks(), remove_arcs_from_pt_map(), and source_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_anywhere_locations_p()

bool entity_anywhere_locations_p ( entity e )

test if an entity is the bottom of the lattice

Definition at line 127 of file anywhere_abstract_locations.c.

 {
     return same_entity_p(e, entity_all_locations());
 }

References entity_all_locations(), and same_entity_p().

Referenced by entities_maymust_conflict_p(), generic_atomic_points_to_reference_p(), module_to_value_mappings(), points_to_cell_translation(), reference_add_field_dimension(), semantics_usable_points_to_reference_p(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_flow_or_context_sentitive_heap_location()

entity entity_flow_or_context_sentitive_heap_location	(	int	stmt_number,
		type	t
	)

FI: Beware, the symbol table is updated but this is not reflected in pipsmake.rc

We need to keep track of these pseudo-variables to destroy them before a module is reanalyzed after a code transformation, for instance a constant propagation that changed dependent types into cosntant types.

We might be in trouble, unless a piece of code is reanalyzed. Let's assume the type is unchanged

Parameters

stmt_number tmt_number

Definition at line 78 of file abstract_location.c.

 {
   entity e;
   string s;
   asprintf(&s, HEAP_AREA_LOCAL_NAME "_l_%d", stmt_number);
  
   e = FindOrCreateEntity(get_current_module_name(),s);
   free(s);
   if(type_undefined_p(entity_type(e))) {
     entity f = get_current_module_entity();
     entity a = module_to_heap_area(f);
     //ram r = make_ram(f, a, UNKNOWN_RAM_OFFSET, NIL);
     ram r = make_ram(f, a, DYNAMIC_RAM_OFFSET, NIL);
  
     /* FI: Beware, the symbol table is updated but this is not
        reflected in pipsmake.rc */
     type ct = compute_basic_concrete_type(t);
     entity_type(e) = copy_type(ct);
     entity_storage(e) = make_storage_ram(r);
     entity_initial(e) = make_value_unknown();
     entity_kind(e) = ABSTRACT_LOCATION;
     (void) add_C_variable_to_area(a, e);
     /* We need to keep track of these pseudo-variables to destroy them
        before a module is reanalyzed after a code transformation, for
        instance a constant propagation that changed dependent types
        into cosntant types. */
     AddEntityToDeclarations(e, f);
   }
   else {
     /* We might be in trouble, unless a piece of code is
        reanalyzed. Let's assume the type is unchanged */
     type ct = compute_basic_concrete_type(t);
     type et = entity_type(e);
     // FI: too strong if 1-D arrays and pointers can be assimilated
     //pips_assert("The type is unchanged",
     // type_equal_p(ct, et));
     if(!type_equal_p(ct,et)) {
       // FI: this might be improvable with array_pointer_type_equal_p
       if(pointer_type_p(ct) && array_type_p(et)) {
         type pt = type_to_pointed_type(ct);
         basic pb = variable_basic(type_variable(pt));
         variable etv = type_variable(et);
         basic eb = variable_basic(etv);
         int d = (int) gen_length(variable_dimensions(etv));
         if(d==1 && basic_equal_p(pb, eb)) 
           ;
         else
           pips_assert("The type is unchanged or compatible", false);
       }
       else if(pointer_type_p(et) && array_type_p(ct)) {
         type pt = type_to_pointed_type(et);
         basic pb = variable_basic(type_variable(pt));
         variable etv = type_variable(ct);
         basic eb = variable_basic(etv);
         int d = (int) gen_length(variable_dimensions(etv));
         if(d==1 && basic_equal_p(pb, eb)) 
           ;
         else
           pips_assert("The type is unchanged or compatible", false);
       }
       else
         pips_assert("The type is unchanged or compatible", false);
     }
     free_type(ct);
   }
   return e;
  
 }

References ABSTRACT_LOCATION, add_C_variable_to_area(), AddEntityToDeclarations(), array_type_p(), asprintf, basic_equal_p(), compute_basic_concrete_type(), copy_type(), DYNAMIC_RAM_OFFSET, entity_initial, entity_kind, entity_storage, entity_type, f(), FindOrCreateEntity(), free(), free_type(), gen_length(), get_current_module_entity(), get_current_module_name(), HEAP_AREA_LOCAL_NAME, int, make_ram(), make_storage_ram(), make_value_unknown(), module_to_heap_area(), NIL, pips_assert, pointer_type_p(), type_equal_p(), type_to_pointed_type(), type_undefined_p, type_variable, variable_basic, and variable_dimensions.

Referenced by malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_flow_or_context_sentitive_heap_location_p()

bool entity_flow_or_context_sentitive_heap_location_p ( entity e )

Definition at line 147 of file abstract_location.c.

 {
   bool result = false;
   const char* ln = entity_local_name(e);
   string found = strstr(ln, ANYWHERE_LOCATION);
  
   pips_debug(9, "input entity: %s\n", ln);
   pips_debug(9, "found (1) = : %s\n", found);
  
   if (found == NULL)
     {
       found = strstr(ln, HEAP_AREA_LOCAL_NAME);
       pips_debug(9, "found (2) = : %s\n", found);
       if (found!=NULL)
         {
           size_t found_n = strspn(found, HEAP_AREA_LOCAL_NAME);
           ln = &found[found_n];
           pips_debug(9, "ln : %s\n", ln);
           found = strstr(ln, "_l_");
           pips_debug(9, "found (3) = : %s\n", found);
           result = (found != NULL);
         }
       else
         result = false;
     }
   else
     result = false;
   pips_debug(9, "result = %d\n", (int) result);
   return result;
 }

References ANYWHERE_LOCATION, entity_local_name(), HEAP_AREA_LOCAL_NAME, and pips_debug.

Referenced by convex_cells_inclusion_p(), convex_cells_intersection_p(), free_to_post_pv(), generic_transform_sink_cells_from_matching_list(), references_may_conflict_p(), 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:

◆ entity_heap_location_p()

bool entity_heap_location_p ( entity b )

abstract_location.c

Amira Mensi 2010

File: abstract_location.c

This file contains various useful functions to modelize a heap. check if an entity b may represent a bucket or a set of buckets in the heap.

Definition at line 64 of file abstract_location.c.

 {
   bool bucket_p = entity_all_heap_locations_p(b) ||
     entity_all_module_heap_locations_p(b);
  
   if(!heap_area_p(b) && !bucket_p) {
       const char* ln = entity_local_name(b);
       const char* found = strstr(ln, HEAP_AREA_LOCAL_NAME);
       bucket_p = found != NULL;
   }
  
   return bucket_p;
 }

References entity_all_heap_locations_p(), entity_all_module_heap_locations_p(), entity_local_name(), HEAP_AREA_LOCAL_NAME, and heap_area_p().

Referenced by analyzable_scalar_entity_p(), cell_out_of_scope_p(), cells_to_read_or_write_effects(), clean_up_points_to_stubs(), generic_atomic_points_to_reference_p(), generic_eval_cell_with_points_to(), generic_remove_unreachable_vertices_in_points_to_graph(), module_to_value_mappings(), points_to_reference_to_typed_index(), and semantics_usable_points_to_reference_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_locations_dereference()

entity entity_locations_dereference ( entity )

◆ entity_locations_max()

entity entity_locations_max	(	entity	al1,
		entity	al2
	)

Here, entity al1 and entity al2 can be program variables.

Both al1 and al2 are abstract locations and they are different

al1 and al2 are assumed to be variables

Parameters

al1	l1
al2	l2

Definition at line 829 of file anywhere_abstract_locations.c.

 {
   entity e = entity_undefined;
   //string ln1 = entity_local_name(al1);
   //string ln2 = entity_local_name(al2);
  
   if(al1==al2) {
     e = al1;
   }
   else {
     bool al1_abstract_location_p = entity_abstract_location_p(al1);
     bool al2_abstract_location_p = entity_abstract_location_p(al2);
     if(al1_abstract_location_p )
       if(al2_abstract_location_p ) {
         /* Both al1 and al2 are abstract locations and they are
            different */
         e = abstract_locations_max(al1, al2);
       }
       else {
         entity al = variable_to_abstract_location(al2);
         e = abstract_locations_max(al1, al);
       }
     else
       if(al2_abstract_location_p) {
         entity al = variable_to_abstract_location(al1);
         e = abstract_locations_max(al, al2);
       }
       else {
         /* al1 and al2 are assumed to be variables */
         storage s1 = entity_storage(al1);
         storage s2 = entity_storage(al2);
  
         if(storage_ram_p(s1) && storage_ram_p(s2)) {
           ram r1 = storage_ram(s1);
           ram r2 = storage_ram(s2);
           entity f1 = ram_function(r1);
           entity f2 = ram_function(r2);
           entity a1 = ram_section(r1);
           entity a2 = ram_section(r2);
           const char* mn ;
           const char* ln ;
  
           if(f1==f2)
             mn = entity_local_name(f1);
           else
             mn = ANY_MODULE_NAME;
  
           if(static_area_p(a1) && static_area_p(a2))
             ln = STATIC_AREA_LOCAL_NAME;
           else if(dynamic_area_p(a1) && dynamic_area_p(a2))
             ln = DYNAMIC_AREA_LOCAL_NAME;
           else if(stack_area_p(a1) && stack_area_p(a2))
             ln = STACK_AREA_LOCAL_NAME;
           else if(heap_area_p(a1) && heap_area_p(a2))
             ln = HEAP_AREA_LOCAL_NAME;
           else
             ln = ANYWHERE_LOCATION;
           e = FindEntity(mn, ln);
         }
         else
           pips_internal_error("not implemented");
       }
   }
   return e;
 }

References abstract_locations_max(), ANY_MODULE_NAME, ANYWHERE_LOCATION, DYNAMIC_AREA_LOCAL_NAME, dynamic_area_p(), entity_abstract_location_p(), entity_local_name(), entity_storage, entity_undefined, f2(), FindEntity(), HEAP_AREA_LOCAL_NAME, heap_area_p(), pips_internal_error, ram_function, ram_section, s1, STACK_AREA_LOCAL_NAME, stack_area_p(), STATIC_AREA_LOCAL_NAME, static_area_p(), storage_ram, storage_ram_p, and variable_to_abstract_location().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_nowhere_locations()

entity entity_nowhere_locations ( void )

return ANY_MODULE:NOWHERE

Size and layout are unknown

Definition at line 174 of file anywhere_abstract_locations.c.

 {
   static entity nowhere = entity_undefined;
   static const char any_name [] = ANY_MODULE_NAME MODULE_SEP_STRING NOWHERE_LOCATION ;
   nowhere = gen_find_tabulated(any_name, entity_domain);
   if(entity_undefined_p(nowhere)) {
       area a = make_area(0,NIL); /* Size and layout are unknown */
       type t = make_type_area(a);
       nowhere = make_entity(strdup(any_name),
               t, make_storage_rom(), make_value_unknown());
       entity_kind(nowhere)=ABSTRACT_LOCATION;
       register_static_entity(&nowhere);
   }
  
    return nowhere;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, entity_domain, entity_kind, entity_undefined, entity_undefined_p, gen_find_tabulated(), make_area(), make_entity, make_storage_rom(), make_type_area(), make_value_unknown(), MODULE_SEP_STRING, NIL, NOWHERE_LOCATION, register_static_entity(), and strdup().

Referenced by check_abstract_locations(), and entity_nowhere_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_nowhere_locations_p()

bool entity_nowhere_locations_p ( entity e )

test if an entity is the bottom of the lattice

Should we care for the typed nowhere too?

Definition at line 200 of file anywhere_abstract_locations.c.

 {
     return same_entity_p(e,entity_nowhere_locations());
 }

References entity_nowhere_locations(), and same_entity_p().

Referenced by check_abstract_locations(), gen_may_set(), gen_must_set(), opkill_may_name(), opkill_must_name(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_null_locations()

entity entity_null_locations ( void )

return TOP-LEVEL:NULL_POINTER The NULL pointer should be a global variable, unique for all modules FI: why isn't it called entity_null_location()?

Since NULL is a constant, it should be declared as a function. But then it cold not be used in a reference for the points-to analysis. Too bad for the semantics analysis of pointers were a constant 0-ary function would make more sense.

Size and layout are unknown

Definition at line 223 of file anywhere_abstract_locations.c.

 {
   static entity null_pointer = entity_undefined;
   if(entity_undefined_p(null_pointer)) {
     if(true) {
       const char null_name [] = TOP_LEVEL_MODULE_NAME MODULE_SEP_STRING NULL_POINTER_NAME;
       area a = make_area(0,NIL); /* Size and layout are unknown */
       type t = make_type_area(a);
       null_pointer = make_entity(strdup(null_name),
                                  t, make_storage_rom(), make_value_unknown());
       // FI: I do not see why NULL should be an abstract location; it
       // does not represent a set of locations, but a unique one
       // entity_kind(null_pointer) = ABSTRACT_LOCATION;
       entity_kind(null_pointer) = DEFAULT_ENTITY_KIND;
     }
     else {
       entity null_pointer = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,
                                                NULL_POINTER_NAME);
       type rt = type_to_pointer_type(make_type_void(NIL));
       type ft = make_type_functional(make_functional(NIL, copy_type(rt)));
       entity_type(null_pointer) = ft;
       entity_storage(null_pointer) = make_storage_rom();
       entity_initial(null_pointer) = make_value_constant(make_constant_int(0));
     }
     register_static_entity(&null_pointer);
   }
  
   return null_pointer;
 }

References copy_type(), DEFAULT_ENTITY_KIND, entity_initial, entity_kind, entity_storage, entity_type, entity_undefined, entity_undefined_p, FindOrCreateEntity(), make_area(), make_constant_int(), make_entity, make_functional(), make_storage_rom(), make_type_area(), make_type_functional(), make_type_void(), make_value_constant(), make_value_unknown(), MODULE_SEP_STRING, NIL, NULL_POINTER_NAME, register_static_entity(), strdup(), TOP_LEVEL_MODULE_NAME, and type_to_pointer_type().

Referenced by check_abstract_locations(), entity_null_locations_p(), make_null_cell(), null_pointer_value_entity(), and points_to_null_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_null_locations_p()

bool entity_null_locations_p ( entity e )

test if an entity is the NULL POINTER

Definition at line 254 of file anywhere_abstract_locations.c.

 {
     return same_entity_p(e,entity_null_locations());
 }

References entity_null_locations(), and same_entity_p().

Referenced by any_basic_update_to_transformer(), any_update_to_transformer(), atomic_constant_path_p(), check_abstract_locations(), entities_maymust_conflict_p(), gen_may_set(), gen_must_set(), generic_atomic_points_to_reference_p(), generic_transform_sink_cells_from_matching_list(), null_cell_p(), null_pointer_value_entity_p(), opkill_may_name(), opkill_must_name(), points_to_unary_operation_to_transformer(), reference_add_field_dimension(), references_may_conflict_p(), semantics_usable_points_to_reference_p(), strict_constant_path_p(), transformer_internal_consistency_p(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_stub_sink_p()

bool entity_stub_sink_p ( entity e )

test if an entity is a stub sink for a formal parameter e.g.

f->_f_1, EXACT

Definition at line 599 of file anywhere_abstract_locations.c.

 {
   bool stub_sink_p = false;
   bool dummy_target_p = false;
   const char * en = entity_local_name(e);
   storage s = entity_storage(e);
   if(storage_ram_p(s)) {
     // dummy_target_p = pointer_dummy_targets_area_p(ram_section(storage_ram(s)));
     dummy_target_p = formal_area_p(ram_section(storage_ram(s)));
   }
   char first = en[0];
   //char penultimate = en[strlen(en) - 2];
   int l = strlen(en);
   if(dummy_target_p && first == '_') {
     int i = 1;
     while('0' <=en[l-i] && en[l-i]<='9') {
       i++;
     }
     if(i>=2 && en[l-i]=='_')
       stub_sink_p = true;
   }
  
   return stub_sink_p;
 }

References entity_local_name(), entity_storage, formal_area_p(), ram_section, storage_ram, and storage_ram_p.

Referenced by cell_out_of_scope_p(), create_stub_entity(), expand_points_to_domain(), generic_atomic_points_to_reference_p(), generic_points_to_set_to_stub_cell_list(), generic_remove_unreachable_vertices_in_points_to_graph(), generic_transformer_to_analyzed_locations(), reference_to_points_to(), source_to_sinks(), strict_constant_path_p(), stub_entity_of_module_p(), stub_points_to_cell_p(), subscript_to_points_to_sinks(), and transformer_general_consistency_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_typed_anywhere_locations()

entity entity_typed_anywhere_locations ( type t )

Definition at line 111 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t);
 }

References ANYWHERE_LOCATION, and entity_all_xxx_locations_typed().

Referenced by abstract_locations_max(), binary_intrinsic_call_to_points_to_sinks(), cells_to_read_or_write_effects(), points_to_anywhere_sinks(), and reference_add_field_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_typed_anywhere_locations_p()

bool entity_typed_anywhere_locations_p ( entity e )

Test if an entity is the bottom of the lattice.

Not really since it is typed...

The typed anywhere locations have names like ANYWHERE_LOCATION_bxxx

Beware, because the string ANYWHERE_LOCATION is also used for the heap, HEAP**ANYWHERE.

Also, this does not check for the module: is it ANYMODULE or a specific module?

Definition at line 160 of file anywhere_abstract_locations.c.

 {
   bool typed_anywhere_p = false;
   string ln = (string) entity_local_name(e);
   string p = strstr(ln, ANYWHERE_LOCATION);
   if(p==ln) {
     // if the two strings are equal, we have the non-typed anywhere location
     typed_anywhere_p = strcmp(ln, ANYWHERE_LOCATION);
   }
   return typed_anywhere_p;
 }

References ANYWHERE_LOCATION, and entity_local_name().

Referenced by analyzable_scalar_entity_p(), cells_to_read_or_write_effects(), effect_reference_dereferencing_p(), generic_anywhere_effect_p(), generic_atomic_points_to_reference_p(), module_to_value_mappings(), points_to_cell_translation(), reference_add_field_dimension(), reference_typed_anywhere_locations_p(), semantics_usable_points_to_reference_p(), source_to_sinks(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entity_typed_nowhere_locations()

entity entity_typed_nowhere_locations ( type t )

Definition at line 191 of file anywhere_abstract_locations.c.

 {
   return entity_all_xxx_locations_typed(NOWHERE_LOCATION, t);
 }

References entity_all_xxx_locations_typed(), and NOWHERE_LOCATION.

Here is the call graph for this function:

◆ entity_typed_nowhere_locations_p()

bool entity_typed_nowhere_locations_p ( entity e )

test if an entity is the bottom of the lattice

Definition at line 206 of file anywhere_abstract_locations.c.

 {
   string ln = (string) entity_local_name(e);
   string p = strstr(ln, NOWHERE_LOCATION);
   return p!=NULL;
 }

References entity_local_name(), and NOWHERE_LOCATION.

Referenced by any_basic_update_to_transformer(), any_update_to_transformer(), gen_may_set(), gen_must_set(), generic_atomic_points_to_reference_p(), nowhere_cell_p(), points_to_unary_operation_to_transformer(), reference_add_field_dimension(), semantics_usable_points_to_reference_p(), strict_constant_path_p(), and text_points_to_relation().

Here is the call graph for this function:

Here is the caller 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:

◆ error_reset_pt_to_list()

void error_reset_pt_to_list ( void )

◆ exact_points_to_subscript_list_p()

bool exact_points_to_subscript_list_p ( list sl )

See if the subscript list sl is precise, i.e.

if is does not contain any unbounded expression.

It is assumed that it is a points-to subscript list. Each subscript is either an integer constant, or a field reference or an unbounded expression.

This function may have been defined several times...

Parameters

sl l

Definition at line 1027 of file points_to.c.

 {
   bool exact_p = true;
   FOREACH(EXPRESSION, s, sl) {
     if(unbounded_expression_p(s)) {
       exact_p = false;
       break;
     }
   }
   return exact_p;
 }

References EXPRESSION, FOREACH, and unbounded_expression_p().

Here is the call graph for this function:

◆ field_reference_expression_p()

bool field_reference_expression_p ( expression e )

Check if expression "e" is a reference to a struct field.

Definition at line 224 of file points_to.c.

 {
   bool field_p = false;
   syntax s = expression_syntax(e);
   if(syntax_reference_p(s)) {
     reference r = syntax_reference(s);
     entity f = reference_variable(r);
     field_p = entity_field_p(f);
   }
   return field_p;
 }

References entity_field_p(), expression_syntax, f(), reference_variable, syntax_reference, and syntax_reference_p.

Referenced by points_to_array_reference_p(), points_to_array_reference_to_type(), points_to_reference_to_final_dimension(), points_to_reference_update_final_subscripts(), and reduce_cell_to_pointer_type().

Here is the call graph for this function:

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:

◆ find_points_to_subscript_for_type()

list find_points_to_subscript_for_type	(	cell	c,
		type	t
	)

Find the subscript in the reference of cell "c" that would make the reference type be "t" if the subscript list were truncated just after it.

Select the longest possible subscript list.

Core dump if it is not possible.

No smart implementation: trial and error (probably already implemented somewhere else.

Let's try to add a zero subscript instead...

For the time being, no need to restore the reference in case of failure.

Definition at line 1274 of file type.c.

 {
   list csl = list_undefined;
   reference r = cell_any_reference(c);
   entity v = reference_variable(r);
   type rt = points_to_reference_to_concrete_type(r); // reference type
   list sl = reference_indices(r); // subscript list
   list rsl = gen_nreverse(sl); // temporary side-effect on "r" (and "c")
   list crsl = rsl; // current reverse subscript list
  
   while(!array_pointer_type_equal_p(t, rt) && !ENDP(crsl)) {
     POP(crsl);
     list nsl = gen_copy_seq(crsl);
     reference nr = make_reference(v, nsl);
     rt = points_to_reference_to_concrete_type(nr);
     reference_indices(nr) = NIL;
     free_reference(nr);
   }
  
   reference_indices(r)= gen_nreverse(rsl);
  
   if(!ENDP(crsl)) {
     csl = crsl;
   }
   else {
     if(array_pointer_type_equal_p(t, rt)) {
       // dereferencing18.c: only one element is allocated. 0 is the
       // only possible subscript;
       csl = NIL; // ==crsl
     }
     else {
       /* Let's try to add a zero subscript instead... */
       expression z = make_zero_expression();
       list nsl = CONS(EXPRESSION, z, NIL);
       /* For the time being, no need to restore the reference in case of
          failure. */
       reference_indices(r) = gen_nconc(reference_indices(r), nsl);
       rt = points_to_reference_to_concrete_type(r);
       if(array_pointer_type_equal_p(t, rt))
         csl = nsl;
       else
         pips_internal_error("Type t and reference r are incompatible.\n");
     }
   }
  
   return csl;
 }

References array_pointer_type_equal_p(), cell_any_reference(), CONS, ENDP, EXPRESSION, free_reference(), gen_copy_seq(), gen_nconc(), gen_nreverse(), list_undefined, make_reference(), make_zero_expression(), NIL, pips_internal_error, points_to_reference_to_concrete_type(), POP, reference_indices, and reference_variable.

Referenced by offset_points_to_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ formal_parameter_points_to_cell_p()

bool formal_parameter_points_to_cell_p ( cell c )

Definition at line 99 of file points_to.c.

 {
   bool formal_p = true;
   reference r = cell_any_reference(c);
   entity v = reference_variable(r);
   formal_p = formal_parameter_p(v);
   return formal_p;
 }

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

Referenced by points_to_to_context_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fprint_points_to_cell()

void fprint_points_to_cell	(	FILE *	,
		cell
	)

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

bool generic_atomic_points_to_cell_p	(	cell	c,
		bool	strict_p
	)

Is it a unique concrete memory location?

If strict_p, stubs are not considered atomic, as is the case in an interprocedural setting since they can be associated to several cells in the caller frame.

Else, stubs are not considered non atomic per se.

Parameters

strict_p trict_p

Definition at line 452 of file points_to.c.

 {
   reference r = cell_any_reference(c);
   bool atomic_p = null_cell_p(c)
     || generic_atomic_points_to_reference_p(r, strict_p);
  
   return atomic_p;
 }

References cell_any_reference(), generic_atomic_points_to_reference_p(), and null_cell_p().

Referenced by add_implicitly_killed_arcs_to_kill_set(), freed_list_to_points_to(), list_assignment_to_points_to(), and upgrade_approximations_in_points_to_set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generic_atomic_points_to_reference_p()

bool generic_atomic_points_to_reference_p	(	reference	r,
		bool	strict_p
	)

Is it a unique concrete memory location?

No, if it is a reference to an abstract location.

No, if the subscripts include an unbounded expression.

Very preliminary version. One of the keys to Amira Mensi's work.

More about stubs: a stub is not NULL but there is no information to know if they represent one address or a set of addresses. Unless the intraprocedural points-to analysis is performed for each combination of atomic/non-atomic stub, safety implies that stub-based references are not atomic (strict_p=true). In some other cases, you know that a stub does represent a unique location (strict_p=false).

Note: it is assumed that the reference is a points-to reference. All subscripts are constants, field references or unbounded expressions.

Note: FI, I have a probleme when calling this function from a proper effects environment. In that case, stubs might be assumed to be unique memory locations. The exactness information can be derived from the numer of targets in the matching list.

Note 2: FI, I do not understand why the type of the reference is not taken into account.

Parameters

strict_p trict_p

Definition at line 489 of file points_to.c.

 {
   bool atomic_p = false;
   entity v = reference_variable(r);
  
   if(!entity_null_locations_p(v) // FI: NULL is considered atomic
      && !entity_typed_nowhere_locations_p(v)
      && !entity_typed_anywhere_locations_p(v)
      && !entity_anywhere_locations_p(v)
      && !entity_heap_location_p(v)) {
     list sl = reference_indices(r);
     //entity v = reference_variable(r);
     if(!entity_stub_sink_p(v) || !strict_p) {
       atomic_p = true;
       FOREACH(EXPRESSION, se, sl) {
         if(unbounded_expression_p(se)) {
           atomic_p = false;
           break;
         }
         else if(expression_range_p(se)) {
           atomic_p = false;
           break;
         }
       }
     }
   }
  
   return atomic_p;
 }

References entity_anywhere_locations_p(), entity_heap_location_p(), entity_null_locations_p(), entity_stub_sink_p(), entity_typed_anywhere_locations_p(), entity_typed_nowhere_locations_p(), EXPRESSION, expression_range_p(), FOREACH, reference_indices, reference_variable, and unbounded_expression_p().

Referenced by analyzed_reference_p(), atomic_points_to_reference_p(), create_values_for_simple_effect(), generic_atomic_points_to_cell_p(), generic_transform_sink_cells_from_matching_list(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generic_entity_typed_anywhere_locations()

entity generic_entity_typed_anywhere_locations ( type t )

Definition at line 116 of file anywhere_abstract_locations.c.

 {
   entity a = entity_undefined;
   if(get_bool_property("ALIASING_ACROSS_TYPES"))
     a = entity_all_locations();
   else
     a = entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t);
   return a;
 }

References ANYWHERE_LOCATION, entity_all_locations(), entity_all_xxx_locations_typed(), entity_undefined, and get_bool_property().

Here is the call graph for this function:

◆ get_pt_to_list()

statement_points_to get_pt_to_list ( void )

Referenced by generic_points_to_analysis().

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:

◆ init_pt_to_list()

void init_pt_to_list ( void )

Referenced by generic_points_to_analysis().

Here is the caller 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:

◆ is_inferior_cell_descriptor_pvarval()

int is_inferior_cell_descriptor_pvarval	(	Pvecteur *	pvarval1,
		Pvecteur *	pvarval2
	)

weight function for Pvecteur passed as argument to sc_lexicographic_sort in prettyprint functions involving cell descriptors.

The strange argument type is required by qsort(), deep down in the calls. This function is an adaptation of is_inferior_pvarval in semantics

The constant term is given the highest weight to push constant terms at the end of the constraints and to make those easy to compare. If not, constant 0 will be handled differently from other constants. However, it would be nice to give constant terms the lowest weight to print simple constraints first...

Either I define two comparison functions, or I cheat somewhere else. Let's cheat?

Parameters

pvarval1	varval1
pvarval2	varval2

Definition at line 305 of file compare.c.

 {
     /* The constant term is given the highest weight to push constant
        terms at the end of the constraints and to make those easy
        to compare. If not, constant 0 will be handled differently from
        other constants. However, it would be nice to give constant terms
        the lowest weight to print simple constraints first...
  
        Either I define two comparison functions, or I cheat somewhere else.
        Let's cheat? */
     int is_equal = 0;
  
     if (term_cst(*pvarval1) && !term_cst(*pvarval2))
       is_equal = 1;
     else if (term_cst(*pvarval1) && term_cst(*pvarval2))
       is_equal = 0;
     else if(term_cst(*pvarval2))
       is_equal = -1;
     else if(variable_phi_p((entity) vecteur_var(*pvarval1))
             && !variable_phi_p((entity) vecteur_var(*pvarval2)))
       is_equal = -1;
     else  if(variable_phi_p((entity) vecteur_var(*pvarval2))
             && !variable_phi_p((entity) vecteur_var(*pvarval1)))
       is_equal = 1;
     else
         is_equal =
             strcmp(entity_name((entity) vecteur_var(*pvarval1)),
                    entity_name((entity) vecteur_var(*pvarval2)));
  
     return is_equal;
 }

References entity_name, term_cst, variable_phi_p, and vecteur_var.

Referenced by text_pointer_value(), and text_points_to_relation().

Here is the caller 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:

◆ load_pt_to_list()

points_to_list load_pt_to_list ( statement )

Referenced by convex_effect_to_constant_path_effects_with_points_to(), effect_to_constant_path_effects_with_points_to(), get_points_to_graph_from_statement(), and statement_to_points_to().

Here is the caller graph for this function:

◆ location_entity_of_module_p()

bool location_entity_of_module_p	(	entity	le,
		entity	m
	)

Parameters

le e

Definition at line 360 of file locations.c.

 {
   bool location_p = false;
   if(!entity_undefined_p(le)) {
     value v = entity_initial(le);
     if(!value_undefined_p(v))
       if(value_reference_p(v))
         // FI: could be checked with a pointer equality via the storage field
         location_p = strcmp(entity_module_name(le), entity_user_name(m))==0;
   }
   return location_p;
 }

References entity_initial, entity_module_name(), entity_undefined_p, entity_user_name(), value_reference_p, and value_undefined_p.

Referenced by clean_up_points_to_stubs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ location_entity_p()

bool location_entity_p ( entity le )

Parameters

le e

Definition at line 349 of file locations.c.

 {
   bool location_p = false;
   if(!entity_undefined_p(le)) {
     value v = entity_initial(le);
     if(!value_undefined_p(v))
       location_p = value_reference_p(v);
   }
   return location_p;
 }

References entity_initial, entity_undefined_p, value_reference_p, and value_undefined_p.

Referenced by entities_maymust_conflict_p(), generic_effects_maymust_read_or_write_scalar_entity_p(), generic_reference_to_transformer(), module_to_value_mappings(), points_to_cells_parameters(), transformer_formal_parameter_projection(), and value_passing_summary_transformer().

Here is the caller 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:

◆ make_address_of_pointer_value()

cell_relation make_address_of_pointer_value	(	cell	c1,
		cell	c2,
		tag	app_tag,
		descriptor	d
	)

Parameters

c1	1
c2	2
app_tag	pp_tag

Definition at line 142 of file pointer_values.c.

 {
   interpreted_cell ic1 = make_interpreted_cell(c1, make_cell_interpretation_value_of());
   interpreted_cell ic2 = make_interpreted_cell(c2, make_cell_interpretation_address_of());
   cell_relation pv = make_cell_relation(ic1, ic2, make_approximation(app_tag, UU), d);
   return(pv);
 }

References make_approximation(), make_cell_interpretation_address_of(), make_cell_interpretation_value_of(), make_cell_relation(), make_interpreted_cell(), and UU.

Referenced by make_anywhere_anywhere_pvs(), make_simple_pv_from_simple_effects(), module_initial_parameter_pv(), simple_pv_may_union(), simple_pv_must_union(), and simple_pv_translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_anywhere_cell()

cell make_anywhere_cell ( type t )

Definition at line 1028 of file anywhere_abstract_locations.c.

 {
   reference r = make_anywhere_reference(t);
   cell sc = make_cell_reference(r);
   return sc;
 }

References make_anywhere_reference(), and make_cell_reference().

Referenced by binary_intrinsic_call_to_points_to_sinks(), generic_transform_sink_cells_from_matching_list(), k_limit_points_to(), sizeofexpression_to_points_to_sinks(), source_to_sinks(), struct_assignment_to_points_to(), struct_initialization_to_points_to(), unary_intrinsic_call_to_points_to_sinks(), and use_default_sink_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_anywhere_points_to_cell()

cell make_anywhere_points_to_cell ( type t )

Function storing points to information attached to a statement.

Generate a global variable holding a statement_points_to, a mapping from statements to lists of points-to arcs. The variable is called "pt_to_list_object".

The macro also generates a set of functions used to deal with this global variables.

The functions are defined in newgen_generic_function.h:

pt_to_list_undefined_p()

reset_pt_to_list()

error_reset_pt_to_list()

set_pt_to_list(o)

get_pt_to_list()

store_pt_to_list(k, v)

update_pt_to_list(k, v)

load_pt_to_list(k)

delete_pt_to_list(k)

bound_pt_to_list_p(k)

store_or_update_pt_to_list(k, v) Functions specific to points-to analysis

Definition at line 87 of file points_to.c.

 {
   entity n = entity_undefined;
   if(get_bool_property("ALIASING_ACROSS_TYPES"))
     n = entity_all_locations();
   else
     n = entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t);
   reference r = make_reference(n, NIL);
   cell c = make_cell_reference(r);
   return c;
 }

References ANYWHERE_LOCATION, entity_all_locations(), entity_all_xxx_locations_typed(), entity_undefined, get_bool_property(), make_cell_reference(), make_reference(), and NIL.

Referenced by anywhere_source_to_sinks(), assignment_to_points_to(), gen_may_set(), gen_must_set(), list_assignment_to_points_to(), points_to_cells_minimal_upper_bound(), process_casted_sinks(), process_casted_sources(), semantics_expression_to_points_to_sinks(), and source_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_anywhere_reference()

reference make_anywhere_reference ( type t )

This function should be located somewhere in effect-util in or near abstract locations.

Definition at line 1016 of file anywhere_abstract_locations.c.

 {
   bool type_sensitive_p = !get_bool_property("ALIASING_ACROSS_TYPES");
   entity anywhere = type_sensitive_p?
     entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t)
     :
     entity_all_xxx_locations(ANYWHERE_LOCATION);
  
   reference r = make_reference(anywhere,NIL);
   return r;
 }

References ANYWHERE_LOCATION, entity_all_xxx_locations(), entity_all_xxx_locations_typed(), get_bool_property(), make_reference(), and NIL.

Referenced by binary_intrinsic_call_to_points_to_sinks(), generic_eval_cell_with_points_to(), and make_anywhere_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_location_entity()

entity make_location_entity ( reference cp )

locations.c

Add the new entity to the module declarations

Parameters

cp p

Definition at line 274 of file locations.c.

 {
   entity elhs = reference_variable(cp);
  
   type t = points_to_reference_to_concrete_type(cp);
   // Evaluation the constant subscript expressions such as a[4/2]
   reference ncp = constant_reference_to_normalized_constant_reference(cp);
   string cp_name = constant_memory_access_path_to_location_name(ncp);
  
   // Do not make the same entity twice
   entity ecp = gen_find_entity(cp_name);
   if(entity_undefined_p(ecp)) {
     ecp = make_entity(
                       strdup(cp_name),
                       copy_type(t),
                       copy_storage(entity_storage(elhs)),
                       make_value_reference(ncp));
  
     /* Add the new entity to the module declarations */
     string mn = (string) entity_module_name(elhs);
     entity m = module_name_to_entity(mn);
     value val = entity_initial(m);
     if(value_code_p(val)) {
       code c = value_code(val);
       code_declarations(c) =
         CONS(ENTITY, ecp, code_declarations(c));
     }
     else
       pips_internal_error("Module entity \"%s\" is not a module.\n",
                           entity_name(m));
   }
   else {
     free_reference(ncp);
   }
  
   // FI: if this is useful to maintain the intermediate
   // representation, then the module owning ecp should be computed. It
   // does not have to be the current module.
  
   // AddEntityToCurrentModuleWithoutDeclaration(ecp);
  
   return ecp;
 }

References code_declarations, CONS, constant_memory_access_path_to_location_name(), constant_reference_to_normalized_constant_reference(), copy_storage(), copy_type(), cp, ENTITY, entity_initial, entity_module_name(), entity_name, entity_storage, entity_undefined_p, free_reference(), gen_find_entity(), make_entity, make_value_reference(), module_name_to_entity(), pips_internal_error, points_to_reference_to_concrete_type(), reference_variable, strdup(), value_code, and value_code_p.

Referenced by add_inter_or_intraprocedural_field_entities(), add_reference_values(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_null_pointer_value_cell()

cell make_null_pointer_value_cell ( void )

Definition at line 93 of file pointer_values.c.

 {
   entity u = null_pointer_value_entity();
   return make_cell_reference(make_reference(u, NIL));
 }

References make_cell_reference(), make_reference(), NIL, and null_pointer_value_entity().

Referenced by call_to_post_pv(), expression_to_post_pv(), null_to_sinks(), pointer_formal_parameter_to_stub_points_to(), and reference_condition_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_sensitivity_information()

sensitivity_information make_sensitivity_information	(	statement	current_stmt,
		entity	current_module,
		list	enclosing_flow
	)

Parameters

current_stmt	urrent_stmt
current_module	urrent_module
enclosing_flow	nclosing_flow

Definition at line 522 of file abstract_location.c.

 {
   sensitivity_information si;
   si.current_stmt = current_stmt;
   si.current_module = current_module;
   si.enclosing_flow = enclosing_flow;
   return si;
 }

References sensitivity_information::current_module, current_module, current_stmt, sensitivity_information::current_stmt, and sensitivity_information::enclosing_flow.

Referenced by flow_sensitive_malloc_to_points_to_sinks(), heap_intrinsic_to_post_pv(), and original_malloc_to_abstract_location().

Here is the caller graph for this function:

◆ make_undefined_pointer_value_cell()

cell make_undefined_pointer_value_cell ( void )

Definition at line 62 of file pointer_values.c.

 {
   entity u = undefined_pointer_value_entity();
   return make_cell_reference(make_reference(u, NIL));
 }

References make_cell_reference(), make_reference(), NIL, and undefined_pointer_value_entity().

Referenced by expression_to_post_pv(), free_to_post_pv(), make_simple_pv_from_simple_effects(), and pointer_values_remove_var().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_value_of_pointer_value()

cell_relation make_value_of_pointer_value	(	cell	c1,
		cell	c2,
		tag	app_tag,
		descriptor	d
	)

Parameters

c1	1
c2	2
app_tag	pp_tag

Definition at line 129 of file pointer_values.c.

 {
   interpreted_cell ic1 = make_interpreted_cell(c1, make_cell_interpretation_value_of());
   interpreted_cell ic2 = make_interpreted_cell(c2, make_cell_interpretation_value_of());
   cell_relation pv = cell_relation_undefined;
  
   if (null_pointer_value_cell_p(c1) || undefined_pointer_value_cell_p(c1))
       pv = make_cell_relation(ic2, ic1, make_approximation(app_tag, UU), d);
   else
     pv = make_cell_relation(ic1, ic2, make_approximation(app_tag, UU), d);
   return(pv);
 }

References cell_relation_undefined, make_approximation(), make_cell_interpretation_value_of(), make_cell_relation(), make_interpreted_cell(), null_pointer_value_cell_p(), undefined_pointer_value_cell_p(), and UU.

Referenced by kill_pointer_value(), make_simple_pv_from_simple_effects(), and simple_pv_translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ malloc_arg_to_type()

type malloc_arg_to_type ( expression e )

generate the type of the allocated area from the malloc argument

Parameters

e	is the malloc argument expression

Returns: a new type (no sharing)

Store dependent types are not generated. It means that whenever the size of the allocated space is store dependent, the returned type is an array of unbounded_dimension.

which one is the sizeof operator ? try the second one first

sizeofexpression is an expression

Definition at line 187 of file abstract_location.c.

 {
   type t = type_undefined;
   syntax s = expression_syntax(e);
   expression n = expression_undefined;
   sizeofexpression sizeof_exp = sizeofexpression_undefined;
   bool scalar_p = false;;
  
   pips_debug(5, "begin for expression:%s\n", expression_to_string(e));
  
   if (syntax_sizeofexpression_p(s))
     {
       scalar_p = true; // Not necessarily! An array type may be argument
       sizeof_exp = syntax_sizeofexpression(s);
     }
   else if(syntax_cast_p(s)) {
     cast c = syntax_cast(s);
     expression ce = cast_expression(c);
     t = malloc_arg_to_type(ce);
     return t; // FI: I hate doing this...
   }
   else if (syntax_call_p(s))
     {
       call c = syntax_call(s);
       entity func = call_function(c);
       list func_args = call_arguments(c);
  
       if (same_string_p(entity_local_name(func), MULTIPLY_OPERATOR_NAME))
         {
           pips_debug(5, "multiply operator found\n");
           expression arg1 = EXPRESSION(CAR(func_args));
           expression arg2 = EXPRESSION(CAR(CDR(func_args)));
  
           /* which one is the sizeof operator ? try the second one first */
           if (syntax_sizeofexpression_p(expression_syntax(arg2)))
             {
               pips_debug(5," second arg is a sizeof expression\n");
               sizeof_exp = syntax_sizeofexpression(expression_syntax(arg2));
               n = make_op_exp("-", copy_expression(arg1), int_to_expression(1));
             }
           else if (syntax_sizeofexpression_p(expression_syntax(arg1)))
             {
               pips_debug(5," first arg is a sizeof expression\n");
               sizeof_exp = syntax_sizeofexpression(expression_syntax(arg1));
               n = make_op_exp("-", copy_expression(arg2), int_to_expression(1));
             }
           else
             {
               n = make_unbounded_expression();
             }
         }
       else
         {
           n = make_op_exp("-", copy_expression(e), int_to_expression(1));
         }
     }
   else
     n = make_op_exp("-", copy_expression(e), int_to_expression(1));
  
   if (!expression_undefined_p(n) && !unbounded_expression_p(n)
       && !expression_constant_p(n))
     {
       // FI: I do not see why we cannot generate dependent types...
       // We would have to be careful to evaluate the expression in
       // case its variables are modified. Just as the parser should do.
       pips_debug(5, "non constant number of elements "
                  "-> generating unbounded dimension\n");
       free_expression(n);
       n = make_unbounded_expression();
     }
  
   if (sizeofexpression_undefined_p(sizeof_exp))
     {
       t = make_type_variable
         (make_variable(make_basic_int(DEFAULT_CHARACTER_TYPE_SIZE),
                        CONS(DIMENSION,
                             make_dimension(int_to_expression(0), n, NIL),
                             NIL),
                        NIL));
     }
   else if (sizeofexpression_type_p(sizeof_exp))
     {
       type t_sizeof_exp = sizeofexpression_type(sizeof_exp);
       variable t_var_sizeof_exp = type_variable_p(t_sizeof_exp) ?
         type_variable(t_sizeof_exp) : variable_undefined;
       pips_assert("type must be variable",
                   !variable_undefined_p(t_var_sizeof_exp));
  
       if (scalar_p)
         t = make_type_variable
           (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                          gen_full_copy_list(variable_dimensions
                                             (t_var_sizeof_exp)),
                          NIL));
       else
         t = make_type_variable
           (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                          CONS(DIMENSION,
                               make_dimension(int_to_expression(0), n, NIL),
                               gen_full_copy_list(variable_dimensions
                                                  (t_var_sizeof_exp))),
                          NIL));
     }
   else /* sizeofexpression is an expression */
     {
       type t_sizeof_exp =
         expression_to_type(sizeofexpression_expression(sizeof_exp));
       variable t_var_sizeof_exp = type_variable_p(t_sizeof_exp) ?
         type_variable(t_sizeof_exp) : variable_undefined;
  
       if (scalar_p)
         t = make_type_variable
           (make_variable(copy_basic(variable_basic( t_var_sizeof_exp)),
                          gen_full_copy_list(variable_dimensions
                                             (t_var_sizeof_exp)),
                          NIL));
       else
         t = make_type_variable
           (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                          CONS(DIMENSION,
                               make_dimension(int_to_expression(0), n, NIL),
                               gen_full_copy_list(variable_dimensions
                                                  (t_var_sizeof_exp))),
                          NIL));
       free_type(t_sizeof_exp);
     }
   pips_debug(5, "end with type %s\n", string_of_type(t));
   return t;
 }

References call_arguments, call_function, CAR, cast_expression, CDR, CONS, copy_basic(), copy_expression(), DEFAULT_CHARACTER_TYPE_SIZE, DIMENSION, entity_local_name(), EXPRESSION, expression_constant_p(), expression_syntax, expression_to_string(), expression_to_type(), expression_undefined, expression_undefined_p, free_expression(), free_type(), gen_full_copy_list(), int_to_expression(), make_basic_int(), make_dimension(), make_op_exp(), make_type_variable(), make_unbounded_expression(), make_variable(), MULTIPLY_OPERATOR_NAME, NIL, pips_assert, pips_debug, same_string_p, sizeofexpression_expression, sizeofexpression_type, sizeofexpression_type_p, sizeofexpression_undefined, sizeofexpression_undefined_p, string_of_type(), syntax_call, syntax_call_p, syntax_cast, syntax_cast_p, syntax_sizeofexpression, syntax_sizeofexpression_p, type_undefined, type_variable, type_variable_p, unbounded_expression_p(), variable_basic, variable_dimensions, variable_undefined, and variable_undefined_p.

Referenced by malloc_to_abstract_location().

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:

◆ malloc_to_abstract_location()

entity malloc_to_abstract_location	(	expression	malloc_exp,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

malloc_exp	is the argument expression of the call to malloc
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns: an abstract heap location entity

free_type(ct)

Parameters

malloc_exp	alloc_exp
psi	si

Definition at line 389 of file abstract_location.c.

 {
   entity e = entity_undefined;
  
   pips_debug(8, "begin for expression %s\n", expression_to_string(malloc_exp));
   type t = malloc_arg_to_type(malloc_exp);
   //type ct = copy_type(compute_basic_concrete_type(t));
   //e = malloc_type_to_abstract_location(ct, psi);
   e = malloc_type_to_abstract_location(t, psi);
   free_type(t)/*, free_type(ct)*/;
   pips_debug(8, "returning entity %s of type %s\n", entity_name(e),
              string_of_type(entity_type(e)));
  
   return e;
 }

References entity_name, entity_type, entity_undefined, expression_to_string(), free_type(), malloc_arg_to_type(), malloc_type_to_abstract_location(), pips_debug, and string_of_type().

Referenced by calloc_to_abstract_location(), flow_sensitive_malloc_to_points_to_sinks(), heap_intrinsic_to_post_pv(), and original_malloc_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ malloc_type_to_abstract_location()

entity malloc_type_to_abstract_location	(	type	t,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

t	is type of the allocated space
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns: an abstract heap location entity

in case we want an anywhere abstract heap location : the property ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract location is used for all heap buckets.

in case the property ABSTRACT_HEAP_LOCATIONS is set to "insensitive": an abstract location is used for each function.

in case the property ABSTRACT_HEAP_LOCATIONS is set to "flow-sensitive" or "context-sensitive".

No difference here between the two values. The diffferent behavior will show when points-to and effects are translated at call sites

At this level, we want to use the statement number or the statement ordering. The statement ordering is safer because two statements or more can be put on the same line. The statement number is more user-friendly.

There is no need to distinguish between types since the statement ordering is at least as effective.

Parameters

psi si

Definition at line 324 of file abstract_location.c.

 {
   entity e = entity_undefined;
   const char* opt = get_string_property("ABSTRACT_HEAP_LOCATIONS");
   bool type_sensitive_p = !get_bool_property("ALIASING_ACROSS_TYPES");
  
   pips_debug(8, "begin for type %s\n",
              string_of_type(t));
   /* in case we want an anywhere abstract heap location : the property
      ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract
      location is used for all heap buckets. */
   if(strcmp(opt, "unique")==0){
     if(type_sensitive_p)
       e = entity_all_heap_locations_typed(t);
     else
       e = entity_all_heap_locations();
   }
  
   /* in case the property ABSTRACT_HEAP_LOCATIONS is set to
      "insensitive": an abstract location is used for each function. */
   else if(strcmp(opt, "insensitive")==0){
     if(type_sensitive_p)
       e = entity_all_module_heap_locations_typed(psi->current_module,
                                                  copy_type(t));
     else
       e = entity_all_module_heap_locations(psi->current_module);
   }
  
   /* in case the property ABSTRACT_HEAP_LOCATIONS is set to
      "flow-sensitive" or "context-sensitive".
  
      No difference here between the two values. The diffferent
      behavior will show when points-to and effects are translated at
      call sites
  
      At this level, we want to use the statement number or the
      statement ordering. The statement ordering is safer because two
      statements or more can be put on the same line. The statement
      number is more user-friendly.
  
      There is no need to distinguish between types since the statement
      ordering is at least as effective.
   */
   else if(strcmp(opt, "flow-sensitive")==0
           || strcmp(opt, "context-sensitive")==0 )
     e = entity_flow_or_context_sentitive_heap_location
       (statement_number(psi->current_stmt),
        copy_type(t));
   else
     pips_user_error("Unrecognized value for property ABSTRACT_HEAP_LOCATION:"
                     " \"%s\"", opt);
  
   pips_debug(8, "returning entity %s of type %s\n", entity_name(e),
              string_of_type(entity_type(e)));
  
   return e;
 }

References copy_type(), sensitivity_information::current_module, sensitivity_information::current_stmt, entity_all_heap_locations(), entity_all_heap_locations_typed(), entity_all_module_heap_locations(), entity_all_module_heap_locations_typed(), entity_flow_or_context_sentitive_heap_location(), entity_name, entity_type, entity_undefined, get_bool_property(), get_string_property(), pips_debug, pips_user_error, statement_number, and string_of_type().

Referenced by malloc_to_abstract_location().

Here is the call graph for this function:

Here is the caller 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:

◆ merge_points_to_cell_lists()

list merge_points_to_cell_lists	(	list	l1,
		list	l2
	)

Add in "l1" elements of "l2" that are not yet in "l1".

List "l2" is then destroyed.

This is a set union.

Parameters

l1	1
l2	2

Definition at line 134 of file points_to.c.

 {
   list lt = NIL;
   FOREACH(CELL, c2, l2) {
     if(!points_to_cell_in_list_p(c2, l1)) {
       lt = CONS(CELL,c2, lt);
     }
   }
   lt = gen_nreverse(lt);
   l1 = gen_nconc(l1, lt);
   gen_free_list(l2);
   return l1;
 }

References CELL, CONS, FOREACH, gen_free_list(), gen_nconc(), gen_nreverse(), NIL, and points_to_cell_in_list_p().

Referenced by dereferencing_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ module_to_analyzed_array_locations()

list module_to_analyzed_array_locations ( entity m )

m is supposed to be a module entity

Definition at line 393 of file locations.c.

 {
   list ll = NIL;
   value v = entity_initial(m);
   code c = value_code(v);
   list dl = code_declarations(c);
  
   FOREACH(ENTITY, e, dl) {
     if(array_location_entity_of_module_p(e, m))
       ll = CONS(ENTITY, e, ll);
   }
   return ll;
 }

References array_location_entity_of_module_p(), code_declarations, CONS, ENTITY, entity_initial, FOREACH, NIL, and value_code.

Referenced by apply_array_effect_to_transformer().

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:

◆ null_pointer_value_cell_p()

bool null_pointer_value_cell_p ( cell c )

Definition at line 104 of file pointer_values.c.

 {
   reference r;
   if (cell_gap_p(c)) return false;
   else if (cell_reference_p(c))
     r = cell_reference(c);
   else
     r = preference_reference(cell_preference(c));
   return(null_pointer_value_entity_p(reference_variable(r)));
 }

References cell_gap_p, cell_preference, cell_reference, cell_reference_p, null_pointer_value_entity_p(), preference_reference, and reference_variable.

Referenced by generic_effect_find_aliases_with_simple_pointer_values(), generic_effect_find_equivalent_simple_pointer_values(), make_value_of_pointer_value(), multiple_pointer_assignment_to_post_pv(), single_pointer_assignment_to_post_pv(), and source_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ null_pointer_value_entity()

entity null_pointer_value_entity ( void )

Definition at line 87 of file pointer_values.c.

 {
   return entity_null_locations();
 }

References entity_null_locations().

Referenced by declaration_to_post_pv(), make_null_pointer_value_cell(), and pointer_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ null_pointer_value_entity_p()

bool null_pointer_value_entity_p ( entity e )

Definition at line 99 of file pointer_values.c.

 {
   return entity_null_locations_p(e);
 }

References entity_null_locations_p().

Referenced by abstract_pointer_value_entity_p(), convex_effect_to_constant_path_effects_with_pointer_values(), external_value_name(), have_null_value_in_pointer_expression_p(), null_pointer_value_cell_p(), pips_user_value_name(), and simple_effect_to_constant_path_effects_with_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ original_malloc_to_abstract_location()

reference original_malloc_to_abstract_location	(	expression	,
		type	,
		type	,
		expression	,
		entity	,
		statement
	)

◆ pips_region_user_name()

const char* pips_region_user_name ( entity ent )

char * pips_region_user_name(entity ent) output : the name of entity.

modifies : nothing. comment : allows to "catch" the PHIs entities, else, it works like pips_user_value_name() (see semantics.c).

external_value_name cannot be used because there is no need for the #new suffix, but the #old one is necessary

take care of the constant term TCST

ent is a PHI entity from the regions module

if (!hash_entity_to_values_undefined_p() && !entity_has_values_p(ent))

name = external_value_name(ent);

else

Parameters

ent nt

Definition at line 169 of file prettyprint.c.

 {
     /* external_value_name cannot be used because there is no need for
        the #new suffix, but the #old one is necessary */
     const char* name;
     if(ent == NULL)
         /* take care of the constant term TCST */
         name = "";
     else {
         char *ent_name = entity_name(ent);
  
         if (strncmp(ent_name, REGIONS_MODULE_NAME, 7) == 0)
             /* ent is a PHI entity from the regions module */
             name = entity_local_name(ent);
         else
           {
             /* if (!hash_entity_to_values_undefined_p() && !entity_has_values_p(ent)) */
 /*            name = external_value_name(ent); */
 /*          else */
               name = entity_minimal_name(ent);
           }
     }
  
     return name;
 }

References entity_local_name(), entity_minimal_name(), entity_name, and REGIONS_MODULE_NAME.

Referenced by copy_write_statement_with_cumulated_regions(), reg_sc_debug(), reg_v_debug(), text_pointer_value(), text_points_to_relation(), and text_region_no_action().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pointer_value_compare()

int pointer_value_compare	(	cell_relation *	ppv1,
		cell_relation *	ppv2
	)

Compares two pointer values for sorting.

The first criterion is based on names. Local entities come first; then they are sorted according to the lexicographic order of the module name, and inside each module name class, according to the local name lexicographic order. Then for a given entity name, a read effect comes before a write effect. It is assumed that there is only one effect of each type per entity. bc.

result

compare first references of *ppv1 and *ppv2

same first cells

put second cells value_of before address_of

both are value_of or address_of

compare second cells

Parameters

ppv1	pv1
ppv2	pv2

Definition at line 255 of file compare.c.

 {
   int ppv1_pos = 0; /* result */
   /* compare first references of *ppv1 and *ppv2 */
  
   cell ppv1_first_c = cell_relation_first_cell(*ppv1);
   cell ppv2_first_c = cell_relation_first_cell(*ppv2);
  
   pips_assert("there should not be preference cells in pointer values (ppv1 first) \n",
               !cell_preference_p(ppv1_first_c));
   pips_assert("there should not be preference cells in pointer values (ppv2 first) \n",
               !cell_preference_p(ppv2_first_c));
  
   pips_assert("the first cell must have value_of interpretation (ppv1)\n",
               cell_relation_first_value_of_p(*ppv1));
   pips_assert("the first cell must have value_of interpretation (ppv2)\n",
               cell_relation_first_value_of_p(*ppv2));
  
   ppv1_pos = cell_compare(&ppv1_first_c, &ppv2_first_c);
  
   if (ppv1_pos == 0)       /* same first cells */
     {
       /* put second cells value_of before address_of */
       bool ppv1_second_value_of_p = cell_relation_second_value_of_p(*ppv1);
       bool ppv2_second_value_of_p = cell_relation_second_value_of_p(*ppv2);
  
       ppv1_pos = (ppv1_second_value_of_p ==  ppv2_second_value_of_p) ? 0 :
         (ppv1_second_value_of_p ? -1 : 1);
  
       if (ppv1_pos == 0) /* both are value_of or address_of*/
         {
           /* compare second cells */
           cell ppv1_second_c = cell_relation_second_cell(*ppv1);
           cell ppv2_second_c = cell_relation_second_cell(*ppv2);
           ppv1_pos = cell_compare(&ppv1_second_c, &ppv2_second_c);
  
         }
     }
   return(ppv1_pos);
 }

References cell_compare(), cell_preference_p, cell_relation_first_cell, cell_relation_first_value_of_p, cell_relation_second_cell, cell_relation_second_value_of_p, and pips_assert.

Referenced by simple_pvs_syntactically_equal_p(), and text_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_array_reference_p()

bool points_to_array_reference_p ( reference r )

Is this a reference to an array or a reference to a pointer? This is not linked to the type of the reference, as a reference may be a pointer, such as "a[10]" when "a" is declared int "a[10][20]".

Look for the last field among the subscript

Definition at line 599 of file points_to.c.

 {
   bool array_p = false;
   list sl = reference_indices(r);
   entity v = reference_variable(r);
  
   if(ENDP(sl)) {
     type t = entity_basic_concrete_type(v);
     array_p = array_type_p(t);
   }
   else {
     /* Look for the last field among the subscript */
     list rsl = gen_nreverse(sl);
     type t = type_undefined;
     int i = 0;
     FOREACH(EXPRESSION, se, rsl) {
       if(field_reference_expression_p(se)) {
         entity f = reference_variable(expression_reference(se));
         t = entity_basic_concrete_type(f);
         break;
       }
       i++;
     }
     if(type_undefined_p(t)) {
       t = entity_basic_concrete_type(v);
       variable vt = type_variable(t);
       list dl = variable_dimensions(vt);
       int d = (int) gen_length(dl);
       int i = (int) gen_length(rsl);
       if(i<d)
         array_p = true;
     }
     else {
       if(i==0) { // FI: could be merged with the "else if" clause
         array_p = array_type_p(t);
       }
       else if(array_type_p(t)) {
         variable vt = type_variable(t);
         list dl = variable_dimensions(vt);
         int d = (int) gen_length(dl);
         if(i<d)
           array_p = true;
       }
     }
     reference_indices(r) = gen_nreverse(rsl);
   }
   return array_p;
 }

References array_type_p(), ENDP, entity_basic_concrete_type(), EXPRESSION, expression_reference(), f(), field_reference_expression_p(), FOREACH, gen_length(), gen_nreverse(), int, reference_indices, reference_variable, type_undefined, type_undefined_p, type_variable, and variable_dimensions.

Referenced by points_to_cell_add_fixed_subscripts(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_array_reference_to_type()

type points_to_array_reference_to_type ( reference r )

If this is an array reference, what is the type of the underlying array type?

This information cannot be obtained by direct type information because subarrays are typed as pointers to even smaller arrays.

If it is not an array reference, the returned type is undefined.

No new type is allocated.

Look for the last field among the subscript

Definition at line 657 of file points_to.c.

 {
   list sl = reference_indices(r);
   entity v = reference_variable(r);
   type t = type_undefined;
  
   if(ENDP(sl)) {
     t = entity_basic_concrete_type(v);
   }
   else {
     /* Look for the last field among the subscript */
     list rsl = gen_nreverse(sl);
     FOREACH(EXPRESSION, se, rsl) {
       if(field_reference_expression_p(se)) {
         entity f = reference_variable(expression_reference(se));
         t = entity_basic_concrete_type(f);
         break;
       }
     }
     if(type_undefined_p(t)) {
       t = entity_basic_concrete_type(v);
     }
     else {
       ;
     }
     reference_indices(r) = gen_nreverse(rsl);
   }
   return t;
 }

References ENDP, entity_basic_concrete_type(), EXPRESSION, expression_reference(), f(), field_reference_expression_p(), FOREACH, gen_nreverse(), reference_indices, reference_variable, type_undefined, and type_undefined_p.

Referenced by points_to_cell_add_fixed_subscripts().

Here is the call graph for this function:

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

bool points_to_cell_equal_p	(	cell	c1,
		cell	c2
	)

Parameters

c1	1
c2	2

Definition at line 916 of file points_to.c.

 {
   reference r1 = cell_any_reference(c1);
   reference r2 = cell_any_reference(c2);
   return reference_equal_p(r1,r2);
 }

References cell_any_reference(), and reference_equal_p().

Referenced by add_implicitly_killed_arcs_to_kill_set(), compute_points_to_kill_set(), dereferencing_subscript_to_points_to(), expand_points_to_domain(), freed_list_to_points_to(), fuse_points_to_sink_cells(), memory_leak_to_more_memory_leaks(), non_equal_condition_to_points_to(), potential_to_effective_memory_leaks(), remove_points_to_cell(), similar_arc_in_points_to_set_p(), update_points_to_graph_with_arc(), and user_call_to_points_to_fast_interprocedural().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cell_in_list_p()

bool points_to_cell_in_list_p	(	cell	c,
		list	L
	)

Definition at line 117 of file points_to.c.

 {
   bool found_p = false;
   FOREACH(CELL, lc, L) {
     if(cell_equal_p(c,lc)) {
       found_p =true;
       break;
     }
   }
   return found_p;
 }

References CELL, cell_equal_p(), and FOREACH.

Referenced by add_implicitly_killed_arcs_to_kill_set(), compute_points_to_gen_set(), filter_formal_out_context_according_to_formal_in_context(), freed_list_to_points_to(), generic_points_to_set_to_stub_cell_list(), generic_points_to_source_to_sinks(), lower_points_to_approximations_according_to_write_effects(), merge_points_to_cell_lists(), points_to_cell_list_and(), recursive_filter_formal_context_according_to_actual_context(), reference_to_points_to_translations(), and translation_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cell_to_concrete_type()

type points_to_cell_to_concrete_type ( cell c )

Definition at line 676 of file type.c.

 {
   bool to_be_freed;
   type t = points_to_cell_to_type(c, &to_be_freed);
   type ct = compute_basic_concrete_type(t);
   if(to_be_freed) free_type(t);
   return ct;
 }

References compute_basic_concrete_type(), free_type(), and points_to_cell_to_type().

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(), cells_to_read_or_write_effects(), create_scalar_stub_sink_cell(), create_stub_points_to(), expression_to_points_to_cells(), filter_formal_context_according_to_actual_context(), formal_source_to_sinks(), freed_list_to_points_to(), generic_points_to_cell_to_useful_pointer_cells(), list_assignment_to_points_to(), new_filter_formal_context_according_to_actual_context(), new_recursive_filter_formal_context_according_to_actual_context(), points_to_translation_mapping_is_typed_p(), points_to_translation_of_formal_parameters(), points_to_with_stripped_sink(), process_casted_sinks(), process_casted_sources(), recursive_filter_formal_context_according_to_actual_context(), remove_points_to_cell(), and source_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cell_to_type()

type points_to_cell_to_type	(	cell	c,
		bool *	to_be_freed
	)

FI: I need more generality than is offered by cell_to_type()

Parameters

to_be_freed o_be_freed

Definition at line 665 of file type.c.

 {
   type t = type_undefined;
   pips_assert("a cell cannot be a gap yet", !cell_gap_p(c));
   reference ref = cell_any_reference(c);
  
   t = points_to_reference_to_type(ref, to_be_freed);
  
   return t;
 }

References cell_any_reference(), cell_gap_p, pips_assert, points_to_reference_to_type(), ref, and type_undefined.

Referenced by any_source_to_sinks(), anywhere_source_to_sinks(), check_type_of_points_to_cells(), dereferencing_to_sinks(), expression_to_points_to_sources(), internal_pointer_assignment_to_points_to(), offset_cell(), points_to_cell_add_fixed_subscripts(), points_to_cell_to_concrete_type(), points_to_cell_types_compatibility(), points_to_set_block_projection(), points_to_source_to_translations(), recursive_cell_to_pointer_cells(), reduce_cell_to_pointer_type(), struct_initialization_to_points_to(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cell_to_upper_bound_points_to_cells()

list points_to_cell_to_upper_bound_points_to_cells ( cell c )

Return a list of cells that are larger than cell "c" in the points-to cell lattice.

This goal is quite open because a[1][2] is dominated by both a[*][2] and a[1][*], then by a[*][*]. Assuming "a" is variable of function "foo", then we have "foo:*STACK*_b0", "*ANYMODULE*:*STACK*_b0", "foo:*ANYWHERE*_b0", "*ANYMODULE*:*ANYWHERE*_b0", "*ANYMODULE*:*ANYWHERE*".

They would all be useful to guarantee the consistency of the points-to information wrt the points-to cell lattice, but we'd rather maintain a partially consistent points-to graph and rely on functions using it to add the necessary points-to arcs.

A lattice-consistent points-to graph would contain too many arcs as x->y implies x'->y' for all x' bigger than x and y' bigger then y...

For the time being, we only need to convert a[i][j][k] into a[*][*][*] when i, j and k are real subscript expressions, not fields.

We return an empty list when cell "c" does not need any upper bound, as is the case with a, a[f] where f is a field, a[*] and all the abstract locations.

So, for the time being, this function returns a list with one or zero elements.

Definition at line 973 of file points_to.c.

 {
   list ubl = NIL; // upper bound list
   reference r = cell_any_reference(c);
   entity v = reference_variable(r);
   if(!entity_abstract_location_p(v)) {
     list sel = reference_indices(r); // subscript expression list
     list nsel = NIL; // new subscript expression list
     bool new_cell_p = false;
     FOREACH(EXPRESSION, se, sel) {
       expression nse = expression_undefined;
       if(integer_expression_p(se)) {
         nse = make_unbounded_expression();
         new_cell_p = true;
       }
       else
         nse = copy_expression(se);
       nsel = CONS(EXPRESSION, nse, nsel);
     }
     if(new_cell_p) {
       nsel = gen_nreverse(nsel);
       reference nr = make_reference(v, nsel);
       cell nc = make_cell_reference(nr);
       ubl = CONS(CELL, nc, ubl);
     }
     else
       gen_full_free_list(nsel);
   }
   return ubl;
 }

References CELL, cell_any_reference(), CONS, copy_expression(), entity_abstract_location_p(), EXPRESSION, expression_undefined, FOREACH, gen_full_free_list(), gen_nreverse(), integer_expression_p(), make_cell_reference(), make_reference(), make_unbounded_expression(), NIL, reference_indices, and reference_variable.

Referenced by points_to_cells_to_upper_bound_points_to_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cell_types_compatibility()

void points_to_cell_types_compatibility	(	cell	l,
		cell	r
	)

Make sure that cell l can points towards cell r.

FI-AM/FC: Unfortunately, a lot of specification work is missing to develop this function while taking care of abstract locations and their lattice.

Restrictions on cell "l"

1.1 "l" cannot be the abstract nowhere/undefined cell

...

Note: this should be part of points_to_set_consistent_p(), which is called consistent_points_to_set(), but this function goes beyond checking the compatibility. It enforces it when legal and possible.

Maybe this function should be relocated in alias-classes

Beware of possible side-effects on l

FI, 10 August 2012: this function is a mess. No side effect should be applied. it should be redesigned to check compatibility cases one after the other and it should be renamed points_to_cell_types_compatibility_p()

FI, 14 August 2012: the dimension of the sink entity and sink reference must be greater than the dimension of the source reference. This is not checked yet.

FI, 19 August 2012: all cells used in a points-to arc must be scalar, either pointers or basic types

&& overloaded_type_p(urt)

The source points towards an array and the cell is an element of this array.

Formal parameters and potentially stubs can be assumed to points towards an array although they are declared as pointers to a scalar.

This should never be a problem when sink cells are always array elements and not arrays.

Here we may be in trouble because of the heap modeling malloc() returns by default a "void *", or sometimes a "char *" which may be casted into anything...

The dimension of the allocated array should be given by the size of the pointed type and by the size of the right type.

Also, we have different heap modelling, with different flexibilities

& !all_heap_locations_typed_cell_p(r)

all_heap_locations_typed_cell_p(r)

There must be a typing issue.

This may happen with the heap model

Is it an (implicit) array of pointers

This may happen with the heap model

Definition at line 985 of file type.c.

 {
   if(points_to_source_cell_compatible_p(l)) {
     if(null_cell_p(r))
       ;
     else if(points_to_sink_cell_compatible_p(r)) {
       // FI: I'm not sure enought filtering has been performed... to
       // have here type information, especially with an anywhere or a
       // nowhere/undefined not typed
  
       // FI : tests supplementaires pour eviter les cells qui ne sont pas typees:-(
  
       bool l_to_be_freed, r_to_be_freed;
       type lt = points_to_cell_to_type(l, &l_to_be_freed);
       type rt = points_to_cell_to_type(r, &r_to_be_freed);
       type ult = compute_basic_concrete_type(lt);
       type urt = compute_basic_concrete_type(rt);
       if(C_pointer_type_p(ult)) {
         type pt = pointer_type_p(ult) ?
           copy_type(compute_basic_concrete_type(type_to_pointed_type(ult))) :
           array_type_to_element_type(ult);
  
         // Several options are possible
  
         bool get_bool_property(const char *);
         if(array_pointer_type_equal_p(pt, urt)) 
           ; // the pointed type is the type of the right cell
         // FI: we could/should add a compatibility type between void
         // and any scalar type
         // The problem occurs in Pointers/fulguro13 because a cast is
         // not processed:
         // fgUINT16 *array_s = (fgUINT16 *) vct->array;
         // FI->AM/FC/PJ: we need a trick to handle the casts or the
         // typing of the points-to graph is not possible
         else if(scalar_type_p(pt) && type_void_p(urt)) {
           // A void * pointer may be assigned to anything?
           ; // OK, they are compatible...
         }
         else if(type_void_p(pt) /* && overloaded_type_p(urt)*/ ) {
           // a void * is expected to point toward any type, which is
           // encoded with overloaded but could be anything when casts
           // or functions, user or intrinsic, are used. See fulguro03.c
           ;
         }
         else if(overloaded_type_p(urt)) {
           // This is compatible with any pointed type pt by definition
           // of overloaded. See fulguro03.c
           ;
         }
         else if(array_type_p(pt) && scalar_type_p(urt)) {
           /* The source points towards an array and the cell is an
              element of this array. */
           basic pb = variable_basic(type_variable(pt));
           basic rb = variable_basic(type_variable(urt));
           if(basic_equal_p(pb, rb)) {
             ; // OK
           }
           else {
             pips_internal_error("???");
           }
         }
         else if(array_type_p(urt)
                 && !get_bool_property("POINTS_TO_STRICT_POINTER_TYPES")) {
           /* Formal parameters and potentially stubs can be assumed to
            * points towards an array although they are declared as
            * pointers to a scalar.
            *
            * This should never be a problem when sink cells are always
            * array elements and not arrays.
            */
           if(type_variable_p(pt)) {
             basic pb = variable_basic(type_variable(pt));
             basic rb = variable_basic(type_variable(urt));
             if(basic_equal_p(pb,rb)) {
               ; // OK, they are compatible
             }
             else {
               fprintf(stderr, "Type pointed by source \"pt\": \"");
               print_type(pt);
               fprintf(stderr, "\"\nSink type \"urt\": \"");
               print_type(urt);
               pips_internal_error("\"\nIncompatible basics.\n");
             }
           }
           else {
               fprintf(stderr, "Pointed type \"pt\": ");
               print_type(pt);
             pips_internal_error("Unexpected type \"pt\".\n");
           }
         }
         else if(array_type_p(urt)
                 && get_bool_property("POINTS_TO_STRICT_POINTER_TYPES")) {
           // Pointers/assignment10.c
           if(type_variable_p(pt)) {
             basic pb = variable_basic(type_variable(pt));
             basic rb = variable_basic(type_variable(urt));
             if(basic_equal_p(pb,rb)) {
               // OK, they are compatible, but r must be subscripted
               points_to_cell_add_zero_subscripts(r);
             }
             else {
               fprintf(stderr, "Type pointed by source \"pt\": \"");
               print_type(pt);
               fprintf(stderr, "\"\nSink type \"urt\": \"");
               print_type(urt);
               pips_internal_error("\"\nIncompatible basics.\n");
             }
           }
         }
         else if(type_functional_p(urt)) {
           // FI->AM: we should check that the function is a constant
           // with no parameters
           type ret_t = functional_result(type_functional(urt));
           type u_ret_t = compute_basic_concrete_type(ret_t);
           if(pointer_type_p(u_ret_t)) {
             pips_internal_error("This should be useless.\n");
             // FI->AM: must be useless... Designed for C constant strings, but...
             type p_u_ret_t = type_to_pointed_type(u_ret_t);
             if(array_pointer_type_equal_p(pt, p_u_ret_t))
               ;
             else
               pips_internal_error("Type mismatch.\n");
             free_type(u_ret_t);
           }
           else if(string_type_p(u_ret_t)) {
             // FI: hidden pointer...
             // char * fmt; ftm = "foo";
             variable ptv = type_variable(pt);
             basic ptb = variable_basic(ptv);
             if(basic_int_p(ptb) && basic_int(ptb)==1)
               ; // char
             else
               pips_internal_error("Illegal string assignment...\n");
           }
           else {
             pips_internal_error("Illegal assignment to pointer...\n");
           }
         }
         else {
           /* Here we may be in trouble because of the heap modeling
            * malloc() returns by default a "void *", or sometimes a
            * "char *" which may be casted into anything...
            *
            * The dimension of the allocated array should be given by
            * the size of the pointed type and by the size of the right
            * type.
            *
            * Also, we have different heap modelling, with different flexibilities
            */
           if(heap_cell_p(r) && !all_heap_locations_cell_p(r) 
              /*&& !all_heap_locations_typed_cell_p(r) */) {
             pips_internal_error("Type mistake for heap allocation. Probably a user error. It should have been trapped at a higher level.\n");
             type nt = copy_type(pt);
             if(array_type_p(nt)
                || get_bool_property("POINTS_TO_STRICT_POINTER_TYPES"))
               ; // Do not add a dimension to an existing array.
             else if(!type_void_p(nt)) {
               variable v = type_variable(nt);
               expression z = int_to_expression(0);
               // FI FI FI: should be computed... and checked
               expression s = make_unbounded_expression();
               dimension d = make_dimension(z, s, NIL);
               variable_dimensions(v) = CONS(DIMENSION, d, NIL);
             }
             // FI: could be a function entity_type_substitution()...
             // but interference with r_to_be_freed
             r_to_be_freed = true;
             reference rr = cell_any_reference(r);
             entity rv = reference_variable(rr);
             // This assignment breaks the internal consistency of heap modelling
             if(!array_pointer_type_equal_p(nt, entity_type(rv)))
               pips_internal_error("Incompatible types for \"%s\".\n",
                                   entity_name(rv));
             entity_type(rv) = nt;
           }
           else if(all_heap_locations_cell_p(r))
             ; // always compatible
           else if(false /* all_heap_locations_typed_cell_p(r)*/)
             ; // FI: I am not sure what to do...
           else if(null_cell_p(r)) {
             ; // always compatible
           }
           else if(anywhere_cell_p(r)) {
             ; // not typed anywhere, always compatible
           }
           else if(nowhere_cell_p(r)) {
             ; // not typed nowhere/undefined, always compatible
           }
           else {
             /* There must be a typing issue. */
               fprintf(stderr, "Type pointed by source cell, \"pt\": \"");
               void print_points_to_cell(cell); // FI: library organization
               print_points_to_cell(l);
               fprintf(stderr, "\" with type: \"");
               print_type(pt);
               fprintf(stderr, "\"\nType of sink cell, \"urt\": \"");
               print_points_to_cell(r);
               fprintf(stderr, "\" with type: \"");
               print_type(urt);
               fprintf(stderr, "\"\n");
               pips_internal_error("Incompatible Types.\n");
           }
         }
       }
       else if(array_type_p(ult)) {
         /* This may happen with the heap model */
         extern bool get_bool_property(const char *);
         if(!get_bool_property("POINTS_TO_STRICT_POINTER_TYPES")) {
           /* Is it an (implicit) array of pointers*/
           basic ultb = variable_basic(type_variable(ult));
           if(basic_pointer_p(ultb)) { // Array 
             // FI: "pt" should be freed later...
             // FI: should have been done earlier when building l
             // reference lr = cell_any_reference(l);
             // reference_add_zero_subscripts(lr, ult);
             type pt = compute_basic_concrete_type(basic_pointer(ultb));
             if(type_equal_up_to_typedefs_and_qualifiers_p(pt, urt)) {
               // FI: subscripts must be added to the source reference lr
               // FI: implicit typing of pointers as array of pointers
               reference lr = cell_any_reference(l);
               reference_add_zero_subscripts(lr, ult);
             }
             else {
               // FI: error message could be improved...
               pips_internal_error("Incompatible types.\n");
             }
           }
           else
             pips_internal_error("Not an array of pointers.\n");
         }
         else
           pips_internal_error("The source is an array but not a pointer.\n");
       }
       else if(overloaded_type_p(ult)) {
         /* This may happen with the heap model */
         ; // A pointer type is assumed
       }
       else {
         // Could be checked by points_to_source_cell_compatible_p()
         pips_internal_error("The source is not a pointer.\n");
       }
  
       if(l_to_be_freed) free_type(lt);
       if(r_to_be_freed) free_type(rt);
       free_type(ult), free_type(urt);
     }
   }
   return;
 }

References all_heap_locations_cell_p(), anywhere_cell_p(), array_pointer_type_equal_p(), array_type_p(), array_type_to_element_type(), basic_equal_p(), basic_int, basic_int_p, basic_pointer, basic_pointer_p, C_pointer_type_p(), cell_any_reference(), compute_basic_concrete_type(), CONS, copy_type(), DIMENSION, entity_name, entity_type, fprintf(), free_type(), functional_result, get_bool_property(), heap_cell_p(), int_to_expression(), make_dimension(), make_unbounded_expression(), NIL, nowhere_cell_p(), null_cell_p(), overloaded_type_p(), pips_internal_error, pointer_type_p(), points_to_cell_add_zero_subscripts(), points_to_cell_to_type(), points_to_sink_cell_compatible_p(), points_to_source_cell_compatible_p(), print_points_to_cell, print_type(), reference_add_zero_subscripts(), reference_variable, scalar_type_p(), string_type_p(), type_equal_up_to_typedefs_and_qualifiers_p(), type_functional, type_functional_p, type_to_pointed_type(), type_variable, type_variable_p, type_void_p, variable_basic, and variable_dimensions.

Referenced by create_stub_points_to(), and gen_may_constant_paths().

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_cells_intersect_p()

bool points_to_cells_intersect_p	(	cell	lc,
		cell	rc
	)

points-to cells use abstract addresses, hence the proper comparison is an intersection.

simple references are considered to be singleton.

Assume no aliasing between variables and within data structures.

It is safe to assume intersection...

Parameters

lc	c
rc	c

Definition at line 532 of file points_to.c.

 {
   bool intersect_p = false;
   if(cell_equal_p(lc, rc)) {
     // FI: too simple... All the subscript should be checked.
     // unbounded expressions should be used to decide about a possible
     // intersection... Unless this is guarded by
     // atomic_points_to_reference_p(). To be investigated.
     intersect_p = true;
   }
   else {
     // Look for abstract domains
     // Probably pretty complex...
     // Simple first version...
     reference lr = cell_any_reference(lc);
     entity le = reference_variable(lr);
     reference rr = cell_any_reference(rc);
     entity re = reference_variable(rr);
     intersect_p = entities_may_conflict_p(le, re);
   }
   return intersect_p;
 }

References cell_any_reference(), cell_equal_p(), entities_may_conflict_p(), and reference_variable.

Referenced by equal_condition_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_cells_minimal_module_upper_bound()

entity points_to_cells_minimal_module_upper_bound ( list )

◆ points_to_cells_minimal_reference_upper_bound()

reference points_to_cells_minimal_reference_upper_bound	(	entity	,
		type	,
		list
	)

◆ points_to_cells_minimal_type_upper_bound()

type points_to_cells_minimal_type_upper_bound ( list )

◆ points_to_cells_minimal_upper_bound()

cell points_to_cells_minimal_upper_bound ( list )

Referenced by fuse_points_to_sink_cells().

Here is the caller graph for this function:

◆ points_to_cells_to_upper_bound_points_to_cells()

list points_to_cells_to_upper_bound_points_to_cells ( list cl )

Add to list "l" cells that are upper bound cells of the cells already in list "l" and return list "l".

Parameters

cl l

Definition at line 1007 of file points_to.c.

 {
   list ubl = NIL;
   FOREACH(CELL, c, cl) {
     list cubl = points_to_cell_to_upper_bound_points_to_cells(c);
     ubl = gen_nconc(ubl, cubl);
   }
   ubl = gen_nconc(cl, ubl);
   return ubl;
 }

References CELL, FOREACH, gen_nconc(), NIL, and points_to_cell_to_upper_bound_points_to_cells().

Here is the call graph for this function:

◆ points_to_compare_cells()

int points_to_compare_cells	(	const void *	vpt1,
		const void *	vpt2
	)

Comparison of two points-to arcs based on their source and sink nodes.

This comparison function is used to sort a list of points-to before storage and print-out.

It must return -1, 0 or 1 like strcmp(). It should avoid 0 because we want a total order to avoid validation problems. Hence the exploitation of the references, number of indices, subscript expressions, etc. if the entity names are not sufficient to disambiguate the references.

When subscript expressions are used, fields are replaced by the corresponding field number. So the sort is based on the field ranks in the data structure and not on the the field names.

For abstract locations, the local name is used for the sort and the global names is sometimes used in the prettyprint. Hence, the alphabetical order is not obvious in the print-out.

Parameters

vpt1	pt1
vpt2	pt2

Definition at line 295 of file prettyprint.c.

 {
   int i = 0;
  
   points_to pt1 = *((points_to *) vpt1);
   points_to pt2 = *((points_to *) vpt2);
  
   cell c1so = points_to_source(pt1);
   cell c2so = points_to_source(pt2);
   cell c1si = points_to_sink(pt1);
   cell c2si = points_to_sink(pt2);
  
   //cell c1 = CELL(CAR(vc1));
   //cell c2 = CELL(CAR(vc2));
   // FI: bypass of GAP case
   reference r1so = cell_to_reference(c1so);
   reference r2so = cell_to_reference(c2so);
   reference r1si = cell_to_reference(c1si);
   reference r2si = cell_to_reference(c2si);
  
   entity v1so = reference_variable(r1so);
   entity v2so = reference_variable(r2so);
   entity v1si = reference_variable(r1si);
   entity v2si = reference_variable(r2si);
   list sl1 = NIL, sl2 = NIL, sli1 = NIL, sli2 = NIL ;
   // FI: memory leak? generation of a new string?
   extern const char* entity_minimal_user_name(entity);
   string n1so =   entity_abstract_location_p(v1so)?
     (string) entity_local_name(v1so) :  (string) entity_minimal_user_name(v1so);
   string n2so =   entity_abstract_location_p(v2so)?
     (string) entity_local_name(v2so) : (string) entity_minimal_user_name(v2so);
   string n1si =   entity_abstract_location_p(v1si)?
    (string)  entity_local_name(v1si) : (string) entity_minimal_user_name(v1si);
   string n2si =   entity_abstract_location_p(v2si)?
     (string) entity_local_name(v2si) : (string) entity_minimal_user_name(v2si);
  
   i = strcmp(n1so, n2so);
   if(i==0) {
     i = strcmp(n1si, n2si);
     if(i==0) {
       sl1 = reference_indices(r1so);
       sl2 = reference_indices(r2so);
       int i1 = gen_length(sl1);
       int i2 = gen_length(sl2);
  
       i = i2>i1? 1 : (i2<i1? -1 : 0);
  
       if(i==0) {
         sli1 = reference_indices(r1si);
         sli2 = reference_indices(r2si);
         int i1 = gen_length(sli1);
         int i2 = gen_length(sli2);
  
         i = i2>i1? 1 : (i2<i1? -1 : 0);
         //      if(i==0) {
         for(;i==0 && !ENDP(sl1); POP(sl1), POP(sl2)){
           expression se1 = EXPRESSION(CAR(sl1));
           expression se2 = EXPRESSION(CAR(sl2));
           if(expression_constant_p(se1) && expression_constant_p(se2)){
             int i1 = expression_to_int(se1);
             int i2 = expression_to_int(se2);
             i = i2>i1? -11 : (i2<i1? 1 : 0);
           } else {
             string s1 = expression_to_string(se1);
             string s2 = expression_to_string(se2);
             i = strcmp(s1, s2);
           }
         }
         // if(i==0) {
         // i = strcmp(entity_minimal_user_name(v1si), entity_minimal_user_name(v2si));
         for(;i==0 && !ENDP(sli1); POP(sli1), POP(sli2)){
           expression sei1 = EXPRESSION(CAR(sli1));
           expression sei2 = EXPRESSION(CAR(sli2));
           if(expression_constant_p(sei1) && expression_constant_p(sei2)){
             int i1 = expression_to_int(sei1);
             int i2 = expression_to_int(sei2);
             i = i2>i1? -1 : (i2<i1? 1 : 0);
           } else {
             // FI: memory leak?
             string s1 = expression_to_string(sei1);
             string s2 = expression_to_string(sei2);
             i = strcmp(s1, s2);
           }
         }
       }
     }
   }
   // }
   return i;
 }

References CAR, cell_to_reference(), ENDP, entity_abstract_location_p(), entity_local_name(), entity_minimal_user_name(), EXPRESSION, expression_constant_p(), expression_to_int(), expression_to_string(), gen_length(), NIL, points_to_sink, points_to_source, POP, reference_indices, reference_variable, and s1.

Referenced by fi_points_to_storage(), init_points_to_analysis(), points_to_list_sort(), and points_to_storage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_expression_to_concrete_type()

type points_to_expression_to_concrete_type ( expression e )

The type returned is stored in a hash-table.

It should not be freed. See compute_basic_concrete_type().

This function is useful to avoid the conditional free.

Definition at line 617 of file type.c.

 {
   bool to_be_freed;
   type t = points_to_expression_to_type(e, &to_be_freed);
   type ct = compute_basic_concrete_type(t);
   if(to_be_freed) free_type(t);
   return ct;
 }

References compute_basic_concrete_type(), free_type(), and points_to_expression_to_type().

Referenced by binary_intrinsic_call_to_points_to_sinks(), expression_to_points_to_cells(), freed_list_to_points_to(), intrinsic_call_condition_to_points_to(), intrinsic_call_to_points_to(), memory_dereferencing_p(), semantics_expression_to_points_to_sinks(), and unary_intrinsic_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_expression_to_pointed_type()

type points_to_expression_to_pointed_type ( expression e )

Return a new allocated type "t" of the address pointed by expression "e", if expression "e" denotes an address.

"t" should not be freed.

We should return a pointer towards an array of dimension n-1. The first dimension is lost.

Build the pointed type, copy of cet except for its first dimension

Build the poiinter type

Definition at line 631 of file type.c.

 {
   type t = type_undefined;
   bool to_be_freed;
   type et = points_to_expression_to_type(e, &to_be_freed);
   type cet = compute_basic_concrete_type(et);
   if(to_be_freed) free_type(et);
  
   if(pointer_type_p(cet)) {
     type pt = type_to_pointed_type(cet);
     t = copy_type(compute_basic_concrete_type(pt));
   }
   else if(array_type_p(cet)) {
     /* We should return a pointer towards an array of dimension
        n-1. The first dimension is lost. */
     variable cet_v = type_variable(cet);
     list cet_v_dl = variable_dimensions(cet_v);
     /* Build the pointed type, copy of cet except for its first dimension */
     list ndl = gen_full_copy_list(CDR(cet_v_dl));
     basic nat_b = copy_basic(variable_basic(cet_v));
     variable nat_v = make_variable(nat_b, ndl, NIL);
     type nat = make_type_variable(nat_v);
     /* Build the poiinter type*/
     // variable v = type_variable(nat);
     basic b = make_basic_pointer(nat);
     variable v = make_variable(b, NIL, NIL);
     t = make_type_variable(v);
   }
   else
     pips_internal_error("Arg. is not in definition domain.\n");
   return t;
 }

References array_type_p(), CDR, compute_basic_concrete_type(), copy_basic(), copy_type(), free_type(), gen_full_copy_list(), make_basic_pointer(), make_type_variable(), make_variable(), NIL, pips_internal_error, pointer_type_p(), points_to_expression_to_type(), type_to_pointed_type(), type_undefined, type_variable, variable_basic, and variable_dimensions.

Referenced by expression_to_points_to_sinks_with_offset(), and unary_intrinsic_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_expression_to_type()

type points_to_expression_to_type	(	expression	e,
		bool *	to_be_freed
	)

FI: I need more generality than is offered by expression_to_type() because fields are assimilated to subscripts.

In order to type t[*] as well as t[0]...

Parameters

to_be_freed o_be_freed

Definition at line 592 of file type.c.

 {
   type t = type_undefined;
   syntax s = expression_syntax(e);
   if(syntax_reference_p(s)) {
     reference r = syntax_reference(s);
     t = points_to_reference_to_type(r, to_be_freed);
   }
   else {
     /* In order to type t[*] as well as t[0]... */
     expression ne = copy_expression(e);
     eliminate_calls_to_unbounded(ne);
     *to_be_freed = true;
     t = expression_to_type(ne);
     free_expression(ne);
   }
  
   return t;
 }

References copy_expression(), eliminate_calls_to_unbounded(), expression_syntax, expression_to_type(), free_expression(), points_to_reference_to_type(), syntax_reference, syntax_reference_p, and type_undefined.

Referenced by assignment_to_points_to(), check_rhs_value_types(), expression_to_points_to_sources(), pointer_arithmetic_to_points_to(), points_to_expression_to_concrete_type(), points_to_expression_to_pointed_type(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_list_sort()

list points_to_list_sort ( list ptl )

Allocate a copy of ptl and sort it.

It might be better to admit a side effect on ptl and to let the caller copy the liste before sorting.

(gen_cmp_func_t)

Parameters

ptl tl

Definition at line 389 of file prettyprint.c.

 {
   list sptl = gen_full_copy_list(ptl);
  
   gen_sort_list(sptl, /* (gen_cmp_func_t) */ points_to_compare_cells);
  
   return sptl;
 }

References gen_full_copy_list(), gen_sort_list(), and points_to_compare_cells().

Referenced by text_points_to_relations(), and words_points_to_list().

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:

◆ points_to_reference_to_concrete_type()

type points_to_reference_to_concrete_type ( reference r )

Definition at line 685 of file type.c.

 {
   bool to_be_freed;
   type t = points_to_reference_to_type(r, &to_be_freed);
   type ct = compute_basic_concrete_type(t);
   if(to_be_freed) free_type(t);
   return ct;
 }

References compute_basic_concrete_type(), free_type(), and points_to_reference_to_type().

Referenced by analyzed_reference_p(), assign_rhs_to_reflhs_to_transformer(), cells_to_read_or_write_effects(), consistent_points_to_arc_p(), create_values_for_simple_effect(), filter_formal_context_according_to_actual_context(), find_points_to_subscript_for_type(), generic_eval_cell_with_points_to(), generic_reference_to_transformer(), generic_transform_sink_cells_from_matching_list(), make_location_entity(), module_to_value_mappings(), new_filter_formal_context_according_to_actual_context(), perform_array_element_substitutions_in_transformer(), points_to_with_stripped_sink(), reference_to_address_entity(), reference_to_points_to_sinks(), semantics_usable_points_to_reference_p(), subscripted_reference_to_points_to(), substitute_stubs_in_transformer_with_translation_binding(), and use_default_sink_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_reference_to_final_dimension()

int points_to_reference_to_final_dimension ( reference r )

Compute the number of array subscript at the end of a points_to_reference.

Look for the last field subscript and count the number of subscripts after it. If no field susbcript is found, then all subscripts are final array subscripts.

To make thinks easier, the subscript list is reversed.

Definition at line 244 of file points_to.c.

 {
   list sl = reference_indices(r);
   sl = gen_nreverse(sl);
   int d = 0;
   FOREACH(EXPRESSION, e, sl) {
     if(field_reference_expression_p(e))
       break;
     else
       d++;
   }
   sl = gen_nreverse(sl);
   reference_indices(r) = sl;
   return d;
 }

References EXPRESSION, field_reference_expression_p(), FOREACH, gen_nreverse(), and reference_indices.

Here is the call graph for this function:

◆ points_to_reference_to_type()

type points_to_reference_to_type	(	reference	ref,
		bool *	to_be_freed
	)

FI: I need more generality than is offered by cell_to_type()

Maybe because of fields.

Surely because of implicit arrays linked to scalar pointers

Parameters

ref	ef
to_be_freed	o_be_freed

Definition at line 527 of file type.c.

 {
   type t = type_undefined;
  
   entity v = reference_variable(ref);
   list sl = reference_indices(ref);
  
   if(ENDP(sl)) {
     t = entity_type(v);
     *to_be_freed = false;
   }
   else {
     int ns = (int) gen_length(sl);
     expression fs = EXPRESSION(CAR(sl));
     bool int_p = expression_integer_constant_p(fs);
     // FI: faire un cas particulier pour des cas comme i[1] ou i est un scalaire?
     // FI: I do not know what can happen with struct objects; they are
     // scalar, a dimension may be added and nevertheless a field may be
     // accessed....
     if(entity_scalar_p(v) && ns==1 && int_p) {
       *to_be_freed = false;
       t = entity_type(v);
     }
     else {
       expression ls = EXPRESSION(CAR(gen_last(sl)));
       syntax lss = expression_syntax(ls);
       if(syntax_reference_p(lss)) {
         reference r = syntax_reference(lss);
         entity f = reference_variable(r);
         if(entity_field_p(f)) {
           t = entity_type(f);
           *to_be_freed = false;
         }
       }
     }
   }
     
   if(type_undefined_p(t))
     t = cell_reference_to_type(ref, to_be_freed);
  
   return t;
 }

References CAR, cell_reference_to_type(), ENDP, entity_field_p(), entity_scalar_p(), entity_type, EXPRESSION, expression_integer_constant_p(), expression_syntax, f(), gen_last(), gen_length(), int, ref, reference_indices, reference_variable, syntax_reference, syntax_reference_p, type_undefined, and type_undefined_p.

Referenced by adapt_reference_to_type(), create_scalar_stub_sink_cell(), gen_may_constant_paths(), gen_must_constant_paths(), opkill_may_constant_path(), opkill_must_constant_path(), points_to_cell_to_type(), points_to_expression_to_type(), points_to_reference_to_concrete_type(), points_to_reference_to_typed_index(), and reference_add_field_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_reference_to_typed_index()

list points_to_reference_to_typed_index	(	reference	r,
		type	t
	)

Look for the index in "r" that corresponds to a pointer of type "t" and return the corresponding element list.

In other words, the type of "&r" is "t".

It is done in a very inefficient way

Definition at line 361 of file points_to.c.

 {
   bool to_be_freed;
   type rt = points_to_reference_to_type(r, &to_be_freed);
   list rsl = reference_indices(r); // reference subscript list
   pips_assert("t is a pointer type", C_pointer_type_p(t));
   type pt = C_type_to_pointed_type(t);
   list psl = list_undefined; // pointed subscript list
  
   if(array_pointer_type_equal_p(rt, pt))
     psl = gen_last(rsl);
   else {
     if(to_be_freed) free_type(rt);
     entity v = reference_variable(r);
     list nl = NIL;
     int i;
     int n = (int) gen_length(rsl);
     reference nr = make_reference(v, nl);
     bool found_p = false;
  
     for(i=0;i<n;i++) {
       nl = gen_nconc(nl, CONS(EXPRESSION,
                               copy_expression(EXPRESSION(gen_nth(i, rsl))),
                               NIL));
       reference_indices(nr) = nl;
       rt = points_to_reference_to_type(nr, &to_be_freed);
       if(array_pointer_type_equal_p(rt, pt)) {
         found_p = true;
         break;
       }
     }
  
     free_reference(nr);
  
     if(found_p)
       psl = gen_nthcdr(i, rsl);
     else {
       // The issue may be due to a user bug, as was the case in
       // Strict_typing.sub/malloc03.c
       if(entity_heap_location_p(v)) {
         // It would be nice to have a current statement stack...
         pips_user_error("The dynamic allocation of \"%s\" is likely "
                         "to be inadequate with its use in the current "
                         "statement.\n", entity_local_name(v));
       }
       else
         pips_internal_error("Type not found.\n");
     }
   }
  
   free_type(pt);
  
   return psl;
 }

References array_pointer_type_equal_p(), C_pointer_type_p(), C_type_to_pointed_type(), CONS, copy_expression(), entity_heap_location_p(), entity_local_name(), EXPRESSION, free_reference(), free_type(), gen_last(), gen_length(), gen_nconc(), gen_nth(), gen_nthcdr(), int, list_undefined, make_reference(), NIL, pips_assert, pips_internal_error, pips_user_error, points_to_reference_to_type(), reference_indices, and reference_variable.

Referenced by offset_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_reference_update_final_subscripts()

void points_to_reference_update_final_subscripts	(	reference	r,
		list	nsl
	)

Substitute the subscripts "sl" in points-to reference "r" just after the last field subscript by "nsl".

"sl" must be broken into three parts, possibly empty:

The first part that ends up at the last field reference. It may be empty when no field is referenced.
The second part that starts just after the last field reference and that counts at most as many elements as the new subscript list, "nsl". This part must be substituted.
The third part that is left unchanged after substitution.

Issue: how do you know that the initial array subscript must be preserved because it is an implicit dimension added for pointer arithmetics?

build sl1

Parameters

nsl sl

Definition at line 278 of file points_to.c.

 {
   list sl = reference_indices(r);
   list sl1 = NIL, sl3 = NIL, sl23 = NIL;
  
   sl = gen_nreverse(sl); // sl1 and sl23 are built in the right order
   bool found_p = false;
   bool skip_one_p = false; // to skip indices added for pointer arithmetic
   FOREACH(EXPRESSION, e, sl) {
     if(field_reference_expression_p(e)) {
       type et = expression_to_type(e);
       if(pointer_type_p(et))
         skip_one_p = true;
       found_p = true;
       free_type(et);
     }
     if(found_p) {
       /* build sl1 */
       sl1 = CONS(EXPRESSION, e , sl1);
     }
     else
       sl23 = CONS(EXPRESSION, e , sl23);
   }
  
   if(skip_one_p && ENDP(sl23) && !ENDP(nsl)) {
     pips_internal_error("We are not generating a memory access constant path.\n");
   }
  
   // FI: place the new indices as early as possible
 #if 0
   int n = (int) gen_length(nsl);
   int i = 0;
   FOREACH(EXPRESSION, e, sl23) {
     if(skip_one_p) {
       sl1 = gen_nconc(sl1, CONS(EXPRESSION, e , NIL));
       skip_one_p = false;
     }
     else {
       if(i<n)
         free_expression(e);
       else
         sl3 = gen_nconc(sl3, CONS(EXPRESSION, e, NIL));
       i++;
     }
   }
  
   sl = gen_nconc(sl1, nsl);
   sl = gen_nconc(sl, sl3);
 #endif
  
   // FI: place the new indices as late as possible
   int n = (int) gen_length(nsl);
   int n23 = (int) gen_length(sl23);
   int i = 0;
   FOREACH(EXPRESSION, e, sl23) {
     if(i>=n23-n)
       free_expression(e);
     else
       sl3 = gen_nconc(sl3, CONS(EXPRESSION, e, NIL));
     i++;
   }
  
   sl = gen_nconc(sl1, sl3);
   sl = gen_nconc(sl, nsl);
  
   gen_free_list(sl23);
   reference_indices(r) = sl;
  
   // We do not want to generate indirection in the reference
   // The exactitude information is not relevant here
   // bool exact_p;
   // pips_assert("The reference is a constant memory access path",
   //             !effect_reference_dereferencing_p( r, &exact_p));
   // Might only work for standard references and not for points-to
   // references: core dumps with points-to references.
 }

References CONS, ENDP, EXPRESSION, expression_to_type(), field_reference_expression_p(), FOREACH, free_expression(), free_type(), gen_free_list(), gen_length(), gen_nconc(), gen_nreverse(), int, NIL, pips_internal_error, pointer_type_p(), and reference_indices.

Referenced by subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_sink_cell_compatible_p()

bool points_to_sink_cell_compatible_p ( cell )

◆ points_to_source_cell_compatible_p()

bool points_to_source_cell_compatible_p ( cell c )

Definition at line 1241 of file type.c.

 {
   bool compatible_p = true;
  
   if(nowhere_cell_p(c))
     compatible_p = false;
   else if(null_cell_p(c))
     compatible_p = false;
  
   return compatible_p;
 }

References nowhere_cell_p(), and null_cell_p().

Referenced by points_to_cell_types_compatibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_with_stripped_sink()

points_to points_to_with_stripped_sink	(	points_to	pt,
		int(*)(void)	line_number_func
	)

The value of the source can often be expressed with different subscript lists.

For instance, a, a[0], a[0][0] have different types but the same value if a is a 2-D array.

This function allocated a new points-to object whose sink has a minimal number of indices.

FI: I have added this function to deal with pointers to arrays. It is called from generic_reference_to_points_to_matching_list() to try to adapt the points-to information to the undefined requirements of Beatrice's functions for regions_with_points_to. I do not think the function below is correct when structs are involved... The stripping may be useful, but it should be much more careful.

adapt_reference_to_type() might be better here to adjust the subscripts in sink.

Add the implicit dimension

Dealing with the special case of a constant p -> "foo"

The other option would be to accept "foo"[0] as a valid reference... Extending references to constant functions is a first step...

Parameters

pt t

Definition at line 1074 of file points_to.c.

 {
   cell source = points_to_source(pt);
   cell sink = points_to_sink(pt);
   cell new_sink_cell = cell_undefined;
  
   // FI: first implementation
   if(false) {
     reference source_r = cell_any_reference(source);
     list source_sl = reference_indices(source_r);
     list c_source_sl = list_undefined;
  
     reference sink_r = cell_any_reference(sink);
     // FI: sink_sl is longer than source_sl if pt is semantically correct
     list sink_sl = reference_indices(sink_r);
     list c_sink_sl = list_undefined;
     entity sink_e = reference_variable(sink_r);
  
     list new_sink_sl = NIL;
     for(c_source_sl = source_sl, c_sink_sl = sink_sl;
         !ENDP(c_source_sl);
         POP(c_source_sl), POP(c_sink_sl)) {
       expression s = copy_expression(EXPRESSION(CAR(c_sink_sl)));
       new_sink_sl = CONS(EXPRESSION, s, new_sink_sl);
     }
     if(!get_bool_property("POINTS_TO_STRICT_POINTER_TYPES")
        && !anywhere_cell_p(sink)
        && !cell_typed_anywhere_locations_p(sink)
        && !ENDP(c_sink_sl)) {
       /* Add the implicit dimension */
       expression s = copy_expression(EXPRESSION(CAR(c_sink_sl)));
       new_sink_sl = CONS(EXPRESSION, s, new_sink_sl);
     }
     new_sink_sl = gen_nreverse(new_sink_sl);
  
     new_sink_cell = make_cell_reference(make_reference(sink_e, new_sink_sl));
   }
   else {
     // Second implementation
     if(anywhere_cell_p(sink) || cell_typed_anywhere_locations_p(sink)
        || null_cell_p(sink) || nowhere_cell_p(sink)
        // FI: why is the typed heap cell not handled too?
        || heap_cell_p(sink)) {
       new_sink_cell = copy_cell(sink);
     }
     else {
       new_sink_cell = copy_cell(sink);
       reference n_sink_r = cell_any_reference(new_sink_cell);
       type source_t = points_to_cell_to_concrete_type(source);
       if(pointer_type_p(source_t)) {
         type source_pt = type_to_pointed_type(source_t);
         if(adapt_reference_to_type(n_sink_r, source_pt, line_number_func))
           ;
         else {
           /* Dealing with the special case of a constant p -> "foo"
            *
            * The other option would be to accept "foo"[0] as a valid
            * reference... Extending references to constant functions
            * is a first step...
            */
           bool ok_p = false;
           type sink_t = points_to_reference_to_concrete_type(n_sink_r);
           if(char_type_p(source_pt)) {
             if(char_star_constant_function_type_p(sink_t))
               ok_p = true;
           }
           if(!ok_p)
             pips_internal_error("The type of a sink cell, \"%s\", is not compatible with the source cell, \"%s\".\n",
                                 safe_type_to_string(sink_t),
                                 safe_type_to_string(source_t));
         }
       }
  
       else
         pips_internal_error("The type of a source cell is not a pointer.\n");
     }
   }
  
   points_to npt = make_points_to(copy_cell(source),
                                  new_sink_cell,
                                  copy_approximation(points_to_approximation(pt)),
                                  make_descriptor_none());
   return npt;
 }

References adapt_reference_to_type(), anywhere_cell_p(), CAR, cell_any_reference(), cell_typed_anywhere_locations_p(), cell_undefined, char_star_constant_function_type_p(), char_type_p(), CONS, copy_approximation(), copy_cell(), copy_expression(), ENDP, EXPRESSION, gen_nreverse(), get_bool_property(), heap_cell_p(), list_undefined, make_cell_reference(), make_descriptor_none(), make_points_to(), make_reference(), NIL, nowhere_cell_p(), null_cell_p(), pips_internal_error, pointer_type_p(), points_to_approximation, points_to_cell_to_concrete_type(), points_to_reference_to_concrete_type(), points_to_sink, points_to_source, POP, reference_indices, reference_variable, safe_type_to_string(), and type_to_pointed_type().

Referenced by generic_reference_to_points_to_matching_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ points_to_words_reference()

list points_to_words_reference ( reference r )

Specific handling of references appearing in points_to.

Definition at line 232 of file prettyprint.c.

 {
   extern const char* entity_minimal_user_name(entity);
  
   // Normal implementation, used for validation:
   return Words_Any_Reference(r, NIL, entity_minimal_user_name);
   // To ease debugging, use:
   //return words_any_reference(r, NIL, entity_full_name);
 }

References entity_minimal_user_name(), NIL, and Words_Any_Reference().

Referenced by word_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_pointer_value()

void print_pointer_value ( cell_relation pv )

Parameters

pv v

Definition at line 615 of file prettyprint.c.

 {
   text t = text_pointer_value(pv);
   print_text(stderr, t);
   free_text(t);
 }

References free_text(), print_text(), and text_pointer_value().

Referenced by print_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_pointer_values()

void print_pointer_values ( list lpv )

Parameters

lpv pv

Definition at line 622 of file prettyprint.c.

 {
   fprintf(stderr,"\n");
   if (ENDP(lpv))
     fprintf(stderr,"<none>");
   else
     {
       FOREACH(CELL_RELATION, pv, lpv)
         {
           print_pointer_value(pv);
         }
     }
   fprintf(stderr,"\n");
 }

References CELL_RELATION, ENDP, FOREACH, fprintf(), and print_pointer_value().

Referenced by print_pv_results().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_points_to_cell()

void print_points_to_cell ( cell c )

Debug: use stderr.

Definition at line 196 of file points_to.c.

 {
   fprint_points_to_cell(stderr, c);
 }

References fprint_points_to_cell().

Referenced by print_points_to_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_points_to_cells()

void print_points_to_cells ( list cl )

Debug.

Parameters

cl l

Definition at line 202 of file points_to.c.

 {
   if(ENDP(cl))
     fprintf(stderr, "Empty cell list");
   else {
     entity m = get_current_module_entity();
     FOREACH(CELL, c, cl) {
       reference r = cell_any_reference(c);
       entity v = reference_variable(r);
       /* *ANY_MODULE* is unfortunately not an entity... */
       entity mv =  module_name_to_entity(entity_module_name(v));
       if(!entity_undefined_p(mv) && m!=mv)
         fprintf(stderr,"%s" MODULE_SEP_STRING, entity_local_name(mv));
       print_points_to_cell(c);
       if(!ENDP(CDR(cl)))
         fprintf(stderr, ", ");
     }
   }
   fprintf(stderr, "\n");
 }

References CDR, CELL, cell_any_reference(), ENDP, entity_local_name(), entity_module_name(), entity_undefined_p, FOREACH, fprintf(), get_current_module_entity(), module_name_to_entity(), MODULE_SEP_STRING, print_points_to_cell(), and reference_variable.

Here is the call graph for this function:

◆ pt_to_list_undefined_p()

bool pt_to_list_undefined_p ( void )

points_to.c

Referenced by add_values_for_simple_effects_of_statement(), any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), c_user_call_to_transformer(), lhs_expression_to_transformer(), new_substitute_stubs_in_transformer(), points_to_unary_operation_to_transformer(), semantics_expression_to_points_to_sinks(), semantics_expression_to_points_to_sources(), and substitute_stubs_in_transformer().

Here is the caller graph for this function:

◆ pv_cells_mergeable_p()

bool pv_cells_mergeable_p	(	cell_relation	pv1,
		cell_relation	pv2
	)

value_of pvs, try to see if their cells are inverted

Parameters

pv1	v1
pv2	v2

Definition at line 230 of file pointer_values.c.

 {
  
  
   bool value_of_1_p = cell_relation_second_value_of_p(pv1);
   bool value_of_2_p = cell_relation_second_value_of_p(pv1);
  
   if ( (value_of_1_p && !value_of_2_p) || (value_of_2_p && !value_of_1_p))
     return false;
  
   cell c_first_1 = cell_relation_first_cell(pv1);
   cell c_second_1 = cell_relation_second_cell(pv1);
  
   cell c_first_2 = cell_relation_first_cell(pv2);
   cell c_second_2 = cell_relation_second_cell(pv2);
  
   int n_first_first = cell_compare(&c_first_1, &c_first_2);
  
   if (n_first_first == 0)
     {
       int n_second_second = cell_compare(&c_second_1, &c_second_2);
       
       if (n_second_second != 0)
         {
           if (cell_entity(c_second_1) != cell_entity(c_second_2)
               || (gen_length(reference_indices(cell_any_reference(c_second_1)))
                   != gen_length(reference_indices(cell_any_reference(c_second_2)))))
             return false;
         }
     }
   else
     {
       if (!value_of_1_p)
         return false;
       else /* value_of pvs, try to see if their cells are inverted */
         {
           int n_first_second = cell_compare(&c_first_1, &c_second_2);
           if (n_first_second == 0)
             {
               int n_second_first = cell_compare(&c_second_1, &c_first_2);
               
               if (n_second_first != 0)
                 return false;
             }   
           else
             return false;
           
         }
     }
   
   descriptor d1 = cell_relation_descriptor(pv1);
   descriptor d2 = cell_relation_descriptor(pv1);
  
   if (descriptor_none_p(d1) && descriptor_none_p(d2))
     {
       return true;
     }
   else
     pips_internal_error("Convex pointer_values not implemented yet");
   
   return false;
 }

References cell_any_reference(), cell_compare(), cell_entity(), cell_relation_descriptor, cell_relation_first_cell, cell_relation_second_cell, cell_relation_second_value_of_p, descriptor_none_p, gen_length(), pips_internal_error, and reference_indices.

Referenced by pvs_union_combinable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pv_cells_syntactically_equal_p()

bool pv_cells_syntactically_equal_p	(	cell_relation	pv1,
		cell_relation	pv2
	)

value_of pvs, try to see if their cells are inverted

Parameters

pv1	v1
pv2	v2

Definition at line 162 of file pointer_values.c.

 {
  
  
   bool value_of_1_p = cell_relation_second_value_of_p(pv1);
   bool value_of_2_p = cell_relation_second_value_of_p(pv1);
  
   if ( (value_of_1_p && !value_of_2_p) || (value_of_2_p && !value_of_1_p))
     return false;
  
   cell c_first_1 = cell_relation_first_cell(pv1);
   cell c_second_1 = cell_relation_second_cell(pv1);
  
   cell c_first_2 = cell_relation_first_cell(pv2);
   cell c_second_2 = cell_relation_second_cell(pv2);
  
   int n_first_first = cell_compare(&c_first_1, &c_first_2);
  
   if (n_first_first == 0)
     {
       int n_second_second = cell_compare(&c_second_1, &c_second_2);
       
       if (n_second_second != 0)
         return false;
     }
   else
     {
       if (!value_of_1_p)
         return false;
       else /* value_of pvs, try to see if their cells are inverted */
         {
           int n_first_second = cell_compare(&c_first_1, &c_second_2);
           if (n_first_second == 0)
             {
               int n_second_first = cell_compare(&c_second_1, &c_first_2);
               
               if (n_second_first != 0)
                 return false;
             }   
           else
             return false;
           
         }
     }
   
   descriptor d1 = cell_relation_descriptor(pv1);
   descriptor d2 = cell_relation_descriptor(pv1);
  
   if (descriptor_none_p(d1) && descriptor_none_p(d2))
     {
       return true;
     }
   else
     pips_internal_error("Convex pointer_values not implemented yet");
   
   return false;
 }

References cell_compare(), cell_relation_descriptor, cell_relation_first_cell, cell_relation_second_cell, cell_relation_second_value_of_p, descriptor_none_p, and pips_internal_error.

Referenced by simple_pvs_syntactically_equal_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:

◆ recursive_store_independent_points_to_reference_p()

bool recursive_store_independent_points_to_reference_p	(	type	t,
		list	sl
	)

Parameters

t	any type, but here initial reference type
sl	remaining subscript list, all subscripts are supposed to be store independent

Returns: true none of the subsequence subscript implies a dereferencing

Reduce the length of the subscript list

There are indices because of the first test on the number of subscripts

Parameters

sl l

Definition at line 1169 of file points_to.c.

                                                                        {
   bool independent_p = false;
  
   if(ENDP(sl))
     independent_p = true;
   else if(struct_type_p(t)) {
     expression se = EXPRESSION(CAR(sl));
     reference r = expression_reference(se);
     entity f = reference_variable(r);
     type nt = entity_basic_concrete_type(f);
     independent_p = recursive_store_independent_points_to_reference_p(nt, CDR(sl));
   }
   else if(array_type_p(t)) {
     unsigned int d = array_type_dimension(t); 
     if(gen_length(sl)<=d)
       independent_p = true;
     else {
       type nt = array_type_to_element_type(t);
       list nsl = sl;
       unsigned int i;
       // Skip the array subscripts
       for(i=0;i<d;i++)
         nsl = CDR(nsl);
       independent_p = recursive_store_independent_points_to_reference_p(nt, nsl);
     }
   }
   else if(pointer_type_p(t)) {
     /* There are indices because of the first test on the number of subscripts */
     independent_p = false;
   }
   else {
     // FI: It is more difficult... and it must have been programmed
     // somewhere else.
     pips_internal_error("Not implemented yet");
   }
  
   return independent_p;
 }

References array_type_dimension(), array_type_p(), array_type_to_element_type(), CAR, CDR, ENDP, entity_basic_concrete_type(), EXPRESSION, expression_reference(), f(), gen_length(), pips_internal_error, pointer_type_p(), recursive_store_independent_points_to_reference_p(), reference_variable, and struct_type_p().

Referenced by recursive_store_independent_points_to_reference_p(), and store_independent_points_to_reference_p().

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:

◆ reference_typed_anywhere_locations_p()

bool reference_typed_anywhere_locations_p ( reference r )

test if a reference is the bottom of the lattice

Definition at line 141 of file anywhere_abstract_locations.c.

 {
   entity e = reference_variable(r);
   bool anywhere_p = entity_typed_anywhere_locations_p(e);
   return anywhere_p;
 }

References entity_typed_anywhere_locations_p(), and reference_variable.

Referenced by any_assign_to_transformer(), and cell_typed_anywhere_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reference_unbounded_indices_p()

bool reference_unbounded_indices_p ( reference r )

This function should be at expression.c.

It already exist and is called reference_with_unbounded_indices_p() but includes two cases that should be disjoint: constant indices and unbounded ones.

Definition at line 1373 of file type.c.

 {
   list sel = reference_indices(r);
   bool unbounded_p = true;
  
   FOREACH(EXPRESSION, se, sel) {
       if(!unbounded_expression_p(se)) {
         unbounded_p = false;
         break;
       }
     }
   return unbounded_p;
 }

References EXPRESSION, FOREACH, reference_indices, and unbounded_expression_p().

Referenced by strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ related_points_to_cell_in_list_p()

bool related_points_to_cell_in_list_p	(	cell	c,
		list	L
	)

Two cells are related if they are based on the same entity.

Definition at line 149 of file points_to.c.

 {
   bool found_p = false;
   reference rc = cell_any_reference(c);
   entity ec = reference_variable(rc);
   FOREACH(CELL, lc, L) {
     reference rlc = cell_any_reference(lc);
     entity elc = reference_variable(rlc);
     if(ec==elc) {
       found_p =true;
       break;
     }
   }
   return found_p;
 }

References CELL, cell_any_reference(), FOREACH, and reference_variable.

Referenced by filter_formal_context_according_to_actual_context(), freed_list_to_points_to(), new_filter_formal_context_according_to_actual_context(), 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:

◆ related_points_to_cells_p()

bool related_points_to_cells_p	(	cell	c1,
		cell	c2
	)

Parameters

c1	1
c2	2

Definition at line 165 of file points_to.c.

 {
   bool related_p = false;
   reference rc1 = cell_any_reference(c1);
   entity ec1 = reference_variable(rc1);
   reference rc2 = cell_any_reference(c2);
   entity ec2 = reference_variable(rc2);
   related_p = (ec1==ec2);
   return related_p;
 }

References cell_any_reference(), and reference_variable.

Referenced by sink_to_sources(), and unreachable_points_to_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_pt_to_list()

void reset_pt_to_list ( void )

Referenced by generic_points_to_analysis(), preconditions_inter_full_with_points_to(), print_xml_application_main_with_points_to(), print_xml_application_with_points_to(), refine_transformers_with_points_to(), transformers_inter_full_with_points_to(), and update_precondition_with_call_site_preconditions().

Here is the caller graph for this function:

◆ set_pt_to_list()

void set_pt_to_list ( statement_points_to )

Referenced by preconditions_inter_full_with_points_to(), print_xml_application_main_with_points_to(), print_xml_application_with_points_to(), refine_transformers_with_points_to(), transformers_inter_full_with_points_to(), and update_precondition_with_call_site_preconditions().

Here is the caller graph for this function:

◆ similar_arc_in_points_to_set_p()

bool similar_arc_in_points_to_set_p	(	points_to	spt,
		set	in,
		approximation *	pa
	)

See if an arc like "spt" exists in set "in", regardless of its approximation.

If yes, returns the approximation of the arc found in "in".

See also arc_in_points_to_set_p(), which requires full identity

Parameters

spt	pt
in	n
pa	a

Definition at line 929 of file points_to.c.

 {
   bool in_p = false;
   cell spt_source = points_to_source(spt);
   cell spt_sink = points_to_sink(spt);
   SET_FOREACH(points_to, pt, in) {
     if(points_to_cell_equal_p(spt_source, points_to_source(pt))
        && points_to_cell_equal_p(spt_sink, points_to_sink(pt))) {
       *pa = points_to_approximation(pt);
       in_p = true;
       break;
     }
   }
   return in_p;
 }

References points_to_approximation, points_to_cell_equal_p(), points_to_sink, points_to_source, and SET_FOREACH.

Referenced by filter_formal_out_context_according_to_formal_in_context().

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:

◆ store_independent_points_to_indices_p()

bool store_independent_points_to_indices_p ( list sl )

check that the subscript list il is either empty or made of integers or fields or unbounded entity "*".

What would you do with a constant range ?

Parameters

sl l

Definition at line 1301 of file points_to.c.

 {
   bool constant_p = true;
  
   FOREACH(EXPRESSION, se, sl) {
     if(!extended_integer_constant_expression_p(se)) {
       syntax s = expression_syntax(se);
       if(syntax_reference_p(s)) {
         reference r = syntax_reference(s);
         entity f = reference_variable(r);
         if(!entity_field_p(f)) {
           constant_p = false;
           break;
         }
       }
       else if(syntax_call_p(s)) {
         call c = syntax_call(s);
         entity f = call_function(c);
         if(!unbounded_entity_p(f)) {
           constant_p = false;
           break;
         }
       }
       else {
         constant_p = false;
         break;
       }
     }
   }
   return constant_p;
 }

References call_function, constant_p(), entity_field_p(), EXPRESSION, expression_syntax, extended_integer_constant_expression_p(), f(), FOREACH, reference_variable, syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, and unbounded_entity_p().

Referenced by store_independent_points_to_reference_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_independent_points_to_reference_p()

bool store_independent_points_to_reference_p ( reference r )

Functions for points-to references, the kind of references used in points-to cells.

Does this points-to reference define the same set of memory locations regardless of the current (environment and) memory state?

The reference indices can be used to encode fields in data structures and can be applied to pointers as offset.

The types associated to the reference and to prefixes of the index list change. So a pointer dereferencing can be hidden anywhere. For instance, a[i][2] can be:

a 2-D array element,
a[i]+2 if a[i] is a 1-D array of pointers,
a.i[2], the second element of a 1-D array embedded as field i in struct a,
a.i+2, if field i is a pointer embedded as field i in struct a,
&a[i][2][0]... if a is an array of dimension 3 or more

Remember that *p is equivalent and encoded as p[0].

To guarantee store independence, either

the list of indices is empty, which covers abstract locations such as anywhere, null, etc.

or

the list of indices is a list of integer constants and fields and none of the intermediate types that are still indexed are pointers unless a multidimensional array is used...

Beware of named types...

Definition at line 1247 of file points_to.c.

 {
   list il = reference_indices(r);
   bool independent_p = ENDP(il); // any variable is a constant address
  
   if(!independent_p) {
     if(!store_independent_points_to_indices_p(il))
       independent_p = false; // at least one index is store-dependent
     else {
       entity v = reference_variable(r);
       type t = entity_basic_concrete_type(v);
       if(type_functional_p(t))
         independent_p = true;
       else
         independent_p =
           recursive_store_independent_points_to_reference_p(t, il);
     }
   }
  
   return independent_p;
 }

References ENDP, entity_basic_concrete_type(), recursive_store_independent_points_to_reference_p(), reference_indices, reference_variable, store_independent_points_to_indices_p(), and type_functional_p.

Referenced by analyzed_reference_p(), assign_rhs_to_reflhs_to_transformer(), consistent_points_to_arc_p(), and reference_to_address_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_or_update_pt_to_list()

void store_or_update_pt_to_list	(	statement	,
		points_to_list
	)

Referenced by fi_points_to_storage(), and points_to_storage().

Here is the caller graph for this function:

◆ store_pt_to_list()

void store_pt_to_list	(	statement	,
		points_to_list
	)

◆ strict_constant_path_p()

bool strict_constant_path_p ( reference r )

Definition at line 1407 of file type.c.

 {
   bool constant_path = false;
   entity v = reference_variable(r);
   list l_ind = reference_indices(r);
  
   // Test the different top and bottom area
   if (entity_all_locations_p(v)
       || entity_anywhere_locations_p(v) || entity_typed_anywhere_locations_p(v)
       || entity_nowhere_locations_p(v) || entity_typed_nowhere_locations_p(v)
       || entity_all_module_locations_p(v)
       ) {
     constant_path = true;
   }
   else if (entity_all_module_heap_locations_p(v)
       || entity_all_heap_locations_p(v)
       ) {
     constant_path = true;
   }
   else if (entity_all_module_stack_locations_p(v)
       || entity_all_stack_locations_p(v)
       ) {
     constant_path = true;
   }
   else if (entity_all_module_static_locations_p(v)
       || entity_all_static_locations_p(v)
       ) {
     constant_path = true;
   }
   else if (entity_all_module_dynamic_locations_p(v)
       || entity_all_dynamic_locations_p(v)
       ) {
     constant_path = true;
   }
   else if (entity_abstract_location_p(v)) { // Maybe this test permit to eliminate the 4 test just before?
     constant_path = true;
   }
   // Test if it's the constant NULL
   else if (entity_null_locations_p(v)) {
     constant_path = true;
   }
   // Test if it's a formal parameter
   else if (entity_stub_sink_p(v)) {
     constant_path = true;
   }
   // Test if it's a heap element
   else if (heap_area_p(v)) {
     constant_path = true;
   }
   // Maybe not efficient enough, for array of struct or struct of array?
   // Test if it's a structure
   else if (struct_type_p(entity_type(v)) && !ENDP(l_ind)) {
     constant_path = true;
   }
   // Test if it's a array with only *
   else if (!ENDP(l_ind)) {
     // see reference_unbounded_indices_p
     constant_path = reference_unbounded_indices_p(r);
   }
  
   return constant_path;
 }

Referenced by can_be_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stub_entity_of_module_p()

bool stub_entity_of_module_p	(	entity	s,
		entity	m
	)

There are several ways to decide if entity "s" is local to "m": its module name, its belonging to the declarations of m, its storage,... Let's avoir string comparisons and list scans...

Definition at line 624 of file anywhere_abstract_locations.c.

 {
   bool stub_p = entity_stub_sink_p(s);
   if(stub_p) {
     /* There are several ways to decide if entity "s" is local to "m":
        its module name, its belonging to the declarations of m, its
        storage,... Let's avoir string comparisons and list scans... */
     storage ss = entity_storage(s);
     if(storage_ram_p(ss)) {
       ram rss = storage_ram(ss);
       entity f = ram_function(rss);
       stub_p = m==f;
     }
   }
   return stub_p;
 }

References entity_storage, entity_stub_sink_p(), f(), ram_function, storage_ram, and storage_ram_p.

Referenced by clean_up_points_to_stubs(), compute_points_to_binded_set(), and generic_points_to_set_to_stub_cell_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stub_points_to_cell_p()

bool stub_points_to_cell_p ( cell c )

Definition at line 108 of file points_to.c.

 {
   bool formal_p = true;
   reference r = cell_any_reference(c);
   entity v = reference_variable(r);
   formal_p = entity_stub_sink_p(v); // FI: can be a source too
   return formal_p;
 }

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

Referenced by freeable_points_to_cells(), freed_list_to_points_to(), freed_pointer_to_points_to(), null_equal_condition_to_points_to(), and points_to_to_context_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text_pointer_value()

text text_pointer_value ( cell_relation pv )

text text_region(effect reg) input : a region output : a text consisting of several lines of commentaries, representing the region modifies : nothing

of string

PREFIX

REFERENCES

DESCRIPTOR

sorts in such a way that constraints with phi variables come first.

APPROXIMATION

CLOSE

Parameters

pv v

Definition at line 480 of file prettyprint.c.

 {
   text tpv = text_undefined;
  
   bool foresys = false;
   string str_prefix = get_comment_continuation();
   char line_buffer[MAX_LINE_LENGTH];
   Psysteme sc;
   list /* of string */ ls;
  
   if (cell_relation_undefined_p(pv))
     {
       ifdebug(1)
         {
           return make_text(CONS(SENTENCE,
                                 make_sentence(is_sentence_formatted,
                                               strdup(concatenate(str_prefix,
                                                                  "undefined pointer value\n",
                                                                  NULL))),
                                 NIL));
         }
       else
         pips_user_warning("unexpected pointer value undefined\n");
     }
   else
     tpv = make_text(NIL);
  
   cell first_c = cell_relation_first_cell(pv);
   cell second_c = cell_relation_second_cell(pv);
  
   pips_assert("there should not be preference cells in pointer values (first) \n",
               !cell_preference_p(first_c));
   pips_assert("there should not be preference cells in pointer values (second) \n",
               !cell_preference_p(second_c));
  
   pips_assert("gaps not handled yet (first)", !cell_gap_p(first_c));
   pips_assert("gaps not handled yet (second)", !cell_gap_p(second_c));
  
   pips_assert("the first cell must have value_of interpretation\n",
               cell_relation_first_value_of_p(pv));
  
  
   reference first_r = cell_reference(first_c);
   reference second_r = cell_reference(second_c);
   approximation ap = cell_relation_approximation(pv);
   descriptor d = cell_relation_descriptor(pv);
  
   /* PREFIX
    */
   strcpy(line_buffer, get_comment_sentinel());
   append(" ");
  
   /* REFERENCES */
   ls = effect_words_reference(first_r);
  
   FOREACH(STRING, s, ls) {append(s);}
   gen_free_string_list(ls); ls = NIL;
  
   append(" == ");
  
   ls = effect_words_reference(second_r);
   if (cell_relation_second_address_of_p(pv))
     append("&");
  
   FOREACH(STRING, s, ls) {append(s);}
   gen_free_string_list(ls); ls = NIL;
  
   /* DESCRIPTOR */
   /* sorts in such a way that constraints with phi variables come first.
    */
   if(!descriptor_none_p(d))
     {
       sc = sc_copy(descriptor_convex(d));
       sc_lexicographic_sort(sc, is_inferior_cell_descriptor_pvarval);
       system_sorted_text_format(line_buffer, str_prefix, tpv, sc,
                                 (get_variable_name_t) pips_region_user_name,
                                 vect_contains_phi_p, foresys);
       sc_rm(sc);
     }
  
   /* APPROXIMATION */
   append(approximation_may_p(ap) ? " (may);" : " (exact);");
  
   /* CLOSE */
   close_current_line(line_buffer, tpv,str_prefix);
  
   return tpv;
 }

References append, approximation_may_p, cell_gap_p, cell_preference_p, cell_reference, cell_relation_approximation, cell_relation_descriptor, cell_relation_first_cell, cell_relation_first_value_of_p, cell_relation_second_address_of_p, cell_relation_second_cell, cell_relation_undefined_p, close_current_line(), concatenate(), CONS, descriptor_convex, descriptor_none_p, effect_words_reference(), FOREACH, gen_free_string_list(), get_comment_continuation(), get_comment_sentinel(), ifdebug, is_inferior_cell_descriptor_pvarval(), is_sentence_formatted, line_buffer, make_sentence(), make_text(), MAX_LINE_LENGTH, NIL, pips_assert, pips_region_user_name(), pips_user_warning, sc_copy(), sc_lexicographic_sort(), sc_rm(), SENTENCE, strdup(), STRING, system_sorted_text_format(), text_undefined, and vect_contains_phi_p().

Referenced by print_pointer_value(), and text_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text_pointer_values()

text text_pointer_values	(	list	lpv,
		string	header
	)

in case of loose_prettyprint, at least one region to print?

GO: No redundant test anymore, see text_statement_array_regions

header first

Parameters

lpv	pv
header	eader

Definition at line 571 of file prettyprint.c.

 {
     text tpv = make_text(NIL);
     /* in case of loose_prettyprint, at least one region to print? */
     bool loose_p = get_bool_property("PRETTYPRINT_LOOSE");
  
     /* GO: No redundant test anymore, see  text_statement_array_regions */
     if (lpv != (list) HASH_UNDEFINED_VALUE && lpv != list_undefined)
     {
       /* header first */
       char line_buffer[MAX_LINE_LENGTH];
       string str_prefix = get_comment_continuation();
       if (loose_p)
         {
           strcpy(line_buffer,"\n");
           append(get_comment_sentinel());
         }
       else
         {
           strcpy(line_buffer,get_comment_sentinel());
         }
       append(" ");
       append(header);
       if(ENDP(lpv))
         append(" none\n");
       else
         append("\n");
       ADD_SENTENCE_TO_TEXT(tpv,
                            make_sentence(is_sentence_formatted,
                                          strdup(line_buffer)));
       gen_sort_list(lpv, (int (*)(const void *,const void *)) pointer_value_compare);
       FOREACH(CELL_RELATION, pv, lpv)
         {
           MERGE_TEXTS(tpv, text_pointer_value(pv));
         }
  
       if (loose_p)
         ADD_SENTENCE_TO_TEXT(tpv,
                              make_sentence(is_sentence_formatted,
                                            strdup("\n")));
     }
     return tpv;
 }

References ADD_SENTENCE_TO_TEXT, append, CELL_RELATION, ENDP, FOREACH, gen_sort_list(), get_bool_property(), get_comment_continuation(), get_comment_sentinel(), HASH_UNDEFINED_VALUE, is_sentence_formatted, line_buffer, list_undefined, make_sentence(), make_text(), MAX_LINE_LENGTH, MERGE_TEXTS, NIL, pointer_value_compare(), strdup(), and text_pointer_value().

Referenced by generic_print_code_pv(), and text_pv().

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:

◆ types_compatible_for_effects_interprocedural_translation_p()

bool types_compatible_for_effects_interprocedural_translation_p	(	type	real_arg_t,
		type	formal_arg_t
	)

tests if the actual argument type and the formal argument type are compatible with the current state of the interprocedural translation algorithms.

safe default result

Parameters

real_arg_t	eal_arg_t
formal_arg_t	ormal_arg_t

Definition at line 932 of file type.c.

 {
   bool result = false; /* safe default result */
  
   if (real_arg_t == formal_arg_t)
     result = true;
   else
     {
       type real_arg_ct = compute_basic_concrete_type(real_arg_t);
       type formal_arg_ct = compute_basic_concrete_type(formal_arg_t);
  
       result =
         basic_concrete_types_compatible_for_effects_interprocedural_translation_p
         (real_arg_ct, formal_arg_ct);
  
       free_type(real_arg_ct);
       free_type(formal_arg_ct);
     }
  
   return result;
 }

References basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), compute_basic_concrete_type(), and free_type().

Referenced by c_convex_effects_on_formal_parameter_backward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undefined_pointer_value_cell_p()

bool undefined_pointer_value_cell_p ( cell c )

Definition at line 76 of file pointer_values.c.

 {
   reference r;
   if (cell_gap_p(c)) return false;
   else if (cell_reference_p(c))
     r = cell_reference(c);
   else
     r = preference_reference(cell_preference(c));
   return(undefined_pointer_value_entity_p(reference_variable(r)));
 }

References cell_gap_p, cell_preference, cell_reference, cell_reference_p, preference_reference, reference_variable, and undefined_pointer_value_entity_p().

Referenced by generic_effect_find_aliases_with_simple_pointer_values(), generic_effect_find_equivalent_simple_pointer_values(), make_simple_pv_from_simple_effects(), make_value_of_pointer_value(), multiple_pointer_assignment_to_post_pv(), pointer_values_remove_var(), and single_pointer_assignment_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undefined_pointer_value_entity()

entity undefined_pointer_value_entity ( void )

pointer_values.c

Definition at line 42 of file pointer_values.c.

 {
   entity u = entity_undefined;
   string u_name = strdup(concatenate(ANY_MODULE_NAME,
                                      MODULE_SEP_STRING,
                                      UNDEFINED_POINTER_VALUE_NAME,
                                      NULL));
   u = gen_find_tabulated(u_name, entity_domain);
   if(entity_undefined_p(u)) {
     type tv = make_type_void(NIL);
     variable v = make_variable(make_basic_pointer(tv), NIL, NIL);
     type t = make_type_variable(v);
     u = make_entity(u_name,
                     t, make_storage_rom(), make_value_unknown());
     entity_kind(u)=ABSTRACT_LOCATION;
   }
   return u;
 }

References ABSTRACT_LOCATION, ANY_MODULE_NAME, concatenate(), entity_domain, entity_kind, entity_undefined, entity_undefined_p, gen_find_tabulated(), make_basic_pointer(), make_entity, make_storage_rom(), make_type_variable(), make_type_void(), make_value_unknown(), make_variable(), MODULE_SEP_STRING, NIL, strdup(), and UNDEFINED_POINTER_VALUE_NAME.

Referenced by declaration_to_post_pv(), make_undefined_pointer_value_cell(), and sequence_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undefined_pointer_value_entity_p()

bool undefined_pointer_value_entity_p ( entity e )

Definition at line 68 of file pointer_values.c.

 {
   bool res;
   res = same_string_p(entity_local_name(e), UNDEFINED_POINTER_VALUE_NAME);
   res = res && same_string_p(entity_module_name(e), ANY_MODULE_NAME);
   return res;
 }

References ANY_MODULE_NAME, entity_local_name(), entity_module_name(), same_string_p, and UNDEFINED_POINTER_VALUE_NAME.

Referenced by abstract_pointer_value_entity_p(), convex_effect_to_constant_path_effects_with_pointer_values(), simple_effect_to_constant_path_effects_with_pointer_values(), and undefined_pointer_value_cell_p().

Here is the call graph for this function:

Here is the caller 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:

◆ update_pt_to_list()

void update_pt_to_list	(	statement	,
		points_to_list
	)

◆ variable_to_abstract_location()

entity variable_to_abstract_location ( entity v )

returns the smallest abstract locations containing the location of variable v.

This does not work for formal parameters or, if it works, the caller module is not known and the resulting abstract location is very large. A large abstract location is returned.

No idea to model return values... even though they are located in the stack in real world.

If v cannot be converted into an abstract location, either the function aborts or an undefined entity is returned.

NULL is an abstract location

Definition at line 675 of file anywhere_abstract_locations.c.

 {
   entity al = entity_undefined;
  
   if(entity_abstract_location_p(v))
     al = v;
   /* NULL is an abstract location  */
   else if(entity_null_locations_p(v))
     al = v;
   else if(entity_variable_p(v)
      && !dummy_parameter_entity_p(v)
      && !variable_return_p(v)) {
     bool typed_p = !get_bool_property("ALIASING_ACROSS_TYPES");
  
     // Too simplistic
     //al = FindOrCreateEntity(mn, ln);
  
     if(formal_parameter_p(v)) {
       const char * ln = FORMAL_AREA_LOCAL_NAME;
       type uvt = entity_basic_concrete_type(v);
       storage s = entity_storage(v);
       formal fs = storage_formal(s);
       entity f = formal_function(fs);
       if(typed_p) {
         const char* fn = entity_local_name(f);
         al = entity_all_module_xxx_locations_typed(fn, ln, uvt);
       }
       else
         al = entity_all_module_xxx_locations(f, ln);
       entity_kind(al)=ABSTRACT_LOCATION; // should it be a static/dynamic/stack/heap area too ? not according to static_area_p
     }
     else { // must be a standard variable, or a stub
       storage s = entity_storage(v);
       ram r = storage_ram(s);
       entity f = ram_function(r);
       entity a = ram_section(r);
       //string mn = entity_local_name(f);
       const char *ln = string_undefined;
       type uvt = entity_basic_concrete_type(v);
  
       if(static_area_p(a))
         ln = STATIC_AREA_LOCAL_NAME;
       else if(dynamic_area_p(a))
         ln = DYNAMIC_AREA_LOCAL_NAME;
       else if(stack_area_p(a))
         ln = STACK_AREA_LOCAL_NAME;
       else if(heap_area_p(a))
         ln = HEAP_AREA_LOCAL_NAME;
       else if(formal_area_p(a))
         ln = FORMAL_AREA_LOCAL_NAME;
       else
         pips_internal_error("Unexpected area\n");
  
       if(typed_p) {
         const char* fn = entity_local_name(f);
         al = entity_all_module_xxx_locations_typed(fn, ln, uvt);
       }
       else
         al = entity_all_module_xxx_locations(f, ln);
       entity_kind(al)=ABSTRACT_LOCATION; // should it be a static/dynamic/stack/heap area too ? not according to static_area_p
     }
   }
   else
     pips_internal_error("arg. not in definition domain");
  
   pips_assert("al is an abstract location entity",
               entity_abstract_location_p(al));
  
   return al;
 }

References ABSTRACT_LOCATION, dummy_parameter_entity_p(), DYNAMIC_AREA_LOCAL_NAME, dynamic_area_p(), entity_abstract_location_p(), entity_all_module_xxx_locations(), entity_all_module_xxx_locations_typed(), entity_basic_concrete_type(), entity_kind, entity_local_name(), entity_null_locations_p(), entity_storage, entity_undefined, entity_variable_p, f(), FORMAL_AREA_LOCAL_NAME, formal_area_p(), formal_function, formal_parameter_p(), get_bool_property(), HEAP_AREA_LOCAL_NAME, heap_area_p(), pips_assert, pips_internal_error, ram_function, ram_section, STACK_AREA_LOCAL_NAME, stack_area_p(), STATIC_AREA_LOCAL_NAME, static_area_p(), storage_formal, storage_ram, string_undefined, and variable_return_p().

Referenced by add_conflicts(), entities_maymust_conflict_p(), entity_locations_max(), opkill_may_name(), and opkill_must_name().

Here is the call graph for this function:

Here is the caller 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:

◆ word_points_to()

list word_points_to ( points_to pt )

Parameters

pt t

Definition at line 242 of file prettyprint.c.

 {
   list l2 = NIL, l1 = NIL, rlt1 = NIL;
  
   pips_assert("pt is defined", !points_to_undefined_p(pt));
   points_to_consistent_p(pt);
   cell c1 = points_to_source(pt);
   cell c2 = points_to_sink(pt);
   // FI->AM: check all your copy_xxxx(); you often copy a large object
   // to obtain a small part of it
   reference r1 = cell_to_reference(c1);
   reference r2 = cell_to_reference(c2);
   approximation rel = points_to_approximation(pt);
   string l3 = "-MAY-";
  
   if (approximation_exact_p(rel))
     l3 = "-Exact-";
   if(variable_p(reference_variable(r2)))
     l2 = words_fictious_reference(r2);
   else
     l2 = points_to_words_reference(r2);
  
   l1 = points_to_words_reference(r1);
  
   rlt1 = gen_nconc((CONS(STRING,strdup("("), NIL)),l1);
   rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(","), NIL)));
  
   rlt1 = gen_nconc(rlt1, l2);
   rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(","), NIL)));
   rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(l3), NIL)));
   rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(")"), NIL)));
   return rlt1;
 }

References approximation_exact_p, cell_to_reference(), CONS, gen_nconc(), NIL, pips_assert, points_to_approximation, points_to_consistent_p(), points_to_sink, points_to_source, points_to_undefined_p, points_to_words_reference(), reference_variable, strdup(), STRING, variable_p(), and words_fictious_reference().

Referenced by generic_reference_to_points_to_matching_list(), generic_transform_sink_cells_from_matching_list(), and words_points_to_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ words_fictious_reference()

list words_fictious_reference ( reference obj )

To modelize the heap locations we manufacture fictious reference, that triggered a bug when it appears as an argument of entity_user_name().

Parameters

obj bj

Definition at line 215 of file prettyprint.c.

 {
   list pc = NIL;
   entity e = reference_variable(obj);
   pc = CHAIN_SWORD(pc, entity_name(e));
   return(pc);
 }

References CHAIN_SWORD, entity_name, NIL, and reference_variable.

Referenced by word_points_to().

Here is the caller graph for this function:

◆ words_pointer_value()

list words_pointer_value ( cell_relation pv )

Parameters

pv v

Definition at line 428 of file prettyprint.c.

 {
   cell first_c = cell_relation_first_cell(pv);
   cell second_c = cell_relation_second_cell(pv);
  
   pips_assert("there should not be preference cells in pointer values (first) \n",
               !cell_preference_p(first_c));
   pips_assert("there should not be preference cells in pointer values (second) \n",
               !cell_preference_p(second_c));
  
   pips_assert("gaps not handled yet (first)", !cell_gap_p(first_c));
   pips_assert("gaps not handled yet (second)", !cell_gap_p(second_c));
  
   pips_assert("the first cell must have value_of interpretation\n",
               cell_relation_first_value_of_p(pv));
  
   list w = NIL;
  
   reference first_r = cell_reference(first_c);
   reference second_r = cell_reference(second_c);
   approximation ap = cell_relation_approximation(pv);
   pips_assert("approximation is not must\n", !approximation_exact_p(ap));
  
   w= gen_nconc(w, effect_words_reference(first_r));
   w = CHAIN_SWORD(w," == ");
   w= gen_nconc(w, effect_words_reference(second_r));
   w = CHAIN_SWORD(w, approximation_may_p(ap) ? " (may)" : " (exact)" );
   return (w);
 }

References approximation_exact_p, approximation_may_p, cell_gap_p, cell_preference_p, cell_reference, cell_relation_approximation, cell_relation_first_cell, cell_relation_first_value_of_p, cell_relation_second_cell, CHAIN_SWORD, effect_words_reference(), gen_nconc(), NIL, and pips_assert.

Here is the call graph for this function:

◆ words_points_to_list()

list words_points_to_list	(	string	,
		points_to_list
	)

Referenced by text_points_to().

Here is the caller graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ ANY_MODULE_NAME

◆ ANYWHERE_LOCATION

◆ BETA_PREFIX

◆ cell_relation_approximation_tag

◆ cell_relation_exact_p

◆ cell_relation_first_address_of_p

◆ cell_relation_first_cell

◆ cell_relation_first_interpretation_tag

◆ cell_relation_first_value_of_p

◆ cell_relation_may_p

◆ cell_relation_second_address_of_p

◆ cell_relation_second_cell

◆ cell_relation_second_interpretation_tag

◆ cell_relation_second_value_of_p

◆ effect_action_tag

◆ effect_any_entity

◆ effect_any_reference

◆ effect_approximation_tag

◆ effect_exact_p

◆ effect_may_p

◆ effect_must_p

◆ effect_read_p

◆ effect_reference

◆ effect_system

◆ effect_variable

◆ effect_write_p

◆ make_convex_effect

◆ make_preference_simple_effect

◆ make_reference_simple_effect

◆ make_simple_effect

◆ NOWHERE_LOCATION

◆ NULL_POINTER_NAME

◆ NULL_POINTER_VALUE_NAME

◆ PHI_PREFIX

◆ pips_debug_pv

◆ pips_debug_pvs

◆ PROPER

◆ PSI_PREFIX

◆ RHO_PREFIX

◆ SUMMARY

◆ UNDEFINED_LOCATION

◆ UNDEFINED_POINTER_VALUE_NAME

◆ variable_beta_p

◆ variable_phi_p

◆ variable_psi_p

◆ variable_rho_p

Function Documentation

◆ abstract_locations_max()

◆ abstract_locations_may_conflict_p()

◆ abstract_locations_must_conflict_p()

◆ abstract_pointer_value_cell_p()

◆ abstract_pointer_value_entity_p()

◆ action_equal_p()

◆ action_kind_to_string()

◆ action_to_action_kind()

◆ action_to_string()

◆ adapt_reference_to_type()

◆ all_heap_locations_cell_p()

◆ any_anywhere_effect_p()

◆ anywhere_cell_p()

◆ anywhere_effect()

◆ anywhere_effect_p()

◆ anywhere_reference_p()

◆ approximation_and()

◆ approximation_or()

◆ approximation_to_string()

◆ array_location_entity_of_module_p()

◆ atomic_effect_p()

◆ atomic_points_to_cell_p()

◆ atomic_points_to_reference_p()

◆ basic_concrete_types_compatible_for_effects_interprocedural_translation_p()

◆ bound_pt_to_list_p()

◆ calloc_to_abstract_location()

◆ can_be_constant_path_p()

◆ cell_abstract_location_p()

◆ cell_any_reference()