6 #ifndef effects_util_header_included
7 #define effects_util_header_included
39 #define ANY_MODULE_NAME "*ANY_MODULE*"
40 #define ANYWHERE_LOCATION "*ANYWHERE*"
41 #define NOWHERE_LOCATION "*NOWHERE*"
43 #define NULL_POINTER_NAME "*NULL*"
44 #define UNDEFINED_LOCATION "*UNDEFINED*"
46 #define UNDEFINED_POINTER_VALUE_NAME "*UNDEFINED*"
47 #define NULL_POINTER_VALUE_NAME "*NULL*"
49 #define PHI_PREFIX "PHI"
50 #define PSI_PREFIX "PSI"
51 #define RHO_PREFIX "RHO"
52 #define BETA_PREFIX "BETA"
59 #define effect_any_entity(e) effect_to_entity(e)
60 #define effect_action_tag(eff) action_tag(effect_action(eff))
61 #define effect_approximation_tag(eff) \
62 approximation_tag(effect_approximation(eff))
80 #define effect_read_p(eff) (action_tag(effect_action(eff))==is_action_read)
81 #define effect_write_p(eff) (action_tag(effect_action(eff))==is_action_write)
82 #define effect_may_p(eff) \
83 (approximation_tag(effect_approximation(eff)) == is_approximation_may)
84 #define effect_must_p(eff) \
85 (approximation_tag(effect_approximation(eff)) == is_approximation_must)
86 #define effect_exact_p(eff) \
87 (approximation_tag(effect_approximation(eff)) ==is_approximation_exact)
94 #define effect_variable(e) reference_variable(effect_any_reference(e))
103 #define variable_phi_p(e) \
104 ((e)!=(entity)NULL && (e)!=entity_undefined && \
105 strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
106 strstr(entity_name(e), PHI_PREFIX) != NULL)
108 #define variable_psi_p(e) \
109 ((e)!=(entity)NULL && (e)!=entity_undefined && \
110 strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
111 strstr(entity_name(e), PSI_PREFIX) != NULL)
113 #define variable_rho_p(e) \
114 ((e)!=(entity)NULL && (e)!=entity_undefined && \
115 strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
116 strstr(entity_name(e), RHO_PREFIX) != NULL)
118 #define variable_beta_p(e)\
119 ((e)!=(entity)NULL && (e)!=entity_undefined && \
120 strncmp(entity_name(e), REGIONS_MODULE_NAME, 10)==0 && \
121 strstr(entity_name(e), BETA_PREFIX) != NULL)
123 #define effect_system(e) \
124 (descriptor_convex_p(effect_descriptor(e))? \
125 descriptor_convex(effect_descriptor(e)) : SC_UNDEFINED)
134 #define effect_reference(e) \
138 effect_reference_not_defined_anymore()
141 #define effect_any_reference(e) \
142 (cell_preference_p(effect_cell(e))? preference_reference(cell_preference(effect_cell(e))) : cell_reference(effect_cell(e)))
143 #define make_preference_simple_effect(reference,action,approximation)\
144 make_effect(make_cell(is_cell_preference, make_preference(reference)),\
145 (action), (approximation), \
146 make_descriptor(is_descriptor_none,UU))
148 #define make_reference_simple_effect(reference,action,approximation)\
149 make_effect(make_cell(is_cell_reference, (reference)), \
150 (action), (approximation), \
151 make_descriptor(is_descriptor_none,UU))
153 #define make_simple_effect(reference,action,approximation)\
154 make_effect(make_cell(is_cell_preference, make_preference(reference)),\
155 (action), (approximation), \
156 make_descriptor(is_descriptor_none,UU))
158 #define make_convex_effect(reference,action,approximation,system)\
159 make_effect(make_cell(is_reference, (reference)), \
160 (action), (approximation), \
161 make_descriptor(is_descriptor_convex,system))
166 #define cell_relation_first_cell(cr)\
167 interpreted_cell_cell(cell_relation_first(cr))
169 #define cell_relation_first_interpretation_tag(cr)\
170 cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_first(cr)))
172 #define cell_relation_first_value_of_p(cr)\
173 cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))
175 #define cell_relation_first_address_of_p(cr)\
176 cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_first(cr)))
178 #define cell_relation_second_cell(cr)\
179 interpreted_cell_cell(cell_relation_second(cr))
181 #define cell_relation_second_interpretation_tag(cr)\
182 cell_interpretation_tag(interpreted_cell_cell_interpretation(cell_relation_second(cr)))
184 #define cell_relation_second_value_of_p(cr)\
185 cell_interpretation_value_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))
187 #define cell_relation_second_address_of_p(cr)\
188 cell_interpretation_address_of_p(interpreted_cell_cell_interpretation(cell_relation_second(cr)))
190 #define cell_relation_approximation_tag(cr)\
191 approximation_tag(cell_relation_approximation(cr))
193 #define cell_relation_may_p(cr)\
194 approximation_tag(cell_relation_approximation(cr))==is_approximation_may
196 #define cell_relation_exact_p(cr)\
197 approximation_tag(cell_relation_approximation(cr))==is_approximation_exact
199 #define pips_debug_pv(level, message, pv) \
200 ifdebug(level) { pips_debug(level, "%s\n", message); \
201 print_pointer_value(pv);}
203 #define pips_debug_pvs(level, message, l_pv) \
204 ifdebug(level) { pips_debug(level, "%s\n", message); \
205 print_pointer_values(l_pv);}
static string current_module
static statement current_stmt
bool formal_parameter_points_to_cell_p(cell)
bool reference_unbounded_indices_p(reference)
This function should be at expression.c.
bool cell_typed_anywhere_locations_p(cell)
test if a cell is the bottom of the lattice
bool cell_points_to_null_sink_in_set_p(cell, set)
reference reference_add_field_dimension(reference, entity)
add a field f as a subscript to a reference r if it is meaningful.
bool effects_read_variable_p(list, entity)
bool undefined_pointer_value_cell_p(cell)
bool type_declaration_effect_p(effect)
bool pv_cells_syntactically_equal_p(cell_relation, cell_relation)
action_kind action_to_action_kind(action)
Without the consistency test, this function would certainly be inlined.
bool related_points_to_cell_in_list_p(cell, list)
Two cells are related if they are based on the same entity.
void points_to_cell_add_fixed_subscripts(cell, bool)
Convert a reference to an array into a reference to its first element.
tag approximation_and(tag, tag)
tag approximation_and(tag t1, tag t2) input : two approximation tags.
bool location_entity_p(entity)
bool location_entity_of_module_p(entity, entity)
void check_abstract_locations(void)
For debugging the API.
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.
void print_pointer_value(cell_relation)
bool effect_on_non_local_variable_p(effect)
Test if an effect has a non local effect.
type cell_to_type(cell, bool *)
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 t...
bool effect_abstract_location_p(effect)
list effect_words_reference(reference)
prettyprint.c
bool cell_equal_p(cell, cell)
CELLS.
type points_to_reference_to_concrete_type(reference)
entity entity_all_stack_locations(void)
return ANY_MODULE:STACK
entity entity_locations_dereference(entity)
cell make_anywhere_points_to_cell(type)
Function storing points to information attached to a statement.
const char * pips_region_user_name(entity)
char * pips_region_user_name(entity ent) output : the name of entity.
bool pv_cells_mergeable_p(cell_relation, cell_relation)
bool effects_write_variable_p(list, entity)
bool cell_equivalent_p(cell, cell)
Check that memory locations denoted by cell "c1" can be reached by knowing cell "c2" and by using poi...
type points_to_cell_to_type(cell, bool *)
FI: I need more generality than is offered by cell_to_type()
entity entity_all_xxx_locations_typed(string, type)
FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing...
cell points_to_cells_minimal_upper_bound(list)
reference cell_any_reference(cell)
API for reference.
statement_mapping effectsmap_to_listmap(statement_mapping)
reference points_to_cells_minimal_reference_upper_bound(entity, type, list)
cell points_to_cell_add_field_dimension(cell, entity)
Functions about points-to cells - There is no cell.c file.
bool points_to_source_cell_compatible_p(cell)
bool reference_typed_anywhere_locations_p(reference)
test if a reference is the bottom of the lattice
bool effects_write_p(list)
void points_to_cell_add_unbounded_subscripts(cell)
list points_to_list_sort(list)
Allocate a copy of ptl and sort it.
bool cells_may_not_point_to_null_p(list)
void print_pointer_values(list)
entity null_pointer_value_entity(void)
bool effect_reference_dereferencing_p(reference, bool *)
points_to points_to_with_stripped_sink(points_to, int(*)(void))
The value of the source can often be expressed with different subscript lists.
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 ...
bool generic_atomic_points_to_reference_p(reference, bool)
Is it a unique concrete memory location?
bool entity_all_module_stack_locations_p(entity)
test if an entity is the a stack area
entity effect_entity(effect)
cproto-generated files
entity entity_all_heap_locations(void)
return ANY_MODULE:HEAP
void print_points_to_cells(list)
Debug.
bool typed_anywhere_effect_p(effect)
Is it a typed anywhere effect? ANYMMODULE:ANYWHERE_b0, 1, 2.
string approximation_to_string(approximation)
bool atomic_effect_p(effect)
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 elem...
bool anywhere_reference_p(reference)
action make_action_write_memory(void)
To ease the extension of action with action_kind.
type points_to_cell_to_concrete_type(cell)
bool entity_heap_location_p(entity)
abstract_location.c
bool entity_all_module_locations_p(entity)
test if an entity is the set of locations defined in a module
bool entity_all_heap_locations_p(entity)
test if an entity is the set of all heap locations
int compare_effect_reference(effect *, effect *)
int compare_effect_reference(e1, e2):
bool abstract_pointer_value_cell_p(cell)
int points_to_reference_to_final_dimension(reference)
Compute the number of array subscript at the end of a points_to_reference.
void store_pt_to_list(statement, points_to_list)
type points_to_reference_to_type(reference, bool *)
FI: I need more generality than is offered by cell_to_type()
bool recursive_store_independent_points_to_reference_p(type, list)
bool effects_abstract_location_p(list)
Returns true if at least one effect of effect list el is related to an abstract location.
bool heap_effect_p(effect)
bool field_reference_expression_p(expression)
Check if expression "e" is a reference to a struct field.
bool cell_points_to_nowhere_sink_in_set_p(cell, set)
entity abstract_locations_max(entity, entity)
eturns the smallest abstract location set greater than or equalt to al1 and al2.
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 ad...
string full_action_to_short_string(action)
entity entity_flow_or_context_sentitive_heap_location(int, type)
sensitivity_information make_sensitivity_information(statement, entity, list)
bool undefined_pointer_value_entity_p(entity)
reference original_malloc_to_abstract_location(expression, type, type, expression, entity, statement)
bool points_to_cell_equal_p(cell, cell)
bool stub_entity_of_module_p(entity, entity)
bool related_points_to_cells_p(cell, cell)
list module_to_analyzed_array_locations(entity)
m is supposed to be a module entity
bool effect_list_consistent_p(list)
Debugging.
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...
entity malloc_to_abstract_location(expression, sensitivity_information *)
generate an abstract heap location entity
bool store_effect_p(effect)
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 a...
action_kind effect_action_kind(effect)
bool std_file_cell_p(cell)
void print_points_to_cell(cell)
Debug: use stderr.
int pointer_value_compare(cell_relation *, cell_relation *)
Compares two pointer values for sorting.
bool entity_all_locations_p(entity)
test if an entity is the top of the lattice
void store_or_update_pt_to_list(statement, points_to_list)
bool entity_flow_or_context_sentitive_heap_location_p(entity)
points_to_list load_pt_to_list(statement)
entity make_location_entity(reference)
locations.c
list word_points_to(points_to)
entity entity_typed_nowhere_locations(type)
cell make_null_pointer_value_cell(void)
bool entity_typed_anywhere_locations_p(entity)
Test if an entity is the bottom of the lattice.
text text_pointer_value(cell_relation)
text text_region(effect reg) input : a region output : a text consisting of several lines of commenta...
bool effect_scalar_p(effect)
bool points_to_reference_included_p(reference, reference)
FI->FC/AM: some elements of the lattice must be exploited here...
bool entity_all_static_locations_p(entity)
test if an entity is the set of all static locations
entity effect_field_dimension_entity(expression, list)
type.c
int effect_compare(effect *, effect *)
Compares two effects for sorting.
bool points_to_sink_cell_compatible_p(cell)
bool malloc_reference_p(reference)
bool memory_dereferencing_p(reference)
Does the set of locations referenced by r depend on a pointer dereferencing?
list words_pointer_value(cell_relation)
statement_mapping listmap_to_effectsmap(statement_mapping)
void fprint_points_to_cell(FILE *, cell)
reference cell_to_reference(cell)
FI: probably to be moved elsewhere in ri-util.
bool cell_included_p(cell, cell)
Check that all memory locations denoted by cell "c1" are included in cell "c2".
tag approximation_or(tag, tag)
tag approximation_or(tag t1, tag t2) input : two approximation tags.
cell_relation make_address_of_pointer_value(cell, cell, tag, descriptor)
entity entity_locations_max(entity, entity)
Here, entity al1 and entity al2 can be program variables.
void set_pt_to_list(statement_points_to)
bool entity_nowhere_locations_p(entity)
test if an entity is the bottom of the lattice
bool FILE_star_effect_reference_p(reference)
list effects_to_list(effects)
bool io_effect_entity_p(entity)
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 ...
entity entity_all_module_heap_locations_typed(entity, type)
bool strict_constant_path_p(reference)
bool anywhere_cell_p(cell)
Is it an anywhere cell?
cell_relation make_value_of_pointer_value(cell, cell, tag, descriptor)
bool abstract_locations_may_conflict_p(entity, entity)
Do these two abstract locations MAY share some real memory locations ?
entity entity_all_module_heap_locations(entity)
return m:*HEAP**ANYWHERE
entity entity_all_module_static_locations(entity)
return m:*DYNAMIC**ANYWHERE
list recursive_cell_to_pointer_cells(cell)
void points_to_cell_complete_with_zero_subscripts(cell)
entity entity_all_module_locations(entity)
return m:ANYWHERE Set of all memory locations related to one module.
bool cell_entity_equal_p(cell, cell)
bool all_heap_locations_cell_p(cell)
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 ...
type points_to_expression_to_concrete_type(expression)
The type returned is stored in a hash-table.
entity entity_typed_anywhere_locations(type)
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"...
string action_to_string(action)
Functions dealing with actions.
effect heap_effect(entity, action)
bool compatible_points_to_subscripts_p(expression, expression)
Two subscript are compatible if they are equal or if one of them is unbounded.
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...
bool generic_atomic_points_to_cell_p(cell, bool)
Is it a unique concrete memory location?
type points_to_cells_minimal_type_upper_bound(list)
bool entity_null_locations_p(entity)
test if an entity is the NULL POINTER
entity entity_all_heap_locations_typed(type)
entity entity_anywhere_locations(void)
bool nowhere_cell_p(cell)
Target of an undefined pointer.
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 "*...
reference simple_reference_add_field_dimension(reference, entity)
Do not check anything, just add f as a last subscript.
int cell_compare(cell *, cell *)
entity entity_null_locations(void)
return TOP-LEVEL:NULL_POINTER The NULL pointer should be a global variable, unique for all modules FI...
bool union_compatible_effects_p(effect, effect)
DO NOT USE ANYMORE: NOT COMPATIBLE WITH ABSTRACT LOCATIONS.
entity entity_all_module_dynamic_locations(entity)
return m:*DYNAMIC**ANYWHERE
bool environment_effect_p(effect)
bool cells_must_point_to_null_p(list)
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.
entity entity_all_module_xxx_locations(entity, const char *)
return m:xxx*ANYWHERE* Generic set of functions for all kinds of areas
bool effects_all_read_p(list)
Check that all effects in el are read effects.
bool cell_must_point_to_nowhere_sink_in_set_p(cell, set)
How are array handled in pts? do we have arcs "a->a"?
bool entity_anywhere_locations_p(entity)
test if an entity is the bottom of the lattice
entity variable_to_abstract_location(entity)
returns the smallest abstract locations containing the location of variable v.
bool malloc_effect_p(effect)
entity calloc_to_abstract_location(expression, expression, sensitivity_information *)
generate an abstract heap location entity
type cell_reference_to_type(reference, bool *)
computes the type of a cell reference representing a memory access path.
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
bool pt_to_list_undefined_p(void)
points_to.c
points_to_list delete_pt_to_list(statement)
text text_pointer_values(list, string)
bool action_equal_p(action, action)
void init_pt_to_list(void)
effect anywhere_effect(action)
Anywhere effect: an effect which can be related to any location of any areas.
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 re...
bool can_be_constant_path_p(reference)
TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want t...
bool effects_interfere_p(effect, effect)
Two effects interfere if one of them modify the set of locations defined by the other one.
bool points_to_cell_in_list_p(cell, list)
list words_fictious_reference(reference)
To modelize the heap locations we manufacture fictious reference, that triggered a bug when it appear...
entity entity_all_locations(void)
anywhere_abstract_locations.c
bool atomic_points_to_cell_p(cell)
Is it a unique concrete memory location?
entity entity_all_module_xxx_locations_typed(const char *, const char *, type)
bool anywhere_effect_p(effect)
Is it an anywhere effect? ANYMMODULE:ANYWHERE
bool entity_all_module_static_locations_p(entity)
test if an entity is the a static area
cell make_anywhere_cell(type)
bool atomic_points_to_reference_p(reference)
void points_to_cell_add_zero_subscript(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 subs...
void update_pt_to_list(statement, points_to_list)
bool io_effects_p(list effects)
void error_reset_pt_to_list(void)
cell make_undefined_pointer_value_cell(void)
entity malloc_type_to_abstract_location(type, sensitivity_information *)
generate an abstract heap location entity
bool std_file_effect_p(effect)
list words_points_to_list(string, points_to_list)
type points_to_array_reference_to_type(reference)
If this is an array reference, what is the type of the underlying array type?
string full_action_to_string(action)
void points_to_cell_types_compatibility(cell, cell)
Make sure that cell l can points towards cell r.
void reset_pt_to_list(void)
action make_action_read_memory(void)
entity generic_entity_typed_anywhere_locations(type)
list points_to_words_reference(reference)
Specific handling of references appearing in points_to.
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.
bool array_location_entity_of_module_p(entity, entity)
Expanded version of location_entity_of_module_p()
list merge_points_to_cell_lists(list, list)
Add in "l1" elements of "l2" that are not yet in "l1".
entity entity_nowhere_locations(void)
return ANY_MODULE:NOWHERE
void close_pt_to_list(void)
bool effect_list_can_be_safely_full_freed_p(list)
Check if some references might be freed with the effects.
bool entity_stub_sink_p(entity)
test if an entity is a stub sink for a formal parameter e.g.
bool adapt_reference_to_type(reference, type, int(*)(void))
FI: a really stupid function...
bool entity_all_module_dynamic_locations_p(entity)
test if an entity is the a dynamic area
entity effect_to_entity(effect)
Returns the entity corresponding to the mutation.
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 ...
bool cell_abstract_location_p(cell)
bool entity_all_stack_locations_p(entity)
test if an entity is the set of all stack locations
bool entity_abstract_location_p(entity)
statement_points_to get_pt_to_list(void)
bool entity_typed_nowhere_locations_p(entity)
test if an entity is the bottom of the lattice
void complete_points_to_reference_with_zero_subscripts(reference)
string effect_reference_to_string(reference)
entity points_to_cells_minimal_module_upper_bound(list)
entity constant_memory_access_path_to_location_entity(reference)
A constant memory access path may not be considered.
effects list_to_effects(list)
Future API for GAP, Generic Access Path.
int points_to_compare_cells(const void *, const void *)
Comparison of two points-to arcs based on their source and sink nodes.
bool store_independent_effect_p(effect)
Does this effect define the same set of memory locations regardless of the current (environment and) ...
bool std_file_effects_p(list effects)
bool abstract_locations_must_conflict_p(entity, entity)
bool null_pointer_value_cell_p(cell)
bool null_pointer_value_entity_p(entity)
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...
bool any_anywhere_effect_p(effect)
Is it a typed or untyped anywhere effect?
bool entity_all_module_heap_locations_p(entity)
test if an entity is the a heap area
bool stub_points_to_cell_p(cell)
type malloc_arg_to_type(expression)
generate the type of the allocated area from the malloc argument
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 in...
bool effects_on_non_local_variable_p(list effects)
Test if a list of effects concerns non local variables.
effect effect_to_store_independent(effect)
bool effect_comparable_p(effect, effect)
Can we merge these two effects because they are equal or because they only differ by their approximat...
effect effect_interference(effect, effect)
Modifies effect eff1 to make sure that any memory state modification abstracted by eff2 preserves the...
entity entity_all_module_stack_locations(entity)
return m:*STACK**ANYWHERE
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.
string action_kind_to_string(action_kind)
int cell_reference_compare(reference *, reference *)
compare.c
bool constant_points_to_indices_p(list)
check that the subscript list il is either empty or made of integers or fields.
void points_to_cell_add_zero_subscripts(cell)
bool heap_cell_p(cell)
Any heap cell, more or less abstract or typed.
bool bound_pt_to_list_p(statement)
reference make_anywhere_reference(type)
This function should be located somewhere in effect-util in or near abstract locations.
bool store_independent_points_to_reference_p(reference)
Functions for points-to references, the kind of references used in points-to cells.
entity undefined_pointer_value_entity(void)
pointer_values.c
bool entity_all_dynamic_locations_p(entity)
test if an entity is the set of all dynamic locations
int is_inferior_cell_descriptor_pvarval(Pvecteur *, Pvecteur *)
weight function for Pvecteur passed as argument to sc_lexicographic_sort in prettyprint functions inv...
entity entity_all_xxx_locations(string)
return ANY_MODULE:xxx
entity entity_all_dynamic_locations(void)
return ANY_MODULE:DYNAMIC
bool effect_reference_contains_pointer_dimension_p(reference, bool *)
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.
bool vect_contains_phi_p(Pvecteur)
bool vect_contains_phi_p(Pvecteur v) input : a vector output : true if v contains a PHI variable,...
bool abstract_pointer_value_entity_p(entity)
entity entity_all_static_locations(void)
return ANY_MODULE:STATIC
bool points_to_cells_intersect_p(cell, cell)
points-to cells use abstract addresses, hence the proper comparison is an intersection.
bool exact_points_to_subscript_list_p(list)
See if the subscript list sl is precise, i.e.
int compare_effect_reference_in_common(effect *, effect *)
int compare_effect_reference_in_common(e1, e2):
list concrete_effects_entities_which_may_conflict_with_scalar_entity(list, entity)
bool first_effect_certainly_includes_second_effect_p(effect, effect)
tests whether first effect certainly includes second one.
bool entities_must_conflict_p(entity, entity)
Check if two entities must conflict.
bool effects_maymust_read_or_write_scalar_entity_p(list, entity, bool)
bool points_to_cell_lists_must_conflict_p(list, list)
Same as above, but for lists.
bool cells_must_conflict_p(cell, cell)
Check if two cell must conflict.
bool concrete_effects_may_read_or_write_scalar_entity_p(list, entity)
bool entities_may_conflict_p(entity, entity)
Check if two entities may conflict.
bool first_exact_scalar_effect_certainly_includes_second_effect_p(effect, effect)
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 ...
bool references_may_conflict_p(reference, reference)
Check if two references may conflict.
void set_conflict_testing_properties(void)
conflicts.c
bool entities_maymust_conflict_p(entity, entity, bool)
Check if two entities may or must conflict.
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
bool effects_conflict_p(effect, effect)
Synonym for effects_may_conflict_p().
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 ac...
bool generic_effects_maymust_read_or_write_scalar_entity_p(list, entity, bool, bool)
bool cells_may_conflict_p(cell, cell)
Check if two cell may conflict.
bool variable_references_may_conflict_p(entity, list, list)
FIXME ?
bool effects_must_conflict_p(effect, effect)
Intersection tests.
bool concrete_effects_maymust_read_or_write_scalar_entity_p(list, entity, bool)
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; ...
bool points_to_cell_lists_may_conflict_p(list, list)
Same as above, but for lists.
list effects_entities_which_may_conflict_with_scalar_entity(list, entity)
bool array_references_may_conflict_p(list, list)
Check if there may be a conflict between two array references.
bool effect_may_read_or_write_memory_paths_from_entity_p(effect, entity)
misc functions
bool effects_may_conflict_p(effect, effect)
Check if two effect may conflict @description Two effects may conflict if their abstract two location...
bool references_must_conflict_p(reference, reference)
Check if two references may conflict.
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.