593 "pointer and not \"%s\".\n",
630 else if(n==2 && m==2)
631 pips_user_error(
"IO intrinsics \"%s\" requires at least two arguments",
821 if(-k <= ov && ov <= k) {
875 bool unfeasible_p =
false;
970 pips_user_error(
"Use of pointer arithmetic on \"%s\" at line %d via reference \"%s\" is not "
971 "standard-compliant.\n"
972 "Reset property \"POINTS_TO_STRICT_POINTER_TYPES\""
973 " for usual non-standard compliant C code.\n",
993 pips_user_error(
"Use of pointer arithmetic on \"%s\" at line %d via reference \"%s\" is not "
994 "standard-compliant.\n"
995 "Reset property \"POINTS_TO_STRICT_POINTER_TYPES\""
996 " for usual non-standard compliant C code.\n",
1002 pips_user_error(
"Use of pointer arithmetic on \"%s\" at line %d via reference \"%s\" is not "
1003 "standard-compliant.\n",
1093 if(-k <= ov && ov <= k) {
1150 pips_user_error(
"Use of pointer arithmetic on \"%s\" at line %d is not "
1151 "standard-compliant.\n%s",
1155 "Try resetting property \"POINTS_TO_STRICT_POINTER_TYPES\""
1156 " for usual non-standard compliant C code.\n"
1172 bool to_be_freed =
false;
1258 "the type returned for the cell"
1260 "\"%s\", is not the expected type, \"%s\".\n",
1332 pips_assert(
"pt_out is consistent after computing L",
1359 pips_assert(
"pt_out is consistent after cells are dangerously updated",
1372 pips_assert(
"pt_out is consistent after computing R",
1781 "by \"%s\" at line %d.\n"
1782 "Or bug in the points-to analysis...\n",
2031 pips_assert(
"This function is not called with a bottom points-to",
2066 pips_user_warning(
"Possible dereferencing of a null pointer \"%s\" at line %d.\n",
2095 bool null_dereferencing_p
2097 bool nowhere_dereferencing_p
2099 if(!null_dereferencing_p) {
2101 if(!nowhere_dereferencing_p) {
2109 if(!
ENDP(ndl) && null_dereferencing_p) {
2117 if(!
ENDP(udl) && nowhere_dereferencing_p) {
2151 bool address_of_p =
true;
2171 if(type_sensitive_p)
2180 pips_assert(
"After removing the kill set, pt_out is consistent",
2202 pips_assert(
"After union and approximation updates pt_out is consistent",
2223 set_size(kill_must)>1?
"possibly " :
"",
2253 kill_may, kill_must,
2298 pips_assert(
"The field and initial value lists have the same length",
2414 pips_assert(
"Both types are struct or array of struct",
2738 #define LESS_THAN_OR_EQUAL_TO 1
2739 #define GREATER_THAN 2
2740 #define GREATER_THAN_OR_EQUAL_TO 3
2751 pips_user_error(
"Incomparable pointers to \"%s\" and \"%s\" are compared.\n",
2760 !
ENDP(sl1c) && !
ENDP(sl2c) && xxx_p;
2761 sl1c =
CDR(sl1c), sl2c =
CDR(sl2c)) {
2855 bool null_initialization_p
2864 bool found_p =
false;
2940 bool found_p =
false;
3028 bool equal_p =
false;
3109 pips_assert(
"The two expressions can be dereferenced", nL>=1 && nR>=1);
3110 if(nL==1 && nR==1) {
3126 " \"%s\" at line %d.\n",
3131 " \"%s\" at line %d.\n",
3203 cmp_function = NULL;
3220 if(cmp_function(lc, sink)) {
3245 if(cmp_function(sink, rc)) {
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
int get_int_property(const string)
cell make_cell_reference(reference _field_)
approximation make_approximation_exact(void)
approximation copy_approximation(approximation p)
APPROXIMATION.
approximation make_approximation_may(void)
descriptor copy_descriptor(descriptor p)
DESCRIPTOR.
descriptor make_descriptor_none(void)
cell copy_cell(cell p)
CELL.
points_to make_points_to(cell a1, cell a2, approximation a3, descriptor a4)
void free_points_to(points_to p)
bool points_to_graph_consistent_p(points_to_graph p)
points_to copy_points_to(points_to p)
POINTS_TO.
points_to_graph copy_points_to_graph(points_to_graph p)
POINTS_TO_GRAPH.
type copy_type(type p)
TYPE.
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
#define remove_arc_from_pt_map(a, s)
#define add_arc_to_pt_map(a, s)
#define difference_of_pt_maps(pt1, pt2, pt3)
#define new_simple_pt_map()
#define union_of_pt_maps(pt1, pt2, pt3)
bool entity_abstract_location_p(entity al)
bool entity_stub_sink_p(entity e)
test if an entity is a stub sink for a formal parameter e.g.
bool cell_typed_anywhere_locations_p(cell c)
test if a cell is the bottom of the lattice
cell make_anywhere_cell(type t)
void const char const char const int
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
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 points_to_must_filter(set in)
returns a set which contains all the EXACT points to
cell make_nowhere_cell()
This file contains all the operators defining constant paths :
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)
set points_to_anywhere_typed(list lhs_list, set input)
Already exists in points_to_general_algorithm.c, to be removed later...
pt_map dereferencing_to_points_to(expression p, pt_map in)
Make sure that expression p can be dereferenced in points-to graph "in".
reference reference_add_field_dimension(reference, entity)
add a field f as a subscript to a reference r if it is meaningful.
bool related_points_to_cell_in_list_p(cell, list)
Two cells are related if they are based on the same entity.
type cell_to_type(cell, bool *)
type points_to_reference_to_concrete_type(reference)
cell make_anywhere_points_to_cell(type)
Function storing points to information attached to a statement.
type points_to_cell_to_type(cell, bool *)
FI: I need more generality than is offered by cell_to_type()
reference cell_any_reference(cell)
API for reference.
cell points_to_cell_add_field_dimension(cell, entity)
Functions about points-to cells - There is no cell.c file.
void points_to_cell_add_unbounded_subscripts(cell)
bool cells_may_not_point_to_null_p(list)
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...
type points_to_cell_to_concrete_type(cell)
bool field_reference_expression_p(expression)
Check if expression "e" is a reference to a struct field.
bool points_to_cell_equal_p(cell, cell)
cell make_null_pointer_value_cell(void)
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 ...
bool anywhere_cell_p(cell)
Is it an anywhere cell?
type points_to_expression_to_concrete_type(expression)
The type returned is stored in a hash-table.
bool generic_atomic_points_to_cell_p(cell, bool)
Is it a unique concrete memory location?
bool nowhere_cell_p(cell)
Target of an undefined pointer.
reference simple_reference_add_field_dimension(reference, entity)
Do not check anything, just add f as a last subscript.
bool cells_must_point_to_null_p(list)
bool points_to_cell_in_list_p(cell, list)
bool atomic_points_to_cell_p(cell)
Is it a unique concrete memory location?
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...
bool adapt_reference_to_type(reference, type, int(*)(void))
FI: a really stupid function...
string effect_reference_to_string(reference)
bool stub_points_to_cell_p(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 in...
void points_to_cell_add_zero_subscripts(cell)
bool heap_cell_p(cell)
Any heap cell, more or less abstract or typed.
bool points_to_cells_intersect_p(cell, cell)
points-to cells use abstract addresses, hence the proper comparison is an intersection.
#define cell_undefined_p(x)
struct _newgen_struct_cell_ * cell
#define approximation_exact_p(x)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
void gen_full_free_list(list l)
entity get_current_module_entity(void)
Get the entity of the current module.
#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)
void gen_list_and_not(list *a, const list b)
Compute A = A inter non B:
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
list gen_last(list l)
Return the last element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
#define list_undefined
Undefined list definition :-)
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
bool set_empty_p(const set)
tell whether set s is empty.
set set_assign(set, const set)
Assign a set with the content of another set.
void sets_free(set,...)
Free several sets in one call.
int set_size(const set)
returns the number of items in s.
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_clear(set)
Assign the empty set to s s := {}.
set set_union(set, const set, const set)
int bool
we cannot use an enum or stdbool because we need to be compatible with newgen, thus boolean need to h...
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
#define remove_arc_from_pt_map_(a, s)
void offset_points_to_cell(cell sink, expression delta, type t, bool unique_p __attribute__((__unused__)))
FI: offset_cell() has been derived from this function.
pt_map relational_intrinsic_call_condition_to_points_to(call c, pt_map in, bool true_p)
Update the points-to information "in" according to the validity of the condition.
void offset_array_reference(reference r, expression delta, type et)
Side effect on reference "r".
points_to offset_cell(points_to pt, expression delta, type et)
Allocate and return a new points-to "npt", copy of "pt", with an offset of "delta" on the sink.
static bool cell_is_xxx_p(cell c1, cell c2, int xxx)
pt_map reference_condition_to_points_to(reference r, pt_map in, bool true_p)
Handle conditions such as "if(p)".
#define GREATER_THAN_OR_EQUAL_TO
pt_map constant_call_to_points_to(call c __attribute__((unused)), pt_map pt_in)
FI: this should not generate any points-to update.
pt_map equal_condition_to_points_to(list al, pt_map in)
The expression list "al" contains exactly two arguments, "lhs" and "rhs".
pt_map pointer_arithmetic_to_points_to(expression lhs, expression delta, pt_map pt_in)
Update the sink locations associated to the source "lhs" under points-to information pt_map by "delta...
pt_map struct_assignment_to_points_to(expression lhs, expression rhs, pt_map pt_in)
pt_in is modified by side-effects and returned as pt_out
cell reduce_cell_to_pointer_type(cell c)
Remove last subscripts of cell c till its type becomes a scalar pointer.
pt_map user_call_condition_to_points_to(call c, pt_map in, list el, bool true_p)
#define LESS_THAN
See if you can decide that the addresses linked to c1 are xxx than the addresses linked to c2.
pt_map intrinsic_call_condition_to_points_to(call c, pt_map in, bool true_p)
We can break down the intrinsics according to their arity or according to their kinds....
pt_map freed_pointer_to_points_to(expression lhs, pt_map pt_in, bool side_effect_p)
Any abstract location of the lhs in L is going to point to nowhere, maybe.
void check_rhs_value_types(expression lhs, expression rhs __attribute__((unused)), list sinks)
Check that the cells in list "sinks" have types compatible with the expression on the left-hand side,...
pt_map call_condition_to_points_to(call c, pt_map in, list el, bool true_p)
Handle any condition that is a call such as "if(p!=q)", "if(*p)", "if(foo(p=q))".....
pt_map call_to_points_to(call c, pt_map pt_in, list el, bool side_effect_p)
Three different kinds of calls are distinguished:
pt_map expressions_to_points_to(list el, pt_map pt_in, bool side_effect_p)
Compute the points-to information pt_out that results from the evaluation of a possibly empty list of...
void check_type_of_points_to_cells(list sinks, type ct, bool eval_p)
Check that all cells in list "sinks" are compatible with type "ct" if "eval_p" is false,...
#define LESS_THAN_OR_EQUAL_TO
pt_map application_to_points_to(application a, pt_map pt_in, bool side_effect_p)
pt_map struct_initialization_to_points_to(expression lhs, expression rhs, pt_map in)
list reduce_cells_to_pointer_type(list cl)
Undo the extra eval performed when stubs are generated: 0 subscripts are added when arrays are involv...
void offset_cells(cell source, list sinks, expression delta, type et, pt_map in)
Each cell in sinks is replaced by a cell located "delta" elements further up in the memory.
pt_map list_assignment_to_points_to(list L, list R, pt_map pt_out)
Update "pt_out" when any element of L can be assigned any element of R.
void subscripted_reference_to_points_to(reference r, list sl, pt_map pt_in)
FI: what is this function supposed to do? Just update "pt_in" to make sure that "r" can be dereferenc...
list points_to_cell_to_useful_pointer_cells(cell c, set pts)
bool cell_is_greater_than_or_equal_to_p(cell c1, cell c2)
pt_map boolean_intrinsic_call_condition_to_points_to(call c, pt_map in, bool true_p)
Deal with "!", "&&", "||" etc.
pt_map internal_pointer_assignment_to_points_to(expression lhs, expression rhs, pt_map pt_in)
Any abstract location of the lhs in L is going to point to any sink of any abstract location of the r...
pt_map condition_to_points_to(expression c, pt_map in, bool true_p)
Update points-to set "in" according to the content of the expression using side effects.
pt_map order_condition_to_points_to(entity f, list al, bool true_p, pt_map in)
The expression list "al" contains exactly two arguments.
pt_map memory_leak_to_more_memory_leaks(cell l, pt_map in)
Cell "l" has been memory leaked for sure and is not referenced any more in "in".
pt_map null_non_equal_condition_to_points_to(expression e, pt_map in)
The condition is e!=NULL.
bool cell_is_greater_than_p(cell c1, cell c2)
pt_map pointer_assignment_to_points_to(expression lhs, expression rhs, pt_map pt_in)
void offset_points_to_cells(list sinks, expression delta, type t)
Each cell in sinks is replaced by a cell located "delta" elements further up in the memory.
pt_map range_to_points_to(range r, pt_map pt_in, bool side_effect_p)
static list generic_points_to_cell_to_useful_pointer_cells(cell c, set pts)
Returns a list of cells of pointer type which are included in cell "c".
bool cell_is_less_than_p(cell c1, cell c2)
pt_map freed_list_to_points_to(expression lhs, list L, list R, pt_map pt_in)
Error detections on "L" and "R" have already been performed.
pt_map intrinsic_call_to_points_to(call c, pt_map pt_in, bool side_effect_p)
bool cell_is_less_than_or_equal_to_p(cell c1, cell c2)
See if you can decide that the addresses linked to c1 are smaller than the addresses linked to c2.
pt_map reference_to_points_to(reference r, pt_map pt_in, bool side_effect_p)
The subscript expressions may impact the points-to information.
pt_map expression_to_points_to(expression e, pt_map pt_in, bool side_effect_p)
Update pt_in and pt_out according to expression e.
pt_map non_equal_condition_to_points_to(list al, pt_map in)
The expression list "al" contains exactly two arguments.
list freeable_points_to_cells(list R)
Remove from points-to cell list R cells that certainly cannot be freed.
list points_to_cells_to_pointer_cells(list pl)
Convert cells in l into derived pointer cells when possible.
pt_map assignment_to_points_to(expression lhs, expression rhs, pt_map pt_in)
pt_map null_equal_condition_to_points_to(expression e, pt_map in)
The condition is e==NULL.
list points_to_cell_to_pointer_cells(cell c)
points_to_graph user_call_to_points_to(call c, points_to_graph pt_in, list el)
FI: limited to the interprocedural option.
bool cell_in_list_p(cell, const list)
bool unreachable_points_to_cell_p(cell, pt_map)
Can cell c be accessed via another cell?
list reference_to_points_to_sinks(reference, type, pt_map, bool, bool)
Returns a list of memory cells "sinks" possibly accessed by the evaluation of reference "r".
bool reference_must_points_to_null_p(reference, pt_map)
bool cell_in_points_to_set_p(cell, set)
Check if a cell c appears as source or sink in points-to set pts.
list points_to_source_to_arcs(cell, pt_map, bool)
Build the list of arcs whose source is "source" according to the points-to graphs "ptm".
points_to find_arc_in_points_to_set(cell, cell, pt_map)
The approximation is not taken into account.
pt_map add_arc_to_pt_map_(points_to, pt_map)
bool statement_points_to_context_defined_p(void)
bool reference_may_points_to_null_p(reference, pt_map)
void remove_points_to_arcs(cell, cell, pt_map)
cell make_null_cell(void)
points_to_graph points_to_cell_source_projection(points_to_graph, cell)
Remove all arcs in "ptg" starting from "c".
pt_map full_copy_pt_map(pt_map)
set points_to_source_projection(set, entity)
Remove all arcs starting from e because e has been assigned a new value.
bool consistent_points_to_set(set)
make sure that set "s" does not contain redundant or contradictory elements
list variable_to_pointer_locations(entity)
variable.c
void remove_impossible_arcs_to_null(list *, pt_map)
You know that null and undefined cells in "*pL" are impossible because of the operation that is going...
int points_to_context_statement_line_number(void)
string points_to_cell_to_string(cell)
list variable_to_sinks(entity, pt_map, bool)
Return all cells in points-to set "pts" who source is based on entity "e".
list source_to_sinks(cell, pt_map, bool)
Return a list of cells, "sinks", that are sink for some arc whose source is "source" or related to "s...
list points_to_sink_to_sources(cell, pt_map, bool)
Build the sources of sink "sink" according to the points-to graphs.
bool consistent_points_to_graph_p(points_to_graph)
pt_map merge_points_to_graphs(pt_map, pt_map)
#define points_to_approximation(x)
#define points_to_undefined_p(x)
#define points_to_graph_undefined_p(x)
#define points_to_sink(x)
#define points_to_graph_bottom(x)
#define POINTS_TO(x)
POINTS_TO.
#define points_to_graph_set(x)
#define points_to_descriptor(x)
#define points_to_source(x)
string reference_to_string(reference r)
string expression_to_string(expression e)
#define print_points_to_cell(x)
string string_of_type(const type)
string type_to_full_string_definition(type)
type.c
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
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_STRCMP_SYSTEM_P(e)
include <string.h>
#define ENTITY_FSCANF_P(e)
#define ENTITY_PLUS_UPDATE_P(e)
#define ENTITY_RELATIONAL_OPERATOR_P(e)
#define ENTITY_FWRITE_P(e)
#define ENTITY_FREE_SYSTEM_P(e)
#define ENTITY_SCANF_P(e)
#define ENTITY_STRNCMP_SYSTEM_P(e)
#define ENTITY_NON_EQUAL_P(e)
#define ENTITY_EQUAL_P(e)
#define ENTITY_ASSIGN_P(e)
#define ENTITY_DEREFERENCING_P(e)
#define ENTITY_LESS_THAN_P(e)
#define ENTITY_ISOC99_SSCANF_P(e)
#define ENTITY_PRINTF_P(e)
o functions: C library and system io.Amira Mensi
#define ENTITY_POINT_TO_P(e)
#define ENTITY_PRE_DECREMENT_P(e)
#define ENTITY_POST_DECREMENT_P(e)
#define DEREFERENCING_OPERATOR_NAME
#define ENTITY_FOPEN_P(e)
#define ENTITY_POST_INCREMENT_P(e)
#define ENTITY_EXIT_SYSTEM_P(e)
#define ENTITY_CONDITIONAL_P(e)
#define ENTITY_FCLOSE_P(e)
#define ENTITY_ISOC99_SCANF_P(e)
#define unary_intrinsic_expression(name, e)
Building quickly bool expressions, FC.
#define ENTITY_PRE_INCREMENT_P(e)
#define ENTITY_FREAD_P(e)
#define ENTITY_PLUS_C_P(e)
#define ENTITY_SPRINTF_P(e)
#define ENTITY_GREATER_THAN_P(e)
#define ENTITY_SSCANF_P(e)
#define ENTITY_LOGICAL_OPERATOR_P(e)
Attention : This definition is different with the Fortran Standard where the logical operators are th...
#define ENTITY_FREOPEN_P(e)
#define ENTITY_MINUS_C_P(e)
#define ENTITY_FERROR_P(e)
#define ENTITY_STRNCAT_SYSTEM_P(e)
#define ENTITY_ABORT_SYSTEM_P(e)
#define ENTITY_FDOPEN_P(e)
#define UNARY_MINUS_OPERATOR_NAME
#define ENTITY_C_RETURN_P(e)
#define ENTITY_ISOC99_FSCANF_P(e)
#define ENTITY_FPRINTF_P(e)
#define ENTITY_FILENO_P(e)
#define ENTITY_LESS_OR_EQUAL_P(e)
#define ENTITY_MINUS_UPDATE_P(e)
#define ENTITY_CLEARERR_P(e)
#define ENTITY_STRCAT_SYSTEM_P(e)
#define ENTITY_GREATER_OR_EQUAL_P(e)
#define ENTITY_ASSERT_FAIL_SYSTEM_P(e)
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
bool entity_array_p(entity e)
Is e a variable with an array type?
entity FindOrCreateTopLevelEntity(const char *name)
Return a top-level entity.
value EvalExpression(expression e)
Evaluate statically an expression.
list struct_initialization_expression_to_expressions(expression e)
Returns a list of expressions hidden by the brace function.
expression reference_to_expression(reference r)
bool zero_expression_p(expression e)
void reference_add_zero_subscripts(reference r, type t)
expression make_unbounded_expression()
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
bool expression_null_p(expression exp)
returns true if the expression is equal to zero or NULL (even if there is a cast before such as in (v...
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
bool expression_reference_p(expression e)
Test if an expression is a reference.
bool unbounded_expression_p(expression e)
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
bool C_initialization_expression_p(expression e)
entity function_to_return_value(entity m)
Returns the entity rv that carries the value returned by module m, when m is not a C void function or...
bool char_star_constant_function_type_p(type)
Beware of typedefs.
type array_type_to_sub_array_type(type)
Allocate a new type, the sub-array type of "t".
bool type_void_star_p(type)
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
bool array_of_pointers_type_p(type)
bool scalar_integer_type_p(type)
bool basic_equal_p(basic, basic)
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.
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
bool pointer_type_p(type)
Check for scalar pointers.
bool type_structurally_equal_p(type, type)
Type t1 and t2 are equal if their basic concrete components are equal.
bool array_pointer_type_equal_p(type, type)
assume that a pointer to type x is equal to a 1-D array of x
size_t type_depth(type)
Number of steps to access the lowest leave of type t without dereferencing.
bool formal_parameter_p(entity)
list struct_type_to_fields(type)
bool struct_type_p(type)
Returns true if t is of type derived and if the derived type is a struct.
type array_type_to_element_type(type)
returns the type of the elements of an array type, as a newly allocated type.
type compute_basic_concrete_type(type)
computes a new type which is the basic concrete type of the input type (this new type is not stored i...
bool overloaded_type_p(type)
Returns true if t is a variable type with a basic overloaded.
bool char_star_type_p(type)
Beware of typedefs.
bool array_of_struct_type_p(type)
bool char_type_p(type)
return true whether âtâ is a char or an unsigned char
bool C_pointer_type_p(type)
Returns OK for "char[]" as well as for "char *".
list struct_variable_to_fields(entity)
Assume that v is declared as a struct.
#define type_functional_p(x)
#define syntax_reference_p(x)
#define functional_result(x)
#define value_constant(x)
#define syntax_reference(x)
#define reference_variable(x)
#define SIZEOFEXPRESSION(x)
SIZEOFEXPRESSION.
#define value_intrinsic_p(x)
#define sizeofexpression_expression(x)
#define type_functional(x)
#define syntax_application(x)
@ is_syntax_sizeofexpression
#define range_increment(x)
#define value_constant_p(x)
#define value_symbolic(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define application_arguments(x)
#define subscript_indices(x)
#define constant_int_p(x)
#define reference_indices(x)
#define syntax_sizeofexpression(x)
#define sizeofexpression_type_p(x)
#define subscript_array(x)
#define application_function(x)
#define syntax_subscript(x)
#define call_arguments(x)
#define expression_syntax(x)
#define type_variable_p(x)
#define symbolic_expression(x)
#define value_expression(x)
#define variable_basic(x)
#define entity_initial(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
#define semantics_user_warning
static list expression_to_points_to_sources(_UNUSED_ expression e, _UNUSED_ points_to_graph in)
static list expression_to_points_to_sinks(_UNUSED_ expression e, _UNUSED_ points_to_graph in)
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.