59 if(type_sensitive_p) {
61 bool to_be_freed_p =
true;
179 bool changed =
false;
320 pips_user_error(
"NULL or ANYWHERE locations can't appear as an lvalue\n");
371 pips_user_error(
"NULL or ANYWHERE locations can't appear as an lvalue\n");
458 bool kill_may_p =
true;
482 bool kill_must_p =
false;
522 i = i2>i1? 1 : (i2<i1? -1 : 0);
536 return (i==0?
true:
false);
576 i = i2>i1? 1 : (i2<i1? -1 : 0);
595 return (i==0?
true:
false);
613 bool to_be_freed1, to_be_freed2;
743 bool address_of_p =
false;
760 bool expression_null_locations_p(
expression e)
859 string bug = null_p?
"a null" :
"";
860 bug = nowhere_p?
"an undefined" :
"";
862 if(null_p || nowhere_p) {
931 bool error_p =
false;
940 string bug = null_p?
"a null" :
"";
941 bug = nowhere_p?
"an undefined" :
"";
942 if(null_p || nowhere_p) {
966 set_union(gen_must2, gen_must2,gen_must1);
1012 if(!(*address_of_p)){
1027 bool t_to_be_freed =
false;
1098 bool changed =
false;
1146 bool t_to_be_freed =
false;
1164 return gen_must_cps;
1225 bool gen_may_p =
true;
1245 bool atomic_cp_p =
true;
1250 atomic_cp_p =
false;
1277 bool changed =
false;
1295 bool changed =
false;
1322 i = i2>i1? 1 : (i2<i1? -1 : 0);
1341 return (i==0?
true:
false);
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
cell make_cell_reference(reference _field_)
approximation make_approximation_exact(void)
approximation copy_approximation(approximation p)
APPROXIMATION.
approximation make_approximation_may(void)
descriptor make_descriptor_none(void)
cell copy_cell(cell p)
CELL.
void free_approximation(approximation p)
points_to make_points_to(cell a1, cell a2, approximation a3, descriptor a4)
type copy_type(type p)
TYPE.
reference make_reference(entity a1, list a2)
static reference ref
Current stmt (an integer)
#define new_simple_pt_map()
bool entity_null_locations_p(entity e)
test if an entity is the NULL POINTER
bool entity_abstract_location_p(entity al)
entity variable_to_abstract_location(entity v)
returns the smallest abstract locations containing the location of variable v.
bool cell_typed_anywhere_locations_p(cell c)
test if a cell is the bottom of the lattice
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
bool entity_nowhere_locations_p(entity e)
test if an entity is the bottom of the lattice
entity entity_all_xxx_locations(string xxx)
return ANY_MODULE:xxx
entity entity_all_xxx_locations_typed(string xxx, type t)
FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing...
entity entity_all_locations()
eturn ANY_MODULE:ANYWHERE (the top of the lattice)
bool entity_typed_nowhere_locations_p(entity e)
test if an entity is the bottom of the lattice
void const char const char const int
set points_to_independent_store(set s)
set opgen_null_location(set L, cell r)
bool opgen_may_vreference(list vr1, list vr2)
bool opkill_may_reference(cell c1, cell c2)
cell max_module(cell m1, cell m2)
we define operator max fot the lattice Module which has any_module as top and a bottom which is not y...
bool opgen_may_module(entity e1, entity e2)
bool address_of_expression_p(expression e)
shoud be moved to expression.c
bool opkill_may_module(cell m1, cell m2)
set kill_must_set(list L, set in)
Generate the subset of arcs that must be removed from the points-to graph "in".
set points_to_may_filter(set in)
returns a set which contains all the MAY points to
bool opgen_must_module(entity e1, entity e2)
bool opkill_must_module(cell m1, cell m2)
set gen_must_constant_paths(cell l, list R, set in_must, bool *address_of_p, int Lc)
Build a set of arcs from cell l towards cells in list R if *address_p is true, or towards cells point...
set kill_may_set(list L, set in_may)
Compute the set of arcs in the input points-to relation "in" whose approximation must be changed from...
set gen_must_set(list L, list R, set in_must, bool *address_of_p)
bool atomic_constant_path_p(cell cp)
Could be replaced by abstract_location_p() but this later don't take into account the null location.
set points_to_must_filter(set in)
returns a set which contains all the EXACT points to
bool unique_location_cell_p(cell c)
Does cell "c" represent a unique memory location or a set of memory locations?
bool opkill_may_constant_path(cell c1, cell c2)
bool opkill_must_reference(cell c1, cell c2)
bool opkill_may_vreference(cell c1, cell c2)
FI: really weird and unefficient.
cell op_gen_module(cell m1, __attribute__((__unused__)) cell m2)
Operator gen for modules: m1 is the sink, m2 the source (m2 points to m1) opkill_gen_module : Module ...
set points_to_nowhere(list lhs_list, set input)
arg1: list of cells arg2: set of points-to Create a points-to set with elements of lhs_list as source...
cell make_nowhere_cell()
This file contains all the operators defining constant paths :
bool opkill_must_constant_path(cell c1, cell c2)
returns true if c2 kills c1
points_to opgen_must_constant_path(cell l __attribute__((__unused__)), cell r __attribute__((__unused__)))
cell cell_to_nowhere_sink(cell source)
assuming source is a reference to a pointer, build the corresponding sink when the pointer is not ini...
bool opkill_must_vreference(cell c1, cell c2)
returns true if c2 must kills c1 because of the subscript expressions
bool opgen_may_name(entity e1, entity e2)
list array_to_constant_paths(expression e, set in __attribute__((__unused__)))
input : expression e and a set of points_to output : a set of constant paths translates an expression...
bool opkill_must_type(type t1, type t2)
opkill_must_type is the same as op_kill_may_type...
type opgen_may_type(type t1, type t2)
set gen_may_set(list L, list R, set in_may, bool *address_of_p)
Should be moved to anywhere_abstract_locations.c.
set points_to_anywhere(list lhs_list, set input)
cell make_typed_nowhere_cell(type t)
type opgen_must_type(type t1, type t2)
the same as opgen_may_type
points_to opgen_may_constant_path(cell l __attribute__((__unused__)), cell r __attribute__((__unused__)))
set gen_may_constant_paths(cell l, list R, set in_may, bool *address_of_p, int Lc)
bool opkill_must_name(cell n1, cell n2)
bool entity_any_module_p(entity e)
operator kill for the dimension Module:
bool opgen_must_name(entity e1, entity e2)
bool equal_must_vreference(cell c1, cell c2)
set points_to_anywhere_typed(list lhs_list, set input)
Already exists in points_to_general_algorithm.c, to be removed later...
bool subscript_expression_p(expression e)
bool opkill_may_type(type t1, type t2)
bool opkill_may_name(cell n1, cell n2)
We define operators for the lattice Name which can be a: -variable of a the program -malloc -NULL /0 ...
type max_type(type t1, type t2)
void generic_effects_reset_all_methods(void)
void set_methods_for_proper_simple_effects(void)
cell simple_cell_to_store_independent_cell(cell, bool *)
#define ANYWHERE_LOCATION
type cell_to_type(cell, bool *)
cell make_anywhere_points_to_cell(type)
Function storing points to information attached to a statement.
reference cell_any_reference(cell)
API for reference.
type points_to_reference_to_type(reference, bool *)
FI: I need more generality than is offered by cell_to_type()
bool anywhere_cell_p(cell)
Is it an anywhere cell?
void points_to_cell_types_compatibility(cell, cell)
Make sure that cell l can points towards cell r.
bool heap_cell_p(cell)
Any heap cell, more or less abstract or typed.
#define cell_reference(x)
#define cell_preference(x)
#define cell_reference_p(x)
#define approximation_exact_p(x)
#define approximation_may_p(x)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
bool cells_may_conflict_p(cell c1, cell c2)
Check if two cell may conflict.
void gen_null(__attribute__((unused)) void *unused)
Ignore the argument.
#define ENDP(l)
Test if a list is empty.
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
#define CAR(pcons)
Get the value of the first element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
bool expression_constant_p(expression)
HPFC module by Fabien COELHO.
#define pips_user_warning
#define pips_internal_error
const char * entity_minimal_user_name(entity e)
Do not preserve scope information.
#define same_string_p(s1, s2)
set set_generic_make(set_type, hash_equals_t, hash_rank_t)
what about this replacement? #define SET_MAP(the_item, the_code, the_set) \ { SET_FOREACH(void *,...
set set_difference(set, const set, const set)
#define SET_FOREACH(type_name, the_item, the_set)
enumerate set elements in their internal order.
set set_union(set, const set, const set)
set set_add_element(set, const set, const void *)
_uint points_to_rank(const void *, size_t)
create a key which is a concatenation of the source's name, the sink's name and the approximation of ...
bool points_to_compare_cell(cell, cell)
int points_to_equal_p(const void *, const void *)
returns true if two points-to arcs "vpt1" and "vpt2" are equal.
#define points_to_approximation(x)
#define points_to_undefined_p(x)
#define points_to_undefined
#define points_to_sink(x)
#define points_to_descriptor(x)
#define points_to_source(x)
string expression_to_string(expression e)
static statement gen(int what, entity src, entity trg, entity lid, entity proc, entity(*create_src)(), entity(*create_trg)(), Psysteme sr, list ldiff)
arguments: all that may be useful to generate some code
#define entity_an_operator_p(e, name)
macros
bool array_entity_p(entity e)
const char * entity_module_name(entity e)
See comments about module_name().
bool extended_integer_constant_expression_p(expression e)
More extensive than next function.
int expression_to_int(expression exp)
================================================================
bool field_expression_p(expression e)
The expression is of kind "a", where "a" is a field of some struct "s".
bool expression_equal_p(expression e1, expression e2)
Syntactic equality e1==e2.
bool reference_equal_p(reference r1, reference r2)
bool array_reference_p(reference r)
predicates on references
bool expression_reference_p(expression e)
Test if an expression is a reference.
bool store_independent_reference_p(reference r)
Does this reference define the same set of memory locations regardless of the current (environment an...
bool unbounded_expression_p(expression e)
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
entity expression_variable(expression e)
type MakeTypeUnknown(void)
bool type_equal_p(type, type)
type type_to_pointed_type(type)
returns t if t is not a pointer type, and the pointed type if t is a pointer type.
bool pointer_type_p(type)
Check for scalar pointers.
#define type_unknown_p(x)
#define reference_undefined
#define reference_variable(x)
#define EXPRESSION(x)
EXPRESSION.
#define reference_indices(x)
#define preference_reference(x)
#define expression_syntax(x)
#define syntax_subscript_p(x)
Pvecteur cp
pointeur sur l'egalite ou l'inegalite courante
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.