188 if( strcmp(mn, sn)==0) {
213 if(type_sensitive_p) {
320 bool success_p =
false;
336 pts_kill =
set_union(pts_kill, pts_kill, kill_1);
338 pts_gen =
set_union(pts_gen, pts_gen, gen_1);
339 pts_gen =
set_union(pts_gen, pts_gen, gen_2);
340 pt_end =
set_union(pt_end, pt_end, pts_gen);
504 pips_assert(
"The points-to translation mapping is well typed",
509 if(ok_p && !
ENDP(nfcl)) {
511 (nfcl, pt_in, pt_binded, binding, filtered);
724 semantics_user_warning(
"Type \"%s\" for formal reference \"%s\" is incompatible with type \"%s\" for actual reference \"%s\".\n",
731 (
"Translation failure for actual parameter \"%s\" at line %d.\n"
732 "Maybe property POINTS_TO_STRICT_POINTER_TYPES should be reset.\n",
739 (
"Translation failure for actual parameter \"%s\" at line %d.\n",
763 pips_debug(8,
"First filtered IN set for callee at call site:\n");
765 pips_debug(8,
"First translation mapping for call site:\n");
769 pips_assert(
"The points-to translation mapping is well typed",
776 (fcl, pt_in, pt_binded, binding, filtered);
791 pips_debug(8,
"Final filtered IN set for callee at call site:\n");
793 pips_debug(8,
"Final mapping for call site:\n");
815 bool a_null_p =
false;
816 bool a_nowhere_p =
false;
819 bool f_null_p =
false;
840 if(nfcl>0 && nacl==1 && a_nowhere_p) {
844 else if(nfcl>0 && a_nowhere_p) {
857 bool no_null_p = f_null_p && !a_null_p;
992 (fc, ac, ap, pt_in, pt_binded, binding, filtered);
1012 (nfc, nac, nap, pt_in, pt_binded, binding, filtered);
1016 (nfc, nac, ap, pt_in, pt_binded, binding, filtered);
1029 (nfc, nac, ap, pt_in, pt_binded, binding, filtered);
1033 (nfc, nac, ap, pt_in, pt_binded, binding, filtered);
1134 if(nfl==1 && nal==1)
1178 semantics_user_warning(
"Type \"%s\" for formal reference \"%s\" is incompatible with type \"%s\" for actual reference \"%s\".\n",
1185 (
"Translation failure for actual parameter \"%s\" at line %d.\n"
1186 "Maybe property POINTS_TO_STRICT_POINTER_TYPES should be reset.\n",
1193 (
"Translation failure for actual parameter \"%s\" at line %d.\n",
1206 (fc, ac, approx, pt_in, pt_binded, binding, filtered);
1223 pips_debug(8,
"First filtered IN set for callee at call site:\n");
1225 pips_debug(8,
"First translation mapping for call site:\n");
1229 pips_assert(
"The points-to translation mapping is well typed",
1243 pips_debug(8,
"Final filtered IN set for callee at call site:\n");
1245 pips_debug(8,
"Final mapping for call site:\n");
1362 return out_filtered;
1435 bool typed_p =
true;
1503 if(
false &&
ENDP(acl)) {
1524 type sink_t = e_sink_t;
1545 bool succeed_p =
false;
1546 if(!
ENDP(n_sink_sl)) {
1613 pips_assert(
"The points-to translation mapping is well typed",
1666 set pt_out_callee_filtered,
1706 bool finished_p =
false;
1707 while(!finished_p) {
1737 bool alias_p =
false;
1742 for( ; !
ENDP(c_fpcl);
POP(c_fpcl)) {
1745 hash_put(closure, (
void *) c, (
void *) succ_l);
1746 for(p_fpcl = fpcl; p_fpcl!=c_fpcl;
POP(p_fpcl)) {
1756 if(may_conflict_p ) {
1764 "\"%s\" and \"%s\" at line %d.\n",
1765 must_conflict_p?
"" :
"possible ",
1772 "\"%s\" and \"%s\".\n",
1773 must_conflict_p?
"" :
"possible ",
1855 if(!(
ENDP(l_pt_to_out) &&
ENDP(l_pt_to_in))) {
1859 bool success_p =
false;
1871 set pt_in_filtered =
1895 pt_map pt_end_f = pt_caller;
1913 if(!(
ENDP(l_pt_to_out) &&
ENDP(l_pt_to_in))) {
1924 bool success_p =
false;
1957 set pt_in_filtered =
1979 out_bottom_p =
true;
1984 set pt_out_filtered =
1986 (pt_out, pt_in_filtered, wpl,
f);
1999 c_pt_caller_s =
set_union(c_pt_caller_s, c_pt_caller_s, pt_caller_s);
2029 "callee's output.\n");
2030 out_bottom_p =
true;
2074 pt_end =
set_union(pt_end, pt_end, pt_gen_1);
2087 "We would have to create a new formal context "
2088 "and to restart the points-to analysis "
2089 "and to modify the IN and OUT data structures...\n"
2090 "Or use a simpler analysis, here an intraprocedural one.\n",
2097 out_bottom_p =
true;
2151 list written_cs = written_must_translated;
2175 written_cs =
CONS(
CELL, new_sr, written_cs);
2179 written_cs =
CONS(
CELL, c, written_cs);
2226 new_sr_l =
CONS(
CELL, new_sr, new_sr_l);
2245 pips_assert(
"The effective subscript list is longer than "
2246 "the translated subscript list",
2250 list cind1 = ind1, cind2 = ind2;
2251 bool compatible_p =
true;
2252 while(!
ENDP(cind2)) {
2256 compatible_p =
false;
2265 new_sr_l =
CONS(
CELL, new_sr, new_sr_l);
2272 new_sr_l =
CONS(
CELL, new_sr, new_sr_l);
2349 list translation_failures =
NIL;
2378 if(!
ENDP(new_sr_l)) {
2386 new_sk_l =
CONS(
CELL, new_sk, new_sk_l);
2391 if(!
ENDP(new_sk_l)) {
2426 translation_failures =
CONS(
CELL, sk1, translation_failures);
2430 pips_user_warning(
"Points-to sink cell sk1=\"%s\" could not be translated but has to be.\n",
2459 pips_user_warning(
"Points-to source cell sr1=\"%s\" could not be translated.\n",
2461 translation_failures =
CONS(
CELL, sr1, translation_failures);
2469 pips_user_warning(
"Points-to source cell sr1=\"%s\" could not be translated but has to be.\n",
2484 fprintf(stderr,
"pt_gen is bottom\n");
2654 for (ipc = 1, pc = real_args; pc !=
NIL; pc =
CDR(pc), ipc++) {
2656 int tr = ipc>mnp? mnp : ipc;
2763 pt_binded =
set_union(pt_binded, s, pt_caller);
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)
points_to copy_points_to(points_to p)
POINTS_TO.
points_to_graph make_points_to_graph(bool a1, set a2)
reference make_reference(entity a1, list a2)
reference copy_reference(reference p)
REFERENCE.
#define remove_arc_from_simple_pt_map(a, s)
#define add_arc_to_simple_pt_map(a, s)
#define consistent_pt_map_p(s)
#define new_simple_pt_map()
bool stub_entity_of_module_p(entity s, entity m)
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
bool entity_typed_anywhere_locations_p(entity e)
Test if an entity is the bottom of the lattice.
entity entity_anywhere_locations()
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...
bool entity_anywhere_locations_p(entity e)
test if an entity is the bottom of the lattice
void const char const char const int
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 constant_string_entity_p(entity e)
list load_body_effects(entity e)
list load_summary_effects(entity e)
FI->FI, FI->BC: these two functions should be moved into effects-util or effects-simple.
bool effect_pointer_type_p(effect)
list effects_write_effects(list)
#define ANYWHERE_LOCATION
bool cell_points_to_null_sink_in_set_p(cell, set)
bool related_points_to_cell_in_list_p(cell, list)
Two cells are related if they are based on the same entity.
bool location_entity_p(entity)
bool cell_equal_p(cell, cell)
CELLS.
type points_to_reference_to_concrete_type(reference)
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)
type points_to_cell_to_concrete_type(cell)
bool cell_points_to_nowhere_sink_in_set_p(cell, set)
bool points_to_cell_equal_p(cell, cell)
reference cell_to_reference(cell)
FI: probably to be moved elsewhere in ri-util.
bool anywhere_cell_p(cell)
Is it an anywhere cell?
list recursive_cell_to_pointer_cells(cell)
void points_to_cell_complete_with_zero_subscripts(cell)
bool cell_entity_equal_p(cell, 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 ...
bool compatible_points_to_subscripts_p(expression, expression)
Two subscript are compatible if they are equal or if one of them is unbounded.
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.
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 points_to_cell_in_list_p(cell, list)
bool atomic_points_to_cell_p(cell)
Is it a unique concrete memory location?
void points_to_cell_add_zero_subscript(cell)
bool adapt_reference_to_type(reference, type, int(*)(void))
FI: a really stupid function...
bool heap_cell_p(cell)
Any heap cell, more or less abstract or typed.
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.
#define cell_undefined_p(x)
#define approximation_exact_p(x)
#define approximation_may_p(x)
#define approximation_must_p(x)
#define approximation_undefined
#define effect_approximation(x)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
bool points_to_cell_lists_must_conflict_p(list l1, list l2)
Same as above, but for lists.
bool points_to_cell_lists_may_conflict_p(list l1, list l2)
Same as above, but for lists.
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
void gen_remove(list *cpp, const void *o)
remove all occurences of item o from list *cpp, which is thus modified.
#define POP(l)
Modify a list pointer to point on the next element of the list.
void gen_remove_once(list *pl, const void *o)
Remove the first occurence of o in list pl:
#define NIL
The empty list (nil in Lisp)
list gen_copy_seq(list l)
Copy a list structure.
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)
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.
gen_chunk gen_nth(int n, const list l)
to be used as ENTITY(gen_nth(3, l))...
list gen_full_copy_list(list l)
Copy a list structure with element copy.
void gen_sort_list(list l, gen_cmp_func_t compare)
Sorts a list of gen_chunks in place, to avoid allocations...
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
hash_table hash_table_make(hash_key_type key_type, size_t size)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_put(hash_table htp, const void *key, const void *val)
This functions stores a couple (key,val) in the hash table pointed to by htp.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
#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
#define HASH_MAP(k, v, code, ht)
#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_assign_list(set, const list)
assigns a list contents to a set all duplicated elements are lost
set set_del_element(set, const set, const void *)
set set_assign(set, const set)
Assign a set with the content of another set.
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)
#define set_undefined_p(s)
set set_add_element(set, const set, const void *)
int(* gen_cmp_func_t)(const void *, const void *)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
bool interprocedural_points_to_analysis_p()
void update_points_to_context_with_arc(points_to pt)
Same as , but be careful about the arc before adding it to the points-to context.
bool fast_interprocedural_points_to_analysis_p()
list points_to_cell_to_useful_pointer_cells(cell c, set pts)
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)
static list generic_written_pointers_set(list eff, bool exact_p)
Filter out written effects on pointers.
list points_to_set_to_module_stub_cell_list(entity m, set s, list osl)
void add_implicitly_killed_arcs_to_kill_set(set pt_kill, list wpl, set pt_caller, set pt_out_callee_filtered, set binding, entity f)
Initial comments: add arcs of set "pt_caller" to set "pt_kill" if their origin cells are not in the l...
set filter_formal_out_context_according_to_formal_in_context(set out, set in, list wpl, entity f)
If an address has not been written, i.e.
list points_to_set_to_stub_cell_list(set s, list osl)
pt_map user_call_to_points_to_fast_interprocedural(call c, pt_map pt_in, list csel __attribute__((unused)))
ompute the points to relations in a fast interprocedural way
static bool new_recursive_filter_formal_context_according_to_actual_context_for_pointer_pair(cell fc, cell ac, approximation ap, set pt_in, set pt_binded, set binding, set filtered)
fc and ac are two pointer cells with same or compatible pointer type
static type constant_string_type_to_string_type(type t)
We have to handle constant strings such as "Hello!" and not to forget functional parameters or other ...
list translation_transitive_closure(cell c, set translation)
set compute_points_to_kill_set(list written_must_translated, set pt_caller, set binding __attribute__((unused)))
Translate the "out" set into the scope of the caller.
void remove_arcs_from_pt_map(points_to pts, set pt_out)
bool aliased_translation_p(list fpcl, set translation)
See if two cells in "fpcl" point toward the same location via the transitive closure of "translation"...
set compute_points_to_gen_set(set pt_out, list Written, set binding, entity f)
Translate the out set in the scope of the caller using the binding information, but eliminate irrelev...
list points_to_cell_translation(cell sr1, set binding, entity f)
Compute the list of cells that correspond to cell "sr1" according to the translation mapping "bm" whe...
set compute_points_to_binded_set(entity called_func, list real_args, set pt_caller, bool *success_p)
For each actual argument "r" and its corresponding formal one "f", create the assignment "f = r;" and...
list generic_points_to_set_to_stub_cell_list(entity f, set s, list osl)
Add cells referencing a points-to stub found in parameter "s" are copied and added to list "osl".
static set lower_points_to_approximations_according_to_write_effects(set pt_end, list wpl)
It is partly a kill and partly a gen operation.
list written_pointers_set(list eff)
Filter out written effects on pointers.
list user_call_to_points_to_sinks(call c, type et __attribute__((unused)), pt_map in __attribute__((unused)), bool eval_p)
FI: I assume we do not need the eval_p parameter here.
static bool new_recursive_filter_formal_context_according_to_actual_context(cell fc, cell ac, approximation ap, set pt_in, set pt_binded, set binding, set filtered)
The code is derived from generic_points_to_cell_to_useful_pointer_cell() with no filtering and a dire...
list generic_points_to_cells_translation(list cl, set binding, entity f, bool exact_p)
Allocate a new list with the translations of the cells in cl, when their translation make sense.
list points_to_cells_translation(list cl, set binding, entity f)
Allocate a new list with the translations of the cells in cl, when their translation make sense.
set new_filter_formal_context_according_to_actual_context(list fpcl, set pt_in, set pt_binded, set binding)
bool points_to_translation_mapping_is_typed_p(set translation)
void points_to_translation_of_struct_formal_parameter(cell fc, cell ac, approximation a, type st, set translation)
void points_to_translation_of_formal_parameters(list fpcl, list al, pt_map pt_in, set translation)
List al and fpcl are assumed consistent, and consistent with the formal parameter ranks.
points_to_graph user_call_to_points_to(call c, points_to_graph pt_in, list el)
FI: limited to the interprocedural option.
set user_call_to_points_to_interprocedural_binding_set(call c, pt_map pt_caller)
Compute the binding relations in a complete interprocedural way: be as accurate as possible.
list points_to_cells_pointer_arguments(list al)
Transform a list of arguments of type "expression" to a list of cells.
list points_to_cells_parameters(list dl)
Transform a list of parameters of type "entity" to a list of cells.
pt_map user_call_to_points_to_interprocedural(call c, pt_map pt_caller)
Compute the points-to relations in a complete interprocedural way: be as accurate as possible.
pt_map user_call_to_points_to_intraprocedural(call c, pt_map pt_in, list el __attribute__((unused)))
set points_to_binding_arguments(cell c1, cell c2, set in, set pt_binded)
Recursively find all the arcs, "ai", starting from the argument "c1" using "in", find all the arcs,...
static bool merge_actual_and_formal_sinks(cell fc, list *pfcl, cell ac, list *pacl, set pt_in, set pt_binded, set filtered)
Handle constant cells such as NULL and UNDEFINED (nowhere) in "fcl" and "acl".
set points_to_binding(list args, set in, set pt_binded)
Apply points_to_binding_arguments() to each pair (, complete the process of binding each element of "...
cell points_to_source_alias(points_to pt, set pt_binded)
Let "pt_binded" be the results of assignments of actual arguments to formal arguments (see compute_po...
list points_to_cells_exact_translation(list cl, set binding, entity f)
Allocate a new list with the translations of the cells in cl, when their translation make sense and i...
list certainly_written_pointers_set(list eff)
Filter out certainly written effects on pointers.
set filter_formal_context_according_to_actual_context(list fpcl, set pt_in, set pt_binded, set binding)
Filter "pt_in" according to "pt_binded".
bool recursive_filter_formal_context_according_to_actual_context(list fcl, set pt_in, set pt_binded, set binding, set filtered)
This function looks for successors of elements of list "fcl" both in points-to relations "pt_in" and ...
list expression_to_points_to_sinks(expression, pt_map)
The returned list contains cells used in "in".
points_to create_stub_points_to(cell, type, bool)
bool source_subset_in_set_p(cell, set)
test if a cell "source" appears as a source in a set of points-to
bool source_in_graph_p(cell, points_to_graph)
list points_to_sources_to_effective_sinks(list, pt_map, bool)
list expression_to_points_to_sources(expression, pt_map)
expression_to_points_to_sources() does not always work, especially with pointer arithmetic or subscri...
void upgrade_approximations_in_points_to_set(pt_map)
When arcs have been removed from a points-to relation, the approximations of remaining arcs may not c...
list points_to_source_to_some_sinks(cell, pt_map, bool)
May not retrieve all sinks of the source.
_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 statement_points_to_context_defined_p(void)
list points_to_source_to_sinks(cell, pt_map, bool)
Build the sinks of source "source" according to the points-to graphs.
bool source_in_set_p(cell, set)
test if a cell appear as a source in a set of points-to
list points_to_source_to_any_sinks(cell, pt_map, bool)
Retrieve all possible sinks of the source.
bool points_to_compare_ptr_cell(const void *, const void *)
set add_subscript_dependent_arc_to_simple_pt_map(points_to, set)
The source and destination references imply no dereferencing but the subscripts may be any kind of ex...
list entity_to_sinks(entity)
sinks.c
list any_source_to_sinks(cell, pt_map, bool)
Generalization of source_to_sinks().
void print_points_to_set(string, set)
string points_to_cell_name(cell)
Create a string which is the cell reference in C syntax.
bool consistent_points_to_set(set)
make sure that set "s" does not contain redundant or contradictory elements
list expression_to_points_to_cells(expression, pt_map, bool, bool)
Return a possibly empty list of abstract locations whose addresses are possible value of expression "...
bool arc_in_points_to_set_p(points_to, set)
Check if points-to arc "spt" belongs to points-to set "pts".
int points_to_context_statement_line_number(void)
string points_to_cell_to_string(cell)
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.
pt_map points_to_context_statement_in(void)
#define points_to_approximation(x)
#define points_to_sink(x)
#define points_to_list_list(x)
#define points_to_graph_bottom(x)
#define POINTS_TO(x)
POINTS_TO.
#define points_to_list_bottom(x)
struct _newgen_struct_points_to_list_ * points_to_list
#define points_to_graph_set(x)
#define points_to_source(x)
string reference_to_string(reference r)
#define print_points_to_cells(x)
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 int tc
Internal variables
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
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...
entity entity_to_module_entity(entity e)
Find the enclosing module of an entity.
const char * module_local_name(entity e)
Returns the module local user name.
bool zero_expression_p(expression e)
bool expression_call_p(expression e)
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
bool expression_string_constant_p(expression exp)
call expression_call(expression e)
bool expression_pointer_p(expression e)
we get the type of the expression by calling expression_to_type() which allocates a new one.
bool expression_reference_p(expression e)
Test if an expression is a reference.
void free_expressions(list el)
Free a list of expressions.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
entity any_function_to_return_value(entity m)
Same as function_to_return_value(), but returns value_undefined when m is a C void function or a Fort...
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.
bool array_of_pointers_type_p(type)
bool global_variable_p(entity)
Is v a global variable such as "int i;".
bool static_global_variable_p(entity)
Is v a global variable declared local to a C file such "static int i;".
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.
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 formal_parameter_p(entity)
list struct_type_to_fields(type)
bool array_pointer_string_type_equal_p(type, type)
Assume that a pointer to type x is equal to a 1-D array of x.
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 array_of_struct_type_p(type)
bool char_type_p(type)
return true whether âtâ is a char or an unsigned char
entity find_ith_parameter(entity, int)
#define type_functional_p(x)
#define functional_result(x)
#define parameter_type(x)
#define reference_variable(x)
#define type_functional(x)
#define entity_storage(x)
#define code_declarations(x)
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define entity_undefined_p(x)
#define functional_parameters(x)
#define PARAMETER(x)
PARAMETER.
#define reference_indices(x)
#define type_varargs_p(x)
#define call_arguments(x)
#define entity_initial(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
#define semantics_user_warning
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.