25 #include "pips_config.h"
58 #include "pips-libs.h"
215 sc_nbre_egalites(sc) = 0;
217 sc_nbre_inegalites(sc) = 0;
235 "variable eliminated\n",
242 sc_projection_along_variable_ofl_ctrl
686 pips_assert(
"post is a consistent transformer if pre is defined",
773 pips_assert(
"post is a consistent transformer if pre is defined",
858 pips_debug(8,
"tftwc before transformer_temporary_value_projection %p:\n", tftwc);
864 pips_debug(8,
"tftwc before transformer_apply %p:\n", tftwc);
871 pips_debug(8,
"tftwc after transformer_apply %p:\n", tftwc);
873 pips_debug(8,
"post_tftwc after transformer_apply %p:\n", post_tftwc);
885 pips_debug(8,
"post_tftwc before transformer_convex_hull %p:\n", post_tftwc);
887 pips_debug(8,
"post_tffwc after transformer_apply %p:\n", post_tffwc);
991 Pbase b = sc_base(sc);
1054 pips_debug(9,
"begin with precondition %p \n", pre);
1095 "ignored. Should it be casted to \"(void)\"?\n",
1105 "Should it be casted to \"(void)\"?\n",
1133 pips_debug(8,
"Transformer before intersection with precondition, tf=%p\n",
1143 pips_debug(8,
"After intersection and before normalization with tf=%p\n", tf);
1147 pips_debug(8,
"with precondition pre=%p\n", pre);
1154 pips_debug(8,
"end after normalization with tf=%p\n", tf);
1201 pips_debug(8,
"Transformer %p for callee %s:\n",
1212 "Transformer %p for equality of %s with %s:\n",
1231 "Final transformer %p for assignment of %s with %s:\n",
1242 pips_debug(8,
"end with t_caller=%p\n", t_caller);
1284 pips_debug(8,
"Transformer %p for callee %s:\n",
1307 "Transformer %p for equality of %s with %s:\n",
1327 "Final transformer %p for assignment of %s with %s:\n",
1364 pips_debug(8,
"end with t_caller=%p\n", t_caller);
1521 bool void_p =
false;
1532 pips_internal_error(
"Inconsistent internal representation: \"void\" type used among several formal parameters.\n");
1540 Pbase b = sc_base(sc);
1563 pips_debug(1,
"Transformer before projection:\n");
1670 for(i = 0; i <= c; i++) {
1688 " with upper bound \"%s\": Not implemented yet.\n",
1732 " imprecise effects.\n",
1783 pips_assert(
"We except at least as many subscripts as dimenions",
1842 bool mismatch_p =
false;
1843 while(!
ENDP(asl) && !
ENDP(alsl) && !mismatch_p) {
1849 if(!mismatch_p &&
ENDP(asl)) {
1856 " imprecise effects.\n",
1905 pips_assert(
"The points-to references include all subscripts",
1907 int count = arsn-fd;
1974 pips_assert(
"Same number of actual and formal arguments",
2046 if(pll==0 && !
ENDP(
pl)) {
2060 "(%d and %d) for function \"%s\"\n",
2073 "(%d and %d) for function \"%s\"\n",
2079 pips_user_error(
"Incompatible numbers of actual and formal parameters"
2080 "(%d and %d) for function \"%s\"\n",
2113 pips_user_error(
"Cannot find formal parameter %d for function \"%s\"."
2114 " Mismatch between function declaration and call site."
2115 " Check the source code with flint, gcc or gfortran.\n",
2130 if(as-fs==10 || fs-as==10)
2142 " for argument \"%s\" (rank %d) of function \"%s\" "
2143 "called from function \"%s\".\n",
2152 " for argument \"%s\" (rank %d) of function \"%s\" "
2153 "called from function \"%s\": %s/%s\n",
2296 pips_debug(8,
"Transformer for callee %s:\n",
2312 " %s in call to %s from %s\n",
2325 "Meanwhile, \"atomize\" the call site to avoid the problem.\n");
2331 "for formal parameter \"%s\" (rank %d) "
2332 "in call to \"%s\" from \"%s\"\n",
2354 "Variable %s seems to be aliased thru variable %s"
2355 " at a call site to %s in %s\n"
2356 "PIPS semantics analysis assumes no aliasing as"
2357 " imposed by the Fortran standard.\n",
2368 (t_caller, fp_new, ap_new);
2370 (t_caller, fp_old, ap_old);
2391 "%dth formal parameter %s\n",
2418 pips_debug(8,
"Before formal new values left over are eliminated\n");
2424 formals_new =
CONS(
ENTITY, e_new, formals_new);
2429 formals_new =
CONS(
ENTITY, e_old, formals_new);
2441 "After binding formal/real parameters and eliminating formals\n");
2460 pips_debug(8,
"After replacing global variables\n");
2484 " This may be due to an infinite loop in %s,"
2485 " or to a systematic exit in %s,"
2486 " or to standard violations (see previous messages)\n",
2494 "End: after taking all scalar effects in consideration %p\n",
2748 pips_debug(6,
"return tf=%lx\n", (
unsigned long)tf);
2782 pips_debug(8,
"A transformer has been obtained:\n");
2792 "illegally updated by rhs '%s'\n",
2808 pips_debug(8,
"After substitution v_new=%s -> v_old=%s\n",
2814 pips_debug(8,
"After substitution tmp=%s -> v_new=%s\n",
2823 pips_debug(8,
"After temporary value projection, tf=%p:\n", tf);
3771 pips_debug(8,
"begin for statement %03td (%td,%td) with precondition %p:\n",
3775 pips_assert(
"The statement and its substatements are fully defined",
3859 pips_debug(8,
"Statement local preconditions due to declarations:");
3953 (void)
fprintf(stderr,
"statement %03td (%td,%td):\n",
3962 pips_assert(
"Transformer is internally consistent",
3981 pips_assert(
"transformers are computed in context",
3983 pips_debug(1,
"Convex hull for transformer of statement %03td (%td,%td)\n",
4054 (void)
fprintf(stderr,
"statement %03td (%td,%td), transformer %p:\n",
4072 pips_assert(
"The statement and its substatements are still fully defined",
4076 pips_debug(8,
"end for statement %03td (%td,%td) with t=%p, nt=%p and te=%p\n",
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
int get_int_property(const string)
void free_transformer(transformer p)
transformer make_transformer(list a1, predicate a2)
call make_call(entity a1, list a2)
predicate make_predicate(Psysteme a1)
void free_reference(reference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
bool transformer_consistent_p(transformer p)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
transformer copy_transformer(transformer p)
TRANSFORMER.
struct _newgen_struct_entity_ * entity
bool entity_null_locations_p(entity e)
test if an entity is the NULL POINTER
bool entity_abstract_location_p(entity al)
bool reference_typed_anywhere_locations_p(reference r)
test if a reference is the bottom of the lattice
bool entity_all_module_locations_p(entity e)
test if an entity is the set of locations defined in a module
bool entity_typed_nowhere_locations_p(entity e)
test if an entity is the bottom of the lattice
cons * arguments_union(cons *a1, cons *a2)
cons * arguments_union(cons * a1, cons * a2): returns a = union(a1, a2) where a1 and a2 are lists of ...
void free_arguments(cons *args)
bool entity_is_argument_p(entity e, cons *args)
cons * arguments_add_entity(cons *a, entity e)
void const char const char const int
bool base_contains_variable_p(Pbase b, Variable v)
bool base_contains_variable_p(Pbase b, Variable v): returns true if variable v is one of b's elements...
Pbase vect_add_variable(Pbase b, Variable v)
package vecteur - routines sur les bases
transformer transformer_add_modified_variable(transformer tf, entity var)
FI: this function does not end up with a consistent transformer because the old value is not added to...
transformer transformer_dup(transformer t_in)
transformer package - basic routines
transformer transformer_add_value_update(transformer t, entity v)
Add an update of variable v to t (a value cannot be updated)
transformer precondition_to_abstract_store(transformer pre)
Get rid of all old values and arguments.
void transformer_free(transformer t)
transformer transformer_add_3d_affine_constraint(transformer tf, int a1, entity v1, int a2, entity v2, int a3, entity v3, int cst, bool equation_p)
Add the constraint a1 v1 + a2 v2 + a3 v3 + cst <= or == 0.
bool transformer_weak_consistency_p(transformer t)
Interprocedural transformers do not meet all conditions.
transformer transformer_add_modified_variable_entity(transformer tf, entity var)
FI: like the previous function, but supposed to end up with a consistent transformer.
transformer transformer_identity()
Allocate an identity transformer.
bool transformer_consistency_p(transformer t)
FI: I do not know if this procedure should always return or fail when an inconsistency is found.
transformer transformer_empty()
Allocate an empty transformer.
transformer transformer_add_variables_update(transformer t, list vl)
transformer transformer_add_equality(transformer tf, entity v1, entity v2)
Add an equality between two values (two variables?)
bool transformer_is_empty_p(transformer t)
Check that transformer t is the canonical representation of an empty transformer.
transformer transformer_add_variable_update(transformer t, entity v)
Add an update of variable v into t.
bool transformer_internal_consistency_p(transformer t)
Same as above but equivalenced variables should not appear in the argument list or in the predicate b...
#define CONTRAINTE_UNDEFINED
Pcontrainte contraintes_free(Pcontrainte pc)
Pcontrainte contraintes_free(Pcontrainte pc): desallocation de toutes les contraintes de la liste pc.
Pcontrainte contrainte_make(Pvecteur pv)
Pcontrainte contrainte_make(Pvecteur pv): allocation et initialisation d'une contrainte avec un vecte...
bool refine_transformers_p
Transformer recomputation cannot be of real use unless an interprocedural analysis is performed.
transformer load_summary_transformer(entity e)
bool effects_write_at_least_once_p(list)
list effect_to_constant_path_effects_with_no_pointer_information(effect)
list effects_to_constant_path_effects_with_no_pointer_information(list)
list load_cumulated_rw_effects_list(statement)
bool some_integer_scalar_read_or_write_effects_p(cons *)
list effect_to_constant_path_effects_with_points_to(effect, statement, transformer)
list expression_to_proper_constant_path_effects(expression)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
bool location_entity_p(entity)
type points_to_reference_to_concrete_type(reference)
reference cell_any_reference(cell)
API for reference.
bool anywhere_reference_p(reference)
bool effects_abstract_location_p(list)
Returns true if at least one effect of effect list el is related to an abstract location.
list module_to_analyzed_array_locations(entity)
m is supposed to be a module entity
bool store_effect_p(effect)
bool pt_to_list_undefined_p(void)
points_to.c
bool can_be_constant_path_p(reference)
TODO most of the time return same result that !effect_reference_dereferencing_p for the moment want t...
entity constant_memory_access_path_to_location_entity(reference)
A constant memory access path may not be considered.
bool store_independent_points_to_reference_p(reference)
Functions for points-to references, the kind of references used in points-to cells.
#define cell_reference(x)
#define cell_preference(x)
#define action_write_p(x)
#define cell_preference_p(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)
bool concrete_effects_may_read_or_write_scalar_entity_p(list fx, entity e)
bool entities_may_conflict_p(entity e1, entity e2)
Check if two entities may conflict.
bool references_may_conflict_p(reference r1, reference r2)
Check if two references may conflict.
bool effects_may_read_or_write_scalar_entity_p(list fx, entity e)
check whether scalar entity e may be read or written by effects fx or cannot be accessed at all
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 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.
void gen_free_list(list l)
free the spine of the list
list gen_last(list l)
Return the last element of a list.
bool gen_in_list_p(const void *vo, const list lx)
tell whether vo belongs to lx
#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.
#define list_undefined
Undefined list definition :-)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
bool all_statements_defined_p(statement)
bool declaration_statement_p(statement)
Had to be optimized according to Beatrice Creusillet.
#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
string concatenate(const char *,...)
Return the concatenation of the given strings.
void * gen_find_tabulated(const char *, int)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
void print_entity_variable(entity e)
print_entity_variable(e)
string reference_to_string(reference r)
void print_expression(expression e)
no file descriptor is passed to make is easier to use in a debugging stage.
string expression_to_string(expression e)
#define print_transformer(t)
#define dump_transformer(t)
string basic_to_string(basic)
void print_statement(statement)
Print a statement on stderr.
#define pips_flag_p(p)
for upwards compatibility with Francois's modified version
#define SEMANTICS_FLOW_SENSITIVE
#define SEMANTICS_INTERPROCEDURAL
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
#define ENTITY_PLUS_UPDATE_P(e)
#define ENTITY_MODULO_UPDATE_P(e)
#define ENTITY_BITWISE_AND_UPDATE_P(e)
#define ENTITY_ASSIGN_P(e)
#define ENTITY_COMMA_P(e)
#define ENTITY_ASSERT_SYSTEM_P(e)
include <assert.h>
#define ORDERING_NUMBER(o)
#define ORDERING_STATEMENT(o)
#define NORMALIZE_EXPRESSION(e)
#define statement_block_p(stat)
#define ENTITY_PRE_DECREMENT_P(e)
#define ENTITY_POST_DECREMENT_P(e)
#define entity_symbolic_p(e)
#define ENTITY_POST_INCREMENT_P(e)
#define ENTITY_EXIT_SYSTEM_P(e)
#define ENTITY_CONDITIONAL_P(e)
#define ENTITY_RIGHT_SHIFT_UPDATE_P(e)
#define ENTITY_PRE_INCREMENT_P(e)
#define ENTITY_BITWISE_OR_UPDATE_P(e)
#define is_instruction_block
soft block->sequence transition
#define ENTITY_ABORT_SYSTEM_P(e)
#define ENTITY_MULTIPLY_UPDATE_P(e)
#define ENTITY_DIVIDE_UPDATE_P(e)
#define ENTITY_C_RETURN_P(e)
#define ENTITY_BITWISE_XOR_UPDATE_P(e)
#define instruction_block(i)
#define ENTITY_MINUS_UPDATE_P(e)
#define ENTITY_LEFT_SHIFT_UPDATE_P(e)
#define entity_constant_p(e)
#define ENTITY_ASSERT_FAIL_SYSTEM_P(e)
#define PLUS_C_OPERATOR_NAME
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
entity FindEntity(const char *package, const char *name)
Retrieve an entity from its package/module name and its local name.
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 update_operator_to_regular_operator(entity op)
Returns the binary operator associated to a C update operator such as +=.
bool c_module_p(entity m)
Test if a module "m" is written in C.
bool effects_package_entity_p(entity e)
checks if an entity is an IO_EFFECTS_PACKAGE_NAME, a MALLOC_EFFECTS_NAME or a RAND_EFFECTS_PACKAGE_NA...
basic entity_basic(entity e)
return the basic associated to entity e if it's a function/variable/constant basic_undefined otherwis...
const char * module_local_name(entity e)
Returns the module local user name.
void print_entities(list l)
bool entity_module_p(entity e)
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
bool reference_with_unbounded_subscript_p(reference r)
See if the reference uses the unbounded function '*'.
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
bool extended_integer_constant_expression_p_to_int(expression e, int *result)
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.
call expression_call(expression e)
reference add_subscript_to_reference(reference r, expression s)
Add a last subscript expression s to a reference r.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression find_ith_argument(list args, int n)
bool expression_reference_p(expression e)
Test if an expression is a reference.
bool store_independent_reference_p(reference r)
Does this reference define the same set of memory locations regardless of the current (environment an...
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
expression call_to_expression(call c)
Build an expression that call a function or procedure.
basic basic_of_expression(expression)
basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
bool compatible_basic_p(basic, basic)
check if two basics are similar.
bool variable_return_p(entity)
True if a variable is the pseudo-variable used to store value returned by a function:
statement pop_statement_global_stack(void)
bool global_variable_p(entity)
Is v a global variable such as "int i;".
statement get_current_statement_from_statement_global_stack(void)
bool statement_global_stack_defined_p(void)
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.
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
bool pointer_type_p(type)
Check for scalar pointers.
unsigned int array_type_dimension(type)
bool derived_type_p(type)
Returns true if t is of type struct, union or enum.
bool formal_parameter_p(entity)
expression variable_initial_expression(entity)
Returns a copy of the initial (i.e.
list struct_type_to_fields(type)
bool struct_type_p(type)
Returns true if t is of type derived and if the derived type is a struct.
basic basic_of_call(call, bool, bool)
basic basic_of_call(call c): returns the basic of the result given by the call "c".
void push_statement_on_statement_global_stack(statement)
bool type_with_const_qualifier_p(type)
Is there a const qualifier associated to type t.
type array_type_to_element_type(type)
returns the type of the elements of an array type, as a newly allocated type.
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...
bool variable_static_p(entity)
true if v appears in a SAVE statement, or in a DATA statement, or is declared static i C.
entity find_ith_parameter(entity, int)
#define type_functional_p(x)
#define syntax_reference_p(x)
#define transformer_undefined
#define functional_result(x)
#define transformer_undefined_p(x)
#define instruction_sequence_p(x)
#define storage_formal_p(x)
#define parameter_type(x)
#define syntax_reference(x)
#define value_reference(x)
#define normalized_linear_p(x)
#define instruction_loop_p(x)
#define reference_variable(x)
#define instruction_loop(x)
#define statement_ordering(x)
#define type_functional(x)
#define dimension_lower(x)
#define whileloop_evaluation(x)
#define entity_storage(x)
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define instruction_forloop_p(x)
#define entity_undefined_p(x)
#define expression_undefined
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_expression
#define instruction_tag(x)
#define transformer_relation(x)
#define functional_parameters(x)
#define transformer_arguments(x)
#define PARAMETER(x)
PARAMETER.
#define formal_function(x)
#define dimension_upper(x)
#define reference_indices(x)
#define instruction_forloop(x)
#define preference_reference(x)
#define instruction_expression(x)
#define expression_undefined_p(x)
#define type_varargs_p(x)
#define test_condition(x)
#define instruction_whileloop(x)
#define variable_dimensions(x)
#define statement_declarations(x)
#define statement_instruction(x)
#define instruction_whileloop_p(x)
#define instruction_call(x)
#define call_arguments(x)
#define instruction_test(x)
#define statement_undefined_p(x)
#define statement_number(x)
#define normalized_linear(x)
#define expression_syntax(x)
#define storage_return_p(x)
#define evaluation_before_p(x)
#define type_variable_p(x)
#define predicate_system(x)
#define instruction_unstructured(x)
#define storage_return(x)
#define entity_domain
newgen_syntax_domain_defined
#define variable_basic(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
#define entity_initial(x)
#define syntax_subscript_p(x)
void transformer_add_reference_information(transformer tf, statement s)
struct Ssysteme * Psysteme
void sc_base_add_variable(Psysteme sc, Variable var)
Psysteme sc_make(Pcontrainte leg, Pcontrainte lineg)
Psysteme sc_make(Pcontrainte leg, Pcontrainte lineg): allocation et initialisation d'un systeme d'equ...
bool sc_weak_consistent_p(Psysteme sc)
check that sc is well defined, that the numbers of equalities and inequalities are consistent with th...
Pcontrainte eq
element du vecteur colonne du systeme donne par l'analyse
Pvecteur cp
pointeur sur l'egalite ou l'inegalite courante
void sc_fprint(FILE *fp, Psysteme ps, get_variable_name_t nom_var)
void sc_fprint(FILE * f, Psysteme ps, char * (*nom_var)()): cette fonction imprime dans le fichier po...
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
Psysteme sc_restricted_to_variables_transitive_closure(Psysteme sc, Pbase variables)
for an improved dependence test (Beatrice Creusillet)
Psysteme sc_elim_var(Psysteme sc, Variable v)
package sur les systemes de contraintes sc
#define semantics_user_warning
bool semantics_usable_points_to_reference_p(reference rlhs, expression lhs, int n)
See if references rlhs is usable and process null, undefined and anywhere locations defined by rlhs.
transformer safe_any_expression_to_transformer(entity v, expression expr, transformer pre, bool is_internal)
Always return a usable transformer.
transformer expression_effects_to_transformer(expression expr)
transformer generic_reference_to_transformer(entity v, reference r, transformer pre, bool is_internal)
TYPE INDEPENDENT OPERATIONS.
transformer any_expression_to_transformer(entity v, expression expr, transformer pre, bool is_internal)
A set of functions to compute the transformer associated to an expression evaluated in a given contex...
transformer expressions_to_transformer(list expl, transformer pre)
Compute the transformer associated to a list of expressions such as "i=0, j = 1;".
transformer expression_to_transformer(expression exp, transformer pre, list el)
Just to capture side effects as the returned value is ignored.
transformer safe_expression_to_transformer(expression exp, transformer pre)
transformer conditional_to_transformer(expression cond, expression te, expression fe, transformer pre, list ef)
FI: not too smart to start with the special case with no value returned, just side-effects....
transformer condition_to_transformer(expression cond, transformer pre, bool veracity)
To capture side effects and to add C twist for numerical conditions.
void translate_global_values(entity m, transformer tf)
list module_to_formal_analyzable_parameters(entity f)
returns a module's parameter's list
transformer complete_loop_transformer(transformer ltf, transformer pre, loop l)
The transformer computed and stored for a loop is useful to compute the loop body precondition,...
transformer whileloop_to_transformer(whileloop l, transformer pre, list e)
effects of whileloop l
transformer complete_forloop_transformer(transformer t_body_star, transformer pre, forloop fl)
transformer forloop_to_transformer(forloop fl, transformer pre, list flel)
effects of forloop fl
transformer loop_to_transformer(loop l, transformer pre, list e)
The transformer associated to a DO loop does not include the exit condition because it is used to com...
transformer new_complete_whileloop_transformer(transformer t_body_star, transformer pre, whileloop wl, bool entered_p)
entered_p is used to for the execution of at least one iteration
transformer complete_repeatloop_transformer(transformer t_body_star, transformer pre, whileloop wl)
list dynamic_variables_to_values(list list_mod)
Build the list of values to be projected when the declaration list list_mod is no longer valid becaus...
list semantics_expression_to_points_to_sources(expression e)
Special wrapping for the semantics analyses.
transformer new_substitute_stubs_in_transformer(transformer tf, call c, statement s, bool backward_p)
transformer substitute_scalar_stub_in_transformer(transformer tf, entity se, entity de, bool backward_p, list *ppl)
If both "se", source entity, and "de", destination entity, are defined, substitute the values of "se"...
transformer unstructured_to_transformer(unstructured, transformer, list)
effects of u
void transformer_add_type_information(transformer)
type.c
transformer load_statement_precondition(statement)
void store_statement_transformer(statement, transformer)
transformer load_statement_transformer(statement)
void update_statement_transformer(statement, transformer)
void transformer_add_variable_type_information(transformer, entity)
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
#define VECTEUR_NUL
DEFINITION DU VECTEUR NUL.
#define BASE_UNDEFINED_P(b)
struct Svecteur * Pvecteur
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
Pvecteur vect_make(Pvecteur v, Variable var, Value val,...)
Pvecteur vect_make(v, [var, val,]* 0, val) Pvecteur v; // may be NULL, use assigne anyway Variable va...