25 #include "pips_config.h"
74 bool use_preference_p)
79 pips_debug(8,
"Begins for reference: \"%s\"\n",
103 bool is_array_p = !
ENDP(utd);
111 if (use_preference_p)
127 if (use_preference_p)
140 pips_assert(
"invalid number of reference indices \n",
144 pips_debug(7,
"less ref indices than number of dimensions\n");
171 if (use_preference_p)
184 if (use_preference_p)
443 for(ch_eff=h_eff_l; !
ENDP(ch_eff);
POP(ch_eff)) {
446 for(c_eff = l_eff; !
ENDP(c_eff);
POP(c_eff)) {
484 for(cind = l_inds; !
ENDP(cind);
POP(cind))
549 for(cind = ind; !
ENDP(cind);
POP(cind)) {
567 if(may_p || force_may_p)
667 for(l1= l_eff; !
ENDP(l1);
POP(l1)) {
678 (void)
fprintf(stderr,
"e1: \n");
680 (void)
fprintf(stderr,
"e2: \n");
687 (void)
fprintf(stderr,
"resulting effect e2: \n");
697 (*effects_prettyprint_func)(l_eff);
706 (*effects_prettyprint_func)(l_eff);
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_)
action copy_action(action p)
ACTION.
descriptor make_descriptor(enum descriptor_utype tag, void *val)
cell make_cell(enum cell_utype tag, void *val)
bool effect_consistent_p(effect p)
approximation make_approximation_exact(void)
approximation make_approximation(enum approximation_utype tag, void *val)
approximation copy_approximation(approximation p)
APPROXIMATION.
approximation make_approximation_may(void)
effect make_effect(cell a1, action a2, approximation a3, descriptor a4)
descriptor copy_descriptor(descriptor p)
DESCRIPTOR.
effect copy_effect(effect p)
EFFECT.
descriptor make_descriptor_none(void)
cell make_cell_preference(preference _field_)
void free_preference(preference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
syntax copy_syntax(syntax p)
SYNTAX.
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
void free_syntax(syntax p)
preference make_preference(reference a1)
static reference ref
Current stmt (an integer)
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
void effects_to_may_effects(list)
list proper_effects_combine(list, bool)
effect reference_to_reference_effect(reference, action, bool)
list effect_to_store_independent_sdfi_list(effect, bool)
void simple_effects_descriptor_normalize(list)
void simple_effect_change_ith_dimension_expression(effect, expression, int)
void simple_effect_add_expression_dimension(effect, expression)
list effect_to_sdfi_list(effect)
effect reference_to_simple_effect(reference, action, bool)
unary_operators.c
reference simple_reference_to_store_independent_reference(reference, bool *)
cell simple_cell_to_store_independent_cell(cell, bool *)
list effect_to_may_sdfi_list(effect)
effect simple_effect_field_to_rank_conversion(effect)
list proper_effects_of_range(range)
effect simple_effect_dup(effect)
list simple_effects_composition_with_effect_transformer(list, transformer)
list simple_effects_union_over_range(list, entity, range, descriptor)
list old_effects_composition_with_effect_transformer(list, transformer)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
#define effect_approximation_tag(eff)
action make_action_write_memory(void)
To ease the extension of action with action_kind.
effect effect_interference(effect, effect)
Modifies effect eff1 to make sure that any memory state modification abstracted by eff2 preserves the...
#define cell_reference(x)
#define cell_preference(x)
#define cell_reference_p(x)
#define effect_descriptor(x)
#define cell_preference_p(x)
#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....
void gen_full_free_list(list l)
entity get_current_module_entity(void)
Get the entity of the current module.
bool range_contains_at_least_one_point_p(range r)
bool range_contains_nothing_p(range r)
#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)
#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.
#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_nthcdr(int n, const list lx)
caution: the first item is 0! was: return( (n<=0) ? l : gen_nthcdr( n-1, CDR( l ))) ; if n>gen_length...
#define list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
#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
string reference_to_string(reference r)
#define NORMALIZE_EXPRESSION(e)
bool dummy_parameter_entity_p(entity p)
is p a dummy parameter?
bool c_module_p(entity m)
Test if a module "m" is written in C.
bool entity_field_p(entity e)
e is the field of a structure
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 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 unbounded_expression_p(expression e)
entity expression_variable(expression e)
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
size_t type_depth(type)
Number of steps to access the lowest leave of type t without dereferencing.
#define syntax_reference_p(x)
#define syntax_reference(x)
#define normalized_linear_p(x)
#define reference_variable(x)
#define EXPRESSION(x)
EXPRESSION.
#define reference_indices(x)
#define preference_reference(x)
#define variable_dimensions(x)
#define expression_syntax(x)
#define type_variable_p(x)
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
The structure used to build lists in NewGen.
#define exp
Avoid some warnings from "gcc -Wshadow".