34 #include "pips_config.h"
72 bucket_p = found != NULL;
125 pips_assert(
"The type is unchanged or compatible",
false);
136 pips_assert(
"The type is unchanged or compatible",
false);
139 pips_assert(
"The type is unchanged or compatible",
false);
163 ln = &found[found_n];
165 found = strstr(ln,
"_l_");
167 result = (found != NULL);
193 bool scalar_p =
false;;
223 pips_debug(5,
" second arg is a sizeof expression\n");
229 pips_debug(5,
" first arg is a sizeof expression\n");
252 pips_debug(5,
"non constant number of elements "
253 "-> generating unbounded dimension\n");
287 (t_var_sizeof_exp))),
309 (t_var_sizeof_exp))),
335 if(strcmp(opt,
"unique")==0){
344 else if(strcmp(opt,
"insensitive")==0){
367 else if(strcmp(opt,
"flow-sensitive")==0
368 || strcmp(opt,
"context-sensitive")==0 )
373 pips_user_error(
"Unrecognized value for property ABSTRACT_HEAP_LOCATION:"
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
static string current_module
value make_value_unknown(void)
type make_type_variable(variable _field_)
type copy_type(type p)
TYPE.
basic copy_basic(basic p)
BASIC.
basic make_basic_int(intptr_t _field_)
ram make_ram(entity a1, entity a2, intptr_t a3, list a4)
expression copy_expression(expression p)
EXPRESSION.
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)
void free_expression(expression p)
storage make_storage_ram(ram _field_)
reference original_malloc_to_abstract_location(expression lhs __attribute__((unused)), type __attribute__((unused)) var_t, type __attribute__((unused)) cast_t, expression sizeof_exp, entity f, statement stmt)
to handle malloc statemennts:
entity entity_flow_or_context_sentitive_heap_location(int stmt_number, type t)
entity calloc_to_abstract_location(expression n, expression size, sensitivity_information *psi)
generate an abstract heap location entity
sensitivity_information make_sensitivity_information(statement current_stmt, entity current_module, list enclosing_flow)
entity malloc_type_to_abstract_location(type t, sensitivity_information *psi)
generate an abstract heap location entity
type malloc_arg_to_type(expression e)
generate the type of the allocated area from the malloc argument
entity malloc_to_abstract_location(expression malloc_exp, sensitivity_information *psi)
generate an abstract heap location entity
bool entity_flow_or_context_sentitive_heap_location_p(entity e)
bool entity_heap_location_p(entity b)
package abstract location.
entity entity_all_module_heap_locations(entity m)
return m:*HEAP**ANYWHERE
entity entity_all_module_heap_locations_typed(entity m, type t)
bool entity_all_module_heap_locations_p(entity e)
test if an entity is the a heap area
entity entity_all_heap_locations()
return ANY_MODULE:HEAP
entity entity_all_heap_locations_typed(type t)
bool entity_all_heap_locations_p(entity e)
test if an entity is the set of all heap locations
void const char const char const int
static statement current_stmt
#define ANYWHERE_LOCATION
char * get_string_property(const char *)
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 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 CDR(pcons)
Get the list less its first element.
list gen_full_copy_list(list l)
Copy a list structure with element copy.
bool expression_constant_p(expression)
HPFC module by Fabien COELHO.
#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 HEAP_AREA_LOCAL_NAME
#define same_string_p(s1, s2)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
string expression_to_string(expression e)
string string_of_type(const type)
#define DYNAMIC_RAM_OFFSET
FI: I would have assumed that it is used for the stack area, but I must be wrong.....
#define DEFAULT_CHARACTER_TYPE_SIZE
Default type sizes.
#define MULTIPLY_OPERATOR_NAME
bool heap_area_p(entity aire)
entity module_to_heap_area(entity f)
Returns the heap area "a" associated to module "f".
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 entity_array_p(entity e)
Is e a variable with an array type?
expression make_unbounded_expression()
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression make_op_exp(char *op_name, expression exp1, expression exp2)
================================================================
bool unbounded_expression_p(expression e)
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
void AddEntityToDeclarations(entity, entity)
END_EOLE.
int add_C_variable_to_area(entity, entity)
bool type_equal_p(type, 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.
bool pointer_type_p(type)
Check for scalar pointers.
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...
#define reference_undefined
#define sizeofexpression_type(x)
#define sizeofexpression_expression(x)
#define entity_storage(x)
#define syntax_sizeofexpression_p(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define type_undefined_p(x)
#define expression_undefined
#define variable_undefined
#define sizeofexpression_undefined_p(x)
#define syntax_sizeofexpression(x)
#define variable_undefined_p(x)
#define sizeofexpression_type_p(x)
#define expression_undefined_p(x)
#define variable_dimensions(x)
#define sizeofexpression_undefined
#define call_arguments(x)
#define statement_number(x)
#define expression_syntax(x)
#define type_variable_p(x)
#define variable_basic(x)
#define entity_initial(x)
int var_t
Type of variables.
The structure used to build lists in NewGen.