25 #include "pips_config.h"
45 #include "constants.h"
56 #include "resources.h"
208 eff = (*effect_dup_func)(eff1);
215 eff = (*effect_dup_func)(eff2);
231 eff = (*effect_dup_func)(eff1);
317 eff = (*effect_dup_func)(eff1);
324 eff = (*effect_dup_func)(eff2);
340 eff = (*effect_dup_func)(eff1);
443 debug(3,
"EffectsSupDifference",
"begin\n");
445 difference_combinable_p,
447 debug(3,
"EffectsSupDifference",
"end\n");
467 debug(3,
"EffectsInfDifference",
"begin\n");
469 difference_combinable_p,
471 debug(3,
"EffectsInfDifference",
"end\n");
510 pips_debug(8,
"Proper effect %p with reference %p: %s\n", eff,
ref,
516 for(cind = inds; !
ENDP(cind);
POP(cind)) {
543 pips_debug(8,
"Summary simple effect %p with reference %p: %s\n", eff,
ref,
572 bool concrete_locations_p =
true;
579 if (c1_abstract_location_p || c2_abstract_location_p)
586 if (heap1_context_sensitive_p && heap2_context_sensitive_p)
588 concrete_locations_p =
true;
592 concrete_locations_p =
false;
599 if (concrete_locations_p)
606 res =
true; *exact_p =
true;
607 while(res && !
ENDP(l1))
651 bool concrete_locations_p =
true;
658 if (c1_abstract_location_p || c2_abstract_location_p)
665 if (heap1_context_sensitive_p && heap2_context_sensitive_p)
667 concrete_locations_p =
true;
673 concrete_locations_p =
false;
677 if (concrete_locations_p)
684 for(;!
ENDP(inds1) && res ==
true;
POP(inds1),
POP(inds2))
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.
approximation make_approximation(enum approximation_utype tag, void *val)
reference make_reference(entity a1, list a2)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
bool entity_flow_or_context_sentitive_heap_location_p(entity e)
static reference ref
Current stmt (an integer)
entity abstract_locations_max(entity al1, entity al2)
eturns the smallest abstract location set greater than or equalt to al1 and al2.
entity entity_locations_max(entity al1, entity al2)
Here, entity al1 and entity al2 can be program variables.
list list_of_effects_generic_sup_difference_op(list, list, bool(*)(effect, effect), list(*)(effect, effect))
list effect_to_may_effect_list(effect)
void effects_to_may_effects(list)
list list_of_effects_generic_union_op(list, list, bool(*)(effect, effect), list(*)(effect, effect), list(*)(effect))
list list_of_effects_generic_inf_difference_op(list, list, bool(*)(effect, effect), list(*)(effect, effect))
effect(* effect_dup_func)(effect eff)
list effect_to_list(effect)
bool cells_combinable_p(cell, cell)
list EffectsMustUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect))
list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a l...
list EffectsMayUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect))
list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a li...
static list effect_sup_difference(effect eff1, effect eff2)
effect effect_may_union(effect eff1, effect eff2)
Preserve store independent information as long as you can.
list effects_may_union(effect eff1, effect eff2)
list ReferenceTestUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect) __attribute__((unused)))
list ReferenceUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect) __attribute__((unused)))
package effect: new version by Beatrice Creusillet
bool simple_cells_inclusion_p(cell c1, __attribute__((__unused__)) descriptor d1, cell c2, __attribute__((__unused__)) descriptor d2, bool *exact_p)
Inclusion test :
list effects_must_union(effect eff1, effect eff2)
list ProperEffectsMustUnion(list l1, list l2, bool(*union_combinable_p)(effect, effect))
list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a l...
bool simple_cells_intersection_p(cell c1, descriptor __attribute__((__unused__)) d1, cell c2, descriptor __attribute__((__unused__)) d2, bool *exact_p)
static list effect_inf_difference(effect eff1 __attribute__((unused)), effect eff2 __attribute__((unused)))
list EffectsInfDifference(list l1, list l2, bool(*difference_combinable_p)(effect, effect))
list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect,...
list EffectsSupDifference(list l1, list l2, bool(*difference_combinable_p)(effect, effect))
list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect,...
effect effect_must_union(effect eff1, effect eff2)
computes the must union of two combinable effects
effect proper_to_summary_simple_effect(effect eff)
FI: the goal is to get rid of array subscripts to handle the arrays atomically.
list effect_to_sdfi_list(effect)
list effect_to_may_sdfi_list(effect)
list words_effect(effect)
#define effect_may_p(eff)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
#define effect_approximation_tag(eff)
#define effect_exact_p(eff)
#define make_simple_effect(reference, action, approximation)
tag approximation_and(tag, tag)
tag approximation_and(tag t1, tag t2) input : two approximation tags.
bool effect_abstract_location_p(effect)
entity effect_entity(effect)
cproto-generated files
bool effect_scalar_p(effect)
tag approximation_or(tag, tag)
tag approximation_or(tag t1, tag t2) input : two approximation tags.
bool cell_abstract_location_p(cell)
#define cell_reference(x)
#define cell_preference(x)
#define approximation_tag(x)
#define cell_preference_p(x)
#define effect_approximation(x)
#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)
#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 list_undefined
Undefined list definition :-)
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
void print_expression(expression e)
no file descriptor is passed to make is easier to use in a debugging stage.
bool same_entity_p(entity e1, entity e2)
predicates on entities
bool entity_field_p(entity e)
e is the field of a structure
bool extended_integer_constant_expression_p(expression e)
More extensive than next function.
expression make_unbounded_expression()
bool expression_equal_p(expression e1, expression e2)
Syntactic equality e1==e2.
bool reference_equal_p(reference r1, reference r2)
bool expression_reference_p(expression e)
Test if an expression is a reference.
bool unbounded_expression_p(expression e)
entity expression_variable(expression e)
#define reference_undefined
#define EXPRESSION(x)
EXPRESSION.
#define reference_indices(x)
#define preference_reference(x)
The structure used to build lists in NewGen.
string words_to_string(cons *lw)