25 #include "pips_config.h"
67 for(casl=asl, cisl=isl; !
ENDP(casl) && !
ENDP(cisl);
POP(casl),
POP(cisl)) {
125 int nb_common_indices,
130 bool ok_p = nb_common_indices==0 ||
ENDP(sl);
148 else if(nis==nas+1) {
161 else if(nis>0 && nas==0) {
181 if(strict_p? nis<=nd : nis<=nd+1) {
203 pips_internal_error(
"Translation failure: the type of the translated cells is different from the type of the input cell.\n");
245 int nb_common_indices,
251 pips_debug(1,
"nb_common_indices: %d \n", nb_common_indices);
271 for(
int i = 0; i<nb_common_indices; i++,
POP(input_remaining_indices));
275 if (!
ENDP(output_indices)) {
286 pips_user_warning(
"potential memory overflow due to effect -> returning anywhere\n");
292 new_exp = last_output_indices_exp;
298 intptr_t i_first_input_remaining_exp;
301 bool b_i_first_input_remaining_exp =
expression_integer_value(first_input_remaining_exp, &i_first_input_remaining_exp);
303 if (b_i_last_output_indices_exp && i_last_output_indices_exp == 0) {
305 POP(input_remaining_indices);
307 else if (b_i_first_input_remaining_exp && i_first_input_remaining_exp == 0) {
309 POP(input_remaining_indices);
325 POP(input_remaining_indices);
331 POP(input_remaining_indices);
347 POP(input_remaining_indices);
360 pips_user_warning(
"potential memory overflow due to effect -> returning anywhere\n");
388 list sl = input_remaining_indices;
393 sl =
CDR(input_remaining_indices);
414 pips_internal_error(
"Translation failure: the type of the translated cells is different from the type of the input cell.\n");
440 int nb_common_indices,
459 for(
int i = 0; i<nb_common_indices; i++,
POP(input_inds));
473 int nb_common_indices,
481 address_of_ref, address_of_desc,
482 nb_common_indices, &output_ref,
492 int nb_common_indices,
500 value_of_ref, value_of_desc,
501 nb_common_indices, &output_ref,
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_)
void free_reference(reference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
entity entity_all_locations()
eturn ANY_MODULE:ANYWHERE (the top of the lattice)
void const char const char const int
void simple_cell_reference_with_address_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
bool add_points_to_subscript_lists(list *, list, list)
translation.c
bool simple_cell_reference_with_address_of_cell_reference_translation_fi(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
void simple_cell_with_value_of_cell_translation(cell, descriptor, cell, descriptor, int, cell *, descriptor *, bool *)
void simple_cell_reference_with_value_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
void simple_cell_with_address_of_cell_translation(cell, descriptor, cell, descriptor, int, cell *, descriptor *, bool *)
type points_to_reference_to_concrete_type(reference)
reference cell_any_reference(cell)
API for reference.
bool anywhere_reference_p(reference)
bool exact_points_to_subscript_list_p(list)
See if the subscript list sl is precise, i.e.
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#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.
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.
list gen_full_copy_list(list l)
Copy a list structure with element copy.
#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
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
string reference_to_string(reference r)
#define PLUS_OPERATOR_NAME
#define binary_intrinsic_expression(name, e1, e2)
bool entity_field_p(entity e)
e is the field of a structure
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
value EvalExpression(expression e)
Evaluate statically an expression.
bool expression_integer_value(expression e, intptr_t *pval)
bool expression_field_p(expression e)
The expression is of kind "s.a", where "s" is a struct and a "a" field.
bool zero_expression_p(expression e)
expression make_unbounded_expression()
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
bool expression_equal_p(expression e1, expression e2)
Syntactic equality e1==e2.
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_reference_p(expression e)
Test if an expression is a reference.
bool expression_equal_integer_p(expression exp, int i)
================================================================
bool unbounded_expression_p(expression e)
entity expression_variable(expression e)
bool type_equal_p(type, type)
size_t maximal_type_depth(type)
Number of steps to access the lowest leave of type t without a recursive test.
bool type_equal_up_to_qualifiers_p(type, type)
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
#define value_undefined_p(x)
#define value_constant(x)
#define reference_variable(x)
#define value_constant_p(x)
#define EXPRESSION(x)
EXPRESSION.
#define constant_int_p(x)
#define expression_undefined
#define reference_indices(x)
The structure used to build lists in NewGen.