|
list | ReferenceUnion (list, list, bool(*)(effect, effect)) |
| cproto-generated files More...
|
|
list | ReferenceTestUnion (list, list, bool(*)(effect, effect)) |
|
list | EffectsMayUnion (list, list, bool(*)(effect, effect)) |
| list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, may union of the two initial lists modifies : l1 and l2 and their effects. More...
|
|
list | ProperEffectsMustUnion (list, list, bool(*)(effect, effect)) |
| list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...
|
|
list | EffectsMustUnion (list, list, bool(*)(effect, effect)) |
| list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...
|
|
list | effects_may_union (effect, effect) |
|
list | effects_must_union (effect, effect) |
|
effect | effect_may_union (effect, effect) |
| Preserve store independent information as long as you can. More...
|
|
effect | effect_must_union (effect, effect) |
| computes the must union of two combinable effects More...
|
|
list | EffectsSupDifference (list, list, bool(*)(effect, effect)) |
| list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the sup_difference of the initial effects. More...
|
|
list | EffectsInfDifference (list, list, bool(*)(effect, effect)) |
| list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the inf_difference of the initial effects. More...
|
|
effect | proper_to_summary_simple_effect (effect) |
| FI: the goal is to get rid of array subscripts to handle the arrays atomically. More...
|
|
bool | simple_cells_intersection_p (cell, descriptor, cell, descriptor, bool *) |
|
bool | simple_cells_inclusion_p (cell, descriptor, cell, descriptor, bool *) |
|
bool | cumulated_references (const string) |
| interface.c More...
|
|
bool | proper_references (const string) |
|
bool | proper_pointer_effects (const string) |
|
bool | summary_pointer_effects (const string) |
|
bool | cumulated_pointer_effects (const string) |
|
bool | cumulated_pointer_effects_with_points_to (const string) |
|
bool | cumulated_pointer_effects_with_pointer_values (const string) |
|
bool | proper_effects (const string) |
|
bool | proper_effects_with_points_to (const string) |
|
bool | proper_effects_with_pointer_values (const string) |
|
bool | summary_effects (const string) |
|
bool | cumulated_effects (const string) |
|
bool | cumulated_effects_with_points_to (const string) |
|
bool | cumulated_effects_with_pointer_values (const string) |
|
bool | in_summary_effects (const string) |
|
bool | out_summary_effects (const string) |
|
bool | in_effects (const string) |
|
bool | out_effects (const string) |
|
bool | print_code_proper_pointer_effects (const string) |
|
bool | print_code_cumulated_pointer_effects (const string) |
|
bool | print_code_proper_effects (const string) |
|
bool | print_code_cumulated_effects (const string) |
|
bool | print_code_proper_references (const string) |
|
bool | print_code_cumulated_references (const string) |
|
bool | print_code_in_effects (const string) |
|
bool | print_code_out_effects (const string) |
|
bool | print_source_proper_effects (const string) |
|
bool | print_source_cumulated_effects (const string) |
|
bool | print_source_in_effects (const string) |
|
bool | print_source_out_effects (const string) |
|
bool | print_code_as_a_graph_proper_effects (const string) |
|
bool | print_code_as_a_graph_cumulated_effects (const string) |
|
text | get_text_proper_pointer_effects (const string) |
|
text | get_text_cumulated_pointer_effects (const string) |
|
text | get_text_proper_effects (const string) |
|
text | get_text_cumulated_effects (const string) |
|
list | proper_effects_of_expression (expression) |
|
list | expression_to_proper_effects (expression) |
|
list | proper_constant_path_effects_of_any_expression (expression, bool) |
|
list | proper_constant_path_effects_of_expression (expression) |
|
list | proper_constant_path_effects_of_lhs_expression (expression) |
|
list | expression_to_proper_constant_path_effects (expression) |
|
list | lhs_expression_to_proper_constant_path_effects (expression) |
|
bool | expression_with_side_effect_p (expression) |
|
list | proper_constant_path_effects_of_expression_with_points_to (expression, statement) |
|
list | expression_to_proper_constant_path_effects_with_points_to (expression, statement) |
|
list | proper_effects_of_range (range) |
|
bool | expression_invariant_wrt_effects (expression, list) |
|
void | rproper_effects_of_statement (statement) |
|
void | rcumulated_effects_of_statement (statement) |
|
list | statement_to_effects (statement) |
|
bool | full_simple_proper_effects (const char *, statement) |
|
bool | simple_cumulated_effects (const char *, statement) |
|
bool | live_paths (const string) |
|
bool | live_in_summary_paths (const string) |
|
bool | live_out_summary_paths (const string) |
|
bool | print_code_live_in_paths (const string) |
|
bool | print_code_live_out_paths (const string) |
|
bool | update_loops_locals (const char *, statement) |
|
bool | is_implied_do_index (entity, instruction) |
|
list | get_list_of_variable_to_filter (void) |
|
bool | print_icfg_with_proper_effects (const string) |
|
bool | print_icfg_with_cumulated_effects (const string) |
|
bool | print_icfg_with_loops_proper_effects (const string) |
|
bool | print_icfg_with_loops_cumulated_effects (const string) |
|
bool | print_icfg_with_control_proper_effects (const string) |
|
bool | print_icfg_with_control_cumulated_effects (const string) |
|
bool | print_icfg_with_filtered_proper_effects (const string) |
|
bool | print_dvicfg_with_filtered_proper_effects (const string) |
|
void | set_methods_for_proper_references (void) |
| methods.c More...
|
|
void | set_methods_for_cumulated_references (void) |
|
void | set_default_methods_for_proper_simple_effects (void) |
|
void | set_methods_for_proper_simple_effects (void) |
|
void | set_methods_for_proper_simple_pointer_effects (void) |
|
void | set_methods_for_simple_effects (void) |
|
void | set_methods_for_simple_pointer_effects (void) |
|
void | set_methods_for_inout_effects (const char *) |
|
void | set_methods_for_live_paths (const char *) |
|
void | reset_methods_for_inout_effects (void) |
|
void | set_methods_for_rw_effects_prettyprint (const char *) |
|
void | set_methods_for_inout_effects_prettyprint (const char *) |
|
void | set_methods_for_live_in_paths_prettyprint (const char *) |
|
void | set_methods_for_live_out_paths_prettyprint (const char *) |
|
void | reset_methods_for_effects_prettyprint (const char *) |
|
bool | add_points_to_subscript_lists (list *, list, list) |
| translation.c More...
|
|
bool | simple_cell_reference_with_address_of_cell_reference_translation_fi (reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *) |
|
void | simple_cell_reference_with_address_of_cell_reference_translation (reference, descriptor, reference, descriptor, int, reference *, 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 *) |
|
void | simple_cell_with_value_of_cell_translation (cell, descriptor, cell, descriptor, int, cell *, descriptor *, bool *) |
|
void | simple_effects_translation_init (entity, list, bool) |
| interprocedural.c More...
|
|
void | simple_effects_translation_end (void) |
|
void | simple_effect_descriptor_interprocedural_translation (effect) |
|
list | simple_effects_backward_translation (entity, list, list, transformer) |
|
effect | translate_effect_to_sdfi_effect (effect) |
|
list | effects_dynamic_elim (list) |
|
list | make_unknown_subscript (int) |
|
list | summary_effect_to_proper_effect (call, effect) |
|
void | check_user_call_site (entity, list) |
|
list | fortran_summary_to_proper_effects (entity, list, list) |
|
list | c_simple_effects_on_formal_parameter_backward_translation (list, expression, transformer) |
|
list | c_summary_effect_to_proper_effects (effect, expression) |
|
list | c_summary_to_proper_effects (entity, list, list) |
|
list | summary_to_proper_effects (entity, list, list) |
|
list | simple_effects_forward_translation (entity, list, list, transformer) |
|
list | c_simple_effects_on_actual_parameter_forward_translation (entity, expression, entity, list, transformer) |
|
text | simple_rw_effects_to_text (list) |
| prettyprint.c More...
|
|
text | simple_inout_effects_to_text (list) |
|
text | simple_live_in_paths_to_text (list) |
|
text | simple_live_out_paths_to_text (list) |
|
string | effect_to_string (effect) |
|
list | words_effect_generic (effect, bool) |
|
list | words_effect (effect) |
|
list | words_effect_without_approximation (effect) |
|
void | print_effect (effect) |
|
void | print_effects (list) |
|
void | print_memory_effects (list) |
|
bool | print_call_graph_with_proper_effects (const string) |
|
bool | print_call_graph_with_cumulated_effects (const string) |
|
effect | reference_to_simple_effect (reference, action, bool) |
| unary_operators.c More...
|
|
void | simple_effect_add_expression_dimension (effect, expression) |
|
void | simple_effect_change_ith_dimension_expression (effect, expression, int) |
|
effect | simple_effect_field_to_rank_conversion (effect) |
|
effect | simple_effect_dup (effect) |
|
effect | reference_to_reference_effect (reference, action, bool) |
|
list | simple_effects_union_over_range (list, entity, range, descriptor) |
|
reference | simple_reference_to_store_independent_reference (reference, bool *) |
|
cell | simple_cell_to_store_independent_cell (cell, bool *) |
|
list | effect_to_store_independent_sdfi_list (effect, bool) |
|
list | effect_to_may_sdfi_list (effect) |
|
list | effect_to_sdfi_list (effect) |
|
void | simple_effects_descriptor_normalize (list) |
|
list | simple_effects_composition_with_effect_transformer (list, transformer) |
|
list | old_effects_composition_with_effect_transformer (list, transformer) |
|
bool | filter_proper_effects (const char *) |
| filter_proper_effects.c More...
|
|
bool | simple_cell_reference_preceding_p (reference, descriptor, reference, descriptor, transformer, bool, bool *) |
| eval.c More...
|
|
bool | simple_cell_preceding_p (cell, descriptor, cell, descriptor, transformer, bool, bool *) |
|
bool | path_preceding_p (effect, effect, transformer, bool, bool *) |
|
void | simple_reference_to_simple_reference_conversion (reference, reference *, descriptor *) |
|
void | simple_cell_to_simple_cell_conversion (cell, cell *, descriptor *) |
|
list | eval_simple_cell_with_points_to (cell, descriptor, list, bool *, transformer) |
|
list | simple_effect_to_constant_path_effects_with_pointer_values (effect) |
|
list | effect_to_constant_path_effects_with_points_to (effect, statement, transformer) |
|
list | simple_effect_to_constant_path_effects_with_points_to (effect) |
|
list | eval_cell_with_points_to (cell, list, bool *) |
| for backward compatibility More...
|
|
Preserve store independent information as long as you can.
I should have some order on references to absorb, for instance, x[1] by x[*].
computes the may union of two combinable effects
- Parameters
-
- See also
- effects_combinable_p
- Returns
- a new effect with no sharing with the input effects
Abstract locations cases
In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);
new_ent = entity_locations_max(e1, e2);
eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }
but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))
concrete locations cases
it's a preference : we change for a reference cell
let us check the indices
- Parameters
-
Definition at line 163 of file binary_operators.c.
208 eff = (*effect_dup_func)(eff1);
215 eff = (*effect_dup_func)(eff2);
231 eff = (*effect_dup_func)(eff1);
cell make_cell_reference(reference _field_)
action copy_action(action p)
ACTION.
approximation make_approximation(enum approximation_utype tag, void *val)
reference copy_reference(reference p)
REFERENCE.
static reference ref
Current stmt (an integer)
entity entity_locations_max(entity al1, entity al2)
Here, entity al1 and entity al2 can be program variables.
#define effect_approximation_tag(eff)
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)
#define cell_preference(x)
#define cell_preference_p(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 CAR(pcons)
Get the value of the first element of a list.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
expression make_unbounded_expression()
bool expression_equal_p(expression e1, expression e2)
Syntactic equality e1==e2.
#define EXPRESSION(x)
EXPRESSION.
#define preference_reference(x)
The structure used to build lists in NewGen.
References approximation_and(), approximation_tag, CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.
Referenced by effects_may_union().
computes the must union of two combinable effects
- Parameters
-
- See also
- effects_combinable_p
- Returns
- a new effect with no sharing with the input effects
Abstract locations cases
In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);
new_ent = entity_locations_max(e1, e2);
eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }
but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))
concrete locations cases
it's a preference : we change for a reference cell
let us check the indices
- Parameters
-
Definition at line 272 of file binary_operators.c.
317 eff = (*effect_dup_func)(eff1);
324 eff = (*effect_dup_func)(eff2);
340 eff = (*effect_dup_func)(eff1);
tag approximation_or(tag, tag)
tag approximation_or(tag t1, tag t2) input : two approximation tags.
References approximation_and(), approximation_or(), CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.
Referenced by effects_must_union().
FI: the goal is to get rid of array subscripts to handle the arrays atomically.
This is not possible with pointer indexing. For instance, p[0] is reduced the Fortran way into p, which is wrong. It could be reduced to p[*] and lead to an anywhere effects. Or we must preserve constant indices (store independent), which is the way to go with C since we transform lots of scalar accesses into array accesses.
FI: I do not understand the mix of side effects on eff, free and alloc conditionnaly for some fields. To be checked.
it's a preference : we change for a reference cell
it's a reference : let'us modify it
it may still be a field entity
- Parameters
-
Definition at line 488 of file binary_operators.c.
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,
void free_expression(expression p)
list words_effect(effect)
#define cell_reference(x)
#define list_undefined
Undefined list definition :-)
void print_expression(expression e)
no file descriptor is passed to make is easier to use in a debugging stage.
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.
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
string words_to_string(cons *lw)
References CAR, cell_preference, cell_preference_p, cell_reference, copy_reference(), effect_approximation_tag, effect_cell, effect_scalar_p(), ENDP, entity_field_p(), EXPRESSION, EXPRESSION_, expression_reference_p(), expression_variable(), extended_integer_constant_expression_p(), free_cell(), free_expression(), ifdebug, is_approximation_may, list_undefined, make_cell_reference(), make_unbounded_expression(), pips_debug, POP, preference_reference, print_expression(), ref, reference_indices, reference_undefined, unbounded_expression_p(), words_effect(), and words_to_string().