94 bool to_be_freed =
false;
183 char *suffix = strrchr(en,
'_');
292 pips_debug(1,
"Number of source dimensions: %d\n", d);
297 pips_assert(
"The source dimension is zero if the target is not an array", d==0);
303 pips_assert(
"The target dimension is greater than or equal to the source dimension", d<=td);
398 for (csl = sl; !
ENDP(csl);
POP(csl)) {
429 for(csl = ptsl; !
ENDP(csl);
POP(csl)) {
599 bool e_exact_p =
true;
631 else if(source_cd>0) {
690 pips_internal_error(
"This function is no longer used. Functionality moved into create_stub_points_to directly...\n");
728 char *suffix = strrchr(en,
'_');
821 bool null_initialization_p =
get_bool_property(
"POINTS_TO_NULL_POINTER_INITIALIZATION");
822 if(null_initialization_p) {
837 !null_initialization_p);
932 !null_initialization_p);
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 make_approximation_may(void)
bool cell_consistent_p(cell p)
descriptor make_descriptor_none(void)
cell copy_cell(cell p)
CELL.
points_to make_points_to(cell a1, cell a2, approximation a3, descriptor a4)
bool reference_consistent_p(reference p)
value make_value_unknown(void)
type make_type_variable(variable _field_)
storage make_storage_rom(void)
entity gen_find_entity(char *s)
type copy_type(type p)
TYPE.
basic copy_basic(basic p)
BASIC.
basic make_basic_overloaded(void)
ram make_ram(entity a1, entity a2, intptr_t a3, list a4)
expression copy_expression(expression p)
EXPRESSION.
value make_value(enum value_utype tag, void *val)
reference make_reference(entity a1, list a2)
dimension make_dimension(expression a1, expression a2, list a3)
variable make_variable(basic a1, list a2, list a3)
area make_area(intptr_t a1, list a2)
void free_expression(expression p)
storage make_storage_ram(ram _field_)
type make_type(enum type_utype tag, void *val)
static reference ref
Current stmt (an integer)
#define add_arc_to_simple_pt_map(a, s)
bool entity_stub_sink_p(entity e)
test if an entity is a stub sink for a formal parameter e.g.
bdt base
Current expression.
entity MakeIoFileArray(entity f)
This array is pointed by FILE * pointers returned or used by fopen, fclose,...
bool expression_is_constant_p(expression e)
BEGIN_EOLE.
list generic_proper_effects_of_complex_address_expression(expression, list *, int)
void generic_effects_reset_all_methods(void)
void set_methods_for_proper_simple_effects(void)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
reference cell_any_reference(cell)
API for reference.
type points_to_cell_to_concrete_type(cell)
type points_to_reference_to_type(reference, bool *)
FI: I need more generality than is offered by cell_to_type()
cell make_null_pointer_value_cell(void)
reference cell_to_reference(cell)
FI: probably to be moved elsewhere in ri-util.
type cell_reference_to_type(reference, bool *)
computes the type of a cell reference representing a memory access path.
void points_to_cell_types_compatibility(cell, cell)
Make sure that cell l can points towards cell r.
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
const char * get_current_module_name(void)
Get the name of the current module.
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#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)
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
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
list gen_full_copy_list(list l)
Copy a list structure with element copy.
#define STDIN_FILENO
NetBSD 5.0 mis-defines NULL.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define FORMAL_AREA_LOCAL_NAME
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
#define POINTER_DUMMY_TARGETS_AREA_LOCAL_NAME
#define MODULE_SEP_STRING
string concatenate(const char *,...)
Return the concatenation of the given strings.
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_union(set, const set, const set)
set set_add_element(set, const set, const void *)
#define string_undefined_p(s)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
_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 ...
int points_to_equal_p(const void *, const void *)
returns true if two points-to arcs "vpt1" and "vpt2" are equal.
set array_formal_parameter_to_stub_points_to(type t, cell c)
Type "t" is supposed to be a concrete type.
points_to create_pointer_to_array_stub_points_to(cell c, type t, bool exact_p)
To create the points-to stub associated to the formal parameter, the sink name is a concatenation of ...
points_to create_advanced_stub_points_to(cell c, type t, bool exact_p)
Take into account the POINTS_TO_STRICT_POINTER_TYPE to allocate a sink cell of type "t" if the strict...
set pointer_formal_parameter_to_stub_points_to(type pt, cell c)
Input : a formal parameter which is a pointer and its type.
int points_to_indices_to_array_index_number(list sl)
Count the number of array indices and ignore the field subscripts.
list points_to_indices_to_subscript_indices(list ptsl)
Generate a new subscript list.
void points_to_backward_translation()
set derived_formal_parameter_to_stub_points_to(type pt, cell c)
Input : a formal parameter which has a derived type (FI, I guess).
string reference_to_field_disambiguator(reference r)
Build an ASCII string to disambiguate the different field paths that may exist in similar references.
cell create_scalar_stub_sink_cell(entity v, type st, type pt, int d, list sl, string fs)
Create a stub entity "se" for entity "v" with type "t" and return a cell based on a reference to the ...
set formal_points_to_parameter(cell c)
We want a recursive descent on the type of the formal parameter, once we found a pointer type we begu...
void points_to_indices_to_unbounded_indices(list sl)
FI: probably a duplicate...
void points_to_forward_translation()
-----------------------------—Interprocedural Points-to Analysis--------------------—
points_to create_stub_points_to(cell c, type unused_st __attribute__((__unused__)), bool exact_p)
points_to create_stub_points_to(cell c, bool exact_p)
entity create_stub_entity(entity e, string fs, type t)
Allocate a stub entity "stub" for entity "e" and with type "t".
set typedef_formal_parameter_to_stub_points_to(type pt, cell c)
Input : a formal parameter which is a typedef.
#define points_to_undefined
#define points_to_sink(x)
#define print_points_to_cell(x)
void print_type(type)
For debugging.
#define make_entity(n, t, s, i)
#define FOPEN_FUNCTION_NAME
#define ENTITY_STDIN_P(e)
#define FIELD_OPERATOR_NAME
#define DYNAMIC_RAM_OFFSET
FI: I would have assumed that it is used for the stack area, but I must be wrong.....
#define UNKNOWN_RAM_OFFSET
#define DEFAULT_CHARACTER_TYPE_SIZE
Default type sizes.
#define entity_variable_p(e)
An entity_variable_p(e) may hide a typedef and hence a functional type.
#define ENTITY_STDERR_P(e)
#define ENTITY_STDOUT_P(e)
@ ENTITY_POINTER_DUMMY_TARGETS_AREA
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 FindOrCreateEntity(const char *package, const char *local_name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
bool array_entity_p(entity e)
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
bool entity_field_p(entity e)
e is the field of a structure
bool top_level_entity_p(entity e)
Check if the scope of entity e is global.
const char * entity_module_name(entity e)
See comments about module_name().
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
int entity_field_rank(entity f)
f is a field of a structure or of an union: what is its rank?
bool extended_integer_constant_expression_p(expression e)
More extensive than next function.
expression make_unbounded_expression()
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
expression make_zero_expression(void)
Make a zero expression.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
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.
bool unbounded_expression_p(expression e)
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
list make_unbounded_dimensions(int)
Minimal information to build a d-dimensional array type.
type C_type_to_pointed_type(type)
returns a copy of t if t is not a pointer type, and the pointed type if t is a pointer type or.
void AddEntityToDeclarations(entity, entity)
END_EOLE.
type type_to_array_type(type)
convert a type "t" into a newly allocated array type "at" whose elements are of type "t",...
bool static_global_variable_p(entity)
Is v a global variable declared local to a C file such "static int i;".
int variable_dimension_number(variable)
int add_C_variable_to_area(entity, entity)
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 array_pointer_type_equal_p(type, type)
assume that a pointer to type x is equal to a 1-D array of x
type make_scalar_integer_type(_int)
bool formal_parameter_p(entity)
type MakeTypeOverloaded(void)
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.
#define type_functional_p(x)
#define reference_undefined
#define reference_variable(x)
#define basic_typedef_p(x)
#define dimension_lower(x)
#define basic_pointer_p(x)
#define basic_derived_p(x)
#define entity_storage(x)
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define type_undefined_p(x)
#define entity_undefined_p(x)
#define expression_undefined
#define dimension_upper(x)
#define reference_indices(x)
#define variable_dimensions(x)
#define type_variable_p(x)
#define variable_basic(x)
#define entity_initial(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.