transformer.h File Reference

Go to the source code of this file.

Macros
#define	SEMANTICS_MODULE_NAME   "*SEMANTICS*"
	Warning! Do not modify this file that is automatically generated! More...
#define	SEMANTICS_SEPARATOR   '#'
	Must be used in suffixes and prefixes below. More...
#define	OLD_VALUE_PREFIX   "o#"
	internal entity names (FI: I should have used suffixes to be consistent with external suffixes More...
#define	INTERMEDIATE_VALUE_PREFIX   "i#"
#define	TEMPORARY_VALUE_PREFIX   "t#"
#define	NEW_VALUE_SUFFIX   "#new"
	external suffixes (NEW_VALUE_SUFFIX is not used, new values are represented by the variable itself, i.e. More...
#define	OLD_VALUE_SUFFIX   "#init"
#define	INTERMEDIATE_VALUE_SUFFIX   "#int"
#define	ADDRESS_OF_SUFFIX   "#addressof"
#define	SIZEOF_SUFFIX   "#sizeof"

Functions
transformer	transformer_dup (transformer)
	cproto-generated files More...
void	transformer_free (transformer)
void	free_transformers (transformer,...)
void	old_transformer_free (transformer)
transformer	transformer_identity (void)
	Allocate an identity transformer. More...
transformer	transformer_empty (void)
	Allocate an empty transformer. More...
transformer	empty_transformer (transformer)
	Do not allocate an empty transformer, but transform an allocated transformer into an empty_transformer. More...
bool	transformer_identity_p (transformer)
	Check that t is an identity function. More...
bool	transformer_is_empty_p (transformer)
	Check that transformer t is the canonical representation of an empty transformer. More...
bool	transformer_is_rn_p (transformer)
	Check that transformer t is the canonical representation of the whole afine space defined by its basis. More...
transformer	transformer_add_sign_information (transformer, entity, int)
	CHANGE THIS NAME: no loop index please, it's not directly linked to loops!!! More...
transformer	transformer_add_variable_incrementation (transformer, entity, Pvecteur)
	transformer transformer_add_loop_index(transformer t, entity i, Pvecteur incr): add the index incrementation expression incr for loop index i to transformer t. More...
transformer	transformer_add_variable_update (transformer, entity)
	Add an update of variable v into t. More...
transformer	transformer_add_value_update (transformer, entity)
	Add an update of variable v to t (a value cannot be updated) More...
transformer	transformer_add_variables_update (transformer, list)
transformer	transformer_constraint_add (transformer, Pvecteur, bool)
transformer	transformer_inequality_add (transformer, Pvecteur)
transformer	transformer_equality_add (transformer, Pvecteur)
transformer	transformer_equalities_add (transformer, Pcontrainte)
transformer	transformer_inequalities_add (transformer, Pcontrainte)
	Warning: More...
transformer	transformer_add_identity (transformer, entity)
transformer	transformer_add_equality (transformer, entity, entity)
	Add an equality between two values (two variables?) More...
transformer	transformer_add_equality_with_integer_constant (transformer, entity, long long int)
	Add an equality between a value and an integer constant: v==cst. More...
transformer	transformer_add_inequality (transformer, entity, entity, bool)
	Add the equality v1 <= v2 or v1 < v2. More...
transformer	transformer_add_inequality_with_integer_constraint (transformer, entity, long long int, bool)
	Add the inequality v <= cst or v >= cst. More...
transformer	transformer_add_inequality_with_affine_term (transformer, entity, entity, int, int, bool)
	Add the inequality v <= a x + cst or v >= a x + cst. More...
transformer	transformer_add_equality_with_affine_term (transformer, entity, entity, int, int)
	Add the equality v = a x + cst. More...
transformer	transformer_add_inequality_with_linear_term (transformer, entity, entity, int, bool)
	Add the inequality v <= a x or v >= a x. More...
transformer	transformer_add_3d_affine_constraint (transformer, int, entity, int, entity, int, entity, int, bool)
	Add the constraint a1 v1 + a2 v2 + a3 v3 + cst <= or == 0. More...
bool	transformer_argument_consistency_p (transformer)
bool	transformer_argument_weak_consistency_p (transformer)
bool	transformer_argument_general_consistency_p (transformer, bool)
bool	transformer_consistency_p (transformer)
	FI: I do not know if this procedure should always return or fail when an inconsistency is found. More...
bool	transformers_consistency_p (list)
bool	transformer_weak_consistency_p (transformer)
	Interprocedural transformers do not meet all conditions. More...
bool	transformer_general_consistency_p (transformer, bool)
bool	transformer_internal_consistency_p (transformer)
	Same as above but equivalenced variables should not appear in the argument list or in the predicate basis. More...
list	transformer_projectable_values (transformer)
bool	value_belongs_to_transformer_space (entity, transformer)
void	add_value_to_transformer_space (entity, transformer)
transformer	precondition_to_abstract_store (transformer)
	Get rid of all old values and arguments. More...
transformer	transformer_add_modified_variable (transformer, entity)
	FI: this function does not end up with a consistent transformer because the old value is not added to the basis of sc. More...
transformer	transformer_add_modified_variable_entity (transformer, entity)
	FI: like the previous function, but supposed to end up with a consistent transformer. More...
transformer	move_transformer (transformer, transformer)
	Move arguments and predicate of t2 into t1, free old arguments and predicate of t1, free what's left of t2. More...
bool	transformer_equations_constrain_variable_p (const transformer, const entity)
	Is value v used with a non-zero coefficient by the equations of transformer t? More...
bool	transformer_inequalities_constrain_variable_p (const transformer, const entity)
	Is value v used with a non-zero coefficient by the inequalities of transformer t? More...
transformer	transformer_convex_hull (transformer, transformer)
	convex_hull.c More...
transformer	transformer_halbwachs_fix_point (transformer)
transformer	transformer_equality_fix_point (transformer)
	Let A be the affine loop transfert function. More...
void	build_transfer_equations (Pcontrainte, Pcontrainte *, Pbase *)
bool	transfer_equation_p (Pvecteur)
	A transfer equation is an explicit equation giving one new value as a function of old values and a constant term. More...
entity	new_value_in_transfer_equation (Pvecteur)
bool	sub_basis_p (Pbase, Pbase)
	FI: should be moved in base.c. More...
void	equations_to_bases (Pcontrainte, Pbase *, Pbase *)
transformer	transformer_pattern_fix_point (transformer)
	This fixpoint function was developped to present a talk at FORMA. More...
Pvecteur	look_for_the_best_counter (Pcontrainte)
	Try to identify a loop counter among the equation egs. More...
Psysteme	sc_eliminate_constant_terms (Psysteme, Pvecteur)
	Eliminate all constant terms in sc using v. More...
Pcontrainte	constraints_eliminate_constant_terms (Pcontrainte, Pvecteur)
Psysteme	sc_keep_invariants_only (Psysteme)
	This function cannot be moved into the Linear library. More...
Pcontrainte	constraints_keep_invariants_only (Pcontrainte)
bool	invariant_vector_p (Pvecteur)
	A vector (in fact, a constraint) represents an invariant if it is a sum of delta for each variable. More...
Psysteme	sc_multiply_constant_terms (Psysteme, Variable, bool)
	Specific for the derivative fix point: each constant term in the constraints is multiplied by ik which is not in sc's basis, and ik is added to the basis is necessary. More...
transformer	transformer_derivative_fix_point (transformer)
	Computation of a transitive closure using constraints on the discrete derivative. More...
list	transformers_derivative_fix_point (list)
transformer	transformer_basic_fix_point (transformer)
	Computation of a fix point: drop all constraints, remember which variables are changed. More...
transformer	any_transformer_to_k_closure (transformer, transformer, transformer, transformer, transformer, int, bool)
	Derived from any_loop_to_k_transformer() More...
transformer	print_transformer (transformer)
	io.c More...
transformer	print_any_transformer (transformer)
	For debugging without problem from temporary values. More...
list	print_transformers (list)
transformer	fprint_transformer (FILE *, transformer, get_variable_name_t)
list	fprint_transformers (FILE *, list, get_variable_name_t)
char *	dump_value_name (entity)
	char * dump_value_name(e): used as functional argument because entity_name is a macro More...
void	dump_transformer (transformer)
transformer	simple_equality_to_transformer (entity, entity, bool)
	transformer.c More...
transformer	simple_unary_minus_to_transformer (entity, entity)
transformer	generic_equality_to_transformer (entity, entity, bool, bool)
transformer	simple_addition_to_transformer (entity, entity, entity, bool)
	e and e1 and e2 are assumed to be values. More...
transformer	relation_to_transformer (entity, entity, entity, bool)
	e and f are assumed to be values. More...
transformer	transformer_combine (volatile transformer, transformer)
	transformer transformer_combine(transformer t1, transformer t2): compute the composition of transformers t1 and t2 (t1 then t2) More...
list	transformers_combine (list, transformer)
	Combine each transformer of transformer list tl1 with t2. More...
list	one_to_one_transformers_combine (list, list)
	Combine each transformer of transformer list tl1 with the corresponding transformer in transformer list tl2. More...
transformer	transformer_safe_combine_with_warnings (transformer, transformer)
	Transformer tf1 and tf2 are supposed to be independent but they may interfere, for instance because subexpressions have non-standard conformant side effects. More...
transformer	transformer_intersection (transformer, transformer)
	tf is a new transformer that receives the constraints in t1 and t2. More...
transformer	transformer_image_intersection (transformer, transformer)
	allocate a new transformer based on transformer t1 and postcondition t2 More...
transformer	transformer_safe_intersection (transformer, transformer)
	Allocate a new transformer. More...
transformer	transformer_safe_image_intersection (transformer, transformer)
	Allocate a new transformer. More...
transformer	transformer_domain_intersection (transformer, transformer)
	Restrict the domain of the relation tf with pre. More...
transformer	transformer_safe_domain_intersection (transformer, transformer)
	If tf and pre are defined, update tf. More...
transformer	transformer_range (transformer)
	Return the range of relation tf in a newly allocated transformer. More...
transformer	transformer_safe_range (transformer)
list	transformers_range (list)
	Substitute each transformer in list tfl by its range. More...
transformer	transformer_to_domain (transformer)
	Return the domain of relation tf in a newly allocated transformer. More...
transformer	transformer_safe_domain (transformer)
transformer	transformer_range_intersection (transformer, transformer)
	Allocate a new transformer rtf that is tf with its range restricted by the range r. More...
transformer	transformer_intersect_range_with_domain (transformer)
	When tf is used repeatedly in a loop, the range is part of the domain from iteration 2 to the end. More...
transformer	transformer_normalize (transformer, int)
	Eliminate (some) rational or integer redundancy. More...
transformer	transformer_safe_normalize (transformer, int)
list	transformers_safe_normalize (list, int)
bool	transformer_with_temporary_values_p (transformer)
	Does transformer tf use temporary values? More...
transformer	transformer_temporary_value_projection (transformer)
transformer	safe_transformer_projection (transformer, list)
	t may be undefined, args may contain values unrelated to t More...
transformer	transformer_return_value_projection (entity, transformer)
	Project return values that are not linked to function f. More...
transformer	transformer_projection (transformer, list)
	values in args must be in t's base More...
transformer	transformer_arguments_projection (transformer)
	transformer transformer_projection(transformer t); projection of t along the hyperplane defined by values of variables in arguments; this generate a projection and not a cylinder based on the projection More...
Psysteme	no_elim (Psysteme)
transformer	transformer_projection_with_redundancy_elimination (transformer, list, Psysteme(*)(Psysteme))
	It is not clear if this function projects values or variables. More...
transformer	transformer_projection_without_check (transformer, list, Psysteme(*)(Psysteme))
	In some cases, you know the projection will result in a non-consistent transformer that will be fixed later. More...
transformer	transformer_projection_with_redundancy_elimination_and_check (volatile transformer, list, Psysteme(*)(Psysteme), bool)
transformer	transformer_apply (transformer, transformer)
	transformer transformer_apply(transformer tf, transformer pre): apply transformer tf on precondition pre to obtain postcondition post More...
list	transformer_apply_generic (list, transformer, bool)
	Generates a new list of postconditions, one for each transformer in tl, unless the postcondition is empty and keep_p is FALSE. More...
list	transformer_apply_map (list, transformer)
	Generates a new list of postconditions, one for each transformer in tl, unless the postcondition is empty. More...
list	transformers_apply (list, transformer)
	Same as previous one, but with a more normalized name. More...
list	transformers_apply_and_keep_all (list, transformer)
	Same as previous one, but with a more normalized name. More...
transformer	transformer_safe_apply (transformer, transformer)
list	transformers_safe_apply (list, transformer)
	returns a list of postconditions, one for each transformer in tl More...
transformer	transformer_inverse_apply (transformer, transformer)
	transformer transformer_inverse_apply(transformer tf, transformer post): apply transformer tf on precondition pre to obtain postcondition post More...
transformer	transformer_safe_inverse_apply (transformer, transformer)
transformer	transformer_filter (transformer, list)
	transformer transformer_filter(transformer t, cons * args): projection of t along the hyperplane defined by entities in args; this generate a projection and not a cylinder based on the projection; More...
transformer	transformer_variables_filter (transformer, list)
	Transformers are dealing with variables and/or variable values. More...
bool	transformer_affect_linear_p (transformer, Pvecteur)
	bool transformer_affect_linear_p(transformer tf, Pvecteur l): returns TRUE if there is a state s such that eval(l, s) != eval(l, tf(s)); returns false if l is invariant w.r.t. More...
bool	transformer_affect_transformer_p (transformer, transformer)
	Transformer tf1 affects transformer tf2 if values modified by tf1 appear in any constraint of tf2. More...
bool	transformer_safe_affect_transformer_p (transformer, transformer)
transformer	args_to_transformer (list)
	Generates a transformer abstracting a totally unknown modification of the values associated to variables in list le. More...
transformer	invariant_wrt_transformer (transformer, transformer)
	transformer invariant_wrt_transformer(transformer p, transformer tf): Assume that tf is a fix-point operator. More...
transformer	transformer_value_substitute (transformer, entity, entity)
	transformer transformer_value_substitute(transformer t, entity e1, entity e2): if e2 does not appear in t initially: replaces occurences of value e1 by value e2 in transformer t's arguments and relation fields; else error fi More...
bool	transformer_value_substitutable_p (transformer, entity, entity)
	If e1 does not appear in t, it is substitutable. More...
transformer	transformer_safe_value_substitute (transformer, entity, entity)
Pvecteur	simplify_float_constraint (Pvecteur, bool)
	If v is a not a float constraint, retun v. More...
Psysteme	simplify_float_constraint_system (Psysteme)
	Simplify float constraints and possibly detect. More...
bool	transformer_empty_p (transformer)
	If true is returned, the transformer certainly is empty. More...
bool	transformer_strongly_empty_p (transformer)
	If true is returned, the transformer certainly is empty. More...
bool	transformer_to_1D_lattice (entity, transformer, Value *, Value *)
	See if the equations in transformer "pre" constraint variable "v" by v = gcd x + c, where x is a free variable. More...
transformer	formal_and_actual_parameters_association (call, transformer)
	formal_and_actual_parameters_association(call c, transformer pre): Add equalities between actual and formal parameters binding by call c to pre pre := pre U {f = expr } i i for all i such that formal fi is an integer scalar variable and expression expr-i is affine More...
bool	same_dimension_p (entity, entity, list, size_t, transformer)
	This function returns true if the actual array and the dummy array have the same dimension number i, with respect to the current context (precondition + association) In case if the actual argument is an array element, we have to add the following condition: the i-th subscript of the array element is equal to its correspond lower bound. More...
list	transformer_to_potential_stub_translation (transformer, entity)
list	transformer_to_analyzed_array_locations (transformer)
list	transformer_to_analyzed_locations (transformer)
	The list of location entities that appear in the basis of the transformer predicate. More...
list	transformer_to_analyzed_arrays (transformer)
	The list of array entities that appear in the basis of the transformer predicate as array element locations. More...
list	transformer_to_local_values (transformer, list)
	Build a list of values appearing in tf that are linked to a variable in dl. More...
bool	hash_entity_to_values_undefined_p (void)
	value.c More...
void	reset_value_counters (void)
void	reset_temporary_value_counter (void)
int	number_of_temporary_values (void)
void	set_analyzed_types (void)
void	reset_analyzed_types (void)
bool	integer_analyzed_p (void)
bool	boolean_analyzed_p (void)
bool	string_analyzed_p (void)
bool	float_analyzed_p (void)
bool	complex_analyzed_p (void)
bool	pointer_analyzed_p (void)
bool	constant_path_analyzed_p (void)
bool	analyzed_basic_p (basic)
	The basic corresponds to one of the analyzed types. More...
bool	analyzed_type_p (type)
	The type t is one of the analyzed types. More...
bool	analyzed_struct_p (entity)
	Does struct s contain directly or indirectly a field that may be analyzable? More...
bool	analyzed_struct_type_p (type)
bool	analyzed_array_p (entity)
	Does array a contain directly or indirectly a field that may be analyzable? More...
bool	analyzed_array_type_p (type)
bool	analyzed_entity_p (entity)
bool	analyzable_scalar_entity_p (entity)
	The entity type is one of the analyzed types. More...
bool	analyzed_constant_p (entity)
	The constant may appear as a variable in the linear systems. More...
bool	analyzed_reference_p (reference)
	FI: Nelson explains the motivation for can_be_constant_path_p() but I do not understand them. More...
entity	make_local_temporary_value_entity (type)
entity	make_local_temporary_value_entity_with_basic (basic)
entity	make_local_temporary_integer_value_entity (void)
bool	local_old_value_entity_p (entity)
	Return true if an entity is a local old value (such as "o#0" for a global value "i#init"...). More...
bool	local_intermediate_value_entity_p (entity)
bool	local_temporary_value_entity_p (entity)
bool	global_new_value_p (entity)
	GLOBAL VALUES. More...
bool	global_old_value_p (entity)
	Return true if an entity is a global old value (such as "i#init"...). More...
bool	global_intermediate_value_p (entity)
entity	global_new_value_to_global_old_value (entity)
const char *	global_value_name_to_user_name (const char *)
	HASH TABLE USE. More...
const char *	external_value_name (entity)
const char *	pips_user_value_name (entity)
	This function is called many times when the constraints and the system of constraints are sorted using lexicographic information based on this particular value name. More...
entity	entity_to_new_value (entity)
entity	entity_to_old_value (entity)
entity	entity_to_intermediate_value (entity)
entity	reference_to_address_of_value (reference)
entity	type_to_sizeof_value (type)
bool	entity_has_values_p (entity)
	This function could be made more robust by checking the storage of e. More...
bool	new_value_entity_p (entity)
	the following three functions are directly or indirectly relative to the current module and its value hash tables. More...
bool	old_value_entity_p (entity)
bool	intermediate_value_entity_p (entity)
bool	address_of_value_entity_p (entity)
bool	sizeof_value_entity_p (entity)
bool	value_entity_p (entity)
void	print_value_mappings (void)
list	modified_variables_with_values (void)
	Return the list of all analyzed variables which are modified in the current module. More...
void	test_mapping_entry_consistency (void)
int	number_of_analyzed_values (void)
int	aproximate_number_of_analyzed_variables (void)
int	number_of_analyzed_variables (void)
	FI: looks more like the number of values used. More...
void	allocate_value_mappings (int, int, int)
bool	hash_value_to_name_undefined_p (void)
void	error_reset_value_mappings (void)
	To be called by error handler only. More...
void	free_value_mappings (void)
	Normal call to free the mappings. More...
void	error_free_value_mappings (void)
	To be called by an error handler. More...
entity	reference_to_address_entity (reference)
	The address is the address of a variable or of a reference such as &a[5], not a of a value. More...
void	add_address_of_value (reference, type)
void	add_sizeof_value (type)
	For a given architecture, sizeof(t) is a constant. More...
void	add_new_value (entity)
void	add_new_alias_value (entity, entity)
entity	external_entity_to_new_value (entity)
entity	external_entity_to_old_value (entity)
void	add_old_value (entity)
void	add_old_alias_value (entity, entity)
void	add_intermediate_value (entity)
void	add_intermediate_alias_value (entity, entity)
void	add_local_old_value (entity)
void	add_local_intermediate_value (entity)
void	remove_entity_values (entity, bool)
void	add_synonym_values (entity, entity, bool)
entity	value_to_variable (entity)
	Get the primitive variable associated to any value involved in a transformer. More...
entity	old_value_to_new_value (entity)
entity	new_value_to_old_value (entity)
entity	value_alias (entity)
	Static aliasing. More...
Pvecteur	vect_variables_to_values (Pvecteur)
	FI: not used, not debugged. More...
string	value_full_name (entity)
	for debugging purposes More...
const char *	readable_value_name (entity)
	For debugging purposes, we might have to print system with temporary values. More...
string	transformer_to_string (transformer)
	prettyprint.c More...
string	precondition_to_string (transformer)
string	arguments_to_string (string, list)
string	relation_to_string (string, Psysteme, char *(*)(entity))
const char *	generic_value_name (entity)
list	merge_transformer_lists (list, list)
	transformer_list.c More...
bool	check_transformer_list (list)
	What do we want to impose? More...
list	combine_transformer_lists (list, list)
	each transformer of tl1 must be combined with a transformer of tl2, including the identity transformer. More...
list	apply_transformer_lists_generic (list, list, bool)
	each transformer of tl1 must be applied to each precondition of tl2, including the identity transformer. More...
list	apply_transformer_lists (list, list)
list	apply_transformer_lists_with_exclusion (list, list)
list	clean_up_transformer_list (list)
	Eliminate empty transformers and keep at most one identity transformer, placed as first list element. More...
list	two_transformers_to_list (transformer, transformer)
	Transformer two transformers into a correct transformer list. More...
transformer	generic_transformer_list_to_transformer (list, bool)
	Reduce the transformer list with the convex hull operator. More...
transformer	transformer_list_to_transformer (list)
	Reduce the transformer list ltl to one transformer using the convex hull operator. More...
transformer	active_transformer_list_to_transformer (list)
	Reduce the sublist of active transformers in the transformer list ltl to one transformer using the convex hull operator. More...
list	transformer_list_to_active_transformer_list (list)
transformer	transformer_list_closure_to_precondition (list, transformer, transformer)
	Relay to select a heuristic. More...
list	transformer_list_safe_variables_projection (list, list)
	Returns a new list of newly allocated projected transformers. More...
list	transformer_list_to_argument (list)
	Returns the list of variables modified by at least one transformer in tl. More...
list	transformer_list_with_effect (list, entity)
	build a sublist sl of the transformer list tl with transformers that modify the value of variable v More...
list	transformer_list_preserved_variables (list, list, list)
	returns the list of variables in vl which are not modified by transformers belonging to tl-tl_v. More...
transformer	transformer_list_multiple_closure_to_precondition (list, transformer, transformer)
	When some variables are not modified by some transformers, use projections on subsets to increase the number of identity transformers and to increase the accuracy of the loop precondition. More...
Psysteme	transformer_derivative_constraints (transformer)
	Allocate a new constraint system sc(dx) with dx=x'-x and t(x,x') More...
transformer	transformer_list_generic_transitive_closure (list, bool)
	Computation of an upper approximation of a transitive closure using constraints on the discrete derivative for a list of transformers. More...
transformer	transformer_list_transitive_closure (list)
	Compute (U tfl)*. More...
transformer	transformer_list_transitive_closure_plus (list)
	Compute (U tfl)+. More...

Variables
transformer(*	transformer_fix_point_operator )(transformer)
	fix_point.c More...

Macro Definition Documentation

ADDRESS_OF_SUFFIX

#define ADDRESS_OF_SUFFIX   "#addressof"

Definition at line 56 of file transformer.h.

INTERMEDIATE_VALUE_PREFIX

#define INTERMEDIATE_VALUE_PREFIX   "i#"

Definition at line 46 of file transformer.h.

INTERMEDIATE_VALUE_SUFFIX

#define INTERMEDIATE_VALUE_SUFFIX   "#int"

Definition at line 54 of file transformer.h.

NEW_VALUE_SUFFIX

#define NEW_VALUE_SUFFIX   "#new"

external suffixes (NEW_VALUE_SUFFIX is not used, new values are represented by the variable itself, i.e.

new value suffix is the empty string "")

Definition at line 52 of file transformer.h.

OLD_VALUE_PREFIX

#define OLD_VALUE_PREFIX   "o#"

internal entity names (FI: I should have used suffixes to be consistent with external suffixes

Definition at line 45 of file transformer.h.

OLD_VALUE_SUFFIX

#define OLD_VALUE_SUFFIX   "#init"

Definition at line 53 of file transformer.h.

SEMANTICS_MODULE_NAME

#define SEMANTICS_MODULE_NAME   "*SEMANTICS*"

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/transformer/transformer-local.h instead, to add your own modifications. header file built by cproto transformer-local.h include file for transformer library prefix used for value entity names; no conflict should occur with user function names as long as they are restricted to 6 characters

Definition at line 38 of file transformer.h.

SEMANTICS_SEPARATOR

#define SEMANTICS_SEPARATOR   '#'

Must be used in suffixes and prefixes below.

Definition at line 41 of file transformer.h.

SIZEOF_SUFFIX

#define SIZEOF_SUFFIX   "#sizeof"

Definition at line 58 of file transformer.h.

TEMPORARY_VALUE_PREFIX

#define TEMPORARY_VALUE_PREFIX   "t#"

Definition at line 47 of file transformer.h.

Function Documentation

active_transformer_list_to_transformer()

transformer active_transformer_list_to_transformer

(

list

ltl

)

Reduce the sublist of active transformers in the transformer list ltl to one transformer using the convex hull operator.

An active transformer is a transformer with argument(s): at least one value is changed.

Note: a hidden identity transformer such as T(i) {i==i::init} is not detected.

Parameters

ltl

tl

Definition at line 447 of file transformer_list.c.

{
  return generic_transformer_list_to_transformer(ltl, true);
}

References generic_transformer_list_to_transformer().

Referenced by transformer_list_closure_to_precondition_depth_two(), transformer_list_closure_to_precondition_max_depth(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

add_address_of_value()

void add_address_of_value	(	reference	r,
		type	t
	)

add the couple (e, address_of_value)

add its name

Definition at line 1309 of file value.c.

{
  pips_internal_error("Obsolete function.\n");
  entity e = reference_variable(r);
  entity address_of_value;
  string address_of_value_name;
  string indice = strstr(reference_to_string(r), "[");
 
  if (indice != NULL)
  address_of_value_name = concatenate(
      entity_name(e), indice, ADDRESS_OF_SUFFIX, (char *) NULL);
  else
    address_of_value_name = concatenate(
        entity_name(e), ADDRESS_OF_SUFFIX, (char *) NULL);
 
 
  //address_of_value = gen_find_entity(address_of_value_name);
  address_of_value = gen_find_tabulated(address_of_value_name, entity_domain);
  //if (entity_undefined_p(address_of_value))
  if(address_of_value == entity_undefined)
    address_of_value = make_entity(strdup(address_of_value_name),
                                  copy_type(t),
                                  make_storage(is_storage_rom, UU),
                                  value_undefined);
 
  /* add the couple (e, address_of_value) */
  if(hash_get(hash_reference_to_address_of_value, (char *) r) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_reference_to_address_of_value, (char *) r, (char *) address_of_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) address_of_value,
               strdup(entity_name(address_of_value)));
    // The next table be reset after the analysis, can't be reuse for the prettyprint, so useless to add in the table?
    entity v = value_to_variable(address_of_value);
    hash_put(hash_entity_to_user_value_name, (char *) address_of_value,
               strdup(concatenate("&", entity_user_name(v), indice, (char *) NULL)));
  }
}

References ADDRESS_OF_SUFFIX, concatenate(), copy_type(), entity_domain, entity_name, entity_undefined, entity_user_name(), gen_find_tabulated(), hash_entity_to_user_value_name, hash_get(), hash_put(), hash_reference_to_address_of_value, HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), pips_internal_error, reference_to_string(), reference_variable, strdup(), UU, value_to_variable(), and value_undefined.

Here is the call graph for this function:

add_intermediate_alias_value()

void add_intermediate_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1495 of file value.c.

{
  entity v = entity_undefined;
 
  pips_assert("add_intermediate_alias_valued",
              (hash_get(hash_entity_to_intermediate_value, (char *) e)
               == HASH_UNDEFINED_VALUE));
 
  v = entity_to_intermediate_value(a);
 
  hash_put(hash_entity_to_intermediate_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_to_intermediate_value(), entity_undefined, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_intermediate_value()

void add_intermediate_value

(

entity

e

)

get a new intermediate value, if necessary

add its (external) name

Definition at line 1476 of file value.c.

{
  entity intermediate_value;
 
  /* get a new intermediate value, if necessary */
  if((intermediate_value =
      (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    intermediate_value = make_local_intermediate_value_entity(entity_type(e));
    hash_put(hash_entity_to_intermediate_value, (char *) e,
             (char *) intermediate_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) intermediate_value,
             strdup(concatenate(entity_name(e),
                                INTERMEDIATE_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, INTERMEDIATE_VALUE_SUFFIX, make_local_intermediate_value_entity(), and strdup().

Referenced by add_interprocedural_value_entities(), add_or_kill_equivalenced_variables(), convex_in_effect_loop_range_fix(), and interlaced_basic_workchunk_regions_p().

Here is the call graph for this function:

Here is the caller graph for this function:

add_local_intermediate_value()

void add_local_intermediate_value

(

entity

e

)

get a new intermediate value, if necessary

add its (external) name

Definition at line 1526 of file value.c.

{
  entity intermediate_value;
 
  /* get a new intermediate value, if necessary */
  if((intermediate_value =
      (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    intermediate_value = make_local_intermediate_value_entity(entity_type(e));
    hash_put(hash_entity_to_intermediate_value, (char *) e,
             (char *) intermediate_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) intermediate_value,
             strdup(concatenate(entity_name(e),
                                INTERMEDIATE_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, INTERMEDIATE_VALUE_SUFFIX, make_local_intermediate_value_entity(), and strdup().

Referenced by add_intraprocedural_value_entities_unconditionally().

Here is the call graph for this function:

Here is the caller graph for this function:

add_local_old_value()

void add_local_old_value

(

entity

e

)

get a new old value, if necessary

add its (external) name

Definition at line 1509 of file value.c.

{
  entity old_value;
 
  /* get a new old value, if necessary */
  if((old_value =
      (entity) hash_get(hash_entity_to_old_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    old_value = make_local_old_value_entity(entity_type(e));
    hash_put(hash_entity_to_old_value, (char *) e, (char *) old_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) old_value,
             strdup(concatenate(entity_name(e), OLD_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, make_local_old_value_entity(), OLD_VALUE_SUFFIX, and strdup().

Referenced by add_intraprocedural_value_entities_unconditionally().

Here is the call graph for this function:

Here is the caller graph for this function:

add_new_alias_value()

void add_new_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1396 of file value.c.

{
  entity v = entity_undefined;
  pips_debug(8, "begin: for %s and %s\n",
        entity_name(e),entity_name(a));
  pips_assert("hash_entity_to_new_value is defined",
              (hash_get(hash_entity_to_new_value, (char *) e)
               == HASH_UNDEFINED_VALUE));
 
  v = entity_to_new_value(a);
 
  hash_put(hash_entity_to_new_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_name, entity_to_new_value(), entity_undefined, hash_entity_to_new_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, pips_assert, and pips_debug.

Referenced by add_interprocedural_new_value_entity(), and add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_new_value()

void add_new_value

(

entity

e

)

Definition at line 1386 of file value.c.

{
  pips_debug(8,"begin: for %s\n", entity_name(e));
  if(hash_get(hash_entity_to_new_value, (char *) e)
     == HASH_UNDEFINED_VALUE) {
    hash_put(hash_entity_to_new_value, (char *) e, (char *) e);
    add_new_value_name(e);
  }
}

References add_new_value_name(), entity_name, hash_entity_to_new_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_debug.

Referenced by add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), add_intraprocedural_value_entities_unconditionally(), and add_or_kill_equivalenced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

add_old_alias_value()

void add_old_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1463 of file value.c.

{
  entity v = entity_undefined;
 
  pips_assert("add_old_alias_valued", (hash_get(hash_entity_to_old_value, (char *) e)
                                       == HASH_UNDEFINED_VALUE));
 
  v = entity_to_old_value(a);
 
  hash_put(hash_entity_to_old_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_to_old_value(), entity_undefined, hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_old_value()

void add_old_value

(

entity

e

)

find the old value entity if possible, else, generate it

add the couple (e, old_value)

add its name

Definition at line 1440 of file value.c.

{
  entity old_value;
  string old_value_name;
 
  /* find the old value entity if possible, else, generate it */
  old_value_name = concatenate(entity_name(e),OLD_VALUE_SUFFIX,
                               (char *) NULL);
  old_value = gen_find_tabulated(old_value_name, entity_domain);
  if(old_value == entity_undefined)
    old_value = make_entity(strdup(old_value_name),
                            copy_type(entity_type(e)),
                            make_storage(is_storage_rom, UU),
                            value_undefined);
  /* add the couple (e, old_value) */
  if(hash_get(hash_entity_to_old_value, (char *) e) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_entity_to_old_value, (char *) e, (char *) old_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) old_value,
             strdup(entity_name(old_value)));
  }
}

References concatenate(), copy_type(), entity_domain, entity_name, entity_type, entity_undefined, gen_find_tabulated(), hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), OLD_VALUE_SUFFIX, strdup(), UU, and value_undefined.

Referenced by add_interprocedural_value_entities(), add_or_kill_equivalenced_variables(), and add_synonym_values().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sizeof_value()

void add_sizeof_value

(

type

t

)

For a given architecture, sizeof(t) is a constant.

It has no old value, no new value, it is a value.

Constants are encoded as 0-ary functions, not as values.

find the sizeof entity if possible, else, generate it

add the couple (e, old_value)

add its name

Definition at line 1352 of file value.c.

{
  entity sizeof_value;
  string sizeof_value_name;
 
  // improvement create the entity with the name of type
  // issue because of value_to_variable
  /* find the sizeof entity if possible, else, generate it */
  sizeof_value_name =
      concatenate(
          TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING,
          type_to_full_string_definition(t), SIZEOF_SUFFIX, (char *) NULL);
  sizeof_value = gen_find_tabulated(sizeof_value_name, entity_domain);
  if(sizeof_value == entity_undefined)
    sizeof_value =
        make_entity(strdup(sizeof_value_name),
            //make_type(is_type_variable,
            //    make_variable(make_basic(is_basic_int, (void*)sizeof(int)),NIL,NIL)),
            copy_type(t),
            make_storage(is_storage_rom, UU),
            value_undefined);
  /* add the couple (e, old_value) */
  if(hash_get(hash_type_to_sizeof_value, (char *) t) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_type_to_sizeof_value, (char *) t, (char *) sizeof_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) sizeof_value,
        strdup(entity_name(sizeof_value)));
    hash_put(hash_entity_to_new_value, (char *) sizeof_value,
        (char *) sizeof_value);
    hash_put(hash_entity_to_user_value_name, (char *) sizeof_value,
        concatenate("sizeof(", type_to_full_string_definition(t), ")", (char *) NULL));
  }
}

References concatenate(), copy_type(), entity_domain, entity_name, entity_undefined, gen_find_tabulated(), hash_entity_to_new_value, hash_entity_to_user_value_name, hash_get(), hash_put(), hash_type_to_sizeof_value, HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), MODULE_SEP_STRING, SIZEOF_SUFFIX, strdup(), TOP_LEVEL_MODULE_NAME, type_to_full_string_definition(), UU, and value_undefined.

Referenced by expression_multiply_sizeof_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

add_synonym_values()

void add_synonym_values	(	entity	e,
		entity	eq,
		bool	readonly
	)

e and eq are entities whose values are always equal because they share the exact same memory location (i.e. they are alias). Values for e have already been declared. Values for eq have to be declared.

hash_put(hash_value_to_name, (char *) old_value_eq, entity_name(old_value_eq));

The name does not change. It is not used until the equivalence equations are added

Parameters

eq	q
readonly	eadonly

Definition at line 1578 of file value.c.

{
  /* e and eq are entities whose values are always equal because they
   * share the exact same memory location (i.e. they are alias). Values
   * for e have already been declared. Values for eq have to be
   * declared. */
  entity new_value = entity_to_new_value(e);
  entity intermediate_value;
 
  pips_debug(8, "Begin for registered variable %s"
             " equivalenced with new variable %s"
             " with status %s\n",
             entity_local_name(e), entity_local_name(eq),
             readonly? "readonly" : "read/write");
 
  hash_put(hash_entity_to_new_value, (char *) eq,
           (char *) new_value);
  if(!readonly) {
    entity old_value = entity_to_old_value(e);
    intermediate_value = entity_to_intermediate_value(e);
    add_old_value(eq);
    hash_put(hash_entity_to_intermediate_value, (char *) eq,
             (char *) intermediate_value);
    hash_update(hash_entity_to_old_value, (char *) eq, 
                (char *) old_value);
    /* hash_put(hash_value_to_name, (char *) old_value_eq, entity_name(old_value_eq)); */
  }
  /* The name does not change. It is not used until the equivalence
     equations are added */
  hash_put(hash_value_to_name, (char *) eq,
           strdup(concatenate(entity_name(eq),
                              NEW_VALUE_SUFFIX, (char *) NULL)));
 
  pips_debug(8, "End\n");
}

References add_old_value(), concatenate(), entity_local_name(), entity_name, entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), eq, hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_put(), hash_update(), hash_value_to_name, NEW_VALUE_SUFFIX, pips_debug, and strdup().

Referenced by add_equivalenced_values().

Here is the call graph for this function:

Here is the caller graph for this function:

add_value_to_transformer_space()

void add_value_to_transformer_space	(	entity	v,
		transformer	tf
	)

Parameters

tf

f

Definition at line 859 of file basic.c.

{
  Psysteme sc = predicate_system(transformer_relation(tf));
  sc_base_add_variable(sc, (Variable) v);
  return;
}

References predicate_system, sc_base_add_variable(), and transformer_relation.

Referenced by transformer_add_variable_type_information().

Here is the call graph for this function:

Here is the caller graph for this function:

address_of_value_entity_p()

bool address_of_value_entity_p

(

entity

e

)

Definition at line 962 of file value.c.

{
  string s = strstr(entity_local_name(e), ADDRESS_OF_SUFFIX);
 
  return s!=NULL;
}

References ADDRESS_OF_SUFFIX, and entity_local_name().

Referenced by pips_user_value_name(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_value_mappings()

void allocate_value_mappings	(	int	n,
		int	o,
		int	i
	)

hash_warn_on_redefinition();

Definition at line 1165 of file value.c.

{
  pips_assert("undefined mappings for allocation",
              hash_table_undefined_p(hash_entity_to_new_value) &&
              hash_table_undefined_p(hash_entity_to_old_value) &&
              hash_table_undefined_p(hash_entity_to_intermediate_value) &&
              hash_table_undefined_p(hash_reference_to_address_of_value) &&
              hash_table_undefined_p(hash_type_to_sizeof_value) &&
              hash_table_undefined_p(hash_value_to_name));
 
  /* hash_warn_on_redefinition(); */
  hash_entity_to_new_value = hash_table_make(hash_pointer, n);
  hash_entity_to_old_value = hash_table_make(hash_pointer, o);
  hash_entity_to_intermediate_value =
    hash_table_make(hash_pointer, i);
  hash_value_to_name =
    hash_table_make(hash_pointer, n + o + i + n); // The last +n for the pointer
  hash_entity_to_user_value_name =
    hash_table_make(hash_pointer, n + o + i + n); // The last +n for the pointer
  hash_reference_to_address_of_value = hash_table_make(hash_pointer, n);
  hash_type_to_sizeof_value = hash_table_make(hash_pointer, n);
}

References hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_entity_to_user_value_name, hash_pointer, hash_reference_to_address_of_value, hash_table_make(), hash_table_undefined_p, hash_type_to_sizeof_value, hash_value_to_name, and pips_assert.

Referenced by allocate_module_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzable_scalar_entity_p()

bool analyzable_scalar_entity_p

(

entity

e

)

The entity type is one of the analyzed types.

Definition at line 471 of file value.c.

{
  bool result = false;
 
  if(!abstract_state_variable_p(e) // for packages such as IO or RAND
     && !typedef_entity_p(e)
     && !entity_typed_anywhere_locations_p(e)
     && !entity_heap_location_p(e)
     && !place_holder_variable_p(e)) { // Because enum are analyzed
    type bct = entity_basic_concrete_type(e);
    result = analyzed_type_p(bct);
  }
  return result;
}

References abstract_state_variable_p(), analyzed_type_p(), entity_basic_concrete_type(), entity_heap_location_p(), entity_typed_anywhere_locations_p(), place_holder_variable_p(), and typedef_entity_p().

Referenced by add_implicit_interprocedural_write_effects(), add_or_kill_equivalenced_variables(), any_user_call_site_to_transformer(), c_return_to_transformer(), external_entity_to_new_value(), generic_reference_to_transformer(), module_to_formal_analyzable_parameters(), module_to_value_mappings(), precondition_intra_to_inter(), and same_analyzable_type_scalar_entity_list_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_array_p()

bool analyzed_array_p

(

entity

a

)

Does array a contain directly or indirectly a field that may be analyzable?

Definition at line 434 of file value.c.

{
  bool analyzed_p = false;
  type at = entity_basic_concrete_type(a);
  type et = array_type_to_element_type(at);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  return analyzed_p;
}

References analyzed_struct_type_p(), analyzed_type_p(), array_type_to_element_type(), entity_basic_concrete_type(), and struct_type_p().

Here is the call graph for this function:

analyzed_array_type_p()

bool analyzed_array_type_p

(

type

at

)

Parameters

at

t

Definition at line 446 of file value.c.

{
  bool analyzed_p = false;
  type et = array_type_to_element_type(at);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  return analyzed_p;
}

References analyzed_struct_type_p(), analyzed_type_p(), array_type_to_element_type(), and struct_type_p().

Referenced by analyzed_entity_p(), and analyzed_struct_type_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_basic_p()

bool analyzed_basic_p

(

basic

b

)

The basic corresponds to one of the analyzed types.

Definition at line 337 of file value.c.

{
  bool analyzed_p = false;
 
  if(analyze_integer_scalar_entities && basic_int_p(b))
    analyzed_p = true;
  else if(analyze_string_scalar_entities && basic_string_p(b))
    analyzed_p = true;
  else if(analyze_boolean_scalar_entities && basic_logical_p(b))
    analyzed_p = true;
  else if(analyze_float_scalar_entities && basic_float_p(b))
    analyzed_p = true;
  else if(analyze_pointer_scalar_entities && basic_pointer_p(b)) {
    pips_debug(9,"pointer type : %s\n", type_to_string(basic_pointer(b)));
    analyzed_p = true;
  }
  else if(analyze_complex_scalar_entities && basic_complex_p(b))
    analyzed_p = true;
  else if(analyze_integer_scalar_entities && basic_derived_p(b)) {
    entity de = basic_derived(b);
    type dt = entity_basic_concrete_type(de);
    analyzed_p = type_enum_p(dt);
  }
  else
    analyzed_p = false;
 
  return analyzed_p;
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_pointer, basic_pointer_p, basic_string_p, entity_basic_concrete_type(), pips_debug, type_enum_p, and type_to_string().

Referenced by analyzed_type_p(), and condition_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_constant_p()

bool analyzed_constant_p

(

entity

f

)

The constant may appear as a variable in the linear systems.

is f a 0-ary function, i.e. a constant of proper type?

integer and logical constants are handled explicitly

Definition at line 487 of file value.c.

{
  /* is f a 0-ary function, i.e. a constant of proper type? */
  if(entity_constant_p(f)) {
    basic b = variable_basic(type_variable
      (functional_result(type_functional(entity_type(f)))));
 
    /* integer and logical constants are handled explicitly */
 
    if(basic_string_p(b) && analyze_string_scalar_entities)
      return true;
    if(basic_float_p(b) && analyze_float_scalar_entities)
      return true;
    if(basic_complex_p(b) && analyze_complex_scalar_entities)
      return true;
    if(basic_pointer_p(b) && analyze_pointer_scalar_entities)
      return true;
  }
  return false;
}

References analyze_complex_scalar_entities, analyze_float_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, basic_complex_p, basic_float_p, basic_pointer_p, basic_string_p, entity_constant_p, entity_type, f(), functional_result, type_functional, type_variable, and variable_basic.

Referenced by value_mappings_compatible_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_entity_p()

bool analyzed_entity_p

(

entity

e

)

Definition at line 457 of file value.c.

{
  bool analyzed_p = false;
  type et = entity_basic_concrete_type(e);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  else if(array_type_p(et))
    analyzed_p = analyzed_array_type_p(et);
  return analyzed_p;
}

References analyzed_array_type_p(), analyzed_struct_type_p(), analyzed_type_p(), array_type_p(), entity_basic_concrete_type(), and struct_type_p().

Referenced by generic_substitute_formal_array_elements_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_reference_p()

bool analyzed_reference_p

(

reference

r

)

FI: Nelson explains the motivation for can_be_constant_path_p() but I do not understand them.

He also explains the motivation for strict_constant_path_p() and I do not understand them either.

Stricly speaking, this funtion should be called analyzed_points_to_reference_p()

Definition at line 518 of file value.c.

{
  pips_debug(7, "analyzed_reference_p, ref : %s\n", reference_to_string(r));
  bool result = false;
  entity v = reference_variable(r);
 
  if (store_independent_points_to_reference_p(r)
      //&& atomic_points_to_reference_p(r)) {
      && generic_atomic_points_to_reference_p(r, false)
      && !effects_package_entity_p(v)) {
    type t = points_to_reference_to_concrete_type(r);
    result = analyzed_type_p(t);
  }
  else {
    // e.g. a[i]
    result = false;
  }
 
  pips_debug(7, "analyzed_reference_p result : %i\n", result);
  return result;
}

References analyzed_type_p(), effects_package_entity_p(), generic_atomic_points_to_reference_p(), pips_debug, points_to_reference_to_concrete_type(), reference_to_string(), reference_variable, and store_independent_points_to_reference_p().

Referenced by any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), assign_rhs_to_reflhs_to_transformer(), generic_apply_effect_to_transformer(), lhs_expression_to_transformer(), module_to_value_mappings(), points_to_unary_operation_to_transformer(), and substitute_stubs_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_struct_p()

bool analyzed_struct_p

(

entity

s

)

Does struct s contain directly or indirectly a field that may be analyzable?

Definition at line 387 of file value.c.

{
  bool analyzed_p = false;
  list fl = struct_variable_to_fields(s);
  FOREACH(ENTITY, f, fl) {
    type ft = entity_basic_concrete_type(f);
    if(analyzed_type_p(ft)) {
      analyzed_p = true;
      break;
    }
    else if(struct_type_p(ft)) {
      analyzed_p = analyzed_struct_p(f);
      if(analyzed_p)
        break;
    }
  }
  return analyzed_p;
}

References analyzed_struct_p(), analyzed_type_p(), ENTITY, entity_basic_concrete_type(), f(), FOREACH, struct_type_p(), and struct_variable_to_fields().

Referenced by analyzed_struct_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_struct_type_p()

bool analyzed_struct_type_p

(

type

st

)

Parameters

st

t

Definition at line 406 of file value.c.

{
  bool analyzed_p = false;
  list fl = struct_type_to_fields(st);
  FOREACH(ENTITY, f, fl) {
    // FI: might be shorter an safer to call entity_analyzed_p(f)
    type ft = entity_basic_concrete_type(f);
    if(analyzed_type_p(ft)) {
      analyzed_p = true;
      break;
    }
    else if(struct_type_p(ft)) {
      analyzed_p = analyzed_struct_type_p(ft);
      if(analyzed_p)
        break;
    }
    else if(array_type_p(ft)) {
      analyzed_p = analyzed_array_type_p(ft);
      if(analyzed_p)
        break;
    }
  }
  return analyzed_p;
}

References analyzed_array_type_p(), analyzed_struct_type_p(), analyzed_type_p(), array_type_p(), ENTITY, entity_basic_concrete_type(), f(), FOREACH, struct_type_p(), and struct_type_to_fields().

Referenced by analyzed_array_p(), analyzed_array_type_p(), analyzed_entity_p(), and analyzed_struct_type_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_type_p()

bool analyzed_type_p

(

type

t

)

The type t is one of the analyzed types.

Definition at line 367 of file value.c.

{
  bool result = false;
  type bct = compute_basic_concrete_type(t);
 
  if(type_variable_p(bct)) {
    variable v = type_variable(bct);
    if (!volatile_variable_p(v)
        && ENDP(variable_dimensions(v))           //NL : for checking the dimension instead of entity_scalar_p which filter pointer type
    ) {
      result = analyzed_basic_p(variable_basic(v));
    }
  }
 
  return result;
}

References analyzed_basic_p(), compute_basic_concrete_type(), ENDP, type_variable, type_variable_p, variable_basic, variable_dimensions, and volatile_variable_p().

Referenced by add_inter_or_intraprocedural_field_entities(), analyzable_scalar_entity_p(), analyzed_array_p(), analyzed_array_type_p(), analyzed_entity_p(), analyzed_reference_p(), analyzed_struct_p(), analyzed_struct_type_p(), assign_rhs_to_reflhs_to_transformer(), call_to_transformer(), create_values_for_simple_effect(), expression_to_transformer(), generic_reference_to_transformer(), generic_substitute_formal_array_elements_in_transformer(), make_local_temporary_value_entity(), module_to_value_mappings(), perform_array_element_substitutions_in_transformer(), semantics_usable_points_to_reference_p(), substitute_struct_stub_in_transformer(), and transformer_apply_field_assignments_or_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

any_transformer_to_k_closure()

transformer any_transformer_to_k_closure	(	transformer	t_init,
		transformer	t_enter,
		transformer	t_next,
		transformer	t_body,
		transformer	post_init,
		int	k,
		bool	assume_previous_iteration_p
	)

Derived from any_loop_to_k_transformer()

The recursive computation of the loop transformer is not performed here.

Complete the body transformer with t_next (t_body is modified by side effects into t_fbody)

Compute the fix point

Compute t_body_star = t_init ; t_enter

and add the continuation condition, pre_iteration improved with knowledge about the body, npre_iteration. Note that pre_iteration would also provide correct results, although less accurate.

FI: this is a very strong normalization

obvious redundancy like 0<=x, x<=y, 0<=y is detected

Integer redundancy elimination is aso used and leads potentially to larger coefficients and ultimately to an accuracy reduction when a convex hull is performed.

Any transformer or other data structure to free?

Parameters

t_init	_init
t_enter	_enter
t_next	_next
t_body	_body
post_init	ost_init
assume_previous_iteration_p	ssume_previous_iteration_p

Definition at line 1304 of file fix_point.c.

{
  transformer t_fbody = transformer_undefined; // t_body; t_next
  transformer t_fbody_star = transformer_undefined; // t_fbody*
  transformer t_body_star = transformer_undefined; // t_init ; t_enter ; tfbodystar
  transformer post_enter = transformer_apply(t_enter, post_init);
  transformer enter_condition = transformer_range(post_enter);
  transformer next_condition = transformer_range(t_next);
  transformer post_next = transformer_undefined;
  //transformer pre_iteration = transformer_convex_hull(enter_condition, next_condition);
  transformer npre_iteration = transformer_undefined;
  transformer post_loop_star = transformer_undefined;
  transformer post_loop_plus = transformer_undefined;
  transformer post_loop = transformer_undefined;
  transformer t_next_star = transformer_undefined;
  transformer t_fbody_k = transformer_undefined;
  int ck; // used to unroll k-1 times the loop body
 
  ifdebug(8) {
    fprintf(stderr, "t_init:\n");
    print_transformer(t_init);
    fprintf(stderr, "t_enter:\n");
    print_transformer(t_enter);
    fprintf(stderr, "t_next:\n");
    print_transformer(t_next);
    fprintf(stderr, "t_body:\n");
    print_transformer(t_body);
    fprintf(stderr, "post_init:\n");
    print_transformer(post_init);
  }
 
  if(assume_previous_iteration_p)
    t_body = transformer_intersect_range_with_domain(t_body);
 
  /* Complete the body transformer with t_next (t_body is modified by
     side effects into t_fbody) */
  t_fbody = transformer_combine(t_body, t_next);
 
  /* Compute the fix point */
  t_fbody_k = copy_transformer(t_fbody);
  for(ck=2; ck<=k; ck++)
    t_fbody_k = transformer_combine(t_fbody_k, t_fbody);
  t_fbody_star = (* transformer_fix_point_operator)(t_fbody_k);
  free_transformer(t_fbody_k);
 
  /* Compute t_body_star = t_init ; t_enter */
  t_body_star = transformer_combine(transformer_dup(t_init), t_enter);
  t_body_star = transformer_combine(t_body_star, t_fbody_star);
 
  /* and add the continuation condition, pre_iteration improved with
     knowledge about the body, npre_iteration. Note that pre_iteration
     would also provide correct results, although less accurate. */
  post_loop_star = transformer_apply(t_fbody_star, enter_condition);
  post_loop_plus = transformer_apply(t_fbody, post_loop_star);
  post_loop = transformer_range(post_loop_plus);
  npre_iteration = transformer_convex_hull(enter_condition, post_loop);
  if(k==2) { // Should be a loop over k
    transformer post_loop_plus_plus =  transformer_apply(t_fbody, post_loop_plus);
    transformer old_npre_iteration = npre_iteration;
    post_loop = transformer_range(post_loop_plus_plus);
    npre_iteration = transformer_convex_hull(npre_iteration, post_loop);
    free_transformer(post_loop_plus_plus);
    free_transformer(old_npre_iteration);
  }
  t_body_star = transformer_combine(t_body_star, npre_iteration);
  /* FI: this is a very strong normalization
   *
   * obvious redundancy like 0<=x, x<=y, 0<=y is detected
   *
   * Integer redundancy elimination is aso used and leads potentially
   * to larger coefficients and ultimately to an accuracy reduction
   * when a convex hull is performed.
   */
  // FI: I remove it for the time being because it slows down PIPS a lot
  // according to measurements for NSAD2014, nested01-09.c
  // t_body_star = transformer_normalize(t_body_star, 0);
  // Not sufficient for the simple case in Semantics-New/do01
  // t_body_star = transformer_normalize(t_body_star, 2);
 
  /* Any transformer or other data structure to free? */
  //free_transformer(t_body); transformed into t_fbody
  free_transformer(t_fbody);
  free_transformer(t_fbody_star);
  free_transformer(post_next);
  //free_transformer(t_effects);
  free_transformer(post_enter);
  free_transformer(enter_condition);
  free_transformer(next_condition);
  free_transformer(npre_iteration);
  free_transformer(post_loop_star);
  free_transformer(post_loop_plus);
  free_transformer(post_loop);
  free_transformer(t_next_star);
 
  ifdebug(8) {
    fprintf(stderr, "t_body_star:\n");
    print_transformer(t_body_star);
  }
 
  return t_body_star;
}

References copy_transformer(), fprintf(), free_transformer(), ifdebug, print_transformer, transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_intersect_range_with_domain(), transformer_range(), and transformer_undefined.

Referenced by any_loop_to_k_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_transformer_lists()

list apply_transformer_lists	(	list	tl1,
		list	tl2
	)

Parameters

tl1	l1
tl2	l2

Definition at line 269 of file transformer_list.c.

{
  return apply_transformer_lists_generic(tl1, tl2, false);
}

References apply_transformer_lists_generic().

Here is the call graph for this function:

apply_transformer_lists_generic()

list apply_transformer_lists_generic	(	list	tl1,
		list	tl2,
		bool	exclude_p
	)

each transformer of tl1 must be applied to each precondition of tl2, including the identity transformer.

If an identity transformer is generated and if identity transformers are always first in the list, it will again be first in the returned list. Empty preconditions are not preserved in the returned list. An empty list is unfeasible.

if exclude_p==false, return U_i1 U_i2 apply(t_i1, p_i2); else return U_i1 U_i2!=i1 apply(t_i1, p_i2);

Parameters

tl1	l1
tl2	l2
exclude_p	xclude_p

Definition at line 223 of file transformer_list.c.

{
  list ntl = NIL;
  int n1 = gen_length(tl1);
  int n2 = gen_length(tl2);
  int en = 0; // number of empty preconditions generated
  int sn = 0; // number of excluded/skipped preconditions
  int nn = -1; // number of preconditions in the result
  int i1 = 0;
 
  // FI: not true is option keep_p has been used to maintain
  //|tl_1|==|tl_2| which is useful when exclude_p is TRUE
  if(!exclude_p) {
    pips_assert("tl1 is OK\n", check_transformer_list(tl1));
    pips_assert("tl2 is OK\n", check_transformer_list(tl2));
  }
 
  FOREACH(TRANSFORMER, t1, tl1) {
    int i2 = 0;
    i1++;
    FOREACH(TRANSFORMER, t2, tl2) {
      i2++;
      if(i1!=i2 && exclude_p) {
        transformer nt = transformer_apply(t1, t2);
 
        if(!transformer_empty_p(nt))
          ntl = CONS(TRANSFORMER, nt, ntl);
        else
          en++;
      }
      else if(exclude_p)
        sn++;
    }
  }
  ntl = gen_nreverse(ntl);
 
  nn = gen_length(ntl);
  pips_assert("nn is n1*n2-en", nn==n1*n2-en-sn);
  //FI: there is no guarantee here that the identity transformer is
  //not returned multiple times... although it would make sense if the
  //input lists are properly sorted.
  pips_assert("ntl is OK\n", check_transformer_list(ntl));
 
  return ntl;
}

References check_transformer_list(), CONS, FOREACH, gen_length(), gen_nreverse(), NIL, pips_assert, TRANSFORMER, transformer_apply(), and transformer_empty_p().

Referenced by apply_transformer_lists(), and apply_transformer_lists_with_exclusion().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_transformer_lists_with_exclusion()

list apply_transformer_lists_with_exclusion	(	list	tl1,
		list	tl2
	)

Parameters

tl1	l1
tl2	l2

Definition at line 274 of file transformer_list.c.

{
  return apply_transformer_lists_generic(tl1, tl2, true);
}

References apply_transformer_lists_generic().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

aproximate_number_of_analyzed_variables()

int aproximate_number_of_analyzed_variables

(

void

)

FI: I do not know if equivalenced variables are well taken into account

Definition at line 1153 of file value.c.

{
  /* FI: I do not know if equivalenced variables are well taken into account*/
  return hash_table_entry_count(hash_entity_to_new_value);
}

References hash_entity_to_new_value, and hash_table_entry_count().

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

args_to_transformer()

transformer args_to_transformer

(

list

le

)

Generates a transformer abstracting a totally unknown modification of the values associated to variables in list le.

list of entities

Parameters

le

e

Definition at line 1907 of file transformer.c.

{
    transformer tf = transformer_identity();
    cons * args = transformer_arguments(tf);
    Pbase b = VECTEUR_NUL;
    Psysteme s = sc_new();
 
    MAPL(ce, {
      entity e = ENTITY(CAR(ce));
      entity new_val = entity_to_new_value(e);
 
      args = arguments_add_entity(args, new_val);
      b = vect_add_variable(b, (Variable) new_val);
      }, le);
 
    transformer_arguments(tf) = args;
    s->base = b;
    s->dimension = vect_size(b);
    predicate_system_(transformer_relation(tf)) = s;
    return tf;
}

References arguments_add_entity(), Ssysteme::base, CAR, Ssysteme::dimension, ENTITY, entity_to_new_value(), MAPL, predicate_system_, sc_new(), transformer_arguments, transformer_identity(), transformer_relation, vect_add_variable(), vect_size(), and VECTEUR_NUL.

Referenced by add_loop_index_exit_value(), and invariant_wrt_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

arguments_to_string()

string arguments_to_string	(	string	s,
		list	args
	)

Parameters

args

rgs

Definition at line 65 of file prettyprint.c.

{
    pips_internal_error("not implemenented anymore, s=\"%s\", args=%p", s, args);
    return string_undefined;
}

References pips_internal_error, and string_undefined.

boolean_analyzed_p()

bool boolean_analyzed_p

(

void

)

Definition at line 305 of file value.c.

{
  return analyze_boolean_scalar_entities;
}

References analyze_boolean_scalar_entities.

Referenced by any_expression_to_transformer(), and fortran_data_to_prec_for_variables().

Here is the caller graph for this function:

build_transfer_equations()

void build_transfer_equations	(	Pcontrainte	leq,
		Pcontrainte *	plteq,
		Pbase *	pb_new
	)

FI: this is the simplest version; It would be possible to build a larger set of transfer equations by adding indirect transfer equations using a new basis till the set is stable, and then by removing equations containing old values which are not defined, again till the result is stable

I guess that these new equations would not change the fix-point and/or the preconditions.

derive the new basis and the old basis

check that the old basis is included in the new basis (else no fix-point!)

Remove equations as long b_old is not included in b_new

could be avoided by using only lteq...

Parameters

leq	eq
plteq	lteq
pb_new	b_new

Definition at line 433 of file fix_point.c.

{
    Pcontrainte lteq = CONTRAINTE_UNDEFINED;
    Pbase b_new = BASE_NULLE;
    Pbase b_old = BASE_NULLE;
    Pbase b_diff = BASE_NULLE;
    Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
    ifdebug(8) {
        pips_debug(8, "begin\ninput equations:\n");
        egalites_fprint(stderr, leq, (char * (*)(Variable)) external_value_name);
    }
 
    /* FI: this is the simplest version;
     * It would be possible to build a larger set of transfer equations
     * by adding indirect transfer equations using a new basis
     * till the set is stable, and then by removing equations containing
     * old values which are not defined, again till the result is stable
     *
     * I guess that these new equations would not change the fix-point
     * and/or the preconditions.
     */
    for(eq = leq; !CONTRAINTE_UNDEFINED_P(eq); eq = eq->succ) {
        if(transfer_equation_p(contrainte_vecteur(eq))) {
            Pcontrainte neq = contrainte_dup(eq);
 
            neq->succ = lteq;
            lteq = neq;
        }
    }
 
    ifdebug(8) {
      pips_debug(8, "preliminary transfer equations:\n");
      egalites_fprint(stderr, lteq,
                      (char * (*)(Variable)) external_value_name);
    }
 
    /* derive the new basis and the old basis */
    equations_to_bases(lteq, &b_new, &b_old);
 
    /* check that the old basis is included in the new basis (else no
       fix-point!) */
    ifdebug(8) {
        pips_debug(8, "old basis:\n");
        base_fprint(stderr, b_old, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "new basis:\n");
        base_fprint(stderr, b_new, (char * (*)(Variable)) external_value_name);
    }
 
    /* Remove equations as long b_old is not included in b_new */
    b_diff = base_difference(b_old, b_new);
    while(!BASE_NULLE_P(b_diff)) {
        Pcontrainte n_lteq = CONTRAINTE_UNDEFINED;
        Pcontrainte next_eq = CONTRAINTE_UNDEFINED;
 
        for(eq = lteq; !CONTRAINTE_UNDEFINED_P(eq); eq = next_eq) {
            bool preserve = true;
            Pvecteur t = VECTEUR_UNDEFINED;
            for(t = contrainte_vecteur(eq);
                !VECTEUR_UNDEFINED_P(t) && preserve;
                t = t->succ) {
                entity e = (entity) vecteur_var(t);
 
                preserve = base_contains_variable_p(b_diff, (Variable) e);
            }
            next_eq = eq->succ;
            if(preserve) {
                eq->succ = n_lteq;
                n_lteq = eq;
            }
            else {
                contrainte_rm(eq);
            }
        }
        lteq = n_lteq; /* could be avoided by using only lteq... */
        equations_to_bases(lteq, &b_new, &b_old);
        b_diff = base_difference(b_old, b_new);
    }
 
    ifdebug(8) {
        pips_debug(8, "final transfer equations:\n");
        egalites_fprint(stderr, lteq,
                        (char * (*)(Variable)) external_value_name);
        pips_debug(8, "old basis:\n");
        base_fprint(stderr, b_old, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "new basis:\n");
        base_fprint(stderr, b_new, (char * (*)(Variable)) external_value_name);
    }
 
    if(!sub_basis_p(b_old, b_new)) {
        pips_internal_error("Old basis is too large");
    }
    base_rm(b_old);
    b_old = BASE_UNDEFINED;
    *plteq = lteq;
    *pb_new = b_new;
 
    ifdebug(8) {
        pips_debug(8, "results\ntransfer equations:\n");
        egalites_fprint(stderr, lteq, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "results\ntransfer basis:\n");
        base_fprint(stderr, b_new, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "end\n");
    }
}

References base_contains_variable_p(), base_difference(), base_fprint(), BASE_NULLE, BASE_NULLE_P, base_rm, BASE_UNDEFINED, contrainte_dup(), contrainte_rm, CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, egalites_fprint(), eq, equations_to_bases(), external_value_name(), ifdebug, pips_debug, pips_internal_error, sub_basis_p(), Scontrainte::succ, Svecteur::succ, transfer_equation_p(), VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by transformer_equality_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

check_transformer_list()

bool check_transformer_list

(

list

tl

)

What do we want to impose?

1. Only one identity transformer
2. Common basis?
3. No empty transformer

The empty transformer list is used to represent the empty transformer...

It must be the first one

Parameters

tl

l

Definition at line 140 of file transformer_list.c.

{
  bool identity_p = false;
  // unused: bool one_p = false; // useless for the time being
 
  if(ENDP(tl)) {
    /* The empty transformer list is used to represent the empty
       transformer... */
    ;
  }
  else {
    FOREACH(TRANSFORMER, tf, tl) {
      if(transformer_identity_p(tf)) {
        if(identity_p) {
          pips_internal_error("Two identity transformers in one list.");
        }
        else {
          identity_p = true;
        }
      }
    }
    if(identity_p) {
      /* It must be the first one */
      if(!transformer_identity_p(TRANSFORMER(CAR(tl))))
        pips_internal_error("The identity transformer is not the list header.");
    }
 
    FOREACH(TRANSFORMER, tf, tl) {
      if(transformer_empty_p(tf))
        pips_internal_error("An empty transformer has been found.");
    }
  }
 
  return true;
}

References CAR, ENDP, FOREACH, pips_internal_error, TRANSFORMER, transformer_empty_p(), and transformer_identity_p().

Referenced by apply_transformer_lists_generic(), combine_transformer_lists(), and merge_transformer_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_up_transformer_list()

list clean_up_transformer_list

(

list

tfl

)

Eliminate empty transformers and keep at most one identity transformer, placed as first list element.

check_transformer_list(ntfl) should be TRUE.

tfl is fully destroyed (to avoid memory leaks and nightmares); to be more efficient, the transformers moved from the input list into the output list should be detached from the input list and then the input list could be fully destroyed without having to copy any transformers; but FOREACH operates at too high a level for this.

Parameters

tfl

fl

Definition at line 290 of file transformer_list.c.

{
  list ntfl = NIL;
  bool identity_p = false;
 
  FOREACH(TRANSFORMER, tf, tfl) {
    bool tf_identity_p = transformer_identity_p(tf);
    if(!tf_identity_p && !transformer_empty_p(tf))
      ntfl = CONS(TRANSFORMER, copy_transformer(tf), ntfl);
    identity_p = identity_p || tf_identity_p;
  }
  gen_full_free_list(tfl);
  ntfl = gen_nreverse(ntfl);
  if(identity_p)
    ntfl = CONS(TRANSFORMER, transformer_identity(), ntfl);
  return ntfl;
}

References CONS, copy_transformer(), FOREACH, gen_full_free_list(), gen_nreverse(), NIL, TRANSFORMER, transformer_empty_p(), transformer_identity(), and transformer_identity_p().

Referenced by block_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

combine_transformer_lists()

list combine_transformer_lists	(	list	tl1,
		list	tl2
	)

each transformer of tl1 must be combined with a transformer of tl2, including the identity transformer.

If an identity transformer is generated and if identity transformers are always first in the list, it will again be first in the returned list.

Parameters

tl1	l1
tl2	l2

Definition at line 180 of file transformer_list.c.

{
  list ntl = NIL;
  int n1 = gen_length(tl1);
  int n2 = gen_length(tl2);
  int en = 0;
  int nn = -1;
 
  pips_assert("tl1 is OK\n", check_transformer_list(tl1));
  pips_assert("tl2 is OK\n", check_transformer_list(tl2));
 
  FOREACH(TRANSFORMER, t1, tl1) {
    FOREACH(TRANSFORMER, t2, tl2) {
      transformer nt = transformer_combine(copy_transformer(t1), t2);
 
      // transformer_empty_p() is not strong enough currently
      // It does not detect that k<= 2 && k>=3 is empty...
      nt = transformer_normalize(nt, 2);
      if(!transformer_empty_p(nt))
        ntl = CONS(TRANSFORMER, nt, ntl);
      else
        en++;
    }
  }
  ntl = gen_nreverse(ntl);
 
  nn = gen_length(ntl);
  pips_assert("ntl is OK\n", check_transformer_list(ntl));
  pips_assert("nn is n1*n2-en", nn==n1*n2-en);
 
  return ntl;
}

References check_transformer_list(), CONS, copy_transformer(), FOREACH, gen_length(), gen_nreverse(), NIL, pips_assert, TRANSFORMER, transformer_combine(), transformer_empty_p(), and transformer_normalize().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

complex_analyzed_p()

bool complex_analyzed_p

(

void

)

Definition at line 320 of file value.c.

{
  return analyze_complex_scalar_entities;
}

References analyze_complex_scalar_entities.

constant_path_analyzed_p()

bool constant_path_analyzed_p

(

void

)

Definition at line 330 of file value.c.

{
  return analyze_constant_path;
}

References analyze_constant_path.

Referenced by any_assign_to_transformer(), assign_rhs_to_reflhs_to_transformer(), basic_update_reflhs_with_rhs_to_transformer(), generic_apply_effect_to_transformer(), integer_call_expression_to_transformer(), lhs_expression_to_transformer(), module_to_value_mappings(), process_call_for_summary_precondition(), and update_reflhs_with_rhs_to_transformer().

Here is the caller graph for this function:

constraints_eliminate_constant_terms()

Pcontrainte constraints_eliminate_constant_terms	(	Pcontrainte	lc,
		Pvecteur	v
	)

cv may now be the null vector

Parameters

lc

c

Definition at line 865 of file fix_point.c.

{
    Value c1 = vect_coeff(TCST, v);
    Pcontrainte cc = CONTRAINTE_UNDEFINED;
 
    if(c1==0) {
        abort();
    }
 
    for(cc = lc; !CONTRAINTE_UNDEFINED_P(cc); cc = contrainte_succ(cc)) {
        Pvecteur cv = contrainte_vecteur(cc);
        Value c2;
 
        if((c2 = vect_coeff(TCST, cv))!=0) {
            cv = vect_multiply(cv, c1);
            cv = vect_cl(cv, -c2, v);
        }
 
        /* cv may now be the null vector */
        contrainte_vecteur(cc) = cv;
    }
 
    return lc;
}

References abort, contrainte_succ, CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, TCST, vect_cl(), vect_coeff(), and vect_multiply().

Referenced by sc_eliminate_constant_terms().

Here is the call graph for this function:

Here is the caller graph for this function:

constraints_keep_invariants_only()

Pcontrainte constraints_keep_invariants_only

(

Pcontrainte

lc

)

Parameters

lc

c

Definition at line 910 of file fix_point.c.

{
    Pcontrainte cc;
 
    for(cc = lc; !CONTRAINTE_UNDEFINED_P(cc); cc = contrainte_succ(cc)) {
        Pvecteur cv = contrainte_vecteur(cc);
        if(!invariant_vector_p(cv)) {
            vect_rm(cv);
            contrainte_vecteur(cc) = VECTEUR_NUL;
        }
    }
 
    return lc;
}

References contrainte_succ, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, invariant_vector_p(), vect_rm(), and VECTEUR_NUL.

Referenced by sc_keep_invariants_only().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_transformer()

void dump_transformer

(

transformer

tf

)

Parameters

tf

f

Definition at line 134 of file io.c.

{
    (void) fprint_transformer(stderr, tf, (get_variable_name_t) dump_value_name);
}

References dump_value_name(), and fprint_transformer().

Here is the call graph for this function:

dump_value_name()

char* dump_value_name

(

entity

e

)

char * dump_value_name(e): used as functional argument because entity_name is a macro

FI: should be moved in ri-util/entity.c

Definition at line 128 of file io.c.

{
    return entity_name(e);
}

References entity_name.

Referenced by check_range_wrt_precondition(), dump_transformer(), fortran_user_call_to_transformer(), print_value_mappings(), transformer_combine(), and translate_global_values().

Here is the caller graph for this function:

empty_transformer()

transformer empty_transformer

(

transformer

t

)

Do not allocate an empty transformer, but transform an allocated transformer into an empty_transformer.

Pretty dangerous because the predicate contained in t may have been deleted before empty_transformer is called. It is not clear that the predicate of t can be freed or not: it is up to the caller to be aware of the problem.

This function is risky to use. It can cause either a memory leak if the predicate is not freed, or a double free if the pointer in the transformer is already dangling. If the predicate has already been freed during some processing at the linear level, the caller must update the pointer transformer_relation(t) with:

transformer_relation(t) = relation_undefined;

before the call.

Definition at line 144 of file basic.c.

{
  free_predicate(transformer_relation(t));
  gen_free_list(transformer_arguments(t));
  transformer_arguments(t) = NIL;
  transformer_relation(t) = make_predicate(sc_empty(BASE_NULLE));
  return t;
}

References BASE_NULLE, free_predicate(), gen_free_list(), make_predicate(), NIL, sc_empty(), transformer_arguments, and transformer_relation.

Referenced by modulo_by_a_constant_to_transformer(), statement_to_postcondition(), transformer_combine(), transformer_convex_hulls(), transformer_projection_with_redundancy_elimination_and_check(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_has_values_p()

bool entity_has_values_p

(

entity

e

)

This function could be made more robust by checking the storage of e.

Formal parameters of analyzed type always have values.

is e a variable whose value(s) (already) are analyzed?

Definition at line 911 of file value.c.

{
  /* is e a variable whose value(s) (already) are analyzed?
   */
  pips_assert("value hash table is defined",
              !hash_table_undefined_p(hash_entity_to_new_value));
  bool has_values_p = hash_defined_p(hash_entity_to_new_value, (char *) e);
  return has_values_p;
}

References hash_defined_p(), hash_entity_to_new_value, hash_table_undefined_p, and pips_assert.

Referenced by add_index_range_conditions(), add_inter_or_intraprocedural_field_entities(), add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), add_intraprocedural_value_entities(), add_loop_index_exit_value(), add_or_kill_equivalenced_variables(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), apply_abstract_effect_to_transformer(), assign_operation_to_transformer(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), c_data_to_prec_for_variables(), declaration_to_transformer(), declaration_to_transformer_list(), dynamic_variables_to_values(), effects_to_arguments(), filter_transformer(), fortran_data_to_prec_for_variables(), fortran_user_call_to_transformer(), generic_apply_effect_to_transformer(), generic_reference_to_transformer(), generic_unary_operation_to_transformer(), integer_assign_to_transformer(), integer_assign_to_transformer_list(), logical_reference_to_transformer(), loop_bound_evaluation_to_transformer(), module_to_value_mappings(), noms_var(), pips_user_value_name(), pointer_unary_operation_to_transformer(), safe_assigned_expression_to_transformer(), safe_assigned_expression_to_transformer_list(), string_expression_to_transformer(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer(), transformer_add_condition_information_updown(), transformer_add_loop_index_incrementation(), transformer_add_loop_index_initialization(), transformer_add_modified_variable_entity(), transformer_add_variable_type_information(), transformer_filter_subsumed_variables(), transformer_general_consistency_p(), transformer_projection_with_redundancy_elimination_and_check(), transformer_variables_filter(), value_mappings_compatible_vector_p(), variable_to_values(), and variables_to_values().

Here is the call graph for this function:

entity_to_intermediate_value()

entity entity_to_intermediate_value

(

entity

e

)

Definition at line 879 of file value.c.

{
  entity i;
  if((i = (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return i;
}

References entity_name, entity_undefined, hash_entity_to_intermediate_value, hash_get(), and pips_internal_error.

Referenced by add_intermediate_alias_value(), add_synonym_values(), convex_in_effect_loop_range_fix(), external_value_name(), interlaced_basic_workchunk_regions_p(), remove_entity_values(), transformer_combine(), transformer_derivative_constraints(), transformer_derivative_fix_point(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_new_value()

entity entity_to_new_value

(

entity

e

)

Definition at line 859 of file value.c.

{
  entity n;
  if((n = (entity) hash_get(hash_entity_to_new_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return n;
}

References entity_name, entity_undefined, hash_entity_to_new_value, hash_get(), and pips_internal_error.

Referenced by add_affine_bound_conditions(), add_loop_index_exit_value(), add_new_alias_value(), add_synonym_values(), affine_to_transformer(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), args_to_transformer(), assign_operation_to_transformer(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), comp_regions_of_implied_do(), dynamic_variables_to_values(), external_value_name(), filter_transformer(), fortran_user_call_to_transformer(), generic_reference_to_transformer(), logical_reference_to_transformer(), loop_bound_evaluation_to_transformer(), old_value_to_new_value(), remove_entity_values(), string_expression_to_transformer(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_add_condition_information_updown(), transformer_add_identity(), transformer_add_loop_index_incrementation(), transformer_add_modified_variable_entity(), transformer_add_value_update(), transformer_add_variable_incrementation(), transformer_add_variable_type_information(), transformer_add_variable_update(), transformer_argument_general_consistency_p(), transformer_arguments_projection(), transformer_convex_hulls(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_domain_intersection(), transformer_internal_consistency_p(), transformer_list_generic_transitive_closure(), transformer_to_domain(), transformer_variables_filter(), update_cp_with_rhs_to_transformer(), value_mappings_compatible_vector_p(), value_passing_summary_transformer(), variable_to_values(), variables_to_new_values(), variables_to_values(), and vect_variables_to_values().

Here is the call graph for this function:

entity_to_old_value()

entity entity_to_old_value

(

entity

e

)

Definition at line 869 of file value.c.

{
  entity o;
  if((o = (entity) hash_get(hash_entity_to_old_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return o;
}

References entity_name, entity_undefined, hash_entity_to_old_value, hash_get(), and pips_internal_error.

Referenced by add_old_alias_value(), add_synonym_values(), add_type_information(), affine_to_transformer(), any_assign_operation_to_transformer(), any_basic_update_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), dynamic_variables_to_values(), external_value_name(), fortran_user_call_to_transformer(), new_value_to_old_value(), perform_array_element_substitutions_in_transformer(), precondition_intra_to_inter(), remove_entity_values(), safe_transformer_projection(), statement_to_postcondition(), statement_to_total_precondition(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_add_identity(), transformer_add_loop_index_incrementation(), transformer_add_loop_index_initialization(), transformer_add_modified_variable_entity(), transformer_add_value_update(), transformer_add_variable_incrementation(), transformer_add_variable_update(), transformer_arguments_projection(), transformer_combine(), transformer_convex_hulls(), transformer_domain_intersection(), transformer_intersect_range_with_domain(), transformer_list_safe_variables_projection(), transformer_projection_with_redundancy_elimination_and_check(), transformer_range(), transformer_to_domain(), transformer_variables_filter(), update_cp_with_rhs_to_transformer(), value_passing_summary_transformer(), variable_to_values(), variables_to_old_values(), and variables_to_values().

Here is the call graph for this function:

Here is the caller graph for this function:

equations_to_bases()

void equations_to_bases	(	Pcontrainte	lteq,
		Pbase *	pb_new,
		Pbase *	pb_old
	)

Parameters

lteq	teq
pb_new	b_new
pb_old	b_old

Definition at line 660 of file fix_point.c.

{
  Pbase b_new = BASE_UNDEFINED;
  Pbase b_old = BASE_UNDEFINED;
  Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
  for(eq = lteq; !CONTRAINTE_UNDEFINED_P(eq); eq = eq->succ) {
    Pvecteur t;
 
    for(t=contrainte_vecteur(eq); !VECTEUR_UNDEFINED_P(t); t = t->succ) {
      entity e = (entity) vecteur_var(t);
 
      if( e != (entity) TCST ) {
        if(new_value_entity_p(e)) {
          b_new = vect_add_variable(b_new, (Variable) e);
        }
        else {
          b_old = vect_add_variable(b_old,
                                    (Variable) old_value_to_new_value(e));
        }
      }
    }
  }
 
  *pb_new = b_new;
  *pb_old = b_old;
}

References BASE_UNDEFINED, CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, eq, new_value_entity_p(), old_value_to_new_value(), Scontrainte::succ, Svecteur::succ, TCST, vect_add_variable(), VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by build_transfer_equations().

Here is the call graph for this function:

Here is the caller graph for this function:

error_free_value_mappings()

void error_free_value_mappings

(

void

)

To be called by an error handler.

free previous hash tables, desallocate names; this implies ALL value names were malloced and were not pointer to a ri part

the three tables are assumed to be allocated all together

free names in hash_value_to_name; the other two hash tables contain pointers to the entity tabulated domain and thus need no value freeing

k is discovered unused by lint; it is syntaxically necessary

free the three tables themselves

Definition at line 1222 of file value.c.

{
  /* free previous hash tables, desallocate names; this implies ALL
     value names were malloced and were not pointer to a ri part */
 
  /* the three tables are assumed to be allocated all together */
 
  /* free names in hash_value_to_name; the other two hash tables
     contain pointers to the entity tabulated domain and thus need
     no value freeing */
  /* k is discovered unused by lint; it is syntaxically necessary */
  HASH_MAP(k, v, {free(v);}, hash_value_to_name);
  // Do not deallocate the names: they are pointers towards parts of
  // entity names
  //HASH_MAP(k, v, {free(v);}, hash_entity_to_user_value_name);
  /* free the three tables themselves */
  hash_table_free(hash_entity_to_new_value);
  hash_table_free(hash_entity_to_old_value);
  hash_table_free(hash_entity_to_intermediate_value);
  hash_table_free(hash_value_to_name);
  hash_table_free(hash_entity_to_user_value_name);
  hash_table_free(hash_reference_to_address_of_value);
  hash_table_free(hash_type_to_sizeof_value);
 
  reset_value_mappings();
  reset_temporary_value_counter();
  reset_analyzed_types();
}

References free(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_entity_to_user_value_name, HASH_MAP, hash_reference_to_address_of_value, hash_table_free(), hash_type_to_sizeof_value, hash_value_to_name, reset_analyzed_types(), reset_temporary_value_counter(), and reset_value_mappings().

Referenced by free_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

error_reset_value_mappings()

void error_reset_value_mappings

(

void

)

To be called by error handler only.

Potential memory leak.

Definition at line 1205 of file value.c.

{
  reset_value_mappings();
}

References reset_value_mappings().

Referenced by free_value_mappings(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

external_entity_to_new_value()

entity external_entity_to_new_value

(

entity

e

)

there is no decisive test here; a necessary condition is used instead

Definition at line 1411 of file value.c.

{
  /* there is no decisive test here; a necessary condition is used instead */
 
  entity e_new;
 
  pips_assert("e must be a type analyzable scalar variable", analyzable_scalar_entity_p(e));
  e_new = e;
  return e_new;
}

References analyzable_scalar_entity_p(), and pips_assert.

Referenced by add_formal_to_actual_bindings(), formal_and_actual_parameters_association(), fortran_user_call_to_transformer(), generic_reference_to_transformer(), logical_reference_to_transformer(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

external_entity_to_old_value()

entity external_entity_to_old_value

(

entity

e

)

find the old value entity if possible or abort I should never have to call this function on an local entity (local entities include static local variables)

Definition at line 1422 of file value.c.

{
  /* find the old value entity if possible or abort
     I should never have to call this function on an local entity
     (local entities include static local variables) */
 
  entity old_value;
  string old_value_name;
 
  old_value_name = concatenate(entity_name(e),OLD_VALUE_SUFFIX,
                               (char *) NULL);
  old_value = gen_find_tabulated(old_value_name, entity_domain);
 
  pips_assert("external_entity_to_old_value", old_value!=entity_undefined);
 
  return old_value;
}

References concatenate(), entity_domain, entity_name, entity_undefined, gen_find_tabulated(), OLD_VALUE_SUFFIX, and pips_assert.

Referenced by fortran_user_call_to_transformer(), perform_array_element_substitutions_in_transformer(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

external_value_name()

const char* external_value_name

(

entity

e

)

This should never occur. Please core dump!

Definition at line 753 of file value.c.

{
  const char* s = string_undefined;
  if(entity_constant_p(e)) {
    // Used for floating point and string constants? Why entity name?
    s = entity_local_name(e);
  }
  else if(entity_symbolic_p(e)) {
    // Used for locations, i.e. constant memory access paths
    s = entity_local_name(e);
  }
  else if(null_pointer_value_entity_p(e)) {
    s = entity_name(e);
  }
  else {
    // it must be one of the values attached to a user variable
    entity m = get_current_module_entity();
    s = hash_get(hash_value_to_name, (char *) e);
    // type t = entity_type(e);
 
    if(s==HASH_UNDEFINED_VALUE
       //&& type_variable_p(t)
       && !variable_in_module_p(e,m)) {
      if(global_new_value_p(e)) {
        entity a = entity_to_new_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else if(global_old_value_p(e)) {
        entity a = entity_to_old_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else if(global_intermediate_value_p(e)) {
        entity a = entity_to_intermediate_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else {
        /* This should never occur. Please core dump! */
        pips_internal_error("\nUnexpected value \"%s\""
                            " for current module \"%s\"",
                            entity_name(e),
                            module_local_name(get_current_module_entity()));
      }
    }
 
    pips_assert("A value name must be defined",
                s != HASH_UNDEFINED_VALUE);
 
    if(strcmp(module_local_name(m), module_name(s)) == 0
       ||strcmp(TOP_LEVEL_MODULE_NAME, module_name(s)) == 0) {
      //s = local_name(s);
      s = global_value_name_to_user_name(s);
    }
  }
 
  return s;
}

References entity_constant_p, entity_local_name(), entity_name, entity_symbolic_p, entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), get_current_module_entity(), global_intermediate_value_p(), global_new_value_p(), global_old_value_p(), global_value_name_to_user_name(), hash_get(), HASH_UNDEFINED_VALUE, hash_value_to_name, module_local_name(), module_name(), null_pointer_value_entity_p(), pips_assert, pips_internal_error, string_undefined, TOP_LEVEL_MODULE_NAME, and variable_in_module_p().

Referenced by __attribute__(), add_loop_skip_condition(), build_transfer_equations(), complete_loop_transformer(), complete_loop_transformer_list(), intermediate_value_entity_p(), invariant_vector_p(), loop_to_transformer(), noms_var(), old_complete_whileloop_transformer(), pips_user_value_name(), print_transformer(), print_transformers(), print_value_mappings(), readable_value_name(), recompute_loop_transformer(), remove_entity_values(), standard_whileloop_to_transformer(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_equality_fix_point(), transformer_list_generic_transitive_closure(), transformer_normalize(), and transformer_pattern_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

float_analyzed_p()

bool float_analyzed_p

(

void

)

Definition at line 315 of file value.c.

{
  return analyze_float_scalar_entities;
}

References analyze_float_scalar_entities.

Referenced by any_expression_to_transformer(), fortran_data_to_prec_for_variables(), parametric_transformer_empty_p(), and transformer_normalize().

Here is the caller graph for this function:

formal_and_actual_parameters_association()

transformer formal_and_actual_parameters_association	(	call	c,
		transformer	pre
	)

formal_and_actual_parameters_association(call c, transformer pre): Add equalities between actual and formal parameters binding by call c to pre pre := pre U {f = expr } i i for all i such that formal fi is an integer scalar variable and expression expr-i is affine

let's start a long, long, long MAPL, so long that MAPL is a pain

Parameters

pre

re

Definition at line 2542 of file transformer.c.

{
  entity f = call_function(c);
  list pc = call_arguments(c);
  list formals = entity_to_formal_integer_parameters(f);
  cons * ce;
 
  ifdebug(6) {
    debug(6,"formal_and_actual_parameters_association",
          "begin for call to %s pre=%x\n", module_local_name(f), pre);
    dump_transformer(pre);
  }
 
  pips_assert("formal_and_actual_parameters_association",
              entity_module_p(f));
  pips_assert("formal_and_actual_parameters_association",
              pre != transformer_undefined);
 
  /* let's start a long, long, long MAPL, so long that MAPL is a pain */
  for( ce = formals; !ENDP(ce); POP(ce)) {
    entity e = ENTITY(CAR(ce));
    int r = formal_offset(storage_formal(entity_storage(e)));
    expression expr;
    normalized n;
 
    if((expr = find_ith_argument(pc, r)) == expression_undefined)
      user_error("formal_and_actual_parameters_association",
                 "not enough args for formal parm. %d\n", r);
 
    n = NORMALIZE_EXPRESSION(expr);
    if(normalized_linear_p(n)) {
      Pvecteur v = vect_dup((Pvecteur) normalized_linear(n));
      entity e_new = external_entity_to_new_value(e);
 
      vect_add_elem(&v, (Variable) e_new, -1);
      pre = transformer_equality_add(pre, v);
    }
  }
 
  free_arguments(formals);
 
  ifdebug(6) {
    debug(6,"formal_and_actual_parameters_association",
          "new pre=%x\n", pre);
    dump_transformer(pre);
    debug(6,"formal_and_actual_parameters_association","end for call to %s\n",
          module_local_name(f));
  }
 
  return pre;
}

References call_arguments, call_function, CAR, debug(), dump_transformer, ENDP, ENTITY, entity_module_p(), entity_storage, entity_to_formal_integer_parameters(), expression_undefined, external_entity_to_new_value(), f(), find_ith_argument(), formal_offset, free_arguments(), ifdebug, module_local_name(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_assert, POP, storage_formal, transformer_equality_add(), transformer_undefined, user_error, vect_add_elem(), and vect_dup().

Referenced by interprocedural_abc_arrays(), and translate_to_module_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_transformer()

transformer fprint_transformer	(	FILE *	fd,
		transformer	tf,
		get_variable_name_t	value_name
	)

print_transformer returns an int to be compatible with the debug() function; however, debug being a function and not a macro, its arguments are ALWAYS evaluated regardless of the debug level; so a call to print_transformer passed as an argument to debug is ALWAYS effective

print argument list

print relation

Parameters

fd	d
tf	f
value_name	alue_name

Definition at line 69 of file io.c.

{
  /* print_transformer returns an int to be compatible with the debug()
     function; however, debug being a function and not a macro, its
     arguments are ALWAYS evaluated regardless of the debug level;
     so a call to print_transformer passed as an argument to debug
     is ALWAYS effective */
 
  if(tf==transformer_undefined)
    (void) fprintf(stderr,"TRANSFORMER UNDEFINED\n");
  // For debugging with gdb, dynamic type checking
  else if((transformer_domain_number(tf))!=transformer_domain) {
    (void) fprintf(stderr,"Arg. \"tf\"is not a transformer.\n");
  }
  else {
    cons * args = transformer_arguments(tf);
    Psysteme sc = (Psysteme) predicate_system(transformer_relation(tf));
 
    /* print argument list */
    (void) fprintf(fd,"arguments:");
    print_homogeneous_arguments(args, (const char* (*) (entity))value_name);
 
    /* print relation */
    if(SC_UNDEFINED_P(sc))
      pips_internal_error("undefined relation");
    (void) fprintf(fd,"\nrelation:");
    sc_fprint(fd,
              sc,
              value_name);
  }
 
  return tf;
}

References fprintf(), pips_internal_error, predicate_system, print_homogeneous_arguments(), sc_fprint(), transformer_arguments, transformer_domain, transformer_domain_number, transformer_relation, and transformer_undefined.

Referenced by complete_loop_transformer(), complete_loop_transformer_list(), dump_transformer(), expression_equal_in_context_p(), expression_less_than_in_context(), fprint_transformers(), loop_to_transformer(), old_complete_whileloop_transformer(), print_any_transformer(), print_transformer(), standard_whileloop_to_transformer(), transformer_derivative_fix_point(), transformer_equality_fix_point(), transformer_filter(), transformer_list_generic_transitive_closure(), transformer_normalize(), transformer_pattern_fix_point(), and transformer_projection_with_redundancy_elimination_and_check().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_transformers()

list fprint_transformers	(	FILE *	fd,
		list	tl,
		get_variable_name_t	value_name
	)

Parameters

fd	d
tl	l
value_name	alue_name

Definition at line 105 of file io.c.

{
  if(ENDP(tl)) {
    // FI: I changed my mind; this is a way to represent a non
    //feasible transformer
    //pips_internal_error("transformer lists should never be empty.");
    fprintf(fd, "Empty transformer list\n");
  }
  else {
    FOREACH(TRANSFORMER, tf, tl) {
      fprint_transformer(fd, tf, value_name);
    }
  }
  return tl;
}

References ENDP, FOREACH, fprint_transformer(), fprintf(), and TRANSFORMER.

Referenced by print_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

free_transformers()

void free_transformers	(	transformer	t,
			...
	)

Analyze in args the variadic arguments that may be after t:

Since a variadic function in C must have at least 1 non variadic argument (here the s), just skew the varargs analysis:

Get the next argument:

Release the variadic analyzis:

Definition at line 73 of file basic.c.

                                           {
  va_list args;
 
  /* Analyze in args the variadic arguments that may be after t: */
  va_start(args, t);
  /* Since a variadic function in C must have at least 1 non variadic
     argument (here the s), just skew the varargs analysis: */
  do {
    free_transformer(t);
    /* Get the next argument: */
    t = va_arg(args, transformer);
  } while(t!=NULL);
  /* Release the variadic analyzis: */
  va_end(args);
}

References free_transformer().

Referenced by loop_to_enter_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

free_value_mappings()

void free_value_mappings

(

void

)

Normal call to free the mappings.

Definition at line 1212 of file value.c.

{
  reset_hooks_unregister(error_reset_value_mappings);
  pips_assert("no free of undefined mappings",
              !hash_table_undefined_p(hash_entity_to_old_value));
  error_free_value_mappings();
}

References error_free_value_mappings(), error_reset_value_mappings(), hash_entity_to_old_value, hash_table_undefined_p, pips_assert, and reset_hooks_unregister().

Referenced by add_alias_pairs_for_this_caller(), alias_classes(), alias_lists(), alias_pairs(), aliases_text(), any_complexities(), array_expansion(), bdsc_code_instrumentation(), call_site_to_module_precondition_text(), continuation_conditions(), dsc_code_parallelization(), generic_module_name_to_transformers(), generic_print_xml_application(), get_continuation_condition_text(), get_semantic_text(), hbdsc_parallelization(), initial_precondition(), isolate_statement(), kernel_data_mapping(), kernel_load_store_engine(), module_name_to_preconditions(), module_name_to_total_preconditions(), out_regions_from_caller_to_callee(), partial_eval(), phrase_comEngine_distributor(), phrase_distributor(), phrase_distributor_control_code(), pragma_outliner(), print_initial_precondition(), print_program_precondition(), program_precondition(), reset_convex_in_out_regions(), reset_convex_rw_regions(), reset_convex_summary_in_out_regions(), reset_convex_summary_rw_regions(), safescale_distributor(), safescale_module_analysis(), sequence_dependence_graph(), solve_hardware_constraints(), spire_distributed_unstructured_to_structured(), summary_precondition(), summary_total_postcondition(), and update_precondition_with_call_site_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_equality_to_transformer()

transformer generic_equality_to_transformer	(	entity	e,
		entity	f,
		bool	assignment,
		bool	unary_minus_p
	)

Parameters

assignment	ssignment
unary_minus_p	nary_minus_p

Definition at line 72 of file transformer.c.

{
  transformer tf = transformer_undefined;
  Pvecteur eq = vect_new((Variable) e, VALUE_ONE);
  cons * tf_args = NIL;
  Pcontrainte c;
 
  ifdebug(9) {
    pips_debug(9, "entity e: %s, entity f: %s, %s\n",
               entity_local_name(e), entity_local_name(f),
               assignment? "Is an assignment" : "Is not an assignment");
  }
 
  if(assignment)
    tf_args = CONS(ENTITY, e, NIL);
 
  vect_add_elem(&eq, (Variable) f, unary_minus_p? VALUE_ONE : VALUE_MONE);
  c = contrainte_make(eq);
  tf = make_transformer(tf_args,
                        make_predicate(sc_make(c, CONTRAINTE_UNDEFINED)));
 
  ifdebug(9) {
    pips_debug(9, "end with tf=%p\n", tf);
    dump_transformer(tf);
  }
 
  return tf;
}

References CONS, contrainte_make(), CONTRAINTE_UNDEFINED, dump_transformer, ENTITY, entity_local_name(), eq, f(), ifdebug, make_predicate(), make_transformer(), NIL, pips_debug, sc_make(), transformer_undefined, VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by simple_equality_to_transformer(), and simple_unary_minus_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_transformer_list_to_transformer()

transformer generic_transformer_list_to_transformer	(	list	ltl,
		bool	active_p
	)

Reduce the transformer list with the convex hull operator.

If active_p is true, skip transformers that do not update the state. Beyond the identity transformer, any transformer without arguments does not really update the state, although it may restrict it.

A new transformer is always allocated. The transformers in the transformer list ltl are freed.

Look for the first useful transformer in the list

Only range conditions have been found: the store is restricted but not changed.

Take care of the following useful transformers

Look for the next useful transformer in the list

Parameters

ltl	tl
active_p	ctive_p

Definition at line 384 of file transformer_list.c.

{
  transformer ltf = transformer_undefined; // list transformer
 
  if(ENDP(ltl))
    ltf = transformer_empty();
  else {
    list ctl = ltl;
    /* Look for the first useful transformer in the list */
    FOREACH(TRANSFORMER, tf, ltl) {
      if(!active_p || !ENDP(transformer_arguments(tf))) {
        ltf = copy_transformer(tf);
        free_transformer(tf);
        POP(ctl);
        break;
      }
      POP(ctl);
    }
    if(ENDP(ctl)) {
      if(transformer_undefined_p(ltf))
        /* Only range conditions have been found: the store is
           restricted but not changed. */
        ltf = transformer_identity();
    }
    else {
      /* Take care of the following useful transformers */
      while(!ENDP(ctl)) {
        /* Look for the next useful transformer in the list */
        FOREACH(TRANSFORMER, tf, ctl) {
          if(!active_p || !ENDP(transformer_arguments(tf))) {
            transformer ntf = copy_transformer(tf);
            transformer ptf = ltf;
            ltf = transformer_convex_hull(ptf, ntf);
            free_transformer(ntf);
            free_transformer(ptf);
            POP(ctl);
            break;
          }
          POP(ctl);
        }
      }
    }
  }
 
  return ltf;
}

References copy_transformer(), ENDP, FOREACH, free_transformer(), POP, TRANSFORMER, transformer_arguments, transformer_convex_hull(), transformer_empty(), transformer_identity(), transformer_undefined, and transformer_undefined_p.

Referenced by active_transformer_list_to_transformer(), and transformer_list_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_value_name()

const char* generic_value_name

(

entity

e

)

else if (entity_has_values_p(e)){

n = external_value_name(e);

Definition at line 81 of file prettyprint.c.

{
  const char* n = string_undefined;
 
  if(e == (entity) TCST) {
    n = "";
  }
  else {
    (void) gen_check((gen_chunk *) e, entity_domain);
    if(local_temporary_value_entity_p(e)) {
      n = entity_minimal_name(e);
    }
    /* else if (entity_has_values_p(e)){ */
    else if (!hash_value_to_name_undefined_p()
             && value_entity_p(e)){
      /* n = external_value_name(e); */
      n = pips_user_value_name(e);
    }
    else {
      n = entity_minimal_name(e);
    }
  }
  return n;
}

References entity_domain, entity_minimal_name(), gen_check(), hash_value_to_name_undefined_p(), local_temporary_value_entity_p(), pips_user_value_name(), string_undefined, TCST, and value_entity_p().

Referenced by varval_value_name_is_inferior_p().

Here is the call graph for this function:

Here is the caller graph for this function:

global_intermediate_value_p()

bool global_intermediate_value_p

(

entity

e

)

this is not a general test; it will only work for GLOBAL values

Definition at line 703 of file value.c.

{
  /* this is not a general test; it will only work for GLOBAL values */
  string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
  bool intermediate = false;
 
  if(suf!=NULL)
    intermediate = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
      strcmp(suf, INTERMEDIATE_VALUE_SUFFIX) == 0;
 
  return intermediate;
}

References entity_local_name(), entity_module_name(), INTERMEDIATE_VALUE_SUFFIX, SEMANTICS_MODULE_NAME, and SEMANTICS_SEPARATOR.

Referenced by external_value_name().

Here is the call graph for this function:

Here is the caller graph for this function:

global_new_value_p()

bool global_new_value_p

(

entity

e

)

GLOBAL VALUES.

this is not a general test; it will only work for GLOBAL values

this function should always return false because new value = variable (FI)

=> suf == NULL string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);

pips_assert("global_new_value", suf != NULL);

new = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 && strcmp(suf, NEW_VALUE_SUFFIX) == 0;

Definition at line 667 of file value.c.

{
  bool new = false;
  /* this is not a general test; it will only work for GLOBAL values */
 
  /* this function should always return false because new value = variable (FI) */
 
  /* => suf == NULL
     string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
 
     pips_assert("global_new_value", suf != NULL);
 
     new = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
     strcmp(suf, NEW_VALUE_SUFFIX) == 0;
  */
 
  pips_assert("global_new_value", new == false && e==e);
 
  return new;
}

References pips_assert.

Referenced by external_value_name().

Here is the caller graph for this function:

global_new_value_to_global_old_value()

entity global_new_value_to_global_old_value

(

entity

v_new

)

There is no real test for global new values

Parameters

v_new

_new

Definition at line 716 of file value.c.

{
  entity v_old = entity_undefined;
 
  /* There is no real test for global new values */
 
  pips_assert("new value must be a real variable entity, denoting the new value",
              strcmp(entity_module_name(v_new), SEMANTICS_MODULE_NAME) != 0);
 
  string v_old_name = concatenate(entity_name(v_new), OLD_VALUE_SUFFIX, NULL);
  v_old = (entity) gen_find_tabulated(v_old_name, entity_domain);
  if(v_old==NULL) v_old = entity_undefined;
 
  return v_old;
}

References concatenate(), entity_domain, entity_module_name(), entity_name, entity_undefined, gen_find_tabulated(), OLD_VALUE_SUFFIX, pips_assert, and SEMANTICS_MODULE_NAME.

Referenced by c_user_function_call_to_transformer(), fortran_user_function_call_to_transformer(), substitute_scalar_stub_in_transformer(), transformer_projection_with_redundancy_elimination_and_check(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

global_old_value_p()

bool global_old_value_p

(

entity

e

)

Return true if an entity is a global old value (such as "i#init"...).

this is not a general test; it will only work for GLOBAL values

Definition at line 690 of file value.c.

{
  /* this is not a general test; it will only work for GLOBAL values */
  string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
  bool old = false;
 
  if(suf!=NULL)
    old = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
      strcmp(suf, OLD_VALUE_SUFFIX) == 0;
 
  return old;
}

References entity_local_name(), entity_module_name(), OLD_VALUE_SUFFIX, SEMANTICS_MODULE_NAME, and SEMANTICS_SEPARATOR.

Referenced by external_value_name(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

global_value_name_to_user_name()

const char* global_value_name_to_user_name

(

const char *

gn

)

HASH TABLE USE.

Return a variable value name or map a variable to its different variable values. the '#' character used in value naming conflicts with the reserved character for struct naming

Parameters

gn

n

Definition at line 741 of file value.c.

{
  const char* un = strrchr(gn, BLOCK_SEP_CHAR);
 
  if(un==NULL)
    un = local_name(gn);
  else
    un++;
 
  return un;
}

References BLOCK_SEP_CHAR, and local_name().

Referenced by external_value_name().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_entity_to_values_undefined_p()

bool hash_entity_to_values_undefined_p

(

void

)

value.c

Definition at line 229 of file value.c.

{
  return (hash_table_undefined_p(hash_entity_to_new_value));
}

References hash_entity_to_new_value, and hash_table_undefined_p.

hash_value_to_name_undefined_p()

bool hash_value_to_name_undefined_p

(

void

)

Definition at line 1199 of file value.c.

{
  return hash_table_undefined_p(hash_value_to_name);
}

References hash_table_undefined_p, and hash_value_to_name.

Referenced by generic_value_name().

Here is the caller graph for this function:

integer_analyzed_p()

bool integer_analyzed_p

(

void

)

Definition at line 300 of file value.c.

{
  return analyze_integer_scalar_entities;
}

References analyze_integer_scalar_entities.

Referenced by any_expression_to_transformer().

Here is the caller graph for this function:

intermediate_value_entity_p()

bool intermediate_value_entity_p

(

entity

e

)

Definition at line 955 of file value.c.

{
  string s = strstr(external_value_name(e), INTERMEDIATE_VALUE_SUFFIX);
 
  return s!=NULL;
}

References external_value_name(), and INTERMEDIATE_VALUE_SUFFIX.

Referenced by transformer_internal_consistency_p(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

invariant_vector_p()

bool invariant_vector_p

(

Pvecteur

v

)

A vector (in fact, a constraint) represents an invariant if it is a sum of delta for each variable.

Let di = i::new - i::old. If v = sigma (di) = 0, v can be used to build a loop invariant.

It is assumed that constant terms have been substituted earlier using a loop counter.

OK, you could argue for invariant = false, but this would not help my debugging!

if v_sum is non zero, you might try to bound it wrt the loop precondition?

Definition at line 934 of file fix_point.c.

{
    bool invariant = true;
    Pvecteur cv = VECTEUR_UNDEFINED;
    Pvecteur v_old = VECTEUR_NUL;
    Pvecteur v_new = VECTEUR_NUL;
    Pvecteur v_sum = VECTEUR_UNDEFINED;
 
    ifdebug(8) {
        pips_debug(8, "begin for vector: ");
        vect_fprint(stderr, v, (char * (*)(Variable)) external_value_name);
    }
 
    for(cv=v; !VECTEUR_UNDEFINED_P(cv); cv = vecteur_succ(cv)) {
        if(vecteur_var(cv)==TCST) {
            /* OK, you could argue for invariant = false,
             * but this would not help my debugging!
             */
            pips_internal_error("Constant term in a potential invariant vector!");
        }
        else {
            entity e = (entity) vecteur_var(cv);
            entity var = value_to_variable(e);
 
 
            if(old_value_entity_p(e)) {
                vect_add_elem(&v_old, (Variable) var, vecteur_val(cv));
            }
            else if(new_value_entity_p(e)) {
                vect_add_elem(&v_new, (Variable) var, vecteur_val(cv));
            }
            else {
                pips_internal_error("Non value entity %s in invariant vector",
                           entity_name(e));
            }
        }
    }
 
    v_sum = vect_add(v_new, v_old);
 
    ifdebug(8) {
        pips_debug(8, "vector v_new: ");
        vect_fprint(stderr, v_new, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "vector v_old: ");
        vect_fprint(stderr, v_old, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "vector v_sum: ");
        vect_fprint(stderr, v_sum, (char * (*)(Variable)) external_value_name);
    }
 
    if(VECTEUR_NUL_P(v_sum)) {
        invariant = true;
    }
    else {
        /* if v_sum is non zero, you might try to bound it
         * wrt the loop precondition?
         */
        invariant = false;
        vect_rm(v_sum);
    }
 
    vect_rm(v_new);
    vect_rm(v_old);
 
    pips_debug(8, "end invariant=%s\n",
          bool_to_string(invariant));
 
    return invariant;
}

References bool_to_string(), entity_name, external_value_name(), ifdebug, new_value_entity_p(), old_value_entity_p(), pips_debug, pips_internal_error, TCST, value_to_variable(), vect_add(), vect_add_elem(), vect_fprint(), vect_rm(), VECTEUR_NUL, VECTEUR_NUL_P, vecteur_succ, VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, vecteur_val, and vecteur_var.

Referenced by constraints_keep_invariants_only().

Here is the call graph for this function:

Here is the caller graph for this function:

invariant_wrt_transformer()

transformer invariant_wrt_transformer	(	transformer	p,
		transformer	tf
	)

transformer invariant_wrt_transformer(transformer p, transformer tf): Assume that tf is a fix-point operator.

Old version: keep the invariant part of predicat p wrt tf in a VERY crude way; old and new values related to an entity modified by tf are discarded by projection, regardless of the way they are modified; information that they are modified is preserved; in fact, this is not a projection but a cylinder based on the projection. inf A real fix-point a la Halbwachs should be used p' = UNION(tf^k(p)) k=0 or simply one of PIPS loop fix-points.

Be careful if tf is not feasible because the result is p itself which may not be what you expect.

p is not modified.

if it is expensive, maybe it should not be computed over and over...

tf? fptf?

must be freed, otherwise it is leaked.

Parameters

tf

f

Definition at line 1948 of file transformer.c.

{
  transformer inv = transformer_undefined;
  transformer fptf = transformer_undefined;
 
  if(!transformer_undefined_p(p)) {
    //transformer raw_inv = transformer_undefined;
    if(false)
      {
        fptf = args_to_transformer(transformer_arguments(tf));
      }
    else
      {
        /* if it is expensive, maybe it should not be computed over and over...
         */
        fptf = transformer_derivative_fix_point(tf);
      }
 
    inv = transformer_apply(fptf, p); /* tf? fptf? */
    //inv = transformer_range(raw_inv);
 
    //free_transformer(raw_inv); // Newgen syntax
    transformer_free(fptf); /* must be freed, otherwise it is leaked. */
  }
  else {
    inv = transformer_undefined;
  }
  return inv;
}

References args_to_transformer(), transformer_apply(), transformer_arguments, transformer_derivative_fix_point(), transformer_free(), transformer_undefined, and transformer_undefined_p.

Referenced by loop_to_transformer(), new_loop_to_transformer(), old_complete_whileloop_transformer(), process_ready_node(), standard_whileloop_to_transformer(), unstructured_to_postcondition(), and unstructured_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

local_intermediate_value_entity_p()

bool local_intermediate_value_entity_p

(

entity

e

)

this is not a general test; it will only work for LOCAL values

Definition at line 648 of file value.c.

{
  /* this is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), INTERMEDIATE_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and INTERMEDIATE_VALUE_PREFIX.

Here is the call graph for this function:

local_old_value_entity_p()

bool local_old_value_entity_p

(

entity

e

)

Return true if an entity is a local old value (such as "o#0" for a global value "i#init"...).

This is not a general test; it will only work for LOCAL values

Definition at line 642 of file value.c.

{
  /* This is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), OLD_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and OLD_VALUE_PREFIX.

Referenced by add_type_information(), and regions_transformer_apply().

Here is the call graph for this function:

Here is the caller graph for this function:

local_temporary_value_entity_p()

bool local_temporary_value_entity_p

(

entity

e

)

this is not a general test; it will only work for LOCAL values

Definition at line 654 of file value.c.

{
  /* this is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), TEMPORARY_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and TEMPORARY_VALUE_PREFIX.

Referenced by generic_transformer_to_analyzed_locations(), generic_value_name(), non_local_temporary_value_entity_p(), old_value_entity_p(), readable_value_name(), transformer_add_sign_information(), transformer_projection_with_redundancy_elimination_and_check(), transformer_temporary_value_projection(), transformer_to_potential_stub_translation(), transformer_with_temporary_values_p(), and value_mappings_compatible_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

look_for_the_best_counter()

Pvecteur look_for_the_best_counter

(

Pcontrainte

egs

)

Try to identify a loop counter among the equation egs.

If the transformer has been build naively, a loop counter should have a transformer equation like i::new = i::old + K_i where K_i is a numerical constant.

Since the loop counter is later used to eliminate constant terms in other constraints, variable i with the minimal absolute value K_i shuold be chosen.

Parameters

egs

gs

Definition at line 797 of file fix_point.c.

{
    Pvecteur v_inc = VECTEUR_UNDEFINED;
    Pcontrainte leq = CONTRAINTE_UNDEFINED;
    int inc = 0;
 
    for(leq = egs;
        !CONTRAINTE_UNDEFINED_P(leq);
        leq = contrainte_succ(leq)) {
 
        Pvecteur v = contrainte_vecteur(leq);
        int c_inc = 0;
 
        if(vect_size(v)==3) {
            entity p_old_index = entity_undefined;
            entity p_new_index = entity_undefined;
            Pvecteur lv = VECTEUR_UNDEFINED;
            bool failed = false;
            for(lv = v; !VECTEUR_UNDEFINED_P(lv) && !failed; lv = vecteur_succ(lv)) {
                if(vecteur_var(lv) == TCST) {
                    c_inc = (int) vecteur_val(lv);
                }
                else if(old_value_entity_p((entity) vecteur_var(lv))) {
                    if(entity_undefined_p(p_old_index))
                        p_old_index = (entity) vecteur_var(lv);
                    else
                        failed = true;
                }
                else if(new_value_entity_p((entity) vecteur_var(lv))) {
                    if(entity_undefined_p(p_new_index))
                        p_new_index = (entity) vecteur_var(lv);
                    else
                        failed = true;
                }
                else {
                    pips_internal_error("Unexpected value entity %s",
                               entity_local_name((entity) vecteur_var(lv)));
                }
            }
            if(!failed && value_to_variable(p_old_index) == value_to_variable(p_new_index)) {
                if(ABS(c_inc) < ABS(inc) || c_inc == 1) {
                    inc = c_inc;
                    v_inc = v;
                }
            }
        }
    }
 
    return v_inc;
}

References ABS, contrainte_succ, CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, entity_local_name(), entity_undefined, entity_undefined_p, int, new_value_entity_p(), old_value_entity_p(), pips_internal_error, TCST, value_to_variable(), vect_size(), vecteur_succ, VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, vecteur_val, and vecteur_var.

Referenced by transformer_pattern_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_integer_value_entity()

entity make_local_temporary_integer_value_entity

(

void

)

Definition at line 629 of file value.c.

{
  basic b = make_basic(is_basic_int, (void *) 4);
  type t = make_type(is_type_variable, make_variable(b, NIL,NIL));
  entity tmp = make_local_value_entity(local_temporary_value_counter++, 2, t);
 
  free_type(t);
  return tmp;
}

References free_type(), is_basic_int, is_type_variable, local_temporary_value_counter, make_basic(), make_local_value_entity(), make_type(), make_variable(), and NIL.

Referenced by add_type_information(), bitwise_xor_to_transformer(), logical_not_to_transformer(), modulo_to_transformer(), transformer_add_condition_information_updown(), transformer_derivative_fix_point(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_value_entity()

entity make_local_temporary_value_entity

(

type

t

)

FI: is it easier to admit value of type void than to make a special case? Let see if it works... No, it's not a good idea because value are assumed of type variable in many places.

Definition at line 605 of file value.c.

{
  entity tv = entity_undefined;
 
  /* FI: is it easier to admit value of type void than to make a
     special case? Let see if it works... No, it's not a good idea
     because value are assumed of type variable in many places. */
  if(analyzed_type_p(t))
    tv = make_local_value_entity(local_temporary_value_counter++, 2, t);
  else
    pips_internal_error("Request for a temporary value with a non analyzed type.\n");
 
  return tv;
}

References analyzed_type_p(), entity_undefined, local_temporary_value_counter, make_local_value_entity(), and pips_internal_error.

Referenced by add_formal_to_actual_bindings(), add_index_bound_conditions(), add_type_information(), addition_operation_to_transformer(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), call_to_transformer(), expression_multiply_sizeof_to_transformer(), expression_to_transformer(), generic_abs_to_transformer(), generic_minmax_to_transformer(), iabs_to_transformer(), integer_binary_operation_to_transformer(), integer_expression_and_precondition_to_integer_interval(), integer_left_shift_to_transformer(), integer_minmax_to_transformer(), integer_multiply_to_transformer(), logical_binary_operation_to_transformer(), logical_unary_operation_to_transformer(), loop_bound_evaluation_to_transformer(), loop_to_enter_transformer(), unary_minus_operation_to_transformer(), update_cp_with_rhs_to_transformer(), update_operation_to_transformer(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_value_entity_with_basic()

entity make_local_temporary_value_entity_with_basic

(

basic

b

)

Definition at line 620 of file value.c.

{
  type t = make_type(is_type_variable, make_variable(copy_basic(b), NIL,NIL));
  entity tmp = make_local_value_entity(local_temporary_value_counter++, 2, t);
 
  free_type(t);
  return tmp;
}

References copy_basic(), free_type(), is_type_variable, local_temporary_value_counter, make_local_value_entity(), make_type(), make_variable(), and NIL.

Referenced by condition_to_transformer(), precondition_minmax_of_expression(), and transformer_add_any_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_transformer_lists()

list merge_transformer_lists	(	list	tl1,
		list	tl2
	)

transformer_list.c

transformer_list.c

Tansformer lists are used to delay convex hulls and to refine the precondition computation of loops by putting aside the identity transformer.

If there is an identity transformer in the list, it is supposed to be the first one in the list.

However, some control paths are almost identity transformers because the store is apparently unchanged. However, they contain predicates on the possible values. Although they have no arguments, and hence, the store is left unchanged, they are different from the identity transformer bebcause the relation is smaller.

So it should be up to the function using the transformer list to decide how to cope with transformers that restrict the identity transition. Must not be used, beware of library cycles: include "semantics.h" Union of two lists

If the list includes the identity transformer, it must be the first in the list and be nowehere else

It is not clear if transformer lists will be stored in hash tables... Hence I do not know if the input list should be freed, reused or left unshared. To be conservative, no alias is created.

Do we have to worry about different bases in transformers?

Too much information is sometimes lost with this simplification

Parameters

tl1	l1
tl2	l2

Definition at line 74 of file transformer_list.c.

{
  list ntl = NIL;
  list ntl1 = NIL;
  list ntl2 = NIL;
 
  if(ENDP(tl1))
    ntl = gen_full_copy_list(tl2);
  else if(ENDP(tl2))
    ntl = gen_full_copy_list(tl1);
  else {
    /* Do we have to worry about different bases in transformers? */
    transformer t1 = TRANSFORMER(CAR(tl1));
    transformer t2 = TRANSFORMER(CAR(tl2));
 
    /* Too much information is sometimes lost with this
       simplification */
    /*
    if(ENDP(transformer_arguments(t1))) {
      free_transformer(t1);
      t1 = transformer_identity();
    }
 
    if(ENDP(transformer_arguments(t2))) {
      free_transformer(t2);
      t2 = transformer_identity();
    }
    */
 
    if(transformer_identity_p(t1) || transformer_identity_p(t2)) {
      ntl = CONS(TRANSFORMER, transformer_identity(), NIL);
    }
    if(transformer_identity_p(t1))
      ntl1 = gen_full_copy_list(CDR(tl1));
    else
      ntl1 = gen_full_copy_list(tl1);
    if(transformer_identity_p(t2))
      ntl2 = gen_full_copy_list(CDR(tl2));
    else
      ntl2 = gen_full_copy_list(tl2);
    ntl1 = gen_nconc(ntl1, ntl2);
    ntl = gen_nconc(ntl, ntl1);
  }
 
  ifdebug(1) {
    int ntll = gen_length(ntl);
    int tl1l = gen_length(tl1);
    int tl2l = gen_length(tl2);
    pips_assert("The new list is about the sum of the input lists.\n",
                ntll>=tl1l+tl2l-1 && ntll<=tl1l+tl2l);
    pips_assert("The new transformer list is legal",
                check_transformer_list(ntl));
  }
  return ntl;
}

References CAR, CDR, check_transformer_list(), CONS, ENDP, gen_full_copy_list(), gen_length(), gen_nconc(), ifdebug, NIL, pips_assert, TRANSFORMER, transformer_identity(), and transformer_identity_p().

Referenced by test_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

modified_variables_with_values()

list modified_variables_with_values

(

void

)

Return the list of all analyzed variables which are modified in the current module.

If they are modified, they must have old values.

The intermediate values could be used as well

Definition at line 1094 of file value.c.

{
  /* The intermediate values could be used as well */
  /*
  list ivl = mapping_to_domain_list(hash_entity_to_old_value); // initial
                                                               // value list
  list wvl = NIL; // written variable list
 
  FOREACH(ENTITY, e, ivl) {
    entity wv = new_value_to_variable(e);
    ivl = CONS(ENTITY, wv, ivl);
  }
 
  gen_reverse(wvl);
  */
  list wvl = mapping_to_domain_list(hash_entity_to_old_value);
  return wvl;
}

References hash_entity_to_old_value, and mapping_to_domain_list().

Referenced by apply_abstract_effect_to_transformer(), generic_reference_to_transformer(), and transformer_combine().

Here is the call graph for this function:

Here is the caller graph for this function:

move_transformer()

transformer move_transformer	(	transformer	t1,
		transformer	t2
	)

Move arguments and predicate of t2 into t1, free old arguments and predicate of t1, free what's left of t2.

This is used to perform a side effect on an argument when a function allocates a new transformer to return a result. t2 should not be used after a call to move_transformer()

Parameters

t1	1
t2	2

Definition at line 939 of file basic.c.

{
  pips_assert("t1 is consistent on entry", transformer_consistency_p(t1));
  pips_assert("t2 is consistent on entry", transformer_consistency_p(t2));
 
  free_arguments(transformer_arguments(t1));
  transformer_arguments(t1) = transformer_arguments(t2);
  transformer_arguments(t2) = NIL;
 
  sc_rm(predicate_system(transformer_relation(t1)));
  predicate_system(transformer_relation(t1))
    = predicate_system(transformer_relation(t2));
  predicate_system(transformer_relation(t2))= SC_UNDEFINED;
 
  free_transformer(t2);
 
  pips_assert("t1 is consistent on exit", transformer_consistency_p(t1));
 
  return t1;
}

References free_arguments(), free_transformer(), NIL, pips_assert, predicate_system, sc_rm(), transformer_arguments, transformer_consistency_p(), and transformer_relation.

Referenced by transformer_domain_intersection().

Here is the call graph for this function:

Here is the caller graph for this function:

new_value_entity_p()

bool new_value_entity_p

(

entity

e

)

the following three functions are directly or indirectly relative to the current module and its value hash tables.

since new values are always variable entities, hash_entity_to_new_value can be used for this test

Definition at line 925 of file value.c.

{
  /* since new values are always variable entities, hash_entity_to_new_value
     can be used for this test */
 
  pips_assert("new_value_entity_p",e != entity_undefined);
 
  return (entity) hash_get(hash_entity_to_new_value, (char *) e)
    == e;
}

References entity_undefined, hash_entity_to_new_value, hash_get(), and pips_assert.

Referenced by build_transfer_matrix(), equations_to_bases(), invariant_vector_p(), look_for_the_best_counter(), new_value_in_transfer_equation(), transfer_equation_p(), transformer_internal_consistency_p(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

new_value_in_transfer_equation()

entity new_value_in_transfer_equation

(

Pvecteur

eq

)

for gcc

Parameters

eq

q

Definition at line 570 of file fix_point.c.

{
    Pvecteur t;
    int n_new = 0;
    Value coeff = VALUE_ZERO; /* for gcc */
    entity new_value = entity_undefined;
 
    for(t=eq; !VECTEUR_UNDEFINED_P(t) && n_new <= 1; t = t->succ) {
        entity e = (entity) vecteur_var(t);
 
        if( e != (entity) TCST && new_value_entity_p(e) &&
           (value_one_p(vecteur_val(t)) || value_mone_p(vecteur_val(t)))) {
            new_value = e;
            coeff = vecteur_val(t);
            n_new++;
        }
    }
 
    if(value_mone_p(coeff)) {
        for(t=eq; !VECTEUR_UNDEFINED_P(t) && n_new <= 1; t = t->succ) {
            value_oppose(vecteur_val(t));
        }
    }
 
    pips_assert("n_new==1", n_new==1);
 
    return new_value;
}

References entity_undefined, eq, new_value_entity_p(), pips_assert, Svecteur::succ, TCST, value_mone_p, value_one_p, value_oppose, VALUE_ZERO, VECTEUR_UNDEFINED_P, vecteur_val, and vecteur_var.

Referenced by build_transfer_matrix().

Here is the call graph for this function:

Here is the caller graph for this function:

new_value_to_old_value()

entity new_value_to_old_value

(

entity

n_val

)

FI: correct code entity var = entity_undefined;

var = value_to_variable(n_val); o_val = entity_to_old_value(var);

FI: faster code

Parameters

n_val

_val

Definition at line 1710 of file value.c.

{
  entity o_val = entity_undefined;
 
  /* FI: correct code
     entity var = entity_undefined;
 
     var = value_to_variable(n_val);
     o_val = entity_to_old_value(var);
  */
 
  /* FI: faster code */
  o_val = entity_to_old_value(n_val);
 
  return o_val;
}

References entity_to_old_value(), and entity_undefined.

Referenced by transformer_equality_fix_point(), and upwards_vect_rename().

Here is the call graph for this function:

Here is the caller graph for this function:

no_elim()

Psysteme no_elim

(

Psysteme

ps

)

Parameters

ps

s

Definition at line 1306 of file transformer.c.

{
    return ps;
}

number_of_analyzed_values()

int number_of_analyzed_values

(

void

)

Definition at line 1148 of file value.c.

{
  return hash_table_entry_count(hash_value_to_name);
}

References hash_table_entry_count(), and hash_value_to_name.

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_analyzed_variables()

int number_of_analyzed_variables

(

void

)

FI: looks more like the number of values used.

Definition at line 1160 of file value.c.

{
  return hash_table_entry_count(hash_value_to_name);
}

References hash_table_entry_count(), and hash_value_to_name.

Here is the call graph for this function:

number_of_temporary_values()

int number_of_temporary_values

(

void

)

Definition at line 255 of file value.c.

{
  return local_temporary_value_counter;
}

References local_temporary_value_counter.

Referenced by transformer_temporary_value_projection(), and transformer_with_temporary_values_p().

Here is the caller graph for this function:

old_transformer_free()

void old_transformer_free

(

transformer

t

)

I should use gen_free directly but Psysteme is not yet properly interfaced with NewGen

gen_free should stop before trying to free a Psysteme and won't free entities in arguments because they are tabulated

commented out for DRET demo

end of DRET demo

Definition at line 89 of file basic.c.

{
    /* I should use gen_free directly but Psysteme is not yet properly
       interfaced with NewGen */
    Psysteme s;
 
    pips_assert("transformer_free", t != transformer_undefined);
 
    s = (Psysteme) predicate_system(transformer_relation(t));
    sc_rm(s);
    predicate_system_(transformer_relation(t)) = SC_UNDEFINED;
    /* gen_free should stop before trying to free a Psysteme and
       won't free entities in arguments because they are tabulated */
    /* commented out for DRET demo */
    /*
    gen_free(t);
    */
    /* end of DRET demo */
}

References pips_assert, predicate_system, predicate_system_, sc_rm(), transformer_relation, and transformer_undefined.

Here is the call graph for this function:

old_value_entity_p()

bool old_value_entity_p

(

entity

e

)

Temporary values do not have an external name.

OLD_VALUE_PREFIX is not used for global old values

string s = strstr(external_value_name(e), OLD_VALUE_SUFFIX);

string s = strstr(entity_local_name(e), OLD_VALUE_PREFIX);

Definition at line 936 of file value.c.

{
  /* Temporary values do not have an external name. */
  /* OLD_VALUE_PREFIX is not used for global old values */
  /* string s = strstr(external_value_name(e), OLD_VALUE_SUFFIX); */
  /* string s = strstr(entity_local_name(e), OLD_VALUE_PREFIX); */
 
  if(!local_temporary_value_entity_p(e)) {
    string s1 = strstr(entity_local_name(e), OLD_VALUE_SUFFIX);
    // Need to remake the search for OLD_VALUE_PREFIX
    // bug for toto#...
    string s2 = strstr(entity_local_name(e), OLD_VALUE_PREFIX);
    // s2==entity_local_name(e) : for the case toto#...
    return s1!=NULL || (s2!=NULL && s2==entity_local_name(e));
  }
  else
    return false;
}

References entity_local_name(), local_temporary_value_entity_p(), OLD_VALUE_PREFIX, OLD_VALUE_SUFFIX, and s1.

Referenced by expression_less_than_in_context(), invariant_vector_p(), look_for_the_best_counter(), my_system_remove_variables(), precondition_filter_old_values(), print_call_precondition(), remove_temporal_variables_from_system(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_general_consistency_p(), transformer_internal_consistency_p(), transformer_list_generic_transitive_closure(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

old_value_to_new_value()

entity old_value_to_new_value

(

entity

o_val

)

o_val = variable_to_old_value(var);

Parameters

o_val

_val

Definition at line 1698 of file value.c.

{
  entity var = entity_undefined;
  entity n_val = entity_undefined;
 
  var = value_to_variable(o_val);
  /* o_val = variable_to_old_value(var); */
  n_val = entity_to_new_value(var);
 
  return n_val;
}

References entity_to_new_value(), entity_undefined, and value_to_variable().

Referenced by build_transfer_matrix(), and equations_to_bases().

Here is the call graph for this function:

Here is the caller graph for this function:

one_to_one_transformers_combine()

list one_to_one_transformers_combine	(	list	tl1,
		list	tl2
	)

Combine each transformer of transformer list tl1 with the corresponding transformer in transformer list tl2.

Side-effect on tl1. See comments for transformer_combine().

See combine_transformer_lists() to combine each element of t1 with each element of t2.

Parameters

tl1	l1
tl2	l2

Definition at line 476 of file transformer.c.

{
  list ntl2 = tl2;
  pips_assert("The two lists have the same number of elements",
              gen_length(tl1)==gen_length(tl2));
  FOREACH(TRANSFORMER, t1, tl1) {
    transformer t2 = TRANSFORMER(CAR(ntl2));
    t1 = transformer_combine(t1, t2);
    POP(ntl2);
  }
  return tl1;
}

References CAR, FOREACH, gen_length(), pips_assert, POP, TRANSFORMER, and transformer_combine().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_user_value_name()

const char* pips_user_value_name

(

entity

e

)

This function is called many times when the constraints and the system of constraints are sorted using lexicographic information based on this particular value name.

See for instance Semantics-New/freia_52.c. Hence it is memorized.

Definition at line 815 of file value.c.

{
  pips_debug(9, "start with entity : %s\n", entity_name(e));
  const char* uvn = string_undefined;
 
  if(e == (entity) TCST) {
    uvn = "";
  }
  else {
    // To check the execution speed, uncomment the next line
    // return entity_name(e);
    uvn = hash_get(hash_entity_to_user_value_name, (char *) e);
 
    if(uvn==HASH_UNDEFINED_VALUE) {
      // Need to discriminate the case of an address_of value
      // because the hash table are reset between each pass
      if (address_of_value_entity_p(e)) {
        entity v = value_to_variable(e);
        string temp = strdup(entity_name(e));
        string indice = strstr(temp, "[");
        if (indice != NULL)
          *(indice+strlen(indice)-strlen(ADDRESS_OF_SUFFIX)) = '\0';
        uvn = strdup(concatenate("&", entity_user_name(v), indice, (char *) NULL));
        free(temp);
      }
      else if (null_pointer_value_entity_p(e)) {
        uvn = strdup("NULL");
      }
      else if (sizeof_value_entity_p(e)) {
        type t = entity_type(e);
        uvn = strdup(concatenate("sizeof(", type_to_full_string_definition(t), ")", (char *) NULL));
      }
      else {
        (void) gen_check((gen_chunk *) e, entity_domain);
        uvn = entity_has_values_p(e)? (string)entity_minimal_name(e) :
            external_value_name(e);
      }
        hash_put(hash_entity_to_user_value_name, (char *) e, uvn);
    }
  }
  pips_debug(9, "end with string : %s\n", uvn);
  return uvn;
}

References ADDRESS_OF_SUFFIX, address_of_value_entity_p(), concatenate(), entity_domain, entity_has_values_p(), entity_minimal_name(), entity_name, entity_type, entity_user_name(), external_value_name(), free(), gen_check(), hash_entity_to_user_value_name, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, null_pointer_value_entity_p(), pips_debug, sizeof_value_entity_p(), strdup(), string_undefined, TCST, type_to_full_string_definition(), and value_to_variable().

Referenced by generic_value_name(), is_inferior_pvarval(), semantics_is_inferior_pvarval(), text_continuation(), and text_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_analyzed_p()

bool pointer_analyzed_p

(

void

)

Definition at line 325 of file value.c.

{
  return analyze_pointer_scalar_entities;
}

References analyze_pointer_scalar_entities.

Referenced by any_expression_to_transformer().

Here is the caller graph for this function:

precondition_to_abstract_store()

transformer precondition_to_abstract_store

(

transformer

pre

)

Get rid of all old values and arguments.

Argument pre is unchanged and result as is allocated. Should be a call to transformer_range(). Should not be in basic.c.

Project all old values

Redefine the arguments

Parameters

pre

re

Definition at line 871 of file basic.c.

{
  transformer as = transformer_dup(pre);
 
  /* Project all old values */
  as = transformer_projection(as, transformer_arguments(as));
 
  /* Redefine the arguments */
  gen_free_list(transformer_arguments(as));
  transformer_arguments(as) = NIL;
 
  return as;
}

References gen_free_list(), NIL, transformer_arguments, transformer_dup(), and transformer_projection().

Referenced by test_to_transformer(), and test_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

precondition_to_string()

string precondition_to_string

(

transformer

pre

)

Parameters

pre

re

Definition at line 58 of file prettyprint.c.

{
    pips_internal_error("not implemenented anymore, pre=%p", pre);
    return string_undefined;
}

References pips_internal_error, and string_undefined.

Referenced by comp_regions_of_implied_do(), and evaluate_var_to_complexity().

Here is the caller graph for this function:

print_any_transformer()

transformer print_any_transformer

(

transformer

tf

)

For debugging without problem from temporary values.

Parameters

tf

f

Definition at line 56 of file io.c.

{
    return fprint_transformer(stderr, tf,
                              (get_variable_name_t) entity_local_name);
}

References entity_local_name(), and fprint_transformer().

Here is the call graph for this function:

print_transformer()

transformer print_transformer

(

transformer

tf

)

io.c

io.c

Francois Irigoin, 21 April 1990 print_transformer(tf): not a macro because of dbx and gdb

Parameters

tf

f

Definition at line 48 of file io.c.

{
  (void) fprint_transformer(stderr, tf,
                            (get_variable_name_t) external_value_name);
  return tf;
}

References external_value_name(), and fprint_transformer().

Here is the call graph for this function:

print_transformers()

list print_transformers

(

list

tl

)

Parameters

tl

l

Definition at line 62 of file io.c.

{
    return fprint_transformers(stderr, tl,
                               (get_variable_name_t) external_value_name);
}

References external_value_name(), and fprint_transformers().

Referenced by any_assign_to_transformer_list(), any_basic_update_to_transformer_list(), any_update_to_transformer_list(), block_to_transformer_list(), complete_any_loop_transformer_list(), declaration_to_transformer_list(), instruction_to_transformer_list(), integer_assign_to_transformer_list(), statement_to_transformer_list(), test_to_transformer_list(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

print_value_mappings()

void print_value_mappings

(

void

)

Definition at line 993 of file value.c.

{
  (void) fprintf(stderr,"\nhash table value to name:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)dump_value_name, (gen_string_func_t)string_identity,
                     hash_value_to_name);
 
  (void) fprintf(stderr,"\nhash table entity to new value:\n");
  /*
    hash_table_fprintf(stderr, entity_local_name, external_value_name,
    hash_entity_to_new_value);
  */
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)entity_minimal_name,
                     hash_entity_to_new_value);
 
  (void) fprintf(stderr,"\nhash table entity to old value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)external_value_name,
                     hash_entity_to_old_value);
 
  (void) fprintf(stderr, "\nhash table entity to intermediate value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)external_value_name,
                         hash_entity_to_intermediate_value);
 
  (void) fprintf(stderr, "\nhash table reference to address_of value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)reference_to_string, (gen_string_func_t)external_value_name,
                         hash_reference_to_address_of_value);
 
  (void) fprintf(stderr, "\nhash table entity to sizeof value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)type_to_full_string_definition, (gen_string_func_t)external_value_name,
                         hash_type_to_sizeof_value);
}

References dump_value_name(), entity_minimal_name(), external_value_name(), fprintf(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_reference_to_address_of_value, hash_table_fprintf(), hash_type_to_sizeof_value, hash_value_to_name, reference_to_string(), string_identity(), and type_to_full_string_definition().

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

readable_value_name()

const char* readable_value_name

(

entity

v

)

For debugging purposes, we might have to print system with temporary values.

Definition at line 1769 of file value.c.

{
  const char* n ;
 
  if(local_temporary_value_entity_p(v)) {
    n = entity_local_name(v);
  }
  else {
    n = external_value_name(v);
  }
 
  return n;
}

References entity_local_name(), external_value_name(), and local_temporary_value_entity_p().

Referenced by generic_module_name_to_transformers(), module_name_to_preconditions(), and module_name_to_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_to_address_entity()

entity reference_to_address_entity

(

reference

r

)

The address is the address of a variable or of a reference such as &a[5], not a of a value.

The reference must be a constant memory access path. It does not have to be atomic, as struct are not considered atomic, following Pierre Jouvelot's view point since partial updates are possible.

An address is a constant within a C user function.

As a constant, it must be encoded as a 0-ary function, just like 1.0 or true.

We use the user representation as entity name, namey &a[5].

We do not use array names as constant pointers because they alreay are entities with types and storage. So the address of array a is &a[0].

References can be points-to references, i.e. fields can be encoded as indices.

trict_constant_path_p(r)

Should this local constant be added to the module declarations ?

Definition at line 1285 of file value.c.

{
  entity a = entity_undefined;
  // if(can_be_constant_path_p(r) /*strict_constant_path_p(r)*/) {
  /*strict_constant_path_p(r)*/
  if(store_independent_points_to_reference_p(r)) {
    entity v = reference_variable(r);
    /* Should this local constant be added to the module declarations ? */
    string mn = (string) entity_module_name(v);
    string ln = strdup(concatenate("&", reference_to_string(r), NULL));
    type t = points_to_reference_to_concrete_type(r);
    type ft = make_type_functional(make_functional(NIL, copy_type(t)));
    a = FindOrCreateEntity(mn, ln);
    entity_type(a) = ft;
    entity_storage(a) = make_storage_rom();
    expression re = reference_to_expression(copy_reference(r));
    expression i = unary_intrinsic_expression(ADDRESS_OF_OPERATOR_NAME, re);
    symbolic s = make_symbolic(i, make_constant_unknown());
    entity_initial(a) = make_value_symbolic(s);
    entity_kind(a) = DEFAULT_ENTITY_KIND;
  }
  return a;
}

References ADDRESS_OF_OPERATOR_NAME, concatenate(), copy_reference(), copy_type(), DEFAULT_ENTITY_KIND, entity_initial, entity_kind, entity_module_name(), entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), make_constant_unknown(), make_functional(), make_storage_rom(), make_symbolic(), make_type_functional(), make_value_symbolic(), NIL, points_to_reference_to_concrete_type(), reference_to_expression(), reference_to_string(), reference_variable, store_independent_points_to_reference_p(), strdup(), and unary_intrinsic_expression.

Here is the call graph for this function:

reference_to_address_of_value()

entity reference_to_address_of_value

(

reference

r

)

Definition at line 889 of file value.c.

{
  entity n;
  if((n = (entity) hash_get(hash_reference_to_address_of_value, (char *) r))
      == entity_undefined)
    pips_internal_error("unbounded reference %s",
        reference_to_string(r));
  return n;
}

References entity_undefined, hash_get(), hash_reference_to_address_of_value, pips_internal_error, and reference_to_string().

Here is the call graph for this function:

relation_to_string()

string relation_to_string	(	string	,
		Psysteme	,
		char *	*)(entity
	)

relation_to_transformer()

transformer relation_to_transformer	(	entity	op,
		entity	e1,
		entity	e2,
		bool	veracity
	)

e and f are assumed to be values.

Operator op is overloaded and the result is operator and type dependent

Beware of type coercion... Fabien conjectures that values with incompatible types won't get mixed up...

type independent

Non convex information

Parameters

op	p
e1	1
e2	2
veracity	eracity

Definition at line 139 of file transformer.c.

{
  transformer tf = transformer_undefined;
  basic b1 = variable_basic(type_variable(entity_type(e1)));
  basic b2 = variable_basic(type_variable(entity_type(e2)));
  Pvecteur eq = VECTEUR_NUL;
  Pvecteur ineq = VECTEUR_NUL;
  Pcontrainte ceq = CONTRAINTE_UNDEFINED;
  Pcontrainte cineq = CONTRAINTE_UNDEFINED;
 
  ifdebug(9) {
    pips_debug(9, "Begin for entity e1: %s of basic %s, "
               "entity e2: %s of basic %s and operator %s\n",
               entity_local_name(e1), basic_to_string(b1),
               entity_local_name(e2), basic_to_string(b2),
               module_local_name(op));
  }
 
  /* Beware of type coercion... Fabien conjectures that values with
     incompatible types won't get mixed up... */
 
  if((ENTITY_EQUAL_P(op) && veracity)
     || (ENTITY_NON_EQUAL_P(op) && !veracity)) {
    /* type independent */
    eq = vect_new((Variable) e1, VALUE_ONE);
    vect_add_elem(&eq, (Variable) e2, VALUE_MONE);
  }
  else if((ENTITY_NON_EQUAL_P(op) && veracity)
          || (ENTITY_EQUAL_P(op) && !veracity)) {
    /* Non convex information */
    ;
  }
  else if((ENTITY_LESS_OR_EQUAL_P(op) && veracity)
          || (ENTITY_GREATER_THAN_P(op) && !veracity)) {
    ineq = vect_new((Variable) e1, VALUE_ONE);
    vect_add_elem(&ineq, (Variable) e2, VALUE_MONE);
  }
  else if((ENTITY_LESS_THAN_P(op) && veracity)
          ||(ENTITY_GREATER_OR_EQUAL_P(op) && !veracity)) {
    ineq = vect_new((Variable) e1, VALUE_ONE);
    vect_add_elem(&ineq, (Variable) e2, VALUE_MONE);
    // if we want to authorize to compare a pointer with an integer
    //if((basic_int_p(b1) || basic_logical_p(b1) || basic_pointer_p(b1))
    //   && (basic_int_p(b2) || basic_logical_p(b2) || basic_pointer_p(b2))) {
    // if we only want to compare a pointer with an another pointer
    if(((basic_int_p(b1) || basic_logical_p(b1))
       && (basic_int_p(b2) || basic_logical_p(b2)))
       || (basic_pointer_p(b1) && basic_pointer_p(b2))) {
      vect_add_elem(&ineq, TCST, VALUE_ONE);
    }
  }
  else if((ENTITY_GREATER_OR_EQUAL_P(op) && veracity)
          || (ENTITY_LESS_THAN_P(op) && !veracity)) {
    ineq = vect_new((Variable) e1, VALUE_MONE);
    vect_add_elem(&ineq, (Variable) e2, VALUE_ONE);
  }
  else if((ENTITY_GREATER_THAN_P(op) && veracity)
          || (ENTITY_LESS_OR_EQUAL_P(op) && !veracity)) {
    ineq = vect_new((Variable) e1, VALUE_MONE);
    vect_add_elem(&ineq, (Variable) e2, VALUE_ONE);
    // if we want to authorize to compare a pointer with an integer
    //if((basic_int_p(b1) || basic_logical_p(b1) || basic_pointer_p(b1))
    //   && (basic_int_p(b2) || basic_logical_p(b2) || basic_pointer_p(b2))) {
    // if we only want to compare a pointer with an another pointer
    if(((basic_int_p(b1) || basic_logical_p(b1))
       && (basic_int_p(b2) || basic_logical_p(b2)))
       || (basic_pointer_p(b1) && basic_pointer_p(b2))) {
      vect_add_elem(&ineq, TCST, VALUE_ONE);
    }
  }
  else {
    pips_internal_error("Unexpected relational operator %s", entity_name(op));
  }
 
  ceq = VECTEUR_NUL_P(eq)? CONTRAINTE_UNDEFINED : contrainte_make(eq);
  cineq = VECTEUR_NUL_P(ineq)? CONTRAINTE_UNDEFINED : contrainte_make(ineq);
 
  if(ceq!=CONTRAINTE_UNDEFINED||cineq!=CONTRAINTE_UNDEFINED) {
    tf = make_transformer(NIL,
                          make_predicate(sc_make(ceq, cineq)));
  }
 
  ifdebug(9) {
    pips_debug(9, "end with tf=%p\n", tf);
    dump_transformer(tf);
  }
 
  return tf;
}

References b1, b2, basic_int_p, basic_logical_p, basic_pointer_p, basic_to_string(), contrainte_make(), CONTRAINTE_UNDEFINED, dump_transformer, ENTITY_EQUAL_P, ENTITY_GREATER_OR_EQUAL_P, ENTITY_GREATER_THAN_P, ENTITY_LESS_OR_EQUAL_P, ENTITY_LESS_THAN_P, entity_local_name(), entity_name, ENTITY_NON_EQUAL_P, entity_type, eq, ifdebug, make_predicate(), make_transformer(), module_local_name(), NIL, pips_debug, pips_internal_error, sc_make(), TCST, transformer_undefined, type_variable, VALUE_MONE, VALUE_ONE, variable_basic, vect_add_elem(), vect_new(), VECTEUR_NUL, and VECTEUR_NUL_P.

Referenced by transformer_add_any_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_entity_values()

void remove_entity_values	(	entity	e,
		bool	readonly
	)

pips_assert("remove_entity_values", e != entity_undefined);

Parameters

readonly

eadonly

Definition at line 1545 of file value.c.

{
  entity new_value = entity_to_new_value(e);
  const char* s;
 
  /* pips_assert("remove_entity_values", e != entity_undefined); */
  pips_assert("remove_entity_values", new_value != entity_undefined);
 
  s = external_value_name(new_value);
  pips_assert("remove_entity_values", s != (char *) NULL);
  (void) hash_del(hash_value_to_name, (char *) new_value);
  (void) hash_del(hash_entity_to_new_value, (char *) e);
 
  if(!readonly) {
    entity old_value = entity_to_old_value(e);
    entity intermediate_value = entity_to_intermediate_value(e);
 
    pips_assert("remove_entity_values", old_value != entity_undefined);
    pips_assert("remove_entity_values",
                intermediate_value!=entity_undefined);
 
    s = external_value_name(old_value);
    pips_assert("remove_entity_values", s != (char *) NULL);
    (void) hash_del(hash_value_to_name, (char *) old_value);
    s = external_value_name(intermediate_value);
    pips_assert("remove_entity_values", s != (char *) NULL);
    (void) hash_del(hash_value_to_name, (char *) intermediate_value);
 
    (void) hash_del(hash_entity_to_old_value, (char *) e);
    (void) hash_del(hash_entity_to_intermediate_value, (char *) e);
  }
}

References entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), entity_undefined, external_value_name(), hash_del(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_value_to_name, and pips_assert.

Referenced by add_or_kill_equivalenced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_analyzed_types()

void reset_analyzed_types

(

void

)

Definition at line 289 of file value.c.

{
  analyze_integer_scalar_entities = true;
  analyze_boolean_scalar_entities = false;
  analyze_string_scalar_entities = false;
  analyze_float_scalar_entities = false;
  analyze_complex_scalar_entities = false;
  analyze_pointer_scalar_entities = false;
  analyze_constant_path = false;
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_constant_path, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, and analyze_string_scalar_entities.

Referenced by error_free_value_mappings(), and eval_linear_expression().

Here is the caller graph for this function:

reset_temporary_value_counter()

void reset_temporary_value_counter

(

void

)

Definition at line 250 of file value.c.

{
  local_temporary_value_counter = 0;
}

References local_temporary_value_counter.

Referenced by add_index_bound_conditions(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), call_to_transformer(), error_free_value_mappings(), loop_bound_evaluation_to_transformer(), module_to_value_mappings(), precondition_add_condition_information(), test_to_transformer(), test_to_transformer_list(), and transformer_add_condition_information().

Here is the caller graph for this function:

reset_value_counters()

void reset_value_counters

(

void

)

Definition at line 244 of file value.c.

{
  local_old_value_counter = 0;
  local_intermediate_value_counter = 0;
}

References local_intermediate_value_counter, and local_old_value_counter.

Referenced by module_to_value_mappings().

Here is the caller graph for this function:

safe_transformer_projection()

transformer safe_transformer_projection	(	transformer	t,
		list	args
	)

t may be undefined, args may contain values unrelated to t

keep only values of args related to the transformer t

Make sure v is in the basis

Make sure the old value is projected too

Parameters

args

rgs

Definition at line 1187 of file transformer.c.

{
  transformer nt = transformer_undefined;
  if(!transformer_undefined_p(t)) {
    Psysteme r = (Psysteme) predicate_system(transformer_relation(t));
    list nargs = NIL;
 
    /* keep only values of args related to the transformer t */
    FOREACH(ENTITY, v, args) {
      /* Make sure v is in the basis */
      if(base_contains_variable_p(sc_base(r), (Variable) v)) {
        nargs = arguments_add_entity(nargs, v);
      }
      if(entity_is_argument_p(v, transformer_arguments(t))) {
        /* Make sure the old value is projected too */
        entity ov = entity_to_old_value(v);
        if(base_contains_variable_p(sc_base(r), (Variable) ov)) {
          nargs = arguments_add_entity(nargs, ov);
        }
      }
    }
 
    nt = transformer_projection(t, nargs);
    gen_free_list(nargs);
  }
  return nt;
}

References arguments_add_entity(), base_contains_variable_p(), ENTITY, entity_is_argument_p(), entity_to_old_value(), FOREACH, gen_free_list(), NIL, predicate_system, transformer_arguments, transformer_projection(), transformer_relation, transformer_undefined, and transformer_undefined_p.

Referenced by add_index_bound_conditions(), add_type_information(), loop_to_transformer(), statement_to_postcondition(), statement_to_transformer(), statement_to_transformer_list(), substitute_stubs_in_transformer(), transformer_list_multiple_closure_to_precondition(), and transformer_list_safe_variables_projection().

Here is the call graph for this function:

Here is the caller graph for this function:

same_dimension_p()

bool same_dimension_p	(	entity	actual_array,
		entity	dummy_array,
		list	l_actual_ref,
		size_t	i,
		transformer	context
	)

This function returns true if the actual array and the dummy array have the same dimension number i, with respect to the current context (precondition + association) In case if the actual argument is an array element, we have to add the following condition: the i-th subscript of the array element is equal to its correspond lower bound.

The following test is necessary in case of array reshaping

Parameters

actual_array	ctual_array
dummy_array	ummy_array
l_actual_ref	_actual_ref
context	ontext

Definition at line 2665 of file transformer.c.

{
  variable actual_var = type_variable(entity_type(actual_array));
  variable dummy_var = type_variable(entity_type(dummy_array));
  list l_actual_dims = variable_dimensions(actual_var);
  list l_dummy_dims = variable_dimensions(dummy_var);
 
  /* The following test is necessary in case of array reshaping */
  if ((i <= gen_length(l_actual_dims)) && (i < gen_length(l_dummy_dims)))
  {
    dimension dummy_dim = find_ith_dimension(l_dummy_dims,i);
    expression dummy_lower = dimension_lower(dummy_dim);
    expression dummy_upper = dimension_upper(dummy_dim);
    dimension actual_dim = find_ith_dimension(l_actual_dims,i);
    expression actual_lower = dimension_lower(actual_dim);
    expression actual_upper = dimension_upper(actual_dim);
    expression dummy_size, actual_size;
    if (expression_equal_integer_p(dummy_lower,1) &&
        expression_equal_integer_p(actual_lower,1))
    {
      dummy_size = copy_expression(dummy_upper);
      actual_size = copy_expression(actual_upper);
    }
    else
    {
      dummy_size = binary_intrinsic_expression(MINUS_OPERATOR_NAME,
                                               dummy_upper,dummy_lower);
      actual_size = binary_intrinsic_expression(MINUS_OPERATOR_NAME,
                                                actual_upper,actual_lower);
    }
    if (expression_equal_in_context_p(actual_size, dummy_size, context))
    {
      if (l_actual_ref == NIL)
        // case : array name
        return true;
      else
            {
              // the actual argument is an array element name,
              // we have to calculate the subscript value also*/
              expression actual_sub = find_ith_argument(l_actual_ref,i);
              if (same_expression_p(actual_sub,actual_lower))
          return true;
            }
    }
  }
  return false;
}

References binary_intrinsic_expression, copy_expression(), dimension_lower, dimension_upper, entity_type, expression_equal_in_context_p(), expression_equal_integer_p(), find_ith_argument(), find_ith_dimension(), gen_length(), MINUS_OPERATOR_NAME, NIL, same_expression_p(), type_variable, and variable_dimensions.

Referenced by interprocedural_abc_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_eliminate_constant_terms()

Psysteme sc_eliminate_constant_terms	(	Psysteme	sc,
		Pvecteur	v
	)

Eliminate all constant terms in sc using v.

No sharing between sc and v is assumed as sc is updated!

This function should be located in Linear/sc

Parameters

sc

c

Definition at line 853 of file fix_point.c.

{
    int cv = vect_coeff(TCST, v);
 
    assert(cv!=0);
 
    sc_egalites(sc) = constraints_eliminate_constant_terms(sc_egalites(sc), v);
    sc_inegalites(sc) = constraints_eliminate_constant_terms(sc_inegalites(sc), v);
 
    return sc;
}

References assert, constraints_eliminate_constant_terms(), TCST, and vect_coeff().

Referenced by transformer_pattern_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_keep_invariants_only()

Psysteme sc_keep_invariants_only

(

Psysteme

sc

)

This function cannot be moved into the Linear library.

It relies on the concepts of old and new values.

It could be improved by using an approximate initial fix-point to evaluate v_sum (see invariant_vector_p) and to degrade equations into inequalities or to relax inequalities.

For instance, p = p + a won't generate an invariant. However, if the lousy fix-point is sufficient to prove a >= 0, it is possible to derive p::new >= p::old. Or even better if a's value turns out to be known.

Parameters

sc

c

Definition at line 902 of file fix_point.c.

{
    sc_egalites(sc) = constraints_keep_invariants_only(sc_egalites(sc));
    sc_inegalites(sc) = constraints_keep_invariants_only(sc_inegalites(sc));
    return sc;
}

References constraints_keep_invariants_only().

Referenced by transformer_pattern_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_multiply_constant_terms()

Psysteme sc_multiply_constant_terms	(	Psysteme	sc,
		Variable	ik,
		bool	star_p
	)

Specific for the derivative fix point: each constant term in the constraints is multiplied by ik which is not in sc's basis, and ik is added to the basis is necessary.

This possible only if ik is positive. Constraint ik>=0 is added if star_p is true because the function is used to compute T*. Else, contraint ik>=1 is added because the function is used to compute T+.

Also used in transformer_list.c

add constraint ik >= 0 to compute T*. Would be ik>=1 if T+ were sought.

Parameters

sc	c
ik	k
star_p	tar_p

Definition at line 1013 of file fix_point.c.

{
  Pcontrainte c;
 
  pips_assert("sc is defined", !SC_UNDEFINED_P(sc));
  pips_assert("ik is not in sc's basis",
              !base_contains_variable_p(sc->base, ik));
 
  for(c = sc->egalites; !CONTRAINTE_UNDEFINED_P(c); c = c->succ) {
    Pvecteur v = c->vecteur;
    for(;!VECTEUR_NUL_P(v); v = v->succ) {
      Variable var = var_of(v);
      if(var==TCST) {
        var_of(v) = ik;
        break;
      }
    }
  }
 
  for(c = sc->inegalites; !CONTRAINTE_UNDEFINED_P(c); c = c->succ) {
    Pvecteur v = c->vecteur;
    for(;!VECTEUR_NUL_P(v); v = v->succ) {
      Variable var = var_of(v);
      if(var==TCST) {
        var_of(v) = ik;
        break;
      }
    }
  }
 
  /* add constraint ik >= 0 to compute T*. Would be ik>=1 if T+ were
     sought. */
  Pvecteur v = vect_new(ik, VALUE_MONE);
  if(!star_p) {
    // add the constant term for T+
    vect_add_elem(&v, TCST, VALUE_ONE);
  }
  c = contrainte_make(v);
  sc_add_inegalite(sc, c);
  base_add_dimension(&(sc->base), ik);
  sc->dimension++;
 
  return sc;
}

References Ssysteme::base, base_add_dimension, base_contains_variable_p(), contrainte_make(), CONTRAINTE_UNDEFINED_P, Ssysteme::dimension, Ssysteme::egalites, Ssysteme::inegalites, pips_assert, sc_add_inegalite(), Scontrainte::succ, Svecteur::succ, TCST, VALUE_MONE, VALUE_ONE, var_of, vect_add_elem(), vect_new(), Scontrainte::vecteur, and VECTEUR_NUL_P.

Referenced by transformer_derivative_fix_point(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

set_analyzed_types()

void set_analyzed_types

(

void

)

Definition at line 271 of file value.c.

{
  analyze_integer_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_INTEGER_VARIABLES");
  analyze_boolean_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_BOOLEAN_VARIABLES");
  analyze_string_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_STRING_VARIABLES");
  analyze_float_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_FLOAT_VARIABLES");
  analyze_complex_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_COMPLEX_VARIABLES");
  analyze_pointer_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_POINTER_VARIABLES");
  analyze_constant_path =
    get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH");
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_constant_path, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, and get_bool_property().

Referenced by eval_linear_expression(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_addition_to_transformer()

transformer simple_addition_to_transformer	(	entity	e,
		entity	e1,
		entity	e2,
		bool	addition_p
	)

e and e1 and e2 are assumed to be values.

State e=e1+e2 or e=e1-e2. Type independent.

Parameters

e1	1
e2	2
addition_p	ddition_p

Definition at line 106 of file transformer.c.

{
  transformer tf = transformer_undefined;
  Pvecteur eq = vect_new((Variable) e, VALUE_ONE);
  Pcontrainte c;
 
  ifdebug(9) {
    pips_debug(9, "entity e: %s, entity e1: %s, entity e2: %s, %s\n",
               entity_local_name(e),
               entity_local_name(e1),
               entity_local_name(e2),
               addition_p? "Is an addition" : "Is a subtraction");
  }
 
  vect_add_elem(&eq, (Variable) e1, VALUE_MONE);
  vect_add_elem(&eq, (Variable) e2, addition_p? VALUE_MONE : VALUE_ONE);
  c = contrainte_make(eq);
  tf = make_transformer(NIL,
                        make_predicate(sc_make(c, CONTRAINTE_UNDEFINED)));
 
  ifdebug(9) {
    pips_debug(9, "end with tf=%p\n", tf);
    dump_transformer(tf);
  }
 
  return tf;
}

References contrainte_make(), CONTRAINTE_UNDEFINED, dump_transformer, entity_local_name(), eq, ifdebug, make_predicate(), make_transformer(), NIL, pips_debug, sc_make(), transformer_undefined, VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by addition_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_equality_to_transformer()

transformer simple_equality_to_transformer	(	entity	e,
		entity	f,
		bool	assignment
	)

transformer.c

transformer.c

Parameters

assignment

ssignment

Definition at line 58 of file transformer.c.

{
  transformer tf = generic_equality_to_transformer(e, f, assignment, false);
 
  return tf;
}

References f(), and generic_equality_to_transformer().

Referenced by any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), c_user_function_call_to_transformer(), constant_to_transformer(), generic_reference_to_transformer(), logical_reference_to_transformer(), pointer_expression_to_transformer(), pointer_unary_operation_to_transformer(), and string_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_unary_minus_to_transformer()

transformer simple_unary_minus_to_transformer	(	entity	e,
		entity	f
	)

Definition at line 65 of file transformer.c.

{
  transformer tf = generic_equality_to_transformer(e, f, false, true);
 
  return tf;
}

References f(), and generic_equality_to_transformer().

Referenced by unary_minus_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_float_constraint()

Pvecteur simplify_float_constraint	(	Pvecteur	v,
		bool	is_equation_p
	)

If v is a not a float constraint, retun v.

If v is a float constraint, merge all float constants. If the constraint is trivially satisfied, return a NULL vector.

An integer constant cannot be mixed with floating point values

x!=0.

FI: do we want to represent 0. by 0?

Check that v is a feasible constraint

The new term must be the only one since vx is a new entity whose term cannot be cancelled by vect_add()

Unfeasible constraint

Parameters

is_equation_p

s_equation_p

Definition at line 2061 of file transformer.c.

{
  long double x = 0.;
  int occ = 0;
  bool is_float = true; // maybe a float constraint
  Pvecteur cv = VECTEUR_UNDEFINED;
  Pvecteur nv = VECTEUR_NUL;
 
  for(cv=v; !VECTEUR_UNDEFINED_P(cv) && is_float; cv = vecteur_succ(cv)) {
    entity e = (entity) vecteur_var(cv);
    Value val = vecteur_val(cv);
 
    if((Variable) e == TCST) {
      /* An integer constant cannot be mixed with floating point
         values */
      // pips_assert("x is zero", x==0.);
      is_float = false;
    }
    else if(entity_constant_p(e)) {
      if(float_constant_p(e)) {
        double d = float_constant_to_double(e);
        x += (long double)(val) * (long double) (d);
        occ++;
        if(val!=1)
          occ++;
        vect_add_elem(&nv, (Variable) e, -val);
      }
      else
        is_float = false;
    }
    else {
      type t = entity_type(e);
      if(float_type_p(t)) {
        ;
      }
      else {
        is_float = false;
      }
    }
  }
 
  if(is_float && vect_size(nv) > 0 && occ > 1 /* x!=0. */) {
    /* FI: do we want to represent 0. by 0? */
    if(x!=0.) {
      // FI: awfull precision loss...
      entity vx = float_to_entity((float) x>0?x:-x);
      // FI: let's try to move the constants on the right side,
      // i.e. the constant side, of the constraints
      // Might be independent of the constant sign
      // Avoid -(-6.) if a term is moved from one side to the other
      if(x>0)
        vect_add_elem(&nv, (Variable) vx, VALUE_ONE);
      else
        vect_add_elem(&nv, (Variable) vx, VALUE_MONE);
    }
    Pvecteur sv = vect_add(v, nv);
    vect_rm(v);
    vect_rm(nv);
    v = sv;
  }
 
  /* Check that v is a feasible constraint */
  if(vect_size(v)==1) {
    entity e = (entity) vecteur_var(v);
    /* The new term must be the only one since vx is a new entity
       whose term cannot be cancelled by vect_add() */
    if(e != (entity) TCST && entity_constant_p(e)) {
      if((!is_equation_p && x >0)
         || (is_equation_p && x!=0.)) {
        /* Unfeasible constraint */
        Pvecteur nv = vect_new(TCST, VALUE_ONE);
        vect_rm(v);
        v = nv;
      }
      else {
        vect_rm(v);
        v = VECTEUR_NUL;
      }
    }
  }
 
  return v;
}

References entity_constant_p, entity_type, float_constant_p(), float_constant_to_double(), float_to_entity(), float_type_p(), TCST, VALUE_MONE, VALUE_ONE, vect_add(), vect_add_elem(), vect_new(), vect_rm(), vect_size(), VECTEUR_NUL, vecteur_succ, VECTEUR_UNDEFINED, VECTEUR_UNDEFINED_P, vecteur_val, vecteur_var, and x.

Referenced by simplify_float_constraint_system().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_float_constraint_system()

Psysteme simplify_float_constraint_system

(

Psysteme

ps

)

Simplify float constraints and possibly detect.

Recompute the base, most of the time useless, but you cannot guess what happened in simplify_float_constraint()

Do not discard old values due to arguments... Just in case, keep too many floating point constants in the base. But add the new ones.

Parameters

ps

s

Definition at line 2146 of file transformer.c.

{
  Pcontrainte eq;
 
  for (eq = ps->egalites; eq != NULL; eq=eq->succ) {
    if (eq->vecteur) {
      eq->vecteur = simplify_float_constraint(eq->vecteur, true);
    }
  }
  for (eq = ps->inegalites; eq != NULL; eq=eq->succ) {
    if (eq->vecteur) {
      eq->vecteur = simplify_float_constraint(eq->vecteur, false);
    }
  }
 
  /* Recompute the base, most of the time useless, but you cannot
     guess what happened in simplify_float_constraint() */
  Pbase ob = sc_base(ps);
  Pbase nb = sc_to_minimal_basis(ps);
  /* Do not discard old values due to arguments... Just in case, keep
     too many floating point constants in the base. But add the new
     ones. */
  sc_base(ps) = base_union(ob, nb);
  sc_dimension(ps) = base_dimension(sc_base(ps));
  vect_rm(ob);
  vect_rm(nb);
 
  ifdebug(1) pips_assert("sc is consistent", sc_consistent_p(ps));
 
  return ps;
}

References base_dimension, base_union(), Ssysteme::egalites, eq, ifdebug, Ssysteme::inegalites, pips_assert, sc_consistent_p(), sc_to_minimal_basis(), simplify_float_constraint(), Scontrainte::succ, vect_rm(), and Scontrainte::vecteur.

Referenced by transformer_normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

sizeof_value_entity_p()

bool sizeof_value_entity_p

(

entity

e

)

Definition at line 969 of file value.c.

{
  string s = strstr(entity_local_name(e), SIZEOF_SUFFIX);
 
  return s!=NULL;
}

References entity_local_name(), and SIZEOF_SUFFIX.

Referenced by have_sizeof_value_in_multiply_pointer_expression_p(), pips_user_value_name(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

string_analyzed_p()

bool string_analyzed_p

(

void

)

Definition at line 310 of file value.c.

{
  return analyze_string_scalar_entities;
}

References analyze_string_scalar_entities.

Referenced by any_expression_to_transformer(), fortran_data_to_prec_for_variables(), and parametric_transformer_empty_p().

Here is the caller graph for this function:

sub_basis_p()

bool sub_basis_p	(	Pbase	b1,
		Pbase	b2
	)

FI: should be moved in base.c.

sub_basis_p(Pbase b1, Pbase b2): check if b1 is included in b2

Parameters

b1	1
b2	2

Definition at line 648 of file fix_point.c.

{
    bool is_a_sub_basis = true;
    Pbase t;
 
    for(t=b1; !VECTEUR_UNDEFINED_P(t) && is_a_sub_basis; t = t->succ) {
        is_a_sub_basis = base_contains_variable_p(b2, vecteur_var(t));
    }
 
    return is_a_sub_basis;
}

References b1, b2, base_contains_variable_p(), Svecteur::succ, VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by build_transfer_equations().

Here is the call graph for this function:

Here is the caller graph for this function:

test_mapping_entry_consistency()

void test_mapping_entry_consistency

(

void

)

This second assert is too strong when some analyzable variables are equivalenced together. The number of values required is smaller since two (or more) different variables share the same value: the number of entries in the tables is greater than the number of values. We must compute the number of values in each table.

Why greater instead of equal? Because the equivalence variable appears in the equivalence equations although it should never appear in regular constraints, except under its canonical name.

Definition at line 1113 of file value.c.

{
  int nbo = 0;
  int nbi = 0;
  int nbn = 0;
 
  pips_assert("The number of old values is equal to the number of intermediate values",
              ((nbo= hash_table_entry_count(hash_entity_to_old_value))
               == (nbi= hash_table_entry_count(hash_entity_to_intermediate_value))));
  /* This second assert is too strong when some analyzable variables are
     equivalenced together. The number of values required is smaller
     since two (or more) different variables share the same value: the
     number of entries in the tables is greater than the number of
     values. We must compute the number of values in each table.
  */
  /*
    pips_assert("The number of values is greater than the number"
    " of new, old and intermediate values",
    hash_table_entry_count(hash_value_to_name) >=
    hash_table_entry_count(hash_entity_to_new_value)
    + nbo + nbi);
  */
  nbo = mapping_to_value_number(hash_entity_to_old_value);
  nbi = mapping_to_value_number(hash_entity_to_intermediate_value);
  nbn = mapping_to_value_number(hash_entity_to_new_value);
 
  /* Why greater instead of equal? Because the equivalence variable
     appears in the equivalence equations although it should never
     appear in regular constraints, except under its canonical name. */
  pips_assert("The number of values with a name is greater than the number"
              " of new, old and intermediate values",
              hash_table_entry_count(hash_value_to_name) >=
              nbn + nbo + nbi);
}

References hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_table_entry_count(), hash_value_to_name, mapping_to_value_number(), and pips_assert.

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

transfer_equation_p()

bool transfer_equation_p

(

Pvecteur

eq

)

A transfer equation is an explicit equation giving one new value as a function of old values and a constant term.

Because we are using diophantine equations, the coefficient of the new value must one or minus one. We assume that the equation is reduced (i.e. gcd(coeffs) == 1).

FI: Non-unary coefficients may appear because equations were combined, for instance by a previous internal fix-point as in KINETI of mdg-fi.f (Perfect Club). Maybe, something could be done for these nested fix-points.

Parameters

eq

q

Definition at line 552 of file fix_point.c.

{
    Pvecteur t;
    int n_new = 0;
    Value coeff = VALUE_ZERO;
 
    for(t=eq; !VECTEUR_UNDEFINED_P(t) && n_new <= 1; t = t->succ) {
        entity e = (entity) vecteur_var(t);
 
        if( e != (entity) TCST && new_value_entity_p(e)) {
            coeff = vecteur_val(t);
            n_new++;
        }
    }
 
    return (n_new==1) && (value_one_p(coeff) || value_mone_p(coeff));
}

References eq, new_value_entity_p(), Svecteur::succ, TCST, value_mone_p, value_one_p, VALUE_ZERO, VECTEUR_UNDEFINED_P, vecteur_val, and vecteur_var.

Referenced by build_transfer_equations().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_3d_affine_constraint()

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.

Parameters

tf	f
a1	1
v1	1
a2	2
v2	2
a3	3
v3	3
cst	st
equation_p	quation_p

Definition at line 536 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v1, (Value) a1);
  vect_add_elem(&eq, (Variable) v2, (Value) a2);
  vect_add_elem(&eq, (Variable) v3, (Value) a3);
  vect_add_elem(&eq, TCST, (Value) cst);
 
  if(equation_p)
    tf = transformer_equality_add(tf, eq);
  else
    tf = transformer_inequality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_equality_add(), transformer_inequality_add(), vect_add_elem(), and vect_new().

Referenced by process_bounds_for_divide(), and update_cp_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_equality()

transformer transformer_add_equality	(	transformer	tf,
		entity	v1,
		entity	v2
	)

Add an equality between two values (two variables?)

Parameters

tf	f
v1	1
v2	2

Definition at line 436 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v1, (Value) 1);
 
  //pips_assert("v1 has values", entity_has_values_p(v1));
  //pips_assert("v2 has values", entity_has_values_p(v2));
 
  vect_add_elem(&eq, (Variable) v2, VALUE_MONE);
  tf = transformer_equality_add(tf, eq);
 
  return tf;
}

References eq, transformer_equality_add(), VALUE_MONE, vect_add_elem(), and vect_new().

Referenced by any_basic_update_operation_to_transformer(), assign_operation_to_transformer(), generic_abs_to_transformer(), generic_reference_to_transformer(), generic_unary_operation_to_transformer(), lhs_expression_to_transformer(), transformer_apply_field_assignments_or_equalities(), and update_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_equality_with_affine_term()

transformer transformer_add_equality_with_affine_term	(	transformer	tf,
		entity	v,
		entity	x,
		int	a,
		int	cst
	)

Add the equality v = a x + cst.

Parameters

tf	f
cst	st

Definition at line 517 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v, VALUE_ONE);
 
  vect_add_elem(&eq, (Variable) x, (Value) -a);
  vect_add_elem(&eq, TCST, (Value) -cst);
 
  tf = transformer_equality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_equality_add(), VALUE_ONE, vect_add_elem(), vect_new(), and x.

Referenced by generic_abs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_equality_with_integer_constant()

transformer transformer_add_equality_with_integer_constant	(	transformer	tf,
		entity	v,
		long long int	cst
	)

Add an equality between a value and an integer constant: v==cst.

Parameters

tf	f
cst	st

Definition at line 450 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v, VALUE_MONE);
 
  //pips_assert("v1 has values", entity_has_values_p(v1));
  //pips_assert("v2 has values", entity_has_values_p(v2));
 
  vect_add_elem(&eq, TCST, (Value) cst);
  tf = transformer_equality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_equality_add(), VALUE_MONE, vect_add_elem(), and vect_new().

Referenced by add_type_information(), bitwise_xor_to_transformer(), constant_to_transformer(), generic_abs_to_transformer(), integer_expression_to_transformer(), integer_left_shift_to_transformer(), integer_power_to_transformer(), logical_binary_function_to_transformer(), logical_expression_to_transformer(), logical_not_to_transformer(), modulo_by_a_constant_to_transformer(), modulo_of_a_constant_to_transformer(), and transformer_add_condition_information_updown().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_identity()

transformer transformer_add_identity	(	transformer	tf,
		entity	v
	)

Parameters

tf

f

Definition at line 421 of file basic.c.

{
  entity v_new = entity_to_new_value(v);
  entity v_old = entity_to_old_value(v);
  Pvecteur eq = vect_new((Variable) v_new, (Value) 1);
 
  vect_add_elem(&eq, (Variable) v_old, (Value) -1);
  tf = transformer_equality_add(tf, eq);
  transformer_arguments(tf) =
    arguments_add_entity(transformer_arguments(tf), v_new);
 
  return tf;
}

References arguments_add_entity(), entity_to_new_value(), entity_to_old_value(), eq, transformer_arguments, transformer_equality_add(), vect_add_elem(), and vect_new().

Here is the call graph for this function:

transformer_add_inequality()

transformer transformer_add_inequality	(	transformer	tf,
		entity	v1,
		entity	v2,
		bool	strict_p
	)

Add the equality v1 <= v2 or v1 < v2.

Parameters

tf	f
v1	1
v2	2
strict_p	trict_p

Definition at line 464 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v1, VALUE_ONE);
 
  vect_add_elem(&eq, (Variable) v2, VALUE_MONE);
  if(strict_p)
    vect_add_elem(&eq, TCST, VALUE_ONE);
  tf = transformer_inequality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_inequality_add(), VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by add_index_bound_conditions(), integer_left_shift_to_transformer(), and integer_multiply_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_inequality_with_affine_term()

transformer transformer_add_inequality_with_affine_term	(	transformer	tf,
		entity	v,
		entity	x,
		int	a,
		int	cst,
		bool	less_than_p
	)

Add the inequality v <= a x + cst or v >= a x + cst.

Parameters

tf	f
cst	st
less_than_p	ess_than_p

Definition at line 496 of file basic.c.

{
  Pvecteur eq = VECTEUR_NUL;
 
  if(less_than_p) {
    eq = vect_new((Variable) v, VALUE_ONE);
    vect_add_elem(&eq, (Variable) x, (Value) -a);
    vect_add_elem(&eq, TCST, (Value) -cst);
  }
  else {
    eq = vect_new((Variable) v, VALUE_MONE);
    vect_add_elem(&eq, TCST, (Value) cst);
    vect_add_elem(&eq, (Variable) x, (Value) a);
  }
 
  tf = transformer_inequality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_inequality_add(), VALUE_MONE, VALUE_ONE, vect_add_elem(), vect_new(), VECTEUR_NUL, and x.

Referenced by integer_left_shift_to_transformer(), integer_multiply_to_transformer(), and transformer_add_inequality_with_linear_term().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_inequality_with_integer_constraint()

transformer transformer_add_inequality_with_integer_constraint	(	transformer	tf,
		entity	v,
		long long int	cst,
		bool	less_than_p
	)

Add the inequality v <= cst or v >= cst.

Parameters

tf	f
cst	st
less_than_p	ess_than_p

Definition at line 477 of file basic.c.

{
  Pvecteur eq = vect_new((Variable) v, VALUE_ONE);
 
  if(less_than_p) {
    eq = vect_new((Variable) v, VALUE_ONE);
    vect_add_elem(&eq, TCST, (Value) -cst);
  }
  else {
    eq = vect_new((Variable) v, VALUE_MONE);
    vect_add_elem(&eq, TCST, (Value) cst);
  }
 
  tf = transformer_inequality_add(tf, eq);
 
  return tf;
}

References eq, TCST, transformer_inequality_add(), VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by add_type_information(), integer_call_expression_to_transformer(), integer_left_shift_to_transformer(), integer_minmax_to_transformer(), integer_power_to_transformer(), logical_binary_function_to_transformer(), logical_not_to_transformer(), modulo_by_a_constant_to_transformer(), modulo_of_a_constant_to_transformer(), modulo_of_a_negative_value_to_transformer(), modulo_of_a_positive_value_to_transformer(), and modulo_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_inequality_with_linear_term()

transformer transformer_add_inequality_with_linear_term	(	transformer	tf,
		entity	v,
		entity	x,
		int	a,
		bool	less_than_p
	)

Add the inequality v <= a x or v >= a x.

Parameters

tf	f
less_than_p	ess_than_p

Definition at line 530 of file basic.c.

{
  return transformer_add_inequality_with_affine_term(tf, v, x, a, VALUE_ZERO, less_than_p);
}

References transformer_add_inequality_with_affine_term(), VALUE_ZERO, and x.

Referenced by expression_multiply_sizeof_to_transformer(), integer_multiply_to_transformer(), and loop_to_enter_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_modified_variable()

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 the basis of sc.

Also, the variable should be transformed into a new value... See next function.

Should we check that var has values?

Parameters

tf	f
var	ar

Definition at line 889 of file basic.c.

{
  /* Should we check that var has values? */
  Psysteme sc =  (Psysteme) predicate_system(transformer_relation(tf));
  Pbase b = sc_base(sc);
 
  transformer_arguments(tf) = arguments_add_entity(transformer_arguments(tf), var);
  sc_base(sc) = vect_add_variable(b, (Variable) var);
  sc_dimension(sc) = base_dimension(sc_base(sc));
 
  return tf;
}

References arguments_add_entity(), base_dimension, predicate_system, transformer_arguments, transformer_relation, and vect_add_variable().

Referenced by any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), transformer_apply_field_assignments_or_equalities(), and transformer_apply_unknown_field_assignments_or_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_modified_variable_entity()

transformer transformer_add_modified_variable_entity	(	transformer	tf,
		entity	var
	)

FI: like the previous function, but supposed to end up with a consistent transformer.

When the transformer is empty/unfeasible, the variable is not added to conform to rules about standard empty transformer: how could a variable be updated by a non-existing transition?

FI: it is not well specifived if the argument should be made of new values or of progtram variables because up to now the two are the same, except when printed out.

Parameters

tf	f
var	ar

Definition at line 909 of file basic.c.

{
  if(!transformer_empty_p(tf)) {
    Psysteme sc =  (Psysteme) predicate_system(transformer_relation(tf));
    Pbase b = sc_base(sc);
 
    if(entity_has_values_p(var)) {
      entity v_new = entity_to_new_value(var);
      entity v_old = entity_to_old_value(var);
 
      /* FI: it is not well specifived if the argument should be made
         of new values or of progtram variables because up to now the
         two are the same, except when printed out. */
      transformer_arguments(tf) = arguments_add_entity(transformer_arguments(tf), var);
      sc_base(sc) = vect_add_variable(b, (Variable) v_new);
      sc_base(sc) = vect_add_variable(sc_base(sc), (Variable) v_old);
      sc_dimension(sc) = base_dimension(sc_base(sc));
    }
    else
      pips_internal_error("Entity \"%s\" has no values.", entity_name(var));
  }
 
  return tf;
}

References arguments_add_entity(), base_dimension, entity_has_values_p(), entity_name, entity_to_new_value(), entity_to_old_value(), pips_internal_error, predicate_system, transformer_arguments, transformer_empty_p(), transformer_relation, and vect_add_variable().

Referenced by safe_assigned_expression_to_transformer(), and safe_assigned_expression_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_sign_information()

transformer transformer_add_sign_information	(	transformer	tf,
		entity	v,
		int	v_sign
	)

CHANGE THIS NAME: no loop index please, it's not directly linked to loops!!!

Add in tf the information that v is striclty positive, strictly negative or zero.

Assume that v is a value and tf is defined.

v_sign<0

v_sign==0

Parameters

tf	f
v_sign	_sign

Definition at line 200 of file basic.c.

{
  Psysteme psyst = predicate_system(transformer_relation(tf));
 
  ifdebug(1) {
    pips_assert("Transformer tf is consistent on entrance",
                transformer_consistency_p(tf));
  }
 
  pips_assert("v is a value", value_entity_p(v) || local_temporary_value_entity_p(v));
 
  psyst->base = base_add_variable(psyst->base, (Variable) v);
  psyst->dimension = base_dimension(psyst->base);
 
  if(v_sign!=0) {
    Pvecteur cv;
    Pcontrainte ineq;
    if(v_sign>0) {
      cv = vect_new((Variable) v, VALUE_MONE);
      vect_add_elem(&cv, TCST, VALUE_ONE);
    }
    else {
      /* v_sign<0 */
      cv = vect_new((Variable) v, VALUE_ONE);
      vect_add_elem(&cv, TCST, VALUE_ONE);
    }
    ineq = contrainte_make(cv);
    sc_add_inegalite(psyst, ineq);
  }
  else {
    /* v_sign==0*/
    Pvecteur cv = vect_new((Variable) v, VALUE_ONE);
    Pcontrainte eq = contrainte_make(cv);
 
    sc_add_egalite(psyst, eq);
  }
 
  ifdebug(1) {
    pips_assert("Transformer tf is consistent on exit",
                transformer_consistency_p(tf));
  }
 
  return tf;
}

References Ssysteme::base, base_add_variable(), base_dimension, contrainte_make(), Ssysteme::dimension, eq, ifdebug, local_temporary_value_entity_p(), pips_assert, predicate_system, sc_add_egalite(), sc_add_inegalite(), TCST, transformer_consistency_p(), transformer_relation, value_entity_p(), VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by condition_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_value_update()

transformer transformer_add_value_update	(	transformer	t,
		entity	v
	)

Add an update of variable v to t (a value cannot be updated)

Definition at line 321 of file basic.c.

{
  entity nv = entity_to_new_value(v);
  entity ov = entity_to_old_value(v);
 
  if(!transformer_empty_p(t)) {
    Psysteme psyst = predicate_system(transformer_relation(t));
 
    transformer_arguments(t) = arguments_add_entity(transformer_arguments(t), v);
    if(!base_contains_variable_p(psyst->base, (Variable) nv))
      psyst->base = base_add_variable(psyst->base, (Variable) nv);
    if(!base_contains_variable_p(psyst->base, (Variable) ov))
      psyst->base = base_add_variable(psyst->base, (Variable) ov);
    psyst->dimension = vect_size(psyst->base);
  }
 
  return t;
}

References arguments_add_entity(), Ssysteme::base, base_add_variable(), base_contains_variable_p(), Ssysteme::dimension, entity_to_new_value(), entity_to_old_value(), predicate_system, transformer_arguments, transformer_empty_p(), transformer_relation, and vect_size().

Referenced by assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), c_return_to_transformer(), and transformer_add_variables_update().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_variable_incrementation()

transformer transformer_add_variable_incrementation	(	transformer	t,
		entity	i,
		Pvecteur	incr
	)

transformer transformer_add_loop_index(transformer t, entity i, Pvecteur incr): add the index incrementation expression incr for loop index i to transformer t.

t = intersection(t, i::new = i::old + incr)

incr is supposed to be compatible with the value mappings

Pvecteur incr should not be used after a call to transformer_add_index because it is shared by t and modified

Psysteme * ps = &((Psysteme) predicate_system(transformer_relation(t)));

Parameters

incr

ncr

Definition at line 260 of file basic.c.

{
    /* Psysteme * ps =
       &((Psysteme) predicate_system(transformer_relation(t))); */
    Psysteme psyst = predicate_system(transformer_relation(t));
    entity i_old = entity_to_old_value(i);
    entity i_new = entity_to_new_value(i);
    entity i_rep = value_to_variable(i_new);
 
    transformer_arguments(t) = arguments_add_entity(transformer_arguments(t), i_rep);
    psyst->base = vect_add_variable(psyst->base, (Variable) i_new);
    psyst->base = vect_add_variable(psyst->base, (Variable) i_old);
    psyst->dimension = vect_size(psyst->base);
    vect_chg_coeff(&incr, (Variable) i_new, -1);
    vect_chg_coeff(&incr, (Variable) i_old, 1);
    psyst = sc_equation_add(psyst, contrainte_make(incr));
 
    return t;
}

References arguments_add_entity(), Ssysteme::base, contrainte_make(), Ssysteme::dimension, entity_to_new_value(), entity_to_old_value(), predicate_system, sc_equation_add(), transformer_arguments, transformer_relation, value_to_variable(), vect_add_variable(), vect_chg_coeff(), and vect_size().

Referenced by transformer_add_loop_index_incrementation().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_variable_update()

transformer transformer_add_variable_update	(	transformer	t,
		entity	v
	)

Add an update of variable v into t.

NL : this function is not finish do the same thing than transformer_add_value_update for the moment TODO

Definition at line 289 of file basic.c.

{
  Psysteme psyst = predicate_system(transformer_relation(t));
  entity v_new = entity_to_new_value(v);
  entity v_old = entity_to_old_value(v);
  entity v_rep = value_to_variable(v_new);
 
  transformer_arguments(t) = arguments_add_entity(transformer_arguments(t), v_rep);
  if(!base_contains_variable_p(psyst->base, (Variable) v_new)) {
    psyst->base = base_add_variable(psyst->base, (Variable) v_new);
  }
  if(!base_contains_variable_p(psyst->base, (Variable) v_old)) {
    psyst->base = base_add_variable(psyst->base, (Variable) v_old);
  }
  psyst->dimension = vect_size(psyst->base);
 
//
//  pips_assert("before value substitution\n", transformer_consistency_p(t));
////  t = transformer_value_substitute(t, v_new, v_old);
//
//  pips_debug(9, "before tes\nt");
//  if(base_contains_variable_p(psyst->base, (Variable) v_new)) {
//    if(!base_contains_variable_p(psyst->base, (Variable) v_old)) {
//      pips_debug(9, "rename variable\n");
//      (void) sc_variable_rename(psyst,(Variable) v_new, (Variable)v_old);
//    }
//  }
//  pips_assert("after value substitution\n", transformer_consistency_p(t));
  return t;
}

References arguments_add_entity(), Ssysteme::base, base_add_variable(), base_contains_variable_p(), Ssysteme::dimension, entity_to_new_value(), entity_to_old_value(), predicate_system, transformer_arguments, transformer_relation, value_to_variable(), and vect_size().

Referenced by apply_abstract_effect_to_transformer(), apply_array_effect_to_transformer(), apply_concrete_effect_to_transformer(), generic_apply_effect_to_transformer(), and generic_reference_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_variables_update()

transformer transformer_add_variables_update	(	transformer	t,
		list	vl
	)

Parameters

vl

l

Definition at line 340 of file basic.c.

{
  FOREACH(ENTITY, v, vl) {
    transformer_add_value_update(t, v);  
  }
  return t;
}

References ENTITY, FOREACH, and transformer_add_value_update().

Referenced by c_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_affect_linear_p()

bool transformer_affect_linear_p	(	transformer	tf,
		Pvecteur	l
	)

bool transformer_affect_linear_p(transformer tf, Pvecteur l): returns TRUE if there is a state s such that eval(l, s) != eval(l, tf(s)); returns false if l is invariant w.r.t.

tf, i.e. for all state s, eval(l, s) == eval(l, tf(s))

Parameters

tf

f

Definition at line 1850 of file transformer.c.

{
    if (!transformer_undefined_p(tf)){
        list args = transformer_arguments(tf);
 
        MAP(ENTITY, e,
        {
            Value v = vect_coeff((Variable) e, l);
            if(value_notzero_p(v)) return true;
        },
            args);
    }
 
    return false;
}

References ENTITY, MAP, transformer_arguments, transformer_undefined_p, value_notzero_p, and vect_coeff().

Referenced by add_affine_bound_conditions(), add_loop_index_exit_value(), and transformer_affect_transformer_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_affect_transformer_p()

bool transformer_affect_transformer_p	(	transformer	tf1,
		transformer	tf2
	)

Transformer tf1 affects transformer tf2 if values modified by tf1 appear in any constraint of tf2.

The two transformer do not commute and tf1 o tf2 does not equal tf2 o tf1.

No need to check anything if tf1 does not change the memory state

Parameters

tf1	f1
tf2	f2

Definition at line 1870 of file transformer.c.

{
  bool affect_p = false;
 
  /* No need to check anything if tf1 does not change the memory state */
  if(!ENDP(transformer_arguments(tf1))) {
    Psysteme s2 = predicate_system(transformer_relation(tf2));
    Pcontrainte ceq = sc_egalites(s2);
    Pcontrainte cineq = sc_inegalites(s2);
 
    for(; !CONTRAINTE_UNDEFINED_P(ceq) && !affect_p; ceq = contrainte_succ(ceq)) {
      Pvecteur v = contrainte_vecteur(ceq);
      affect_p = transformer_affect_linear_p(tf1, v);
    }
 
    for(; !CONTRAINTE_UNDEFINED_P(cineq) && !affect_p; cineq = contrainte_succ(cineq)) {
      Pvecteur v = contrainte_vecteur(cineq);
      affect_p = transformer_affect_linear_p(tf1, v);
    }
  }
 
  return affect_p;
}

References contrainte_succ, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, ENDP, predicate_system, transformer_affect_linear_p(), transformer_arguments, and transformer_relation.

Referenced by transformer_safe_affect_transformer_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_apply()

transformer transformer_apply	(	transformer	tf,
		transformer	pre
	)

transformer transformer_apply(transformer tf, transformer pre): apply transformer tf on precondition pre to obtain postcondition post

post = tf(pre) = pre o tf

There is (should be!) no sharing between pre and tf. No sharing is introduced between pre or tf and post. Neither pre nor tf are modified.

post = tf o pre ; pre would be modified by transformer_combine

Parameters

tf	f
pre	re

Definition at line 1559 of file transformer.c.

{
    transformer post;
    transformer copy_pre;
 
    pips_debug(8,"begin\n");
    pips_assert("tf is not undefined", tf!=transformer_undefined);
    pips_debug(8,"tf=%p\n", tf);
    ifdebug(8) (void) dump_transformer(tf);
    pips_assert("pre is not undefined", pre!=transformer_undefined);
    pips_debug(8,"pre=%p\n", pre);
    ifdebug(8) (void) dump_transformer(pre);
 
    /* post = tf o pre ; pre would be modified by transformer_combine */
    copy_pre = transformer_dup(pre);
    post = transformer_combine(copy_pre, tf);
 
    pips_assert("post is not undefined", post!=transformer_undefined);
    pips_debug(8,"post=%p\n", post);
    ifdebug(8) (void) dump_transformer(post);
    pips_assert("unexpected sharing",post != pre);
    pips_debug(8,"end\n");
 
    return post;
}

References dump_transformer, ifdebug, pips_assert, pips_debug, transformer_combine(), transformer_dup(), and transformer_undefined.

Referenced by add_good_loop_conditions(), add_loop_index_exit_value(), add_loop_index_initialization(), addition_operation_to_transformer(), any_assign_to_transformer(), any_conditional_to_transformer(), any_expressions_to_transformer(), any_loop_to_k_transformer(), any_loop_to_postcondition(), any_transformer_to_k_closure(), any_user_call_site_to_transformer(), apply_transformer_lists_generic(), assign_rhs_to_reflhs_to_transformer(), bitwise_xor_to_transformer(), call_to_postcondition(), complete_forloop_transformer(), complete_forloop_transformer_list(), complete_loop_transformer(), complete_loop_transformer_list(), complete_repeatloop_transformer_list(), condition_to_transformer(), conditional_to_transformer(), cycle_to_flow_sensitive_preconditions(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), dag_to_flow_sensitive_preconditions(), declaration_to_transformer(), declaration_to_transformer_list(), dimensions_to_transformer(), expression_multiply_sizeof_to_transformer(), expression_to_postcondition(), expressions_to_transformer(), forloop_to_postcondition(), forloop_to_transformer(), integer_binary_operation_to_transformer(), integer_left_shift_to_transformer(), integer_multiply_to_transformer(), invariant_wrt_transformer(), loop_to_postcondition(), modulo_to_transformer(), new_add_formal_to_actual_bindings(), new_complete_whileloop_transformer_list(), new_loop_to_transformer(), precondition_minmax_of_expression(), process_ready_node(), repeatloop_to_postcondition(), statement_to_postcondition(), statement_to_transformer(), test_to_postcondition(), test_to_total_precondition(), test_to_transformer(), test_to_transformer_list(), transformer_add_any_relation_information(), transformer_add_condition_information_updown(), transformer_apply_generic(), transformer_list_closure_to_precondition_depth_two(), transformer_list_closure_to_precondition_max_depth(), transformer_safe_apply(), unstructured_to_postcondition(), unstructured_to_total_precondition(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

transformer_apply_generic()

list transformer_apply_generic	(	list	tl,
		transformer	pre,
		bool	keep_p
	)

Generates a new list of postconditions, one for each transformer in tl, unless the postcondition is empty and keep_p is FALSE.

keep_p is used to preserve the list lengths: the output list is exactly as long as the input list.

If keep_p is true, the output list is not "normalized"

Parameters

tl	l
pre	re
keep_p	eep_p

Definition at line 1593 of file transformer.c.

{
  list ntl = NIL;
  FOREACH(TRANSFORMER, tf, tl) {
    transformer post = transformer_apply(tf, pre);
 
    // Be careful with empty transformers that may creep out
 
    if(!transformer_empty_p(post) || keep_p)
      ntl = CONS(TRANSFORMER, post, ntl);
  }
  ntl = gen_nreverse(ntl);
  return ntl;
}

References CONS, FOREACH, gen_nreverse(), NIL, TRANSFORMER, transformer_apply(), and transformer_empty_p().

Referenced by transformer_apply_map(), transformers_apply(), and transformers_apply_and_keep_all().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_apply_map()

list transformer_apply_map	(	list	tl,
		transformer	pre
	)

Generates a new list of postconditions, one for each transformer in tl, unless the postcondition is empty.

Parameters

tl	l
pre	re

Definition at line 1610 of file transformer.c.

{
  return transformer_apply_generic(tl, pre, false);
}

References transformer_apply_generic().

Referenced by test_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_argument_consistency_p()

bool transformer_argument_consistency_p

(

transformer

t

)

Definition at line 551 of file basic.c.

{
  return transformer_argument_general_consistency_p(t, false);
}

References transformer_argument_general_consistency_p().

Referenced by transformer_add_any_relation_information(), and transformer_general_consistency_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_argument_general_consistency_p()

bool transformer_argument_general_consistency_p	(	transformer	t,
		bool	is_weak
	)

If no final state can be reached, no variable can be changed in between

If a variable appears as argument, its new value must be in the basis See for instance, effects_to_transformer()

pips_user_warning("No value for argument %s in relation basis\n", entity_name(e));

Parameters

is_weak

s_weak

Definition at line 561 of file basic.c.

{
  list args = transformer_arguments(t);
  bool consistent = true;
  Psysteme sc = (Psysteme) predicate_system(transformer_relation(t));
  Pbase b = sc_base(sc);
 
  /* If no final state can be reached, no variable can be changed in between */
  if(sc_empty_p(sc)) {
    consistent = ENDP(args);
    pips_assert("Empty transformer must have no arguments", consistent);
  }
  else if(!is_weak) {
    /* If a variable appears as argument, its new value must be in the basis
     * See for instance, effects_to_transformer()
     */
 
    MAP(ENTITY, e, {
      entity v = entity_to_new_value(e);
      /*
        pips_assert("Argument is in the basis", base_contains_variable_p(b, (Variable) v));
      */
      if(!base_contains_variable_p(b, (Variable) v)) {
        /* pips_user_warning("No value for argument %s in relation basis\n",
           entity_name(e)); */
        pips_internal_error("No value for argument %s in relation basis",
                            entity_name(e));
        consistent = false;
      }
    }, args);
    pips_assert("Argument variables must have values in basis", consistent);
  }
 
  return consistent;
}

References base_contains_variable_p(), ENDP, ENTITY, entity_name, entity_to_new_value(), MAP, pips_assert, pips_internal_error, predicate_system, sc_empty_p(), transformer_arguments, and transformer_relation.

Referenced by transformer_argument_consistency_p(), and transformer_argument_weak_consistency_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_argument_weak_consistency_p()

bool transformer_argument_weak_consistency_p

(

transformer

t

)

Definition at line 556 of file basic.c.

{
  return transformer_argument_general_consistency_p(t, true);
}

References transformer_argument_general_consistency_p().

Here is the call graph for this function:

transformer_arguments_projection()

transformer transformer_arguments_projection

(

transformer

t

)

transformer transformer_projection(transformer t); projection of t along the hyperplane defined by values of variables in arguments; this generate a projection and not a cylinder based on the projection

use the most complex/complete redundancy elimination in Linear

args is not modified. t is modified by side effects.

Definition at line 1285 of file transformer.c.

{
  list args = NIL;
  Psysteme sc = predicate_system(transformer_relation(t));
  Pbase b = sc_base(sc);
 
  MAP(ENTITY, a, {
    entity ov = entity_to_old_value(a);
    entity nv = entity_to_new_value(a);
 
    if(base_contains_variable_p(b, (Variable) ov))
      args = CONS(ENTITY, ov, args);
    if(base_contains_variable_p(b, (Variable)  nv))
      args = CONS(ENTITY, nv, args);
  }, transformer_arguments(t));
 
  t = transformer_projection(t, args);
  gen_free_list(args);
  return t;
}

References base_contains_variable_p(), CONS, ENTITY, entity_to_new_value(), entity_to_old_value(), gen_free_list(), MAP, NIL, predicate_system, transformer_arguments, transformer_projection(), and transformer_relation.

Here is the call graph for this function:

transformer_basic_fix_point()

transformer transformer_basic_fix_point

(

transformer

tf

)

Computation of a fix point: drop all constraints, remember which variables are changed.

Except if the transformer is syntactically empty since its fix point is easy to compute. Without normalization, mathematically empty transformers are lost.

get rid of equalities and inequalities but keep the basis

Parameters

tf

f

Definition at line 1280 of file fix_point.c.

{
  transformer fix_tf = copy_transformer(tf);
 
  if(!transformer_empty_p(tf)) {
    /* get rid of equalities and inequalities but keep the basis */
    Psysteme sc = predicate_system(transformer_relation(fix_tf));
    Pcontrainte eq = sc_egalites(sc);
    Pcontrainte ineq = sc_inegalites(sc);
    contraintes_free(eq);
    contraintes_free(ineq);
    sc_egalites(sc) = CONTRAINTE_UNDEFINED;
    sc_inegalites(sc) = CONTRAINTE_UNDEFINED;
    sc_nbre_egalites(sc) = 0;
    sc_nbre_inegalites(sc) = 0;
  }
 
  return fix_tf;
}

References CONTRAINTE_UNDEFINED, contraintes_free(), copy_transformer(), eq, predicate_system, transformer_empty_p(), and transformer_relation.

Referenced by select_fix_point_operator().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_combine()

transformer transformer_combine	(	volatile transformer	t1,
		transformer	t2
	)

transformer transformer_combine(transformer t1, transformer t2): compute the composition of transformers t1 and t2 (t1 then t2)

t1 := t2 o t1 return t1

t1 is updated, but t2 is preserved

general algorithm: let a1 be t1 arguments, a2 be t2 arguments, let ints be the intersection of a1 and a2 let r1 be t1 relation and r2 be a copy of t2 relation let a be a1 union a2 rename entities in ints in r1 (new->int) and r2 (old->int) rename entities in a2-ints in r1 (new->old) build a system b with r1 and r2 project b along ints build t1 with a and b

Handling of four special cases because abstract effects are likely to generate rn transformers, which lead to lots of variable projections if handled as a usual transformer. Not sufficient to solve Ticket 644. But sufficient to introduce lots of bugs...

not much to do since t1 is going to destroy all information in t2, except its range

not much to do since t2 is going to destroy all information in t1, except its domain

Standard case

Newgen does not generate the proper castings

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

ints: list of intermediate value entities

The consistencies of transformers t1 and t2 cannot be checked with respect to the current environment because t1 or t2 may be relative to a callee as in user_function_call_to_transformer(). Hence a debug level of 10.

both t1 and t2 are not obviously unfeasible

build new argument list and rename old and intermediate values, as well as new (i.e. unmodified) variables in t1

renaming of intermediate values in r1 and r2

if ever e2 is used as e2::new in r1 it must now be replaced by e2::old

e2 must be appended to a1 as new t1's arguments; hopefully we are not iterating on a1; but entity_is_argument_p() receives a longer argument each time; possible improvements?

build global linear system: r1 is destroyed, r2 is preserved

??? The base returned may be empty... FC... boumbadaboum in the projection later on.

get rid of intermediate values, if any. ??? guard added to avoid an obscure bug, but I guess it should never get here with en nil base... FC

CA

IER: problem with e_temp that should be volatile because of the catch structure. Not easy make it volatile because of the MAP MACRO

get rid of ints

update t1

No old values should be left in r1's basis.

Parameters

t1	1
t2	2

Definition at line 238 of file transformer.c.

{
  /* general algorithm:
     let a1 be t1 arguments, a2 be t2 arguments,
     let ints be the intersection of a1 and a2
     let r1 be t1 relation and r2 be a copy of t2 relation
     let a be a1 union a2
     rename entities in ints in r1 (new->int) and r2 (old->int)
     rename entities in a2-ints in r1 (new->old)
     build a system b with r1 and r2
     project b along ints
     build t1 with a and b
  */
  volatile list a1 = transformer_arguments(t1);
  list a2 = transformer_arguments(t2);
  list wvl = modified_variables_with_values();
 
  /* Handling of four special cases because abstract effects are
     likely to generate rn transformers, which lead to lots of
     variable projections if handled as a usual transformer. Not
     sufficient to solve Ticket 644. But sufficient to introduce lots
     of bugs... */
  if(transformer_is_rn_p(t1) && !ENDP(wvl) && arguments_set_equal_p(a1, wvl)) {
    if(transformer_is_empty_p(t2)) {
      free_transformer(t1);
      t1 = copy_transformer(t2); // t1 is empty
    }
    else {
      /* not much to do since t1 is going to destroy all information
         in t2, except its range */
      transformer r = transformer_range(t2);
      t1 = transformer_range_intersection(t1, r);
      free_transformer(r);
    }
  }
  else if(transformer_is_rn_p(t2) && !ENDP(wvl) && arguments_set_equal_p(a2, wvl)) {
    if(transformer_is_empty_p(t1))
      //t1 == t1;
      ;
    else {
      /* not much to do since t2 is going to destroy all information
         in t1, except its domain */
      transformer d = transformer_to_domain(t1);
      free_transformer(t1);
      t1 = transformer_domain_intersection(copy_transformer(t2), d);
      free_transformer(d);
    }
  }
  /* Standard case */
  else {
  /* Newgen does not generate the proper castings */
  /* Automatic variables read in a CATCH block need to be declared volatile as
   * specified by the documentation*/
  Psysteme volatile r1 = (Psysteme) predicate_system(transformer_relation(t1));
  Psysteme r2 = sc_dup((Psysteme)predicate_system(transformer_relation(t2)));
  /* ints: list of intermediate value entities */
  volatile list ints = NIL;
  list ce2;
 
  pips_debug(8,"begin\n");
 
  pips_debug(8,"arg. t1=%p\n",t1);
  ifdebug(8) (void) dump_transformer(t1);
  /* The consistencies of transformers t1 and t2 cannot be checked with
     respect to the current environment because t1 or t2 may be relative
     to a callee as in user_function_call_to_transformer(). Hence a
     debug level of 10. */
  ifdebug(10) pips_assert("consistent t1", transformer_consistency_p(t1));
 
  pips_debug(8,"arg. t2=%p\n",t2);
  ifdebug(8) (void) dump_transformer(t2);
  ifdebug(10) pips_assert("consistent t2", transformer_consistency_p(t2));
 
  if(!sc_empty_p(r1)) {
 
    if(sc_empty_p(r2)) {
      empty_transformer(t1);
    }
    else { /* both t1 and t2 are not obviously unfeasible */
 
    /* build new argument list and rename old and intermediate values,
       as well as new (i.e. unmodified) variables in t1 */
 
    for(ce2 = a2; !ENDP(ce2); POP(ce2)) {
      entity e2 = ENTITY(CAR(ce2));
      if(entity_is_argument_p(e2, a1)) {
        /* renaming of intermediate values in r1 and r2 */
        entity e_int = entity_to_intermediate_value(e2);
        entity e_old = entity_to_old_value(e2);
        r1 = sc_variable_rename(r1, (Variable) e2, (Variable) e_int);
        r2 = sc_variable_rename(r2, (Variable) e_old, (Variable) e_int);
        ints = arguments_add_entity(ints, e_int);
      }
      else {
        /* if ever e2 is used as e2#new in r1 it must now be
           replaced by e2#old */
        if(base_contains_variable_p(r1->base, (Variable) e2)) {
          entity e_old = entity_to_old_value(e2);
          r1 = sc_variable_rename(r1, (Variable) e2, (Variable) e_old);
        }
        /* e2 must be appended to a1 as new t1's arguments;
           hopefully we are not iterating on a1; but 
           entity_is_argument_p() receives a longer argument each time;
           possible improvements? */
        a1 = gen_nconc(a1, CONS(ENTITY, e2, NIL));
      }
    }
 
    /* build global linear system: r1 is destroyed, r2 is preserved
     */
    r1 = sc_append(r1, r2);
 
    /* ??? The base returned may be empty... FC...
     * boumbadaboum in the projection later on.
     */
    sc_rm(r2);
    r2 = SC_UNDEFINED;
    ifdebug(9) {
      pips_debug(9, "global linear system r1 before projection\n");
      sc_fprint(stderr, r1, (char * (*)(Variable)) dump_value_name);
      sc_dump(r1);
    }
 
    /* get rid of intermediate values, if any.
     * ??? guard added to avoid an obscure bug, but I guess it should
     * never get here with en nil base... FC
     */
    if (sc_base(r1)) {
      VOLATILE_FOREACH(ENTITY, e_temp, ints)
      {
        if (sc_expensive_projection_p(r1,(Variable) e_temp)) {
          ifdebug(9) {
            pips_debug(9, "expensive projection on %s with\n",
                       entity_local_name(e_temp));
            sc_fprint(stderr, r1, (char * (*)(Variable)) entity_local_name);
          }
          sc_elim_var(r1,(Variable) e_temp);
          sc_base_remove_variable(r1,(Variable) e_temp);
          ifdebug(9) {
            pips_debug(9, "simplified tranformer\n");
            sc_fprint(stderr, r1,(char * (*)(Variable)) entity_local_name);
          }
        }
        else {
          CATCH(overflow_error)
            {
              /* CA */
              /*PIER: problem with e_temp that should be volatile because of
              * the catch structure. Not easy make it volatile because of
              * the MAP MACRO */
              pips_user_warning("overflow error in projection of %s, "
                                "variable eliminated\n",
                                entity_name(e_temp));
              r1 = sc_elim_var(r1, (Variable) e_temp);
            }
          TRY
            {
              sc_and_base_projection_along_variable_ofl_ctrl
                (&r1, (Variable) e_temp, NO_OFL_CTRL);
              UNCATCH(overflow_error);
            }
 
          if (! sc_empty_p(r1)) {
            r1 = sc_normalize2(r1);
            if(SC_EMPTY_P(r1)) {
              r1 = sc_empty(BASE_NULLE);
              break;
            }
          }
        }
      }
    }
 
    ifdebug(9) {
      pips_debug(9, "global linear system r1 after projection\n");
      sc_fprint(stderr, r1, (char * (*)(Variable)) dump_value_name);
      sc_dump(r1);
    }
 
    /* get rid of ints */
    gen_free_list(ints);
    ints = NIL;
 
    /* update t1 */
    if(sc_empty_p(r1)) {
      /* No old values should be left in r1's basis. */
      MAP(ENTITY, v, {
        entity oldv = entity_to_old_value(v);
        if(base_contains_variable_p(sc_base(r1), (Variable) oldv))
          sc_base_remove_variable(r1, (Variable) oldv);
      }, a1);
      free_arguments(a1);
      transformer_arguments(t1) = NIL;
    }
    else {
      transformer_arguments(t1) = a1;
    }
    predicate_system(transformer_relation(t1)) = r1;
    }
  }
  }
 
  pips_debug(8,"res. t1=%p\n",t1);
  ifdebug(8) dump_transformer(t1);
  pips_debug(8,"end\n");
 
  return t1;
}

References arguments_add_entity(), arguments_set_equal_p(), Ssysteme::base, base_contains_variable_p(), BASE_NULLE, CAR, CATCH, CONS, copy_transformer(), dump_transformer, dump_value_name(), empty_transformer(), ENDP, ENTITY, entity_is_argument_p(), entity_local_name(), entity_name, entity_to_intermediate_value(), entity_to_old_value(), free_arguments(), free_transformer(), gen_free_list(), gen_nconc(), ifdebug, MAP, modified_variables_with_values(), NIL, NO_OFL_CTRL, overflow_error, pips_assert, pips_debug, pips_user_warning, POP, predicate_system, sc_append(), sc_base_remove_variable(), sc_dump(), sc_dup(), sc_elim_var(), sc_empty(), sc_empty_p(), sc_fprint(), sc_normalize2(), sc_rm(), sc_variable_rename(), transformer_arguments, transformer_consistency_p(), transformer_domain_intersection(), transformer_is_empty_p(), transformer_is_rn_p(), transformer_range(), transformer_range_intersection(), transformer_relation, transformer_to_domain(), TRY, UNCATCH, and VOLATILE_FOREACH.

Referenced by any_assign_operation_to_transformer(), any_assign_to_transformer(), any_conditional_to_transformer(), any_expression_side_effects_to_transformer(), any_expressions_side_effects_to_transformer(), any_expressions_to_transformer(), any_loop_to_k_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), any_transformer_to_k_closure(), any_user_call_site_to_transformer(), assign_rhs_to_reflhs_to_transformer(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), block_to_transformer(), block_to_transformer_list(), c_data_to_prec_for_variables(), c_user_call_to_transformer(), c_user_function_call_to_transformer(), combine_transformer_lists(), complete_any_loop_transformer_list(), complete_loop_transformer(), complete_loop_transformer_list(), complete_repeatloop_transformer_list(), condition_to_transformer(), conditional_to_transformer(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), declaration_to_transformer(), declaration_to_transformer_list(), declarations_to_transformer(), declarations_to_transformer_list(), dimensions_to_transformer(), expression_to_transformer(), expressions_to_transformer(), forloop_to_postcondition(), forloop_to_transformer(), fortran_data_to_prec_for_variables(), fortran_user_function_call_to_transformer(), generic_unary_operation_to_transformer(), integer_binary_operation_to_transformer(), integer_expression_to_transformer(), integer_multiply_to_transformer(), loop_to_continue_transformer(), loop_to_postcondition(), loop_to_total_precondition(), loop_to_transformer(), module_name_to_total_preconditions(), modulo_to_transformer(), old_complete_whileloop_transformer(), one_to_one_transformers_combine(), pointer_unary_operation_to_transformer(), propagate_preconditions_in_declarations(), repeatloop_to_transformer(), safe_assigned_expression_to_transformer(), struct_reference_assignment_or_equality_to_transformer(), transformer_add_any_relation_information(), transformer_add_call_condition_information_updown(), transformer_apply(), transformer_apply_field_assignments_or_equalities(), transformer_apply_unknown_field_assignments_or_equalities(), transformer_halbwachs_fix_point(), transformer_inverse_apply(), transformer_list_add_combination(), transformer_safe_combine_with_warnings(), transformers_combine(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

transformer_consistency_p()

bool transformer_consistency_p

(

transformer

t

)

FI: I do not know if this procedure should always return or fail when an inconsistency is found.

For instance, summary transformers for callees are inconsistent with respect to the current module. FC/CA: help...

I do not understand why errors are reported only if the debug level is greater than 1. A demo effect? No, this routine is coded that way to save time on regular runs.

Also, since no precise information about the inconsistency is displayed, a core dump would be welcome to retrieve pieces of information with gdb. The returned value should always be tested and a call to pips_internal_error() should always be performed if an inconsistency is detected.

But, see final comment... In spite of it, I do not always return any longer.

Definition at line 612 of file basic.c.

{
  return transformer_general_consistency_p(t, false);
}

References transformer_general_consistency_p().

Referenced by block_to_transformer(), block_to_transformer_list(), call_to_transformer(), declarations_to_transformer(), declarations_to_transformer_list(), generic_module_name_to_transformers(), initial_precondition(), loop_to_total_precondition(), module_name_to_total_preconditions(), move_transformer(), node_to_path_transformer_or_postcondition(), print_cycle_head_to_fixpoint(), program_postcondition(), program_precondition(), propagate_preconditions_in_declarations(), safe_assigned_expression_to_transformer(), statement_to_postcondition(), statement_to_total_precondition(), statement_to_transformer(), statement_to_transformer_list(), store_control_fix_point(), store_control_postcondition(), transformer_add_loop_index_incrementation(), transformer_add_sign_information(), transformer_combine(), transformer_derivative_fix_point(), transformer_internal_consistency_p(), transformer_inverse_apply(), transformer_list_closure_to_precondition(), transformer_list_closure_to_precondition_depth_two(), transformer_list_generic_transitive_closure(), transformer_list_multiple_closure_to_precondition(), transformer_normalize(), unstructured_to_flow_sensitive_postconditions(), and unstructured_to_flow_sensitive_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_constraint_add()

transformer transformer_constraint_add	(	transformer	tf,
		Pvecteur	i,
		bool	equality
	)

Parameters

tf	f
equality	quality

Definition at line 348 of file basic.c.

{
    Pcontrainte c;
    Psysteme sc; 
 
    pips_assert("tf is defined", tf != transformer_undefined
                && tf != (transformer) NULL);
 
    if(VECTEUR_NUL_P(i)) {
        user_warning("transformer_constraint_add",
                     "trivial constraint 0 %s 0 found: code should be optimized\n",
                     (equality)? "==" : "<=");
        return tf;
    }
 
    c = contrainte_make(i);
    sc = (Psysteme) predicate_system(transformer_relation(tf));
 
    sc = sc_constraint_add(sc, c, equality);
 
    return tf;
}

References contrainte_make(), pips_assert, predicate_system, sc_constraint_add(), transformer_relation, transformer_undefined, user_warning, and VECTEUR_NUL_P.

Referenced by transformer_equalities_add(), transformer_equality_add(), transformer_inequalities_add(), and transformer_inequality_add().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_convex_hull()

transformer transformer_convex_hull	(	transformer	t1,
		transformer	t2
	)

convex_hull.c

convex_hull.c

return transformer_convex_hulls(t1, t2, sc_enveloppe);

return transformer_convex_hulls(t1, t2, sc_enveloppe_chernikova);

return transformer_convex_hulls(t1, t2, sc_common_projection_convex_hull);

t1 = transformer_normalize(t1, 4);

t2 = transformer_normalize(t2, 4);

Parameters

t1	1
t2	2

Definition at line 216 of file convex_hull.c.

{
  /* return transformer_convex_hulls(t1, t2, sc_enveloppe);  */
  /* return transformer_convex_hulls(t1, t2, sc_enveloppe_chernikova); */
  /* return transformer_convex_hulls(t1, t2, sc_common_projection_convex_hull);
   */
/*   t1 = transformer_normalize(t1, 4); */
/*   t2 = transformer_normalize(t2, 4); */
  t1 = transformer_normalize(t1, 2);
  t2 = transformer_normalize(t2, 2);
  return transformer_convex_hulls(t1, t2, cute_convex_union);
}

References cute_convex_union(), transformer_convex_hulls(), and transformer_normalize().

Referenced by add_module_call_site_precondition(), any_assign_to_transformer(), any_basic_update_to_transformer(), any_conditional_to_transformer(), any_loop_to_k_transformer(), any_loop_to_postcondition(), any_transformer_to_k_closure(), any_update_to_transformer(), complete_loop_transformer(), complete_loop_transformer_list(), condition_to_transformer(), conditional_to_transformer(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), dag_to_flow_sensitive_preconditions(), generic_transformer_list_to_transformer(), generic_unary_operation_to_transformer(), get_control_precondition(), lhs_expression_to_transformer(), loop_body_transformer_add_entry_and_iteration_information(), loop_to_postcondition(), loop_to_total_precondition(), main(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), old_complete_whileloop_transformer(), points_to_unary_operation_to_transformer(), process_call_for_summary_precondition(), process_ready_node(), repeatloop_to_postcondition(), repeatloop_to_transformer(), statement_to_transformer(), statement_to_transformer_list(), struct_reference_assignment_or_equality_to_transformer(), test_to_postcondition(), test_to_total_precondition(), test_to_transformer(), transformer_add_anded_conditions_updown(), transformer_add_any_relation_information(), transformer_add_integer_relation_information(), transformer_add_ored_conditions_updown(), transformer_halbwachs_fix_point(), transformer_list_closure_to_precondition_depth_two(), transformer_list_closure_to_precondition_max_depth(), unstructured_to_flow_insensitive_transformer(), update_summary_precondition(), update_temporary_precondition(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_derivative_constraints()

Psysteme transformer_derivative_constraints

(

transformer

t

)

Allocate a new constraint system sc(dx) with dx=x'-x and t(x,x')

FI: this function should/might be located in fix_point.c

sc is going to be modified and returned

Do not handle variable which do not appear explicitly in constraints!

basis vector

Compute constraints with difference equations

Only generate difference equations if the old value is used

Project all variables but differences to get T'

Definition at line 891 of file transformer_list.c.

{
  Psysteme sc = sc_copy(predicate_system(transformer_relation(t)));
  /* sc is going to be modified and returned */
  /* Do not handle variable which do not appear explicitly in constraints! */
  Pbase b = sc_to_minimal_basis(sc);
  Pbase bv = BASE_NULLE; /* basis vector */
 
  /* Compute constraints with difference equations */
 
  for(bv = b; !BASE_NULLE_P(bv); bv = bv->succ) {
    entity oldv = (entity) vecteur_var(bv);
 
    /* Only generate difference equations if the old value is used */
    if(old_value_entity_p(oldv)) {
      entity var = value_to_variable(oldv);
      entity newv = entity_to_new_value(var);
      entity diffv = entity_to_intermediate_value(var);
      Pvecteur diff = VECTEUR_NUL;
      Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
      diff = vect_make(diff,
                       (Variable) diffv, VALUE_ONE,
                       (Variable) newv,  VALUE_MONE,
                       (Variable) oldv, VALUE_ONE,
                       TCST, VALUE_ZERO);
 
      eq = contrainte_make(diff);
      sc = sc_equation_add(sc, eq);
    }
  }
 
  ifdebug(8) {
    pips_debug(8, "with difference equations=\n");
    sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
  }
 
  /* Project all variables but differences to get T' */
 
  sc = sc_projection_ofl_along_variables(sc, b);
 
  ifdebug(8) {
    pips_debug(8, "Non-homogeneous constraints on derivatives=\n");
    sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
  }
 
  return sc;
}

References BASE_NULLE, BASE_NULLE_P, contrainte_make(), CONTRAINTE_UNDEFINED, entity_to_intermediate_value(), entity_to_new_value(), eq, external_value_name(), ifdebug, old_value_entity_p(), pips_debug, predicate_system, sc_copy(), sc_equation_add(), sc_fprint(), sc_to_minimal_basis(), Svecteur::succ, TCST, transformer_relation, VALUE_MONE, VALUE_ONE, value_to_variable(), VALUE_ZERO, vect_make(), VECTEUR_NUL, and vecteur_var.

Referenced by transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_derivative_fix_point()

transformer transformer_derivative_fix_point

(

transformer

tf

)

Computation of a transitive closure using constraints on the discrete derivative.

See http://www.cri.ensmp.fr/classement/doc/A-429.pdf

Implicit equations, n::new - n::old = 0, are not added. Instead, invariant constraints in tf are obtained by projection and added.

Intermediate values are used to encode the differences. For instance, i::int = i::new - i::old

I tried to use the standard procedure but arguments are not removed when the transformer tf is not feasible. Since we compute the * fix point and not the + fix point, the fix point is the identity.

sc is going to be modified and destroyed and eventually replaced in fix_tf

Do not handle variable which do not appear explicitly in constraints!

initial and final basis

basis vector

basis of difference vectors

Compute constraints with difference equations

Only generate difference equations if the old value is used

Project all variables but differences to get T'

Multiply the constant terms by the iteration number ik and add a positivity constraint for the iteration number ik and then eliminate the iteration number ik to get T*(dx).

Difference variables must substituted back to differences between old and new values.

Only generate difference equations if the old value is used

Project all difference variables

The full basis must be used again

Plug sc back into fix_tf

Add constraints about invariant variables. This could be avoided if implicit equalities were added before the derivative are processed: each invariant variable would generate an implicit null difference.

Such invariant constraints do not exist in general. We have them when array references are trusted.

This is wrong because we compute f* and not f+ and this is not true for the initial store.

What can be done instead is to refine fix_tf as :

dom(tf) U tf(fix_tf(dom(tf)))

But this fails because tf loops back to the beginning of the next iteration. Hence, the domain of tf implies two iterations instead of one. For instance, "i<n" becomes "i<=n-2" for a while loop such as "while(i<n) i++;".

So this refinement should be performed at a higher level where t_init and t_enter are know... so as to have:

dom_tf = transformer_range(t_enter(t_init)).

That's all!

Parameters

tf

f

Definition at line 1067 of file fix_point.c.

{
  transformer fix_tf = transformer_dup(tf);
 
  ifdebug(8) {
    pips_debug(8, "Begin for transformer %p:\n", tf);
    fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
  }
 
  if(transformer_empty_p(tf)) {
    /* I tried to use the standard procedure but arguments are not removed
       when the transformer tf is not feasible. Since we compute the * fix
       point and not the + fix point, the fix point is the identity. */
    free_transformer(fix_tf);
    fix_tf = transformer_identity();
  }
  else {
    //transformer inv_tf = transformer_undefined; /* invariant constraints of tf */
    /* sc is going to be modified and destroyed and eventually
       replaced in fix_tf */
    Psysteme sc = predicate_system(transformer_relation(fix_tf));
    /* Do not handle variable which do not appear explicitly in constraints! */
    Pbase b = sc_to_minimal_basis(sc);
    Pbase ib = base_dup(sc_base(sc)); /* initial and final basis */
    Pbase bv = BASE_NULLE; /* basis vector */
    Pbase diffb = BASE_NULLE; /* basis of difference vectors */
 
    /* Compute constraints with difference equations */
 
    for(bv = b; !BASE_NULLE_P(bv); bv = bv->succ) {
      entity oldv = (entity) vecteur_var(bv);
 
      /* Only generate difference equations if the old value is used */
      if(old_value_entity_p(oldv)) {
        entity var = value_to_variable(oldv);
        entity newv = entity_to_new_value(var);
        entity diffv = entity_to_intermediate_value(var);
        Pvecteur diff = VECTEUR_NUL;
        Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
        diff = vect_make(diff,
                         (Variable) diffv, VALUE_ONE,
                         (Variable) newv,  VALUE_MONE,
                         (Variable) oldv, VALUE_ONE,
                         TCST, VALUE_ZERO);
 
        eq = contrainte_make(diff);
        sc = sc_equation_add(sc, eq);
      }
    }
 
    ifdebug(8) {
      pips_debug(8, "with difference equations=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Project all variables but differences to get T' */
 
    sc = sc_projection_ofl_along_variables(sc, b);
 
    ifdebug(8) {
      pips_debug(8, "Non-homogeneous constraints on derivatives=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Multiply the constant terms by the iteration number ik and add a
       positivity constraint for the iteration number ik and then
       eliminate the iteration number ik to get T*(dx). */
    entity ik = make_local_temporary_integer_value_entity();
    //Psysteme sc_t_prime_k = sc_dup(sc);
    //sc_t_prime_k = sc_multiply_constant_terms(sc_t_prime_k, (Variable) ik);
    sc = sc_multiply_constant_terms(sc, (Variable) ik, true);
    //Psysteme sc_t_prime_star = sc_projection_ofl(sc_t_prime_k, (Variable) ik);
    sc = sc_projection_ofl(sc, (Variable) ik);
    sc->base = base_remove_variable(sc->base, (Variable) ik);
    sc->dimension--;
    // FI: I do not remember nor find how to get rid of local values...
    //sc_rm(sc);
    //sc = sc_t_prime_star;
 
    ifdebug(8) {
      pips_debug(8, "All invariants on derivatives=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Difference variables must substituted back to differences
     * between old and new values.
     */
 
    for(bv = b; !BASE_NULLE_P(bv); bv = bv->succ) {
      entity oldv = (entity) vecteur_var(bv);
 
      /* Only generate difference equations if the old value is used */
      if(old_value_entity_p(oldv)) {
        entity var = value_to_variable(oldv);
        entity newv = entity_to_new_value(var);
        entity diffv = entity_to_intermediate_value(var);
        Pvecteur diff = VECTEUR_NUL;
        Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
        diff = vect_make(diff,
                         (Variable) diffv, VALUE_ONE,
                         (Variable) newv,  VALUE_MONE,
                         (Variable) oldv, VALUE_ONE,
                         TCST, VALUE_ZERO);
 
        eq = contrainte_make(diff);
        sc = sc_equation_add(sc, eq);
        diffb = base_add_variable(diffb, (Variable) diffv);
      }
    }
 
    ifdebug(8) {
      pips_debug(8,
                 "All invariants on derivatives with difference variables=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Project all difference variables */
 
    sc = sc_projection_ofl_along_variables(sc, diffb);
 
    ifdebug(8) {
      pips_debug(8, "All invariants on differences=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* The full basis must be used again */
    base_rm(sc_base(sc)), sc_base(sc) = BASE_NULLE;
    sc_base(sc) = ib;
    sc_dimension(sc) = vect_size(ib);
    base_rm(b), b = BASE_NULLE;
 
    ifdebug(8) {
      pips_debug(8, "All invariants with proper basis =\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Plug sc back into fix_tf */
    predicate_system(transformer_relation(fix_tf)) = sc;
 
    /* Add constraints about invariant variables. This could be avoided if
       implicit equalities were added before the derivative are processed:
       each invariant variable would generate an implicit null
       difference.
 
       Such invariant constraints do not exist in general. We have them when
       array references are trusted.
 
       This is wrong because we compute f* and not f+ and this is not true
       for the initial store.
 
    */
    /*
       inv_tf = transformer_arguments_projection(transformer_dup(tf));
       fix_tf = transformer_image_intersection(fix_tf, inv_tf);
       free_transformer(inv_tf);
    */
 
    /* What can be done instead is to refine fix_tf as :
     *
     * dom(tf) U tf(fix_tf(dom(tf)))
     *
     * But this fails because tf loops back to the beginning of the
     * next iteration. Hence, the domain of tf implies *two*
     * iterations instead of one. For instance, "i<n" becomes "i<=n-2"
     * for a while loop such as "while(i<n) i++;".
     *
     * So this refinement should be performed at a higher level where
     * t_init and t_enter are know... so as to have:
     *
     * dom_tf = transformer_range(t_enter(t_init)).
     */
    /*
    transformer dom_tf = transformer_to_domain(tf);
    transformer tf_plus = transformer_combine(copy_transformer(dom_tf), fix_tf);
    tf_plus = transformer_combine(tf_plus, tf);
    free_transformer(fix_tf);
    fix_tf = transformer_convex_hull(dom_tf, tf_plus);
    free_transformer(dom_tf);
    free_transformer(tf_plus);
    */
  }
  /* That's all! */
 
  ifdebug(8) {
    pips_debug(8, "fix-point fix_tf=\n");
    fprint_transformer(stderr, fix_tf, (get_variable_name_t) external_value_name);
    transformer_consistency_p(fix_tf);
    pips_debug(8, "end\n");
  }
 
  return fix_tf;
}

Referenced by transformers_derivative_fix_point().

Here is the caller graph for this function:

transformer_domain_intersection()

transformer transformer_domain_intersection	(	transformer	tf,
		transformer	pre
	)

Restrict the domain of the relation tf with pre.

pre is assumed to be restricted to a store predicate: its argument list must be empty.

For a restriction on the image of tf, see transformer_image_intersection

tf is updated by side effect although transformer_image_intersection() allocates a fresh new transformer.

if a value in pre is modified by tf, it must be renamed as an old value

transformer dom is not consistent since it references old values but has no arguments

Parameters

tf	f
pre	re

Definition at line 661 of file transformer.c.

{
  transformer dom = transformer_dup(pre);
  transformer tf_inter = transformer_undefined;
 
  pips_assert("pre does not involve old values and has no arguments",
              ENDP(transformer_arguments(pre)));
 
  pips_debug(9, "Begin with tf=%p and pre=%p\n", tf, pre);
 
  /* if a value in pre is modified by tf, it must be renamed as an old
     value */
  MAP(ENTITY, a, {
    entity na = entity_to_new_value(a);
    entity oa = entity_to_old_value(a);
    Psysteme pre_sc = predicate_system(transformer_relation(dom));
    pre_sc = sc_variable_rename(pre_sc, (Variable) na, (Variable) oa);
  }, transformer_arguments(tf));
 
  /* transformer dom is not consistent since it references old values but
     has no arguments */
 
  tf_inter = transformer_image_intersection(tf, dom);
  tf = move_transformer(tf, tf_inter);
  free_transformer(dom);
 
  return tf;
}

References ENDP, ENTITY, entity_to_new_value(), entity_to_old_value(), free_transformer(), MAP, move_transformer(), pips_assert, pips_debug, predicate_system, sc_variable_rename(), transformer_arguments, transformer_dup(), transformer_image_intersection(), transformer_relation, and transformer_undefined.

Referenced by loop_body_transformer_add_entry_and_iteration_information(), loop_to_transformer(), statement_to_transformer(), statement_to_transformer_list(), transformer_combine(), and transformer_safe_domain_intersection().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_dup()

transformer transformer_dup

(

transformer

t_in

)

cproto-generated files

basic.c

cproto-generated files

Francois Irigoin

FI: I do not reduce transformer_dup() to a macro calling copy_transformer() because I do not want to create problems with the link edit and because I want to keep the assertion

Parameters

t_in

_in

Definition at line 49 of file basic.c.

{
    /* FI: I do not reduce transformer_dup() to a macro calling
       copy_transformer() because I do not want to create problems with
       the link edit and because I want to keep the assertion */
 
    Psysteme sc = SC_UNDEFINED;
    transformer t_out;
 
    pips_assert("transformer t_in is not undefined", t_in != transformer_undefined);
 
    sc = (Psysteme) predicate_system(transformer_relation(t_in));
    pips_assert("transformer_dup", !SC_UNDEFINED_P(sc));
    t_out = copy_transformer(t_in);
 
    return t_out;
}

References copy_transformer(), pips_assert, predicate_system, transformer_relation, and transformer_undefined.

Referenced by add_index_bound_conditions(), add_loop_index_exit_value(), any_transformer_to_k_closure(), block_to_postcondition(), block_to_total_precondition(), block_to_transformer(), call_site_to_module_precondition_text(), call_to_summary_precondition(), check_condition_wrt_precondition(), comp_regions_of_implied_do(), complete_loop_transformer(), complete_loop_transformer_list(), cycle_to_flow_sensitive_preconditions(), dag_to_flow_sensitive_preconditions(), declarations_to_transformer(), declarations_to_transformer_list(), eval_condition_wrt_precondition_p(), forloop_to_postcondition(), fortran_user_call_to_transformer(), generic_module_name_to_transformers(), generic_transformer_intra_to_inter(), integer_expression_and_precondition_to_integer_interval(), interprocedural_abc_arrays(), load_arc_precondition(), loop_to_postcondition(), loop_to_total_precondition(), loop_to_transformer(), module_name_to_total_preconditions(), old_complete_whileloop_transformer(), precondition_to_abstract_store(), process_call_for_summary_precondition(), process_ready_node(), program_precondition(), propagate_preconditions_in_declarations(), recompute_loop_transformer(), standard_whileloop_to_transformer(), test_to_postcondition(), test_to_transformer(), test_to_transformer_list(), transformer_add_anded_conditions_updown(), transformer_add_any_relation_information(), transformer_add_integer_relation_information(), transformer_add_ored_conditions_updown(), transformer_apply(), transformer_convex_hulls(), transformer_derivative_fix_point(), transformer_domain_intersection(), transformer_equality_fix_point(), transformer_halbwachs_fix_point(), transformer_inverse_apply(), transformer_pattern_fix_point(), transformer_range(), transformer_to_domain(), unstructured_continuation_conditions(), unstructured_to_postcondition(), unstructured_to_postconditions(), unstructured_to_total_precondition(), unstructured_to_transformer(), update_summary_precondition(), update_temporary_precondition(), and whileloop_to_postcondition().

Here is the call graph for this function:

transformer_empty()

transformer transformer_empty

(

void

)

Allocate an empty transformer.

Definition at line 120 of file basic.c.

{
    return make_transformer(NIL,
                            make_predicate(sc_empty(BASE_NULLE)));
}

References BASE_NULLE, make_predicate(), make_transformer(), NIL, and sc_empty().

Referenced by add_index_range_conditions(), block_continuation_conditions(), call_continuation_conditions(), complete_repeatloop_transformer_list(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), expression_multiply_sizeof_to_transformer(), generic_transformer_list_to_transformer(), get_control_precondition(), integer_binary_operation_to_transformer(), intrinsic_to_transformer(), intrinsic_to_transformer_list(), load_arc_precondition(), loop_continuation_conditions(), loop_to_postcondition(), loop_to_total_precondition(), module_summary_continuation_conditions(), modulo_of_a_constant_to_transformer(), modulo_to_transformer(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), new_substitute_stubs_in_transformer(), ordinary_summary_precondition(), pointer_binary_operation_to_transformer(), points_to_unary_operation_to_transformer(), precondition_intra_to_inter(), process_bounds_for_divide(), process_unreachable_node(), ready_to_be_processed_p(), repeatloop_to_postcondition(), standard_whileloop_to_transformer(), statement_to_total_precondition(), summary_total_postcondition(), test_continuation_conditions(), transformer_add_call_condition_information_updown(), transformer_add_condition_information_updown(), transformer_general_intersection(), transformer_list_generic_transitive_closure(), unstructured_continuation_conditions(), unstructured_to_flow_insensitive_transformer(), unstructured_to_postconditions(), unstructured_to_transformer(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_empty_p()

bool transformer_empty_p

(

transformer

t

)

If true is returned, the transformer certainly is empty.

If false is returned, the transformer still might be empty, but it's not too likely...

Well, k <= 2 and k >= 3 does not return empty in spite of sc_strong_normalize()... sc_bounded_normalization() should be used at a cost of O(n)

See also transformer_is_empty_p() for a simple quick syntactic check

Definition at line 2455 of file transformer.c.

{
    bool empty_p = parametric_transformer_empty_p(t, sc_strong_normalize4);
    return empty_p;
}

References parametric_transformer_empty_p(), and sc_strong_normalize4().

Referenced by apply_transformer_lists_generic(), block_to_transformer_list(), check_condition_wrt_precondition(), check_transformer_list(), clean_up_transformer_list(), combine_transformer_lists(), eval_condition_wrt_precondition_p(), fortran_user_call_to_transformer(), generic_module_name_to_transformers(), instruction_to_transformer_list(), integer_binary_operation_to_transformer(), integer_multiply_to_transformer(), logical_binary_function_to_transformer(), main_summary_precondition(), precondition_intra_to_inter(), process_unreachable_node(), ready_to_be_processed_p(), simplify_boolean_expression_with_precondition(), standard_whileloop_to_transformer(), statement_feasible_p(), transformer_add_modified_variable_entity(), transformer_add_value_update(), transformer_apply_generic(), transformer_basic_fix_point(), transformer_convex_hulls(), transformer_derivative_fix_point(), transformer_equality_fix_point(), transformer_general_intersection(), transformer_list_add_combination(), transformer_projection_with_redundancy_elimination_and_check(), transformers_combine(), two_transformers_to_list(), unstructured_to_postcondition(), unstructured_to_total_precondition(), and unstructured_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_equalities_add()

transformer transformer_equalities_add	(	transformer	tf,
		Pcontrainte	eqs
	)

please, do not introduce any sharing at the Pcontrainte level you do not know how they have to be chained in diferent transformers; do not introduce any sharing at the Pvecteur level; I'm not sure it's so useful, but think of what would happen if one transformer is renamed...

Parameters

tf	f
eqs	qs

Definition at line 391 of file basic.c.

{
    /* please, do not introduce any sharing at the Pcontrainte level
       you do not know how they have to be chained in diferent transformers;
       do not introduce any sharing at the Pvecteur level; I'm not
       sure it's so useful, but think of what would happen if one transformer
       is renamed... */
    for(;eqs!=CONTRAINTE_UNDEFINED; eqs = eqs->succ)
        (void) transformer_constraint_add(tf, 
                                          vect_dup(contrainte_vecteur(eqs)),
                                          true);
    return tf;
}

References CONTRAINTE_UNDEFINED, contrainte_vecteur, Scontrainte::succ, transformer_constraint_add(), and vect_dup().

Referenced by tf_equivalence_equalities_add().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_equality_add()

transformer transformer_equality_add	(	transformer	tf,
		Pvecteur	i
	)

Parameters

tf

f

Definition at line 383 of file basic.c.

{
    return transformer_constraint_add(tf, i, true);
}

References transformer_constraint_add().

Referenced by add_loop_index_exit_value(), add_type_information(), bitwise_xor_to_transformer(), expression_multiply_sizeof_to_transformer(), formal_and_actual_parameters_association(), fortran_data_to_prec_for_variables(), integer_left_shift_to_transformer(), integer_multiply_to_transformer(), logical_unary_operation_to_transformer(), transformer_add_3d_affine_constraint(), transformer_add_condition_information_updown(), transformer_add_equality(), transformer_add_equality_with_affine_term(), transformer_add_equality_with_integer_constant(), transformer_add_identity(), and transformer_add_integer_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_equality_fix_point()

transformer transformer_equality_fix_point

(

transformer

tf

)

Let A be the affine loop transfert function.

The affine transfer fix-point T is such that T(A-I) = 0

T A = 0 also gives a fix-point when merged with the initial state. It can only be used to compute preconditions.

Algorithm (let H be A's Smith normal form):

A = A - I (if necessary) H = P A Q A = P^-1 H Q^-1 T A = T P^-1 H Q^-1 = 0 T P^-1 H = 0 (by multipliying by Q)

Soit X t.q. X H = 0 A basis for all solutions is given by X chosen such that X is a rectangular matrix (0 I) selecting the zero submatrix of H

T P^-1 = X T = X P

Note: I (FI) believe this functions is wrong because it does not return the appropriate arguments. The fix point transformer should modify as many variables as the input tf. A new basis should not be recomputed according to the transition matrix. This problem seems to be fixed in the callers, see loop_to_transformer() and whileloop_to_transformer().

result

do not modify an input argument

number of transfer equalities plus the homogeneous constraint which states that 1 == 1

use a matrix a to store these equalities in a dense form

Pbase t = BASE_UNDEFINED;

If the input transformer is not feasible, so is not its fixpoint because the number of iterations may be zero which implies identity.

fix_tf = transformer_identity();

find or build explicit transfer equations: v::new = f(v1::old, v2::old,...) and the corresponding sub-basis

FI: for each constant variable, whose constance is implictly implied by not having it in the argument field, an equation should be added...

lieq = build_implicit_equalities(tf); lieq->succ = leq; leq = lieq;

build matrix a from lteq and b_new: this should be moved in a function

Subtract the identity matrix

Compute the Smith normal form: H = P A Q

Find out the number of invariants n_inv

Convert p's last n_inv rows into constraints

FI: maybe I should retrieve fix_tf system...

is it a non-trivial invariant?

Set fix_tf's argument list

Fix the basis and the dimension

get rid of dense matrices

Parameters

tf

f

Definition at line 266 of file fix_point.c.

{
    /* result */
    transformer fix_tf = transformer_identity();
 
    /* do not modify an input argument */
    transformer tf_copy = transformer_dup(tf);
 
    /* number of transfer equalities plus the homogeneous constraint which
       states that 1 == 1 */
    int n_eq = 1;
    /* use a matrix a to store these equalities in a dense form */
    matrice a = MATRICE_UNDEFINED;
    matrice h = MATRICE_UNDEFINED;
    matrice p = MATRICE_UNDEFINED;
    matrice q = MATRICE_UNDEFINED;
    Pbase b_new = BASE_NULLE;
    Pcontrainte lteq = CONTRAINTE_UNDEFINED;
    Pcontrainte leq = sc_egalites((Psysteme) predicate_system(transformer_relation(tf_copy)));
 
    Psysteme sc_inv = SC_UNDEFINED;
    int n_inv = 0;
 
    int i = 0;
    /* Pbase t = BASE_UNDEFINED; */
 
    ifdebug(8) {
        pips_debug(8, "begin for transformer %p\n", tf);
        fprint_transformer(stderr, tf,
                           (get_variable_name_t) external_value_name);
    }
 
    /* If the input transformer is not feasible, so is not its fixpoint
     * because the number of iterations may be zero which implies identity.
     */
    if(transformer_empty_p(tf)) {
      /* fix_tf = transformer_identity(); */
        ifdebug(8) {
            pips_debug(8, "fix-point fix_tf=\n");
            fprint_transformer(stderr, fix_tf,
                               (get_variable_name_t) external_value_name);
            pips_debug(8, "end\n");
        }
        return fix_tf;
    }
 
    /* find or build explicit transfer equations: v#new = f(v1#old, v2#old,...)
     * and the corresponding sub-basis
     *
     * FI: for each constant variable, whose constance is implictly
     * implied by not having it in the argument field, an equation
     * should be added...
     *
     * lieq = build_implicit_equalities(tf);
     * lieq->succ = leq;
     * leq = lieq;
     */
    build_transfer_equations(leq, &lteq, &b_new);
 
    /* build matrix a from lteq and b_new: this should be moved in a function */
    n_eq = base_dimension(b_new)+1;
    build_transfer_matrix(&a , lteq, n_eq, b_new);
    ifdebug(8) {
        pips_debug(8, "transfer matrix:\n");
        matrice_fprint(stderr, a, n_eq, n_eq);
    }
 
    /* Subtract the identity matrix */
    for(i=1; i<= n_eq; i++) {
        value_substract(ACCESS(a, n_eq, i, i),VALUE_ONE);
    }
 
    /* Compute the Smith normal form: H = P A Q */
    h = matrice_new(n_eq, n_eq);
    p = matrice_new(n_eq, n_eq);
    q = matrice_new(n_eq, n_eq);
    DENOMINATOR(h) = VALUE_ONE;
    DENOMINATOR(p) = VALUE_ONE;
    DENOMINATOR(q) = VALUE_ONE;
    matrice_smith(a, n_eq, n_eq, p, h, q);
 
    ifdebug(8) {
        pips_debug(8, "smith matrix h=p.a.q:\n");
        matrice_fprint(stderr, h, n_eq, n_eq);
        pips_debug(8, "p  matrix:\n");
        matrice_fprint(stderr, p, n_eq, n_eq);
        pips_debug(8, "q  matrix:\n");
        matrice_fprint(stderr, q, n_eq, n_eq);
    }
 
    /* Find out the number of invariants n_inv */
    for(i=1; i <= n_eq &&
            value_notzero_p(ACCESS(h, n_eq, i, i)) ; i++)
        ;
    n_inv = n_eq - i + 1;
    pips_debug(8, "number of useful invariants: %d\n", n_inv-1);
    pips_assert("n_inv>=1", n_inv >= 1);
 
    /* Convert p's last n_inv rows into constraints */
    /* FI: maybe I should retrieve fix_tf system... */
    sc_inv = sc_new();
 
    for(i = n_eq - n_inv + 1 ; i <= n_eq; i++) {
        int j;
        /* is it a non-trivial invariant? */
        for(j=1; j<= n_eq-1 && value_zero_p(ACCESS(p, n_eq, i, j)); j++)
            ;
        if( j != n_eq) {
            Pvecteur v_inv = VECTEUR_NUL;
            Pcontrainte c_inv = CONTRAINTE_UNDEFINED;
 
            for(j = 1; j<= n_eq; j++) {
                Value coeff = ACCESS(p, n_eq, i, j);
 
                if(value_notzero_p(coeff)) {
                    entity n_eb = (entity) variable_of_rank(b_new, j);
                    entity o_eb = new_value_to_old_value(n_eb);
 
                    vect_add_elem(&v_inv, (Variable)n_eb, coeff);
                    vect_add_elem(&v_inv, (Variable)o_eb, value_uminus(coeff));
                }
            }
            c_inv = contrainte_make(v_inv);
            sc_add_egalite(sc_inv, c_inv);
        }
    }
 
    sc_creer_base(sc_inv);
 
    ifdebug(8) {
        pips_debug(8, "fix-point sc_inv=\n");
        sc_fprint(stderr, sc_inv, (char * (*)(Variable)) external_value_name);
        pips_debug(8, "end\n");
    }
 
    /* Set fix_tf's argument list */
    /*
    for(t = b_new; !BASE_NULLE_P(t); t = t->succ) {
        I should use a conversion function from value_to_variable()
        entity arg = (entity) vecteur_var(t);
 
        transformer_arguments(fix_tf) = arguments_add_entity(transformer_arguments(fix_tf), arg);
    }
    */
    transformer_arguments(fix_tf) = dup_arguments(transformer_arguments(tf));
    /* Fix the basis and the dimension */
    sc_base(sc_inv) = base_dup(sc_base(predicate_system(transformer_relation(tf))));
    sc_dimension(sc_inv) = sc_dimension(predicate_system(transformer_relation(tf)));
    transformer_relation(fix_tf) = make_predicate(sc_inv);
 
    /* get rid of dense matrices */
    matrice_free(a);
    matrice_free(h);
    matrice_free(p);
    matrice_free(q);
 
    free_transformer(tf_copy);
 
    ifdebug(8) {
        pips_debug(8, "fix-point fix_tf=\n");
        fprint_transformer(stderr, fix_tf, (get_variable_name_t) external_value_name);
        pips_debug(8, "end\n");
    }
 
    return fix_tf;
}

transformer_equations_constrain_variable_p()

bool transformer_equations_constrain_variable_p	(	const	transformer,
		const	entity
	)

Is value v used with a non-zero coefficient by the equations of transformer t?

Definition at line 963 of file basic.c.

{
  Psysteme sc = (Psysteme) predicate_system(transformer_relation(t));
  return sc_equations_constrain_variable_p(sc, (Variable) v);
}

References predicate_system, sc_equations_constrain_variable_p(), and transformer_relation.

Here is the call graph for this function:

transformer_filter()

transformer transformer_filter	(	transformer	t,
		list	args
	)

transformer transformer_filter(transformer t, cons * args): projection of t along the hyperplane defined by entities in args; this generate a projection and not a cylinder based on the projection;

if the relation associated to t is empty, t is not modified although it should have a basis and this basis should be cleaned up. Since no basis is carried in the current implementation of an empty system, this cannot be performed (FI, 7/12/92).

formal argument args is not modified. t is updated by side effect.

Note: this function is almost equal to transformer_projection(); however, entities of args do not all have to appear in t's relation; thus transformer_filter has a larger definition domain than transformer_projection; on transformer_projection's domain, both functions are equal

transformer_projection is useful to get cores when you know all entities in args should appear in the relation.

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

sc_fprint(stderr, r, exernal_value_name);

sc_fprint(stderr, r, (char * (*)(Variable)) entity_local_name);

get rid of unwanted values in the relation r and in the basis

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

r = sc_projection(r, (Variable) e);

CA

sc_projection_along_variable_ofl_ctrl_timeout_ctrl

sc_projection_along_variable_ofl_ctrl(&r, (Variable) e, OFL_CTRL);

compute new_args

use functions on arguments instead of in-lining ! MAPL(ce, { entity e = ENTITY(CAR(ce)); if((entity) gen_find_eq(e, args)== (entity) chunk_undefined) { – e must be kept if it is not in args – new_args = arguments_add_entity(new_args, e); }}, transformer_arguments(t));

update the relation and the arguments field for t

Is the relation updated by side effect? Yes, in general. No if the system is non feasible

replace the old arguments by the new one

sc_fprint(stderr, r, exernal_value_name);

Parameters

args

rgs

Definition at line 1716 of file transformer.c.

{
  cons * new_args = NIL;
  /* Automatic variables read in a CATCH block need to be declared volatile as
   * specified by the documentation*/
  Psysteme volatile r = (Psysteme) predicate_system(transformer_relation(t));
 
  ifdebug(9) {
    pips_debug(9, "Begin for transformer %p\n", t);
    /* sc_fprint(stderr, r, exernal_value_name); */
    /* sc_fprint(stderr, r, (char * (*)(Variable)) entity_local_name); */
    fprint_transformer(stderr, t, (get_variable_name_t) entity_global_name);
    pips_debug(9, "and entities to be projected: ");
    dump_arguments(args);
    pips_assert("t is weakly consistent", transformer_weak_consistency_p(t));
  }
 
  if(!ENDP(args) && !SC_EMPTY_P(r)) {
    /* get rid of unwanted values in the relation r and in the basis */
    volatile list cea = list_undefined;
 
    for(cea=args; !ENDP(cea); POP(cea)) {
      /* Automatic variables read in a CATCH block need to be declared volatile as
       * specified by the documentation*/
      entity volatile e = ENTITY(CAR(cea));
      if(base_contains_variable_p(r->base, (Variable) e)) {
        /* r = sc_projection(r, (Variable) e); */
        /*
          sc_projection_along_variable_ofl_ctrl(&r, (Variable) e,
          NO_OFL_CTRL);  */
        CATCH(overflow_error)
          {
                                /* CA */
            pips_user_warning("overflow error in projection of %s, "
                              "variable eliminated\n",
                              entity_name(e));
            r = sc_elim_var(r, (Variable) e);
          }
        TRY
          {
            /* sc_projection_along_variable_ofl_ctrl_timeout_ctrl */
            sc_projection_along_variable_ofl_ctrl
              (&r, (Variable) e, NO_OFL_CTRL);
            UNCATCH(overflow_error);
          }
        /*       sc_projection_along_variable_ofl_ctrl(&r, (Variable) e,
                 OFL_CTRL);*/
        sc_base_remove_variable(r,(Variable) e);}
    }
    r->dimension = vect_size(r->base);
 
    /* compute new_args */
    /* use functions on arguments instead of in-lining !
       MAPL(ce, { entity e = ENTITY(CAR(ce));
       if((entity) gen_find_eq(e, args)== (entity) chunk_undefined) {
       -- e must be kept if it is not in args --
       new_args = arguments_add_entity(new_args, e);
       }},
       transformer_arguments(t));
    */
    new_args = arguments_difference(transformer_arguments(t), args);
 
    /* update the relation and the arguments field for t */
 
    /* Is the relation updated by side effect?
     * Yes, in general. No if the system is non feasible
     */
 
    predicate_system_(transformer_relation(t)) = newgen_Psysteme(r);
 
    /* replace the old arguments by the new one */
    free_arguments(transformer_arguments(t));
    if(sc_empty_p(r)) {
      transformer_arguments(t) = NULL;
      gen_free_list(new_args);
    }
    else
      transformer_arguments(t) = new_args;
  }
 
  ifdebug(9) {
    pips_debug(9, "Transformer after argument list update\n");
    /* sc_fprint(stderr, r, exernal_value_name); */
    fprint_transformer(stderr, t, (get_variable_name_t) entity_global_name);
  }
 
  ifdebug(1) {
    pips_assert("After filtering,"
                " transformer t is consistent",
                transformer_weak_consistency_p(t));
  }
  pips_debug(9, "End for t=%p\n", t);
 
  return t;
}

References arguments_difference(), Ssysteme::base, base_contains_variable_p(), CAR, CATCH, Ssysteme::dimension, dump_arguments(), ENDP, ENTITY, entity_global_name(), entity_name, fprint_transformer(), free_arguments(), gen_free_list(), ifdebug, list_undefined, newgen_Psysteme, NIL, NO_OFL_CTRL, overflow_error, pips_assert, pips_debug, pips_user_warning, POP, predicate_system, predicate_system_, sc_base_remove_variable(), sc_elim_var(), sc_empty_p(), transformer_arguments, transformer_relation, transformer_weak_consistency_p(), TRY, UNCATCH, and vect_size().

Referenced by c_user_function_call_to_transformer(), fortran_user_call_to_transformer(), fortran_user_function_call_to_transformer(), loop_to_transformer(), statement_to_postcondition(), statement_to_total_precondition(), transformer_variables_filter(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_free()

void transformer_free

(

transformer

t

)

Definition at line 68 of file basic.c.

{
    free_transformer(t);
}

References free_transformer().

Referenced by add_loop_index_exit_value(), add_loop_index_initialization(), add_module_call_site_precondition(), comp_regions_of_implied_do(), complete_loop_transformer(), complete_loop_transformer_list(), do_array_expansion(), invariant_wrt_transformer(), loop_to_postcondition(), loop_to_total_precondition(), process_call_for_summary_precondition(), statement_to_transformer(), statement_to_transformer_list(), test_to_transformer(), test_to_transformer_list(), transformer_add_any_relation_information(), transformer_halbwachs_fix_point(), unstructured_to_postcondition(), unstructured_to_postconditions(), unstructured_to_total_precondition(), update_summary_precondition(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_general_consistency_p()

bool transformer_general_consistency_p	(	transformer	tf,
		bool	is_weak
	)

the relation should be consistent and any variable corresponding to an old value should appear in the argument list since an old value cannot (should not) be introduced unless the variable is changed and since every changed variable is in the argument list.

Apparently, a variable may appear as an argument but its old value does not have to appear in the basis if it is not required by the constraints. This does not seem very safe to me (FI, 13 Nov. 95)

The NewGen data structure must be fully defined

The predicate must be weakly consistent. Every variable in the constraints must be in the basis (but not the other way round).

If an old value appears in the predicate, the corresponding variable should be an argument of the transformer

test aliasing between arguments and relations high cost testing

FI: the next test is not safe because val can be a global value not recognized in the current context. old_value_entity_p() returns true or FALSE or pips_error.

A general version of this routine is needed... The return value of a function is not recognized as a global value by old_value_entity_p

old_value_entity_p() is likely to core dump on interprocedural transformers and preconditions.

The constant term should not appear in the basis

The constant term should not be an argument

Check that the transformer is compatible with the current value mappings.

This is not always true as you may need to import the summary transformer of a callee. Before translation, this check will most likely fail.

Debugging step which does not return if an incompatibility is found.

Check that every argument has a value. This is not redundant with the printout procedure which uses entity_minimal_name() and not the value mappings.

Values returned by callees may appear in interprocedural transformers

FI: let the user react and print info before core dumping

pips_assert("transformer_consistency_p", consistent);

Parameters

tf	f
is_weak	s_weak

Definition at line 632 of file basic.c.

{
#define TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL 0
    /* the relation should be consistent
     * and any variable corresponding to an old value
     * should appear in the argument list since
     * an old value cannot (should not) be
     * introduced unless the variable is changed and
     * since every changed variable is
     * in the argument list.
     *
     * Apparently, a variable may appear as an argument but its old value
     * does not have to appear in the basis if it is not required by
     * the constraints. This does not seem very safe to me (FI, 13 Nov. 95)
     */
    Psysteme sc = (Psysteme) predicate_system(transformer_relation(tf));
    list args = transformer_arguments(tf);
    bool consistent = true;
 
    /* The NewGen data structure must be fully defined */
    ifdebug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL)
        consistent = transformer_defined_p(tf);
    else
        consistent = true;
    if(!consistent)
        pips_debug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL,
                   "transformer tf is not gen_defined\n");
 
    /* The predicate must be weakly consistent. Every variable
     * in the constraints must be in the basis (but not the other
     * way round).
     */
    consistent = consistent && sc_weak_consistent_p(sc);
    if(!consistent)
        pips_debug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL,
                   "sc is not weakly consistent\n");
 
    /* If an old value appears in the predicate, the corresponding
     * variable should be an argument of the transformer
     */
    if(consistent) {
        Pbase b = sc_base(sc);
        Pbase t = BASE_UNDEFINED;
 
        for( t = b; !BASE_UNDEFINED_P(t) && consistent; t = t->succ) {
            entity val = (entity) vecteur_var(t);
 
       /* test aliasing between arguments and relations
          high cost testing */
            ifdebug(8) {
                bool aliasing = false;
                const char* emn = entity_module_name(val);
                const char* eln = entity_local_name(val);
                list lt =  args;
                entity e;
                for (lt =  args; lt && !aliasing ;POP(lt)) {
                    e = ENTITY(CAR(lt));
                    consistent = consistent &&
                        (same_string_p(entity_local_name(e), eln) ?
                         same_string_p(entity_module_name(e),emn)
                         : true);
                    aliasing = aliasing && entities_may_conflict_p(e,val);
                }
 
                if(!consistent)
                    pips_user_warning("different global variable names in "
                                      "arguments and basis: \"%s\"\n", eln);
                if (aliasing)
                    pips_internal_error("aliasing between arguments and basis: \"%s\" ",
                                        entity_name(val));
            }
 
            /* FI: the next test is not safe because val can be
             * a global value not recognized in the current
             * context. old_value_entity_p() returns true or FALSE
             * or pips_error.
             *
             * A general version of this routine is needed...  The
             * return value of a function is not recognized as a
             * global value by old_value_entity_p
             *
             * old_value_entity_p() is likely to core dump on
             * interprocedural transformers and preconditions.
             */
            if( !storage_return_p(entity_storage(val))
                && old_value_entity_p(val)) {
                entity var = value_to_variable(val);
 
                consistent = entity_is_argument_p(var, args);
                if(!consistent) {
                  dump_transformer(tf);
                  pips_debug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL,
                             "Old value of \"%s\" in sc but not in arguments of transformer tf, %p\n",
                             entity_name(var), tf);
                }
            }
            /* The constant term should not appear in the basis */
            if(consistent) {
                consistent = consistent && !term_cst(t);
                if(!consistent)
                    pips_debug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL,
                               "TCST in sc basis\n");
            }
        }
    }
 
    /* The constant term should not be an argument */
    if(consistent) {
        MAP(ENTITY, e, {
            consistent = consistent && (e != (entity) TCST);
        }, args);
        if(!consistent)
            debug(TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL,
                  "transformer_consistency_p", "TCST appears in arguments\n");
    }
 
    /* Check that the transformer is compatible with the current value mappings.
     *
     * This is not always true as you may need to import the summary transformer
     * of a callee. Before translation, this check will most likely fail.
     *
     * Debugging step which does not return if an incompatibility is found.
     */
 
    /* Check that every argument has a value.
     * This is not redundant with the printout procedure which uses
     * entity_minimal_name() and not the value mappings.
     */
    FOREACH(ENTITY, e, args) {
        /*
        pips_assert("Argument entity appears in the value mappings",
                    entity_has_values_p(e));
                    */
        if(!entity_has_values_p(e)) {
          /* Values returned by callees may appear in interprocedural
             transformers */
          if(!storage_return_p(entity_storage(e))
             && !entity_stub_sink_p(e)
             && !entity_in_formal_area_p(e)) {
            pips_user_warning("No value for argument %s in value mappings\n",
                              entity_name(e));
            if(!is_weak)
              consistent = false;
            }
        }
    }
 
    if(consistent && !is_weak)
      consistent = transformer_argument_consistency_p(tf);
 
    /* FI: let the user react and print info before core dumping */
    /* pips_assert("transformer_consistency_p", consistent); */
 
    return consistent;
}

References BASE_UNDEFINED, BASE_UNDEFINED_P, CAR, debug(), dump_transformer, entities_may_conflict_p(), ENTITY, entity_has_values_p(), entity_in_formal_area_p(), entity_is_argument_p(), entity_local_name(), entity_module_name(), entity_name, entity_storage, entity_stub_sink_p(), FOREACH, ifdebug, MAP, old_value_entity_p(), pips_debug, pips_internal_error, pips_user_warning, POP, predicate_system, same_string_p, sc_weak_consistent_p(), storage_return_p, Svecteur::succ, TCST, term_cst, transformer_argument_consistency_p(), transformer_arguments, TRANSFORMER_CONSISTENCY_P_DEBUG_LEVEL, transformer_defined_p(), transformer_relation, value_to_variable(), and vecteur_var.

Referenced by transformer_consistency_p(), transformer_weak_consistency_p(), and transformers_consistency_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_halbwachs_fix_point()

transformer transformer_halbwachs_fix_point

(

transformer

tf

)

THIS FUNCTION WAS NEVER CORRECT AND HAS NOT BEEN REWRITTEN FOR THE NEW VALUE PACKAGE

simple fix-point for inductive variables: loop bounds are ignored

cons * args = effects_to_arguments(e);

tf1: transformer for one loop iteration

tf2: transformer for two loop iterations

tf12: transformer for one or two loop iterations

tf23: transformer for two or three loop iterations

tf_star: transformer for one, two, three,... loop iterations should be called tf_plus by I do not use the one_trip flag

preserve transformer of loop body s

temporarily commented out

duplicate tf1 because transformer_combine might not be able to use twice the same argument

input/output relation for one or two iteration of the loop

apply one iteration on tf12

fix-point

should be done again based on Chenikova

tf_star = transformer_fix_point(tf12, tf23);

free useless transformers

Parameters

tf

f

Definition at line 143 of file fix_point.c.

{
    /* THIS FUNCTION WAS NEVER CORRECT AND HAS NOT BEEN REWRITTEN FOR
       THE NEW VALUE PACKAGE */
 
    /* simple fix-point for inductive variables: loop bounds are
       ignored */
 
    /* cons * args = effects_to_arguments(e); */
    /* tf1: transformer for one loop iteration */
    transformer tf1;
    /* tf2: transformer for two loop iterations */
    transformer tf2;
    /* tf12: transformer for one or two loop iterations */
    transformer tf12;
    /* tf23: transformer for two or three loop iterations */
    transformer tf23;
    /* tf_star: transformer for one, two, three,... loop iterations
       should be called tf_plus by I do not use the one_trip flag */
    transformer tf_star = transformer_undefined;
 
    pips_internal_error("not implemented");
 
    /* preserve transformer of loop body s */
    /* temporarily commented out */
    /*
      tf1 = transformer_rename(transformer_dup(tf), args);
      */
    tf1 = transformer_dup(tf);
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer",
                "tf1 after renaming =");
        (void) print_transformer(tf1);
    }
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer", "tf1 =");
        (void) print_transformer(tf1);
    }
 
    /* duplicate tf1 because transformer_combine might not be able
       to use twice the same argument */
    tf2 = transformer_dup(tf1);
    tf2 = transformer_combine(tf2, tf1);
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer", "tf2 =");
        (void) print_transformer(tf2);
    }
 
    /* input/output relation for one or two iteration of the loop */
    tf12 = transformer_convex_hull(tf1, tf2);
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer", "tf12 =");
        (void) print_transformer(tf12);
    }
 
    /* apply one iteration on tf12 */
    tf23 = transformer_combine(tf12, tf1);
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer", "tf23 =");
        (void) print_transformer(tf23);
    }
 
    /* fix-point */
    /* should be done again based on Chenikova */
    /* tf_star = transformer_fix_point(tf12, tf23); */
 
    ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","loop_to_transformer", "tf_star =");
        (void) print_transformer(tf_star);
    }
 
    /* free useless transformers */
    transformer_free(tf1);
    transformer_free(tf2);
    transformer_free(tf12);
    transformer_free(tf23);
 
    tf = tf_star;
 
    return tf;
}

References fprintf(), ifdebug, pips_internal_error, print_transformer, transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_free(), and transformer_undefined.

Referenced by standard_whileloop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_identity()

transformer transformer_identity

(

void

)

Allocate an identity transformer.

return make_transformer(NIL, make_predicate(SC_RN));

en fait, on voudrait initialiser a "liste de contraintes vide"

Definition at line 110 of file basic.c.

{
    /* return make_transformer(NIL, make_predicate(SC_RN)); */
    /* en fait, on voudrait initialiser a "liste de contraintes vide" */
    return make_transformer(NIL,
                            make_predicate(sc_make(CONTRAINTE_UNDEFINED,
                                                   CONTRAINTE_UNDEFINED)));
}

References CONTRAINTE_UNDEFINED, make_predicate(), make_transformer(), NIL, and sc_make().

Referenced by __attribute__(), addition_operation_to_transformer(), any_expression_to_transformer(), any_expressions_to_transformer(), any_user_call_site_to_transformer(), args_to_transformer(), bitwise_xor_to_transformer(), block_continuation_conditions(), block_to_transformer(), c_data_to_prec_for_variables(), c_return_to_transformer(), call_continuation_conditions(), call_to_transformer(), clean_up_transformer_list(), complete_loop_transformer(), complete_loop_transformer_list(), complete_repeatloop_transformer_list(), compute_postcondition(), condition_to_transformer(), constant_to_transformer(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), declaration_to_transformer(), declaration_to_transformer_list(), declarations_to_transformer(), declarations_to_transformer_list(), dimensions_to_transformer(), effects_to_transformer(), expression_multiply_sizeof_to_transformer(), expressions_to_transformer(), forloop_to_transformer(), fortran_data_to_prec_for_variables(), generic_abs_to_transformer(), generic_module_name_to_transformers(), generic_transformer_list_to_transformer(), iabs_to_transformer(), instruction_to_transformer(), integer_binary_operation_to_transformer(), integer_call_expression_to_transformer(), integer_expression_to_transformer(), integer_left_shift_to_transformer(), integer_minmax_to_transformer(), integer_multiply_to_transformer(), integer_power_to_transformer(), interprocedural_abc_arrays(), intrinsic_to_transformer(), load_completed_statement_transformer(), logical_binary_function_to_transformer(), logical_expression_to_transformer(), loop_continuation_conditions(), loop_to_continue_transformer(), loop_to_enter_transformer(), merge_transformer_lists(), module_name_to_total_preconditions(), module_summary_continuation_conditions(), modulo_by_a_constant_to_transformer(), modulo_of_a_constant_to_transformer(), modulo_of_a_negative_value_to_transformer(), modulo_of_a_positive_value_to_transformer(), modulo_to_transformer(), new_complete_whileloop_transformer_list(), new_whileloop_to_k_transformer(), new_whileloop_to_transformer(), old_complete_whileloop_transformer(), old_summary_precondition(), ordinary_summary_precondition(), pointer_unary_operation_to_transformer(), precondition_intra_to_inter(), program_postcondition(), program_precondition(), repeatloop_to_postcondition(), repeatloop_to_transformer(), safe_any_assign_operation_to_transformer(), safe_any_expression_to_transformer(), safe_assigned_expression_to_transformer(), safe_assigned_expression_to_transformer_list(), safe_expression_to_transformer(), sequence_dg(), standard_whileloop_to_transformer(), statement_continuation_conditions(), statement_to_transformer(), statement_to_transformer_list(), summary_total_postcondition(), test_continuation_conditions(), test_to_transformer(), test_to_transformer_list(), transformer_add_any_relation_information(), transformer_apply_field_assignments_or_equalities(), transformer_apply_unknown_field_assignments_or_equalities(), transformer_convex_hulls(), transformer_derivative_fix_point(), transformer_equality_fix_point(), transformer_general_intersection(), transformer_list_generic_transitive_closure(), transformer_safe_domain_intersection(), translate_to_module_frame(), unstructured_continuation_conditions(), unstructured_to_transformer(), and whileloop_to_postcondition().

Here is the call graph for this function:

transformer_identity_p()

bool transformer_identity_p

(

transformer

t

)

Check that t is an identity function.

no variables are modified; no constraints exist on their values

Definition at line 154 of file basic.c.

{
    /* no variables are modified; no constraints exist on their values */
 
    Psysteme s;
 
    pips_assert("transformer_identity_p", t != transformer_undefined);
    s = (Psysteme) predicate_system(transformer_relation(t));
    return transformer_arguments(t) == NIL && sc_nbre_egalites(s) == 0
        && sc_nbre_inegalites(s) == 0;
}

References NIL, pips_assert, predicate_system, transformer_arguments, transformer_relation, and transformer_undefined.

Referenced by add_module_call_site_precondition(), check_transformer_list(), clean_up_transformer_list(), merge_transformer_lists(), modulo_to_transformer(), process_call_for_summary_precondition(), and two_transformers_to_list().

Here is the caller graph for this function:

transformer_image_intersection()

transformer transformer_image_intersection	(	transformer	t1,
		transformer	t2
	)

allocate a new transformer based on transformer t1 and postcondition t2

Parameters

t1	1
t2	2

Definition at line 608 of file transformer.c.

{
  transformer t = transformer_undefined;
 
  pips_debug(9, "begins with t1 = %p and t2 = %p\n", t1, t2);
 
  t = transformer_general_intersection(t1, t2, true);
 
  pips_debug(9, "ends with t = %p, t1 = %p and t2 = %p\n", t, t1, t2);
 
  return t;
}

References pips_debug, transformer_general_intersection(), and transformer_undefined.

Referenced by statement_to_transformer(), transformer_domain_intersection(), and transformer_range_intersection().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_inequalities_add()

transformer transformer_inequalities_add	(	transformer	tf,
		Pcontrainte	ineqs
	)

Warning:

Parameters

tf	f
ineqs	neqs

Definition at line 409 of file basic.c.

{
  Pcontrainte ineq = CONTRAINTE_UNDEFINED;
 
    for(ineq = ineqs; !CONTRAINTE_UNDEFINED_P(ineq); ineq = contrainte_succ(ineq))
        (void) transformer_constraint_add(tf, 
                                          contrainte_vecteur(ineq),
                                          false);
    return tf;
}

References contrainte_succ, CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED_P, contrainte_vecteur, and transformer_constraint_add().

Referenced by generic_minmax_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_inequalities_constrain_variable_p()

bool transformer_inequalities_constrain_variable_p	(	const	transformer,
		const	entity
	)

Is value v used with a non-zero coefficient by the inequalities of transformer t?

Definition at line 972 of file basic.c.

{
  Psysteme sc = (Psysteme) predicate_system(transformer_relation(t));
  return sc_inequalities_constrain_variable_p(sc, (Variable) v);
}

References predicate_system, sc_inequalities_constrain_variable_p(), and transformer_relation.

Here is the call graph for this function:

transformer_inequality_add()

transformer transformer_inequality_add	(	transformer	tf,
		Pvecteur	i
	)

Parameters

tf

f

Definition at line 375 of file basic.c.

{
    return transformer_constraint_add(tf, i, false);
}

References transformer_constraint_add().

Referenced by add_affine_bound_conditions(), add_declaration_list_information(), add_loop_index_exit_value(), add_loop_skip_condition(), add_reference_information(), bitwise_xor_to_transformer(), expression_multiply_sizeof_to_transformer(), generic_abs_to_transformer(), iabs_to_transformer(), integer_left_shift_to_transformer(), integer_minmax_to_transformer(), integer_multiply_to_transformer(), integer_power_to_transformer(), logical_binary_operation_to_transformer(), loop_bound_evaluation_to_transformer(), transformer_add_3d_affine_constraint(), transformer_add_condition_information_updown(), transformer_add_inequality(), transformer_add_inequality_with_affine_term(), transformer_add_inequality_with_integer_constraint(), transformer_add_integer_relation_information(), and transformer_logical_inequalities_add().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_internal_consistency_p()

bool transformer_internal_consistency_p

(

transformer

t

)

Same as above but equivalenced variables should not appear in the argument list or in the predicate basis.

Definition at line 790 of file basic.c.

{
  Psysteme sc = (Psysteme) predicate_system(transformer_relation(t));
  Pbase b = sc_base(sc);
  Pbase e = BASE_UNDEFINED;
  list args = transformer_arguments(t);
  bool consistent = transformer_consistency_p(t);
 
  FOREACH(ENTITY, e, args) {
    entity v = entity_to_new_value(e);
 
    if(v!=e) {
      pips_user_warning("New value %s should be the same entity as variable %s"
                        " as long as equivalence equations are not added\n", 
                        entity_local_name(v), entity_local_name(e));
      pips_assert("Argument must be a value", false);
    }
  }
 
  for(e=b; !BASE_NULLE_P(e); e = vecteur_succ(e)) {
    entity val = (entity) vecteur_var(e);
 
    if(!(new_value_entity_p(val) || old_value_entity_p(val)
         || intermediate_value_entity_p(val))) {
      // Don't we need something else for sizeof variables ?
      if(!entity_constant_p(val) && !entity_symbolic_p(val)
         && !entity_null_locations_p(val)) {
        pips_user_warning("Variable %s in basis should be an internal value",
                          entity_local_name(val));
        pips_assert("Basis variables must be an internal value", false);
      }
    }
  }
 
  return consistent;
}

References BASE_NULLE_P, BASE_UNDEFINED, ENTITY, entity_constant_p, entity_local_name(), entity_null_locations_p(), entity_symbolic_p, entity_to_new_value(), FOREACH, intermediate_value_entity_p(), new_value_entity_p(), old_value_entity_p(), pips_assert, pips_user_warning, predicate_system, transformer_arguments, transformer_consistency_p(), transformer_relation, vecteur_succ, and vecteur_var.

Referenced by recompute_loop_transformer(), statement_to_transformer(), statement_to_transformer_list(), transformer_add_integer_relation_information(), and unstructured_to_flow_insensitive_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_intersect_range_with_domain()

transformer transformer_intersect_range_with_domain

(

transformer

tf

)

When tf is used repeatedly in a loop, the range is part of the domain from iteration 2 to the end.

This improves the derivative of tf when tf is involutive on a subspace. A new transformer is allocated. Of course, it cannot be used without caution. note that tf must be a range, i.e. no arguments, no old values in the basis.

Parameters

tf

f

Definition at line 845 of file transformer.c.

{
  transformer r = transformer_range(tf);
  transformer ntf = copy_transformer(tf);
  Psysteme sc = predicate_system(transformer_relation(ntf));
  Psysteme scr = predicate_system(transformer_relation(r));
  Pbase b = sc_base(scr);
  list vl = base_to_entities(b);
 
  // No convenient iterator on the basis, hence the temporary list of values
  FOREACH(ENTITY, v, vl) {
    entity ov = entity_to_old_value(v);
 
    r = transformer_value_substitute(r, v, ov);
  }
 
  scr = predicate_system(transformer_relation(r));
  // let's hope sc_append takes care of the consistency of sc
  sc = sc_append(sc, scr);
 
  gen_free_list(vl);
 
  return ntf;
}

References base_to_entities(), copy_transformer(), ENTITY, entity_to_old_value(), FOREACH, gen_free_list(), predicate_system, sc_append(), transformer_range(), transformer_relation, and transformer_value_substitute().

Referenced by any_transformer_to_k_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_intersection()

transformer transformer_intersection	(	transformer	t1,
		transformer	t2
	)

tf is a new transformer that receives the constraints in t1 and t2.

For implicit equalities carried by args, this implies that the args for tf is the intersection of the args. And that the resulting transformer may be empty: for instance, a variable may be untouched in t1 and incremented in t2, which is impossible.

Parameters

t1	1
t2	2

Definition at line 600 of file transformer.c.

{
  transformer t = transformer_general_intersection(t1, t2, false);
  return t;
}

References transformer_general_intersection().

Referenced by bitwise_xor_to_transformer(), expression_multiply_sizeof_to_transformer(), generic_reference_to_transformer(), integer_multiply_to_transformer(), logical_expression_to_transformer(), loop_to_enter_transformer(), pointer_expression_to_transformer(), pointer_unary_operation_to_transformer(), transformer_list_multiple_closure_to_precondition(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_inverse_apply()

transformer transformer_inverse_apply	(	transformer	tf,
		transformer	post
	)

transformer transformer_inverse_apply(transformer tf, transformer post): apply transformer tf on precondition pre to obtain postcondition post

pre = post(tf) = tf o post

There is (should be!) no sharing between post and tf. No sharing is introduced between post or tf and pre. Neither post nor tf are modified.

pre = post o tf ; tf would be modified by transformer_combine

Parameters

tf	f
post	ost

Definition at line 1657 of file transformer.c.

{
    transformer pre = transformer_undefined;
    transformer copy_tf = transformer_dup(tf);
 
    pips_debug(8,"begin with\n");
    pips_assert("tf is not undefined", tf!=transformer_undefined);
    pips_debug(8,"tf=%p\n", tf);
    ifdebug(8) (void) dump_transformer(tf);
    pips_assert("post is not undefined", post!=transformer_undefined);
    pips_debug(8,"post=%p\n", post);
    ifdebug(8) {
      (void) dump_transformer(post);
      pips_assert("tf is consistent", transformer_consistency_p(tf));
      pips_assert("post is consistent", transformer_consistency_p(post));
    }
 
    /* pre = post o tf ; tf would be modified by transformer_combine */
    pre = transformer_combine(copy_tf, post);
 
    pips_assert("pre is not undefined", pre!=transformer_undefined);
    pips_debug(8,"return: pre=%p\n", pre);
    ifdebug(8) (void) dump_transformer(pre);
    pips_assert("unexpected sharing",post != pre);
    pips_debug(8,"end\n");
 
    return pre;
}

References dump_transformer, ifdebug, pips_assert, pips_debug, transformer_combine(), transformer_consistency_p(), transformer_dup(), and transformer_undefined.

Referenced by call_to_total_precondition(), loop_to_total_precondition(), and transformer_safe_inverse_apply().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_is_empty_p()

bool transformer_is_empty_p

(

transformer

t

)

Check that transformer t is the canonical representation of an empty transformer.

See transformer_empty_p(), transformer_strongly_empty_p() if you need to check that a set of affine constraints is not feasible.

Definition at line 172 of file basic.c.

{
    Psysteme s;
 
    pips_assert("transformer_identity_p", t != transformer_undefined);
    s = (Psysteme) predicate_system(transformer_relation(t));
    return sc_empty_p(s) && ENDP(transformer_arguments(t));
}

References ENDP, pips_assert, predicate_system, sc_empty_p(), transformer_arguments, transformer_relation, and transformer_undefined.

Referenced by generic_apply_effects_to_transformer(), transformer_combine(), and transformer_normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_is_rn_p()

bool transformer_is_rn_p

(

transformer

t

)

Check that transformer t is the canonical representation of the whole afine space defined by its basis.

Definition at line 183 of file basic.c.

{
    Psysteme s;
 
    pips_assert("transformer_identity_p", t != transformer_undefined);
    s = (Psysteme) predicate_system(transformer_relation(t));
    return sc_nbre_egalites(s)==0 && sc_nbre_inegalites(s)==0;
}

References pips_assert, predicate_system, transformer_relation, and transformer_undefined.

Referenced by eval_linear_expression(), and transformer_combine().

Here is the caller graph for this function:

transformer_list_closure_to_precondition()

transformer transformer_list_closure_to_precondition	(	list	tl,
		transformer	c_t,
		transformer	p_0
	)

Relay to select a heuristic.

Parameters

tl	l
c_t	_t
p_0	_0

Definition at line 705 of file transformer_list.c.

{
  transformer p_star = transformer_undefined;
  const char* h = get_string_property("SEMANTICS_LIST_FIX_POINT_OPERATOR");
 
  if(strcmp(h, "depth_two")) {
    p_star = transformer_list_closure_to_precondition_depth_two(tl, c_t, p_0);
  }
    else if(strcmp(h, "max_depth")) {
    p_star = transformer_list_closure_to_precondition_max_depth(tl, c_t, p_0);
  }
  else
    pips_user_error("Unknown value \"%s\" for property "
                    "\"SEMANTICS_LIST_FIX_POINT_OPERATOR\"", h);
  pips_assert("prec is consistent", transformer_consistency_p(p_star));
  return p_star;
}

References get_string_property(), pips_assert, pips_user_error, transformer_consistency_p(), transformer_list_closure_to_precondition_depth_two(), transformer_list_closure_to_precondition_max_depth(), and transformer_undefined.

Referenced by transformer_list_multiple_closure_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_generic_transitive_closure()

transformer transformer_list_generic_transitive_closure	(	list	tfl,
		bool	star_p
	)

Computation of an upper approximation of a transitive closure using constraints on the discrete derivative for a list of transformers.

Each transformer is used to compute its derivative and the derivatives are unioned by convex hull.

The reason for doing this is D(T1) U D(T2) == D(T1 U T2) but the complexity is lower

See http://www.cri.ensmp.fr/classement/doc/A-429.pdf

Implicit equations, n::new - n::old = 0, are added because they are necessary for the convex hull.

Intermediate values are used to encode the differences. For instance, i::int = i::new - i::old This code was cut-and-pasted from transformer_derivative_fix_point() but is more general and subsume it transformer transformer_derivative_fix_point(transformer tf)

Since we compute the * transitive closure and not the + transitive closure, the fix point is the identity.

basis of difference vectors

Compute the global argument list and the global base b

Cannot use arguments_union() because a new list is allocated

For each transformer t in list tl

compute its derivative constraint system

add the equations for the unchanged variables

compute its convex hull with the current value of sc if sc is already defined

Add corresponding equation

This could be optimized by using the convex hull of a Psystemes list and by keeping the dual representation of the result instead of converting it several time back and forth.

Multiply the constant terms by the iteration number ik and add a positivity constraint for the iteration number ik and then eliminate the iteration number ik to get T*(dx).

Difference variables must substituted back to differences between old and new values.

Only generate difference equations if the old value is used

Project all difference variables

The full basis must be used again

Plug sc back into tc_tf

That's all!

Parameters

tfl	fl
star_p	tar_p

Definition at line 960 of file transformer_list.c.

{
  transformer tc_tf = transformer_identity();
 
  ifdebug(8) {
    pips_debug(8, "Begin for transformer list %p:\n", tfl);
    print_transformers(tfl);
  }
 
  if(ENDP(tfl)) {
    if(star_p) {
    /* Since we compute the * transitive closure and not the +
       transitive closure, the fix point is the identity. */
      tc_tf = transformer_identity();
    }
    else {
      tc_tf = transformer_empty();
    }
  }
  else {
    // Pbase ib = base_dup(sc_base(sc)); /* initial and final basis */
    Pbase ib = BASE_NULLE;
    Pbase diffb = BASE_NULLE; /* basis of difference vectors */
    Pbase bv = BASE_NULLE;
    Pbase b = BASE_NULLE;
 
    /* Compute the global argument list and the global base b */
    list gal = NIL;
    FOREACH(TRANSFORMER, t, tfl) {
      list al = transformer_arguments(t);
      /* Cannot use arguments_union() because a new list is allocated */
      FOREACH(ENTITY, e, al)
        gal = arguments_add_entity(gal, e);
 
      // FI: this copy is almost entirely memory leaked
      Psysteme sc = sc_copy(predicate_system(transformer_relation(t)));
      // redundant with call to transformer_derivative_constraints(t)
      Pbase tb = sc_to_minimal_basis(sc);
      Pbase nb = base_union(b, tb);
      base_rm(b); // base_union() allocates a new base
      b = nb;
    }
 
    /* For each transformer t in list tl
     *
     *   compute its derivative constraint system
     *
     *   add the equations for the unchanged variables
     *
     *   compute its convex hull with the current value of sc if sc is
     *   already defined
     */
    Psysteme sc = SC_UNDEFINED;
    FOREACH(TRANSFORMER, t, tfl) {
      Psysteme tsc = transformer_derivative_constraints(t);
      FOREACH(ENTITY,e,gal) {
        if(!entity_is_argument_p(e, transformer_arguments(t))) {
          /* Add corresponding equation */
          entity diffv = entity_to_intermediate_value(e);
          Pvecteur diff = VECTEUR_NUL;
          Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
          diff = vect_make(diff,
                           (Variable) diffv, VALUE_ONE,
                           TCST, VALUE_ZERO);
 
          eq = contrainte_make(diff);
          tsc = sc_equation_add(tsc, eq);
        }
      }
      if(SC_UNDEFINED_P(sc))
        sc = tsc;
      else {
        /* This could be optimized by using the convex hull of a
           Psystemes list and by keeping the dual representation of
           the result instead of converting it several time back
           and forth. */
        Psysteme nsc = cute_convex_union(sc, tsc);
        sc_free(sc);
        sc = nsc;
      }
    }
 
    /* Multiply the constant terms by the iteration number ik and add a
       positivity constraint for the iteration number ik and then
       eliminate the iteration number ik to get T*(dx). */
    entity ik = make_local_temporary_integer_value_entity();
    //Psysteme sc_t_prime_k = sc_dup(sc);
    //sc_t_prime_k = sc_multiply_constant_terms(sc_t_prime_k, (Variable) ik);
    sc = sc_multiply_constant_terms(sc, (Variable) ik, star_p);
    //Psysteme sc_t_prime_star = sc_projection_ofl(sc_t_prime_k, (Variable) ik);
    sc = sc_projection_ofl(sc, (Variable) ik);
    if(SC_EMPTY_P(sc)) {
      sc = sc_empty(BASE_NULLE);
    }
    else {
      sc->base = base_remove_variable(sc->base, (Variable) ik);
      sc->dimension--;
      // FI: I do not remember nor find how to get rid of local values...
      //sc_rm(sc);
      //sc = sc_t_prime_star;
    }
 
    ifdebug(8) {
      pips_debug(8, "All invariants on derivatives=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Difference variables must substituted back to differences
     * between old and new values.
     */
 
    for(bv = b; !BASE_NULLE_P(bv); bv = bv->succ) {
      entity oldv = (entity) vecteur_var(bv);
 
      /* Only generate difference equations if the old value is used */
      if(old_value_entity_p(oldv)) {
        entity var = value_to_variable(oldv);
        entity newv = entity_to_new_value(var);
        entity diffv = entity_to_intermediate_value(var);
        Pvecteur diff = VECTEUR_NUL;
        Pcontrainte eq = CONTRAINTE_UNDEFINED;
 
        diff = vect_make(diff,
                         (Variable) diffv, VALUE_ONE,
                         (Variable) newv,  VALUE_MONE,
                         (Variable) oldv, VALUE_ONE,
                         TCST, VALUE_ZERO);
 
        eq = contrainte_make(diff);
        sc = sc_equation_add(sc, eq);
        diffb = base_add_variable(diffb, (Variable) diffv);
        ib = base_add_variable(ib, (Variable) oldv);
        ib = base_add_variable(ib, (Variable) newv);
      }
    }
 
    ifdebug(8) {
      pips_debug(8,
                 "All invariants on derivatives with difference variables=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Project all difference variables */
 
    sc = sc_projection_ofl_along_variables(sc, diffb);
 
    ifdebug(8) {
      pips_debug(8, "All invariants on differences=\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* The full basis must be used again */
    base_rm(sc_base(sc)), sc_base(sc) = BASE_NULLE;
    sc_base(sc) = ib;
    sc_dimension(sc) = vect_size(ib);
    base_rm(b), b = BASE_NULLE;
 
    ifdebug(8) {
      pips_debug(8, "All invariants with proper basis =\n");
      sc_fprint(stderr, sc, (char * (*)(Variable)) external_value_name);
    }
 
    /* Plug sc back into tc_tf */
    predicate_system(transformer_relation(tc_tf)) = sc;
    transformer_arguments(tc_tf) = gal;
 
  }
  /* That's all! */
 
  ifdebug(8) {
    pips_debug(8, "Transitive closure tc_tf=\n");
    fprint_transformer(stderr, tc_tf, (get_variable_name_t) external_value_name);
    transformer_consistency_p(tc_tf);
    pips_debug(8, "end\n");
  }
 
  return tc_tf;
}

References arguments_add_entity(), Ssysteme::base, base_add_variable(), BASE_NULLE, BASE_NULLE_P, base_remove_variable(), base_rm, base_union(), contrainte_make(), CONTRAINTE_UNDEFINED, cute_convex_union(), Ssysteme::dimension, ENDP, ENTITY, entity_is_argument_p(), entity_to_intermediate_value(), entity_to_new_value(), eq, external_value_name(), FOREACH, fprint_transformer(), ifdebug, make_local_temporary_integer_value_entity(), NIL, old_value_entity_p(), pips_debug, predicate_system, print_transformers(), sc_copy(), sc_empty(), sc_equation_add(), sc_fprint(), sc_free(), sc_multiply_constant_terms(), sc_to_minimal_basis(), Svecteur::succ, TCST, TRANSFORMER, transformer_arguments, transformer_consistency_p(), transformer_derivative_constraints(), transformer_empty(), transformer_identity(), transformer_relation, VALUE_MONE, VALUE_ONE, value_to_variable(), VALUE_ZERO, vect_make(), vect_size(), VECTEUR_NUL, and vecteur_var.

Referenced by transformer_list_transitive_closure(), and transformer_list_transitive_closure_plus().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_multiple_closure_to_precondition()

transformer transformer_list_multiple_closure_to_precondition	(	list	tl,
		transformer	c_t,
		transformer	p_0
	)

When some variables are not modified by some transformers, use projections on subsets to increase the number of identity transformers and to increase the accuracy of the loop precondition.

The preconditions obtained with the different projections are intersected.

FI: this may be useless when derivatives are computed before the convex union. No. This was due to a bug in the computation of list of derivatives.

FI: this should be mathematically useless but it useful when a heuristic is used to compute the invariant. The number of transitions is reduced and hence a limited number of combinations is more likely to end up with a precise result.

Parameters

tl	l
c_t	_t
p_0	_0

Definition at line 826 of file transformer_list.c.

{
  transformer prec = transformer_list_closure_to_precondition(tl, c_t, p_0);
 
  if(get_bool_property("SEMANTICS_USE_LIST_PROJECTION")) {
    list al = transformer_arguments(prec);
    list vl = transformer_list_to_argument(tl); // list of modified
    // variables
    // FI: this is too strong vl must only be included in transformer_arguments(prec)
    //pips_assert("all modified variables are argument of the global precondition",
    //arguments_equal_p(vl, transformer_arguments(prec)));
    FOREACH(ENTITY, v, vl) {
      // FI: the same projection could be obtained for different
      // variables v and the computation should not be performed again
      // but I choose not to memoize past lists tl_v
      list tl_v = transformer_list_with_effect(tl, v);
 
      if(gen_length(tl_v)<gen_length(tl)) {
        list keep_v = transformer_list_preserved_variables(vl, tl, tl_v);
        list proj_v = arguments_difference(vl, keep_v);
        list ptl_v = transformer_list_safe_variables_projection(tl_v, proj_v);
        transformer p_0_v
          = safe_transformer_projection(copy_transformer(p_0), proj_v);
        transformer c_t_v
          = safe_transformer_projection(copy_transformer(c_t), proj_v);
        transformer prec_v
          = transformer_list_closure_to_precondition(ptl_v, c_t_v, p_0_v);
        if(arguments_subset_p(transformer_arguments(prec_v), al)) {
          // FI: this generates an inconsistent transformer if
          // transformer_arguments(prec_v) is not a subset of al...
          transformer_arguments(prec_v) = gen_copy_seq(al); // memory leak
        }
        else {
          transformer n_prec_v = transformer_range(prec_v);
          free_transformer(prec_v);
          prec_v = n_prec_v;
          transformer_arguments(prec_v) = gen_copy_seq(al);
        }
        prec = transformer_intersection(prec, prec_v); // memory leak
        // transformer_intersection() returns an inconsistent transformer
        // The argument list is empty but an old value is used in the conditions
        // prec = transformer_range(prec); // memory leak
        pips_assert("prec is consistent", transformer_consistent_p(prec));
 
        free_transformer(prec_v);
        free_transformer(c_t_v);
        free_transformer(p_0_v);
        gen_full_free_list(ptl_v);
        gen_free_list(keep_v);
      }
      gen_free_list(tl_v);
    }
 
    gen_free_list(vl);
  }
  pips_assert("prec is consistent", transformer_consistency_p(prec));
  return prec;
}

References arguments_difference(), arguments_subset_p(), copy_transformer(), ENTITY, FOREACH, free_transformer(), gen_copy_seq(), gen_free_list(), gen_full_free_list(), gen_length(), get_bool_property(), pips_assert, safe_transformer_projection(), transformer_arguments, transformer_consistency_p(), transformer_consistent_p(), transformer_intersection(), transformer_list_closure_to_precondition(), transformer_list_preserved_variables(), transformer_list_safe_variables_projection(), transformer_list_to_argument(), transformer_list_with_effect(), and transformer_range().

Referenced by whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_preserved_variables()

list transformer_list_preserved_variables	(	list	vl,
		list	tl,
		list	tl_v
	)

returns the list of variables in vl which are not modified by transformers belonging to tl-tl_v.

tl_v is assumed to be a subset of tl.

Parameters

vl	l
tl	l
tl_v	l_v

Definition at line 786 of file transformer_list.c.

{
  list pvl = NIL;
 
  FOREACH(ENTITY, v, vl) {
    bool found_p = false;
    FOREACH(TRANSFORMER, t, tl) {
      if(!gen_in_list_p(t, tl_v)) {
        if(entity_is_argument_p(v, transformer_arguments(t))) {
          found_p = true;
          break;
        }
      }
    }
    if(!found_p) {
      pvl = CONS(ENTITY, v, pvl);
    }
  }
 
  pvl = gen_nreverse(pvl);
 
  return pvl;
}

References CONS, ENTITY, entity_is_argument_p(), FOREACH, gen_in_list_p(), gen_nreverse(), NIL, TRANSFORMER, and transformer_arguments.

Referenced by transformer_list_multiple_closure_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_safe_variables_projection()

list transformer_list_safe_variables_projection	(	list	tl,
		list	proj
	)

Returns a new list of newly allocated projected transformers.

If a value of a variable in list proj appears in t of tl, it is projected. New transformers are allocated to build the projection list.

Parameters

tl	l
proj	roj

Definition at line 730 of file transformer_list.c.

{
  list ptl = NIL;
  FOREACH(TRANSFORMER, t, tl) {
    list apl = NIL; // actual projection list
    transformer nt = copy_transformer(t);
    FOREACH(ENTITY, v, proj) {
      if(entity_is_argument_p(v, transformer_arguments(t))) {
        entity ov = entity_to_old_value(v);
        apl = CONS(ENTITY, ov, apl);
      }
      apl = CONS(ENTITY, v, apl);
    }
    nt = safe_transformer_projection(nt, apl);
    ptl = CONS(TRANSFORMER, nt, ptl);
    gen_free_list(apl);
  }
  ptl = gen_nreverse(ptl);
  return ptl;
}

References CONS, copy_transformer(), ENTITY, entity_is_argument_p(), entity_to_old_value(), FOREACH, gen_free_list(), gen_nreverse(), NIL, safe_transformer_projection(), TRANSFORMER, and transformer_arguments.

Referenced by transformer_list_multiple_closure_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_to_active_transformer_list()

list transformer_list_to_active_transformer_list

(

list

tl

)

Parameters

tl

l

Definition at line 454 of file transformer_list.c.

{
  list atl = NIL;
 
  FOREACH(TRANSFORMER, tf, tl) {
    if(!ENDP(transformer_arguments(tf)))
      atl = CONS(TRANSFORMER, copy_transformer(tf), atl);
  }
 
  atl = gen_nreverse(atl);
 
  return atl;
}

References CONS, copy_transformer(), ENDP, FOREACH, gen_nreverse(), NIL, TRANSFORMER, and transformer_arguments.

Referenced by whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_to_argument()

list transformer_list_to_argument

(

list

tl

)

Returns the list of variables modified by at least one transformer in tl.

Parameters

tl

l

Definition at line 753 of file transformer_list.c.

{
  list vl = NIL;
 
  FOREACH(TRANSFORMER, t, tl) {
    FOREACH(ENTITY, v, transformer_arguments(t)) {
      if(!gen_in_list_p(v, vl))
        vl = CONS(ENTITY, v, vl);
    }
  }
 
  vl = gen_nreverse(vl);
 
  return vl;
}

References CONS, ENTITY, FOREACH, gen_in_list_p(), gen_nreverse(), NIL, TRANSFORMER, and transformer_arguments.

Referenced by transformer_list_multiple_closure_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_to_transformer()

transformer transformer_list_to_transformer

(

list

ltl

)

Reduce the transformer list ltl to one transformer using the convex hull operator.

Parameters

ltl

tl

Definition at line 434 of file transformer_list.c.

{
  return generic_transformer_list_to_transformer(ltl, false);
}

References generic_transformer_list_to_transformer().

Referenced by complete_any_loop_transformer(), complete_repeatloop_transformer(), new_complete_whileloop_transformer(), transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_transitive_closure()

transformer transformer_list_transitive_closure

(

list

tfl

)

Compute (U tfl)*.

Parameters

tfl

fl

Definition at line 1141 of file transformer_list.c.

{
  return transformer_list_generic_transitive_closure(tfl, true);
}

References transformer_list_generic_transitive_closure().

Referenced by transformer_list_closure_to_precondition_depth_two(), transformer_list_closure_to_precondition_max_depth(), and unstructured_to_flow_insensitive_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_transitive_closure_plus()

transformer transformer_list_transitive_closure_plus

(

list

tfl

)

Compute (U tfl)+.

Parameters

tfl

fl

Definition at line 1147 of file transformer_list.c.

{
  return transformer_list_generic_transitive_closure(tfl, false);
}

References transformer_list_generic_transitive_closure().

Referenced by dag_or_cycle_to_flow_sensitive_postconditions_or_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_list_with_effect()

list transformer_list_with_effect	(	list	tl,
		entity	v
	)

build a sublist sl of the transformer list tl with transformers that modify the value of variable v

Parameters

tl

l

Definition at line 771 of file transformer_list.c.

{
  list sl = NIL;
 
  FOREACH(TRANSFORMER, t, tl){
    if(entity_is_argument_p(v, transformer_arguments(t)))
      sl = CONS(TRANSFORMER, t, sl);
  }
  sl = gen_nreverse(sl);
  return sl;
}

References CONS, entity_is_argument_p(), FOREACH, gen_nreverse(), NIL, TRANSFORMER, and transformer_arguments.

Referenced by transformer_list_multiple_closure_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_normalize()

transformer transformer_normalize	(	transformer	t,
		int	level
	)

Eliminate (some) rational or integer redundancy.

Remember that integer redundancy elimination may degrade results because some transformer operator such as convex hull use a rational interpretation of the constraints. Unfortunately, no information is given here about the properties used by the different functions of the C3 linear library which are used.

Does not take into account value types. So s=="hello" and s=="world" do not result into an empty transformer. But floating point values are taken into account.

Start with sc_bounded_normalization and then according to level:

0 -> sc_safe_elim_redund(), sc_elim_redund(), sc_inequations_elim_redund(), sc_rational_feasibility_ofl_ctrl()

1 -> sc_nredund(), build_sc_nredund_2pass(), build_sc_nredund_2pass_ofl_ctrl(), sc_normalize(), build_sc_nredund_1pass_ofl_ctrl(), build_sc_nredund_1pass_ofl_ctrl()

sc_normalize() is well documented (in French)

2 -> sc_strong_normalize(), sc_normalize() sc_strong_normalize_and_check_feasibility(), sc_check_inequality_redundancy(),

3 -> sc_strong_normalize2(): resolve the equations first, then deal with inequalities

4 -> sc_normalize2(): well documented; does not detect redundancy in a<=b, b<=c, a<=c

5 -> sc_strong_normalize3(), sc_strong_normalize_and_check_feasibility (ps, sc_rational_feasibility);

6 -> sc_strong_normalize4() sc_strong_normalize_and_check_feasibility2(ps, sc_normalize, variable_name, 2): well documented, deterministic

7 -> sc_strong_normalize5() sc_strong_normalize_and_check_feasibility2(ps, sc_rational_feasibility, variable_name, 2);

8 -> sc_safe_build_sc_nredund_1pass(): not documented build_sc_nredund_1pass(): do not take equations into consideration

See timing information in the comments below.

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

Select one tradeoff between speed and accuracy: enumerated by increasing speeds according to Beatrice

CA

Let start with an easy O(n) phase, unlikely to generate an overflow. It should be placed in another try-cath in order to return a better r2 in case of a later overflow.

This is not sufficient: it is more efficient to put this call directly in sc_normalize().

Our best choice for accuracy, but damned slow on ocean

Beatrice's best choice: does not deal with minmax2 (only) but still requires 74 minutes of real time (55 minutes of CPU time) for ocean preconditions, when applied to each precondition stored.

Only 64 s for ocean, if preconditions are not normalized. But andne, callabsval, dead2, hind, negand, negand2, or, validation_dead_code are not validated any more. Redundancy could always be detected in a trivial way after propagating values from equations into inequalities.

Francois' own: does most of the easy stuff. Fails on mimax2 and sum_prec, but it is somehow more user-friendly because trivial preconditions are not destroyed as redundant. It makes you feel safer.

Result for full precondition normalization on ocean: 114 s for preconditions, 4 minutes between split ocean.f and OCEAN.prec

Same plus a good feasibility test

Similar, but variable are actually substituted which is sometimes painful when a complex equations is used to replace a simple variable in a simple inequality.

Similar, but variables are substituted if they belong to a more or less simple equation, and simpler equations are processed first and a lexicographically minimal variable is chosen when equivalent variables are available.

Same plus a good feasibility test, plus variable selection for elimination, plus equation selection for elimination

Too expensive according to measurements by Beatrice Creusillet to be used anywhere but before storing transformers or preconditions or before printing them. Lots of calls to string operations when C is the analyzed language because variable names used for sorting are easy to extract due to scope information. It is not clear from the information mailed by Beatrice if sc_normalize2 is also too computational but it should be as only the basis of the constraint system is sorted out to normalize r more effectively.

Very expensive: the system is rebuilt by adding constraints one by one

end of TRY

Parameters

level

evel

Definition at line 932 of file transformer.c.

{
  ifdebug(1) {
    pips_assert("Transformer t is consistent on entrance",
                transformer_consistency_p(t));
  }
 
  if(!transformer_is_empty_p(t)) {
      if(float_analyzed_p()) {
        predicate_system(transformer_relation(t)) =
          simplify_float_constraint_system(predicate_system(transformer_relation(t)));
        ifdebug(1)
          pips_assert("t is consistent after floating point simplification\n",
                      transformer_consistent_p(t));
      }
 
      /* Automatic variables read in a CATCH block need to be declared volatile as
       * specified by the documentation*/
      Psysteme volatile r = (Psysteme) predicate_system(transformer_relation(t));
 
      if (!sc_empty_p(r)) {
        Pbase b = base_dup(sc_base(r));
        /* Automatic variables read in a CATCH block need to be declared volatile as
         * specified by the documentation*/
        Psysteme r2 = sc_dup(r);
 
        /* Select one tradeoff between speed and accuracy:
         * enumerated by increasing speeds according to Beatrice
         */
 
        CATCH(overflow_error)
        {
          /* CA */
          pips_user_warning("overflow error in  redundancy elimination\n");
          sc_rm(r);
          r = r2;
        }
        TRY
          {
            /* Let start with an easy O(n) phase, unlikely to generate an
               overflow. It should be placed in another try-cath in order
               to return a better r2 in case of a later overflow. */
            /* This is not sufficient: it is more efficient to put this
               call directly in sc_normalize(). */
            r = sc_bounded_normalization(r);
 
            switch(level) {
 
            case 0:
              /* Our best choice for accuracy, but damned slow on ocean */
              r = sc_safe_elim_redund(r);
              break;
 
            case 1:
              /* Beatrice's best choice: does not deal with minmax2 (only)
               * but still requires 74 minutes of real time
               * (55 minutes of CPU time) for ocean preconditions,
               * when applied to each precondition stored.
               *
               * Only 64 s for ocean, if preconditions are not normalized.
               * But andne, callabsval, dead2, hind, negand, negand2, or,
               * validation_dead_code are not validated any more. Redundancy
               * could always be detected in a trivial way after propagating
               * values from equations into inequalities.
               */
              sc_nredund(&r);
              //predicate_system(transformer_relation(t)) = r;
              break;
 
            case 2:
              /* Francois' own: does most of the easy stuff.
               * Fails on mimax2 and sum_prec, but it is somehow
               * more user-friendly because trivial preconditions are
               * not destroyed as redundant. It makes you feel safer.
               *
               * Result for full precondition normalization on ocean: 114 s
               * for preconditions, 4 minutes between split ocean.f and
               * OCEAN.prec
               */
              r = sc_strong_normalize(r);
              //          predicate_system(transformer_relation(t)) = r;
              break;
 
            case 5:
              /* Same plus a good feasibility test
               */
              r = sc_strong_normalize3(r);
              break;
 
            case 3:
              /* Similar, but variable are actually substituted
               * which is sometimes painful when a complex equations
               * is used to replace a simple variable in a simple
               * inequality.
               */
              r = sc_strong_normalize2(r);
              break;
            case 6:
              /* Similar, but variables are substituted if they belong to
               * a more or less simple equation, and simpler equations
               * are processed first and a lexicographically minimal
               * variable is chosen when equivalent variables are
               * available.
               */
              r = sc_strong_normalize4(r,
                                       (char * (*)(Variable)) external_value_name);
              break;
 
            case 7:
              /* Same plus a good feasibility test, plus variable selection
               * for elimination, plus equation selection for elimination
               */
              r = sc_strong_normalize5(r,
                                       (char * (*)(Variable)) external_value_name);
              break;
 
            case 4:
              /* Too expensive according to measurements by Beatrice
               * Creusillet to be used anywhere but before storing
               * transformers or preconditions or before printing
               * them. Lots of calls to string operations when C is the
               * analyzed language because variable names used for sorting
               * are easy to extract due to scope information. It is not
               * clear from the information mailed by Beatrice if
               * sc_normalize2 is also too computational but it should be
               * as only the basis of the constraint system is sorted out
               * to normalize r more effectively.
               */
              vect_sort_in_place(&sc_base(r), varval_value_name_is_inferior_p);
              r = sc_normalize2(r);
              break;
 
            case 8:
              /* Very expensive: the system is rebuilt by adding constraints
               * one by one
               */
              sc_safe_build_sc_nredund_1pass(&r);
              break;
 
            default:
              pips_internal_error("unknown level %d", level);
            }
 
            sc_rm(r2), r2 = NULL;
            UNCATCH(overflow_error);
          } /* end of TRY */
 
        if (SC_EMPTY_P(r)) {
          r = sc_empty(BASE_NULLE);
        }
        else
          base_rm(b), b=BASE_NULLE;
 
        r->dimension = vect_size(r->base);
 
        if(sc_empty_p(r)) {
          //empty_transformer(t);
          predicate_system(transformer_relation(t)) = r;
          free_arguments(transformer_arguments(t));
          transformer_arguments(t) = NIL;
        }
        else
          predicate_system(transformer_relation(t)) = r;
      }
    }
  ifdebug(8) {
    fprintf(stderr, "After normalization of transformer t=%p at level %d:\n",
            t, level);
    fprint_transformer(stderr, t, (get_variable_name_t) entity_local_name);
  }
 
  ifdebug(1) {
    pips_assert("Transformer t is consistent on exit",
                transformer_consistency_p(t));
  }
 
  return t;
}

References Ssysteme::base, base_dup(), BASE_NULLE, base_rm, CATCH, Ssysteme::dimension, entity_local_name(), external_value_name(), float_analyzed_p(), fprint_transformer(), fprintf(), free_arguments(), ifdebug, level, NIL, overflow_error, pips_assert, pips_internal_error, pips_user_warning, predicate_system, sc_bounded_normalization(), sc_dup(), sc_empty(), sc_empty_p(), sc_normalize2(), sc_rm(), sc_safe_build_sc_nredund_1pass(), sc_safe_elim_redund(), sc_strong_normalize(), sc_strong_normalize2(), sc_strong_normalize3(), sc_strong_normalize4(), sc_strong_normalize5(), simplify_float_constraint_system(), transformer_arguments, transformer_consistency_p(), transformer_consistent_p(), transformer_is_empty_p(), transformer_relation, TRY, UNCATCH, varval_value_name_is_inferior_p(), vect_size(), and vect_sort_in_place().

Referenced by any_expressions_to_transformer(), any_user_call_site_to_transformer(), block_to_postcondition(), block_to_transformer(), block_to_transformer_list(), call_site_to_module_precondition_text(), call_to_transformer(), combine_transformer_lists(), complete_any_loop_transformer_list(), complete_loop_transformer(), complete_loop_transformer_list(), condition_to_transformer(), declarations_to_transformer(), declarations_to_transformer_list(), expression_multiply_sizeof_to_transformer(), expressions_to_transformer(), generic_module_name_to_transformers(), integer_multiply_to_transformer(), logical_binary_function_to_transformer(), loop_to_enter_transformer(), module_name_to_total_preconditions(), ordinary_summary_precondition(), propagate_preconditions_in_declarations(), statement_to_postcondition(), statement_to_total_precondition(), statement_to_transformer(), statement_to_transformer_list(), summary_precondition(), summary_total_postcondition(), test_to_postcondition(), test_to_total_precondition(), transformer_add_any_relation_information(), transformer_convex_hull(), transformer_list_add_combination(), transformer_safe_normalize(), and update_precondition_with_call_site_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_pattern_fix_point()

transformer transformer_pattern_fix_point

(

transformer

tf

)

This fixpoint function was developped to present a talk at FORMA.

I used examples published by Pugh and I realized that the fixpoint constraints were obvious in the loop body transformer. You just had to identify them. This is not a clever algorithm. It certainly would not resist any messing up with the constraints, i.e. a change of basis. But it provides very good result for a class of applications.

Algorithm:

1. Find a loop counter
2. Use it to eliminate all constant terms
3. Look for invariant constraints

Let d_i = i::new - i::old. An invariant constraint is a sum of d_i which is equal to zero or greater than zero. Such a constraint is its own fixpoint: if you combine it with itself after renaming i::new as i::int on one hand and i::old as i::int on the other, the global sum for and equation or its sign for an inequality is unchanged.

result

Look for the best loop counter: the smallest increment is chosen

eliminate sharing between v_inc and fix_sc

Replace constant terms in equalities and inequalities by loop counter differences

Remove all constraints to build the invariant transformer

Parameters

tf

f

Definition at line 709 of file fix_point.c.

{
    /* result */
    transformer fix_tf =  transformer_dup(tf);
    Psysteme fix_sc = (Psysteme) predicate_system(transformer_relation(fix_tf));
    Pvecteur v_inc = VECTEUR_UNDEFINED;
 
    ifdebug(8) {
        pips_debug(8, "Begin for transformer %p:\n", tf);
        fprint_transformer(stderr, tf,
                           (get_variable_name_t) external_value_name);
    }
 
    /* Look for the best loop counter: the smallest increment is chosen */
    v_inc = look_for_the_best_counter(sc_egalites(fix_sc));
 
    if(!VECTEUR_UNDEFINED_P(v_inc)) {
 
        ifdebug(8) {
            pips_debug(8, "incrementation vector=\n");
            vect_fprint(stderr, v_inc, (char * (*)(Variable)) external_value_name);
        }
 
        /* eliminate sharing between v_inc and fix_sc */
        v_inc = vect_dup(v_inc);
 
        /* Replace constant terms in equalities and inequalities by
         * loop counter differences
         */
        fix_sc = sc_eliminate_constant_terms(fix_sc, v_inc);
 
        ifdebug(8) {
            pips_debug(8, "after constant term elimination=\n");
            sc_fprint(stderr, fix_sc, (char * (*)(Variable)) external_value_name);
        }
 
        fix_sc = sc_elim_redund(fix_sc);
 
        ifdebug(8) {
            pips_debug(8, "after normalization=\n");
            sc_fprint(stderr, fix_sc, (char * (*)(Variable)) external_value_name);
        }
 
        fix_sc = sc_keep_invariants_only(fix_sc);
 
        ifdebug(8) {
            pips_debug(8, "after non-invariant elimination=\n");
            sc_fprint(stderr, fix_sc, (char * (*)(Variable)) external_value_name);
        }
 
        fix_sc = sc_elim_redund(fix_sc);
 
        ifdebug(8) {
            pips_debug(8, "after 2nd normalization=\n");
            sc_fprint(stderr, fix_sc, (char * (*)(Variable)) external_value_name);
        }
    }
    else {
        pips_debug(8, "No counter found\n");
        /* Remove all constraints to build the invariant transformer */
        contraintes_free(sc_egalites(fix_sc));
        sc_egalites(fix_sc) = CONTRAINTE_UNDEFINED;
        sc_nbre_egalites(fix_sc) = 0;
        contraintes_free(sc_inegalites(fix_sc));
        sc_inegalites(fix_sc) = CONTRAINTE_UNDEFINED;
        sc_nbre_inegalites(fix_sc) = 0;
    }
 
    ifdebug(8) {
        pips_debug(8, "fix-point fix_tf=\n");
        fprint_transformer(stderr, fix_tf, (get_variable_name_t) external_value_name);
        pips_debug(8, "end\n");
    }
 
    return fix_tf;
}

transformer_projectable_values()

list transformer_projectable_values

(

transformer

tf

)

Parameters

tf

f

Definition at line 827 of file basic.c.

{
  list proj = NIL;
  Psysteme sc = predicate_system(transformer_relation(tf));
  Pbase b = BASE_UNDEFINED;
 
  for(b=sc_base(sc); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
    entity v = (entity) vecteur_var(b);
 
    proj = CONS(ENTITY, v, proj);
  }
 
  return proj;
}

References BASE_NULLE_P, BASE_UNDEFINED, CONS, ENTITY, NIL, predicate_system, transformer_relation, vecteur_succ, and vecteur_var.

Referenced by recompute_loop_transformer().

Here is the caller graph for this function:

transformer_projection()

transformer transformer_projection	(	transformer	t,
		list	args
	)

values in args must be in t's base

transformer transformer_projection(transformer t, cons * args): projection of t along the hyperplane defined by values in args; this generate a projection and not a cylinder based on the projection

use the most complex/complete redundancy elimination in Linear

args is not modified. t is modified by side effects.

sc_safe_elim_redund() may increase the rational generating system

t = transformer_projection_with_redundancy_elimination(t, args, sc_safe_elim_redund);

Parameters

args

rgs

Definition at line 1267 of file transformer.c.

{
  /* sc_safe_elim_redund() may increase the rational generating system */
  /* t = transformer_projection_with_redundancy_elimination(t, args,
     sc_safe_elim_redund); */
  t = transformer_projection_with_redundancy_elimination(t, args,
                                                         sc_safe_normalize);
  return t;
}

References sc_safe_normalize(), and transformer_projection_with_redundancy_elimination().

Referenced by generic_transformer_intra_to_inter(), new_array_element_backward_substitution_in_transformer(), precondition_to_abstract_store(), recompute_loop_transformer(), safe_transformer_projection(), transformer_add_loop_index_initialization(), transformer_arguments_projection(), transformer_filter_subsumed_variables(), transformer_formal_parameter_projection(), transformer_return_value_projection(), translate_global_value(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_projection_with_redundancy_elimination()

transformer transformer_projection_with_redundancy_elimination	(	transformer	t,
		list	args,
		Psysteme(*)(Psysteme)	elim
	)

It is not clear if this function projects values or variables.

If variables were projected, all values associated to a variable should also be projected. If values are projected and the transformer argument updated using args, old values should not be left in the basis when a new value is projected and its associated variable removed from tthe argument.

New values are identical to variables which makes it confusing.

The implementation, and the signature, are aware of the nature of the underlying predicate.

Parameters

args

rgs

Definition at line 1322 of file transformer.c.

{
  return transformer_projection_with_redundancy_elimination_and_check
    (t, args, elim, true);
}

References transformer_projection_with_redundancy_elimination_and_check().

Referenced by precondition_intra_to_inter(), transformer_projection(), transformer_range(), and transformer_temporary_value_projection().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_projection_with_redundancy_elimination_and_check()

transformer transformer_projection_with_redundancy_elimination_and_check	(	volatile	transformer,
		list	args,
		Psysteme(*)(Psysteme)	elim,
		bool	check_consistency_p
	)

Library Linear/sc contains several reundancy elimination functions: sc_elim_redund() build_sc_nredund_2pass_ofl_ctrl() — if it had the same profile... ... no_elim() is provided here to obtain the fastest possible projection

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

sc_fprint(stderr, r, exernal_value_name);

sc_fprint(stderr, r, (char * (*)(Variable)) entity_local_name);

A side effect of transformer_empty_p() is to normalize the transformer.

This is very expensive before a projection. empty_transformer_p()

Step 1: get rid of unwanted values in the relation r and in the basis

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

FC

sc_projection_along_variable_ofl_ctrl_timeout_ctrl

could eliminate redundancy at each projection stage to avoid explosion of the constraint number... however it is pretty expensive to do so. But we explode with NPRIO in FPPP (Spec CFP'95 benchmark). A heuristic could apply redundacy elimination from time to time?

Eliminate trivial redundant constraints generated by the projection

Probably redundant with what happens in elim()

if (SC_EMPTY_P(r)) { r = sc_empty(BASE_NULLE); sc_base_remove_variable(r,(Variable) e); } else base_rm(b); }

sc_fprint(stderr, r, exernal_value_name);

Step 2: eliminate redundancy only/again once projections have all been performed because redundancy elimination is expensive and because most variables are exactly projected because they appear in at least one equation

Should we use b or not? It does make some mathematical sense but it is not compatible with the argument list which should not be empty if old values appear in the basis. And the basis should not be used, even in convex hulls if the emptiness is detected first.

get rid of a useless basis

sc_fprint(stderr, r, exernal_value_name);

Step 3: compute new_args, but beware of left over old values!

e must be kept if it is not in args

The variable is going to be dropped from the argument list

Must be a variable from a module which is not the current module

Step 4: update the relation and the arguments field for t

the relation is updated by side effect FI ? Maybe not if SC_EMPTY(r) 1 Feb. 94

replace the old arguments by the new one, except if the constraint system is not feasible

sc_fprint(stderr, r, exernal_value_name);

Weak, because return value may still be present for functions.

Parameters

args	rgs
check_consistency_p	heck_consistency_p

Definition at line 1343 of file transformer.c.

{
  /* Library Linear/sc contains several reundancy elimination functions:
   *  sc_elim_redund()
   *  build_sc_nredund_2pass_ofl_ctrl() --- if it had the same profile...
   *  ...
   * no_elim() is provided here to obtain the fastest possible projection
   */
  volatile list new_args = NIL;
  /* Automatic variables read in a CATCH block need to be declared volatile as
   * specified by the documentation*/
  Psysteme volatile r = (Psysteme) predicate_system(transformer_relation(t));
 
  ifdebug(9) {
    pips_debug(9, "Begin for transformer %p\n", t);
    /* sc_fprint(stderr, r, exernal_value_name); */
    /* sc_fprint(stderr, r, (char * (*)(Variable)) entity_local_name); */
    fprint_transformer(stderr, t, (get_variable_name_t) entity_global_name);
    pips_debug(9, "and entities to be projected: ");
    print_entities(args);
  }
 
  pips_assert("t is weakly consistent", transformer_weak_consistency_p(t));
 
  /* A side effect of transformer_empty_p() is to normalize the transformer.
   *
   * This is very expensive before a projection. empty_transformer_p()
   */
  if(transformer_empty_p(t)) {
    t = empty_transformer(t);
  }
  else if(!ENDP(args)) {
    volatile list cea;
    Pbase mb = sc_to_minimal_basis(r); // Get the variables with non-zero coefficients
 
    /* Step 1: get rid of unwanted values in the relation r and in the basis */
    for (cea = args ; !ENDP(cea); POP(cea)) {
      /* Automatic variables read in a CATCH block need to be declared
       * volatile as specified by the documentation*/
      entity volatile e = ENTITY(CAR(cea));
      pips_assert("base contains variable to project...",
                  base_contains_variable_p(sc_base(r), (Variable) e));
 
      pips_debug(9, "Projection of %s\n", entity_name(e));
 
      if(base_contains_variable_p(mb, (Variable) e)) {
        // The variable appears with a non-zero coefficient in at least one constraint
        CATCH(overflow_error)
        {
          /* FC */
          pips_user_warning("overflow error in projection of %s, "
                            "variable eliminated\n",
                            entity_name(e));
          r = sc_elim_var(r, (Variable) e);
        }
        TRY
          {
            /* sc_projection_along_variable_ofl_ctrl_timeout_ctrl */
            sc_projection_along_variable_ofl_ctrl
              (&r,(Variable) e, NO_OFL_CTRL);
            UNCATCH(overflow_error);
          }
 
        /* could eliminate redundancy at each projection stage to avoid
         * explosion of the constraint number...  however it is pretty
         * expensive to do so. But we explode with NPRIO in FPPP (Spec
         * CFP'95 benchmark). A heuristic could apply redundacy elimination
         * from time to time?
         *
         */
 
        if(true) {
          // if (!sc_empty_p(r)) {
          // Pbase b = base_dup(sc_base(r));
 
          /* Eliminate trivial redundant constraints generated by the
             projection */
          /* Probably redundant with what happens in elim() */
          r = sc_bounded_normalization(r);
 
          r = elim(r);
          /* if (SC_EMPTY_P(r)) {
             r = sc_empty(BASE_NULLE);
             sc_base_remove_variable(r,(Variable) e);
             }
             else base_rm(b);
             }*/
 
        }
      }
 
      sc_base_remove_variable(r,(Variable) e);
 
      ifdebug(9) {
        pips_debug(9, "System after projection of %s\n", entity_name(e));
        /* sc_fprint(stderr, r, exernal_value_name); */
        sc_fprint(stderr, r, (char * (*)(Variable)) entity_global_name);
      }
    }
    vect_rm(mb);
 
    /* Step 2: eliminate redundancy only/again once projections have all
     * been performed because redundancy elimination is
     * expensive and because most variables are exactly
     * projected because they appear in at least one equation
     */
    if (!sc_empty_p(r)) {
      Pbase b = base_dup(sc_base(r));
      r = elim(r);
      if (SC_EMPTY_P(r)) {
        /* Should we use b or not? It does make some mathematical sense
           but it is not compatible with the argument list which should
           not be empty if old values appear in the basis. And the basis
           should not be used, even in convex hulls if the emptiness is
           detected first. */
        r = sc_empty(BASE_NULLE);
        base_rm(b);
      }
      else {
        base_rm(b);
      }
    }
    else {
      /* get rid of a useless basis */
      base_rm(sc_base(r));
      sc_base(r) = BASE_NULLE;
    }
 
    r->dimension = vect_size(r->base);
 
    ifdebug(9) {
      pips_debug(9, "System after redundancy elimination\n");
      /* sc_fprint(stderr, r, exernal_value_name); */
      sc_fprint(stderr, r, (char * (*)(Variable)) entity_global_name);
    }
 
    /* Step 3: compute new_args, but beware of left over old values! */
    FOREACH(ENTITY, e, transformer_arguments(t)) {
      if(!local_temporary_value_entity_p(e)) {
        entity v = value_to_variable(e);
 
        if((entity) gen_find_eq(e, args) == (entity) chunk_undefined)
          {
            /* e must be kept if it is not in args */
            new_args = arguments_add_entity(new_args, e);
          }
        else {
          /* The variable is going to be dropped from the argument list */
          entity old_e = entity_undefined;
 
          if(entity_has_values_p(v)) {
            old_e = entity_to_old_value(v);
          }
          else {
            /* Must be a variable from a module which is not the current module */
            old_e = global_new_value_to_global_old_value(v);
          }
 
          if(check_consistency_p
             && base_contains_variable_p(sc_base(r), (Variable) old_e)) {
            fprintf(stderr, "Value %s should have been eliminated earlier\n",
                    entity_name(old_e));
            fprint_transformer(stderr, t, (get_variable_name_t) entity_global_name);
            pips_internal_error("Wrong set of projected variables");
          }
        }
      }
    }
 
    /* Step 4: update the relation and the arguments field for t */
 
    /* the relation is updated by side effect FI ?
     * Maybe not if SC_EMPTY(r) 1 Feb. 94 */
    predicate_system_(transformer_relation(t)) = newgen_Psysteme(r);
 
    /* replace the old arguments by the new one, except if the
       constraint system is not feasible */
    gen_free_list(transformer_arguments(t));
    if(sc_empty_p(r)) {
      transformer_arguments(t) = NULL;
      gen_free_list(new_args);
    }
    else
      transformer_arguments(t) = new_args;
  }
 
  ifdebug(9) {
    pips_debug(9, "Transformer after argument list update\n");
    /* sc_fprint(stderr, r, exernal_value_name); */
    fprint_transformer(stderr, t, (get_variable_name_t) entity_global_name);
  }
 
  ifdebug(1) {
    /* Weak, because return value may still be present for functions. */
    if(check_consistency_p)
      pips_assert("After projection and redundancy elimination,"
                  " transformer t is consistent",
                  transformer_weak_consistency_p(t));
  }
  pips_debug(9, "End for t=%p\n", t);
 
  return t;
}

References arguments_add_entity(), Ssysteme::base, base_contains_variable_p(), base_dup(), BASE_NULLE, base_rm, CAR, CATCH, chunk_undefined, Ssysteme::dimension, empty_transformer(), ENDP, ENTITY, entity_global_name(), entity_has_values_p(), entity_name, entity_to_old_value(), entity_undefined, FOREACH, fprint_transformer(), fprintf(), gen_find_eq(), gen_free_list(), global_new_value_to_global_old_value(), ifdebug, local_temporary_value_entity_p(), newgen_Psysteme, NIL, NO_OFL_CTRL, overflow_error, pips_assert, pips_debug, pips_internal_error, pips_user_warning, POP, predicate_system, predicate_system_, print_entities(), sc_base_remove_variable(), sc_bounded_normalization(), sc_elim_var(), sc_empty(), sc_empty_p(), sc_fprint(), sc_to_minimal_basis(), transformer_arguments, transformer_empty_p(), transformer_relation, transformer_weak_consistency_p(), TRY, UNCATCH, value_to_variable(), vect_rm(), and vect_size().

Referenced by transformer_projection_with_redundancy_elimination(), and transformer_projection_without_check().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_projection_without_check()

transformer transformer_projection_without_check	(	transformer	t,
		list	args,
		Psysteme(*)(Psysteme)	elim
	)

In some cases, you know the projection will result in a non-consistent transformer that will be fixed later.

The input transformer is nevertheless expected weakly consistent.

Parameters

args

rgs

Definition at line 1334 of file transformer.c.

{
  return transformer_projection_with_redundancy_elimination_and_check
    (t, args, elim, false);
}

References transformer_projection_with_redundancy_elimination_and_check().

Referenced by transformer_to_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_range()

transformer transformer_range

(

transformer

tf

)

Return the range of relation tf in a newly allocated transformer.

Projection of all old values.

A variable may be modified but its old value does not have to appear in the basis. Although the opposite is wrong.

rtf = transformer_projection(rtf, args);

Parameters

tf

f

Definition at line 714 of file transformer.c.

{
  transformer rtf = transformer_dup(tf);
  list args = NIL;
  Psysteme sc = predicate_system(transformer_relation(rtf));
  Pbase b = sc_base(sc);
 
  FOREACH(ENTITY, a, transformer_arguments(rtf)) {
    entity ov = entity_to_old_value(a);
 
    /* A variable may be modified but its old value does not have to
       appear in the basis. Although the opposite is wrong. */
    if(base_contains_variable_p(b, (Variable)  ov)) {
      args = CONS(ENTITY, ov, args);
    }
  }
 
  /* rtf = transformer_projection(rtf, args); */
  rtf = transformer_projection_with_redundancy_elimination(rtf, args,
                                                           sc_identity);
 
  gen_free_list(args);
 
  gen_free_list(transformer_arguments(rtf));
  transformer_arguments(rtf) = NIL;
 
  return rtf;
}

References base_contains_variable_p(), CONS, ENTITY, entity_to_old_value(), FOREACH, gen_free_list(), NIL, predicate_system, sc_identity(), transformer_arguments, transformer_dup(), transformer_projection_with_redundancy_elimination(), and transformer_relation.

Referenced by add_index_bound_conditions(), add_loop_index_initialization(), addition_operation_to_transformer(), any_conditional_to_transformer(), any_expressions_to_transformer(), any_loop_to_k_transformer(), any_transformer_to_k_closure(), assign_rhs_to_reflhs_to_transformer(), bitwise_xor_to_transformer(), block_to_transformer_list(), c_data_to_prec_for_variables(), call_to_postcondition(), complete_loop_transformer(), condition_to_transformer(), conditional_to_transformer(), declaration_to_transformer(), declaration_to_transformer_list(), declarations_to_transformer(), declarations_to_transformer_list(), dimensions_to_transformer(), do_array_expansion(), do_solve_hardware_constraints_on_nb_proc(), do_solve_hardware_constraints_on_volume(), effects_to_dma(), eval_linear_expression(), expression_multiply_sizeof_to_transformer(), expressions_to_transformer(), fortran_data_to_prec_for_variables(), generic_unary_operation_to_transformer(), integer_binary_operation_to_transformer(), integer_left_shift_to_transformer(), integer_multiply_to_transformer(), integer_power_to_transformer(), logical_not_to_transformer(), loop_body_transformer_add_entry_and_iteration_information(), loop_to_postcondition(), loop_to_transformer(), memorize_precondition_for_summary_precondition(), modulo_to_transformer(), new_loop_to_transformer(), partial_eval_min_or_max_operator(), pointer_unary_operation_to_transformer(), precondition_add_condition_information(), process_ready_node(), safe_assigned_expression_to_transformer(), safe_assigned_expression_to_transformer_list(), statement_to_total_precondition(), statement_to_transformer(), statement_to_transformer_list(), transformer_add_any_relation_information(), transformer_combine(), transformer_intersect_range_with_domain(), transformer_list_multiple_closure_to_precondition(), transformer_safe_range(), transformers_range(), unstructured_to_flow_sensitive_postconditions_or_transformers(), unstructured_to_postconditions(), and whileloop_to_postcondition().

Here is the call graph for this function:

transformer_range_intersection()

transformer transformer_range_intersection	(	transformer	tf,
		transformer	r
	)

Allocate a new transformer rtf that is tf with its range restricted by the range r.

As a range, r is assumed to have no arguments.

Parameters

tf

f

Definition at line 830 of file transformer.c.

{
  pips_assert("r does not involve old values and has no arguments",
              ENDP(transformer_arguments(r)));
  transformer rtf = transformer_image_intersection(tf, r);
 
  return rtf;
}

References ENDP, pips_assert, transformer_arguments, and transformer_image_intersection().

Referenced by add_index_bound_conditions(), integer_expression_and_precondition_to_integer_interval(), process_ready_node(), and transformer_combine().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_return_value_projection()

transformer transformer_return_value_projection	(	entity	f,
		transformer	t
	)

Project return values that are not linked to function f.

Almost identical to transformer_formal_parameter_projection(). A lambda expression should be passed for the filtering.

Dealing with an interprocedural transformer, weak consistency is not true

pips_assert("t is weakly consistent", transformer_weak_consistency_p(t));

Definition at line 1220 of file transformer.c.

{
  Psysteme sc = predicate_system(transformer_relation(t));
  Pbase b = sc_base(sc);
  Pbase cd = BASE_UNDEFINED;
  list fpl = NIL;
 
  /* Dealing with an interprocedural transformer, weak consistency is
     not true */
  /* pips_assert("t is weakly consistent",
     transformer_weak_consistency_p(t));*/
  pips_assert("sc is consistent", sc_weak_consistent_p(sc));
  pips_assert("t is weakly consistent", transformer_weak_consistency_p(t));
 
  for(cd = b; !BASE_NULLE_P(cd); cd = vecteur_succ(cd)) {
    entity val = (entity) vecteur_var(cd);
    entity var = value_to_variable(val);
    storage s = entity_storage(var);
 
    if(storage_return_p(s) && storage_return(s)!=f)
      fpl = CONS(ENTITY, var, fpl);
  }
 
  ifdebug(1) {
    pips_debug(1, "Transformer before projection:\n");
    dump_transformer(t);
    pips_debug(1, "Projected variables:\n");
    print_entities(fpl);
    fprintf(stderr, "\n");
  }
 
  t = transformer_projection(t, fpl);
 
  gen_free_list(fpl);
 
  return t;
}

References BASE_NULLE_P, BASE_UNDEFINED, CONS, dump_transformer, ENTITY, entity_storage, f(), fprintf(), gen_free_list(), ifdebug, NIL, pips_assert, pips_debug, predicate_system, print_entities(), sc_weak_consistent_p(), storage_return, storage_return_p, transformer_projection(), transformer_relation, transformer_weak_consistency_p(), value_to_variable(), vecteur_succ, and vecteur_var.

Referenced by struct_reference_assignment_or_equality_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_affect_transformer_p()

bool transformer_safe_affect_transformer_p	(	transformer	tf1,
		transformer	tf2
	)

Parameters

tf1	f1
tf2	f2

Definition at line 1894 of file transformer.c.

{
  bool affect_p = false;
 
  if(!transformer_undefined_p(tf1) && !transformer_undefined_p(tf2))
    affect_p = transformer_affect_transformer_p(tf1, tf2);
 
  return affect_p;
}

References transformer_affect_transformer_p(), and transformer_undefined_p.

Referenced by transformer_safe_combine_with_warnings().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_apply()

transformer transformer_safe_apply	(	transformer	tf,
		transformer	pre
	)

Parameters

tf	f
pre	re

Definition at line 1627 of file transformer.c.

{
  transformer post = transformer_undefined;
 
  if(!transformer_undefined_p(tf) && !transformer_undefined_p(pre))
    post = transformer_apply(tf, pre);
 
  return post;
}

References transformer_apply(), transformer_undefined, and transformer_undefined_p.

Referenced by block_to_transformer(), block_to_transformer_list(), declarations_to_transformer(), declarations_to_transformer_list(), expression_multiply_sizeof_to_transformer(), integer_binary_operation_to_transformer(), integer_left_shift_to_transformer(), integer_multiply_to_transformer(), loop_bound_evaluation_to_transformer(), propagate_preconditions_in_declarations(), transformers_safe_apply(), and unstructured_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_combine_with_warnings()

transformer transformer_safe_combine_with_warnings	(	transformer	tf1,
		transformer	tf2
	)

Transformer tf1 and tf2 are supposed to be independent but they may interfere, for instance because subexpressions have non-standard conformant side effects.

tf12 is a newly allocated transformer with no sharing with tf1 or tf2 (theoretically).

Intersection is not powerful enough to cope with side effects. But side effects can be dealt with only if the operation order is known when the standard is violated. We assume here a right to left evaluation.

No side effects at all

Parameters

tf1	f1
tf2	f2

Definition at line 493 of file transformer.c.

{
  transformer tf12 = transformer_undefined;
 
  /* Intersection is not powerful enough to cope with side effects. But
     side effects can be dealt with only if the operation order is known
     when the standard is violated. We assume here a right to left evaluation. */
  if(transformer_safe_affect_transformer_p(tf1, tf2)) {
    pips_debug(9, "Side effects of tf2 on tf1\n");
    pips_user_warning("Non standard compliant code: side effect in part\n"
                      "of an expression affects variable(s) used in a later part\n");
    tf12 = transformer_combine(tf1, tf2);
  }
  else if (transformer_safe_affect_transformer_p(tf2, tf1)){
    pips_debug(9, "Side effects of tf2 on tf1\n");
    pips_user_warning("Non standard compliant code: side effect in part\n"
                      "of an expression affect variables used in an earlier part\n");
    tf12 = transformer_combine(tf1, tf2);
  }
  else {
    pips_debug(9, "No adversary side effects\n");
    if(transformer_undefined_p(tf1)
       || transformer_undefined_p(tf2)
       || (ENDP(transformer_arguments(tf1)) && ENDP(transformer_arguments(tf2)))) {
      /* No side effects at all */
      pips_debug(9, "No side effects at all\n");
      tf12 = transformer_safe_intersection(tf1, tf2);
      free_transformer(tf1);
    }
    else {
      pips_debug(9, "Side effects on other variables\n");
      tf12 = transformer_combine(tf1, tf2);
    }
  }
  return tf12;
}

References ENDP, free_transformer(), pips_debug, pips_user_warning, transformer_arguments, transformer_combine(), transformer_safe_affect_transformer_p(), transformer_safe_intersection(), transformer_undefined, and transformer_undefined_p.

Referenced by addition_operation_to_transformer(), and transformer_add_any_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_domain()

transformer transformer_safe_domain

(

transformer

tf

)

Parameters

tf

f

Definition at line 815 of file transformer.c.

{
  transformer dtf = transformer_undefined;
 
  if(!transformer_undefined_p(tf)) {
    dtf = transformer_to_domain(tf);
  }
  return dtf;
}

References transformer_to_domain(), transformer_undefined, and transformer_undefined_p.

Here is the call graph for this function:

transformer_safe_domain_intersection()

transformer transformer_safe_domain_intersection	(	transformer	tf,
		transformer	pre
	)

If tf and pre are defined, update tf.

If tf is defined and pre is undefined, return tf unchanged. If tf and pre are undefined, return tf unchanged. If tf is undefined and pre is defined, we could exploit pre or return undefined.

Parameters

tf	f
pre	re

Definition at line 696 of file transformer.c.

{
  if(!transformer_undefined_p(pre)) {
    if(transformer_undefined_p(tf)) {
      tf = transformer_domain_intersection(transformer_identity(), pre);
    }
    else {
      tf = transformer_domain_intersection(tf, pre);
    }
  }
 
  return tf;
}

References transformer_domain_intersection(), transformer_identity(), and transformer_undefined_p.

Referenced by call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_image_intersection()

transformer transformer_safe_image_intersection	(	transformer	t1,
		transformer	t2
	)

Allocate a new transformer.

Parameters

t1	1
t2	2

Definition at line 647 of file transformer.c.

{
  transformer tf = transformer_safe_general_intersection(t1, t2, true);
 
  return tf;
}

References transformer_safe_general_intersection().

Referenced by add_formal_to_actual_bindings(), addition_operation_to_transformer(), fortran_user_call_to_transformer(), generic_abs_to_transformer(), generic_minmax_to_transformer(), iabs_to_transformer(), integer_minmax_to_transformer(), loop_bound_evaluation_to_transformer(), and transformer_add_any_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_intersection()

transformer transformer_safe_intersection	(	transformer	t1,
		transformer	t2
	)

Allocate a new transformer.

Parameters

t1	1
t2	2

Definition at line 639 of file transformer.c.

{
  transformer tf = transformer_safe_general_intersection(t1, t2, false);
 
  return tf;
}

References transformer_safe_general_intersection().

Referenced by logical_binary_operation_to_transformer(), loop_bound_evaluation_to_transformer(), transformer_safe_combine_with_warnings(), and unary_minus_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_inverse_apply()

transformer transformer_safe_inverse_apply	(	transformer	tf,
		transformer	post
	)

Parameters

tf	f
post	ost

Definition at line 1686 of file transformer.c.

{
  transformer pre = transformer_undefined;
 
  if(!transformer_undefined_p(tf) && !transformer_undefined_p(pre))
    pre = transformer_inverse_apply(tf, post);
 
  return pre;
}

References transformer_inverse_apply(), transformer_undefined, and transformer_undefined_p.

Here is the call graph for this function:

transformer_safe_normalize()

transformer transformer_safe_normalize	(	transformer	t,
		int	level
	)

Parameters

level

evel

Definition at line 1111 of file transformer.c.

{
  if(!transformer_undefined_p(t)) {
    t = transformer_normalize(t, level);
  }
  return t;
}

References level, transformer_normalize(), and transformer_undefined_p.

Referenced by block_to_transformer(), block_to_transformer_list(), c_data_to_prec_for_variables(), declarations_to_transformer(), declarations_to_transformer_list(), fortran_data_to_prec_for_variables(), propagate_preconditions_in_declarations(), and transformers_safe_normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_range()

transformer transformer_safe_range

(

transformer

tf

)

Parameters

tf

f

Definition at line 743 of file transformer.c.

{
  transformer rtf = transformer_undefined;
 
  if(!transformer_undefined_p(tf)) {
    rtf = transformer_range(tf);
  }
  return rtf;
}

References transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by loop_initialization_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_safe_value_substitute()

transformer transformer_safe_value_substitute	(	transformer	t,
		entity	e1,
		entity	e2
	)

Parameters

e1	1
e2	2

Definition at line 2048 of file transformer.c.

{
  if(!transformer_undefined_p(t))
    t = transformer_value_substitute(t, e1, e2);
 
  return t;
}

References transformer_undefined_p, and transformer_value_substitute().

Referenced by add_formal_to_actual_bindings().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_strongly_empty_p()

bool transformer_strongly_empty_p

(

transformer

t

)

If true is returned, the transformer certainly is empty.

If false is returned, the transformer still might be empty, but it's not likely at all...

Definition at line 2465 of file transformer.c.

{
    bool empty_p = parametric_transformer_empty_p(t, sc_strong_normalize5);
    return empty_p;
}

References parametric_transformer_empty_p(), and sc_strong_normalize5().

Referenced by statement_strongly_feasible_p().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_temporary_value_projection()

transformer transformer_temporary_value_projection

(

transformer

tf

)

tf = transformer_projection(tf, tv);

tf = transformer_projection_with_redundancy_elimination(tf, tv, sc_identity);

Parameters

tf

f

Definition at line 1149 of file transformer.c.

{
  list tv = NIL;
 
  if(number_of_temporary_values()>0) {
    Psysteme r = (Psysteme) predicate_system(transformer_relation(tf));
    Pbase b = BASE_NULLE;
 
    for(b = sc_base(r); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
      entity e = (entity) vecteur_var(b);
      if(local_temporary_value_entity_p(e)) {
        tv = CONS(ENTITY, e, tv);
      }
    }
    /* tf = transformer_projection(tf, tv); */
    /* tf = transformer_projection_with_redundancy_elimination(tf, tv, sc_identity); */
    tf = transformer_projection_with_redundancy_elimination(tf, tv, sc_safe_normalize);
  }
  else ifdebug(1) {
    Psysteme r = (Psysteme) predicate_system(transformer_relation(tf));
    Pbase b = BASE_NULLE;
 
    for(b = sc_base(r); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
      entity e = (entity) vecteur_var(b);
      if(local_temporary_value_entity_p(e)) {
        tv = CONS(ENTITY, e, tv);
      }
    }
    pips_assert("No temporary values exist in the system since a reset "
                "counter for them has been performed\n", ENDP(tv));
  }
 
  gen_free_list(tv);
 
  return tf;
}

References BASE_NULLE, BASE_NULLE_P, CONS, ENDP, ENTITY, gen_free_list(), ifdebug, local_temporary_value_entity_p(), NIL, number_of_temporary_values(), pips_assert, predicate_system, sc_safe_normalize(), transformer_projection_with_redundancy_elimination(), transformer_relation, vecteur_succ, and vecteur_var.

Referenced by add_index_bound_conditions(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), c_data_to_prec_for_variables(), c_return_to_transformer(), c_user_call_to_transformer(), call_to_transformer(), condition_to_transformer(), expression_to_transformer(), fortran_data_to_prec_for_variables(), fortran_user_call_to_transformer(), loop_bound_evaluation_to_transformer(), loop_to_enter_transformer(), precondition_add_condition_information(), test_to_postcondition(), test_to_transformer(), test_to_transformer_list(), transformer_add_condition_information(), and update_cp_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_1D_lattice()

bool transformer_to_1D_lattice	(	entity	v,
		transformer	pre,
		Value *	gcd_p,
		Value *	c_p
	)

See if the equations in transformer "pre" constraint variable "v" by v = gcd x + c, where x is a free variable.

If "v" is free, gcd==1 and c==0

Entity "v" is supposed to represent a value

Returns true unless the equations in "pre" have no integer solutions.

Parameters

pre	re
gcd_p	cd_p
c_p	_p

Definition at line 2480 of file transformer.c.

{
  Psysteme sc = (Psysteme) predicate_system(transformer_relation(pre));
  Pbase b = sc_base(sc);
  bool success = true;
  // Default returned values
  *gcd_p = 1L;
  *c_p = 0L;
 
  if(base_contains_variable_p(b, (Variable) v)) {
    int rank = rank_of_variable(b, (Variable) v); // could be used in the test
    int n = sc_nbre_egalites(sc);
    if(n>0) {
      int m = base_dimension(sc_base(sc));
      Pmatrix A, B;
      A = matrix_new(n, m);
      B = matrix_new(n, 1);
      constraints_to_matrices(sc_egalites(sc), sc_base(sc), A, B);
      // A x + B = 0 is transformed into A x = B
      for(int i=1;i<=n;i++) MATRIX_ELEM(B, i, 1) = -MATRIX_ELEM(B, i, 1);
      if(!matrices_to_1D_lattice(A, B, n, m, rank, gcd_p, c_p)) {
        // The transformer is in fact empty because its diophantine
        // equations have no solution
        success = false;
      }
      free(A);
      free(B);
    }
  }
  return success;
}

References A, B, base_contains_variable_p(), base_dimension, constraints_to_matrices(), free(), matrices_to_1D_lattice(), MATRIX_ELEM, matrix_new(), predicate_system, rank, rank_of_variable(), and transformer_relation.

Referenced by modulo_by_a_constant_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_analyzed_array_locations()

list transformer_to_analyzed_array_locations

(

transformer

tf

)

Parameters

tf

f

Definition at line 2776 of file transformer.c.

{
  return generic_transformer_to_analyzed_locations(tf, true);
}

References generic_transformer_to_analyzed_locations().

Referenced by generic_substitute_formal_array_elements_in_transformer(), new_array_elements_backward_substitution_in_transformer(), and new_array_elements_forward_substitution_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_analyzed_arrays()

list transformer_to_analyzed_arrays

(

transformer

tf

)

The list of array entities that appear in the basis of the transformer predicate as array element locations.

Parameters

tf

f

Definition at line 2793 of file transformer.c.

{
  list l = NIL;
  Psysteme sc = predicate_system(transformer_relation(tf));
  Pvecteur b = sc_base(sc), cb;
  for(cb=b; !VECTEUR_UNDEFINED_P(cb); cb = vecteur_succ(cb)) {
    Variable v = vecteur_var(cb);
    entity e = value_to_variable((entity) v);
    value val = entity_initial(e);
    //if(location_entity_p(e)) {
    if(value_reference_p(val)) {
      value val = entity_initial(e);
      reference r = value_reference(val);
      entity a = reference_variable(r);
      if(!gen_in_list_p(a, l))
        l = CONS(ENTITY, a, l);
    }
  }
  return l;
}

References CONS, ENTITY, entity_initial, gen_in_list_p(), NIL, predicate_system, reference_variable, transformer_relation, value_reference, value_reference_p, value_to_variable(), vecteur_succ, VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by generic_substitute_formal_array_elements_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_analyzed_locations()

list transformer_to_analyzed_locations

(

transformer

tf

)

The list of location entities that appear in the basis of the transformer predicate.

Parameters

tf

f

Definition at line 2785 of file transformer.c.

{
  return generic_transformer_to_analyzed_locations(tf, false);
}

References generic_transformer_to_analyzed_locations().

Referenced by substitute_stubs_in_transformer(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_domain()

transformer transformer_to_domain

(

transformer

tf

)

Return the domain of relation tf in a newly allocated transformer.

Projection of all new values of modified variables. Renaming of old values as new values. The transformer returned is a predicate on the input state (i.e. not really a transformer).

dtf = transformer_projection(dtf, args);

dtf = transformer_projection_with_redundancy_elimination(dtf, new_args, sc_identity);

The resulting transformer is going to be inconsistent because old values appear although the argument list is empty.

Careful, sc and b have been updated by the projections

A variable may be modified but its old value does not have to appear in the basis. Although the opposite is wrong.

Parameters

tf

f

Definition at line 772 of file transformer.c.

{
  transformer dtf = transformer_dup(tf);
  list new_args = NIL;
  Psysteme sc = predicate_system(transformer_relation(dtf));
  Pbase b = sc_base(sc);
 
  FOREACH(ENTITY, a, transformer_arguments(dtf)) {
    entity nv = entity_to_new_value(a);
 
    if(base_contains_variable_p(b, (Variable)  nv)) {
      new_args = CONS(ENTITY, nv, new_args);
    }
  }
 
  /* dtf = transformer_projection(dtf, args); */
  /* dtf = transformer_projection_with_redundancy_elimination(dtf, new_args,
                                                           sc_identity); */
  /* The resulting transformer is going to be inconsistent because old
     values appear although the argument list is empty. */
  dtf = transformer_projection_without_check(dtf, new_args,
                                             sc_identity);
 
  /* Careful, sc and b have been updated by the projections */
  sc = predicate_system(transformer_relation(dtf));
  b = sc_base(sc);
 
  FOREACH(ENTITY, a, new_args) {
    entity ov = entity_to_old_value(a);
    entity nv = entity_to_new_value(a);
 
    /* A variable may be modified but its old value does not have to
       appear in the basis. Although the opposite is wrong. */
    if(base_contains_variable_p(b, (Variable)  ov)) {
      dtf = transformer_value_substitute(dtf, ov, nv);
    }
  }
 
  gen_free_list(new_args);
 
  return dtf;
}

References base_contains_variable_p(), CONS, ENTITY, entity_to_new_value(), entity_to_old_value(), FOREACH, gen_free_list(), NIL, predicate_system, sc_identity(), transformer_arguments, transformer_dup(), transformer_projection_without_check(), transformer_relation, and transformer_value_substitute().

Referenced by call_to_total_precondition(), loop_to_total_precondition(), transformer_combine(), and transformer_safe_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_local_values()

list transformer_to_local_values	(	transformer	tf,
		list	dl
	)

Build a list of values appearing in tf that are linked to a variable in dl.

These values must be projected if the variables in dl are no longer in the scope, e.g. because they were declared in a block.

FI: I am not sure about what shuold be done for stubs

Parameters

tf	f
dl	l

Definition at line 2821 of file transformer.c.

{
  list l = NIL;
  //entity m = get_current_module_entity();
  Psysteme sc = predicate_system(transformer_relation(tf));
  Pvecteur b = sc_base(sc), cb;
  for(cb=b; !VECTEUR_UNDEFINED_P(cb); cb = vecteur_succ(cb)) {
    Variable v = vecteur_var(cb);
    entity e = value_to_variable((entity) v);
    bool remove_p = false;
    if(gen_in_list_p(e, dl))
      remove_p = true;
    else {
      value val = entity_initial(e);
      if(value_reference_p(val)) {
        reference r = value_reference(val);
        e = reference_variable(r);
        if(gen_in_list_p(e, dl))
          remove_p = true;
      }
    }
    if(remove_p && !gen_in_list_p(v, l))
      l = CONS(ENTITY, v, l);
  }
  return l;
}

References CONS, ENTITY, entity_initial, gen_in_list_p(), NIL, predicate_system, reference_variable, transformer_relation, value_reference, value_reference_p, value_to_variable(), vecteur_succ, VECTEUR_UNDEFINED_P, and vecteur_var.

Referenced by statement_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_to_potential_stub_translation()

list transformer_to_potential_stub_translation	(	transformer	,
		entity
	)

transformer_to_string()

string transformer_to_string

(

transformer

tf

)

prettyprint.c

Parameters

tf

f

Definition at line 52 of file prettyprint.c.

{
    pips_internal_error("not implemenented anymore, tf=%p", tf);
    return string_undefined;
}

References pips_internal_error, and string_undefined.

transformer_value_substitutable_p()

bool transformer_value_substitutable_p	(	transformer	t,
		entity	e1,
		entity	e2
	)

If e1 does not appear in t, it is substitutable.

If e1 does appear in t but not e2, again it is substitutable. Else, it if not.

Parameters

e1	1
e2	2

Definition at line 2033 of file transformer.c.

{
  bool substitutable_p = true;
  Psysteme s = (Psysteme) predicate_system(transformer_relation(t));
 
  pips_assert("e1 and e2 are defined entities",
              e1 != entity_undefined && e2 != entity_undefined);
 
  if(base_contains_variable_p(s->base, (Variable) e1)) {
    substitutable_p = !base_contains_variable_p(s->base, (Variable) e2);
  }
 
  return substitutable_p;
}

References Ssysteme::base, base_contains_variable_p(), entity_undefined, pips_assert, predicate_system, and transformer_relation.

Referenced by translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_value_substitute()

transformer transformer_value_substitute	(	transformer	t,
		entity	e1,
		entity	e2
	)

transformer transformer_value_substitute(transformer t, entity e1, entity e2): if e2 does not appear in t initially: replaces occurences of value e1 by value e2 in transformer t's arguments and relation fields; else error fi

"e2 must not appear in t initially": this is the general case; the second case may occur when procedure A calls B and C and when B and C share a global variable X which is not seen from A. A may contain relations between B:X and C:X... See hidden.f in Bugs or Validation...

updates are performed by side effects

update only if necessary

rename value e1 in argument a; e1 does not necessarily appear in a because it's not necessarily the new value of a modified variable

Parameters

e1	1
e2	2

Definition at line 1993 of file transformer.c.

{
  /* updates are performed by side effects */
 
  cons * a = transformer_arguments(t);
  Psysteme s = (Psysteme) predicate_system(transformer_relation(t));
 
  pips_assert("e1 and e2 are defined entities",
              e1 != entity_undefined && e2 != entity_undefined);
  /*
    pips_assert("transformer_value_substitute",
    !base_contains_variable_p(s->base, (Variable) e2));
  */
 
  /* update only if necessary */
  if(base_contains_variable_p(s->base, (Variable) e1)) {
 
    if(!base_contains_variable_p(s->base, (Variable) e2)) {
 
      (void) sc_variable_rename(s,(Variable) e1, (Variable)e2);
 
      /* rename value e1 in argument a; e1 does not necessarily
         appear in a because it's not necessarily the new value of
         a modified variable */
      MAPL(ce, {entity e = ENTITY(CAR(ce));
      if( e == e1) ENTITY_(CAR(ce)) = e2;},
           a);
    }
    else {
      pips_internal_error("cannot substitute e1=%s by e2=%s: e2 already in basis",
                          entity_name(e1), entity_name(e2));
    }
  }
 
  return t;
}

References Ssysteme::base, base_contains_variable_p(), CAR, ENTITY, ENTITY_, entity_name, entity_undefined, MAPL, pips_assert, pips_internal_error, predicate_system, sc_variable_rename(), transformer_arguments, and transformer_relation.

Referenced by add_type_information(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), fortran_user_call_to_transformer(), perform_array_element_substitutions_in_transformer(), precondition_intra_to_inter(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_intersect_range_with_domain(), transformer_safe_value_substitute(), transformer_to_domain(), translate_global_value(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_variables_filter()

transformer transformer_variables_filter	(	transformer	t,
		list	vl
	)

Transformers are dealing with variables and/or variable values.

The confusion is magnified because the new value of a variable is often identified to the variable. Also, it is not 100% clear if the argument list of a transformer is a list of variables or a list of new values. In principle, it is a list of variables or locations. To make thisn worse, both value and variable start with a v...

Here, it is assumed that list vl is a list of variables or locations.

Transformer t is modified by side effect. All values linked to any variable in ist vl are projected, when possible. It is assumed that the projected variables are removed from the transformer argument.

Parameters

vl

l

Definition at line 1827 of file transformer.c.

{
  list values = NIL;
  FOREACH(ENTITY, var, vl) {
    if(entity_has_values_p(var)) {
      entity new_val = entity_to_new_value(var);
      // FI it might be necessary to guard this definition
      entity old_val = entity_to_old_value(var);
      values = CONS(ENTITY, new_val, values);
      if(!entity_undefined_p(old_val))
        values = CONS(ENTITY, old_val, values);
    }
  }
  t = transformer_filter(t, values);
  gen_free_list(values);
  return t;
}

References CONS, ENTITY, entity_has_values_p(), entity_to_new_value(), entity_to_old_value(), entity_undefined_p, FOREACH, gen_free_list(), NIL, and transformer_filter().

Here is the call graph for this function:

transformer_weak_consistency_p()

bool transformer_weak_consistency_p

(

transformer

t

)

Interprocedural transformers do not meet all conditions.

Definition at line 626 of file basic.c.

{
  return transformer_general_consistency_p(t, true);
}

References transformer_general_consistency_p().

Referenced by c_user_call_to_transformer(), fortran_user_call_to_transformer(), transformer_filter(), transformer_formal_parameter_projection(), transformer_projection_with_redundancy_elimination_and_check(), and transformer_return_value_projection().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_with_temporary_values_p()

bool transformer_with_temporary_values_p

(

transformer

tf

)

Does transformer tf use temporary values?

Parameters

tf

f

Definition at line 1131 of file transformer.c.

{
  int count = 0;
 
  if(number_of_temporary_values()>0) {
    Psysteme r = (Psysteme) predicate_system(transformer_relation(tf));
    Pbase b = BASE_NULLE;
 
    for(b = sc_base(r); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
      entity e = (entity) vecteur_var(b);
      if(local_temporary_value_entity_p(e)) {
        count++;
      }
    }
  }
  return count>0;
}

References BASE_NULLE, BASE_NULLE_P, count, local_temporary_value_entity_p(), number_of_temporary_values(), predicate_system, transformer_relation, vecteur_succ, and vecteur_var.

Here is the call graph for this function:

transformers_apply()

list transformers_apply	(	list	tl,
		transformer	pre
	)

Same as previous one, but with a more normalized name.

Parameters

tl	l
pre	re

Definition at line 1616 of file transformer.c.

{
  return transformer_apply_generic(tl, pre, false);
}

References transformer_apply_generic().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_apply_and_keep_all()

list transformers_apply_and_keep_all	(	list	tl,
		transformer	pre
	)

Same as previous one, but with a more normalized name.

Parameters

tl	l
pre	re

Definition at line 1622 of file transformer.c.

{
  return transformer_apply_generic(tl, pre, true);
}

References transformer_apply_generic().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_combine()

list transformers_combine	(	list	tl1,
		transformer	t2
	)

Combine each transformer of transformer list tl1 with t2.

Side-effect on tl1 or new list etl. See comments for transformer_combine()

FI: I'm not too sure about the best way to remove the resulting empty transformers. gen_remove() on tl1 or creation of new list...

Parameters

tl1	l1
t2	2

Definition at line 454 of file transformer.c.

{
  list ntl = NIL;
 
  FOREACH(TRANSFORMER, t1, tl1) {
    t1 = transformer_combine(t1, t2);
    if(!transformer_empty_p(t1))
      ntl = gen_nconc(ntl, CONS(TRANSFORMER, t1, NIL));
  }
 
  gen_free_list(tl1);
  return ntl;
}

References CONS, FOREACH, gen_free_list(), gen_nconc(), NIL, TRANSFORMER, transformer_combine(), and transformer_empty_p().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_consistency_p()

bool transformers_consistency_p

(

list

tl

)

Parameters

tl

l

Definition at line 616 of file basic.c.

{
  bool consistent_p = true;
  FOREACH(TRANSFORMER, t, tl) {
    consistent_p = consistent_p && transformer_general_consistency_p(t, false);
  }
  return consistent_p;
}

References FOREACH, TRANSFORMER, and transformer_general_consistency_p().

Referenced by safe_assigned_expression_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_derivative_fix_point()

list transformers_derivative_fix_point

(

list

tl

)

Parameters

tl

l

Definition at line 1262 of file fix_point.c.

{
  list ntl = NIL;
  FOREACH(TRANSFORMER, tf, tl) {
    transformer fix_tf = transformer_derivative_fix_point(tf);
    ntl = CONS(TRANSFORMER, fix_tf, ntl);
  }
  ntl = gen_nreverse(ntl);
  return ntl;
}

References CONS, FOREACH, gen_nreverse(), NIL, TRANSFORMER, and transformer_derivative_fix_point().

Referenced by transformer_list_closure_to_precondition_depth_two(), and transformer_list_closure_to_precondition_max_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_range()

list transformers_range

(

list

tfl

)

Substitute each transformer in list tfl by its range.

Parameters

tfl

fl

Definition at line 754 of file transformer.c.

{
  // The substitution in the list cannot be performed by a FOREACH
  MAPL(ctf, {
      transformer tf = TRANSFORMER(CAR(ctf));
      transformer tfr = transformer_range(tf);
      free_transformer(tf);
      TRANSFORMER_(CAR(ctf)) = tfr;
    }, tfl);
  return tfl;
}

References CAR, free_transformer(), MAPL, TRANSFORMER, TRANSFORMER_, and transformer_range().

Referenced by block_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_safe_apply()

list transformers_safe_apply	(	list	tl,
		transformer	pre
	)

returns a list of postconditions, one for each transformer in tl

Parameters

tl	l
pre	re

Definition at line 1638 of file transformer.c.

{
  list postl = NIL;
  FOREACH(TRANSFORMER, tf, tl) {
    transformer post = transformer_safe_apply(tf, pre);
    postl = CONS(TRANSFORMER, post, postl);
  }
  postl = gen_nreverse(postl);
  return postl;
}

References CONS, FOREACH, gen_nreverse(), NIL, TRANSFORMER, and transformer_safe_apply().

Referenced by block_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformers_safe_normalize()

list transformers_safe_normalize	(	list	tl,
		int	level
	)

Parameters

tl	l
level	evel

Definition at line 1119 of file transformer.c.

{
  list ntl = NIL;
  FOREACH(TRANSFORMER, tf, tl) {
    transformer ntf = transformer_safe_normalize(tf, level);
    ntl = CONS(TRANSFORMER, ntf, ntl);
  }
  ntl = gen_nreverse(ntl);
  return ntl;
}

References CONS, FOREACH, gen_nreverse(), level, NIL, TRANSFORMER, and transformer_safe_normalize().

Referenced by block_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

two_transformers_to_list()

list two_transformers_to_list	(	transformer	t1,
		transformer	t2
	)

Transformer two transformers into a correct transformer list.

Could be generalized to any number of transformers using a varargs... and more thinking.

Two transformers are obtained for loops that may be skipped or entered and for tests whose condition is not statically decidable.

This is a very dangerous step that should not always be taken. It is useful to ease the detection of identity paths, but it looses a lot of information. So almost identity path might simply be better identified elsewhere

Parameters

t1	1
t2	2

Definition at line 316 of file transformer_list.c.

{
  list tl = NIL;
  if(transformer_empty_p(t1)) {
    if(transformer_empty_p(t2)) {
      tl = NIL;
    }
    else {
      tl = CONS(TRANSFORMER, t2, NIL);
    }
  }
  else {
    if(transformer_empty_p(t2)) {
      tl = CONS(TRANSFORMER, t1, NIL);
    }
    else {
 
      /* This is a very dangerous step that should not always be
         taken. It is useful to ease the detection of identity
         paths, but it looses a lot of information. So almost
         identity path might simply be better identified elsewhere */
      /*
      if(ENDP(transformer_arguments(t1))) {
        free_transformer(t1);
        t1 = transformer_identity();
      }
 
      if(ENDP(transformer_arguments(t2))) {
        free_transformer(t2);
        t2 = transformer_identity();
      }
      */
 
      if(transformer_identity_p(t1)) {
        if(transformer_identity_p(t2)) {
          tl = CONS(TRANSFORMER, t1, NIL);
          free_transformer(t2);
        }
        else {
          tl = CONS(TRANSFORMER, t1,
                    CONS(TRANSFORMER, t2, NIL));
        }
      }
      else {
        if(transformer_identity_p(t2)) {
          tl = CONS(TRANSFORMER, t2,
                    CONS(TRANSFORMER, t1, NIL));
        }
        else {
          tl = CONS(TRANSFORMER, t1,
                    CONS(TRANSFORMER, t2, NIL));
        }
      }
    }
  }
  return tl;
}

References CONS, free_transformer(), NIL, TRANSFORMER, transformer_empty_p(), and transformer_identity_p().

Referenced by complete_any_loop_transformer_list(), and complete_repeatloop_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

type_to_sizeof_value()

entity type_to_sizeof_value

(

type

t

)

Definition at line 899 of file value.c.

{
  entity i;
  if((i = (entity) hash_get(hash_type_to_sizeof_value, (char *) t))
      == entity_undefined)
    pips_internal_error("unbounded type %s : %s",
        type_to_string(t), type_to_full_string_definition(t));
  return i;
}

References entity_undefined, hash_get(), hash_type_to_sizeof_value, pips_internal_error, type_to_full_string_definition(), and type_to_string().

Referenced by expression_multiply_sizeof_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

value_alias()

entity value_alias

(

entity

e

)

Static aliasing.

useful for Fortran, useless for C. When no alias is found, an undefined entity must be returned.

lookup the current value name mapping and return an arbitrary "representant" of the interprocedural alias set of e; the equivalence relation is "has same location"

Definition at line 1729 of file value.c.

{
  entity a = entity_undefined;
 
  pips_debug(8,"begin: for %s\n", entity_name(e));
 
  /* lookup the current value name mapping and return an arbitrary "representant"
     of the interprocedural alias set of e; the equivalence relation is "has
     same location" */
  HASH_FOREACH(entity, var, string, val, hash_value_to_name) {
    if(variable_entity_p(var)
       && entities_may_conflict_p(var, e)) {
      a = var;
      break;
    }
  }
 
  if(a==entity_undefined)
    pips_debug(8, "return: %s\n", "entity_undefined");
  else
    pips_debug(8, "return: %s\n", entity_name(a));
 
  return a;
}

References entities_may_conflict_p(), entity_name, entity_undefined, HASH_FOREACH, hash_value_to_name, pips_debug, and variable_entity_p().

Referenced by add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

value_belongs_to_transformer_space()

bool value_belongs_to_transformer_space	(	entity	v,
		transformer	tf
	)

Parameters

tf

f

Definition at line 842 of file basic.c.

{
  Psysteme sc = predicate_system(transformer_relation(tf));
  Pbase b = BASE_UNDEFINED;
  bool found_p = false;
 
  for(b=sc_base(sc); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
    entity bv = (entity) vecteur_var(b);
 
    if(bv==v) {
      found_p = true;
      break;
    }
  }
  return found_p;
}

References BASE_NULLE_P, BASE_UNDEFINED, predicate_system, transformer_relation, vecteur_succ, and vecteur_var.

Referenced by transformer_add_variable_type_information().

Here is the caller graph for this function:

value_entity_p()

bool value_entity_p

(

entity

e

)

tells if e is seen as a variable value in the current module

Definition at line 976 of file value.c.

{
  /* tells if e is seen as a variable value in the current module */
  string s = hash_get(hash_value_to_name, (char *) e);
 
  if(s == (char*) HASH_UNDEFINED_VALUE) {
    return false;
  }
  else {
    return true;
  }
}

References hash_get(), HASH_UNDEFINED_VALUE, and hash_value_to_name.

Referenced by generic_value_name(), transformer_add_sign_information(), transformer_filter_subsumed_variables(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

value_full_name()

string value_full_name

(

entity

v

)

for debugging purposes

Definition at line 1762 of file value.c.

{
  return entity_name(v);
}

References entity_name.

Referenced by parametric_transformer_empty_p().

Here is the caller graph for this function:

value_to_variable()

entity value_to_variable

(

entity

val

)

Get the primitive variable associated to any value involved in a transformer.

For example can associate values such as "o#0" to "i" (via "i#init").

This function used to be restricted to values seen by the current module. It was extended to values in general to cope with translation issues.

for gcc only!

pips_assert("value_to_variable", s != HASH_UNDEFINED_VALUE);

pips_assert("value_to_variable", strchr(entity_name(val), (int) SEMANTICS_SEPARATOR) != NULL);

this may be a value, but it is unknown in the current module

new values in fact have no suffixes...

It can be an equivalenced variable... Additional testing should be performed!

Parameters

val

al

Definition at line 1624 of file value.c.

{
  entity var = entity_undefined;
  int l_suffix = -1; /* for gcc only! */
  string s = hash_get(hash_value_to_name, (char *) val);
  string var_name;
 
  /* pips_assert("value_to_variable", s != HASH_UNDEFINED_VALUE); */
 
  /* pips_assert("value_to_variable",
     strchr(entity_name(val), (int) SEMANTICS_SEPARATOR) != NULL); */
 
  // TODO : Maybe redesign the search of suffix/prefix
  //        Can bug if the variable name is/begin/end with
  //        o, i, t, new, init, int, address_of see SUFFIX and PREFIX in transformer.h
  if(s == HASH_UNDEFINED_VALUE) {
    /* this may be a value, but it is unknown in the current module */
    string val_name = entity_name(val);
 
    if(strstr(val_name, NEW_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(NEW_VALUE_SUFFIX);
    else if(strstr(val_name, OLD_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(OLD_VALUE_SUFFIX);
    else if(strstr(val_name, INTERMEDIATE_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(INTERMEDIATE_VALUE_SUFFIX);
    else if(strstr(val_name, ADDRESS_OF_SUFFIX) != NULL)
      l_suffix = strlen(ADDRESS_OF_SUFFIX);
    else if(strstr(val_name, SIZEOF_SUFFIX) != NULL)
      l_suffix = 0;
    else if(strchr(val_name, (int) SEMANTICS_SEPARATOR) == NULL) {
      /* new values in fact have no suffixes... */
      l_suffix = 0;
    }
    else
      pips_internal_error("%s is not a non-local value", entity_name(val));
 
    s = val_name;
  }
  else {
    if(sizeof_value_entity_p(val))
      l_suffix = 0;
    else if(new_value_entity_p(val))
      l_suffix = strlen(NEW_VALUE_SUFFIX);
    else if(old_value_entity_p(val))
      l_suffix = strlen(OLD_VALUE_SUFFIX);
    else if(intermediate_value_entity_p(val))
      l_suffix = strlen(INTERMEDIATE_VALUE_SUFFIX);
    else if(address_of_value_entity_p(val))
      l_suffix = strlen(ADDRESS_OF_SUFFIX);
    else
      /* It can be an equivalenced variable... Additional testing
         should be performed! */
      pips_internal_error("%s is not a locally visible value",
                          entity_name(val));
  }
 
  var_name = strdup(s);
  *(var_name+strlen(var_name)-l_suffix) = '\0';
  if(address_of_value_entity_p(val)) {
    string temp = strstr(var_name, "[");
    if(temp != NULL)
      *temp = '\0';
  }
 
  var = gen_find_tabulated(var_name, entity_domain);
  free(var_name);
 
  if( var == entity_undefined )
    pips_internal_error("no related variable for val=%s",
                        entity_name(val));
 
  return var;
}

References ADDRESS_OF_SUFFIX, address_of_value_entity_p(), entity_domain, entity_name, entity_undefined, free(), gen_find_tabulated(), hash_get(), HASH_UNDEFINED_VALUE, hash_value_to_name, intermediate_value_entity_p(), INTERMEDIATE_VALUE_SUFFIX, new_value_entity_p(), NEW_VALUE_SUFFIX, old_value_entity_p(), OLD_VALUE_SUFFIX, pips_internal_error, SEMANTICS_SEPARATOR, SIZEOF_SUFFIX, sizeof_value_entity_p(), and strdup().

Referenced by add_address_of_value(), add_loop_index_exit_value(), add_type_information(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), fortran_user_call_to_transformer(), generic_transformer_intra_to_inter(), generic_transformer_to_analyzed_locations(), invariant_vector_p(), look_for_the_best_counter(), old_value_to_new_value(), pips_user_value_name(), print_call_precondition(), transformer_add_variable_incrementation(), transformer_add_variable_update(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_formal_parameter_projection(), transformer_general_consistency_p(), transformer_list_generic_transitive_closure(), transformer_projection_with_redundancy_elimination_and_check(), transformer_return_value_projection(), transformer_to_analyzed_arrays(), transformer_to_local_values(), transformer_to_potential_stub_translation(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_variables_to_values()

Pvecteur vect_variables_to_values

(

Pvecteur

v

)

FI: not used, not debugged.

Definition at line 1755 of file value.c.

{
  v = vect_rename_variables(v, (bool (*)(Variable)) non_local_temporary_value_entity_p, (Variable (*)(Variable)) entity_to_new_value);
  return v;
}

References entity_to_new_value(), non_local_temporary_value_entity_p(), and vect_rename_variables().

Here is the call graph for this function:

Variable Documentation

transformer_fix_point_operator

transformer(* transformer_fix_point_operator) (transformer) ( transformer  )

extern

fix_point.c

fix_point.c

Interface between the untyped database manager and clean code and between pipsmake and clean code.

Several algorithms are available:

• two untested versions using Halwachs approach; sc_elarg() was found to be very slow in an earlier implementation by Malik; experimentally, we did not find scientific Frotran programs that required such an algorithm.
• a fix point algorithm based on the transfer matrix linking the new values to the old values; this is sufficient for induction variables but only equations can be found.
• a fix point algorithm based on pattern matching which was developped experimentally for examples presented at FORMA; once the constant terms are eliminated using a loop counter, the constraints which are their own fixpoints are easy to pattern match; equations and inequalities can both be found.

• a fix point algorithm combining the last two algorithms above. This algorithm adds difference variables d_i = i::new - i::old for each variable i. All non d_i variables are thn projected. If the projection algorithm is sophisticated enough, the projection ordering will be "good". Left over inequalities are invariant or useless. Let N be the strictly positive iteration count:

  sum ai di <= -k implies N sum ai di <= -Nk <= -k (OK)

  sum ai di <= k implies N sum ai di <= Nk <= infinity (useless unless k == 0)

  Left over equations can stay equations if the constant term is 0, or be degraded into an inequation if not. The nw inequation depends on the sign of the constant:

  sum ai di == -k implies N sum ai di == -Nk <= -k

  sum ai di == k implies N sum ai di == Nk >= k

  sum ai di == 0 implies N sum ai di == 0

  In a second step, the constant terms are eliminated to obtain new constraints leading to new invariants, using the same rules as above.

  This algorithm was designed for while loops such as:

  WHILE( I > 0 ) J = J + I I = I - 1

  to find as loop transformer T(I,J) {I::new <= I::old - 1, J::new >= J::old + 1, I::new+J::new >= I::old + J::old}

  Note that the second constraint is redundant with the other two, but the last one cannot be found before the constant terms are eliminated.

The current algorithm, the derivative version, is published and describes in NSAD 2010, A/426/CRI. See also A/429/CRI: http://www.cri.ensmp.fr/classement/doc/A-429.pdf

Francois Irigoin, 21 April 1990 The fixpoint operator is selected according to properties

Definition at line 114 of file fix_point.c.