semantics.h File Reference

Go to the source code of this file.

Data Structures
struct	path

Macros
#define	SEMANTICS_OPTIONS   "?Otcfieod-D:"
	Warning! Do not modify this file that is automatically generated! More...
#define	SEQUENTIAL_TRANSFORMER_SUFFIX   ".tran"
#define	USER_TRANSFORMER_SUFFIX   ".utran"
#define	SEQUENTIAL_PRECONDITION_SUFFIX   ".prec"
#define	USER_PRECONDITION_SUFFIX   ".uprec"
#define	SEQUENTIAL_TOTAL_PRECONDITION_SUFFIX   ".tprec"
#define	USER_TOTAL_PRECONDITION_SUFFIX   ".utprec"
#define	semantics_user_warning   semantics_user_warning_func2

Functions
int	call_site_count (entity)
	cproto-generated files More...
int	caller_count (entity)
int	dynamic_call_count (entity)
void	semantics_user_warning_func (const char *, const char *,...)
void	semantics_user_warning_func2 (const char *,...)
transformer	apply_array_effect_to_transformer (transformer, effect, bool)
	ri_to_transformers.c More...
transformer	effects_to_transformer (list)
	list of effects More...
transformer	filter_transformer (transformer, list)
	Previous version of effects_to_transformer() transformer effects_to_transformer(list e) { list args = NIL; Pbase b = VECTEUR_NUL; Psysteme s = sc_new();. More...
transformer	dimensions_to_transformer (entity, transformer)
	Assumes that entity_has_values_p(v) holds. More...
transformer	declaration_to_transformer (entity, transformer)
	Note: initializations of static variables are not used as transformers but to initialize the program precondition. More...
transformer	declarations_to_transformer (list, transformer)
	For C declarations. More...
list	effects_to_arguments (list)
	list of effects More...
transformer	intrinsic_to_transformer (entity, list, transformer, list)
	effects of intrinsic call More...
transformer	call_to_transformer (call, transformer, list)
	Use to be static, but may be called from expressions in C. More...
transformer	user_function_call_to_transformer (entity, expression, transformer)
	a function call is a call to a non void function in C and to a FUNCTION in Fortran More...
transformer	generic_transformer_intra_to_inter (transformer, list, bool)
	transformer translation from the module intraprocedural transformer to the module interprocedural transformer. More...
transformer	transformer_intra_to_inter (transformer, list)
unsigned int	number_of_usable_functional_parameters (list)
	Number of formal parameters in pl before a vararg is reached. More...
transformer	transformer_formal_parameter_projection (entity, transformer)
transformer	array_elements_substitution_in_transformer (transformer, entity, type, expression, transformer, list, bool)
transformer	new_array_element_backward_substitution_in_transformer (transformer, entity, reference, reference)
	Substitute formal location entity l by a location entity corresponding to ar, if it is possible. More...
transformer	new_array_elements_backward_substitution_in_transformer (transformer, entity, type, expression, transformer, list)
transformer	new_array_elements_forward_substitution_in_transformer (transformer, entity, type, expression, transformer, list)
transformer	new_array_elements_substitution_in_transformer (transformer, entity, type, expression, transformer, list, bool)
transformer	generic_substitute_formal_array_elements_in_transformer (transformer, entity, list, transformer, list, bool)
transformer	substitute_formal_array_elements_in_transformer (transformer, entity, list, transformer, list)
transformer	substitute_formal_array_elements_in_precondition (transformer, entity, list, transformer, list)
transformer	any_user_call_site_to_transformer (entity, list, transformer, list)
transformer	c_user_call_to_transformer (entity, list, transformer, list)
transformer	fortran_user_call_to_transformer (entity, list, list)
	Effects are necessary to clean up the transformer t_caller. More...
transformer	user_call_to_transformer (entity, list, transformer, list)
transformer	c_return_to_transformer (entity, list, list, transformer)
transformer	assigned_expression_to_transformer (entity, expression, transformer)
	transformer assigned_expression_to_transformer(entity e, expression expr, list ef): returns a transformer abstracting the effect of assignment "e = expr" when possible, transformer_undefined otherwise. More...
transformer	safe_assigned_expression_to_transformer (entity, expression, transformer)
	Always returns a fully defined transformer. More...
transformer	integer_assign_to_transformer (expression, expression, transformer, list)
	This function never returns an undefined transformer. More...
transformer	any_scalar_assign_to_transformer_without_effect (entity, expression, transformer)
	assign to the scalar variable v the expression rhs (a scalar variable has a basic type; it cannot be an array, a struct or a union; it can be an enum) WARNING : this function can return transformer_undefined More...
transformer	any_scalar_assign_to_transformer (entity, expression, list, transformer)
	precondition More...
transformer	transformer_apply_field_assignments_or_equalities (transformer, reference, reference, type, bool)
	For all analyzable fields f, apply the assignment "le.f = re.f;" to transformer t. More...
transformer	transformer_apply_field_assignments (transformer, reference, reference, type)
transformer	transformer_apply_field_equalities (transformer, reference, reference, type)
transformer	transformer_apply_unknown_field_assignments (transformer, reference, type)
transformer	transformer_apply_unknown_field_equalities (transformer, reference, type)
transformer	struct_reference_assignment_to_transformer (reference, type, expression, transformer, list)
transformer	struct_reference_equality_to_transformer (reference, type, expression, transformer, list)
transformer	struct_variable_assignment_to_transformer (entity, type, expression, transformer, list)
transformer	struct_variable_equality_to_transformer (entity, type, expression, transformer, list)
transformer	any_assign_to_transformer (list, list, transformer)
	precondition More...
transformer	any_update_to_transformer (entity, list, list, transformer)
	precondition More...
transformer	any_basic_update_to_transformer (entity, list, list, transformer)
	precondition More...
transformer	complete_statement_transformer (transformer, transformer, statement)
	Returns the effective transformer ct for a given statement s. More...
transformer	complete_non_identity_statement_transformer (transformer, transformer, statement)
	FI: only implemented for while loops. More...
transformer	generic_complete_statement_transformer (transformer, transformer, statement, bool)
	Loops, do, for, while or repeat, have transformers linked to their body preconditions so as to compute those. More...
transformer	statement_to_transformer (statement, transformer)
	stmt precondition More...
transformer	get_module_precondition (entity)
	interprocedural.c More...
void	add_module_call_site_precondition (entity, transformer)
list	module_to_formal_analyzable_parameters (entity)
	returns a module's parameter's list More...
bool	same_analyzable_type_scalar_entity_list_p (list)
transformer	add_formal_to_actual_bindings (call, transformer, entity)
	add_formal_to_actual_bindings(call c, transformer pre, entity caller): More...
transformer	new_add_formal_to_actual_bindings (call, transformer, entity)
	Take side effects into account: More...
transformer	precondition_intra_to_inter (entity, transformer, list)
void	translate_global_values (entity, transformer)
void	translate_global_value (entity, transformer, entity)
	Try to convert an value on a non-local variable into an value on a local variable using a guessed name (instead of a location identity: M and N declared as COMMON/FOO/M and COMMON/FOO/N are not identified as a unique variable/location). More...
void	expressions_to_summary_precondition (transformer, list)
void	expression_to_summary_precondition (transformer, expression)
void	call_to_summary_precondition (transformer, call)
text	call_site_to_module_precondition_text (entity, entity, statement, call)
	This function does everything needed. More...
void	reset_call_site_number (void)
int	get_call_site_number (void)
void	update_summary_precondition_in_declaration (expression, transformer)
	This function is called to deal with call sites located in initialization expressions carried by declarations. More...
transformer	update_precondition_with_call_site_preconditions (transformer, entity, entity)
	Update precondition t for callee with preconditions of call sites to callee in caller. More...
transformer	value_passing_summary_transformer (entity, transformer)
	With value passing, writes on formal parameters are not effective interprocedurally unless an array is passed as parameter. More...
list	get_module_global_arguments (void)
	ri_to_preconditions.c More...
void	set_module_global_arguments (list)
list	effects_to_entity_list (list)
	returns an allocated list of entities that appear in lef. More...
transformer	data_to_precondition (entity)
	restricted to variables with effects. More...
transformer	all_data_to_precondition (entity)
	any variable is included. More...
void	precondition_add_reference_information (transformer, statement)
void	transformer_add_reference_information (transformer, statement)
void	precondition_add_type_information (transformer)
transformer	statement_to_postcondition (transformer, statement)
	end of the non recursive section More...
transformer	propagate_preconditions_in_declarations (list, transformer, void(*)(expression, transformer))
	This function is mostly copied from declarations_to_transformer(). More...
transformer	tf_equivalence_equalities_add (transformer)
	mappings.c More...
void	add_equivalenced_values (entity, entity, bool)
void	add_intraprocedural_value_entities (entity)
	Use to be static, but may be called from ri_to_transformer. More...
void	add_or_kill_equivalenced_variables (entity, bool)
	Look for variables equivalenced with e. More...
void	add_implicit_interprocedural_write_effects (entity, list)
	It is assumed that al is an abstract location that is written and which may conflict with effects in effect list el. More...
void	module_to_value_mappings (entity)
	void module_to_value_mappings(entity m): build hash tables between variables and values (old, new and intermediate), and between values and names for module m, as well as equivalence equalities More...
bool	value_mappings_compatible_vector_p (Pvecteur)
	transform a vector based on variable entities into a vector based on new value entities when possible; does nothing most of the time; does a little in the presence of equivalenced variables More...
list	variables_to_values (list)
list	variable_to_values (entity)
list	dynamic_variables_to_values (list)
	Build the list of values to be projected when the declaration list list_mod is no longer valid because a block is closed/left. More...
list	variables_to_old_values (list)
void	variables_to_new_values (Pvecteur)
	replace variables by new values which is necessary for equivalenced variables More...
void	upwards_vect_rename (Pvecteur, transformer)
	Renaming of variables in v according to transformations occuring later. More...
bool	transformer_map_undefined_p (void)
	dbm_interface.c More...
void	set_transformer_map (statement_mapping)
statement_mapping	get_transformer_map (void)
void	reset_transformer_map (void)
void	free_transformer_map (void)
void	make_transformer_map (void)
transformer	load_statement_transformer (statement)
void	delete_statement_transformer (statement)
bool	statement_transformer_undefined_p (statement)
void	store_statement_transformer (statement, transformer)
void	update_statement_transformer (statement, transformer)
bool	precondition_map_undefined_p (void)
void	set_precondition_map (statement_mapping)
statement_mapping	get_precondition_map (void)
void	reset_precondition_map (void)
void	free_precondition_map (void)
void	make_precondition_map (void)
transformer	load_statement_precondition (statement)
void	delete_statement_precondition (statement)
bool	statement_precondition_undefined_p (statement)
void	store_statement_precondition (statement, transformer)
void	update_statement_precondition (statement, transformer)
bool	total_precondition_map_undefined_p (void)
void	set_total_precondition_map (statement_mapping)
statement_mapping	get_total_precondition_map (void)
void	reset_total_precondition_map (void)
void	free_total_precondition_map (void)
void	make_total_precondition_map (void)
transformer	load_statement_total_precondition (statement)
void	delete_statement_total_precondition (statement)
bool	statement_total_precondition_undefined_p (statement)
void	store_statement_total_precondition (statement, transformer)
void	update_statement_total_precondition (statement, transformer)
transformer	load_completed_statement_transformer (statement)
	three mappings used throughout semantics analysis: More...
void	add_declaration_list_information (transformer, list, bool)
bool	transformers_intra_fast (char *)
	Functions to make transformers. More...
bool	transformers_intra_full (char *)
bool	transformers_inter_fast (char *)
bool	transformers_inter_full (char *)
bool	transformers_inter_full_with_points_to (char *)
bool	refine_transformers (char *)
bool	refine_transformers_with_points_to (char *)
bool	summary_transformer (char *)
bool	preconditions_intra (char *)
bool	preconditions_intra_fast (char *)
bool	preconditions_inter_fast (char *)
bool	preconditions_inter_full (char *)
bool	preconditions_inter_full_with_points_to (char *)
bool	total_preconditions_intra (char *)
bool	total_preconditions_inter (char *)
bool	old_summary_precondition (char *)
bool	intraprocedural_summary_precondition (char *)
bool	interprocedural_summary_precondition (char *)
bool	use_points_to_p (void)
bool	interprocedural_summary_precondition_with_points_to (char *)
bool	summary_precondition (char *)
bool	summary_total_postcondition (char *)
bool	summary_total_precondition (char *)
void	set_warning_counters (void)
bool	test_warning_counters (void)
bool	generic_module_name_to_transformers (const char *, bool)
	bool generic_module_name_to_transformers(char * module_name, bool in_context): compute a transformer for each statement of a module with a given name; compute also the global transformer for the module More...
bool	module_name_to_transformers_in_context (const char *)
bool	module_name_to_transformers (const char *)
bool	module_name_to_preconditions (const char *)
	resource module_name_to_preconditions(char * module_name): compute a transformer for each statement of a module with a given name; compute also the global transformer for the module More...
bool	module_name_to_total_preconditions (const char *)
transformer	load_summary_transformer (entity)
void	update_summary_precondition (entity, transformer)
	void update_summary_precondition(e, t): t is supposed to be a precondition related to one of e's call sites and translated into e's basis; More...
transformer	load_summary_precondition (entity)
	summary_preconditions are expressed in any possible frame, in fact the frame of the last procedure that used/produced it More...
transformer	load_summary_total_postcondition (entity)
	summary_preconditions are expressed in any possible frame, in fact the frame of the last procedure that used/produced it More...
list	load_summary_effects (entity)
	FI->FI, FI->BC: these two functions should be moved into effects-util or effects-simple. More...
list	load_body_effects (entity)
list	load_module_intraprocedural_effects (entity)
void	cumulated_effects_map_print (void)
	ca n'a rien a` faire ici, et en plus, il serait plus inte'ressant d'avoir une fonction void statement_map_print(statement_mapping htp) More...
bool	semantic_map_undefined_p (void)
	prettyprint.c More...
void	set_semantic_map (statement_mapping)
statement_mapping	get_semantic_map (void)
void	reset_semantic_map (void)
void	free_semantic_map (void)
void	make_semantic_map (void)
transformer	load_statement_semantic (statement)
void	delete_statement_semantic (statement)
bool	statement_semantic_undefined_p (statement)
void	store_statement_semantic (statement, transformer)
void	update_statement_semantic (statement, transformer)
void	set_prettyprint_transformer (void)
bool	print_code_transformers (const char *)
bool	print_code_as_a_graph_transformers (const string)
bool	print_code_preconditions (const char *)
bool	print_code_as_a_graph_preconditions (const string)
bool	print_code_total_preconditions (const char *)
bool	print_code_as_a_graph_total_preconditions (const string)
bool	print_source_transformers (const char *)
bool	print_source_preconditions (const char *)
bool	print_source_total_preconditions (const char *)
text	get_text_transformers (const string)
text	get_text_preconditions (const string)
text	get_text_total_preconditions (const string)
text	semantic_to_text (entity, int, statement)
	this function name is VERY misleading - it should be changed, sometime FI More...
text	text_transformer (transformer)
	text text_transformer(transformer tran) input : a transformer representing a transformer or a precondition output : a text containing commentaries representing the transformer modifies : nothing. More...
text	text_for_a_transformer (transformer, bool)
	call this one from outside. More...
text	string_predicate_to_commentary (string, string)
	text string_predicate_to_commentary(string str_pred, string comment_prefix) input : a string, part of which represents a predicate. More...
text	words_predicate_to_commentary (list, string)
	text words_predicate_to_commentary(list w_pred, string comment_prefix) input : a list of strings, one of them representing a predicate. More...
sentence	make_pred_commentary_sentence (string, string)
	sentence make_pred_commentary_sentence(string str_pred, string comment_prefix) input : a substring formatted to be a commentary output : a sentence, containing the commentary form of this string, beginning with the comment_prefix. More...
bool	print_call_graph_with_transformers (const string)
bool	print_call_graph_with_preconditions (const string)
bool	print_call_graph_with_total_preconditions (const string)
bool	print_icfg_with_preconditions (const string)
bool	print_icfg_with_transformers (const string)
bool	print_icfg_with_loops_preconditions (const string)
bool	print_icfg_with_loops_transformers (const string)
bool	print_icfg_with_control_preconditions (const string)
bool	print_icfg_with_control_transformers (const string)
bool	print_icfg_with_total_preconditions (const string)
bool	print_icfg_with_loops_total_preconditions (const string)
bool	print_icfg_with_control_total_preconditions (const string)
bool	postcondition_map_undefined_p (void)
	postcondition.c More...
void	set_postcondition_map (statement_mapping)
statement_mapping	get_postcondition_map (void)
void	reset_postcondition_map (void)
void	free_postcondition_map (void)
void	make_postcondition_map (void)
transformer	load_statement_postcondition (statement)
void	delete_statement_postcondition (statement)
bool	statement_postcondition_undefined_p (statement)
void	store_statement_postcondition (statement, transformer)
void	update_statement_postcondition (statement, transformer)
statement_mapping	compute_postcondition (statement, statement_mapping, statement_mapping)
	statement_mapping compute_postcondition(stat, post_map, pre_map) statement stat; statement_mapping post_map, pre_map; More...
bool	statement_weakly_feasible_p (statement)
	utils.c More...
bool	statement_feasible_p (statement)
	Return true if statement s is reachable according to its precondition. More...
bool	statement_strongly_feasible_p (statement)
	Return true if statement s is reachable according to its precondition. More...
bool	empty_range_wrt_precondition_p (range, transformer)
	A range cannot be tested exactly wrt a precondition You can try to prove that it is empty or you can try to prove that it is not empty. More...
bool	non_empty_range_wrt_precondition_p (range, transformer)
bool	check_range_wrt_precondition (range, transformer, bool)
	FI: this function is outdated because it does not compute the transformers for the range expressions, because it does not take side effects into account and ... More...
bool	condition_true_wrt_precondition_p (expression, transformer)
	A condition cannot be tested exactly wrt a precondition You can try to prove that it is always true (because it is never false) or you can try to prove that it is always false (because it is never true). More...
bool	condition_false_wrt_precondition_p (expression, transformer)
bool	check_condition_wrt_precondition (expression, transformer, bool)
void	expression_and_precondition_to_integer_interval (expression, transformer, int *, int *)
	Evaluate expression e in context p, assuming that e is an integer expression. More...
void	integer_expression_and_precondition_to_integer_interval (expression, transformer, int *, int *)
	Could be used for bool expressions too? Extended to any kind of expression? More...
void	integer_value_and_precondition_to_integer_interval (entity, transformer, int *, int *)
	Should be used by previous function, integer_expression_and_precondition_to_integer_interval() More...
bool	initial_precondition (string)
	initial.c More...
bool	program_precondition (const string)
	Compute the union of all initial preconditions. More...
bool	program_postcondition (const string)
	The program correctness postcondition cannot be infered. More...
bool	print_initial_precondition (const string)
bool	print_program_precondition (const string)
void	print_control_postcondition_map (control_mapping)
	unstructured.c More...
transformer	load_cycle_fix_point (control, hash_table)
void	update_temporary_precondition (void *, transformer, hash_table)
void	update_statement_temporary_precondition (statement, transformer, statement_mapping)
void	print_statement_temporary_precondition (statement_mapping)
void	update_cycle_temporary_precondition (control, transformer, control_mapping)
transformer	load_cycle_temporary_precondition (control, control_mapping, hash_table, hash_table)
transformer	load_statement_temporary_precondition (statement, statement_mapping)
transformer	dag_or_cycle_to_flow_sensitive_postconditions_or_transformers (list, unstructured, hash_table, hash_table, control_mapping, transformer, transformer, hash_table, bool, bool)
	Should ndu be a dag or a cycle? More...
transformer	dag_to_flow_sensitive_postconditions_or_transformers (list, unstructured, hash_table, hash_table, control_mapping, transformer, transformer, hash_table, bool)
	Compute transformers or preconditions. More...
transformer	cycle_to_flow_sensitive_postconditions_or_transformers (list, unstructured, hash_table, hash_table, control_mapping, transformer, transformer, hash_table, bool)
	Compute transformers or preconditions. More...
transformer	unstructured_to_flow_sensitive_postconditions_or_transformers (transformer, transformer, unstructured, bool)
	compute either the postconditions in an unstructured or the transformer of this unstructured. More...
transformer	unstructured_to_flow_sensitive_postconditions (transformer, transformer, unstructured)
	compute pre- and post-conditions in an unstructured from the entry precondition pre and return the exit postcondition. More...
transformer	unstructured_to_postcondition (transformer, unstructured, transformer)
transformer	unstructured_to_flow_insensitive_transformer (unstructured)
	This simple fix-point over-approximates the CFG by a fully connected graph. More...
transformer	unstructured_to_transformer (unstructured, transformer, list)
	effects of u More...
transformer	unstructured_to_flow_sensitive_total_preconditions (transformer, transformer, unstructured)
transformer	generic_reference_to_transformer (entity, reference, transformer, bool)
	expression.c More...
transformer	any_basic_update_operation_to_transformer (entity, entity, entity)
	See also any_basic_update_to_transformer(), which should be based on this function. More...
transformer	any_assign_operation_to_transformer (entity, list, transformer, bool)
transformer	safe_any_assign_operation_to_transformer (entity, list, transformer, bool)
transformer	transformer_add_condition_information (transformer, expression, transformer, bool)
transformer	precondition_add_condition_information (transformer, expression, transformer, bool)
	context might be derivable from pre as transformer_range(pre) but this is sometimes very computationally intensive, e.g. More...
transformer	transformer_add_domain_condition (transformer, expression, transformer, bool)
transformer	transformer_add_range_condition (transformer, expression, transformer, bool)
transformer	simple_affine_to_transformer (entity, Pvecteur, bool)
	INTEGER EXPRESSIONS. More...
transformer	affine_to_transformer (entity, Pvecteur, bool)
transformer	affine_increment_to_transformer (entity, Pvecteur)
transformer	modulo_by_a_constant_to_transformer (entity, transformer, entity, int)
	Analyze v2 % k, with v2 constrainted by tf, assuming tf is a precondition. More...
transformer	assign_operation_to_transformer (entity, expression, expression, transformer)
	Returns an undefined transformer in case of failure. More...
transformer	points_to_unary_operation_to_transformer (entity, entity, expression, transformer, bool, bool)
	This function is redundant with generic_unary_operation_to_transformer() except for its use of parameter is_pointer. More...
transformer	expression_effects_to_transformer (expression)
transformer	integer_expression_to_transformer (entity, expression, transformer, bool)
	Do check wrt to value mappings... More...
transformer	safe_integer_expression_to_transformer (entity, expression, transformer, bool)
	Always return a defined transformer, using effects in case a more precise analysis fails. More...
transformer	transformer_logical_inequalities_add (transformer, entity)
	PROCESSING OF LOGICAL EXPRESSIONS. More...
transformer	logical_intrinsic_to_transformer (entity, call, transformer, bool)
transformer	logical_expression_to_transformer (entity, expression, transformer, bool)
	Could be used to compute preconditions too. More...
transformer	string_expression_to_transformer (entity, expression)
transformer	float_expression_to_transformer (entity, expression, transformer, bool)
transformer	pointer_expression_to_transformer (entity, expression, transformer, bool)
transformer	transformer_add_any_relation_information (transformer, entity, expression, expression, transformer, bool, bool)
	compute transformer or precondition More...
transformer	any_expression_side_effects_to_transformer (expression, transformer, bool)
transformer	any_expressions_side_effects_to_transformer (list, transformer, bool)
	same as any_expression_side_effects_to_transformer() but for a list of expressions More...
transformer	safe_any_expression_side_effects_to_transformer (expression, transformer, bool)
	Same as any_expression_side_effects_to_transformer() but effects are used to always generate a transformer. More...
transformer	any_expression_to_transformer (entity, expression, transformer, bool)
	A set of functions to compute the transformer associated to an expression evaluated in a given context. More...
transformer	safe_any_expression_to_transformer (entity, expression, transformer, bool)
	Always return a usable transformer. More...
transformer	expression_to_transformer (expression, transformer, list)
	Just to capture side effects as the returned value is ignored. More...
transformer	safe_expression_to_transformer (expression, transformer)
transformer	condition_to_transformer (expression, transformer, bool)
	To capture side effects and to add C twist for numerical conditions. More...
transformer	conditional_to_transformer (expression, expression, expression, transformer, list)
	FI: not too smart to start with the special case with no value returned, just side-effects... More...
transformer	any_conditional_to_transformer (entity, list, transformer)
	Take care of the returned value. More...
transformer	logical_not_to_transformer (entity, list, transformer)
	returns the transformer associated to a C logical not, !, applied to an integer argument, when meaningful, and transformer_undefined otherwise. More...
transformer	bitwise_xor_to_transformer (entity, list, transformer)
	returns the transformer associated to a C bitwise xor, ^, applied to two integer argument, when meaningful, and transformer_undefined otherwise. More...
transformer	expressions_to_transformer (list, transformer)
	Compute the transformer associated to a list of expressions such as "i=0, j = 1;". More...
transformer	any_expressions_to_transformer (entity, list, transformer)
	Compute the transformer associated to a list of expressions such as "i=0, j = 1;". More...
bool	precondition_minmax_of_value (entity, transformer, intptr_t *, intptr_t *)
	compute integer bounds pmax, pmin of value val under preconditions tr require value mappings set ! More...
bool	precondition_minmax_of_expression (expression, transformer, intptr_t *, intptr_t *)
	compute integer bounds pmax, pmin of expression exp under preconditions tr require value mappings set ! More...
void	simplify_minmax_expression (expression, transformer)
	tries hard to simplify expression e if it is a min or a max operator, by evaluating it under preconditions tr. More...
bool	false_condition_wrt_precondition_p (expression, transformer)
bool	true_condition_wrt_precondition_p (expression, transformer)
bool	eval_condition_wrt_precondition_p (expression, transformer, bool)
transformer	transformer_add_integer_relation_information (transformer, entity, expression, expression, bool, bool)
	It is supposed to be obsolete but is still called. More...
int	simplify_boolean_expression_with_precondition (expression, transformer)
	Simplification of bool expressions with precondition. More...
bool	semantics_usable_points_to_reference_p (reference, expression, int)
	See if references rlhs is usable and process null, undefined and anywhere locations defined by rlhs. More...
transformer	lhs_expression_to_transformer (entity, expression, transformer)
	This function deals with e1.e2 and e1->e2, not with simple references such as x or a[i]. More...
transformer	any_loop_to_k_transformer (transformer, transformer, transformer, statement, list, transformer, int)
	loop.c More...
transformer	any_loop_to_transformer (transformer, transformer, transformer, statement, list, transformer)
transformer	forloop_to_transformer (forloop, transformer, list)
	effects of forloop fl More...
list	forloop_to_transformer_list (forloop, transformer, list)
transformer	new_whileloop_to_transformer (whileloop, transformer, list)
	effects of whileloop wl More...
transformer	new_whileloop_to_k_transformer (whileloop, transformer, list, int)
transformer	repeatloop_to_transformer (whileloop, transformer, list)
	effects of whileloop wl More...
transformer	add_loop_skip_condition (transformer, loop, transformer)
	tf and pre are a unique data structure when preconditions are computed More...
transformer	add_index_range_conditions (transformer, entity, range, transformer)
transformer	add_loop_index_exit_value (transformer, loop, transformer)
	The exit value is known if. More...
bool	simple_dead_loop_p (expression, expression)
transformer	precondition_filter_old_values (transformer)
transformer	transformer_add_loop_index_initialization (transformer, loop, transformer)
	The loop initialization is performed before tf. More...
transformer	transformer_add_loop_index_incrementation (transformer, loop, transformer)
transformer	loop_bound_evaluation_to_transformer (loop, transformer)
	Side effects in loop bounds and increment are taken into account. More...
transformer	loop_initialization_to_transformer (loop, transformer)
	Note: It used to be implemented by computing the effect list of the lower bound expression and and new allocated effect for the loop index definition. More...
transformer	loop_to_transformer (loop, transformer, list)
	The transformer associated to a DO loop does not include the exit condition because it is used to compute the precondition for any loop iteration. More...
list	loop_to_transformer_list (loop, transformer, list)
transformer	loop_to_initialization_transformer (loop, transformer)
	Transformer expression the loop initialization. More...
transformer	loop_to_enter_transformer (loop, transformer)
	Transformer expressiong the conditions between the index and the loop bounds according to the sign of the increment. More...
transformer	loop_to_continue_transformer (loop, transformer)
transformer	new_loop_to_transformer (loop, transformer, list)
	loop_to_transformer() was developed first but is not as powerful as the new algorithm used for all kinds of loops. More...
list	complete_any_loop_transformer_list (transformer, transformer, transformer, transformer, transformer, transformer)
	FI: used to be complete_any_loop_transformer() with a direct reduction by convex hull. More...
transformer	complete_any_loop_transformer (transformer, transformer, transformer, transformer, transformer, transformer, transformer, transformer)
transformer	complete_forloop_transformer (transformer, transformer, forloop)
list	complete_forloop_transformer_list (transformer, transformer, forloop)
list	new_complete_whileloop_transformer_list (transformer, transformer, whileloop, bool)
transformer	new_complete_whileloop_transformer (transformer, transformer, whileloop, bool)
	entered_p is used to for the execution of at least one iteration More...
list	complete_repeatloop_transformer_list (transformer, transformer, whileloop)
transformer	complete_repeatloop_transformer (transformer, transformer, whileloop)
transformer	complete_loop_transformer (transformer, transformer, loop)
	The transformer computed and stored for a loop is useful to compute the loop body precondition, but it is not useful to analyze a higher level construct, which need the loop transformer with the exit condition. More...
list	complete_loop_transformer_list (transformer, transformer, loop)
transformer	complete_whileloop_transformer (transformer, transformer, whileloop)
	FI: I'm not sure this function is useful. More...
list	complete_whileloop_transformer_list (transformer, transformer, whileloop)
transformer	old_complete_whileloop_transformer (transformer, transformer, whileloop)
transformer	standard_whileloop_to_transformer (whileloop, transformer, list)
	This function computes the effect of K loop iteration, with K positive. More...
transformer	whileloop_to_transformer (whileloop, transformer, list)
	effects of whileloop l More...
transformer	whileloop_to_k_transformer (whileloop, transformer, list, int)
transformer	any_loop_to_postcondition (statement, transformer, transformer, transformer, transformer, transformer, transformer, transformer, transformer, transformer)
transformer	forloop_to_postcondition (transformer, forloop, transformer)
transformer	repeatloop_to_postcondition (transformer, whileloop, transformer)
transformer	loop_to_postcondition (transformer, loop, transformer)
transformer	loop_to_total_precondition (transformer, loop, transformer, transformer)
transformer	whileloop_to_postcondition (transformer, whileloop, transformer)
transformer	whileloop_to_total_precondition (transformer, whileloop, transformer, transformer)
transformer	statement_to_total_precondition (transformer, statement)
	ri_to_total_preconditions.c More...
list	declaration_to_transformer_list (entity, transformer)
	ri_to_transformer_lists.c More...
list	declarations_to_transformer_list (list, transformer)
	For C declarations. More...
list	intrinsic_to_transformer_list (entity, list, transformer, list)
	because of the conditional and the comma C intrinsics at least More...
list	assigned_expression_to_transformer_list (entity, expression, transformer)
	transformer assigned_expression_to_transformer(entity e, expression expr, list ef): returns a transformer abstracting the effect of assignment "e = expr" when possible, transformer_undefined otherwise. More...
list	safe_assigned_expression_to_transformer_list (entity, expression, transformer)
	Always returns a fully defined transformer. More...
list	integer_assign_to_transformer_list (expression, expression, transformer, list)
	This function never returns an undefined transformer. More...
list	any_scalar_assign_to_transformer_list (entity, expression, list, transformer)
	precondition More...
list	any_assign_to_transformer_list (list, list, transformer)
	precondition More...
list	any_update_to_transformer_list (entity, list, list, transformer)
	precondition More...
list	any_basic_update_to_transformer_list (entity, list, list, transformer)
	precondition More...
list	statement_to_transformer_list (statement, transformer)
	A transformer is already available for statement s, but it is going to be refined into a list of transformers to isolate at least the identity transformer from effective transformers. More...
void	path_initialize (statement, statement, statement, path *, path *)
	path_transformer.c More...
transformer	path_transformer_on (statement, path, path, int)
transformer	compute_path_transformer (statement, path, path)
bool	path_transformer (const string)
void	transformer_add_type_information (transformer)
	type.c More...
void	transformer_add_variable_type_information (transformer, entity)
list	semantics_expression_to_points_to_sources (expression)
	points_to.c More...
list	semantics_expression_to_points_to_sinks (expression)
	Returns a list of cells. More...
transformer	substitute_scalar_stub_in_transformer (transformer, entity, entity, bool, list *)
	If both "se", source entity, and "de", destination entity, are defined, substitute the values of "se" by the values of "de" in "backward_p" mode, when translating a callee transformer at a call site of a caller. More...
transformer	substitute_struct_stub_in_transformer (transformer, reference, type, reference, type, bool, list *)
transformer	substitute_stubs_in_transformer (transformer, call, statement, bool)
	Exploit the binding map to substitute calles's stubs by actual arguments, which may be stubs of the callers,. More...
transformer	new_substitute_stubs_in_transformer (transformer, call, statement, bool)

Variables
bool	refine_transformers_p
	Transformer recomputation cannot be of real use unless an interprocedural analysis is performed. More...

Macro Definition Documentation

SEMANTICS_OPTIONS

#define SEMANTICS_OPTIONS   "?Otcfieod-D:"

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

Modify src/Libs/semantics/semantics-local.h instead, to add your own modifications. header file built by cproto semantics-local.h include file for semantic analysis

Definition at line 34 of file semantics.h.

semantics_user_warning

#define semantics_user_warning   semantics_user_warning_func2

Definition at line 54 of file semantics.h.

SEQUENTIAL_PRECONDITION_SUFFIX

#define SEQUENTIAL_PRECONDITION_SUFFIX   ".prec"

Definition at line 38 of file semantics.h.

SEQUENTIAL_TOTAL_PRECONDITION_SUFFIX

#define SEQUENTIAL_TOTAL_PRECONDITION_SUFFIX   ".tprec"

Definition at line 40 of file semantics.h.

SEQUENTIAL_TRANSFORMER_SUFFIX

#define SEQUENTIAL_TRANSFORMER_SUFFIX   ".tran"

Definition at line 36 of file semantics.h.

USER_PRECONDITION_SUFFIX

#define USER_PRECONDITION_SUFFIX   ".uprec"

Definition at line 39 of file semantics.h.

USER_TOTAL_PRECONDITION_SUFFIX

#define USER_TOTAL_PRECONDITION_SUFFIX   ".utprec"

Definition at line 41 of file semantics.h.

USER_TRANSFORMER_SUFFIX

#define USER_TRANSFORMER_SUFFIX   ".utran"

Definition at line 37 of file semantics.h.

Function Documentation

add_declaration_list_information()

void add_declaration_list_information	(	transformer	pre,
		list	dl,
		bool	precondition_p
	)

Parameters

pre	re
dl	l
precondition_p	recondition_p

Definition at line 179 of file dbm_interface.c.

{
  entity m = get_current_module_entity();
  code c = value_code(entity_initial(m));
  language l = code_language(c);
 
  FOREACH(ENTITY, v, dl) {
    type t = entity_type(v);
 
    if(type_variable_p(t)) {
      variable tv = type_variable(t);
 
      FOREACH(DIMENSION, d, variable_dimensions(tv)) {
        normalized nl = NORMALIZE_EXPRESSION(dimension_lower(d));
        normalized nu = NORMALIZE_EXPRESSION(dimension_upper(d));
 
        if(normalized_linear_p(nl) && normalized_linear_p(nu)) {
          Pvecteur vl = normalized_linear(nl);
          Pvecteur vu = normalized_linear(nu);
 
          if(value_mappings_compatible_vector_p(vl) &&
             value_mappings_compatible_vector_p(vu)) {
            Pvecteur cv = vect_substract(vl, vu);
 
            if(language_c_p(l))
              vect_add_elem(&cv, TCST, VALUE_MONE);
 
            if(!precondition_p) {
              upwards_vect_rename(cv, pre);
            }
 
            if(!vect_constant_p(cv) || vect_coeff(TCST, cv) > 0) {
              transformer_inequality_add(pre, cv);
            }
          }
        }
      }
 
    }
  }
}

References code_language, DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_initial, entity_type, FOREACH, get_current_module_entity(), language_c_p, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, TCST, transformer_inequality_add(), type_variable, type_variable_p, upwards_vect_rename(), value_code, value_mappings_compatible_vector_p(), VALUE_MONE, variable_dimensions, vect_add_elem(), vect_coeff(), vect_constant_p(), and vect_substract().

Referenced by add_declaration_information().

Here is the call graph for this function:

Here is the caller graph for this function:

add_equivalenced_values()

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

e and eq are assumed to be different scalar variables of the same analyzed type

eq will be seen as e, as far as values are concerned, but for printing

new equalities e::new == eq::new and e::old == eq::old have to be added to the preconditions just before they are stored; since eq should never be written no eq::old should appear; thus the first equation is enough

By definition, all variables are conflicting with themselves but this is assumed filtered out above.

add the equivalence equations

Parameters

eq	q
readonly	eadonly

Definition at line 107 of file mappings.c.

{
  /* e and eq are assumed to be different scalar variables of the same
     analyzed type */
  /* eq will be seen as e, as far as values are concerned,
     but for printing */
  /* new equalities e#new == eq#new and e#old == eq#old
     have to be added to the preconditions just before they
     are stored; since eq should never be written no eq#old
     should appear; thus the first equation is enough */
 
  /* By definition, all variables are conflicting
     with themselves but this is assumed filtered out above. */
 
  pips_assert("e is not eq", e!=eq);
 
  add_synonym_values(e, eq, readonly);
  /* add the equivalence equations */
  add_equivalence_equality(e, eq);
 
}

References add_equivalence_equality(), add_synonym_values(), eq, 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:

add_formal_to_actual_bindings()

transformer add_formal_to_actual_bindings	(	call	c,
		transformer	pre,
		entity	caller
	)

add_formal_to_actual_bindings(call c, transformer pre, entity caller):

pre := pre U {f = expr } i i for all i such that formal f_i is an analyzable scalar variable and as far as expression expr_i is analyzable and of the same type

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

type checking. You already know that fp is a scalar variable

Do not care about side effects on expressions: this is used to map a caller precondition towards a callee summary precondition.

tmp must be used instead of fp_new because fp_new does not exist in the caller frame

Likely memory leak for the initial pre

ignore assocation

Parameters

pre	re
caller	aller

Definition at line 283 of file interprocedural.c.

{
  entity f = call_function(c);
  list pc = call_arguments(c);
  list formals = module_to_formal_analyzable_parameters(f);
  cons * ce;
 
  pips_debug(6, "begin for call to %s from %s, pre=%p\n",
             module_local_name(f), module_local_name(caller), pre);
  ifdebug(6) dump_transformer(pre);
 
  pips_assert("f is a module",
              entity_module_p(f));
  pips_assert("The precondition pre is defined",
              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 fp = ENTITY(CAR(ce));
    int r = formal_offset(storage_formal(entity_storage(fp)));
    expression expr = find_ith_argument(pc, r);
 
    if(expr == expression_undefined)
      pips_user_error("not enough args in call to %s from %s for formal parameter %s of rank %d\n",
                      module_local_name(f),
                      module_local_name(caller),
                      entity_local_name(fp), r);
    else {
      /* type checking. You already know that fp is a scalar variable */
      type tfp = entity_type(fp);
      basic bfp = variable_basic(type_variable(tfp));
      basic bexpr = basic_of_expression(expr);
 
      if(!same_basic_p(bfp, bexpr)) {
        pips_user_warning("Type incompatibility (%s/%s) for formal parameter \"%s\""
                          " (rank %d)\nin call to \"%s\" from \"%s\"\n",
                          basic_to_string(bfp), basic_to_string(bexpr),
                          entity_local_name(fp), r,
                          module_local_name(f), module_local_name(caller));
      }
 
      if(basic_tag(bfp)==basic_tag(bexpr)) {
        /* Do not care about side effects on expressions: this is used to map
           a caller precondition towards a callee summary precondition. */
        entity fp_new = external_entity_to_new_value(fp);
        entity tmp = make_local_temporary_value_entity(entity_type(fp));
        /* tmp must be used instead of fp_new because fp_new does not
           exist in the caller frame */
        transformer t_expr = any_expression_to_transformer(tmp, expr,
                                                           transformer_undefined,
                                                           false);
 
        t_expr = transformer_safe_value_substitute(t_expr, tmp, fp_new);
        /* Likely memory leak for the initial pre */
        pre = transformer_safe_image_intersection(pre, t_expr);
        free_transformer(t_expr);
       }
      else {
        /* ignore assocation */
        pips_debug(6, "Full type incompatibility (%s/%s) for formal parameter %s (rank %d)"
                   " in call to %s from %s\n"
                   "Association ignored",
                   basic_to_string(bfp), basic_to_string(bexpr),
                   entity_local_name(fp), r, module_local_name(f),
                   module_local_name(caller));
      }
    }
  }
 
  free_arguments(formals);
 
  ifdebug(6) {
    pips_debug(6, "new pre=%p\n", pre);
    dump_transformer(pre);
    pips_debug(6, "end for call to %s from %s\n", module_local_name(f),
               module_local_name(caller));
  }
 
  return pre;
}

References any_expression_to_transformer(), basic_of_expression(), basic_tag, basic_to_string(), call_arguments, call_function, CAR, dump_transformer, ENDP, ENTITY, entity_local_name(), entity_module_p(), entity_storage, entity_type, expression_undefined, external_entity_to_new_value(), f(), find_ith_argument(), formal_offset, free_arguments(), free_transformer(), ifdebug, make_local_temporary_value_entity(), module_local_name(), module_to_formal_analyzable_parameters(), pips_assert, pips_debug, pips_user_error, pips_user_warning, POP, same_basic_p(), storage_formal, transformer_safe_image_intersection(), transformer_safe_value_substitute(), transformer_undefined, type_variable, and variable_basic.

Referenced by call_site_to_module_precondition_text(), and call_to_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

add_implicit_interprocedural_write_effects()

void add_implicit_interprocedural_write_effects	(	entity	al,
		list	el
	)

It is assumed that al is an abstract location that is written and which may conflict with effects in effect list el.

If there is a conflict, than the variable associated to this effect is written.

It should be generalized to non-interprocedural cases.

Parameters

al	l
el	l

Definition at line 382 of file mappings.c.

{
  type alt = entity_type(al);
 
  if(type_unknown_p(alt)
     || type_area_p(alt) // FI: Let's agree about typing issues!
     || get_bool_property("ALIASING_ACROSS_TYPES")
     || overloaded_type_p(alt)) {
    FOREACH(EFFECT, ef, el) {
      reference r = effect_any_reference(ef);
      entity v = reference_variable(r);
 
      if(!entity_abstract_location_p(v)
         && entities_may_conflict_p(al, v)
         && analyzable_scalar_entity_p(v)) {
        add_interprocedural_value_entities(v);
      }
    }
  }
  else {
    FOREACH(EFFECT, ef, el) {
      reference r = effect_any_reference(ef);
      entity v = reference_variable(r);
      type vt = ultimate_type(entity_type(v));
 
      if(!entity_abstract_location_p(v)
         && entities_may_conflict_p(al, v)
         && type_equal_p(alt, vt)) {
        if(dummy_parameter_entity_p(v))
          pips_internal_error("Effects cannot be related to dummy parameters.");
        add_interprocedural_value_entities(v);
      }
    }
  }
}

References add_interprocedural_value_entities(), analyzable_scalar_entity_p(), dummy_parameter_entity_p(), EFFECT, effect_any_reference, entities_may_conflict_p(), entity_abstract_location_p(), entity_type, FOREACH, get_bool_property(), overloaded_type_p(), pips_internal_error, reference_variable, type_area_p, type_equal_p(), type_unknown_p, and ultimate_type().

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

add_index_range_conditions()

transformer add_index_range_conditions	(	transformer	pre,
		entity	i,
		range	r,
		transformer	tfb
	)

if tfb is not undefined, then it is a loop; loop bounds can be kept as preconditions for the loop body if the loop increment is numerically known and if they are linear and if they are loop body invariant, i.e. indices are accepted

is the loop increment numerically known? Is its sign known?

incr == 0 is used below as a give-up condition

When lost, try to exploit type information thanks to unsigned variables

find the real upper and lower bounds

try to add the lower bound

try to add the upper bound

Parameters

pre	re
tfb	fb

Definition at line 711 of file loop.c.

{
  /* if tfb is not undefined, then it is a loop;
     loop bounds can be kept as preconditions for the loop body
     if the loop increment is numerically known and if they
     are linear and if they are loop body invariant, i.e.
     indices are accepted */
 
  expression lb = range_lower(r);
  expression ub = range_upper(r);
  expression e_incr = range_increment(r);
  int incr = 0;
  int incr_lb = 0;
  int incr_ub = 0;
 
  pips_debug(8, "begin\n");
 
  if(entity_has_values_p(i)) {
 
    /* is the loop increment numerically known? Is its sign known? */
    expression_and_precondition_to_integer_interval(e_incr, pre, &incr_lb, &incr_ub);
 
    if(incr_lb==incr_ub) {
      if(incr_lb==0) {
        pips_user_error("Illegal null increment\n");
      }
      else
        incr = incr_lb;
    }
    else if(incr_lb>=1) {
      incr = 1;
    }
    else if(incr_ub<=-1) {
      incr = -1;
    }
    else {
      /* incr == 0 is used below as a give-up condition */
      incr = 0;
    }
 
    /* When lost, try to exploit type information thanks to unsigned variables */
    if(incr==0) {
      if(positive_expression_p(e_incr))
        incr = 1;
      else if(negative_expression_p(e_incr))
        incr = -1;
    }
 
    /* find the real upper and lower bounds */
    if(incr<0) {
      ub = range_lower(r);
      lb = range_upper(r);
    }
 
    if(incr!=0) {
      if(simple_dead_loop_p(lb, ub)) {
        transformer new_pre = transformer_empty();
 
        free_transformer(pre);
        pre = new_pre;
      }
      else {
        /* try to add the lower bound */
        add_index_bound_conditions(pre, i, lb, IS_LOWER_BOUND, tfb);
 
        /* try to add the upper bound */
        add_index_bound_conditions(pre, i, ub, IS_UPPER_BOUND, tfb);
      }
    }
 
  }
 
  pips_debug(8, "end\n");
  return pre;
}

References add_index_bound_conditions(), entity_has_values_p(), expression_and_precondition_to_integer_interval(), free_transformer(), IS_LOWER_BOUND, IS_UPPER_BOUND, negative_expression_p(), pips_debug, pips_user_error, positive_expression_p(), range_increment, range_lower, range_upper, simple_dead_loop_p(), and transformer_empty().

Referenced by add_good_loop_conditions(), comp_regions_of_implied_do(), and loop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

add_intraprocedural_value_entities()

void add_intraprocedural_value_entities

(

entity

e

)

Use to be static, but may be called from ri_to_transformer.

void add_intraprocedural_value_entities(entity e)

Definition at line 181 of file mappings.c.

{
  type ut = entity_basic_concrete_type(e);
 
  pips_debug(8, "for %s\n", entity_name(e));
  if(!entity_has_values_p(e) && type_variable_p(ut) ) {
    add_intraprocedural_value_entities_unconditionally(e);
  }
}

References add_intraprocedural_value_entities_unconditionally(), entity_basic_concrete_type(), entity_has_values_p(), entity_name, pips_debug, and type_variable_p.

Referenced by add_inter_or_intraprocedural_field_entities(), add_reference_values(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

add_loop_index_exit_value()

transformer add_loop_index_exit_value	(	transformer	post,
		loop	l,
		transformer	pre
	)

The exit value is known if.

• the loop index is an analyzed integer scalar variable real index are standard-compliant, integer index can be equivalenced to a real variable,...
• the increment is affine (non-necessary assumption made: it is affine if the increment sign is known)
• the increment sign is known
• the body and loop initialization execution does not modify the value of the upper bound
• the upper bound is affine (?)

Affine increments can be handled when their signs only are known.

For instance, for increment==k: i >= ub i-k <= ub-1

Note the simplification when k==1.

But, first of all, the value of the loop index in post must be incremented. This changes its relationship with induction variables.

Most tests here are redundant because this function is only called if it has been proved that the loop was executed which implies that the upper and lower bounds are affine, that the increment is affine and that the increment sign is known.

Always returns a newly allocated value precondition on loop entrance

This part should be useless because post really is a loop postcondition. There should be no need for an index incrementation or anything. It is used to recover some of the fix-point failures:-(

In fact, it may be useful. The loop transformer and its invariant are computed without knowledge about the number of iteration, which may be zero. By adding one execution of the loop body and the index incrementation, we change b* into b+ which should add effective information.

Do not apply an extra iteration!

post = transformer_apply(t_body, post);

v_i - v_incr == v_ub, regardless of the sign

v_i - v_incr <= v_ub < v_i or: v_i - v_incr - v_ub <= 0, v_ub - v_i + 1 <= 0

v_i - v_incr >= v_ub > v_i

or:

• v_i + v_incr + v_ub <= 0, - v_ub + v_i + 1 <= 0

should never happen!

Parameters

post	ost
l	postcondition of the last iteration
pre	loop to process

Definition at line 878 of file loop.c.

{
  entity i = loop_index(l);
  expression e_incr = range_increment(loop_range(l));
  normalized n_incr = NORMALIZE_EXPRESSION(e_incr);
  expression e_ub = range_upper(loop_range(l));
  normalized n_ub = NORMALIZE_EXPRESSION(e_ub);
  transformer t_incr = transformer_undefined;
  transformer t_body = load_statement_transformer(loop_body(l));
  list li = CONS(ENTITY, i, NIL);
  int ub_inc = 0;
  int lb_inc = 0;
 
  ifdebug(8) {
    pips_debug(8, "begin with post:\n");
    (void) print_transformer(post);
  }
 
  if(!entity_has_values_p(i)) {
    ifdebug(8) {
      pips_debug(8, "give up because %s has no values:\n",
            entity_local_name(i));
      pips_debug(8, "end with post:\n");
      (void) print_transformer(post);
    }
    return transformer_dup(post);
  }
 
  expression_and_precondition_to_integer_interval(e_incr, pre, &lb_inc, &ub_inc);
 
  /* This part should be useless because post really is a loop postcondition.
   * There should be no need for an index incrementation or anything.
   * It is used to recover some of the fix-point failures:-(
   *
   * In fact, it may be useful. The loop transformer and its invariant are
   * computed without knowledge about the number of iteration, which may be
   * zero. By adding one execution of the loop body and the index incrementation,
   * we change b* into b+ which should add effective information.
   */
  if(normalized_linear_p(n_incr)) {
    Pvecteur v_incr = (Pvecteur) normalized_linear(n_incr);
    if(value_mappings_compatible_vector_p(v_incr)) {
      entity i_new = entity_to_new_value(i);
      entity i_rep = value_to_variable(i_new);
      t_incr = affine_increment_to_transformer(i_rep, v_incr);
    }
    else {
      t_incr = transformer_undefined;
    }
  }
  else {
    t_incr = transformer_undefined;
  }
  if(t_incr==transformer_undefined)
    t_incr = args_to_transformer(li);
  /* Do not apply an extra iteration! */
  /* post = transformer_apply(t_body, post); */
  post = transformer_apply(t_incr, post);
  transformer_free(t_incr);
 
  ifdebug(8) {
    pips_debug(8, "post after index incrementation:\n");
    (void) print_transformer(post);
  }
 
  if(normalized_linear_p(n_ub)
     && !transformer_affect_linear_p(t_body, (Pvecteur) normalized_linear(n_ub))) {
    if(lb_inc >= 1 || ub_inc <= -1) {
      Pvecteur v_ub = (Pvecteur) normalized_linear(n_ub);
      Pvecteur v_incr = (Pvecteur) normalized_linear(n_incr);
 
      if(value_mappings_compatible_vector_p(v_ub)
         && value_mappings_compatible_vector_p(v_incr)) {
        entity i_new = entity_to_new_value(i);
        entity i_rep = value_to_variable(i_new);
        Pvecteur v_i = vect_new((Variable) i_rep, (Value) 1);
        Pvecteur c1 = VECTEUR_UNDEFINED;
        Pvecteur c2 = VECTEUR_UNDEFINED;
 
        pips_assert("The increment is an affine function", normalized_linear_p(n_incr));
        if(lb_inc==ub_inc && ABS(lb_inc)==1) {
          /* v_i - v_incr == v_ub, regardless of the sign */
          c1 = vect_substract(v_i, v_incr);
          c1 = vect_cl(c1, (Value) -1, v_ub);
          transformer_equality_add(post, c1);
        }
        else {
          if(lb_inc>=1) {
            /* v_i - v_incr <= v_ub < v_i
             * or:
             * v_i - v_incr - v_ub <= 0, v_ub - v_i + 1 <= 0
             */
            c1 = vect_substract(v_i, v_incr);
            c2 = vect_substract(v_ub, v_i);
 
            c1 = vect_cl(c1, (Value) -1, v_ub);
            vect_add_elem(&c2, (Variable) TCST, (Value) 1);
          }
          else if(ub_inc<=-1) {
            /* v_i - v_incr >= v_ub > v_i
             *
             * or:
             * - v_i + v_incr + v_ub <= 0, - v_ub + v_i + 1 <= 0
             */
            c1 = vect_substract(v_incr, v_i);
            c2 = vect_substract(v_i, v_ub);
 
            c1 = vect_cl(c1, (Value) 1, v_ub);
            vect_add_elem(&c2, (Variable) TCST, (Value) 1);
          }
          else {
            /* should never happen! */
            pips_assert("add_loop_index_exit_value", false);
          }
          transformer_inequality_add(post, c1);
          transformer_inequality_add(post, c2);
        }
 
        ifdebug(8) {
          pips_debug(8, "post with exit conditions:\n");
          (void) print_transformer(post);
        }
      }
      else {
        pips_debug(8,
              "post is unchanged because the increment or the upper bound"
              " reference unanalyzed variables\n");
      }
    }
    else {
      pips_debug(8,
            "post is unchanged because the increment sign is unknown\n");
    }
  }
  else {
    pips_debug(8,
          "post is unchanged because the upper bound is not affine\n");
  }
 
  ifdebug(8) {
    pips_debug(8, "end: post:\n");
    (void) print_transformer(post);
  }
 
  return post;
}

References ABS, affine_increment_to_transformer(), args_to_transformer(), CONS, ENTITY, entity_has_values_p(), entity_local_name(), entity_to_new_value(), expression_and_precondition_to_integer_interval(), ifdebug, load_statement_transformer(), loop_body, loop_index, loop_range, NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_assert, pips_debug, print_transformer, range_increment, range_upper, TCST, transformer_affect_linear_p(), transformer_apply(), transformer_dup(), transformer_equality_add(), transformer_free(), transformer_inequality_add(), transformer_undefined, value_mappings_compatible_vector_p(), value_to_variable(), vect_add_elem(), vect_cl(), vect_new(), vect_substract(), and VECTEUR_UNDEFINED.

Referenced by complete_loop_transformer(), complete_loop_transformer_list(), loop_to_postcondition(), and loop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

add_loop_skip_condition()

transformer add_loop_skip_condition	(	transformer	tf,
		loop	l,
		transformer	pre
	)

tf and pre are a unique data structure when preconditions are computed

It is assumed that loop l is not entered

EXPRESSION_TO_TRANSFORMER() should be used

is the loop increment numerically known? Is its sign known?

incr == 0 is used below as a give-up condition

find the real upper and lower bounds

exchange bounds

ub < lb, i.e. ub + lb + 1 <= 0

Parameters

tf	f
pre	re

Definition at line 495 of file loop.c.

{
  /* It is assumed that loop l is not entered */
  range r = loop_range(l);
  expression e_lb = range_lower(r);
  expression e_ub = range_upper(r);
  expression e_incr = range_increment(r);
  normalized n_lb = NORMALIZE_EXPRESSION(e_lb);
  normalized n_ub = NORMALIZE_EXPRESSION(e_ub);
  int incr = 0;
  int incr_lb = 0;
  int incr_ub = 0;
 
  /* EXPRESSION_TO_TRANSFORMER() should be used */
 
  pips_debug(8,"begin with transformer tf=%p\n", tf);
  ifdebug(8) {
    (void) print_transformer(tf);
    pips_debug(8,"and precondition pre=%p\n", pre);
    (void) print_transformer(pre);
  }
 
  /* is the loop increment numerically known? Is its sign known? */
  expression_and_precondition_to_integer_interval(e_incr, pre, &incr_lb, &incr_ub);
 
  if(incr_lb==incr_ub) {
    if(incr_lb==0) {
      user_error("add_loop_skip_condition", "Illegal null loop increment\n");
    }
    else
      incr = incr_lb;
  }
  else if(incr_lb>=1) {
    incr = 1;
  }
  else if(incr_ub<=-1) {
    incr = -1;
  }
  else
    incr = 0;
 
  /* incr == 0 is used below as a give-up condition */
 
  /* find the real upper and lower bounds */
  if(incr<0) {
    /* exchange bounds */
    n_lb = NORMALIZE_EXPRESSION(e_ub);
    n_ub = NORMALIZE_EXPRESSION(e_lb);
  }
 
  if(incr!=0 && normalized_linear_p(n_lb) && normalized_linear_p(n_ub)) {
    /* ub < lb, i.e. ub + lb + 1 <= 0 */
    Pvecteur v_ub = (Pvecteur) normalized_linear(n_ub);
    Pvecteur v_lb = (Pvecteur) normalized_linear(n_lb);
 
    if(value_mappings_compatible_vector_p(v_lb)
       && value_mappings_compatible_vector_p(v_ub)) {
      Pvecteur v = vect_substract(v_ub, v_lb);
 
      vect_add_elem(&v, TCST, (Value) 1);
      tf = transformer_inequality_add(tf, v);
 
      ifdebug(8) {
        debug(8,"add_loop_skip_condition","Skip condition:\n");
        vect_fprint(stderr, v, (char * (*)(Variable)) external_value_name);
      }
    }
    else {
      pips_debug(8,"Non-analyzed variable in loop bound(s)\n");
    }
  }
  else {
    pips_debug(8,"increment sign unknown or non-affine bound\n");
  }
 
  ifdebug(8) {
    pips_debug(8,"end with new tf=%p\n", tf);
    (void) print_transformer(tf);
  }
 
  return tf;
}

References debug(), expression_and_precondition_to_integer_interval(), external_value_name(), ifdebug, loop_range, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, print_transformer, range_increment, range_lower, range_upper, TCST, transformer_inequality_add(), user_error, value_mappings_compatible_vector_p(), vect_add_elem(), vect_fprint(), and vect_substract().

Referenced by complete_loop_transformer(), complete_loop_transformer_list(), loop_to_postcondition(), and loop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

add_module_call_site_precondition()

void add_module_call_site_precondition	(	entity	m,
		transformer	p
	)

module precondition

cons * ef = code_effects(value_code(entity_initial(m)));

p might not be printable; it may (should!) contain formal parameters of module m

keep only the interprocedural part of p that can be easily used by m; this is non optimal because symbolic constants will be lost; this is due to value mappings; new and old values should be added to the mapping using the module precondition

convert global variables in the summary precondition in the local frame as defined by value mappings (FI, 1 February 1994)

p is returned in the callee's frame; there is no need for a translation; the caller's frame should always contain the callee's frame by definition of effects;unfortunately, I do not remember why I added this translation; it was linked to a problem encountered with transformer and "invisible" variables, i.e. global variables which are indirectly changed by a procedure which does not see them; such variables receive an arbitrary existing global name; they may receive different names in different context, because there is no canonical name; each time, summary_precondition and summary_transformer are used, they must be converted in a unique frame, which can only be the frame of the current module.

FI, 9 February 1994

the former precondition represents the entire space : the new precondition must also represent the entire space BC, november 1994.

the former precondition is undefined. The new precondition is defined by the current call site precondition BC, november 1994.

Definition at line 123 of file interprocedural.c.

{
  /* module precondition */
  transformer mp;
  transformer new_mp;
  /* cons * ef = code_effects(value_code(entity_initial(m))); */
  list ef = load_summary_effects(m);
 
  pips_assert("add_module_call_site_precondition",entity_module_p(m));
  pips_assert("add_module_call_site_precondition",
              p != transformer_undefined);
 
  ifdebug(8) {
    pips_debug(8,"begin\n");
    pips_debug(8,"for module %s\n",
               module_local_name(m));
    pips_debug(8,"call site precondition %p:\n", p);
    /* p might not be printable; it may (should!) contain formal parameters
       of module m */
    dump_transformer(p);
  }
 
  /* keep only the interprocedural part of p that can be easily used
     by m; this is non optimal because symbolic constants will be
     lost; this is due to value mappings; new and old values should be
     added to the mapping using the module precondition*/
  p = precondition_intra_to_inter(m, p, ef);
 
  pips_debug(8, "filtered call site precondition:\n");
  ifdebug(8) dump_transformer(p);
 
  mp = get_module_precondition(m);
 
  ifdebug(8) {
    if (!transformer_undefined_p(mp)) {
      pips_debug(8, "old module precondition:\n");
      dump_transformer(mp);
    }
    else
      pips_debug(8, "old module precondition undefined\n");
  }
 
  translate_global_values(get_current_module_entity(), p);
 
  pips_debug(8, "new module precondition in current frame:\n");
  ifdebug(8) dump_transformer(p);
 
  if (!transformer_undefined_p(mp)) {
 
    /* convert global variables in the summary precondition in the
     * local frame as defined by value mappings (FI, 1 February
     * 1994) */
 
    /* p is returned in the callee's frame; there is no need for a
     * translation; the caller's frame should always contain the
     * callee's frame by definition of effects;unfortunately, I do not
     * remember *why* I added this translation; it was linked to a
     * problem encountered with transformer and "invisible" variables,
     * i.e. global variables which are indirectly changed by a
     * procedure which does not see them; such variables receive an
     * arbitrary existing global name; they may receive different
     * names in different context, because there is no canonical name;
     * each time, summary_precondition and summary_transformer are
     * used, they must be converted in a unique frame, which can only
     * be the frame of the current module.
     *
     * FI, 9 February 1994
     */
    translate_global_values(get_current_module_entity(), mp);
 
    pips_debug(8, "old module precondition in current frame:\n");
    ifdebug(8) dump_transformer(mp);
 
    if(transformer_identity_p(mp)) {
      /* the former precondition represents the entire space :
       * the new precondition must also represent the entire space
       * BC, november 1994.
       */
      transformer_free(p);
      new_mp = mp;
    }
    else
      new_mp = transformer_convex_hull(mp, p);
 
  }
  else {
    /* the former precondition is undefined. The new precondition
     * is defined by the current call site precondition
     * BC, november 1994.
     */
    new_mp = p;
  }
 
  pips_debug(8, "new module precondition in current frame:\n");
  ifdebug(8) dump_transformer(new_mp);
 
  DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_PRECONDITION,
                         strdup(module_local_name(m)),
                         (char*) new_mp );
 
  pips_debug(8, "end\n");
}

References DB_PUT_MEMORY_RESOURCE, dump_transformer, entity_module_p(), get_current_module_entity(), get_module_precondition(), ifdebug, load_summary_effects(), module_local_name(), pips_assert, pips_debug, precondition_intra_to_inter(), strdup(), transformer_convex_hull(), transformer_free(), transformer_identity_p(), transformer_undefined, transformer_undefined_p, and translate_global_values().

Referenced by call_to_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

add_or_kill_equivalenced_variables()

void add_or_kill_equivalenced_variables	(	entity	e,
		bool	readonly
	)

Look for variables equivalenced with e.

e already has values associated although it may not be a canonical representative of its equivalence class...

Forget dynamic aliasing between formal parameters.

Handle intraprocedural aliasing only.

Do not handle interprocedural aliasing: this does not seem to be the right place because too many synonyms, not visible from the current procedure, are introduced (global_shared = area_layout(type_area(t));

potential canonical representative for all variables equivalenced with e

Is e intraprocedurally equivalenced/aliased with an array or a non-analyzable variable which would make e and all its aliased variables unanalyzable?

Since the equivalence is reflexive, no need to process e==eq again.

Since the equivalence is symetrical, eq may have been processed already.

this approximate test by Pierre Jouvelot should be replaced by an exact test but it does not really matter; an exact test could only be useful in presence of arrays; and in presence of arrays we do nothing here

if it's not, go ahead: it exists at least one eq such that e and eq are different, are scalars and have the same analyzable type. All eq conflicting with e meets these conditions.

Declare values for the canonical representative re

Give values to re which should have none and remove values of e. Assume that e and re are local variables.

If it is intra-procedurally equivalenced, set the synonyms as read-only variables

if eq is an integer scalar variable it does not only have a destructive effect

Variable e is equivalenced with an array or a non-integer variable and cannot be analyzed; it must be removed from the hash tables.

semantics analysis should be performed on this kind of variable but it has probably been eliminated earlier; no equivalence possible anyway!

to be dealt with later if we assume non-standard dynamic aliasing between formal parameters

Parameters

readonly

eadonly

Definition at line 204 of file mappings.c.

{
  storage s = entity_storage(e);
  entity re = e; /* potential canonical representative for all variables equivalenced with e */
 
  pips_debug(8, "Begin for %s %s\n", entity_name(e),
             readonly? "readonly" : "read/write");
 
  pips_assert("e has values", entity_has_values_p(e));
 
  if(storage_ram_p(s)) {
    list local_shared = ram_shared(storage_ram(s));
    bool array_equivalenced = false;
    entity sec = ram_section(storage_ram(s));
    type t = entity_type(sec);
    list ce = list_undefined;
 
    pips_assert("t is an area", type_area_p(t));
 
    /* Is e intraprocedurally equivalenced/aliased with an array or a
     * non-analyzable variable which would make e and all its aliased
     * variables unanalyzable?  */
    for(ce=local_shared; !ENDP(ce); POP(ce)) {
      entity eq = ENTITY(CAR(ce));
 
      /* Since the equivalence is reflexive, no need to process e==eq again. */
      if(e==eq) continue;
      /* Since the equivalence is symetrical, eq may have been processed
         already. */
      if(entity_has_values_p(eq)) continue;
 
      /* this approximate test by Pierre Jouvelot should be
         replaced by an exact test but it does not really matter;
         an exact test could only be useful in presence of arrays;
         and in presence of arrays we do nothing here */
      if(entities_may_conflict_p(e, eq) && !analyzable_scalar_entity_p(eq)) {
        pips_user_warning("Values for variable %s are not analyzed because "
                          "%s is aliased with scalar variable %s with non "
                          "analyzed type %s or with array variable\n",
                          entity_name(e), entity_name(e), entity_name(eq),
                          type_to_string(entity_type(eq)));
        array_equivalenced = true;
        break;
      }
 
      if(entities_may_conflict_p(e, eq) && analyzable_scalar_entity_p(eq)) {
        if(!type_equal_p(entity_type(e),entity_type(eq))) {
          pips_user_warning("Values for variable %s of type %s are not analyzed because "
                            "%s is aliased with scalar variable %s with different "
                            "type %s\n",
                            entity_name(e), type_to_string(entity_type(e)),
                            entity_name(e), entity_name(eq),
                            type_to_string(entity_type(eq)));
          array_equivalenced = true;
          break;
        }
      }
      if(entities_may_conflict_p(e, eq) && strcmp(entity_name(eq), entity_name(re))<0) {
        re = eq;
      }
    }
 
    /* if it's not, go ahead: it exists at least one eq such that e and eq
       are different, are scalars and have the same analyzable type. All
       eq conflicting with e meets these conditions. */
    if(!array_equivalenced) {
 
      /* Declare values for the canonical representative re */
      if(e!=re) {
        pips_debug(8, "Canonical representative is %s\n", entity_local_name(re));
        /* Give values to re which should have none and remove values of
           e. Assume that e and re are local variables. */
        pips_assert("re has no values", !entity_has_values_p(re));
        remove_entity_values(e, readonly);
        add_new_value(re);
        if(!readonly) {
          add_old_value(re);
          add_intermediate_value(re);
        }
      }
 
      /* If it is intra-procedurally equivalenced, set the synonyms as
       * read-only variables
       */
      for(ce=local_shared; !ENDP(ce); POP(ce)) {
        entity eq = ENTITY(CAR(ce));
 
        if(re==eq) continue;
        if(entities_may_conflict_p(re, eq)) {
          /* if eq is an integer scalar variable it does not
             only have a destructive effect */
          add_equivalenced_values(re, eq, readonly);
        }
      }
    }
    else {
      /* Variable e is equivalenced with an array or a non-integer
       * variable and cannot be analyzed; it must be removed from
       * the hash tables.
       */
      remove_entity_values(e, readonly);
    }
  }
  else if(storage_return_p(s)) {
    /* semantics analysis should be performed on this kind of variable
       but it has probably been eliminated earlier; no equivalence
       possible anyway! */
    // FI: the warning message is not useful. See formal parameters
    // pips_user_warning("storage return\n");
    ;
  }
  else if(storage_formal_p(s))
    /* to be dealt with later if we assume non-standard dynamic
       aliasing between formal parameters */
    ;
  else
    pips_internal_error("unproper storage = %d (%s), for entity %s", storage_tag(s), storage_to_string(s), entity_name(e));
 
  pips_debug(8, "End for %s\n", entity_name(e));
}

References add_equivalenced_values(), add_intermediate_value(), add_new_value(), add_old_value(), analyzable_scalar_entity_p(), CAR, ENDP, entities_may_conflict_p(), ENTITY, entity_has_values_p(), entity_local_name(), entity_name, entity_storage, entity_type, eq, list_undefined, pips_assert, pips_debug, pips_internal_error, pips_user_warning, POP, ram_section, ram_shared, remove_entity_values(), storage_formal_p, storage_ram, storage_ram_p, storage_return_p, storage_tag, storage_to_string(), type_area_p, type_equal_p(), and type_to_string().

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

Here is the call graph for this function:

Here is the caller graph for this function:

affine_increment_to_transformer()

transformer affine_increment_to_transformer	(	entity	e,
		Pvecteur	a
	)

Definition at line 1269 of file expression.c.

{
    transformer tf = transformer_undefined;
 
    tf = affine_to_transformer(e, a, false);
 
    return tf;
}

References affine_to_transformer(), and transformer_undefined.

Referenced by add_loop_index_exit_value().

Here is the call graph for this function:

Here is the caller graph for this function:

affine_to_transformer()

transformer affine_to_transformer	(	entity	e,
		Pvecteur	a,
		bool	assignment
	)

must be duplicated right now because it will be renamed and checked at the same time by value_mappings_compatible_vector_p()

Parameters

assignment

ssignment

Definition at line 1212 of file expression.c.

{
  transformer tf = transformer_undefined;
  Pvecteur ve = vect_new((Variable) e, VALUE_ONE);
  entity e_new = entity_to_new_value(e);
  entity e_old = entity_to_old_value(e);
  cons * tf_args = CONS(ENTITY, e_new, NIL);
  /* must be duplicated right now  because it will be
     renamed and checked at the same time by
     value_mappings_compatible_vector_p() */
  Pvecteur vexpr = vect_dup(a);
  Pcontrainte c;
  Pvecteur eq = VECTEUR_NUL;
 
  pips_debug(8, "begin\n");
 
  ifdebug(9) {
    pips_debug(9, "\nLinearized expression:\n");
    vect_dump(vexpr);
  }
 
  if(!assignment) {
    vect_add_elem(&vexpr, (Variable) e, (Value) 1);
 
    ifdebug(8) {
      pips_debug(8, "\nLinearized expression for incrementation:\n");
      vect_dump(vexpr);
    }
  }
 
  if(value_mappings_compatible_vector_p(ve) &&
     value_mappings_compatible_vector_p(vexpr)) {
    ve = vect_variable_rename(ve,
                              (Variable) e,
                              (Variable) e_new);
    (void) vect_variable_rename(vexpr,
                                (Variable) e_new,
                                (Variable) e_old);
    eq = vect_substract(ve, vexpr);
    vect_rm(ve);
    vect_rm(vexpr);
    c = contrainte_make(eq);
    tf = make_transformer(tf_args,
                          make_predicate(sc_make(c, CONTRAINTE_UNDEFINED)));
  }
  else {
    vect_rm(eq);
    vect_rm(ve);
    vect_rm(vexpr);
    tf = transformer_undefined;
  }
 
  pips_debug(8, "end\n");
 
  return tf;
}

References CONS, contrainte_make(), CONTRAINTE_UNDEFINED, ENTITY, entity_to_new_value(), entity_to_old_value(), eq, ifdebug, make_predicate(), make_transformer(), NIL, pips_debug, sc_make(), transformer_undefined, value_mappings_compatible_vector_p(), VALUE_ONE, vect_add_elem(), vect_dump(), vect_dup(), vect_new(), vect_rm(), vect_substract(), vect_variable_rename(), and VECTEUR_NUL.

Referenced by affine_increment_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

all_data_to_precondition()

transformer all_data_to_precondition

(

entity

m

)

any variable is included.

FI: it would be nice, if only for debugging, to pass a more restricted list...

This assumes the all variables declared in a statement is also declared at the module level.

Definition at line 536 of file ri_to_preconditions.c.

{
  /* FI: it would be nice, if only for debugging, to pass a more
     restricted list...
 
     This assumes the all variables declared in a statement is also
     declared at the module level. */
  //  transformer pre =
  // data_to_prec_for_variables(m, code_declarations(entity_code(m)));
  list dl = module_to_all_declarations(m);
  transformer pre = data_to_prec_for_variables(m, dl);
 
  gen_free_list(dl);
 
  return pre;
}

References data_to_prec_for_variables(), gen_free_list(), and module_to_all_declarations().

Referenced by initial_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

any_assign_operation_to_transformer()

transformer any_assign_operation_to_transformer	(	entity	,
		list	,
		transformer	,
		bool
	)

any_assign_to_transformer()

transformer any_assign_to_transformer	(	list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis in Fortran. In C, the condition can be relaxed to take into account side effects in sub-expressions.

f ou NIL ??

if some condition was not met and transformer derivation failed

Parameters

args	rgs
ef	f
pre	re

Definition at line 3177 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  expression rhs = EXPRESSION(CAR(CDR(args)));
  // Take care of side effects in lhs
  // FI: do you want to take care of the write effect as well ?
 
  // The false read implied here does not matter because only write
  // effects are taken into account
  transformer lhst = safe_expression_to_transformer(lhs, pre);
  // FI: the rhs should be evaluated first according to the C standard
  transformer npre = transformer_apply(lhst, pre);
  // How about the side effects in rhs? It might be done below?
  // transformer trhs = safe_expression_to_transformer(rhs, npre);
  // transformer nnpre = transformer_apply(lhsr, npre);
  // Side-effects transformer setf
  // transformer seft = transformer_combine(rhst, lhst);
  // free_transformer(lhst); // rhst is propagated as seft
  // free_transformer(npre);
 
  pips_assert("2 args to assign", CDR(CDR(args))==NIL);
 
  syntax slhs = expression_syntax(lhs);
  /* The lhs must be a scalar reference to perform an interesting
     analysis in Fortran. In C, the condition can be relaxed to take
     into account side effects in sub-expressions. */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    // FI: it is assumed that lhst is identity in case lhs is a reference
    // that leads to a defined transformer
    // Range of the new precondition: nprer
    // transformer nprer = transformer_range(npre);
    tf = assign_rhs_to_reflhs_to_transformer(rlhs, rhs, pre, ef);
    //free_transformer(nprer);
  }
  // case constant path in lhs (dereferencing, struct, array)
  else if (syntax_call_p(slhs) || syntax_subscript_p(slhs)) {
    if (!pt_to_list_undefined_p() || constant_path_analyzed_p()) {
      list l = semantics_expression_to_points_to_sources(lhs);
      int n = (int) gen_length(l);
      // FI: I wonder what happens with side effects in the rhs and
      // with pointer dereferencing in the rhs
      FOREACH(CELL, cp, l) {
        reference rlhs = cell_any_reference(cp);
 
        // example of case which is normally filter *p when p formal
        // parameter, or dynamic allocation of p
        if (semantics_usable_points_to_reference_p(rlhs, expression_undefined, n)
            && analyzed_reference_p(rlhs)) {
          ifdebug(7) {
            pips_debug(7, "source reference : %s\n", reference_to_string(rlhs));
          }
 
          transformer rt = assign_rhs_to_reflhs_to_transformer(rlhs, rhs, npre, ef/*ef ou NIL ?? */);
          // NL : It must have be a better way to do that but I don't know how
          if (transformer_undefined_p(tf))
            tf = rt;
          else {
            if(transformer_undefined_p(rt)) {
              // FI: absorbing element
 
              // FI: this is not going to work in general, because
              // undefined is used to perform or not the convex hull
              tf = transformer_undefined;
            }
            else {
              tf = transformer_convex_hull(tf, rt);
              free_transformer(rt);
            }
          }
        }
        else if(anywhere_reference_p(rlhs)) {
          /*
          list nefl = CONS(EFFECT, anywhere_effect(make_action_write_memory()), NIL);
          tf = effects_to_transformer(nefl);
          gen_full_free_list(nefl);
          */
          tf = transformer_undefined;
        }
        else if(reference_typed_anywhere_locations_p(rlhs)) {
          /*
          type t = points_to_reference_to_concrete_type(rlhs);
          cell c = make_anywhere_points_to_cell(t);
          effect nef = make_effect(c, make_action_write_memory(),
                                   make_approximation_may(), make_descriptor_none());
          list nefl = CONS(EFFECT, nef, NIL);
          tf = effects_to_transformer(nefl);
          gen_full_free_list(nefl);
          */
          tf = transformer_undefined;
        }
      }
    }
  }
  else {
    // if nothing else retrieve lhs and rhs transformers
    transformer rhst = safe_expression_to_transformer(rhs, npre);
    // transformer nnpre = transformer_apply(lhsr, npre);
    // Side-effects transformer setf
    tf = transformer_combine(rhst, lhst);
    // free_transformer(lhst); // rhst is propagated as seft, done below
    // free_transformer(npre); // done below
    tf = apply_additional_effects_to_transformer(tf, ef, true, rhs);
  }
 
  free_transformer(npre);
 
  /* if some condition was not met and transformer derivation failed */
  // This should be dead code now
  if(tf==transformer_undefined) {
    transformer tf1 = lhst;
    transformer tf2 = safe_expression_to_transformer(rhs, pre);
    tf = transformer_combine (tf1, tf2);
    free_transformer(tf2); // tf1 is exported in tf
    // FI: previous solution, only based on effects, was much safer
    // and simpler ! But kills tf1 and tf2 by definition...  tf =
    // apply_effects_to_transformer(tf, ef, true, rhs); FI: the all
    // assignment should be passed as expression to provide
    // information about the effects origin: make_binary_call(=, lhs,
    // rhs); lhs is more likely than rhs to explain the effects
    tf = apply_additional_effects_to_transformer(tf, ef, true, lhs);
  }
  else {
  free_transformer(lhst);
  }
 
  pips_debug(6,"return tf=%p\n", tf);
  ifdebug(6) (void) print_transformer(tf);
  pips_debug(6,"end\n");
  return tf;
}

References analyzed_reference_p(), anywhere_reference_p(), apply_additional_effects_to_transformer(), assign_rhs_to_reflhs_to_transformer(), CAR, CDR, CELL, cell_any_reference(), constant_path_analyzed_p(), cp, EXPRESSION, expression_syntax, expression_undefined, FOREACH, free_transformer(), gen_length(), ifdebug, int, NIL, pips_assert, pips_debug, print_transformer, pt_to_list_undefined_p(), reference_to_string(), reference_typed_anywhere_locations_p(), safe_expression_to_transformer(), semantics_expression_to_points_to_sources(), semantics_usable_points_to_reference_p(), syntax_call_p, syntax_reference, syntax_reference_p, syntax_subscript_p, transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_undefined, and transformer_undefined_p.

Referenced by intrinsic_to_transformer(), and intrinsic_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

any_assign_to_transformer_list()

list any_assign_to_transformer_list	(	list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis

if some condition was not met and transformer derivation failed

Parameters

args	rgs
ef	f
pre	re

Definition at line 777 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  expression rhs = EXPRESSION(CAR(CDR(args)));
  syntax slhs = expression_syntax(lhs);
 
  pips_internal_error("Not implemented yet.");
 
  pips_assert("2 args to assign", CDR(CDR(args))==NIL);
 
  /* The lhs must be a scalar reference to perform an interesting analysis */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    if(ENDP(reference_indices(rlhs))) {
      entity v = reference_variable(rlhs);
      tf = any_scalar_assign_to_transformer(v, rhs, ef, pre);
    }
  }
 
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tl=%p\n", tl);
  ifdebug(6) (void) print_transformers(tl);
  pips_debug(8,"end\n");
  return tl;
}

References any_scalar_assign_to_transformer(), CAR, CDR, effects_to_transformer(), ENDP, EXPRESSION, expression_syntax, ifdebug, NIL, pips_assert, pips_debug, pips_internal_error, print_transformers(), reference_indices, reference_variable, syntax_reference, syntax_reference_p, and transformer_undefined.

Here is the call graph for this function:

any_basic_update_operation_to_transformer()

transformer any_basic_update_operation_to_transformer	(	entity	tmp,
		entity	v,
		entity	op
	)

See also any_basic_update_to_transformer(), which should be based on this function.

FI: why

Parameters

tmp	mp
op	p

Definition at line 317 of file expression.c.

{
  transformer tf = transformer_undefined;
  expression ve = entity_to_expression(v);
  expression inc = expression_undefined;
  expression n_rhs = expression_undefined;
  entity plus = entity_intrinsic(PLUS_C_OPERATOR_NAME);
  list args = list_undefined;
 
  if(ENTITY_POST_INCREMENT_P(op) || ENTITY_PRE_INCREMENT_P(op))
    inc = int_to_expression(1);
  else
    inc = int_to_expression(-1);
 
  n_rhs = MakeBinaryCall(plus, inc, entity_to_expression(v));
 
  /* FI: why*/
  args = CONS(EXPRESSION, ve, CONS(EXPRESSION, n_rhs, NIL));
  tf = any_assign_operation_to_transformer(v,
                                           args,
                                           transformer_undefined,
                                           false); 
  if(ENTITY_POST_INCREMENT_P(op) || ENTITY_POST_DECREMENT_P(op))
    tf = transformer_add_equality(tf, entity_to_old_value(v), tmp);
  else
    tf = transformer_add_equality(tf, v, tmp);
  gen_full_free_list(args);
 
  pips_debug(6,"return tf=%p\n", tf);
  ifdebug(6) (void) dump_transformer(tf);
  pips_debug(8,"end\n");
  return tf;
}

References any_assign_operation_to_transformer(), CONS, dump_transformer, entity_intrinsic(), ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_INCREMENT_P, entity_to_expression(), entity_to_old_value(), EXPRESSION, expression_undefined, gen_full_free_list(), ifdebug, int_to_expression(), list_undefined, MakeBinaryCall(), NIL, pips_debug, PLUS_C_OPERATOR_NAME, transformer_add_equality(), and transformer_undefined.

Referenced by generic_unary_operation_to_transformer(), and pointer_unary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_basic_update_to_transformer()

transformer any_basic_update_to_transformer	(	entity	op,
		list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis No more, lhs can also be dereferencing

f ou NIL ??

if some condition was not met and transformer derivation failed

Parameters

op	p
args	rgs
ef	f
pre	re

Definition at line 3525 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  syntax slhs = expression_syntax(lhs);
 
  pips_assert("1 arg for basic_update", CDR(args)==NIL);
 
  ifdebug(8) (void) print_expression(lhs);
 
  /* The lhs must be a scalar reference to perform an interesting analysis
   * No more, lhs can also be dereferencing
   */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    tf = basic_update_reflhs_with_rhs_to_transformer(op, rlhs, lhs, pre, ef);
  }
  // case constant path in lhs (dereferencing, struct, array)
  else if (syntax_call_p(slhs)) {
    if (!pt_to_list_undefined_p()) {
      list l = semantics_expression_to_points_to_sources(lhs);
      FOREACH(CELL, cp, l) {
        reference rlhs = cell_preference_p(cp)? preference_reference(cell_preference(cp)) : cell_reference(cp);
 
        // example of case which is normally filter *p when p formal parameter, or dynamic allocation of p
        if (analyzed_reference_p(rlhs)) {
          entity source_lhs = reference_variable(rlhs);
 
          ifdebug(7) {
            pips_debug(7, "source reference : %s\n", reference_to_string(rlhs));
          }
 
          if (entity_null_locations_p(source_lhs)) {
            if (gen_length(l) == 1)
              pips_user_error("The pointer \"%s\" points to NULL\n", expression_to_string(lhs));
            else
              semantics_user_warning("The pointer \"%s\" can point to NULL\n", expression_to_string(lhs));
          } else if (entity_typed_nowhere_locations_p(source_lhs)) {
            if (gen_length(l) == 1)
              pips_user_error("The pointer %s points to undefined/indeterminate (%s)\n", expression_to_string(lhs), reference_to_string(rlhs));
            else
              semantics_user_warning("The pointer %s can points to undefined/indeterminate (%s)\n", expression_to_string(lhs), reference_to_string(rlhs));
          }
          else {
            // can be improve with a specific function
            // we will compute 2 times the path to find the cp
            // see assign_rhs_to_cp_to_transformer or update_cp_with_rhs_to_transformer to make basic_update_cp_with_rhs_to_transformer
            transformer rt = basic_update_reflhs_with_rhs_to_transformer(op, rlhs, lhs, pre, ef/*ef ou NIL ?? */);
            // NL : It must have be a better way to do that but I don't know how
            if (transformer_undefined_p(tf))
              tf = rt;
            else {
              tf = transformer_convex_hull(tf, rt);
              free_transformer(rt);
            }
          }
        }
      }
    }
  }
 
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tf=%p\n", tf);
  ifdebug(6) (void) print_transformer(tf);
  pips_debug(8,"end\n");
  return tf;
}

References analyzed_reference_p(), basic_update_reflhs_with_rhs_to_transformer(), CAR, CDR, CELL, cell_preference, cell_preference_p, cell_reference, cp, effects_to_transformer(), entity_null_locations_p(), entity_typed_nowhere_locations_p(), EXPRESSION, expression_syntax, expression_to_string(), FOREACH, free_transformer(), gen_length(), ifdebug, NIL, pips_assert, pips_debug, pips_user_error, preference_reference, print_expression(), print_transformer, pt_to_list_undefined_p(), reference_to_string(), reference_variable, semantics_expression_to_points_to_sources(), semantics_user_warning, syntax_call_p, syntax_reference, syntax_reference_p, transformer_convex_hull(), transformer_undefined, and transformer_undefined_p.

Referenced by intrinsic_to_transformer(), and intrinsic_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

any_basic_update_to_transformer_list()

list any_basic_update_to_transformer_list	(	entity	op,
		list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis

if some condition was not met and transformer derivation failed

Parameters

op	p
args	rgs
ef	f
pre	re

Definition at line 849 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  syntax slhs = expression_syntax(lhs);
 
  pips_internal_error("Not implemented yet.");
 
  pips_assert("1 arg for basic_update", CDR(args)==NIL);
 
  /* The lhs must be a scalar reference to perform an interesting analysis */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    if(ENDP(reference_indices(rlhs))) {
      entity v = reference_variable(rlhs);
      expression ve = expression_undefined;
      expression n_rhs = expression_undefined;
      entity plus = entity_intrinsic(PLUS_C_OPERATOR_NAME);
 
      if(ENTITY_POST_INCREMENT_P(op) || ENTITY_PRE_INCREMENT_P(op))
        ve = int_to_expression(1);
      else
        ve = int_to_expression(-1);
 
      n_rhs = MakeBinaryCall(plus, ve, copy_expression(lhs));
 
      tf = any_scalar_assign_to_transformer(v, n_rhs, ef, pre);
      free_expression(n_rhs);
    }
  }
 
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tl=%p\n", tl);
  ifdebug(6) (void) print_transformers(tl);
  pips_debug(8,"end\n");
  return tl;
}

References any_scalar_assign_to_transformer(), CAR, CDR, copy_expression(), effects_to_transformer(), ENDP, entity_intrinsic(), ENTITY_POST_INCREMENT_P, ENTITY_PRE_INCREMENT_P, EXPRESSION, expression_syntax, expression_undefined, free_expression(), ifdebug, int_to_expression(), MakeBinaryCall(), NIL, pips_assert, pips_debug, pips_internal_error, PLUS_C_OPERATOR_NAME, print_transformers(), reference_indices, reference_variable, syntax_reference, syntax_reference_p, and transformer_undefined.

Here is the call graph for this function:

any_conditional_to_transformer()

transformer any_conditional_to_transformer	(	entity	v,
		list	args,
		transformer	pre
	)

Take care of the returned value.

About a cut-and-paste of previous function, conditional_to_transformer().

Parameters

args	rgs
pre	re

Definition at line 5524 of file expression.c.

{
  expression cond = EXPRESSION(CAR(args));
  expression te = EXPRESSION(CAR(CDR(args)));
  expression fe = EXPRESSION(CAR(CDR(CDR(args))));
  transformer tf = transformer_undefined;
  transformer ttf = condition_to_transformer(cond, pre, true);
  transformer t_pre = transformer_apply(ttf, pre);
  transformer t_pre_r = transformer_range(t_pre);
  transformer tet = safe_any_expression_to_transformer(v, te, t_pre_r, true);
  transformer ftf = condition_to_transformer(cond, pre, false);
  transformer f_pre = transformer_apply(ftf, pre);
  transformer f_pre_r = transformer_range(f_pre);
  transformer fet = safe_any_expression_to_transformer(v, fe, f_pre_r, true);
 
  ttf = transformer_combine(ttf, tet);
  ftf = transformer_combine(ftf, fet);
  tf = transformer_convex_hull(ttf, ftf);
 
  free_transformer(ttf);
  free_transformer(ftf);
  free_transformer(tet);
  free_transformer(fet);
  free_transformer(t_pre_r);
  free_transformer(f_pre_r);
  free_transformer(t_pre);
  free_transformer(f_pre);
 
  //if(transformer_undefined_p(tf))
  //  tf = effects_to_transformer(ef);
  return tf;
}

References CAR, CDR, condition_to_transformer(), EXPRESSION, free_transformer(), safe_any_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_range(), and transformer_undefined.

Referenced by integer_call_expression_to_transformer(), and pointer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_expression_side_effects_to_transformer()

transformer any_expression_side_effects_to_transformer	(	expression	,
		transformer	,
		bool
	)

any_expression_to_transformer()

transformer any_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre,
		bool	is_internal
	)

A set of functions to compute the transformer associated to an expression evaluated in a given context.

The choices are:

1. Do I need the value of the expression? It seems strange but in some cases, the expression value is discarded. See for instance the C for construct.

Keyword: "any" implies that the expression value is needed

1. In case of failure, do I need an approximate transformer based on memory effects or an undefined transformer because I want to try something else?

Keyword: "safe" implies that effects are used and that no undefined transformer is returned.

1. In case of interprocedural call, am I ready to fail? This might be useful for the libraries "control" and "effects", but is not implemented yet.

Suggested keyword: "light"

1. Conditional expressions require specific treatment because the bool analysis is not well linked to the integer analysis and because C uses implicit conditions: if(n) means if(n!=0).
2. Expression lists are a special case of expression. This function may return an undefined transformers if it fails to capture the semantics of expr in the polyhedral framework.

Should basic of expression take care of this?

Assume v is a value

If we are here, it should be an enum type...

Constants, at least, could be typed coerced

Redundant with explicit type coercion also available in PIPS

To be done later

PIPS does not represent negative constants: call to unary_minus

PIPS does not represent complex constants: call to CMPLX

Only constant string are processed

The overloading is supposed to have been lifted by basic_of_expression()

enum type are analyzed like int

This function is called from the region analysis, with extended expressions such as "*", the unbounded expression.

It might be interesting to go further in case the comma operator is used

No need to link the returned value as it must be cast to the proper type.

tf may be transformer_undefined when no information is derived

Parameters

expr	xpr
pre	re
is_internal	s_internal

Definition at line 4993 of file expression.c.

{
  transformer tf = transformer_undefined;
  basic be = basic_of_expression(expr);
  basic bv = variable_basic(type_variable(ultimate_type(entity_type(v))));
 
  if(basic_typedef_p(be)) {
    entity te = basic_typedef(be);
    type nte = ultimate_type(entity_type(te));
 
    pips_assert("nte is of type variable", type_variable_p(nte));
 
    /* Should basic of expression take care of this? */
    pips_debug(8, "Fix basic be\n");
 
    free_basic(be);
    be = copy_basic(variable_basic(type_variable(nte)));
  }
 
  ifdebug(8) {
    pips_debug(8, "begin for entity %s of type %s and %s expression ",
               entity_local_name(v),
               basic_to_string(bv), basic_to_string(be));
    print_expression(expr);
  }
 
  /* Assume v is a value */
  if( (basic_tag(bv)==basic_tag(be))
      || (basic_float_p(bv) && basic_int_p(be))
      || (basic_derived_p(bv) && basic_int_p(be))
      || (basic_derived_p(be) && basic_int_p(bv))
      || (basic_logical_p(bv) && basic_int_p(be))
      || (basic_logical_p(be) && basic_int_p(bv))
      || (basic_pointer_p(bv) && basic_int_p(be))) {
    switch(basic_tag(be)) {
    case is_basic_int:
      if(integer_analyzed_p()) {
        if(basic_int_p(bv)) {
          tf = integer_expression_to_transformer(v, expr, pre, is_internal);
        }
        else if(basic_derived_p(bv)) {
          /* If we are here, it should be an enum type... */
          tf = integer_expression_to_transformer(v, expr, pre, is_internal);
        }
          else if(basic_logical_p(bv)) {
            tf = logical_expression_to_transformer(v, expr, pre, is_internal);
          }
          else if(basic_pointer_p(bv)) {
            //tf = integer_expression_to_transformer(v, expr, pre, is_internal);
            // arithmetic for pointer
            if(pointer_analyzed_p())
              tf = pointer_expression_to_transformer(v, expr, pre, is_internal);
          }
        else {
          semantics_user_warning("Integer expression assigned to float value\n"
                                 "Apply PIPS type checker for better results\n");
          /* Constants, at least, could be typed coerced */
          /* Redundant with explicit type coercion also available in PIPS */
          /* To be done later */
        }
      }
      break;
    case is_basic_logical:
      if(basic_logical_p(bv) && boolean_analyzed_p())
        tf = logical_expression_to_transformer(v, expr, pre, is_internal);
      else if(basic_int_p(bv)) { // We should check that integers are analyzed...
        tf = integer_expression_to_transformer(v, expr, pre, is_internal);
      }
      break;
    case is_basic_float:
      /* PIPS does not represent negative constants: call to unary_minus */
      if(float_analyzed_p())
        tf = float_expression_to_transformer(v, expr, pre, is_internal);
      break;
    case is_basic_pointer:
      if(pointer_analyzed_p())
        tf = pointer_expression_to_transformer(v, expr, pre, is_internal);
      break;
    case is_basic_complex:
      /* PIPS does not represent complex constants: call to CMPLX */
      break;
    case is_basic_string:
      /* Only constant string are processed */
      if(string_analyzed_p())
        tf = string_expression_to_transformer(v, expr);
      break;
    case is_basic_overloaded: {
      /* The overloading is supposed to have been lifted by
         basic_of_expression() */
      if(expression_call_p(expr) && ENTITY_CONTINUE_P(call_function(expression_call(expr))))
        tf = transformer_identity();
      else
        pips_internal_error("illegal overloaded type for an expression");
      break;
    }
    case is_basic_derived: {
      entity de = basic_derived(be);
      type det = ultimate_type(entity_type(de));
      if(type_enum_p(det)) {
        /* enum type are analyzed like int */
        tf = integer_expression_to_transformer(v, expr, pre, is_internal);
      }
      else {
      pips_internal_error("entities of type \"derived\" that are not \"enum\" cannot be analyzed");
      }
      break;
    }
    case is_basic_typedef:
      pips_internal_error("entities of type \"typedef\" cannot be analyzed");
      break;
    default:
      pips_internal_error("unknown basic b=%d", basic_tag(be));
    }
  }
  else {
    if(!basic_overloaded_p(be)) {
    semantics_user_warning("Implicit type coercion between variable \"%s\" of type \"%s\" and "
                      "expression \"%s\" of type \"%s\" may reduce semantic analysis accuracy.\n"
                      "You might apply 'type_checker' to explicit all type coercions.\n",
                           entity_user_name(v),
                           basic_to_string(bv),
                           expression_to_string(expr),
                           basic_to_string(be));
    }
    else if(!unbounded_expression_p(expr)) {
      /* This function is called from the region analysis, with
       * extended expressions such as "*", the unbounded
       * expression.
       */
    semantics_user_warning(
                      "expression \"%s\" with overloaded type may reduce semantic analysis accuracy for variable \"%s\" of type \"%s\".\n"
                      "You might apply 'type_checker' to explicit all type coercions.\n",
                           expression_to_string(expr),
                           entity_user_name(v),
                      basic_to_string(bv));
    }
    /* It might be interesting to go further in case the comma operator is used */
    if(comma_expression_p(expr)) {
      call c = syntax_call(expression_syntax(expr));
      list expr_l = call_arguments(c);
 
      /* No need to link the returned value as it must be cast to the
         proper type. */
      tf = expressions_to_transformer(expr_l, pre);
    }
  }
 
  /* tf may be transformer_undefined when no information is derived */
  ifdebug(1) {
    if(!transformer_undefined_p(pre))
      pips_assert("No obvious aliasing between tf and pre", tf!=pre);
  }
  pips_debug(8, "end with tf=%p\n", tf);
 
  return tf;
}

References basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_of_expression(), basic_overloaded_p, basic_pointer_p, basic_tag, basic_to_string(), basic_typedef, basic_typedef_p, boolean_analyzed_p(), call_arguments, call_function, comma_expression_p(), copy_basic(), ENTITY_CONTINUE_P, entity_local_name(), entity_type, entity_user_name(), expression_call(), expression_call_p(), expression_syntax, expression_to_string(), expressions_to_transformer(), float_analyzed_p(), float_expression_to_transformer(), free_basic(), ifdebug, integer_analyzed_p(), integer_expression_to_transformer(), is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, logical_expression_to_transformer(), pips_assert, pips_debug, pips_internal_error, pointer_analyzed_p(), pointer_expression_to_transformer(), print_expression(), semantics_user_warning, string_analyzed_p(), string_expression_to_transformer(), syntax_call, transformer_identity(), transformer_undefined, transformer_undefined_p, type_enum_p, type_variable, type_variable_p, ultimate_type(), unbounded_expression_p(), and variable_basic.

Referenced by add_formal_to_actual_bindings(), 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_data_to_prec_for_variables(), c_return_to_transformer(), expression_to_transformer(), fortran_user_call_to_transformer(), generic_abs_to_transformer(), generic_minmax_to_transformer(), loop_bound_evaluation_to_transformer(), safe_any_expression_to_transformer(), and unary_minus_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_expressions_side_effects_to_transformer()

transformer any_expressions_side_effects_to_transformer	(	list	el,
		transformer	p,
		bool	is_internal
	)

same as any_expression_side_effects_to_transformer() but for a list of expressions

Parameters

el	l
is_internal	s_internal

Definition at line 4921 of file expression.c.

{
  transformer tf = transformer_undefined;
  FOREACH(EXPRESSION, e, el) {
    transformer etf =
      any_expression_side_effects_to_transformer(e, p, is_internal);
    if(transformer_undefined_p(tf))
      tf = etf;
    else {
      tf = transformer_combine(tf, etf);
      free_transformer(etf);
    }
  }
  return tf;
}

References any_expression_side_effects_to_transformer(), EXPRESSION, FOREACH, free_transformer(), transformer_combine(), transformer_undefined, and transformer_undefined_p.

Referenced by any_expression_side_effects_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_expressions_to_transformer()

transformer any_expressions_to_transformer	(	entity	v,
		list	expl,
		transformer	pre
	)

Compute the transformer associated to a list of expressions such as "i=0, j = 1;".

The value returned is linked to v.

To be merged with the previous function.

el is an over-appoximation; should be replaced by a safe_expression_to_transformer() taking care of computing the precise effects of exp instead of using the effects of expl.

Parameters

expl	xpl
pre	re

Definition at line 5754 of file expression.c.

{
  transformer tf = transformer_identity();
  transformer cpre = transformer_undefined_p(pre)?
    transformer_identity() : transformer_range(pre);
  expression l_exp = EXPRESSION(CAR(gen_last(expl)));
 
  FOREACH(EXPRESSION, exp, expl) {
    /* el is an over-appoximation; should be replaced by a
       safe_expression_to_transformer() taking care of computing the
       precise effects of exp instead of using the effects of expl. */
    transformer ctf = (exp==l_exp)?
      safe_any_expression_to_transformer(v, exp, cpre, false) :
      safe_expression_to_transformer(exp, cpre);
    transformer npre = transformer_undefined;
    transformer npre_r = transformer_undefined;
 
    tf = transformer_combine(tf, ctf);
    tf = transformer_normalize(tf, 2);
    npre = transformer_apply(ctf, cpre);
    npre_r = transformer_range(npre);
    npre_r = transformer_normalize(npre_r, 2);
    free_transformer(cpre);
    free_transformer(npre);
    free_transformer(ctf);
    cpre = npre_r;
  }
  free_transformer(cpre);
  return tf;
}

References CAR, exp, EXPRESSION, FOREACH, free_transformer(), gen_last(), safe_any_expression_to_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by integer_call_expression_to_transformer(), and pointer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_loop_to_k_transformer()

transformer any_loop_to_k_transformer	(	transformer	,
		transformer	,
		transformer	,
		statement	,
		list	,
		transformer	,
		int
	)

loop.c

any_loop_to_postcondition()

transformer any_loop_to_postcondition	(	statement	body,
		transformer	t_init,
		transformer	t_enter,
		transformer	t_skip,
		transformer	t_body_star,
		transformer	t_body,
		transformer	t_next,
		transformer	t_inc,
		transformer	t_exit,
		transformer	pre
	)

The precondition to propagate in the body is:

p_body = (t_init ; t_enter)(pre) + (t_body_star ; t_body ; t_next) (pre)

The loop postcondition to return is:

post = (t_init ; t_skip)(pre) + (t_body_star ; t_body ; t_inc ; t_exit) (pre)

To restrict the state at the beginning of the last iteration: should be part of t_body_star

Decompose the computation of p_body

Decompose the computation of post

a_post should be used because it is more accurate than direct recomputation, but we chose for the time being to recompute post entirely

Get rid of now useless transformers

Parameters

body	ody
t_init	_init
t_enter	_enter
t_skip	_skip
t_body_star	_body_star
t_body	_body
t_next	_next
t_inc	_inc
t_exit	_exit
pre	re

Definition at line 2634 of file loop.c.

{
  /* The precondition to propagate in the body is:
   *
   * p_body = (t_init ; t_enter)(pre) + (t_body_star ; t_body ; t_next) (pre)
   *
   * The loop postcondition to return is:
   *
   * post = (t_init ; t_skip)(pre) + (t_body_star ; t_body ; t_inc ; t_exit) (pre)
   */
  transformer p_body = transformer_undefined;
  transformer post = transformer_undefined;
  /* To restrict the state at the beginning of the last iteration:
     should be part of t_body_star */
  //transformer post_enter = transformer_range(t_enter);
  //transformer post_continue = transformer_range(t_next);
  //transformer pre_iteration = transformer_convex_hull(post_enter, post_continue);
  /* Decompose the computation of p_body */
  transformer p_body_1 = transformer_apply(t_enter, transformer_apply(t_init, pre));
  transformer p_body_2 = transformer_apply(t_body_star, pre);
  //transformer p_body_3 = transformer_apply(pre_iteration, p_body_2);
  transformer p_body_4 = transformer_apply(t_body, p_body_2);
  transformer p_body_5 = transformer_apply(t_next, p_body_4);
  transformer a_post = transformer_undefined;
  /* Decompose the computation of post */
  transformer post_1 = transformer_apply(t_skip, transformer_apply(t_init, pre));
  transformer post_2 = transformer_apply(t_body_star, pre);
  //transformer post_3 = transformer_apply(pre_iteration, post_2);
  transformer post_4 = transformer_apply(t_body, post_2);
  transformer post_5 = transformer_apply(t_inc, post_4);
  transformer post_6 = transformer_apply(t_exit, post_5);
 
  p_body = transformer_convex_hull(p_body_1, p_body_5);
  a_post = statement_to_postcondition(p_body, body);
 
  /* a_post should be used because it is more accurate than direct
     recomputation, but we chose for the time being to recompute post
     entirely */
  post = transformer_convex_hull(post_1, post_6);
 
  /* Get rid of now useless transformers */
 
  free_transformer(a_post);
 
  //free_transformer(post_enter);
  //free_transformer(post_continue);
  //free_transformer(pre_iteration);
 
  free_transformer(p_body_1);
  free_transformer(p_body_2);
  //free_transformer(p_body_3);
  free_transformer(p_body_4);
  free_transformer(p_body_5);
 
  free_transformer(post_1);
  free_transformer(post_2);
  //free_transformer(post_3);
  free_transformer(post_4);
  free_transformer(post_5);
  free_transformer(post_6);
 
  return post;
}

References free_transformer(), statement_to_postcondition(), transformer_apply(), transformer_convex_hull(), and transformer_undefined.

Referenced by forloop_to_postcondition(), and repeatloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

any_loop_to_transformer()

transformer any_loop_to_transformer	(	transformer	,
		transformer	,
		transformer	,
		statement	,
		list	,
		transformer
	)

any_scalar_assign_to_transformer()

transformer any_scalar_assign_to_transformer	(	entity	v,
		expression	rhs,
		list	ef,
		transformer	pre
	)

precondition

Parameters

rhs	hs
ef	f
pre	re

Definition at line 2832 of file ri_to_transformers.c.

{
  transformer tf = any_scalar_assign_to_transformer_without_effect(v, rhs, pre);
 
  if(transformer_undefined_p(tf))
    tf = effects_to_transformer(ef);
 
  return tf;
}

References any_scalar_assign_to_transformer_without_effect(), effects_to_transformer(), and transformer_undefined_p.

Referenced by add_loop_index_initialization(), any_assign_to_transformer_list(), any_basic_update_to_transformer_list(), any_update_to_transformer_list(), assign_rhs_to_cp_to_transformer(), assign_rhs_to_reflhs_to_transformer(), basic_update_reflhs_with_rhs_to_transformer(), loop_initialization_to_transformer(), and update_reflhs_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_scalar_assign_to_transformer_list()

list any_scalar_assign_to_transformer_list	(	entity	v,
		expression	rhs,
		list	ef,
		transformer	pre
	)

precondition

Is it standard compliant? The assigned variable is modified by the rhs.

Take care of aliasing

tf = transformer_value_substitute(tf, v_new, v_old);

Parameters

rhs	hs
ef	f
pre	re

Definition at line 709 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
 
  pips_internal_error("Not implemented yet.");
 
  if(entity_has_values_p(v)) {
    entity v_new = entity_to_new_value(v);
    entity v_old = entity_to_old_value(v);
    entity tmp = make_local_temporary_value_entity(ultimate_type(entity_type(v)));
 
    tf = any_expression_to_transformer(tmp, rhs, pre, true);
 
    if(!transformer_undefined_p(tf)) {
 
      pips_debug(9, "A transformer has been obtained:\n");
      ifdebug(9) dump_transformer(tf);
 
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        /* Is it standard compliant? The assigned variable is modified by the rhs. */
        transformer teq = simple_equality_to_transformer(v, tmp, true);
        string s = expression_to_string(rhs);
 
        semantics_user_warning("Variable \"%s\" in lhs is uselessly or illegally updated by rhs '%s;'\n",
                          entity_user_name(v), s);
        //                        entity_local_name(v), s);
 
        free(s);
 
        tf = transformer_combine(tf, teq);
        free_transformer(teq);
      }
      else {
        /* Take care of aliasing */
        entity v_repr = value_to_variable(v_new);
 
        /* tf = transformer_value_substitute(tf, v_new, v_old); */
        tf = transformer_value_substitute(tf, v_new, v_old);
 
        pips_debug(9,"After substitution v_new=%s -> v_old=%s\n",
              entity_local_name(v_new), entity_local_name(v_old));
 
        tf = transformer_value_substitute(tf, tmp, v_new);
 
        pips_debug(9,"After substitution tmp=%s -> v_new=%s\n",
              entity_local_name(tmp), entity_local_name(v_new));
 
        transformer_add_modified_variable(tf, v_repr);
      }
    }
    if(!transformer_undefined_p(tf)) {
      tf = transformer_temporary_value_projection(tf);
      pips_debug(9, "After temporary value projection, tf=%p:\n", tf);
      ifdebug(9) dump_transformer(tf);
    }
    reset_temporary_value_counter();
  }
 
  if(transformer_undefined_p(tf))
    tf = effects_to_transformer(ef);
 
  return tl;
}

References any_expression_to_transformer(), dump_transformer, effects_to_transformer(), entity_has_values_p(), entity_is_argument_p(), entity_local_name(), entity_to_new_value(), entity_to_old_value(), entity_type, entity_user_name(), expression_to_string(), free(), free_transformer(), ifdebug, make_local_temporary_value_entity(), NIL, pips_debug, pips_internal_error, reset_temporary_value_counter(), semantics_user_warning, simple_equality_to_transformer(), transformer_add_modified_variable(), transformer_arguments, transformer_combine(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, transformer_value_substitute(), ultimate_type(), and value_to_variable().

Here is the call graph for this function:

any_scalar_assign_to_transformer_without_effect()

transformer any_scalar_assign_to_transformer_without_effect	(	entity	v,
		expression	rhs,
		transformer	pre
	)

assign to the scalar variable v the expression rhs (a scalar variable has a basic type; it cannot be an array, a struct or a union; it can be an enum) WARNING : this function can return transformer_undefined

Parameters

v	entity/variable to be assign
rhs	expression/value to assign
pre	precondition, transformer already present

Returns

transformer_undefined or transformer with the scalar assignment precondition

Is it standard compliant? The assigned variable is modified by the rhs.

Take care of aliasing

tf = transformer_value_substitute(tf, v_new, v_old);

Parameters

rhs	hs
pre	re

Definition at line 2766 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
 
  if(entity_has_values_p(v)) {
    entity v_new = entity_to_new_value(v);
    entity v_old = entity_to_old_value(v);
    entity tmp = make_local_temporary_value_entity(ultimate_type(entity_type(v)));
 
    tf = any_expression_to_transformer(tmp, rhs, pre, true);
 
    if(!transformer_undefined_p(tf)) {
 
      ifdebug(8) {
        pips_debug(8, "A transformer has been obtained:\n");
        dump_transformer(tf);
      }
 
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
          /* Is it standard compliant? The assigned variable is modified by the rhs. */
          transformer teq = simple_equality_to_transformer(v, tmp, true);
          string s = expression_to_string(rhs);
 
          semantics_user_warning("Variable \"%s\" in lhs is uselessly or "
                                 "illegally updated by rhs '%s'\n",
                                entity_user_name(v), s);
          //                                entity_local_name(v), s);
 
          free(s);
 
          tf = transformer_combine(tf, teq);
          free_transformer(teq);
      }
      else {
          /* Take care of aliasing */
          entity v_repr = value_to_variable(v_new);
 
          /* tf = transformer_value_substitute(tf, v_new, v_old); */
          tf = transformer_value_substitute(tf, v_new, v_old);
 
          pips_debug(8,"After substitution v_new=%s -> v_old=%s\n",
                entity_local_name(v_new), entity_local_name(v_old));
          ifdebug(8) dump_transformer(tf);
 
          tf = transformer_value_substitute(tf, tmp, v_new);
 
          pips_debug(8,"After substitution tmp=%s -> v_new=%s\n",
                entity_local_name(tmp), entity_local_name(v_new));
          ifdebug(8) dump_transformer(tf);
 
          transformer_add_modified_variable(tf, v_repr);
      }
    }
    if(!transformer_undefined_p(tf)) {
      tf = transformer_temporary_value_projection(tf);
      pips_debug(8, "After temporary value projection, tf=%p:\n", tf);
      ifdebug(8) dump_transformer(tf);
    }
    reset_temporary_value_counter();
  }
 
  return tf;
}

References any_expression_to_transformer(), dump_transformer, entity_has_values_p(), entity_is_argument_p(), entity_local_name(), entity_to_new_value(), entity_to_old_value(), entity_type, entity_user_name(), expression_to_string(), free(), free_transformer(), ifdebug, make_local_temporary_value_entity(), pips_debug, reset_temporary_value_counter(), semantics_user_warning, simple_equality_to_transformer(), transformer_add_modified_variable(), transformer_arguments, transformer_combine(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, transformer_value_substitute(), ultimate_type(), and value_to_variable().

Referenced by any_scalar_assign_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

any_update_to_transformer()

transformer any_update_to_transformer	(	entity	op,
		list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis No more, lhs can also be dereferencing

f ou NIL ??

if some condition was not met and transformer derivation failed

Parameters

op	p
args	rgs
ef	f
pre	re

Definition at line 3401 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  expression rhs = EXPRESSION(CAR(CDR(args)));
  syntax slhs = expression_syntax(lhs);
 
  pips_assert("2 args for regular update", CDR(CDR(args))==NIL);
 
  /* The lhs must be a scalar reference to perform an interesting analysis
   * No more, lhs can also be dereferencing
   */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    tf = update_reflhs_with_rhs_to_transformer(op, rlhs, rhs, pre, ef);
  }
  // case constant path in lhs (dereferencing, struct, array)
  else if (syntax_call_p(slhs)) {
    if (!pt_to_list_undefined_p()) {
      list l = semantics_expression_to_points_to_sources(lhs);
      FOREACH(CELL, cp, l) {
        reference rlhs = cell_preference_p(cp)? preference_reference(cell_preference(cp)) : cell_reference(cp);
 
        // example of case which is normally filter *p when p formal parameter, or dynamic allocation of p
        if (analyzed_reference_p(rlhs)) {
          entity source_lhs = reference_variable(rlhs);
 
          ifdebug(7) {
            pips_debug(7, "source reference : %s\n", reference_to_string(rlhs));
          }
 
          if (entity_null_locations_p(source_lhs)) {
            if (gen_length(l) == 1)
              pips_user_error("The pointer %s points to NULL\n", expression_to_string(lhs));
            else
              semantics_user_warning("The pointer %s can points to NULL\n", expression_to_string(lhs));
          } else if (entity_typed_nowhere_locations_p(source_lhs)) {
            if (gen_length(l) == 1)
              pips_user_error("The pointer %s points to undefined/indeterminate (%s)\n", expression_to_string(lhs), reference_to_string(rlhs));
            else
              semantics_user_warning("The pointer %s can points to undefined/indeterminate (%s)\n", expression_to_string(lhs), reference_to_string(rlhs));
          }
          else {
            transformer rt = update_reflhs_with_rhs_to_transformer(op, rlhs, rhs, pre, ef/*ef ou NIL ?? */);
            // NL : It must have be a better way to do that but I don't know how
            if (transformer_undefined_p(tf))
              tf = rt;
            else {
              tf = transformer_convex_hull(tf, rt);
              free_transformer(rt);
            }
          }
        }
      }
    }
  }
 
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tf=%p\n", tf);
  ifdebug(6) (void) print_transformer(tf);
  pips_debug(8,"end\n");
  return tf;
}

References analyzed_reference_p(), CAR, CDR, CELL, cell_preference, cell_preference_p, cell_reference, cp, effects_to_transformer(), entity_null_locations_p(), entity_typed_nowhere_locations_p(), EXPRESSION, expression_syntax, expression_to_string(), FOREACH, free_transformer(), gen_length(), ifdebug, NIL, pips_assert, pips_debug, pips_user_error, preference_reference, print_transformer, pt_to_list_undefined_p(), reference_to_string(), reference_variable, semantics_expression_to_points_to_sources(), semantics_user_warning, syntax_call_p, syntax_reference, syntax_reference_p, transformer_convex_hull(), transformer_undefined, transformer_undefined_p, and update_reflhs_with_rhs_to_transformer().

Referenced by intrinsic_to_transformer(), and intrinsic_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

any_update_to_transformer_list()

list any_update_to_transformer_list	(	entity	op,
		list	args,
		list	ef,
		transformer	pre
	)

precondition

The lhs must be a scalar reference to perform an interesting analysis

if some condition was not met and transformer derivation failed

Parameters

op	p
args	rgs
ef	f
pre	re

Definition at line 810 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
  expression lhs = EXPRESSION(CAR(args));
  expression rhs = EXPRESSION(CAR(CDR(args)));
  syntax slhs = expression_syntax(lhs);
 
  pips_internal_error("Not implemented yet.");
 
  pips_assert("2 args for regular update", CDR(CDR(args))==NIL);
 
  /* The lhs must be a scalar reference to perform an interesting analysis */
  if(syntax_reference_p(slhs)) {
    reference rlhs = syntax_reference(slhs);
    if(ENDP(reference_indices(rlhs))) {
      entity v = reference_variable(rlhs);
      expression ve = entity_to_expression(v);
      entity sop = update_operator_to_regular_operator(op);
      expression n_rhs = MakeBinaryCall(sop, ve, copy_expression(rhs));
 
      tf = any_scalar_assign_to_transformer(v, n_rhs, ef, pre); 
      free_expression(n_rhs);
    }
  }
 
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tl=%p\n", tl);
  ifdebug(6) (void) print_transformers(tl);
  pips_debug(8,"end\n");
  return tl;
}

References any_scalar_assign_to_transformer(), CAR, CDR, copy_expression(), effects_to_transformer(), ENDP, entity_to_expression(), EXPRESSION, expression_syntax, free_expression(), ifdebug, MakeBinaryCall(), NIL, pips_assert, pips_debug, pips_internal_error, print_transformers(), reference_indices, reference_variable, syntax_reference, syntax_reference_p, transformer_undefined, and update_operator_to_regular_operator().

Here is the call graph for this function:

any_user_call_site_to_transformer()

transformer any_user_call_site_to_transformer	(	entity	,
		list	,
		transformer	,
		list
	)

apply_array_effect_to_transformer()

transformer apply_array_effect_to_transformer	(	transformer	,
		effect	,
		bool
	)

ri_to_transformers.c

array_elements_substitution_in_transformer()

transformer array_elements_substitution_in_transformer	(	transformer	,
		entity	,
		type	,
		expression	,
		transformer	,
		list	,
		bool
	)

assign_operation_to_transformer()

transformer assign_operation_to_transformer	(	entity	val,
		expression	lhs,
		expression	rhs,
		transformer	pre
	)

Returns an undefined transformer in case of failure.

&& integer_scalar_entity_p(e)

Parameters

val	al
lhs	hs
rhs	hs
pre	re

Definition at line 2737 of file expression.c.

{
  transformer tf = transformer_undefined;
 
  pips_debug(8,"begin\n");
 
  if(expression_reference_p(lhs)) {
    entity e = reference_variable(syntax_reference(expression_syntax(lhs)));
 
    if(entity_has_values_p(e) /* && integer_scalar_entity_p(e) */) {
      entity ev = entity_to_new_value(e);
      //transformer teq = simple_equality_to_transformer(val, ev, true);
      tf = assigned_expression_to_transformer(ev, rhs, pre);
      if(!transformer_undefined_p(tf))
        tf = transformer_add_equality(tf, val, ev);
      //tf = transformer_combine(tf, teq);
      //free_transformer(teq);
    }
  }
 
  pips_debug(6,"return tf=%lx\n", (unsigned long)tf);
  ifdebug(6) (void) dump_transformer(tf);
  pips_debug(8,"end\n");
  return tf;
}

References assigned_expression_to_transformer(), dump_transformer, entity_has_values_p(), entity_to_new_value(), expression_reference_p(), expression_syntax, ifdebug, pips_debug, reference_variable, syntax_reference, transformer_add_equality(), transformer_undefined, and transformer_undefined_p.

Referenced by float_binary_operation_to_transformer(), integer_binary_operation_to_transformer(), logical_binary_function_to_transformer(), and pointer_binary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

assigned_expression_to_transformer()

transformer assigned_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre
	)

transformer assigned_expression_to_transformer(entity e, expression expr, list ef): returns a transformer abstracting the effect of assignment "e = expr" when possible, transformer_undefined otherwise.

Note: it might be better to distinguish further between e and expr and to return a transformer stating that e is modified when e is accepted for semantics analysis.

if the assigned variable is also assigned by the expression as in i = (i = 2) + 1, transformer_value_substitute() cannot be used right away. The previous store must be projected out.

v must be assigned

subcase of previous aternative

vect_rm(ve);

Parameters

expr	xpr
pre	re

Definition at line 2595 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
 
  pips_debug(8, "begin\n");
 
  if(entity_has_values_p(v)) {
    entity v_new = entity_to_new_value(v);
    entity tmp = make_local_temporary_value_entity(entity_type(v));
    //list tf_args = CONS(ENTITY, v, NIL);
 
    tf = any_expression_to_transformer(tmp, expr, pre, true);
    // The assignment may be part of a more complex expression
    // This should be guarded by "is_internal==FALSE" if is_internal were an argument
    //reset_temporary_value_counter();
    if(!transformer_undefined_p(tf)) {
      /* if the assigned variable is also assigned by the expression
       as in i = (i = 2) + 1, transformer_value_substitute() cannot be
       used right away. The previous store must be projected out. */
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        /* v must be assigned */
        transformer teq = simple_equality_to_transformer(v, tmp, true);
        tf = transformer_combine(tf, teq);
        free_transformer(teq);
 
      }
      else { /* subcase of previous aternative */
        entity v_old = entity_to_old_value(v);
        tf = transformer_value_substitute(tf, v_new, v_old);
        tf = transformer_value_substitute(tf, tmp, v_new);
        // v cannot be a temporary variable
        //transformer_arguments(tf) =
        //arguments_add_entity(transformer_arguments(tf), v);
        tf = transformer_add_value_update(tf, v);
      }
      tf = transformer_temporary_value_projection(tf);
    }
  }
  else {
    /* vect_rm(ve); */
    tf = transformer_undefined;
  }
 
  pips_debug(8, "end with tf=%p\n", tf);
 
  return tf;
}

References any_expression_to_transformer(), entity_has_values_p(), entity_is_argument_p(), entity_to_new_value(), entity_to_old_value(), entity_type, free_transformer(), make_local_temporary_value_entity(), pips_debug, simple_equality_to_transformer(), transformer_add_value_update(), transformer_arguments, transformer_combine(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, and transformer_value_substitute().

Referenced by assign_operation_to_transformer(), integer_assign_to_transformer(), integer_assign_to_transformer_list(), loop_to_initialization_transformer(), 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:

assigned_expression_to_transformer_list()

list assigned_expression_to_transformer_list	(	entity	v,
		expression	expr,
		transformer	pre
	)

transformer assigned_expression_to_transformer(entity e, expression expr, list ef): returns a transformer abstracting the effect of assignment "e = expr" when possible, transformer_undefined otherwise.

Note: it might be better to distinguish further between e and expr and to return a transformer stating that e is modified when e is accepted for semantics analysis.

if the assigned variable is also assigned by the expression as in i = (i = 2) + 1, transformer_value_substitute() cannot be used right away. The previous store must be projected out.

v must be assigned

subcase of previous aternative

vect_rm(ve);

Parameters

expr	xpr
pre	re

Definition at line 551 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
 
  pips_internal_error("Not implemented yet.");
 
  pips_debug(8, "begin\n");
 
  if(entity_has_values_p(v)) {
    entity v_new = entity_to_new_value(v);
    entity v_old = entity_to_old_value(v);
    entity tmp = make_local_temporary_value_entity(entity_type(v));
    //list tf_args = CONS(ENTITY, v, NIL);
 
    tf = any_expression_to_transformer(tmp, expr, pre, true);
    // The assignment may be part of a more complex expression
    // This should be guarded by "is_internal==FALSE" if is_internal were an argument
    //reset_temporary_value_counter();
    if(!transformer_undefined_p(tf)) {
      /* if the assigned variable is also assigned by the expression
       as in i = (i = 2) + 1, transformer_value_substitute() cannot be
       used right away. The previous store must be projected out. */
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        /* v must be assigned */
        transformer teq = simple_equality_to_transformer(v, tmp, true);
        tf = transformer_combine(tf, teq);
        free_transformer(teq);
 
      }
      else { /* subcase of previous aternative */
        tf = transformer_value_substitute(tf, v_new, v_old);
        tf = transformer_value_substitute(tf, tmp, v_new);
        // v cannot be a temporary variable
        //transformer_arguments(tf) =
        //arguments_add_entity(transformer_arguments(tf), v);
        tf = transformer_add_value_update(tf, v);
      }
      tf = transformer_temporary_value_projection(tf);
    }
  }
  else {
    /* vect_rm(ve); */
    tf = transformer_undefined;
  }
 
  pips_debug(8, "end with tf=%p\n", tl);
 
  return tl;
}

References any_expression_to_transformer(), entity_has_values_p(), entity_is_argument_p(), entity_to_new_value(), entity_to_old_value(), entity_type, free_transformer(), make_local_temporary_value_entity(), NIL, pips_debug, pips_internal_error, simple_equality_to_transformer(), transformer_add_value_update(), transformer_arguments, transformer_combine(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, and transformer_value_substitute().

Here is the call graph for this function:

bitwise_xor_to_transformer()

transformer bitwise_xor_to_transformer	(	entity	v,
		list	args,
		transformer	pre
	)

returns the transformer associated to a C bitwise xor, ^, applied to two integer argument, when meaningful, and transformer_undefined otherwise.

Effects must be used at a higher level to fall back on a legal transformer.

Parameters

v	is the value associated to the expression
args	is assumed to have only one expression element of type int negated by !
pre	is the current precondition

Something can be done when both arguments have values in [0,1], when both arguments have known numerical values, when both arguments have the same value,... However, all this tests imply lots time consuming projections for a limited result... Unless somebody uses XOR to flip-flop between arrays... for instance to bother Sven Verdoolaege:-). A logical not might be more useful for this:-).

The two values are know at compile time

The two values can be interpreted as booleans

Code about cut-and-pasted from logical_binary_operation_to_transformer()

The two arguments may be equal because they are the same expression and the xor is used to generate a zero or because they have the same value.

Since the difference is zero the two values are equal

Parameters

args	rgs
pre	re

Definition at line 5619 of file expression.c.

{
  /* Something can be done when both arguments have values in [0,1],
     when both arguments have known numerical values, when both
     arguments have the same value,... However, all this
     tests imply lots time consuming projections for a limited
     result... Unless somebody uses XOR to flip-flop between
     arrays... for instance to bother Sven Verdoolaege:-). A logical
     not might be more useful for this:-). */
  expression le1 = EXPRESSION(CAR(args));
  //basic be1 = basic_of_expression(le1);
  expression le2 = EXPRESSION(CAR(CDR(args)));
  //basic be2 = basic_of_expression(le2);
  transformer tf = transformer_undefined;
 
  //if(basic_int_p(be1) && basic_int_p(be2)) {
    entity tmp_v1 = make_local_temporary_integer_value_entity();
    // FI: Even with the "in context" property, the precondition is
    // not integrated into the transformer...
    transformer tf1 = safe_any_expression_to_transformer(tmp_v1, le1, pre, true);
    //transformer tfr1 = transformer_range(tf1);
    transformer tfr1 = transformer_apply(tf1, pre);
    intptr_t lb1, ub1;
    entity tmp_v2 = make_local_temporary_integer_value_entity();
    transformer tf2 = safe_any_expression_to_transformer(tmp_v2, le2, pre, true);
    // transformer tfr2 = transformer_range(tf2);
    transformer tfr2 = transformer_apply(tf2, pre);
    intptr_t lb2, ub2;
 
    if(precondition_minmax_of_value(tmp_v1, tfr1, &lb1, &ub1)
       && precondition_minmax_of_value(tmp_v2, tfr2, &lb2, &ub2)) {
      if(lb1==ub1 && lb2==ub2) {
        /* The two values are know at compile time */
        tf = transformer_identity();
        tf = transformer_add_equality_with_integer_constant(tf, v, lb1 ^ lb2);
      }
      else if(0<=lb1 && ub1 <= 1 && 0<=lb2 && ub2 <= 1) {
        tf = transformer_identity();
        /* The two values can be interpreted as booleans */
        /* Code about cut-and-pasted from
           logical_binary_operation_to_transformer() */
        Pvecteur eq1 = vect_new((Variable) v, VALUE_ONE);
        vect_add_elem(&eq1, (Variable) tmp_v1, VALUE_MONE);
        vect_add_elem(&eq1, (Variable) tmp_v2, VALUE_MONE);
 
        Pvecteur eq2 = vect_new((Variable) v, VALUE_ONE);
        vect_add_elem(&eq2, (Variable) tmp_v1, VALUE_ONE);
        vect_add_elem(&eq2, (Variable) tmp_v2, VALUE_ONE);
        vect_add_elem(&eq2, TCST , VALUE_MONE+VALUE_MONE);
 
        Pvecteur eq3 = vect_new((Variable) v, VALUE_MONE);
        vect_add_elem(&eq3, (Variable) tmp_v1, VALUE_ONE);
        vect_add_elem(&eq3, (Variable) tmp_v2, VALUE_MONE);
 
        Pvecteur eq4 = vect_new((Variable) v, VALUE_MONE);
        vect_add_elem(&eq4, (Variable) tmp_v1, VALUE_MONE);
        vect_add_elem(&eq4, (Variable) tmp_v2, VALUE_ONE);
 
        tf = transformer_inequality_add(tf, eq1);
        tf = transformer_inequality_add(tf, eq2);
        tf = transformer_inequality_add(tf, eq3);
        tf = transformer_inequality_add(tf, eq4);
      }
    }
    if(transformer_undefined_p(tf)) {
      /* The two arguments may be equal because they are the same
         expression and the xor is used to generate a zero or because
         they have the same value. */
      if(expression_equal_p(le1, le2)) {
        tf = transformer_identity();
        tf = transformer_add_equality_with_integer_constant(tf, v, 0);
      }
      else {
        transformer tfr1 = transformer_range(tf1);
        transformer tfr2 = transformer_range(tf2);
        transformer tfi = transformer_intersection(tfr1, tfr2);
        entity tmp_d = make_local_temporary_integer_value_entity();
        Pvecteur eq = vect_new((Variable) tmp_d, VALUE_ONE);
        vect_add_elem(&eq, (Variable) tmp_v1, VALUE_MONE);
        vect_add_elem(&eq, (Variable) tmp_v2, VALUE_ONE);
        tfi = transformer_equality_add(tfi, eq);
        intptr_t lbd, ubd;
 
        if(precondition_minmax_of_value(tmp_d, tfi, &lbd, &ubd)) {
          if(lbd==0 && ubd==0) {
            /* Since the difference is zero the two values are equal */
            tf = transformer_identity();
            tf = transformer_add_equality_with_integer_constant(tf, v, 0);
          }
        }
      }
    }
    //}
    //free_basic(be1), free_basic(be2);
    free_transformer(tfr1), free_transformer(tfr2);
  return tf;
}

References CAR, CDR, eq, EXPRESSION, expression_equal_p(), free_transformer(), intptr_t, make_local_temporary_integer_value_entity(), precondition_minmax_of_value(), safe_any_expression_to_transformer(), TCST, transformer_add_equality_with_integer_constant(), transformer_apply(), transformer_equality_add(), transformer_identity(), transformer_inequality_add(), transformer_intersection(), transformer_range(), transformer_undefined, transformer_undefined_p, VALUE_MONE, VALUE_ONE, vect_add_elem(), and vect_new().

Referenced by integer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

c_return_to_transformer()

transformer c_return_to_transformer	(	entity	,
		list	,
		list	,
		transformer
	)

c_user_call_to_transformer()

transformer c_user_call_to_transformer	(	entity	f,
		list	pc,
		transformer	pre,
		list	ef
	)

Compute the call site transformer, the bindings between formal entities and actual argments

substitute stubs and formal array elements which are passed directly or indirectly by reference if requested

Combine tf with the summary transformer

Project the former parameters and the temporary values.

Check the consistency of the transformer with the constant effects

Parameters

pc	c
pre	re
ef	f

Definition at line 2196 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  transformer t_callee = load_summary_transformer(f);
 
  pips_assert("t_callee is consistent", transformer_weak_consistency_p(t_callee));
 
  /* Compute the call site transformer, the bindings between formal
     entities and actual argments */
  tf = any_user_call_site_to_transformer(f, pc, pre, ef);
 
  /* substitute stubs and formal array elements which are passed
     directly or indirectly by reference if requested */
  transformer t_bound = copy_transformer(t_callee);
  if(get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH")) {
    call c = make_call(f, pc);
    statement s = get_current_statement_from_statement_global_stack();
    // t_bound = substitute_stubs_in_transformer(t_bound, c, s, true);
    t_bound = new_substitute_stubs_in_transformer(t_bound, c, s, true);
    call_arguments(c) = NIL;
    free_call(c);
    t_bound = substitute_formal_array_elements_in_transformer(t_bound, f, pc, pre, ef);
  }
 
  /* Combine tf with the summary transformer */
  tf = transformer_combine(tf, t_bound);
  free_transformer(t_bound);
 
  /* Project the former parameters and the temporary values. */
  tf = transformer_temporary_value_projection(tf);
  tf = transformer_formal_parameter_projection(f, tf);
 
  tf = transformer_filter_subsumed_variables(tf);
 
  /* Check the consistency of the transformer with the constant effects */
  // list effect_to_constant_path_effects_with_no_pointer_information(effect /*eff*/);
  // list simple_effect_to_constant_path_effects_with_pointer_values(effect /*eff*/);
  // list simple_effect_to_constant_path_effects_with_points_to(effect /*eff*/);
  list cel = list_undefined;
  if(get_bool_property("CONSTANT_PATH_EFFECTS"))
    cel = ef;
  else {
    if(pt_to_list_undefined_p())
      cel = effects_to_constant_path_effects_with_no_pointer_information(ef);
    else {
      // FI: I used to call pointer_effects_to_constant_path_effects()
      // but it is a generic function that requires setting some
      // function pointers
      cel = NIL;
      statement s = get_current_statement_from_statement_global_stack();
      FOREACH(EFFECT, e, ef) {
        list ncel = effect_to_constant_path_effects_with_points_to(e, s, pre);
        cel = gen_nconc(cel, ncel);
      }
    }
  }
  transformer etf = effects_to_transformer(cel);
  list al = transformer_arguments(etf);
  tf = transformer_add_variables_update(tf, al);
  free_transformer(etf);
 
  return tf;
}

References any_user_call_site_to_transformer(), call_arguments, copy_transformer(), EFFECT, effect_to_constant_path_effects_with_points_to(), effects_to_constant_path_effects_with_no_pointer_information(), effects_to_transformer(), f(), FOREACH, free_call(), free_transformer(), gen_nconc(), get_bool_property(), get_current_statement_from_statement_global_stack(), list_undefined, load_summary_transformer(), make_call(), new_substitute_stubs_in_transformer(), NIL, pips_assert, pt_to_list_undefined_p(), substitute_formal_array_elements_in_transformer(), transformer_add_variables_update(), transformer_arguments, transformer_combine(), transformer_filter_subsumed_variables(), transformer_formal_parameter_projection(), transformer_temporary_value_projection(), transformer_undefined, and transformer_weak_consistency_p().

Referenced by c_user_function_call_to_transformer(), and user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

call_site_count()

int call_site_count

(

entity

m

)

cproto-generated files

misc.c

cproto-generated files

Francois Irigoin, April 1990

Modifications:

• passage a l'utilisation de database probably to add to the future callgraph library

number of "call to m" sites within the current program; they are all in m's CALLERS

I do not know yet; let's return 1 to please the semantic analysis

Definition at line 51 of file misc.c.

{
    /* number of "call to m" sites within the current program;
       they are all in m's CALLERS */
    pips_assert("call_site_count", value_code_p(entity_initial(m)));
    /* I do not know yet; let's return 1 to please the semantic analysis */
    user_warning("call_site_count",
                 "not implemented yet, always returns 1\n");
    return 1;
}

References entity_initial, pips_assert, user_warning, and value_code_p.

call_site_to_module_precondition_text()

text call_site_to_module_precondition_text	(	entity	caller,
		entity	callee,
		statement	s,
		call	c
	)

This function does everything needed.

Called by ICFG with many different contexts.

summary effects for the callee

caller preconditions

callee preconditions

load caller preconditions

first, we deal with the caller

create htable for old_values ...

add to preconditions the links to the callee formal params

transform the preconditions to make sense for the callee

translate_global_values(e_caller, call_site_prec);

Now deal with the callee

Set the htable with its variables because now we work in this frame

Parameters

caller	aller
callee	allee

Definition at line 1051 of file interprocedural.c.

{
  text result;
  /* summary effects for the callee */
  list seffects_callee = load_summary_effects(callee);
  /* caller preconditions */
  transformer caller_prec = transformer_undefined;
  /* callee preconditions */
  transformer call_site_prec = transformer_undefined;
 
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource
                           (DBR_CUMULATED_EFFECTS,
                            module_local_name(caller), true));
 
  set_semantic_map((statement_mapping)
                   db_get_memory_resource
                   (DBR_PRECONDITIONS,
                    module_local_name(caller),
                    true) );
 
  /* load caller preconditions */
  caller_prec = transformer_dup(load_statement_semantic(s));
 
  set_current_module_statement(s);
 
  /* first, we deal with the caller */
  set_current_module_entity(caller);
  /* create htable for old_values ... */
  module_to_value_mappings(caller);
 
  /* add to preconditions the links to the callee formal params */
  caller_prec = add_formal_to_actual_bindings (c, caller_prec, caller);
  /* transform the preconditions to make sense for the callee */
  call_site_prec = precondition_intra_to_inter (callee,
                                                caller_prec,
                                                seffects_callee);
  call_site_prec = transformer_normalize(call_site_prec, 2);
 
  /* translate_global_values(e_caller, call_site_prec); */
  free_value_mappings();
  reset_current_module_entity();
 
  /* Now deal with the callee */
  set_current_module_entity(callee);
  /* Set the htable with its variables because now we work
     in this frame */
  module_to_value_mappings(callee);
 
  result = text_for_a_transformer(call_site_prec, false);
 
  reset_current_module_entity();
  reset_current_module_statement();
  reset_cumulated_rw_effects();
  reset_semantic_map();
  free_value_mappings();
 
  return result;
}

References add_formal_to_actual_bindings(), callee, db_get_memory_resource(), free_value_mappings(), load_statement_semantic(), load_summary_effects(), module_local_name(), module_to_value_mappings(), precondition_intra_to_inter(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_semantic_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_semantic_map(), text_for_a_transformer(), transformer_dup(), transformer_normalize(), and transformer_undefined.

Here is the call graph for this function:

call_to_summary_precondition()

void call_to_summary_precondition	(	transformer	pre,
		call	c
	)

propagate precondition pre as summary precondition of user functions

propagate precondition pre as summary precondition of user functions

user_warning("call_to_summary_precondition", "call to symbolic %s\n", entity_name(e));

Parameters

pre

re

Definition at line 989 of file interprocedural.c.

{
  entity e = call_function(c);
  tag tt;
  list args = call_arguments(c);
  transformer pre_callee = transformer_undefined;
 
  pips_debug(8, "begin\n");
 
  switch (tt = value_tag(entity_initial(e))) {
 
  case is_value_intrinsic:
    pips_debug(5, "intrinsic function %s\n",
               entity_name(e));
    /* propagate precondition pre as summary precondition
       of user functions */
    expressions_to_summary_precondition(pre, args);
    break;
 
  case is_value_code:
    pips_debug(5, "external function %s\n",
               entity_name(e));
    pre_callee = transformer_dup(pre);
    pre_callee =
      add_formal_to_actual_bindings(c, pre_callee, get_current_module_entity());
    add_module_call_site_precondition(e, pre_callee);
    /* propagate precondition pre as summary precondition
       of user functions */
    expressions_to_summary_precondition(pre, args);
    break;
 
  case is_value_symbolic:
    /* user_warning("call_to_summary_precondition",
       "call to symbolic %s\n",
       entity_name(e)); */
    break;
 
  case is_value_constant:
    user_warning("call_to_summary_precondition",
                 "call to constant %s\n",
                 entity_name(e));
    break;
 
  case is_value_unknown:
    pips_internal_error("unknown function %s",
               entity_name(e));
    break;
 
  default:
    pips_internal_error("unknown tag %d", tt);
  }
 
  pips_debug(8, "end\n");
 
}

References add_formal_to_actual_bindings(), add_module_call_site_precondition(), call_arguments, call_function, entity_initial, entity_name, expressions_to_summary_precondition(), get_current_module_entity(), is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, pips_debug, pips_internal_error, transformer_dup(), transformer_undefined, user_warning, and value_tag.

Referenced by expression_to_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

call_to_transformer()

transformer call_to_transformer	(	call	c,
		transformer	pre,
		list	ef
	)

Use to be static, but may be called from expressions in C.

effects of call c

call to an external function; preliminary version: rely on effects

A temporary variable should be allocated and user_function_call_to_transformer() be used. The variable should then be projected to keep only the side effects of the call.

Add information from pre. Invariant information is easy to use. Information about initial values, that is final values in pre, can also be used.

tf = transformer_normalize(tf, 4);

Parameters

pre	re
ef	f

Definition at line 1044 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  entity e = call_function(c);
  cons *pc = call_arguments(c);
  tag tt;
 
  ifdebug(9) {
    pips_debug(9,"begin with precondition %p \n", pre);
    print_transformer(pre);
    print_entity_variable(e);
    ifdebug(9) {
      statement curstat =  statement_undefined;
      if (statement_global_stack_defined_p())
        curstat =  get_current_statement_from_statement_global_stack();
      if (!statement_undefined_p(curstat))
        print_statement(curstat);
    }
  }
 
  switch (tt = value_tag(entity_initial(e))) {
  case is_value_code:
    /* call to an external function; preliminary version:
       rely on effects */
    if(get_bool_property(SEMANTICS_INTERPROCEDURAL)) {
      type et = ultimate_type(entity_type(e));
      type rt = ultimate_type(functional_result(type_functional(et)));
 
      if(type_void_p(rt)) {
        tf = user_call_to_transformer(e, pc, pre, ef);
        reset_temporary_value_counter(); // might not be a good idea
                                         // with expression lists?
        // Get rid of variables that have been subsumed by abstract
        // locations
        tf = transformer_filter_subsumed_variables(tf);
      }
      else {
        if(analyzed_type_p(rt)) {
          /* A temporary variable should be allocated and
             user_function_call_to_transformer() be used. The variable
             should then be projected to keep only the side effects of
             the call. */
          entity trv = make_local_temporary_value_entity(rt);
          expression expr = call_to_expression(c);
 
          tf = user_function_call_to_transformer(trv, expr, pre);
          tf = transformer_temporary_value_projection(tf);
          reset_temporary_value_counter();
          semantics_user_warning("Analyzable result of Function \"%s\" is "
                                 "ignored. Should it be casted to \"(void)\"?\n",
                                 entity_user_name(e));
          // Get rid of variables that have been subsumed by abstract
          // locations
          tf = transformer_filter_subsumed_variables(tf);
        }
        else {
          tf = user_call_to_transformer(e, pc, pre, ef);
          reset_temporary_value_counter(); // might not be a good idea
          semantics_user_warning("Result of function \"%s\" ignored. "
                                 "Should it be casted to \"(void)\"?\n",
                            entity_user_name(e));
          // Get rid of variables that have been subsumed by abstract
          // locations
          tf = transformer_filter_subsumed_variables(tf);
        }
      }
    }
    else
      tf = effects_to_transformer(ef);
    break;
  case is_value_symbolic:
  case is_value_constant:
    tf = transformer_identity();
    break;
  case is_value_unknown:
    pips_internal_error("function %s has an unknown value", entity_name(e));
    break;
  case is_value_intrinsic:
    tf = intrinsic_to_transformer(e, pc, pre, ef);
    break;
  default:
    pips_internal_error("unknown tag %d", tt);
  }
  pips_assert("transformer tf is consistent",
              transformer_consistency_p(tf));
 
  ifdebug(8) {
    pips_debug(8,"Transformer before intersection with precondition, tf=%p\n",
                 tf);
    (void) print_transformer(tf);
  }
 
  /* Add information from pre. Invariant information is easy to
     use. Information about initial values, that is final values in pre,
     can also be used. */
  tf = transformer_safe_domain_intersection(tf, pre);
  ifdebug(8) {
    pips_debug(8,"After intersection and before normalization with tf=%p\n", tf);
    (void) print_transformer(tf);
  }
  ifdebug(8) {
    pips_debug(8,"with precondition pre=%p\n", pre);
    (void) print_transformer(pre);
  }
/*   tf = transformer_normalize(tf, 4); */
  tf = transformer_normalize(tf, 2);
 
  ifdebug(8) {
    pips_debug(8,"end after normalization with tf=%p\n", tf);
    (void) print_transformer(tf);
  }
 
  return(tf);
}

References analyzed_type_p(), call_arguments, call_function, call_to_expression(), effects_to_transformer(), entity_initial, entity_name, entity_type, entity_user_name(), functional_result, get_bool_property(), get_current_statement_from_statement_global_stack(), ifdebug, intrinsic_to_transformer(), is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_local_temporary_value_entity(), pips_assert, pips_debug, pips_internal_error, print_entity_variable(), print_statement(), print_transformer, reset_temporary_value_counter(), SEMANTICS_INTERPROCEDURAL, semantics_user_warning, statement_global_stack_defined_p(), statement_undefined, statement_undefined_p, transformer_consistency_p(), transformer_filter_subsumed_variables(), transformer_identity(), transformer_normalize(), transformer_safe_domain_intersection(), transformer_temporary_value_projection(), transformer_undefined, type_functional, type_void_p, ultimate_type(), user_call_to_transformer(), user_function_call_to_transformer(), and value_tag.

Referenced by expression_to_transformer(), instruction_to_transformer(), and instruction_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

caller_count()

int caller_count

(

entity

m

)

number of modules calling m within the current program; i.e. number of modules containing at least one call site to m

I do not know yet; let's return 1 to please the semantic analysis

Definition at line 63 of file misc.c.

{
    /* number of modules calling m within the current program;
       i.e. number of modules containing at least one call site to m */
    pips_assert("caller_count", value_code_p(entity_initial(m)));
    /* I do not know yet; let's return 1 to please the semantic analysis */
    user_warning("caller_count",
                 "not implemented yet, always returns 1\n");
    return 1;
}

References entity_initial, pips_assert, user_warning, and value_code_p.

check_condition_wrt_precondition()

bool check_condition_wrt_precondition	(	expression	c,
		transformer	pre,
		bool	check_true
	)

Check that is is always false in a store s such that p(s)

Parameters

pre	re
check_true	heck_true

Definition at line 294 of file utils.c.

{
  bool check = true;
  transformer twc = transformer_dup(pre);
 
  pips_debug(8, "begins for check %s\n",
        bool_to_string(check_true));
 
  if(check_true) {
    twc = transformer_add_condition_information(twc, c, pre, false);
  }
  else {
    /* Check that is is always false in a store s such that p(s) */
    twc = transformer_add_condition_information(twc, c, pre, true);
  }
  check = transformer_empty_p(twc);
 
  pips_debug(8, "ends with check=%s for check_true=%s\n",
        bool_to_string(check), bool_to_string(check_true));
 
  return check;
}

References bool_to_string(), pips_debug, transformer_add_condition_information(), transformer_dup(), and transformer_empty_p().

Referenced by condition_false_wrt_precondition_p(), and condition_true_wrt_precondition_p().

Here is the call graph for this function:

Here is the caller graph for this function:

check_range_wrt_precondition()

bool check_range_wrt_precondition	(	range	r,
		transformer	p,
		bool	check_empty
	)

FI: this function is outdated because it does not compute the transformers for the range expressions, because it does not take side effects into account and ...

We might need a range_to_transformer() or loop_range_to_transformer() instead and check that its range is empty.

gather information about the increment sign

Try to prove that no iterations are performed

Without information about the increment sign, you cannot make a decision. Should we accept increments greater or equal to zero? Lesser or equal to zero?

Try to prove that at least one iteration is performed

Without information about the increment sign, you cannot make a decision. Should we accept increments greater or equal to zero? Lesser or equal to zero?

No decision has been made yet

a numerical range may be empty although no information is available

s = sc_strong_normalize4(s, (char * (*)(Variable)) entity_local_name);

= sc_elim_redund(s);

Parameters

check_empty

heck_empty

Definition at line 135 of file utils.c.

{
  bool check = true;
  expression lb_e = range_lower(r);
  expression ub_e = range_upper(r);
  expression incr_e = range_increment(r);
  normalized lb_n = NORMALIZE_EXPRESSION(lb_e);
  normalized ub_n = NORMALIZE_EXPRESSION(ub_e);
  normalized incr_n = NORMALIZE_EXPRESSION(incr_e);
  int incr_lb = 0;
  int incr_ub = 0;
 
  pips_debug(8, "begins for check %s\n", check_empty? "empty" : "non-empty");
 
  if(normalized_undefined_p(lb_n)
     || normalized_undefined_p(lb_n)
     || normalized_undefined_p(lb_n)) {
    user_error("check_range_wrt_precondition",
               "Expression should have been normalized. "
               "Maybe you have DOALL statements in your "
               "supposedly sequential source code!\n");
  }
 
  if(normalized_linear_p(lb_n)
     && normalized_linear_p(ub_n)
     && normalized_linear_p(incr_n)) {
 
    /* gather information about the increment sign */
    expression_and_precondition_to_integer_interval(incr_e, p, &incr_lb, &incr_ub);
 
    if(incr_lb==0 && incr_ub==0) {
      user_error("check_range_wrt_precondition",
                 "Range with illegal zero increment\n");
    }
 
    if(incr_lb<=incr_ub) {
      Pvecteur lb_v = vect_dup((Pvecteur) normalized_linear(lb_n));
      Pvecteur ub_v = vect_dup((Pvecteur) normalized_linear(ub_n));
      Pcontrainte ci = CONTRAINTE_UNDEFINED;
 
      if(check_empty) {
        /* Try to prove that no iterations are performed */
        if(incr_lb>=1) {
          Pvecteur ni = vect_substract(lb_v, ub_v);
 
          ci = contrainte_make(ni);
        }
        else if(incr_ub<=-1) {
          Pvecteur ni = vect_substract(ub_v, lb_v);
 
          ci = contrainte_make(ni);
        }
        else {
          /* Without information about the increment sign,
           * you cannot make a decision. Should we accept
           * increments greater or equal to zero? Lesser
           * or equal to zero?
           */
          check = false;
        }
      }
      else {
        /* Try to prove that at least one iteration is performed */
        if(incr_lb>=1) {
          Pvecteur ni = vect_substract(ub_v, lb_v);
 
          vect_add_elem(&ni, TCST, (Value) 1);
          ci = contrainte_make(ni);
        }
        else if(incr_ub<=-1) {
          Pvecteur ni = vect_substract(lb_v, ub_v);
 
          vect_add_elem(&ni, TCST, (Value) 1);
          ci = contrainte_make(ni);
        }
        else {
          /* Without information about the increment sign,
           * you cannot make a decision. Should we accept
           * increments greater or equal to zero? Lesser
           * or equal to zero?
           */
          check = false;
        }
      }
 
      if(check) {
        /* No decision has been made yet */
        /* a numerical range may be empty although no information is available */
        Psysteme s = transformer_undefined_p(p) ?
          sc_make(CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED) :
          sc_dup((Psysteme) predicate_system(transformer_relation(p)));
 
        s = sc_inequality_add(s, ci);
 
        ifdebug(8) {
          debug(8, "check_range_wrt_precondition",
                "Test feasibility for system:\n");
          sc_fprint(stderr, s, (char * (*)(Variable)) dump_value_name);
        }
 
        /* s = sc_strong_normalize4(s, (char * (*)(Variable)) entity_local_name); */
        s = sc_strong_normalize5(s, (char * (*)(Variable)) entity_local_name);
        /*s = sc_elim_redund(s);*/
        ifdebug(8) {
          debug(8, "check_range_wrt_precondition",
                "System after normalization:\n");
          sc_fprint(stderr, s, (char * (*)(Variable)) dump_value_name);
        }
 
        if(SC_EMPTY_P(s)) {
          check = true;
        }
        else {
          sc_rm(s);
          check = false;
        }
      }
    }
    else {
      debug(8, "check_range_wrt_precondition",
            "The loop is never executed because it is in a dead code section\n");
      check = check_empty;
    }
  }
  else {
    debug(8, "check_range_wrt_precondition",
          "No decision can be made because the increment sign is unknown\n");
    check = false;
  }
 
  debug(8, "check_range_wrt_precondition",
        "ends with check=%s for check_empty=%s\n",
        bool_to_string(check), bool_to_string(check_empty));
 
  return check;
}

References bool_to_string(), contrainte_make(), CONTRAINTE_UNDEFINED, debug(), dump_value_name(), entity_local_name(), expression_and_precondition_to_integer_interval(), ifdebug, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, normalized_undefined_p, pips_debug, predicate_system, range_increment, range_lower, range_upper, sc_dup(), sc_fprint(), sc_inequality_add(), sc_make(), sc_rm(), sc_strong_normalize5(), TCST, transformer_relation, transformer_undefined_p, user_error, vect_add_elem(), vect_dup(), and vect_substract().

Referenced by empty_range_wrt_precondition_p(), and non_empty_range_wrt_precondition_p().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_any_loop_transformer()

transformer complete_any_loop_transformer	(	transformer	,
		transformer	,
		transformer	,
		transformer	,
		transformer	,
		transformer	,
		transformer	,
		transformer
	)

complete_any_loop_transformer_list()

list complete_any_loop_transformer_list	(	transformer	t_init,
		transformer	t_skip,
		transformer	t_body_star,
		transformer	t_body,
		transformer	t_inc,
		transformer	t_exit
	)

FI: used to be complete_any_loop_transformer() with a direct reduction by convex hull.

t_loop = t_init ; t_skip + t_bodystar ; t_body ; t_inc; t_exit

Before entering t_body, t_enter or t_next have been applied which let us restrict the set of state modified by t_body. But this information should already been included in t_body_star.

Several cases must be tested:

1. The loop is always entered and exited (usual case for scientific code: t_skip = transformer_empty).
2. The loop is always entered and never exited (real-time code situation, t_exit = transformer_empty)
3. The loop is never entered (in its current context, t_bodystar = transformer_empty because t_enter = transformer_empty).
4. The loop may be entered and exited (usual case for general purpose computing, think of list handling).
5. The loop may be entered but is then never exited (real-time code again).

These cases are checked with complete01.c, complete02.c,... complete05.c

loop skipped transformer

add loop entered transformer/condition: should already be in t_body_star

combine both cases in a transformer list

Parameters

t_init	_init
t_skip	_skip
t_body_star	_body_star
t_body	_body
t_inc	_inc
t_exit	_exit

Definition at line 1578 of file loop.c.

{
  /* t_loop = t_init ; t_skip + t_bodystar ; t_body ; t_inc; t_exit
   *
   * Before entering t_body, t_enter or t_next have been applied which
   * let us restrict the set of state modified by t_body. But this
   * information should already been included in t_body_star.
   */
 
  /* Several cases must be tested:
   *
   * 1. The loop is always entered and exited (usual case for
   * scientific code: t_skip = transformer_empty).
   *
   * 2. The loop is always entered and never exited (real-time code
   * situation, t_exit = transformer_empty)
   *
   * 3. The loop is never entered (in its current context, t_bodystar
   * = transformer_empty because t_enter = transformer_empty).
   *
   * 4. The loop may be entered and exited (usual case for general
   * purpose computing, think of list handling).
   *
   * 5. The loop may be entered but is then never exited (real-time
   * code again).
   *
   * These cases are checked with complete01.c,
   * complete02.c,... complete05.c
   */
  list ltl = NIL;
  // transformer ct = transformer_undefined;
  /* loop skipped transformer */
  transformer lst = transformer_combine(copy_transformer(t_init), t_skip);
  /* add loop entered transformer/condition: should already be in t_body_star */
  //transformer post_enter = transformer_range(t_enter);
  //transformer post_continue = transformer_range(t_continue);
  //transformer pre_body = transformer_convex_hull(post_enter, post_continue);
  //transformer let = transformer_combine(copy_transformer(t_body_star), pre_body);
  transformer let = copy_transformer(t_body_star);
 
  ifdebug(8) {
    fprintf(stderr, "t_init:\n");
    print_transformer(t_init);
    fprintf(stderr, "t_skip:\n");
    print_transformer(t_skip);
    fprintf(stderr, "t_body_star:\n");
    print_transformer(t_body_star);
    fprintf(stderr, "t_body:inc\n");
    print_transformer(t_body);
    fprintf(stderr, "t_inc:\n");
    print_transformer(t_inc);
    fprintf(stderr, "t_exit:\n");
    print_transformer(t_exit);
  }
 
  let = transformer_combine(let, t_body);
  let = transformer_combine(let, t_inc);
  let = transformer_combine(let, t_exit);
  let = transformer_normalize(let, 2);
 
  /* combine both cases in a transformer list */
  //ct = transformer_convex_hull(lst, let);
  ltl = two_transformers_to_list(lst, let);
 
  //free_transformer(post_enter);
  //free_transformer(post_continue);
  //free_transformer(pre_body);
 
  ifdebug(8) {
    fprintf(stderr, "ltl:\n");
    print_transformers(ltl);
  }
 
  return ltl;
}

References copy_transformer(), fprintf(), ifdebug, NIL, print_transformer, print_transformers(), transformer_combine(), transformer_normalize(), and two_transformers_to_list().

Referenced by complete_any_loop_transformer(), and new_complete_whileloop_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_forloop_transformer()

transformer complete_forloop_transformer	(	transformer	t_body_star,
		transformer	pre,
		forloop	fl
	)

This function does not seem to exist because we only used statement effects in the past and because those are stored in the database.

An effort could be made to compute the precondition for t_exit, especially if the precondition to t_inc is available.

An effort could be made to compute the precondition for t_inc

Make sure you have the effective statement transformer: it is not stored for loops and this is key for nested loops.

Parameters

t_body_star	_body_star
pre	re
fl	l

Definition at line 1686 of file loop.c.

{
  transformer ct = transformer_undefined;
  statement body_s = forloop_body(fl);
  transformer t_body = load_statement_transformer(body_s);
  transformer ct_body = transformer_undefined;
  transformer pre_body = transformer_undefined;
  expression init_e = forloop_initialization(fl);
  /* This function does not seem to exist because we only used
     statement effects in the past and because those are stored in the
     database. */
  transformer t_init = safe_expression_to_transformer(init_e, pre);
  transformer post_init = transformer_apply(t_init, pre);
  expression cond_e = forloop_condition(fl);
  expression inc_e = forloop_increment(fl);
  transformer t_skip = condition_to_transformer(cond_e, post_init, false);
  transformer t_enter = condition_to_transformer(cond_e, post_init, true);
/* An effort could be made to compute the precondition for t_exit,
     especially if the precondition to t_inc is available. */
  transformer t_continue = condition_to_transformer(cond_e, transformer_undefined, true);
  transformer t_exit = condition_to_transformer(cond_e, transformer_undefined, false);
  /* An effort could be made to compute the precondition for t_inc */
  transformer t_inc = safe_expression_to_transformer(inc_e, transformer_undefined);
 
  /* Make sure you have the effective statement transformer: it is not
     stored for loops and this is key for nested loops. */
  pre_body = transformer_apply(t_body_star, pre);
  ct_body = complete_statement_transformer(t_body, pre_body, body_s);
 
  ct = complete_any_loop_transformer(t_init, t_enter, t_skip, t_body_star, ct_body, t_continue, t_inc, t_exit);
 
  free_transformer(ct_body);
  free_transformer(pre_body);
  free_transformer(t_init);
  free_transformer(post_init);
  free_transformer(t_skip);
  free_transformer(t_enter);
  free_transformer(t_continue);
  free_transformer(t_exit);
  free_transformer(t_inc);
 
  return ct;
}

References complete_any_loop_transformer(), complete_statement_transformer(), condition_to_transformer(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, free_transformer(), load_statement_transformer(), safe_expression_to_transformer(), transformer_apply(), and transformer_undefined.

Referenced by generic_complete_statement_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_forloop_transformer_list()

list complete_forloop_transformer_list	(	transformer	t_body_star,
		transformer	pre,
		forloop	fl
	)

This function does not seem to exist because we only used statement effects in the past and because those are stored in the database.

An effort could be made to compute the precondition for t_exit, especially if the precondition to t_inc is available.

An effort could be made to compute the precondition for t_inc

Make sure you have the effective statement transformer: it is not stored for loops and this is key for nested loops.

Parameters

t_body_star	_body_star
pre	re
fl	l

Definition at line 1732 of file loop.c.

{
  list tfl = list_undefined;
  statement body_s = forloop_body(fl);
  transformer t_body = load_statement_transformer(body_s);
  transformer ct_body = transformer_undefined;
  transformer pre_body = transformer_undefined;
  expression init_e = forloop_initialization(fl);
  /* This function does not seem to exist because we only used
     statement effects in the past and because those are stored in the
     database. */
  transformer t_init = safe_expression_to_transformer(init_e, pre);
  transformer post_init = transformer_apply(t_init, pre);
  expression cond_e = forloop_condition(fl);
  expression inc_e = forloop_increment(fl);
  transformer t_skip = condition_to_transformer(cond_e, post_init, false);
  transformer t_enter = condition_to_transformer(cond_e, post_init, true);
/* An effort could be made to compute the precondition for t_exit,
     especially if the precondition to t_inc is available. */
  transformer t_continue = condition_to_transformer(cond_e, transformer_undefined, true);
  transformer t_exit = condition_to_transformer(cond_e, transformer_undefined, false);
  /* An effort could be made to compute the precondition for t_inc */
  transformer t_inc = safe_expression_to_transformer(inc_e, transformer_undefined);
 
  pips_internal_error("function is not implemented");
 
  /* Make sure you have the effective statement transformer: it is not
     stored for loops and this is key for nested loops. */
  pre_body = transformer_apply(t_body_star, pre);
  ct_body = complete_statement_transformer(t_body, pre_body, body_s);
 
  (void)complete_any_loop_transformer(t_init, t_enter, t_skip, t_body_star, ct_body, t_continue, t_inc, t_exit);
 
  free_transformer(ct_body);
  free_transformer(pre_body);
  free_transformer(t_init);
  free_transformer(post_init);
  free_transformer(t_skip);
  free_transformer(t_enter);
  free_transformer(t_continue);
  free_transformer(t_exit);
  free_transformer(t_inc);
 
  return tfl;
}

References complete_any_loop_transformer(), complete_statement_transformer(), condition_to_transformer(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, free_transformer(), list_undefined, load_statement_transformer(), pips_internal_error, safe_expression_to_transformer(), transformer_apply(), and transformer_undefined.

Referenced by instruction_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_loop_transformer()

transformer complete_loop_transformer	(	transformer	ltf,
		transformer	pre,
		loop	l
	)

The transformer computed and stored for a loop is useful to compute the loop body precondition, but it is not useful to analyze a higher level construct, which need the loop transformer with the exit condition.

Only Fortran DO loops are handled here. The need for nested WHILE loops has not been identified yet. The index variable is always initialized and then the loop is either entered and exited or not entered

loop body transformer

compute the loop body transformer

Since it is not stored, we need to go down recursively. A way to avoid this would be to always have sequences as loop bodies... Let's hope that perfectly nested loops are neither frequent nor deep!

compute the loop body precondition

You do not need a range to recurse. A full precondition with arguments is expected by complete_loop_transformer(). Maybe, but it's much easier to debug with ranges as they only carry the useful information. And the result is correct for Semantics-New/for03.c and 04.c

The final index incrementation is performed later by add_loop_index_exit_value()

btf = transformer_add_loop_index_incrementation(btf, l, pre);

compute the transformer when the loop is entered: T o T*

Semantics-New/for04.c: this leads to t_enter == empty_transformer because the same conditions on the initial values of cpi and cpj are preserved in both ltf, which is OK, and btf, which is not OK.

add the entry condition

but it seems to be in t already

t_enter = transformer_add_loop_index_initialization(t_enter, l);

It would make sense to apply the incrementation, but this is performed as a side effect by add_loop_index_exit_value(), which avoids unfeasability wrt the final loop bound.

add the exit condition, without any information pre to estimate the increment

FI: oops, pre is used in spite of previous comment

add initialization for the unconditional initialization of the loop index variable

It might be better not to compute useless transformer, but it's more readable that way. Since pre is information free, only loops with constant lower and upper bound and constant increment can benefit from this.

pre cannot be used as such. the loop initialization must be applied first: the previous comment seems to be correct.

Parameters

ltf	tf
pre	re

Definition at line 1927 of file loop.c.

{
  transformer tf = transformer_undefined;
  transformer t_enter = transformer_undefined;
  transformer t_skip = transformer_undefined;
  /* loop body transformer */
  transformer btf = transformer_undefined;
  range r = loop_range(l);
  statement s = loop_body(l);
 
  pips_debug(8,"begin with loop precondition\n");
  ifdebug(8) {
    (void) print_transformer(pre);
    pips_debug(8,"and loop transformer:\n");
    (void) print_transformer(ltf);
  }
 
  /* compute the loop body transformer */
  if(statement_loop_p(s)) {
    /* Since it is not stored, we need to go down recursively. A way to
       avoid this would be to always have sequences as loop
       bodies... Let's hope that perfectly nested loops are neither
       frequent nor deep! */
    loop il = instruction_loop(statement_instruction(s));
    /* compute the loop body precondition */
    transformer raw_ipre = transformer_apply(ltf, pre);
    transformer ipre = transformer_range(raw_ipre);
    ipre = transformer_normalize(ipre, 2);
    /* You do not need a range to recurse. A full precondition with
       arguments is expected by complete_loop_transformer(). Maybe,
       but it's much easier to debug with ranges as they only carry
       the useful information. And the result is correct for
       Semantics-New/for03.c and 04.c */
    transformer st = load_statement_transformer(s);
    btf = complete_loop_transformer(st, ipre, il);
    btf = transformer_normalize(btf, 2);
    free_transformer(ipre);
    free_transformer(raw_ipre);
  }
  else {
    btf = transformer_dup(load_statement_transformer(s));
  }
  /* The final index incrementation is performed later by add_loop_index_exit_value() */
  /* btf = transformer_add_loop_index_incrementation(btf, l, pre); */
 
  /* compute the transformer when the loop is entered: T o T* */
  /* Semantics-New/for04.c: this leads to t_enter ==
     empty_transformer because the same conditions on the initial
     values of cpi and cpj are preserved in both ltf, which is OK, and
     btf, which is not OK. */
  t_enter = transformer_combine(transformer_dup(ltf), btf);
 
  ifdebug(8) {
    pips_debug(8, "entered loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add the entry condition */
  /* but it seems to be in t already */
  /* t_enter = transformer_add_loop_index_initialization(t_enter, l); */
 
  /* It would make sense to apply the incrementation, but this is
     performed as a side effect by add_loop_index_exit_value(), which
     avoids unfeasability wrt the final loop bound. */
  /*
  transformer t_inc = transformer_identity();
  t_inc = transformer_add_loop_index_incrementation(t_inc, l, pre);
  t_enter = transformer_combine(t_enter, t_inc);
  */
 
  /* add the exit condition, without any information pre to estimate the
     increment */
  transformer tmp = t_enter;
  /* FI: oops, pre is used in spite of previous comment */
  t_enter = add_loop_index_exit_value(t_enter, l, pre);
  transformer_free(tmp);
 
  ifdebug(8) {
    pips_debug(8, "entered and exited loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add initialization for the unconditional initialization of the loop
     index variable */
  tmp = transformer_undefined_p(pre)?
    transformer_identity() :
    transformer_dup(pre);
  t_skip = add_loop_index_initialization(tmp, l, pre);
  //transformer ipre = transformer_apply(t_skip, pre);
  //transformer ripre = transformer_range(ipre);
  transformer_free(tmp);
  t_skip = add_loop_skip_condition(t_skip, l, pre);
  t_skip = transformer_normalize(t_skip, 2);
 
  ifdebug(8) {
    pips_debug(8, "skipped loop transformer t_skip=\n");
    fprint_transformer(stderr, t_skip, (get_variable_name_t) external_value_name);
  }
 
  /* It might be better not to compute useless transformer, but it's more
     readable that way. Since pre is information free, only loops with
     constant lower and upper bound and constant increment can benefit
     from this. */
  /* pre cannot be used as such. the loop initialization must be
     applied first: the previous comment seems to be correct. */
  // if(empty_range_wrt_precondition_p(r, ripre)) {
  if(empty_range_wrt_precondition_p(r, pre)) {
    tf = t_skip;
    free_transformer(t_enter);
  }
  // else if(non_empty_range_wrt_precondition_p(r, ripre)) {
  else if(non_empty_range_wrt_precondition_p(r, pre)) {
    tf = t_enter;
    free_transformer(t_skip);
  }
  else {
    tf = transformer_convex_hull(t_enter, t_skip);
    free_transformer(t_enter);
    free_transformer(t_skip);
  }
  //free_transformer(ipre);
  //free_transformer(ripre);
 
  tf = transformer_normalize(tf, 2);
 
  ifdebug(8) {
    pips_debug(8, "full refined loop transformer tf=\n");
    fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
    pips_debug(8, "end\n");
  }
 
  return tf;
}

References add_loop_index_exit_value(), add_loop_index_initialization(), add_loop_skip_condition(), empty_range_wrt_precondition_p(), external_value_name(), fprint_transformer(), free_transformer(), ifdebug, instruction_loop, load_statement_transformer(), loop_body, loop_range, non_empty_range_wrt_precondition_p(), pips_debug, print_transformer, statement_instruction, statement_loop_p(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_free(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by complete_loop_transformer_list(), generic_complete_statement_transformer(), and old_complete_whileloop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_loop_transformer_list()

list complete_loop_transformer_list	(	transformer	ltf,
		transformer	pre,
		loop	l
	)

loop body transformer

compute the loop body transformer

Since it is not stored, we need to go down recursively. A way to avoid this would be to always have sequences as loop bodies... Let's hope that perfectly nested loops are neither frequent nor deep!

compute the loop body precondition

You do not need a range to recurse. A full precondition with arguments is expected by complete_loop_transformer().

The final index incrementation is performed later by add_loop_index_exit_value()

btf = transformer_add_loop_index_incrementation(btf, l, pre);

compute the transformer when the loop is entered: T o T*

add the entry condition

but it seems to be in t already

t_enter = transformer_add_loop_index_initialization(t_enter, l);

It would make sense to apply the incrementation, but this is performed as a side effect by add_loop_index_exit_value(), which avoids unfeasability wrt the final loop bound.

add the exit condition, without any information pre to estimate the increment

FI: oops, pre is used in spite of previous comment

add initialization for the unconditional initialization of the loop index variable

It might be better not to compute useless transformer, but it's more readable that way. Since pre is information free, only loops with constant lower and upper bound and constant increment can benefit from this.

Parameters

ltf	tf
pre	re

Definition at line 2061 of file loop.c.

{
  list tfl = list_undefined;
  transformer tf = transformer_undefined;
  transformer t_enter = transformer_undefined;
  transformer t_skip = transformer_undefined;
  /* loop body transformer */
  transformer btf = transformer_undefined;
  range r = loop_range(l);
  statement s = loop_body(l);
 
  pips_internal_error("Function not implemented.");
 
  pips_debug(8,"begin with loop precondition\n");
  ifdebug(8) {
    (void) print_transformer(pre);
    pips_debug(8,"and loop transformer:\n");
    (void) print_transformer(ltf);
  }
 
  /* compute the loop body transformer */
  if(statement_loop_p(s)) {
    /* Since it is not stored, we need to go down recursively. A way to
       avoid this would be to always have sequences as loop
       bodies... Let's hope that perfectly nested loops are neither
       frequent nor deep! */
    loop il = instruction_loop(statement_instruction(s));
    /* compute the loop body precondition */
    transformer raw_ipre = transformer_apply(ltf, pre);
    //transformer ipre = transformer_range(raw_ipre);
    //ipre = transformer_normalize(ipre, 2);
    /* You do not need a range to recurse. A full precondition with
       arguments is expected by complete_loop_transformer(). */
    btf = complete_loop_transformer(load_statement_transformer(s), raw_ipre, il);
    btf = transformer_normalize(btf, 2);
    //free_transformer(ipre);
    free_transformer(raw_ipre);
  }
  else {
    btf = transformer_dup(load_statement_transformer(s));
  }
  /* The final index incrementation is performed later by add_loop_index_exit_value() */
  /* btf = transformer_add_loop_index_incrementation(btf, l, pre); */
 
  /* compute the transformer when the loop is entered: T o T* */
  t_enter = transformer_combine(transformer_dup(ltf), btf);
 
  ifdebug(8) {
    pips_debug(8, "entered loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add the entry condition */
  /* but it seems to be in t already */
  /* t_enter = transformer_add_loop_index_initialization(t_enter, l); */
 
  /* It would make sense to apply the incrementation, but this is
     performed as a side effect by add_loop_index_exit_value(), which
     avoids unfeasability wrt the final loop bound. */
  /*
  transformer t_inc = transformer_identity();
  t_inc = transformer_add_loop_index_incrementation(t_inc, l, pre);
  t_enter = transformer_combine(t_enter, t_inc);
  */
 
  /* add the exit condition, without any information pre to estimate the
     increment */
  transformer tmp = t_enter;
  /* FI: oops, pre is used in spite of previous comment */
  t_enter = add_loop_index_exit_value(t_enter, l, pre);
  transformer_free(tmp);
 
  ifdebug(8) {
    pips_debug(8, "entered and exited loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add initialization for the unconditional initialization of the loop
     index variable */
  tmp = transformer_undefined_p(pre)?
    transformer_identity() :
    transformer_dup(pre);
  t_skip = add_loop_index_initialization(tmp, l, pre);
  transformer_free(tmp);
  t_skip = add_loop_skip_condition(t_skip, l, pre);
  t_skip = transformer_normalize(t_skip, 2);
 
  ifdebug(8) {
    pips_debug(8, "skipped loop transformer t_skip=\n");
    fprint_transformer(stderr, t_skip, (get_variable_name_t) external_value_name);
  }
 
  /* It might be better not to compute useless transformer, but it's more
     readable that way. Since pre is information free, only loops with
     constant lower and upper bound and constant increment can benefit
     from this. */
  if(empty_range_wrt_precondition_p(r, pre)) {
    tf = t_skip;
    free_transformer(t_enter);
  }
  else if(non_empty_range_wrt_precondition_p(r, pre)) {
    tf = t_enter;
    free_transformer(t_skip);
  }
  else {
    tf = transformer_convex_hull(t_enter, t_skip);
    free_transformer(t_enter);
    free_transformer(t_skip);
  }
 
  tf = transformer_normalize(tf, 2);
 
  ifdebug(8) {
    pips_debug(8, "full refined loop transformer tf=\n");
    fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
    pips_debug(8, "end\n");
  }
 
  return tfl;
}

References add_loop_index_exit_value(), add_loop_index_initialization(), add_loop_skip_condition(), complete_loop_transformer(), empty_range_wrt_precondition_p(), external_value_name(), fprint_transformer(), free_transformer(), ifdebug, instruction_loop, list_undefined, load_statement_transformer(), loop_body, loop_range, non_empty_range_wrt_precondition_p(), pips_debug, pips_internal_error, print_transformer, statement_instruction, statement_loop_p(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_free(), transformer_identity(), transformer_normalize(), transformer_undefined, and transformer_undefined_p.

Referenced by instruction_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_non_identity_statement_transformer()

transformer complete_non_identity_statement_transformer	(	transformer	t,
		transformer	pre,
		statement	s
	)

FI: only implemented for while loops.

Parameters

pre

re

Definition at line 3685 of file ri_to_transformers.c.

{
  return generic_complete_statement_transformer(t, pre, s, false);
}

References generic_complete_statement_transformer().

Here is the call graph for this function:

complete_repeatloop_transformer()

transformer complete_repeatloop_transformer	(	transformer	t_body_star,
		transformer	pre,
		whileloop	wl
	)

Parameters

t_body_star	_body_star
pre	re
wl	l

Definition at line 1910 of file loop.c.

{
  list tl = complete_repeatloop_transformer_list(t_body_star, pre, wl);
  transformer ct = transformer_list_to_transformer(tl);
  return ct;
}

References complete_repeatloop_transformer_list(), and transformer_list_to_transformer().

Referenced by complete_whileloop_transformer(), and generic_complete_statement_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_repeatloop_transformer_list()

list complete_repeatloop_transformer_list	(	transformer	,
		transformer	,
		whileloop
	)

complete_statement_transformer()

transformer complete_statement_transformer	(	transformer	t,
		transformer	pre,
		statement	s
	)

Returns the effective transformer ct for a given statement s.

t is the stored transformer. For loops, t is useful to compute the body preconditions but not to compute the loop postcondition. ct can be used to compute the statement s postcondition, no matter what kind of statement s is, and to compute the transformer of a higher-level statement enclosing s.

In other words, load_statement_transformer(s) does not always return a transformer which can be composed with another transformer or applied to a precondition. But statement_to_transformer() always returns such a transformer.

Always allocates a new transformer. This probably creates a memory leak when going up the internal representation because it was originally assumed that the transformer returned recursively was also the transformer stored at a lower level. This is changed because this function calls itself recursively. So now statement_to_transformer() returns a transformer which is not the transformer stored for the statement.

Parameters

pre

re

Definition at line 3677 of file ri_to_transformers.c.

{
  return generic_complete_statement_transformer(t, pre, s, true);
}

References generic_complete_statement_transformer().

Referenced by complete_forloop_transformer(), complete_forloop_transformer_list(), complete_repeatloop_transformer_list(), load_completed_statement_transformer(), new_complete_whileloop_transformer_list(), repeatloop_to_postcondition(), statement_to_transformer(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_whileloop_transformer()

transformer complete_whileloop_transformer	(	transformer	ltf,
		transformer	pre,
		whileloop	wl
	)

FI: I'm not sure this function is useful.

Parameters

ltf	tf
pre	re
wl	l

Definition at line 2183 of file loop.c.

{
  transformer t = transformer_undefined;
  evaluation lt = whileloop_evaluation(wl);
 
  if(evaluation_before_p(lt))
    t = new_complete_whileloop_transformer(ltf, pre, wl, false);
  else
    t = complete_repeatloop_transformer(ltf, pre, wl);
 
  return t;
}

References complete_repeatloop_transformer(), evaluation_before_p, new_complete_whileloop_transformer(), transformer_undefined, and whileloop_evaluation.

Referenced by old_complete_whileloop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

complete_whileloop_transformer_list()

list complete_whileloop_transformer_list	(	transformer	ltf,
		transformer	pre,
		whileloop	wl
	)

Parameters

ltf	tf
pre	re
wl	l

Definition at line 2198 of file loop.c.

{
  list tfl = NIL;
  evaluation lt = whileloop_evaluation(wl);
 
  if(evaluation_before_p(lt))
    tfl = new_complete_whileloop_transformer_list(ltf, pre, wl, false);
  else
    tfl = complete_repeatloop_transformer_list(ltf, pre, wl);
 
  return tfl;
}

References complete_repeatloop_transformer_list(), evaluation_before_p, new_complete_whileloop_transformer_list(), NIL, and whileloop_evaluation.

Referenced by instruction_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_path_transformer()

transformer compute_path_transformer	(	statement	,
		path	,
		path
	)

compute_postcondition()

statement_mapping compute_postcondition	(	statement	stat,
		statement_mapping	post_map,
		statement_mapping	pre_map
	)

statement_mapping compute_postcondition(stat, post_map, pre_map) statement stat; statement_mapping post_map, pre_map;

computes the postcondition mapping post_map from the precondition mapping pre_map and the related statement tree starting from stat. The rule applied is that the postcondition of one statement is the precondition of the following one. The last postcondition is arbitrary set to transformer_identity, what is not enough. (??? should I take the stat transformer?)

the initial postcondition is empty ???

Top-down definition

Parameters

stat	tat
post_map	ost_map
pre_map	re_map

Definition at line 186 of file postcondition.c.

{
    debug_on("SEMANTICS_POSTCONDITION_DEBUG_LEVEL");
    pips_debug(1, "computing!\n");
 
    current_postcondition_map = post_map;
    current_precondition_map = pre_map;
 
    /* the initial postcondition is empty ??? */
    StorePost(stat, transformer_identity());
 
    /* Top-down definition */
    gen_recurse(stat, statement_domain, postcondition_filter, gen_null);
 
    current_precondition_map = hash_table_undefined;
    current_postcondition_map = hash_table_undefined;
 
    debug_off();
    return post_map;
}

References current_postcondition_map, current_precondition_map, debug_off, debug_on, gen_null(), gen_recurse, hash_table_undefined, pips_debug, postcondition_filter(), statement_domain, StorePost, and transformer_identity().

Referenced by set_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

condition_false_wrt_precondition_p()

bool condition_false_wrt_precondition_p	(	expression	c,
		transformer	p
	)

Definition at line 285 of file utils.c.

{
  bool non_empty = false;
 
  non_empty = check_condition_wrt_precondition(c, p, false);
 
  return non_empty;
}

References check_condition_wrt_precondition().

Referenced by old_complete_whileloop_transformer(), and standard_whileloop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

condition_to_transformer()

transformer condition_to_transformer	(	expression	cond,
		transformer	pre,
		bool	veracity
	)

To capture side effects and to add C twist for numerical conditions.

Argument pre may be undefined.

Beware of tricky conditions using the comma or the conditional operator, although they should be handled as the default case, using effects.

upwards should be set to false when computing preconditions (but we have no way to know) or when computing tramsformers in context. And set to true in other cases. upwards is a way to gain execution time at the expense of precision. This speed/accuracy tradeoff has evolved with CPU technology.

If a comma operator is used, the test is the last expression

FI: quid of a conditional operator? e.g. "x>0?1<m:1<n"

FI: quid of assignment operator? e.g. "i = j = k = 1"

FI: we probably need a function tcond = expression_to_condition(cond)

C comparison operators return an integer value

FI: not good when side effects in cond

In case, there are side-effects in the condition. This is very unlikely for standard code and should be simplified with a test to transformer_identity_p(tf)

Make sure you can handle this kind of variable.

This test is added for Semantics-New/transformer01.c which tests a pointer. The underlying bug may still be there when pointers are analyzed by PIPS.

tmpv != 0

tmpv==0

Not yet? We may be in a = c? x : y; or in e1, e2,...; Does it matter?

May be dangerous if this routine is called internally to another routine using temporary variables...

reset_temporary_value_counter();

Parameters

cond	ond
pre	re
veracity	eracity

Definition at line 5348 of file expression.c.

{
  transformer tf = transformer_undefined;
 
  if(expression_cast_p(cond)) {
    expression nc = cast_expression(expression_cast(cond));
    tf = condition_to_transformer(nc, pre, veracity);
  }
  else {
    //list el = expression_to_proper_effects(cond);
    list el = expression_to_proper_constant_path_effects(cond);
    transformer safe_pre = transformer_undefined_p(pre)?
      transformer_identity():
      transformer_range(pre);
    basic eb = basic_of_expression(cond);
    bool relation_p = false;
    /* upwards should be set to false when computing preconditions (but
       we have no way to know) or when computing tramsformers in
       context. And set to true in other cases. upwards is a way to gain
       execution time at the expense of precision. This speed/accuracy
       tradeoff has evolved with CPU technology. */
    bool upwards = false;
    expression tcond = cond; // By default; not true for the comma operations
 
    /* If a comma operator is used, the test is the last expression */
    /* FI: quid of a conditional operator? e.g. "x>0?1<m:1<n" */
    /* FI: quid of assignment operator? e.g. "i = j = k = 1" */
    /* FI: we probably need a function tcond = expression_to_condition(cond) */
    if(expression_call_p(cond)) {
      call c = syntax_call(expression_syntax(cond));
      entity op = call_function(c);
      if(ENTITY_COMMA_P(op)) {
        list args = call_arguments(c);
        tcond = EXPRESSION(CAR(gen_last(args)));
        tf = safe_expression_to_transformer(cond, pre);
      }
    }
    if(transformer_undefined_p(tf)) {
      tf = transformer_identity();
    }
 
    /* C comparison operators return an integer value */
    if(!basic_logical_p(eb) && expression_call_p(tcond)) {
      entity op = call_function(syntax_call(expression_syntax(tcond)));
 
      relation_p = ENTITY_LOGICAL_OPERATOR_P(op);
      //relation_p = ENTITY_RELATIONAL_OPERATOR_P(op);
    }
 
    if(basic_logical_p(eb)) {
      // entity tmpv = make_local_temporary_value_entity_with_basic(eb);
      //tf = logical_expression_to_transformer(tmpv, cond, safe_pre, true);
      //tf = transformer_add_condition_information_updown
      //  (transformer_identity(), cond, safe_pre, veracity, upwards);
      /* FI: not good when side effects in cond */
      //tf = transformer_add_condition_information_updown
      //  (copy_transformer(safe_pre), cond, safe_pre, veracity, upwards);
      transformer ctf = transformer_add_condition_information_updown
        (tf, tcond, safe_pre, veracity, upwards);
      tf = transformer_apply(ctf, safe_pre);
      free_transformer(ctf);
    }
    else if(relation_p) {
      //tf = transformer_add_condition_information_updown
      //  (transformer_identity(), cond, safe_pre, veracity, upwards);
      //tf = transformer_add_condition_information_updown
      //  (copy_transformer(safe_pre), cond, safe_pre, veracity, upwards);
      /* In case, there are side-effects in the condition. This is very
         unlikely for standard code and should be simplified with a
         test to transformer_identity_p(tf) */
      transformer new_pre = transformer_apply(tf, safe_pre);
      transformer new_pre_r = transformer_range(new_pre);
      new_pre_r = transformer_normalize(new_pre_r, 2);
      transformer ctf = transformer_add_condition_information_updown
        (transformer_identity(), tcond, new_pre_r, veracity, upwards);
      transformer_temporary_value_projection(ctf);
      ctf = transformer_normalize(ctf, 2);
      tf = transformer_combine(tf, ctf);
      free_transformer(ctf);
      free_transformer(new_pre);
      free_transformer(new_pre_r);
    }
    else {
      /* Make sure you can handle this kind of variable.
 
         This test is added for Semantics-New/transformer01.c which
         tests a pointer. The underlying bug may still be there when
         pointers are analyzed by PIPS.
      */
      if(analyzed_basic_p(eb)) {
        entity tmpv = make_local_temporary_value_entity_with_basic(eb);
        transformer ctf = safe_any_expression_to_transformer(tmpv, tcond, safe_pre, true);
        tf = transformer_combine(tf, ctf);
        if(veracity) {
          /* tmpv != 0 */
          transformer tf_plus = transformer_add_sign_information(copy_transformer(tf), tmpv, 1);
          transformer tf_minus = transformer_add_sign_information(copy_transformer(tf), tmpv, -1);
 
          ifdebug(8) {
            fprintf(stderr, "tf_plus %p:\n", tf_plus);
            dump_transformer(tf_plus);
            fprintf(stderr, "tf_minus %p:\n", tf_minus);
            dump_transformer(tf_minus);
          }
 
          free_transformer(tf);
          tf = transformer_convex_hull(tf_plus, tf_minus);
          free_transformer(tf_plus);
          free_transformer(tf_minus);
        }
        else {
          /* tmpv==0 */
          tf = transformer_add_sign_information(tf, tmpv, 0);
        }
      }
    }
 
    if(transformer_undefined_p(tf))
      tf = effects_to_transformer(el);
    else {
      /* Not yet? We may be in a = c? x : y; or in e1, e2,...; Does it matter? */
      tf = transformer_temporary_value_projection(tf);
      //reset_temporary_value_counter();
    }
    /* May be dangerous if this routine is called internally to another
       routine using temporary variables... */
    /* reset_temporary_value_counter(); */
 
    gen_full_free_list(el);
    free_basic(eb);
    free_transformer(safe_pre);
  }
 
  return tf;
}

References analyzed_basic_p(), basic_logical_p, basic_of_expression(), call_arguments, call_function, CAR, cast_expression, copy_transformer(), dump_transformer, effects_to_transformer(), ENTITY_COMMA_P, ENTITY_LOGICAL_OPERATOR_P, EXPRESSION, expression_call_p(), expression_cast(), expression_cast_p(), expression_syntax, expression_to_proper_constant_path_effects(), fprintf(), free_basic(), free_transformer(), gen_full_free_list(), gen_last(), ifdebug, make_local_temporary_value_entity_with_basic(), safe_any_expression_to_transformer(), safe_expression_to_transformer(), syntax_call, transformer_add_condition_information_updown(), transformer_add_sign_information(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_temporary_value_projection(), transformer_undefined, and transformer_undefined_p.

Referenced by any_conditional_to_transformer(), complete_forloop_transformer(), complete_forloop_transformer_list(), complete_repeatloop_transformer_list(), conditional_to_transformer(), forloop_to_postcondition(), forloop_to_transformer(), intrinsic_to_transformer(), intrinsic_to_transformer_list(), new_complete_whileloop_transformer_list(), new_whileloop_to_k_transformer(), new_whileloop_to_transformer(), repeatloop_to_postcondition(), repeatloop_to_transformer(), simplify_boolean_expression_with_precondition(), test_to_postcondition(), test_to_transformer(), test_to_transformer_list(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

condition_true_wrt_precondition_p()

bool condition_true_wrt_precondition_p	(	expression	c,
		transformer	p
	)

A condition cannot be tested exactly wrt a precondition You can try to prove that it is always true (because it is never false) or you can try to prove that it is always false (because it is never true).

In both case, you may fail and be unable to decide emptiness or non-emptiness.

Definition at line 276 of file utils.c.

{
  bool empty = false;
 
  empty = check_condition_wrt_precondition(c, p, true);
 
  return empty;
}

References check_condition_wrt_precondition(), and empty.

Referenced by old_complete_whileloop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

conditional_to_transformer()

transformer conditional_to_transformer	(	expression	cond,
		expression	te,
		expression	fe,
		transformer	pre,
		list	ef
	)

FI: not too smart to start with the special case with no value returned, just side-effects...

Parameters

cond	ond
te	e
fe	e
pre	re
ef	f

Definition at line 5488 of file expression.c.

{
  transformer tf = transformer_undefined;
  transformer ttf = condition_to_transformer(cond, pre, true);
  transformer t_pre = transformer_apply(ttf, pre);
  transformer t_pre_r = transformer_range(t_pre);
  transformer tet = safe_expression_to_transformer(te, t_pre_r);
  transformer ftf = condition_to_transformer(cond, pre, false);
  transformer f_pre = transformer_apply(ftf, pre);
  transformer f_pre_r = transformer_range(f_pre);
  transformer fet = safe_expression_to_transformer(fe, f_pre_r);
 
  ttf = transformer_combine(ttf, tet);
  ftf = transformer_combine(ftf, fet);
  tf = transformer_convex_hull(ttf, ftf);
 
  free_transformer(ttf);
  free_transformer(ftf);
  free_transformer(tet);
  free_transformer(fet);
  free_transformer(t_pre_r);
  free_transformer(f_pre_r);
  free_transformer(t_pre);
  free_transformer(f_pre);
 
  if(transformer_undefined_p(tf))
    tf = effects_to_transformer(ef);
  return tf;
}

References condition_to_transformer(), effects_to_transformer(), free_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by intrinsic_to_transformer(), and intrinsic_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

cumulated_effects_map_print()

void cumulated_effects_map_print

(

void

)

ca n'a rien a` faire ici, et en plus, il serait plus inte'ressant d'avoir une fonction void statement_map_print(statement_mapping htp)

hash_table_print_header (htp,f);

Definition at line 1549 of file dbm_interface.c.

{
    FILE * f =stderr;
    statement_effects htp = get_cumulated_rw_effects();
 
    /* hash_table_print_header (htp,f); */
 
    STATEMENT_EFFECTS_MAP(k, v, {
        fprintf(f, "\n\n%td", statement_ordering((statement) k));
        print_effects( effects_effects(v));
    },
      htp);
}

References effects_effects, f(), fprintf(), get_cumulated_rw_effects(), print_effects, STATEMENT_EFFECTS_MAP, and statement_ordering.

Here is the call graph for this function:

cycle_to_flow_sensitive_postconditions_or_transformers()

transformer cycle_to_flow_sensitive_postconditions_or_transformers	(	list	partition,
		unstructured	ndu,
		hash_table	ancestor_map,
		hash_table	scc_map,
		control_mapping	fix_point_map,
		transformer	e_pre,
		transformer	n_pre,
		hash_table	control_postcondition_map,
		bool	postcondition_p
	)

Compute transformers or preconditions.

Parameters

partition	artition
ndu	du
ancestor_map	ncestor_map
scc_map	cc_map
fix_point_map	ix_point_map
e_pre	_pre
n_pre	_pre
control_postcondition_map	ontrol_postcondition_map
postcondition_p	ostcondition_p

Definition at line 1744 of file unstructured.c.

{
  transformer tf = transformer_undefined;
 
  tf = dag_or_cycle_to_flow_sensitive_postconditions_or_transformers
    (partition, ndu, ancestor_map, scc_map, fix_point_map, e_pre, n_pre,
     control_postcondition_map, postcondition_p, false);
 
  return tf;
}

References dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), and transformer_undefined.

Referenced by process_ready_node().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_or_cycle_to_flow_sensitive_postconditions_or_transformers()

transformer dag_or_cycle_to_flow_sensitive_postconditions_or_transformers	(	list	partition,
		unstructured	ndu,
		hash_table	ancestor_map,
		hash_table	scc_map,
		control_mapping	fix_point_map,
		transformer	e_pre,
		transformer	n_pre,
		hash_table	control_postcondition_map,
		bool	postcondition_p,
		bool	is_dag
	)

Should ndu be a dag or a cycle?

forward reachable nodes in u

The whole business could be simplified by using a larger definition of "to_be_processed".

wide_forward_control_map_get_blocs(unstructured_control(u), &to_be_processed);

Take care of unreachable nodes

FI: Wouldn't it be better to clean up the unstructured? Aren't they supposed to be clean? This piece of code contradict get_control_precondition() where the problem could be fixed at a lower cost. Another place where the problem is handled is ready_to_be_processed_p(), but it is called on still_to_be_processed, which does not take into account unreachable nodes. To make things worse, the daVinci printouts only include, most of the time, only reachable nodes.

Take care of the entry node

The entry node must be handled in a specific way... but not in the specific way implemented in process_ready_node() which only deals with DAG's. The entry node cannot be a meaningless control node.

Since control nodes have been replicated, it is difficult to predict if es has already been processed or not.

make_control_postcondition_map();

Take care of the forward reachable control nodes

process forward

right away because c's cdr might be modified

Compute fix point transformer for cycle

Compute the convex hull of the paths associated to each predecessor of the entry. Since this is a cycle, preds cannot be empty.

transformer fp_tf_plus = transformer_undefined;

If an entry range is known, do not use it as there may be more than one occurence of the cycle and more than one entry range. Keep this refinement to the precondition computation phase? It might be too late. The the data structure should be change to store more than one fix point per cycle.

Not convincing anyway: you should apply fp_tf_plus to e_pre for the next two lines to make sense.

Use the + fix point to preserve more information about the output and do not forget to perform a convex hull when you need a * fix point in process_ready_node()

Instead of computing the convex hull over all paths before computing the fix point, compute the fix point of a list of transformers.

e may have many synonyms

fix point are unique for all replication of a cycle

each cycle replication has its own fix-point

We might want to return the corresponding fix point?

Parameters

partition	artition
ndu	du
ancestor_map	ncestor_map
scc_map	cc_map
fix_point_map	ix_point_map
e_pre	_pre
n_pre	_pre
control_postcondition_map	ontrol_postcondition_map
postcondition_p	ostcondition_p
is_dag	s_dag

Definition at line 1509 of file unstructured.c.

{
  transformer tf = transformer_undefined;
  list to_be_processed = NIL; /* forward reachable nodes in u */
  list still_to_be_processed = NIL;
  list already_processed = NIL;
  list cannot_be_reached = NIL;
 
  ifdebug(2) {
    pips_debug(2, "Begin for unstructured %p with e_pre=%p:\n", ndu, e_pre);
    print_transformer(e_pre);
  }
 
  /* The whole business could be simplified by using a larger definition of "to_be_processed". */
  /* wide_forward_control_map_get_blocs(unstructured_control(u), &to_be_processed); */
  forward_control_map_get_blocs(unstructured_control(ndu), &to_be_processed);
  control_map_get_blocs(unstructured_control(ndu), &cannot_be_reached);
  still_to_be_processed = gen_copy_seq(to_be_processed);
  gen_list_and_not(&cannot_be_reached, to_be_processed);
 
  /* Take care of unreachable nodes */
 
  if(!ENDP(cannot_be_reached)) {
    /* FI: Wouldn't it be better to clean up the unstructured? Aren't they
       supposed to be clean? This piece of code contradict
       get_control_precondition() where the problem could be fixed at a
       lower cost. Another place where the problem is handled is
       ready_to_be_processed_p(), but it is called on
       still_to_be_processed, which does not take into account unreachable
       nodes. To make things worse, the daVinci printouts only include,
       most of the time, only reachable nodes. */
    ifdebug(3) {
      pips_debug(3, "Process unreachable nodes in unstructured %p\n", ndu);
      print_control_node_unss_sem(cannot_be_reached);
    }
    MAP(CONTROL, cbrc, {
      if(!meaningless_control_p(cbrc)) {
        transformer etf = transformer_empty();
        store_control_postcondition(cbrc, etf, control_postcondition_map);
      }
    }, cannot_be_reached);
    gen_free_list(cannot_be_reached);
    cannot_be_reached = list_undefined;
  }
 
  pips_assert("Node lists are defined", !list_undefined_p(to_be_processed)
              && !list_undefined_p(still_to_be_processed) && ENDP(already_processed) );
 
  /* Take care of the entry node */
 
  if(!is_dag && !postcondition_p) {
    /* The entry node must be handled in a specific way... but not in the
       specific way implemented in process_ready_node() which only deals
       with DAG's. The entry node cannot be a meaningless control node. */
    control e = unstructured_control(ndu);
    statement es = control_statement(e);
    transformer etf = load_statement_transformer(es);
    transformer init = transformer_identity();
    transformer post = transformer_undefined;
 
    /* Since control nodes have been replicated, it is difficult to
       predict if es has already been processed or not. */
    if(transformer_undefined_p(etf)) {
      etf = statement_to_transformer(es, n_pre);
    }
 
    post = transformer_apply(etf, init);
 
    store_control_postcondition(e, post, control_postcondition_map);
 
    gen_remove(&still_to_be_processed, e);
    already_processed = CONS(CONTROL, e, NIL);
  }
 
  /* make_control_postcondition_map(); */
 
  /* Take care of the forward reachable control nodes */
 
  while(!ENDP(still_to_be_processed)) {
    int count = -1;
    do {
      list l = list_undefined;
 
      /* process forward */
      pips_debug(5, "Try forward processing for\n");
      ifdebug(2) print_control_node_unss_sem(still_to_be_processed);
 
      count = 0;
      for(l=still_to_be_processed; !ENDP(l); ) {
        control c = CONTROL(CAR(l));
        POP(l); /* right away because c's cdr might be modified */
        if(meaningless_control_p(c)
           || ready_to_be_processed_p(c, to_be_processed,
                                      still_to_be_processed,
                                      already_processed,
                                      control_postcondition_map)) {
          if(!meaningless_control_p(c)) {
            process_ready_node(c, e_pre, n_pre, ndu, control_postcondition_map,
                               ancestor_map, scc_map, partition, fix_point_map, postcondition_p);
          }
          gen_remove(&still_to_be_processed, c);
          already_processed = gen_append(already_processed, CONS(CONTROL, c, NIL));
          count++;
        }
      }
    } while(count!=0);
    if(!ENDP(still_to_be_processed)) {
      pips_assert("still_to_be_processed is empty because of the Bourdoncle's restructuring",
                  false);
    }
  }
 
  /* Compute fix point transformer for cycle */
  if(!is_dag && !postcondition_p) {
    transformer fp_tf = transformer_undefined;
    control e = unstructured_control(ndu);
    list preds = control_predecessors(e);
    control e_a = control_undefined;
    // FI: we also need SEMANTICS_USE_DERIVATIVE_LIST = TRUE
    // but this should be soon the default option
    if(!get_bool_property("SEMANTICS_USE_TRANSFORMER_LISTS")) {
      /* Compute the convex hull of the paths associated to each predecessor
         of the entry. Since this is a cycle, preds cannot be empty. */
      control pred = CONTROL(CAR(preds));
      transformer path_tf =
        load_arc_precondition(pred, e, control_postcondition_map);
      /* transformer fp_tf_plus = transformer_undefined; */
 
      POP(preds);
      FOREACH(CONTROL, pred, preds) {
        transformer pred_tf =
          load_arc_precondition(pred, e, control_postcondition_map);
        transformer old_path_tf = path_tf;
 
        pips_assert("Partial path transformer pred_tf is defined",
                    !transformer_undefined_p(pred_tf));
        path_tf = transformer_convex_hull(old_path_tf, pred_tf);
        free_transformer(old_path_tf);
      }
 
      fp_tf =  (*transformer_fix_point_operator)(path_tf);
      /* If an entry range is known, do not use it as there may be more than
         one occurence of the cycle and more than one entry range. Keep this
         refinement to the precondition computation phase? It might be too
         late. The the data structure should be change to store more than
         one fix point per cycle.  */
      /* Not convincing anyway: you should apply fp_tf_plus to e_pre for the
         next two lines to make sense. */
      /* Use the + fix point to preserve more information about the output
         and do not forget to perform a convex hull when you need a * fix
         point in process_ready_node() */
      fp_tf = transformer_combine(fp_tf, path_tf);
      /*
        fp_tf = transformer_convex_hull(fp_tf_plus, e_pre);
      */
      free_transformer(path_tf);
    }
    else {
      /* Instead of computing the convex hull over all paths before
         computing the fix point, compute the fix point of a list of
         transformers. */
      list tl = NIL;
      FOREACH(CONTROL, pred, preds) {
        transformer pred_tf =
          load_arc_precondition(pred, e, control_postcondition_map);
        tl = CONS(TRANSFORMER, pred_tf, tl);
      }
      fp_tf = transformer_list_transitive_closure_plus(tl);
      gen_free_list(tl);
    }
 
    /* e may have many synonyms */
 
    if(!get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
      /* fix point are unique for all replication of a cycle */
      e_a = control_to_ancestor(e, ancestor_map);
    }
    else {
      /* each cycle replication has its own fix-point */
      e_a = e;
    }
    store_control_fix_point(e_a, fp_tf, fix_point_map);
 
    /* We might want to return the corresponding fix point? */
    tf = fp_tf;
  }
 
  gen_free_list(to_be_processed);
  to_be_processed = list_undefined;
  gen_free_list(still_to_be_processed);
  still_to_be_processed = list_undefined;
  gen_free_list(already_processed);
  already_processed = list_undefined;
 
  ifdebug(2) {
    pips_debug(2, "End for %s of %s %p with entry node %s and with transformer %p\n",
               postcondition_p? "postcondition" : "transformer",
               is_dag? "dag" : "cycle", ndu,
               statement_identification(control_statement(unstructured_control(ndu))), tf);
    print_transformer(tf);
  }
 
  return tf;
}

References CAR, CONS, CONTROL, control_map_get_blocs(), control_predecessors, control_statement, control_to_ancestor(), control_undefined, count, ENDP, FOREACH, forward_control_map_get_blocs(), free_transformer(), gen_append(), gen_copy_seq(), gen_free_list(), gen_list_and_not(), gen_remove(), get_bool_property(), ifdebug, init, list_undefined, list_undefined_p, load_arc_precondition(), load_statement_transformer(), MAP, meaningless_control_p(), NIL, pips_assert, pips_debug, POP, print_control_node_unss_sem(), print_transformer, process_ready_node(), ready_to_be_processed_p(), statement_identification(), statement_to_transformer(), store_control_fix_point(), store_control_postcondition(), TRANSFORMER, transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_empty(), transformer_identity(), transformer_list_transitive_closure_plus(), transformer_undefined, transformer_undefined_p, and unstructured_control.

Referenced by cycle_to_flow_sensitive_postconditions_or_transformers(), and dag_to_flow_sensitive_postconditions_or_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

dag_to_flow_sensitive_postconditions_or_transformers()

transformer dag_to_flow_sensitive_postconditions_or_transformers	(	list	partition,
		unstructured	ndu,
		hash_table	ancestor_map,
		hash_table	scc_map,
		control_mapping	fix_point_map,
		transformer	e_pre,
		transformer	n_pre,
		hash_table	control_postcondition_map,
		bool	postcondition_p
	)

Compute transformers or preconditions.

Parameters

partition	artition
ndu	du
ancestor_map	ncestor_map
scc_map	cc_map
fix_point_map	ix_point_map
e_pre	_pre
n_pre	_pre
control_postcondition_map	ontrol_postcondition_map
postcondition_p	ostcondition_p

Definition at line 1724 of file unstructured.c.

{
  transformer tf = transformer_undefined;
 
  tf = dag_or_cycle_to_flow_sensitive_postconditions_or_transformers
    (partition, ndu, ancestor_map, scc_map, fix_point_map, e_pre, n_pre,
     control_postcondition_map, postcondition_p, true);
 
  return tf;
}

References dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), and transformer_undefined.

Referenced by unstructured_to_flow_sensitive_postconditions_or_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

data_to_precondition()

transformer data_to_precondition

(

entity

m

)

restricted to variables with effects.

Definition at line 526 of file ri_to_preconditions.c.

{
  list lef = load_module_intraprocedural_effects(m);
  list le = effects_to_entity_list(lef);
  transformer pre = data_to_prec_for_variables(m, le);
  gen_free_list(le);
  return pre;
}

References data_to_prec_for_variables(), effects_to_entity_list(), gen_free_list(), and load_module_intraprocedural_effects().

Referenced by generic_module_name_to_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

declaration_to_transformer()

transformer declaration_to_transformer	(	entity	v,
		transformer	pre
	)

Note: initializations of static variables are not used as transformers but to initialize the program precondition.

It is not assumed that entity_has_values_p(v)==TRUE A write effect on the declared variable is assumed as required by Beatrice Creusillet for region computation.

if(place_holder_variable_p(v)) {

tf = transformer_identity();

}

FI: the initialization expression might have relevant side-effects? This could ba handled by generalizing variable_to_initial_expression() and by returning expression_undefined incase of failure instead of aborting.

Use the dimension expressions and the initial value

add type information because it will not be done later since declarations with no initialization lead to an identity transformer

Parameters

pre

re

Definition at line 580 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
 
  pips_debug(8, "Transformer for declaration of \"%s\"\n", entity_name(v));
 
  // FI: should not be useful here
  /* if(place_holder_variable_p(v)) { */
  /*   tf = transformer_identity(); */
  /* } */
  if(false && !entity_has_values_p(v)) {
    /* FI: the initialization expression might have relevant
       side-effects? This could ba handled by generalizing
       variable_to_initial_expression() and by returning
       expression_undefined incase of failure instead of aborting. */
    tf = transformer_identity();
  }
  else if(variable_static_p(v)) {
    if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"))
      tf = transformer_range(pre);
    else
      tf = transformer_identity();
  }
  else {
    /* Use the dimension expressions and the initial value */
    transformer prer = transformer_range(pre);
    transformer dt = dimensions_to_transformer(v, prer);
    free_transformer(prer);
    transformer npre = transformer_apply(dt, pre);
    transformer nr = transformer_range(npre);
    expression ie = variable_initial_expression(v);
    tf = dt;
    if(!expression_undefined_p(ie)) {
      transformer itf = safe_assigned_expression_to_transformer(v, ie, nr);
      tf = transformer_combine(tf, itf);
      free_transformer(itf);
      free_expression(ie);
    }
    else {
      if(entity_has_values_p(v)) {
        /* add type information because it will not be done later
           since declarations with no initialization lead to an
           identity transformer */
        if(get_bool_property("SEMANTICS_USE_TYPE_INFORMATION")
          || get_bool_property("SEMANTICS_USE_TYPE_INFORMATION_IN_PRECONDITIONS")) {
          transformer_add_variable_type_information(tf, v);
        }
      }
   }
    free_transformer(npre);
    free_transformer(nr);
  }
 
  pips_assert("tf is defined", !transformer_undefined_p(tf));
 
  ifdebug(8) {
    pips_debug(8, "Ends with:\n");
    (void) print_transformer(tf);
  }
 
  return tf;
}

References dimensions_to_transformer(), entity_has_values_p(), entity_name, expression_undefined_p, free_expression(), free_transformer(), get_bool_property(), ifdebug, pips_assert, pips_debug, print_transformer, safe_assigned_expression_to_transformer(), transformer_add_variable_type_information(), transformer_apply(), transformer_combine(), transformer_identity(), transformer_range(), transformer_undefined, transformer_undefined_p, variable_initial_expression(), and variable_static_p().

Referenced by declarations_to_transformer(), declarations_to_transformer_list(), and propagate_preconditions_in_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

declaration_to_transformer_list()

list declaration_to_transformer_list	(	entity	v,
		transformer	pre
	)

ri_to_transformer_lists.c

ri_to_transformer_lists.c

This development was prompted by the last example found in the paper by Schrammel and Jeannet at NSAD 2010. See test cases schrammel04, 05 and 06. The minimal goal is to avoid the indentity transformer when performing the convex hull of several transformers.

This could also be useful to automatize the handling of tests within a loop using the technique presented at NSAD 2010 by Ancourt & al. The control structure

"while(c) if(t) T; else F;"

is replaced by

"while(c) {while(c&&t) T; while(c&& !t) F;}".

This replacement could be performed on the equations instead of requiring a program transformation. semantical analysis

phasis 3: compute transformer lists from statements and statement transformers

For refined precondition analysis. Keep track of all control paths within sequences

Francois Irigoin, September 2010 include <stdlib.h> Note: initializations of static variables are not used as transformers but to initialize the program precondition. It is not assumed that entity_has_values_p(v)==true A write effect on the declared variable is assumed as required by Beatrice Creusillet for region computation.

FI: the initialization expression might have relevant side-effects? This could ba handled by generalizing variable_to_initial_expression() and by returning expression_undefined incase of failure instead of aborting.

Use the dimension expressions and the initial value

FI: I preserve the code below in case I have problems with integer typing in the future

Parameters

pre

re

Definition at line 100 of file ri_to_transformer_lists.c.

{
  list tfl = NIL;
  transformer tf = transformer_undefined;
 
  pips_internal_error("Not implemented yet.");
 
  pips_debug(8, "Transformer for declaration of \"%s\"\n", entity_name(v));
 
  if(false && !entity_has_values_p(v)) {
    /* FI: the initialization expression might have relevant
       side-effects? This could ba handled by generalizing
       variable_to_initial_expression() and by returning
       expression_undefined incase of failure instead of aborting. */
    tf = transformer_identity();
  }
  else if(variable_static_p(v)) {
    if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"))
      tf = transformer_range(pre);
    else
      tf = transformer_identity();
  }
  else {
    /* Use the dimension expressions and the initial value */
    transformer dt = dimensions_to_transformer(v, pre);
    transformer npre = transformer_apply(dt, pre);
    expression ie = variable_initial_expression(v);
    transformer itf = safe_assigned_expression_to_transformer(v, ie, npre);
    tf = dt;
    tf = transformer_combine(tf, itf);
    free_expression(ie);
  }
 
  pips_assert("tf is defined", !transformer_undefined_p(tf));
 
  /* FI: I preserve the code below in case I have problems with
     integer typing in the future*/
  /*
  if(entity_has_values_p(v) && !variable_static_p(v)) {
    value vv = entity_initial(v);
    if(value_unknown_p(vv)) {
      tf = transformer_identity();
    }
    else if (value_symbolic_p(vv)) {
      pips_internal_error("Unexpected value tag: symbolic");
    }
    else if (value_constant_p(vv)) {
      tf = transformer_identity();
      //  SG: quickly fix this, unsure about the meaning
      //pips_internal_error("Unexpected value tag: constant");
    }
    else if (value_expression_p(vv)) {
      expression e = value_expression(vv);
      basic eb = basic_of_expression(e);
      type vt = ultimate_type(entity_type(v));
      basic vb = variable_basic(type_variable(vt));
 
      if(same_basic_p(eb, vb)) {
        tf = safe_any_expression_to_transformer(v, e, pre, false);
        tf = transformer_temporary_value_projection(tf);
      }
      else {
        if(basic_int_p(eb) && basic_int_p(vb)) {
          int i1 = basic_int(eb);
          int i2 = basic_int(vb);
          if(ABS(i1-i2)==10) {
            tf = safe_any_expression_to_transformer(v, e, pre, false);
            tf = transformer_temporary_value_projection(tf);
            semantics_user_warning("Possible conversion issue between signed and"
                              " unsigned int\n");
          }
          else {
            tf = safe_any_expression_to_transformer(v, e, pre, false);
            tf = transformer_temporary_value_projection(tf);
            semantics_user_warning("Possible conversion issue between diffent kinds"
                              " of  ints and/or char (%dd and %d)\n", i1, i2);
          }
        }
        else {
          //list el = expression_to_proper_effects(e);
          list el = expression_to_proper_constant_path_effects(e);
 
          semantics_user_warning("Type mismatch detected in initialization expression."
                            " May be due to overloading and/or implicit confusion"
                            " between logical and integer in C\n");
          tf = effects_to_transformer(el);
        }
      }
    }
    else {
      pips_internal_error("Unexpected value tag");
    }
  }
  else {
    tf = transformer_identity();
  }
  */
 
  ifdebug(8) {
    pips_debug(8, "Ends with:\n");
    (void) print_transformers(tfl);
  }
 
  return tfl;
}

References dimensions_to_transformer(), entity_has_values_p(), entity_name, free_expression(), get_bool_property(), ifdebug, NIL, pips_assert, pips_debug, pips_internal_error, print_transformers(), safe_assigned_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_identity(), transformer_range(), transformer_undefined, transformer_undefined_p, variable_initial_expression(), and variable_static_p().

Here is the call graph for this function:

declarations_to_transformer()

transformer declarations_to_transformer	(	list	dl,
		transformer	pre
	)

For C declarations.

Very close to a block_to_transformer() as declarations can be seen as a sequence of assignments.

Note: initialization of static variables are not taken into account. They must be used for summary preconditions.

post = transformer_safe_normalize(post, 4);

post = transformer_safe_normalize(post, 4);

btf = transformer_normalize(btf, 4);

Parameters

dl	l
pre	re

Definition at line 649 of file ri_to_transformers.c.

{
  entity v = entity_undefined;
  transformer btf = transformer_undefined;
  transformer stf = transformer_undefined;
  transformer post = transformer_undefined;
  transformer next_pre = transformer_undefined;
  list l = dl;
 
  pips_debug(8,"begin\n");
 
  if(ENDP(l))
    btf = transformer_identity();
  else {
    v = ENTITY(CAR(l));
    stf = declaration_to_transformer(v, pre);
    post = transformer_safe_apply(stf, pre);
/*     post = transformer_safe_normalize(post, 4); */
    post = transformer_safe_normalize(post, 2);
    btf = transformer_dup(stf);
    for (POP(l) ; !ENDP(l); POP(l)) {
      v = ENTITY(CAR(l));
      if(!transformer_undefined_p(next_pre))
        free_transformer(next_pre);
      next_pre = transformer_range(post);
      stf = declaration_to_transformer(v, next_pre);
      post = transformer_safe_apply(stf, next_pre);
      free_transformer(next_pre);
      next_pre = transformer_undefined; // FI: works even without this...
/*       post = transformer_safe_normalize(post, 4); */
      post = transformer_safe_normalize(post, 2);
      btf = transformer_combine(btf, stf);
/*       btf = transformer_normalize(btf, 4); */
      btf = transformer_normalize(btf, 2);
 
      ifdebug(1)
        pips_assert("btf is a consistent transformer", transformer_consistency_p(btf));
      pips_assert("post is a consistent transformer if pre is defined",
                    transformer_undefined_p(pre) || transformer_consistency_p(post));
    }
    free_transformer(post);
  }
 
  pips_debug(8, "end\n");
  return btf;
}

References CAR, declaration_to_transformer(), ENDP, ENTITY, entity_undefined, free_transformer(), ifdebug, pips_assert, pips_debug, POP, stf(), transformer_combine(), transformer_consistency_p(), transformer_dup(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_safe_apply(), transformer_safe_normalize(), transformer_undefined, and transformer_undefined_p.

Referenced by statement_to_postcondition(), statement_to_transformer(), and statement_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

declarations_to_transformer_list()

list declarations_to_transformer_list	(	list	dl,
		transformer	pre
	)

For C declarations.

Very close to a block_to_transformer() as declarations can be seen as a sequence of assignments.

Note: initialization of static variables are not taken into account. They must be used for summary preconditions.

post = transformer_safe_normalize(post, 4);

post = transformer_safe_normalize(post, 4);

btf = transformer_normalize(btf, 4);

Parameters

dl	l
pre	re

Definition at line 212 of file ri_to_transformer_lists.c.

{
  list tfl = list_undefined;
  entity v = entity_undefined;
  transformer btf = transformer_undefined;
  transformer stf = transformer_undefined;
  transformer post = transformer_undefined;
  transformer next_pre = transformer_undefined;
  list l = dl;
 
  // May never be useful
  pips_internal_error("Not implemented yet.");
 
  pips_debug(8,"begin\n");
 
  if(ENDP(l))
    btf = transformer_identity();
  else {
    v = ENTITY(CAR(l));
    stf = declaration_to_transformer(v, pre);
    post = transformer_safe_apply(stf, pre);
/*     post = transformer_safe_normalize(post, 4); */
    post = transformer_safe_normalize(post, 2);
    btf = transformer_dup(stf);
    for (POP(l) ; !ENDP(l); POP(l)) {
      v = ENTITY(CAR(l));
      if(!transformer_undefined_p(next_pre))
        free_transformer(next_pre);
      next_pre = transformer_range(post);
      stf = declaration_to_transformer(v, next_pre);
      post = transformer_safe_apply(stf, next_pre);
      free_transformer(next_pre);
      next_pre = transformer_undefined; // FI: works even without this...
/*       post = transformer_safe_normalize(post, 4); */
      post = transformer_safe_normalize(post, 2);
      btf = transformer_combine(btf, stf);
/*       btf = transformer_normalize(btf, 4); */
      btf = transformer_normalize(btf, 2);
 
      ifdebug(1)
        pips_assert("btf is a consistent transformer", transformer_consistency_p(btf));
      pips_assert("post is a consistent transformer if pre is defined",
                    transformer_undefined_p(pre) || transformer_consistency_p(post));
    }
    free_transformer(post);
  }
 
  pips_debug(8, "end\n");
  return tfl;
}

References CAR, declaration_to_transformer(), ENDP, ENTITY, entity_undefined, free_transformer(), ifdebug, list_undefined, pips_assert, pips_debug, pips_internal_error, POP, stf(), transformer_combine(), transformer_consistency_p(), transformer_dup(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_safe_apply(), transformer_safe_normalize(), transformer_undefined, and transformer_undefined_p.

Here is the call graph for this function:

delete_statement_postcondition()

void delete_statement_postcondition

(

statement

)

delete_statement_precondition()

void delete_statement_precondition

(

statement

)

delete_statement_semantic()

void delete_statement_semantic

(

statement

)

delete_statement_total_precondition()

void delete_statement_total_precondition

(

statement

)

delete_statement_transformer()

void delete_statement_transformer

(

statement

)

dimensions_to_transformer()

transformer dimensions_to_transformer	(	entity	v,
		transformer	pre
	)

Assumes that entity_has_values_p(v) holds.

FI: this should be done for all variables, regardless of their types.

Parameters

pre

re

Definition at line 535 of file ri_to_transformers.c.

{
  transformer dt = transformer_identity();
  type vt = entity_basic_concrete_type(v);
 
  if(type_variable_p(vt)) {
    list dl = variable_dimensions(type_variable(vt)); // dimension list
    if(!ENDP(dl)) { // to save a copy and to simplify debugging
      transformer cpre = copy_transformer(pre);
 
      FOREACH(DIMENSION, d, dl) {
        expression l = dimension_lower(d);
        expression u = dimension_upper(d);
        transformer lt = safe_expression_to_transformer(l, cpre);
        transformer lpre = transformer_apply(lt, pre);
        transformer lpre_r = transformer_range(lpre);
        transformer ut = safe_expression_to_transformer(u, lpre_r);
        transformer upre = transformer_apply(ut, lpre);
 
        free_transformer(cpre);
        cpre = transformer_range(upre);
        free_transformer(upre);
        free_transformer(lpre);
        free_transformer(lpre_r);
 
        dt = transformer_combine(transformer_combine(dt, lt), ut);
        free_transformer(lt);
        free_transformer(ut);
      }
      free_transformer(cpre);
    }
    else {
      // FI: equivalent to copy_transformer(pre) I believe
      dt = transformer_apply(dt, pre);
    }
  }
 
  return dt;
}

References copy_transformer(), DIMENSION, dimension_lower, dimension_upper, ENDP, entity_basic_concrete_type(), FOREACH, free_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_identity(), transformer_range(), type_variable, type_variable_p, and variable_dimensions.

Referenced by declaration_to_transformer(), and declaration_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamic_call_count()

int dynamic_call_count

(

entity

m

)

number of call to m during the current program execution; return 0 if m is never called, either because it's a call graph root or because it was linked by mistake; return -1 if the dynamic call count is unknow, for instance because one of m's call site is located in a loop of unknown bounds; return k when it can be evaluated

I do not know yet; let's return 1 to please the semantic analysis

Definition at line 75 of file misc.c.

{
    /* number of call to m during the current program execution;
       return 0 if m is never called, either because it's a call
       graph root or because it was linked by mistake;
       return -1 if the dynamic call count is unknow, for instance
       because one of m's call site is located in a loop of unknown
       bounds;
       return k when it can be evaluated */
    pips_assert("Entity m is a function with defined code",
                value_code_p(entity_initial(m)));
    /* I do not know yet; let's return 1 to please the semantic analysis */
    pips_internal_error("Not implemented yet, always returns -1.\n");
    return -1;
}

References entity_initial, pips_assert, pips_internal_error, and value_code_p.

dynamic_variables_to_values()

list dynamic_variables_to_values

(

list

list_mod

)

Build the list of values to be projected when the declaration list list_mod is no longer valid because a block is closed/left.

Values for static variables are preserved. Values for heap variables also, in case their values are computed in the future...

This may not be the best algorithm when locations are used because the list of locations may be much longer, especially for arrays, than the list of values appearing in the transformer.

Parameters

list_mod

ist_mod

Definition at line 1007 of file mappings.c.

{
  list list_val = NIL;
 
  FOREACH(ENTITY, e, list_mod) {
    if(entity_has_values_p(e)
       && (variable_dynamic_p(e) || variable_stack_p(e))) {
      entity v_old = entity_to_old_value(e);
      entity v_new = entity_to_new_value(e);
 
      list_val = CONS(ENTITY, v_old, list_val);
      list_val = CONS(ENTITY, v_new, list_val);
    }
  }
  return list_val;
}

References CONS, ENTITY, entity_has_values_p(), entity_to_new_value(), entity_to_old_value(), FOREACH, NIL, variable_dynamic_p(), and variable_stack_p().

Referenced by statement_to_transformer(), and statement_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_to_arguments()

list effects_to_arguments

(

list

fx

)

list of effects

algorithm: keep only write effects on scalar variable with values

Parameters

fx

x

Definition at line 798 of file ri_to_transformers.c.

{
  /* algorithm: keep only write effects on scalar variable with values */
  list args = NIL;
 
  FOREACH(EFFECT, ef, fx) {
    reference r = effect_any_reference(ef);
    action a = effect_action(ef);
    entity e = reference_variable(r);
 
    if(action_write_p(a) && entity_has_values_p(e)) {
      args = arguments_add_entity(args, e);
    }
  }
 
  return args;
}

References action_write_p, arguments_add_entity(), EFFECT, effect_action, effect_any_reference, entity_has_values_p(), FOREACH, NIL, and reference_variable.

Here is the call graph for this function:

effects_to_entity_list()

list effects_to_entity_list

(

list

lef

)

returns an allocated list of entities that appear in lef.

an entity may appear several times.

Parameters

lef

ef

Definition at line 516 of file ri_to_preconditions.c.

{
  list le = NIL;
  MAP(EFFECT, e,
      le = CONS(ENTITY, reference_variable(effect_any_reference(e)), le),
      lef);
  return gen_nreverse(le);
}

References CONS, EFFECT, effect_any_reference, ENTITY, gen_nreverse(), MAP, NIL, and reference_variable.

Referenced by data_to_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_to_transformer()

transformer effects_to_transformer

(

list

e

)

list of effects

Definition at line 474 of file ri_to_transformers.c.

{
  transformer tf = transformer_identity();
  tf =  apply_effects_to_transformer(tf, e, false, expression_undefined);
  return tf;
}

References apply_effects_to_transformer(), expression_undefined, and transformer_identity().

Referenced by add_good_loop_conditions(), add_loop_index_initialization(), any_assign_to_transformer_list(), any_basic_update_to_transformer(), any_basic_update_to_transformer_list(), any_loop_to_k_transformer(), any_scalar_assign_to_transformer(), any_scalar_assign_to_transformer_list(), any_update_to_transformer(), any_update_to_transformer_list(), any_user_call_site_to_transformer(), c_return_to_transformer(), c_user_call_to_transformer(), c_user_function_call_to_transformer(), call_to_transformer(), condition_to_transformer(), conditional_to_transformer(), expression_effects_to_transformer(), expression_to_transformer(), fortran_user_call_to_transformer(), integer_assign_to_transformer(), integer_assign_to_transformer_list(), intrinsic_to_transformer(), intrinsic_to_transformer_list(), load_summary_transformer(), loop_to_transformer(), new_loop_to_transformer(), process_ready_node(), safe_any_expression_to_transformer(), standard_whileloop_to_transformer(), test_to_transformer(), test_to_transformer_list(), unstructured_to_transformer(), and user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

empty_range_wrt_precondition_p()

bool empty_range_wrt_precondition_p	(	range	r,
		transformer	p
	)

A range cannot be tested exactly wrt a precondition You can try to prove that it is empty or you can try to prove that it is not empty.

In both case, you may fail and be unable to decide emptiness or non-emptiness.

Definition at line 112 of file utils.c.

{
  bool empty = false;
 
  empty = check_range_wrt_precondition(r, p, true);
 
  return empty;
}

References check_range_wrt_precondition(), and empty.

Referenced by complete_loop_transformer(), complete_loop_transformer_list(), loop_to_postcondition(), and loop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

eval_condition_wrt_precondition_p()

bool eval_condition_wrt_precondition_p	(	expression	c,
		transformer	pre,
		bool	veracity
	)

Parameters

pre	re
veracity	eracity

Definition at line 5909 of file expression.c.

{
  bool result = false;
  transformer f = transformer_dup(pre);
 
  if(veracity) {
    f = precondition_add_condition_information(f, c, pre, false);
  }
  else {
    f = precondition_add_condition_information(f, c, pre, true);
  }
 
  result = transformer_empty_p(f);
 
  return result;
}

References f(), precondition_add_condition_information(), transformer_dup(), and transformer_empty_p().

Referenced by false_condition_wrt_precondition_p(), and true_condition_wrt_precondition_p().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_and_precondition_to_integer_interval()

void expression_and_precondition_to_integer_interval	(	expression	e,
		transformer	p,
		int *	plb,
		int *	pub
	)

Evaluate expression e in context p, assuming that e is an integer expression.

If p is empty, return an empty interval.

Could be more general, I'm lazy (FI).

precondition p is not feasible

OK, we could do something: add a pseudo-variable equal to expression e and check its min abd max values

we are not handling an affine integer expression

Parameters

plb	lb
pub	ub

Definition at line 325 of file utils.c.

{
  normalized n = NORMALIZE_EXPRESSION(e);
 
  if(normalized_linear_p(n)) {
    Pvecteur v = (Pvecteur) normalized_linear(n);
    if(vect_constant_p(v)) {
      if(VECTEUR_NUL_P(v)) {
        *plb = 0;
      }
      else {
        Value vi = vect_coeff(TCST, v);
        *plb = VALUE_TO_INT(vi);
      }
      *pub = *plb;
    }
    else if(vect_size(v) == 1) {
      Psysteme s = transformer_undefined_p(p) ?
        sc_make(CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED) :
        sc_dup((Psysteme) predicate_system(transformer_relation(p)));
      Value lb = VALUE_ZERO, ub = VALUE_ZERO;
      entity var = (entity) vecteur_var(v);
 
      if(sc_minmax_of_variable(s, (Variable) var,
                               &lb, &ub)) {
        *plb = value_min_p(lb)? INT_MIN : VALUE_TO_INT(lb);
        *pub = value_max_p(ub)? INT_MAX : VALUE_TO_INT(ub);
      }
      else {
        /* precondition p is not feasible */
        *plb = 1;
        *pub = 0;
      }
    }
    else {
      /* OK, we could do something: add a pseudo-variable
       * equal to expression e and check its min abd max values
       */
      *plb = INT_MIN;
      *pub = INT_MAX;
    }
  }
  else {
    /* we are not handling an affine integer expression */
    *plb = INT_MIN;
    *pub = INT_MAX;
  }
 
}

References CONTRAINTE_UNDEFINED, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, predicate_system, sc_dup(), sc_make(), sc_minmax_of_variable(), TCST, transformer_relation, transformer_undefined_p, value_max_p, value_min_p, VALUE_TO_INT, VALUE_ZERO, vect_coeff(), vect_constant_p(), vect_size(), VECTEUR_NUL_P, and vecteur_var.

Referenced by add_index_range_conditions(), add_loop_index_exit_value(), add_loop_skip_condition(), check_range_wrt_precondition(), loop_basic_workchunk_to_workchunk(), loop_bound_evaluation_to_transformer(), and modulo_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_effects_to_transformer()

transformer expression_effects_to_transformer

(

expression

expr

)

Parameters

expr

xpr

Definition at line 3465 of file expression.c.

{
  //list el = expression_to_proper_effects(expr);
  list el = expression_to_proper_constant_path_effects(expr);
  transformer tf = effects_to_transformer(el);
 
  gen_full_free_list(el);
  return tf;
}

References effects_to_transformer(), expression_to_proper_constant_path_effects(), and gen_full_free_list().

Referenced by integer_expression_to_transformer(), safe_any_expression_side_effects_to_transformer(), safe_assigned_expression_to_transformer(), safe_integer_expression_to_transformer(), transformer_add_call_condition_information_updown(), and transformer_add_condition_information_updown().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_summary_precondition()

void expression_to_summary_precondition	(	transformer	pre,
		expression	e
	)

Parameters

pre

re

Definition at line 977 of file interprocedural.c.

{
  syntax s = expression_syntax(e);
 
  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    call_to_summary_precondition(pre, c);
  }
}

References call_to_summary_precondition(), expression_syntax, syntax_call, and syntax_call_p.

Referenced by expressions_to_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_transformer()

transformer expression_to_transformer	(	expression	exp,
		transformer	pre,
		list	el
	)

Just to capture side effects as the returned value is ignored.

Example: "(void) inc(&i);".

Or to capture the return of a struct, which cannot be expressed with an atomic return value.

FI: I assume this implies a cast to (void) but I'm wrong for any call to a void function.

FI: I do not remember the meaning of the last parameter

Must be a call to a void function

Wait till it happpens...

FI: is_internal_p has an impact on renaming in simple_affine_to_transformer().

FI: there may be (many) other exceptions with intrinsics...

Fortran intrinsics, such as IOs, are not taken into account because these code should not be executed for Fortran code.

If everything else has failed.

Parameters

exp	xp
pre	re
el	l

Definition at line 5190 of file expression.c.

{
  type et = compute_basic_concrete_type(expression_to_type(exp));
  //entity tmpv = entity_undefined;
  transformer tf = transformer_undefined;
 
  if(type_void_p(et)) {
    /* FI: I assume this implies a cast to (void) but I'm wrong for
       any call to a void function. */
    syntax s_exp = expression_syntax(exp);
 
    if(syntax_cast_p(s_exp)) {
      expression sub_exp = cast_expression(syntax_cast(s_exp));
      type cet = expression_to_type(sub_exp);
 
      if(analyzed_type_p(cet)) {
        entity tmpv = make_local_temporary_value_entity(cet);
 
        /* FI: I do not remember the meaning of the last parameter */
        // it's use in generic_reference_to_transformer
        tf = any_expression_to_transformer(tmpv, sub_exp, pre, false);
      }
      free_type(cet);
    }
    else if(syntax_call_p(s_exp)) {
      /* Must be a call to a void function */
      call c = syntax_call(s_exp);
      //list el = expression_to_proper_effects(exp);;
      list el = expression_to_proper_constant_path_effects(exp);
      tf = call_to_transformer(c, pre, el);
    }
    else {
      /* Wait till it happpens... */
      pips_internal_error("This case is not handled yet");
    }
  }
  else if(analyzed_type_p(et)) {
    entity tmpv = make_local_temporary_value_entity(et);
    /* FI: is_internal_p has an impact on renaming in
       simple_affine_to_transformer(). */
    tf = any_expression_to_transformer(tmpv, exp, pre, true);
  }
  else {
    // FI: we should go down recursively anyway because of casts and
    // side effects in C...
    if(expression_reference_p(exp)) {
      reference r = expression_reference(exp);
      tf = generic_reference_to_transformer(entity_undefined, r, pre, false);
    }
    else if(expression_call_p(exp)) {
      call c = expression_call(exp);
      entity f = call_function(c);
      /* FI: there may be (many) other exceptions with intrinsics...
       *
       * Fortran intrinsics, such as IOs, are not taken into account
       * because these code should not be executed for Fortran code.
       */
      if(ENTITY_FIELD_P(f)||ENTITY_POINT_TO_P(f)) {
        tf = safe_expression_to_transformer(EXPRESSION(CAR(call_arguments(c))),
                                            pre);
      }
      else if (entity_module_p(f)){
        list al = call_arguments(c);
        tf = user_call_to_transformer(f, al, pre, el);
      }
      else
        // FI: I am not pleased with this at all, but no time to think
        tf = expressions_to_transformer(call_arguments(c), pre);
    }
    else if(expression_cast_p(exp)) {
      cast c = expression_cast(exp);
      expression sub_exp = cast_expression(c);
      tf = safe_expression_to_transformer(sub_exp, pre);
    }
    else if(expression_sizeofexpression_p(exp)) {
      sizeofexpression soe = expression_sizeofexpression(exp);
      if(sizeofexpression_expression_p(soe)) {
        expression sub_exp = sizeofexpression_expression(soe);
        tf = safe_expression_to_transformer(sub_exp, pre);
      }
    }
    else if(expression_subscript_p(exp)) {
      subscript sub = expression_subscript(exp);
      expression base = subscript_array(sub);
      transformer tf1 = safe_expression_to_transformer(base, pre);
      transformer tf2
        = expressions_to_transformer(subscript_indices(sub), pre);
      tf = transformer_combine(tf1, tf2);
      free_transformer(tf2); // tf1 is exported in tf
    }
    else if(expression_application_p(exp)) {
      application a = expression_application(exp);
      expression func = application_function(a);
      transformer tf1 = safe_expression_to_transformer(func, pre);
      transformer tf2
        = expressions_to_transformer(application_arguments(a), pre);
      tf = transformer_combine(tf1, tf2);
      free_transformer(tf2); // tf1 is exported in tf
    }
    // FI: Many other possible cases: range, sizeofexpression, subscript,
    // application, va_arg
  }
 
  /* If everything else has failed. */
  if(transformer_undefined_p(tf))
    tf = effects_to_transformer(el);
  else
    tf = transformer_temporary_value_projection(tf);
 
  free_type(et);
 
  return tf;
}

References analyzed_type_p(), any_expression_to_transformer(), application_arguments, application_function, base, call_arguments, call_function, call_to_transformer(), CAR, cast_expression, compute_basic_concrete_type(), effects_to_transformer(), ENTITY_FIELD_P, entity_module_p(), ENTITY_POINT_TO_P, entity_undefined, exp, EXPRESSION, expression_application(), expression_application_p(), expression_call(), expression_call_p(), expression_cast(), expression_cast_p(), expression_reference(), expression_reference_p(), expression_sizeofexpression(), expression_sizeofexpression_p(), expression_subscript(), expression_subscript_p(), expression_syntax, expression_to_proper_constant_path_effects(), expression_to_type(), expressions_to_transformer(), f(), free_transformer(), free_type(), generic_reference_to_transformer(), make_local_temporary_value_entity(), pips_internal_error, safe_expression_to_transformer(), sizeofexpression_expression, sizeofexpression_expression_p, subscript_array, subscript_indices, syntax_call, syntax_call_p, syntax_cast, syntax_cast_p, transformer_combine(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, type_void_p, and user_call_to_transformer().

Referenced by expression_to_postcondition(), instruction_to_transformer(), and safe_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

expressions_to_summary_precondition()

void expressions_to_summary_precondition	(	transformer	pre,
		list	le
	)

Parameters

pre	re
le	e

Definition at line 966 of file interprocedural.c.

{
  MAPL(ce, {
    expression e = EXPRESSION(CAR(ce));
    expression_to_summary_precondition(pre, e);
  },
       le)
    }

References CAR, EXPRESSION, expression_to_summary_precondition(), and MAPL.

Referenced by call_to_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

expressions_to_transformer()

transformer expressions_to_transformer	(	list	expl,
		transformer	pre
	)

Compute the transformer associated to a list of expressions such as "i=0, j = 1;".

The value returned is ignored.

el is an over-appoximation; should be replaced by a safe_expression_to_transformer() taking care of computing the precise effects of exp instead of using the effects of expl.

Parameters

expl	xpl
pre	re

Definition at line 5722 of file expression.c.

{
  transformer tf = transformer_identity();
  transformer cpre = transformer_undefined_p(pre)?
    transformer_identity() : copy_transformer(pre);
 
  FOREACH(EXPRESSION, exp, expl) {
    /* el is an over-appoximation; should be replaced by a
       safe_expression_to_transformer() taking care of computing the
       precise effects of exp instead of using the effects of expl. */
    transformer cpre_r = transformer_range(cpre);
    transformer ctf = safe_expression_to_transformer(exp, cpre_r);
    transformer npre = transformer_undefined;
 
    tf = transformer_combine(tf, ctf);
    tf = transformer_normalize(tf, 2);
    npre = transformer_apply(ctf, cpre);
    npre = transformer_normalize(npre, 2);
    free_transformer(cpre);
    free_transformer(cpre_r);
    cpre = npre;
  }
  free_transformer(cpre);
  return tf;
}

References copy_transformer(), exp, EXPRESSION, FOREACH, free_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by any_expression_side_effects_to_transformer(), any_expression_to_transformer(), expression_to_transformer(), generic_reference_to_transformer(), intrinsic_to_transformer(), and intrinsic_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

false_condition_wrt_precondition_p()

bool false_condition_wrt_precondition_p	(	expression	c,
		transformer	pre
	)

Parameters

pre

re

Definition at line 5891 of file expression.c.

{
  bool result = false;
 
  result = eval_condition_wrt_precondition_p(c, pre, false);
 
  return result;
}

References eval_condition_wrt_precondition_p().

Referenced by whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_transformer()

transformer filter_transformer	(	transformer	t,
		list	e
	)

Previous version of effects_to_transformer() transformer effects_to_transformer(list e) { list args = NIL; Pbase b = VECTEUR_NUL; Psysteme s = sc_new();.

s->base = b; s->dimension = vect_size(b);

return make_transformer(args, make_predicate(s)); }

algorithm: keep only information about scalar variables with values appearing in effects e and store it into a newly allocated transformer

action a = effect_action(ef);

action_write_p(a) &&

I do not know yet if I should keep old values...

FI: I should check if sc is sc_empty but I haven't (yet) found a cheap syntactic test

Definition at line 495 of file ri_to_transformers.c.

{
  /* algorithm: keep only information about scalar variables with values
   * appearing in effects e and store it into a newly allocated transformer
   */
  Pbase b = VECTEUR_NUL;
  Psysteme s = SC_UNDEFINED;
  Psysteme sc = predicate_system(transformer_relation(t));
  list args = NIL;
  Psysteme sc_restricted_to_variables_transitive_closure(Psysteme, Pbase);
 
  FOREACH(EFFECT, ef, e) {
    reference r = effect_any_reference(ef);
    /* action a = effect_action(ef); */
    entity v = reference_variable(r);
 
    if(/* action_write_p(a) && */ entity_has_values_p(v)) {
      /* I do not know yet if I should keep old values... */
      entity new_val = entity_to_new_value(v);
      b = vect_add_variable(b, (Variable) new_val);
 
      if(entity_is_argument_p(v, transformer_arguments(t))) {
        args = arguments_add_entity(args, v);
      }
    }
  }
 
  /* FI: I should check if sc is sc_empty but I haven't (yet) found a
     cheap syntactic test */
  s = sc_restricted_to_variables_transitive_closure(sc, b);
 
  return make_transformer(args, make_predicate(s));
}

References arguments_add_entity(), EFFECT, effect_any_reference, entity_has_values_p(), entity_is_argument_p(), entity_to_new_value(), FOREACH, make_predicate(), make_transformer(), NIL, predicate_system, reference_variable, sc_restricted_to_variables_transitive_closure(), transformer_arguments, transformer_relation, vect_add_variable(), and VECTEUR_NUL.

Referenced by semantic_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

float_expression_to_transformer()

transformer float_expression_to_transformer	(	entity	v,
		expression	rhs,
		transformer	pre,
		bool	is_internal
	)

pre can be used if some integer variables with constant values have to be promoted to float.

pips_assert("Precondition is undefined", transformer_undefined_p(pre));

Parameters

rhs	hs
pre	re
is_internal	s_internal

Definition at line 4153 of file expression.c.

{
  transformer tf = transformer_undefined;
  syntax srhs = expression_syntax(rhs);
 
  /* pre can be used if some integer variables with constant values have
     to be promoted to float. */
 
  /* pips_assert("Precondition is undefined", transformer_undefined_p(pre)); */
 
  switch(syntax_tag(srhs)) {
  case is_syntax_call:
    tf = float_call_expression_to_transformer(v, rhs, pre, is_internal);
    break;
  case is_syntax_reference:
    {
      //entity e = reference_variable(syntax_reference(srhs));
      // FI: some filtering needed if integer expressions should not
      // be exploited...
      reference r = syntax_reference(srhs);
      tf = generic_reference_to_transformer(v, r, pre, is_internal);
      break;
    }
  case is_syntax_range:
    pips_internal_error("Unexpected tag %d", syntax_tag(srhs));
    break;
  default:
    pips_internal_error("Illegal tag %d", syntax_tag(srhs));
  }
 
  return tf;
}

References expression_syntax, float_call_expression_to_transformer(), generic_reference_to_transformer(), is_syntax_call, is_syntax_range, is_syntax_reference, pips_internal_error, syntax_reference, syntax_tag, and transformer_undefined.

Referenced by any_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

forloop_to_postcondition()

transformer forloop_to_postcondition	(	transformer	pre,
		forloop	fl,
		transformer	t_body_star
	)

This function does not seem to exist because we only used statement effects in the past and because those are stored in the database.

An effort could be made to compute the precondition for t_exit, especially if the precondition to t_inc is available.

An effort could be made to compute the precondition for t_inc

Clean up memory

Parameters

pre	re
fl	l
t_body_star	_body_star

Definition at line 2707 of file loop.c.

{
  transformer post = transformer_undefined;
 
  statement body_s = forloop_body(fl);
  transformer t_body = load_statement_transformer(body_s);
 
  expression init_e = forloop_initialization(fl);
  /* This function does not seem to exist because we only used
     statement effects in the past and because those are stored in the
     database. */
  transformer t_init = safe_expression_to_transformer(init_e, pre);
  transformer post_init = transformer_apply(t_init, pre);
 
  expression cond_e = forloop_condition(fl);
  transformer t_skip = condition_to_transformer(cond_e, post_init, false);
  transformer t_enter = condition_to_transformer(cond_e, post_init, true);
/* An effort could be made to compute the precondition for t_exit,
     especially if the precondition to t_inc is available. */
  transformer t_continue = condition_to_transformer(cond_e, transformer_undefined, true);
  transformer t_exit = condition_to_transformer(cond_e, transformer_undefined, false);
 
  expression inc_e = forloop_increment(fl);
  /* An effort could be made to compute the precondition for t_inc */
  transformer t_inc = safe_expression_to_transformer(inc_e, transformer_undefined);
 
  transformer t_next = transformer_combine(transformer_dup(t_inc), t_continue);
 
  post = any_loop_to_postcondition(body_s,
                                   t_init,
                                   t_enter,
                                   t_skip,
                                   t_body_star,
                                   t_body,
                                   t_next,
                                   t_inc,
                                   t_exit,
                                   pre);
 
  /* Clean up memory */
 
  free_transformer(t_init);
  free_transformer(post_init);
  free_transformer(t_skip);
  free_transformer(t_enter);
  free_transformer(t_continue);
  free_transformer(t_exit);
  free_transformer(t_inc);
  free_transformer(t_next);
 
    return post;
}

References any_loop_to_postcondition(), condition_to_transformer(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, free_transformer(), load_statement_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_dup(), and transformer_undefined.

Referenced by instruction_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

forloop_to_transformer()

transformer forloop_to_transformer	(	forloop	fl,
		transformer	pre,
		list	flel
	)

effects of forloop fl

t_body_star = t_init ; t_enter ;(t_body ; t_next)*

Deal with initialization expression

Deal with condition expression

An effort could be made to compute the precondition for t_continue, especially if the precondition to t_inc is available.

Deal with increment expression

An effort could be made to compute the precondition for t_inc

Let's clean up the memory

Parameters

fl	l
pre	re
flel	lel

Definition at line 326 of file loop.c.

{
  /* t_body_star =  t_init ; t_enter ;(t_body ; t_next)* */
  transformer t_body_star = transformer_undefined;
  statement body_s = forloop_body(fl);
 
  /* Deal with initialization expression */
  expression init_e = forloop_initialization(fl);
  transformer t_init = safe_expression_to_transformer(init_e, pre);
  transformer post_init = transformer_apply(t_init, pre);
 
  /* Deal with condition expression */
  expression cond_e = forloop_condition(fl);
  transformer t_enter = condition_to_transformer(cond_e, post_init, true);
  /* An effort could be made to compute the precondition for t_continue,
     especially if the precondition to t_inc is available. */
  transformer p_continue = transformer_identity();
  transformer t_continue = condition_to_transformer(cond_e, p_continue, true);
 
  /* Deal with increment expression */
  expression inc_e = forloop_increment(fl);
  /* An effort could be made to compute the precondition for t_inc */
  transformer t_inc = safe_expression_to_transformer(inc_e, transformer_undefined);
  transformer t_next = transformer_combine(t_inc, t_continue);
 
  t_body_star = any_loop_to_transformer(t_init, t_enter, t_next, body_s, flel, post_init);
 
  /* Let's clean up the memory */
 
  free_transformer(p_continue);
 
  free_transformer(t_init);
  free_transformer(post_init);
 
  free_transformer(t_enter);
  free_transformer(t_continue);
 
  // free_transformer(t_inc); it is absorbed by t_next
  free_transformer(t_next);
 
  return t_body_star;
}

References any_loop_to_transformer(), condition_to_transformer(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, free_transformer(), safe_expression_to_transformer(), transformer_apply(), transformer_combine(), transformer_identity(), and transformer_undefined.

Referenced by instruction_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

forloop_to_transformer_list()

list forloop_to_transformer_list	(	forloop	,
		transformer	,
		list
	)

fortran_user_call_to_transformer()

transformer fortran_user_call_to_transformer	(	entity	f,
		list	pc,
		list	ef
	)

Effects are necessary to clean up the transformer t_caller.

For instance, an effect on variable X may not be taken into account in t_callee but it may be equivalenced thru a common to a variable i which is analyzed in the caller. If X is written, I value is lost. See Validation/equiv02.f.

add equations linking formal parameters to argument expressions to transformer t_callee and project along the formal parameters

for performance, it would be better to avoid building formals and to inline entity_to_formal_parameters

it wouls also be useful to distinguish between in and out parameters; I'm not sure the information is really available in a field ???

take care of analyzable formal parameters

type checking. You already know that fp is a scalar variable

formal parameter e is modified. expr must be a reference

normal case: ap_new==fp_new, ap_old==fp_old

Variable ap is not analyzed. The information about fp will be lost.

Attemps at modifying a value: expr is call, fp is modified

Actual argument is not a reference: it might be a user error! Transformers do not carry the may/must information. A check with effect list ef should be performed...

FI: does effect computation emit a MUST/MAYwarning?

Formal parameter fp is not modified. Add fp == expr, if possible.

We should evaluate expr under a precondition pre... which has not been passed down. We set pre==tf_undefined.

temporary value counter cannot be reset because other temporary values may be in use in a case the user call is a user function call

reset_temporary_value_counter();

formal new and old values left over are eliminated

test to insure that entity_to_old_value exists

take care of global variables

FI: are invisible variables taken care of by translate_global_values()? Yes, now... A variable may be invisible because its location is reached thru an array or thru a non-integer scalar variable in the current module, for instance because a COMMON is defined differently. A variable whose location is not reachable in the current module environment is considered visible.

Callee f may have read/write effects on caller's scalar integer variables thru an array and/or non-integer variables.

The relation basis must be updated too

The return value of a function is not yet projected.

Parameters

pc	c
ef	f

Definition at line 2269 of file ri_to_transformers.c.

{
  transformer t_callee = transformer_undefined;
  transformer t_caller = transformer_undefined;
  transformer t_effects = transformer_undefined;
  entity caller = entity_undefined;
  list all_args = list_undefined;
 
  pips_debug(8, "begin\n");
 
  /* add equations linking formal parameters to argument expressions
     to transformer t_callee and project along the formal parameters */
  /* for performance, it  would be better to avoid building formals
     and to inline entity_to_formal_parameters */
  /* it wouls also be useful to distinguish between in and out
     parameters; I'm not sure the information is really available
     in a field ??? */
  list formals = module_to_formal_analyzable_parameters(f);
  list formals_new = NIL;
 
  t_callee = load_summary_transformer(f);
 
  ifdebug(8) {
    Psysteme s =
      (Psysteme) predicate_system(transformer_relation(t_callee));
    pips_debug(8, "Transformer for callee %s:\n",
               entity_local_name(f));
    dump_transformer(t_callee);
    sc_fprint(stderr, s, (char * (*)(Variable)) dump_value_name);
  }
 
  t_caller = transformer_dup(t_callee);
 
  /* take care of analyzable formal parameters */
 
  FOREACH(ENTITY, fp, formals) {
    int r = formal_offset(storage_formal(entity_storage(fp)));
    expression expr = find_ith_argument(pc, r);
 
    if(expr == expression_undefined)
      pips_user_error("not enough args for %d formal parm."
                      " %s in call to %s from %s\n",
                      r, entity_local_name(fp), entity_local_name(f),
                      get_current_module_entity());
    else {
      /* type checking. You already know that fp is a scalar variable */
      type tfp = entity_type(fp);
      basic bfp = variable_basic(type_variable(tfp));
      basic bexpr = basic_of_expression(expr);
      //list l_eff = expression_to_proper_effects(expr);
      list l_eff = expression_to_proper_constant_path_effects(expr);
 
      if(effects_write_at_least_once_p(l_eff)) {
        semantics_user_warning("Side effects in actual arguments are not yet taken into account\n."
                          "Meanwhile, \"atomize\" the call site to avoid the problem.\n");
      }
      gen_free_list(l_eff);
 
      if(!basic_equal_p(bfp, bexpr)) {
        semantics_user_warning("Type incompatibility (formal %s/actual %s) "
                          "for formal parameter \"%s\" (rank %d) "
                          "in call to \"%s\" from \"%s\"\n",
                          basic_to_string(bfp), basic_to_string(bexpr),
                          entity_local_name(fp), r, module_local_name(f),
                          module_local_name(get_current_module_entity()));
        continue;
      }
    }
 
    if(entity_is_argument_p(fp, transformer_arguments(t_callee))) {
      /* formal parameter e is modified. expr must be a reference */
      syntax sexpr = expression_syntax(expr);
 
      if(syntax_reference_p(sexpr)) {
        entity ap = reference_variable(syntax_reference(sexpr));
 
        if(entity_has_values_p(ap)) {
          Psysteme s = (Psysteme) predicate_system(transformer_relation(t_caller));
          entity ap_new = entity_to_new_value(ap);
          entity ap_old = entity_to_old_value(ap);
 
          if(base_contains_variable_p(s->base, (Variable) ap_new)) {
            pips_user_error(
                            "Variable %s seems to be aliased thru variable %s"
                            " at a call site to %s in %s\n"
                            "PIPS semantics analysis assumes no aliasing as"
                            " imposed by the Fortran standard.\n",
                            entity_name(fp),
                            entity_name(value_to_variable(ap_new)),
                            module_local_name(f),
                            get_current_module_name());
          }
          else { /* normal case: ap_new==fp_new, ap_old==fp_old */
            entity fp_new = external_entity_to_new_value(fp);
            entity fp_old = external_entity_to_old_value(fp);
 
            t_caller = transformer_value_substitute
              (t_caller, fp_new, ap_new);
            t_caller = transformer_value_substitute
              (t_caller, fp_old, ap_old);
          }
        }
        else { /* Variable ap is not analyzed. The information about fp
                  will be lost. */
          ;
        }
      }
      else {
        /* Attemps at modifying a value: expr is call, fp is modified */
        /* Actual argument is not a reference: it might be a user error!
         * Transformers do not carry the may/must information.
         * A check with effect list ef should be performed...
         *
         * FI: does effect computation emit a MUST/MAYwarning?
         */
        entity fp_new = external_entity_to_new_value(fp);
        entity fp_old = external_entity_to_old_value(fp);
        list args = arguments_add_entity(arguments_add_entity(NIL, fp_new), fp_old);
 
        semantics_user_warning("value (!) might be modified by call to %s\n"
                          "%dth formal parameter %s\n",
                          entity_local_name(f), r, entity_local_name(fp));
        t_caller = transformer_filter(t_caller, args);
        free_arguments(args);
      }
    }
    else {
      /* Formal parameter fp is not modified. Add fp == expr, if possible. */
      /* We should evaluate expr under a precondition pre... which has
         not been passed down. We set pre==tf_undefined. */
      entity fp_new = external_entity_to_new_value(fp);
      transformer t_expr = any_expression_to_transformer(fp_new, expr,
                                                         transformer_undefined,
                                                         false);
 
      if(!transformer_undefined_p(t_expr)) {
        t_expr = transformer_temporary_value_projection(t_expr);
        /* temporary value counter cannot be reset because other
           temporary values may be in use in a case the user call is a
           user function call */
        /* reset_temporary_value_counter(); */
        t_caller = transformer_safe_image_intersection(t_caller, t_expr);
        free_transformer(t_expr);
      }
    }
  }
 
  pips_debug(8, "Before formal new values left over are eliminated\n");
  ifdebug(8)   dump_transformer(t_caller);
 
  /* formal new and old values left over are eliminated */
  FOREACH(ENTITY, e, formals) {
    entity e_new = external_entity_to_new_value(e);
    formals_new = CONS(ENTITY, e_new, formals_new);
    /* test to insure that entity_to_old_value exists */
    if(entity_is_argument_p(e_new,
                            transformer_arguments(t_caller))) {
      entity e_old = external_entity_to_old_value(e);
      formals_new = CONS(ENTITY, e_old, formals_new);
    }
  }
 
  t_caller = transformer_filter(t_caller, formals_new);
 
  free_arguments(formals_new);
  free_arguments(formals);
 
  ifdebug(8) {
    Psysteme s = predicate_system(transformer_relation(t_caller));
    pips_debug(8,
               "After binding formal/real parameters and eliminating formals\n");
    dump_transformer(t_caller);
    sc_fprint(stderr, s, (char * (*)(Variable)) dump_value_name);
  }
 
  /* take care of global variables */
  caller = get_current_module_entity();
  translate_global_values(caller, t_caller);
 
  /* FI: are invisible variables taken care of by translate_global_values()?
   * Yes, now...
   * A variable may be invisible because its location is reached
   * thru an array or thru a non-integer scalar variable in the
   * current module, for instance because a COMMON is defined
   * differently. A variable whose location is not reachable
   * in the current module environment is considered visible.
   */
 
  ifdebug(8) {
    pips_debug(8, "After replacing global variables\n");
    dump_transformer(t_caller);
  }
 
  if(!transformer_empty_p(t_caller)) {
    /* Callee f may have read/write effects on caller's scalar
     * integer variables thru an array and/or non-integer variables.
     */
    t_effects = effects_to_transformer(ef);
    all_args = arguments_union(transformer_arguments(t_caller),
                               transformer_arguments(t_effects));
    /*
      free_transformer(t_effects);
      gen_free_list(transformer_arguments(t_caller));
    */
    transformer_arguments(t_caller) = all_args;
    /* The relation basis must be updated too */
    FOREACH(ENTITY, v, transformer_arguments(t_effects)) {
        Psysteme sc = (Psysteme) predicate_system(transformer_relation(t_caller));
        sc_base_add_variable(sc, (Variable) v);
      }
  }
  else {
    semantics_user_warning("Call to %s seems never to return."
                      " This may be due to an infinite loop in %s,"
                      " or to a systematic exit in %s,"
                      " or to standard violations (see previous messages)\n",
                      module_local_name(f),
                      module_local_name(f),
                      module_local_name(f));
  }
 
  ifdebug(8) {
    pips_debug(8,
               "End: after taking all scalar effects in consideration %p\n",
               t_caller);
    dump_transformer(t_caller);
  }
 
  /* The return value of a function is not yet projected. */
  pips_assert("transformer t_caller is consistent",
              transformer_weak_consistency_p(t_caller));
 
  return t_caller;
}

References any_expression_to_transformer(), arguments_add_entity(), arguments_union(), Ssysteme::base, base_contains_variable_p(), basic_equal_p(), basic_of_expression(), basic_to_string(), CONS, dump_transformer, dump_value_name(), effects_to_transformer(), effects_write_at_least_once_p(), ENTITY, entity_has_values_p(), entity_is_argument_p(), entity_local_name(), entity_name, entity_storage, entity_to_new_value(), entity_to_old_value(), entity_type, entity_undefined, expression_syntax, expression_to_proper_constant_path_effects(), expression_undefined, external_entity_to_new_value(), external_entity_to_old_value(), f(), find_ith_argument(), FOREACH, formal_offset, free_arguments(), free_transformer(), gen_free_list(), get_current_module_entity(), get_current_module_name(), ifdebug, list_undefined, load_summary_transformer(), module_local_name(), module_to_formal_analyzable_parameters(), NIL, pips_assert, pips_debug, pips_user_error, predicate_system, reference_variable, sc_base_add_variable(), sc_fprint(), semantics_user_warning, storage_formal, syntax_reference, syntax_reference_p, transformer_arguments, transformer_dup(), transformer_empty_p(), transformer_filter(), transformer_relation, transformer_safe_image_intersection(), transformer_temporary_value_projection(), transformer_undefined, transformer_undefined_p, transformer_value_substitute(), transformer_weak_consistency_p(), translate_global_values(), type_variable, value_to_variable(), and variable_basic.

Referenced by fortran_user_function_call_to_transformer(), and user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

free_postcondition_map()

void free_postcondition_map

(

void

)

Referenced by reset_resources_for_module().

Here is the caller graph for this function:

free_precondition_map()

void free_precondition_map

(

void

)

free_semantic_map()

void free_semantic_map

(

void

)

free_total_precondition_map()

void free_total_precondition_map

(

void

)

free_transformer_map()

void free_transformer_map

(

void

)

generic_complete_statement_transformer()

transformer generic_complete_statement_transformer	(	transformer	t,
		transformer	pre,
		statement	s,
		bool	identity_p
	)

Loops, do, for, while or repeat, have transformers linked to their body preconditions so as to compute those.

But the real loop transformer includes also the possible loop skip and the possible loop exit. This function completes transformer t, which is linked to the loop body precondition, and use additional information carried by statement s, analyzed with precondition pre to return the global loop transformer. If statement s is not a loop, a copy of t is returned.

Parameter identity_p is likely to be useless. It was added to track identity transformers before they were dealt with by transformer lists.

If i is a loop, the expected transformer can be more complex (see nga06) because the stores transformer is later used to compute the loop body precondition. It cannot take into account the exit condition. So the exit condition is added by the complete_xxx functions.

likely memory leak:-(. ct should be allocated in both test branches and freed at call site but I program everything under the opposite assumption

The refined transformer may be lost or stored as a block transformer is the loop is directly surrounded by a bloc or used to compute the transformer of the surroundings blokcs

No need to complete it

The search for an non identity execution path must be propagated downwards

Each component may or not update the state...

Parameters

pre	re
identity_p	dentity_p

Definition at line 3706 of file ri_to_transformers.c.

{
  /* If i is a loop, the expected transformer can be more complex (see
     nga06) because the stores transformer is later used to compute
     the loop body precondition. It cannot take into account the exit
     condition. So the exit condition is added by the complete_xxx
     functions. */
  transformer ct = transformer_undefined;
  instruction i = statement_instruction(s);
 
  if(instruction_loop_p(i)) {
    /* likely memory leak:-(. ct should be allocated in both test
       branches and freed at call site but I program everything under
       the opposite assumption */
    /* The refined transformer may be lost or stored as a block
       transformer is the loop is directly surrounded by a bloc or used to
       compute the transformer of the surroundings blokcs */
    ct = complete_loop_transformer(t, pre, instruction_loop(i));
  }
  else if(instruction_whileloop_p(i)) {
    whileloop w = instruction_whileloop(i);
    evaluation e = whileloop_evaluation(w);
    // This test could be deported by a call to
    // complete_whileloop_transformer()
    if(evaluation_before_p(e)) {
      ct = new_complete_whileloop_transformer(t, pre, w, !identity_p);
    }
    else {
      ct = complete_repeatloop_transformer(t, pre, w);
    }
  }
  else if(instruction_forloop_p(i)) {
    ct = complete_forloop_transformer(t, pre, instruction_forloop(i));
  }
  else {
    if(identity_p) {
      /* No need to complete it */
      ct = copy_transformer(t);
    }
    else {
      /* The search for an non identity execution path must be propagated
         downwards */
      if(instruction_sequence_p(i)) {
        /* Each component may or not update the state... */
      }
    }
  }
  return ct;
}

References complete_forloop_transformer(), complete_loop_transformer(), complete_repeatloop_transformer(), copy_transformer(), evaluation_before_p, instruction_forloop, instruction_forloop_p, instruction_loop, instruction_loop_p, instruction_sequence_p, instruction_whileloop, instruction_whileloop_p, new_complete_whileloop_transformer(), statement_instruction, transformer_undefined, and whileloop_evaluation.

Referenced by complete_non_identity_statement_transformer(), and complete_statement_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_module_name_to_transformers()

bool generic_module_name_to_transformers	(	const char *	module_name,
		bool	in_context
	)

bool generic_module_name_to_transformers(char * module_name, bool in_context): compute a transformer for each statement of a module with a given name; compute also the global transformer for the module

intraprocedural preconditions: proper declarations

This stack is useful to document warnings and to retrieve points-to information.

could be a gen_find_tabulated as well...

cumulated_effects_map_print();

compute the basis related to module m

In the main module, transformers can be computed in context of the initial values

Add declaration information: arrays cannot be empty (Fortran standard, Section 5.1.2)

Get the preconditions: they might prove useful within loops where transformers cannot propagate enough information.

compute intraprocedural transformer

FI: side effect; compute and store the summary transformer, because every needed piece of data is available...

filter out local variables from the global intraprocedural effect

Two auxiliary hash tables allocated by effectsmap_to_listmap()

Parameters

module_name	odule_name
in_context	n_context

Definition at line 918 of file dbm_interface.c.

{
    transformer t_intra = transformer_undefined;
    transformer t_inter = transformer_undefined;
    /* intraprocedural preconditions: proper declarations */
    transformer mod_pre = transformer_undefined;
    list e_inter;
 
    debug_on(SEMANTICS_DEBUG_LEVEL);
    sc_variable_name_push((char* (*)(Variable)) readable_value_name);
 
    /* This stack is useful to document warnings and to retrieve
       points-to information. */
    make_statement_global_stack();
    set_warning_counters();
    set_current_module_entity(module_name_to_entity(module_name));
    /* could be a gen_find_tabulated as well... */
    set_current_module_statement(
        (statement) db_get_memory_resource(DBR_CODE, module_name, true));
    if( get_current_module_statement() == (statement) database_undefined )
        pips_internal_error("no statement for module %s", module_name);
 
    set_proper_rw_effects((statement_effects)
        db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
 
    set_cumulated_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
    set_methods_for_simple_effects();
 
    /* cumulated_effects_map_print();*/
 
    e_inter = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    set_transformer_map( MAKE_STATEMENT_MAPPING() );
 
    /* compute the basis related to module m */
    module_to_value_mappings( get_current_module_entity() );
 
    /* In the main module, transformers can be computed in context of the
       initial values */
    if(entity_main_module_p(get_current_module_entity())
       && get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"))
    {
      if (get_bool_property(SEMANTICS_INTERPROCEDURAL))
      {
        mod_pre = (transformer)
          db_get_memory_resource(DBR_PROGRAM_PRECONDITION, "", false);
        if(transformer_empty_p(mod_pre)) {
          pips_user_warning(
             "Initial preconditions are not consistent.\n"
             " The Fortran standard rules about variable initialization"
             " with DATA statements are likely to be violated.\n"
             "set property PARSER_ACCEPT_ANSI_EXTENSIONS to false\n"
             "and CHECK_FORTRAN_SYNTAX_BEFORE_PIPS to true.\n");
        }
      }
      else
        mod_pre = data_to_precondition(get_current_module_entity());
    }
    else if(in_context) {
      mod_pre =
        transformer_dup(load_summary_precondition(get_current_module_entity()));
    }
    else
      mod_pre = transformer_identity();
 
    /* Add declaration information: arrays cannot be empty (Fortran
       standard, Section 5.1.2) */
    if(get_bool_property("SEMANTICS_TRUST_ARRAY_DECLARATIONS")) {
      transformer_add_declaration_information(mod_pre,
                                              get_current_module_entity());
    }
 
    /* Get the preconditions: they might prove useful within loops where
       transformers cannot propagate enough information. */
    if(in_context) {
     set_precondition_map( (statement_mapping)
        db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
   }
 
    /* compute intraprocedural transformer */
    statement ms = get_current_module_statement();
    t_intra = statement_to_transformer(ms, mod_pre);
    free_transformer(mod_pre);
 
    DB_PUT_MEMORY_RESOURCE(DBR_TRANSFORMERS, module_name,
                           (char*) get_transformer_map() );
 
    /* FI: side effect; compute and store the summary transformer, because
       every needed piece of data is available... */
 
    /* filter out local variables from the global intraprocedural effect */
    t_inter = transformer_intra_to_inter(t_intra, e_inter);
    t_inter = transformer_normalize(t_inter, 2);
    if(c_module_p(get_current_module_entity())) {
      t_inter = value_passing_summary_transformer(get_current_module_entity(), t_inter);
    }
    if(!transformer_consistency_p(t_inter)) {
        (void) print_transformer(t_inter);
        pips_internal_error("Non-consistent summary transformer");
    }
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_TRANSFORMER,
                           module_local_name(get_current_module_entity()),
                           (char*) t_inter);
    pips_debug(8, "t_inter=%p\n", t_inter);
 
    reset_current_module_entity();
    reset_current_module_statement();
    /* Two auxiliary hash tables allocated by effectsmap_to_listmap() */
    reset_proper_rw_effects();
    reset_cumulated_rw_effects();
    generic_effects_reset_all_methods();
    reset_transformer_map();
    if(in_context) reset_precondition_map();
 
    free_value_mappings();
    free_statement_global_stack();
 
    sc_variable_name_pop();
    debug_off();
 
    return true;
}

References c_module_p(), data_to_precondition(), database_undefined, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, effects_to_list(), entity_main_module_p(), free_statement_global_stack(), free_transformer(), free_value_mappings(), generic_effects_reset_all_methods(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), get_transformer_map(), load_summary_precondition(), make_statement_global_stack(), MAKE_STATEMENT_MAPPING, module_local_name(), module_name(), module_name_to_entity(), module_to_value_mappings(), pips_debug, pips_internal_error, pips_user_warning, print_transformer, readable_value_name(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_transformer_map(), sc_variable_name_pop(), sc_variable_name_push(), SEMANTICS_DEBUG_LEVEL, SEMANTICS_INTERPROCEDURAL, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_methods_for_simple_effects(), set_precondition_map(), set_proper_rw_effects(), set_transformer_map(), set_warning_counters(), statement_to_transformer(), transformer_add_declaration_information(), transformer_consistency_p(), transformer_dup(), transformer_empty_p(), transformer_identity(), transformer_intra_to_inter(), transformer_normalize(), transformer_undefined, and value_passing_summary_transformer().

Referenced by module_name_to_transformers(), and module_name_to_transformers_in_context().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_reference_to_transformer()

transformer generic_reference_to_transformer	(	entity	v,
		reference	r,
		transformer	pre,
		bool	is_internal
	)

expression.c

expression.c

May return an undefined transformer

If you are dealing with a C array reference, find transformers for each subscript expression in case of side effects.

Parameters

pre	re
is_internal	s_internal

Definition at line 126 of file expression.c.

{
  transformer tf = transformer_undefined;
  entity rv = reference_variable(r);
  list sl = reference_indices(r);
 
  //FI: we could do better if the subscripts are constants
  // we could try to use constant_memory_access_path_to_location_entity()
  // after checking that the reference is constant
 
  if(ENDP(sl) && ((!is_internal && analyzable_scalar_entity_p(rv))
                  || entity_has_values_p(rv))) {
    if(!entity_undefined_p(v)) {
      entity rv_new = is_internal?
        entity_to_new_value(rv) : external_entity_to_new_value(rv);
      transformer tfr =  simple_equality_to_transformer(v, rv_new, false);
      if(!transformer_undefined_p(pre)) {
        // FI: assume pre is a range
        tf = transformer_intersection(tfr, pre);
      }
      free_transformer(tfr);
    }
  }
  else if(ENDP(sl)) {
    // Might be a constant value for a pointer, such as "a", an array
    type t = entity_basic_concrete_type(rv);
    if(array_type_p(t)) {
      // int d = (int) gen_length(variable_indices(type_variable(t)));
      // list sl = make_zero_subscripts(d);
      list sl = CONS(EXPRESSION, make_zero_expression(), NIL);
      reference r = make_reference(rv, sl);
      entity l = constant_memory_access_path_to_location_entity(r); // l is a constant location
      if(!entity_undefined_p(l)) {
        transformer tfr =  simple_equality_to_transformer(v, l, false);
        if(!transformer_undefined_p(pre)) {
          // FI: assume pre is a range
          tf = transformer_intersection(tfr, pre);
        }
        free_transformer(tfr);
      }
    }
  }
  else if(get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH")) {
    tf = expressions_to_transformer(reference_indices(r), pre);
    // an array reference may have an impact on some values
    type t = points_to_reference_to_concrete_type(r);
    if(analyzed_type_p(t)) {
      bool processed_p = false;
      if(store_independent_reference_p(r)) {
        entity rv = constant_memory_access_path_to_location_entity(r);
        if(!entity_undefined_p(rv) && !entity_undefined_p(v)) {
          processed_p = true;
          tf = transformer_add_equality(tf, v, rv);
        }
      }
      if(!processed_p) {
        // FI: not sure why we would only be interested in modified variables
        list wvl = modified_variables_with_values();
        FOREACH(ENTITY, wv, wvl) {
          if(location_entity_p(wv)) {
            value val = entity_initial(wv);
            reference lr = value_reference(val);
            // FI: when a precondition is available, it should be used
            // to build almost a dependence test
            if(references_may_conflict_p(r, lr)) {
              tf = transformer_add_variable_update(tf, wv);
            }
          }
        }
      }
    }
  }
 
  if(transformer_undefined_p(tf)) {
    /* If you are dealing with a C array reference, find transformers
            for each subscript expression in case of side effects. */
    entity m = get_current_module_entity();
    if(c_language_module_p(m)) {
      tf = expressions_to_transformer(reference_indices(r), pre);
    }
  }
  return tf;
}

References analyzable_scalar_entity_p(), analyzed_type_p(), array_type_p(), c_language_module_p(), CONS, constant_memory_access_path_to_location_entity(), ENDP, ENTITY, entity_basic_concrete_type(), entity_has_values_p(), entity_initial, entity_to_new_value(), entity_undefined_p, EXPRESSION, expressions_to_transformer(), external_entity_to_new_value(), FOREACH, free_transformer(), get_bool_property(), get_current_module_entity(), location_entity_p(), make_reference(), make_zero_expression(), modified_variables_with_values(), NIL, points_to_reference_to_concrete_type(), reference_indices, reference_variable, references_may_conflict_p(), simple_equality_to_transformer(), store_independent_reference_p(), transformer_add_equality(), transformer_add_variable_update(), transformer_intersection(), transformer_undefined, transformer_undefined_p, and value_reference.

Referenced by assign_rhs_to_reflhs_to_transformer(), expression_to_transformer(), float_expression_to_transformer(), integer_expression_to_transformer(), pointer_expression_to_transformer(), and points_to_unary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_substitute_formal_array_elements_in_transformer()

transformer generic_substitute_formal_array_elements_in_transformer	(	transformer	,
		entity	,
		list	,
		transformer	,
		list	,
		bool
	)

generic_transformer_intra_to_inter()

transformer generic_transformer_intra_to_inter	(	transformer	tf,
		list	le,
		bool	preserve_rv_p
	)

transformer translation from the module intraprocedural transformer to the module interprocedural transformer.

Values related to variables local to the module must be eliminated. Note that in C they should be eliminated earlier when the effect of the local declaration is taken into account or when the corresponding scope block is closed.

Filtered TransFormer ftf

cons * old_args = transformer_arguments(ftf);

get rid of tf's arguments that do not appear in effects le

build a list of arguments to suppress

FI: I do not understand anymore why corresponding old values do not have to be suppressed too (6 July 1993)

FI: because only read arguments are eliminated, non? (12 November 1995)

FI: the resulting intermediate transformer is not consistent (18 July 2003)

get rid of them

ftf = transformer_projection(ftf, lost_args);

free the temporary list of entities

get rid of local read variables

FI: why not use this loop to get rid of all local variables, read or written?

Variables with no impact on the caller world are eliminated. However, the return value associated to a function is conditionnally preserved.

get rid of them

free the temporary list of entities

Parameters

tf	f
le	e
preserve_rv_p	reserve_rv_p

Definition at line 1398 of file ri_to_transformers.c.

{
  cons * lost_args = NIL;
  /* Filtered TransFormer ftf */
  transformer ftf = transformer_dup(tf);
  /* cons * old_args = transformer_arguments(ftf); */
  Psysteme sc = SC_UNDEFINED;
  Pbase b = BASE_UNDEFINED;
  Pbase eb = BASE_UNDEFINED;
 
  pips_debug(8,"begin\n");
  pips_debug(8,"argument tf=%p\n",ftf);
  ifdebug(8) (void) dump_transformer(ftf);
 
  /* get rid of tf's arguments that do not appear in effects le */
 
  /* build a list of arguments to suppress */
  /* FI: I do not understand anymore why corresponding old values do not have
   * to be suppressed too (6 July 1993)
   *
   * FI: because only read arguments are eliminated, non? (12 November 1995)
   *
   * FI: the resulting intermediate transformer is not consistent (18 July 2003)
   */
  /*
  MAPL(ca,
  {entity e = ENTITY(CAR(ca));
  if(!effects_write_entity_p(le, e) &&
     !storage_return_p(entity_storage(e)))
    lost_args = arguments_add_entity(lost_args, e);
  },
       old_args);
  */
  /* get rid of them */
  /* ftf = transformer_projection(ftf, lost_args); */
 
  /* free the temporary list of entities */
  /*
  gen_free_list(lost_args);
  lost_args = NIL;
 
  pips_debug(8,"after first filtering ftf=%x\n",ftf);
  ifdebug(8) (void) dump_transformer(ftf);
  */
 
  /* get rid of local read variables */
 
  /* FI: why not use this loop to get rid of *all* local variables, read or written? */
 
  sc = (Psysteme) predicate_system(transformer_relation(ftf));
  b = sc_base(sc);
  for(eb=b; !BASE_UNDEFINED_P(eb); eb = eb->succ) {
    entity e = (entity) vecteur_var(eb);
 
    if(e != (entity) TCST) {
      entity v = value_to_variable(e);
      /*
      entity v = entity_undefined;
 
      // Because static Fortran equivalences are indicated by an equality
      // Only one of the two equivalenced variables has values ?
      if(entity_has_values_p(v))
        v = value_to_variable(e);
      else
        v = e;
      */
 
      /* Variables with no impact on the caller world are eliminated.
       * However, the return value associated to a function is
       * conditionnally preserved.
       */
      if(!entity_constant_p(v)) {
        if(!concrete_effects_may_read_or_write_scalar_entity_p(le, v)) {
          if(!(effects_may_read_or_write_scalar_entity_p(le, v)
               && (global_variable_p(v)||formal_parameter_p(v)))) {
            if(preserve_rv_p) {
              if(!storage_return_p(entity_storage(v)))
                lost_args = arguments_add_entity(lost_args, e);
            }
            else {
              // get rid of non local return entities
              storage s = entity_storage(v);
              if(storage_return_p(s)) {
                entity f = storage_return(s);
                entity m = get_current_module_entity();
                if(f!=m)
                  lost_args = arguments_add_entity(lost_args, e);
              }
              else
                lost_args = arguments_add_entity(lost_args, e);
            }
          }
        }
      }
    }
  }
 
  /* get rid of them */
  ftf = transformer_projection(ftf, lost_args);
 
  /* free the temporary list of entities */
  gen_free_list(lost_args);
  lost_args = NIL;
 
  pips_debug(8,"return ftf=%p\n",ftf);
  ifdebug(8) (void) dump_transformer(ftf);
  pips_debug(8,"end\n");
 
  return ftf;
}

References arguments_add_entity(), BASE_UNDEFINED, BASE_UNDEFINED_P, concrete_effects_may_read_or_write_scalar_entity_p(), dump_transformer, effects_may_read_or_write_scalar_entity_p(), entity_constant_p, entity_storage, f(), formal_parameter_p(), gen_free_list(), get_current_module_entity(), global_variable_p(), ifdebug, NIL, pips_debug, predicate_system, storage_return, storage_return_p, Svecteur::succ, TCST, transformer_dup(), transformer_projection(), transformer_relation, value_to_variable(), and vecteur_var.

Referenced by c_return_to_transformer(), and transformer_intra_to_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_call_site_number()

int get_call_site_number

(

void

)

Definition at line 1131 of file interprocedural.c.

{
    return number_of_call_sites;
}

References number_of_call_sites.

Referenced by summary_precondition(), and summary_total_postcondition().

Here is the caller graph for this function:

get_module_global_arguments()

list get_module_global_arguments

(

void

)

ri_to_preconditions.c

Definition at line 98 of file ri_to_preconditions.c.

{
    return module_global_arguments;
}

References module_global_arguments.

Referenced by statement_to_postcondition(), and statement_to_total_precondition().

Here is the caller graph for this function:

get_module_precondition()

transformer get_module_precondition

(

entity

m

)

interprocedural.c

interprocedural.c

include <stdlib.h> What follows has to be updated!!!

The SUMMARY_PRECONDITION of a module m is built incrementally when the preconditions of its CALLERS are computed. Each time a call site cs to m is encountered, the precondition for cs is augmented with equations between formal and actual integer arguments. The new precondition so obtained is chained to the other preconditions for m.

In other word, SUMMARY_PRECONDITION is a list of preconditions containing each a relation between formal and actual parameter. Should it be called SUMMARY_PRECONDITIONS?

Before using the list of preconditions for m, each precondition has to:

• be translated to update references to variables in common; if they are visible in m, their entity names caller:x have to be replaced by m:x;
• be projected to eliminate variables which are not recognized by m semantics analysis (i.e. they do not appear in its value mappings);
• be replaced by their unique convex hull, which is the real module precondition.

These steps cannot be performed in the caller because the callee's value mappings are unknown.

Memory management:

• transformers stored by add_module_call_site_precondition() are copies or modified copies of the precondition argument ;
• transformers returned as module preconditions are not duplicated; it does not seem to matter for the time being because a module precondition should be used only once. Wait for the strange bugs... db_get_memory_resource() could be not PURE.

Note: illegal request are made to pipsdbm()

FI: this does not work because the summary preconditions is reset each time it should be accumulated

Definition at line 92 of file interprocedural.c.

{
  transformer p;
 
  pips_assert("get_module_precondition",entity_module_p(m));
 
  if(db_resource_p(DBR_SUMMARY_PRECONDITION, module_local_name(m)))
    p = (transformer) db_get_memory_resource(DBR_SUMMARY_PRECONDITION,
                                             module_local_name(m),
                                             true);
  else
    p = transformer_undefined;
 
  /* FI: this does not work because the summary preconditions is reset
     each time it should be accumulated */
  /*
    if(check_resource_up_to_date(DBR_SUMMARY_PRECONDITION,
    module_local_name(m))) {
    p = (transformer) db_get_memory_resource(DBR_SUMMARY_PRECONDITION,
    module_local_name(m),
    true);
    }
    else {
    p = transformer_undefined;
    }
  */
 
  return p;
}

References db_get_memory_resource(), db_resource_p(), entity_module_p(), module_local_name(), pips_assert, and transformer_undefined.

Referenced by add_module_call_site_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

get_postcondition_map()

statement_mapping get_postcondition_map

(

void

)

get_precondition_map()

statement_mapping get_precondition_map

(

void

)

Referenced by init_use_preconditions(), module_name_to_preconditions(), set_resources_for_module(), and transformer_map_print().

Here is the caller graph for this function:

get_semantic_map()

statement_mapping get_semantic_map

(

void

)

get_text_preconditions()

text get_text_preconditions

(

const

string

)

Parameters

string

odule_name

Definition at line 193 of file prettyprint.c.

{
  is_user_view = false;
  is_transformer = false;
  is_total_precondition = false;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  return get_semantic_text(module_name,false);
}

References get_bool_property(), get_semantic_text(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, and module_name().

Referenced by print_call_graph_with_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_text_total_preconditions()

text get_text_total_preconditions

(

const

string

)

Parameters

string

odule_name

Definition at line 203 of file prettyprint.c.

{
  is_user_view = false;
  is_transformer = false;
  is_total_precondition = true;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  return get_semantic_text(module_name,false);
}

References get_bool_property(), get_semantic_text(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, and module_name().

Referenced by print_call_graph_with_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_text_transformers()

text get_text_transformers

(

const

string

)

Parameters

string

odule_name

Definition at line 184 of file prettyprint.c.

{
  is_user_view = false;
  is_transformer = true;
  is_total_precondition = false;
  is_transformer_filtered = false;
  return get_semantic_text(module_name,false);
}

References get_semantic_text(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, and module_name().

Referenced by print_call_graph_with_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

get_total_precondition_map()

statement_mapping get_total_precondition_map

(

void

)

Referenced by module_name_to_total_preconditions().

Here is the caller graph for this function:

get_transformer_map()

statement_mapping get_transformer_map

(

void

)

Referenced by generic_module_name_to_transformers().

Here is the caller graph for this function:

initial_precondition()

bool initial_precondition

(

string

name

)

initial.c

initial.c

Filter out local and unused variables from the local precondition? No, because it is not possible to guess what is used or unused at the program level. Filtering is postponed to program_precondition().

Parameters

name

ame

Definition at line 75 of file initial.c.

{
    entity module = module_name_to_entity(name);
    transformer prec;
 
    debug_on("SEMANTICS_DEBUG_LEVEL");
 
    set_current_module_entity(module);
    set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, name, true));
    make_statement_global_stack();
    set_cumulated_rw_effects((statement_effects)
                   db_get_memory_resource(DBR_CUMULATED_EFFECTS, name, true));
    set_proper_rw_effects((statement_effects)
                   db_get_memory_resource(DBR_PROPER_EFFECTS, name, true));
    module_to_value_mappings(module);
 
    prec = all_data_to_precondition(module);
 
    ifdebug(1)
        pips_assert("consistent initial precondition before filtering", 
                    transformer_consistency_p(prec));
 
    /* Filter out local and unused variables from the local precondition?
     * No, because it is not possible to guess what is used or unused at
     * the program level. Filtering is postponed to program_precondition().
     */
 
    DB_PUT_MEMORY_RESOURCE(DBR_INITIAL_PRECONDITION, strdup(name), (char*) prec);
 
    reset_current_module_entity();
    reset_current_module_statement();
    free_statement_global_stack();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    free_value_mappings();
 
    debug_off();
    return true;
}

References all_data_to_precondition(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, free_statement_global_stack(), free_value_mappings(), ifdebug, make_statement_global_stack(), module, module_name_to_entity(), module_to_value_mappings(), pips_assert, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), strdup(), and transformer_consistency_p().

Here is the call graph for this function:

integer_assign_to_transformer()

transformer integer_assign_to_transformer	(	expression	lhs,
		expression	rhs,
		transformer	pre,
		list	ef
	)

This function never returns an undefined transformer.

It is used for an assignment statement, not for an assignment operation. effects of assign

algorithm: if lhs and rhs are linear expressions on scalar integer variables, build the corresponding equation; else, use effects ef

should be extended to cope with constant integer division as in N2 = N/2 because it is used in real program; inequalities should be generated in that case 2*N2 <= N <= 2*N2+1

same remark for MOD operator

implementation: part of this function should be moved into transformer.c

&& integer_scalar_entity_p(e)

FI: the initial version was conservative because only affine scalar integer assignments were processed precisely. But non-affine operators and calls to user defined functions can also bring some information as soon as some integer read or write effect exists

check that all read effects are on integer scalar entities

Check that some read or write effects are on integer scalar entities. This is almost always true... Let's hope assigned_expression_to_transformer() returns quickly for array expressions used to initialize a scalar integer entity.

if some condition was not met and transformer derivation failed

Parameters

lhs	hs
rhs	hs
pre	re
ef	f

Definition at line 2693 of file ri_to_transformers.c.

{
  /* algorithm: if lhs and rhs are linear expressions on scalar integer
     variables, build the corresponding equation; else, use effects ef
 
     should be extended to cope with constant integer division as in
     N2 = N/2
     because it is used in real program; inequalities should be
     generated in that case 2*N2 <= N <= 2*N2+1
 
     same remark for MOD operator
 
     implementation: part of this function should be moved into
     transformer.c
  */
 
  transformer tf = transformer_undefined;
  normalized n = NORMALIZE_EXPRESSION(lhs);
 
  pips_debug(8,"begin\n");
 
  if(normalized_linear_p(n)) {
    Pvecteur vlhs = (Pvecteur) normalized_linear(n);
    entity e = (entity) vecteur_var(vlhs);
 
    if(entity_has_values_p(e) /* && integer_scalar_entity_p(e) */) {
      /* FI: the initial version was conservative because
       * only affine scalar integer assignments were processed
       * precisely. But non-affine operators and calls to user defined
       * functions can also bring some information as soon as
       * *some* integer read or write effect exists
       */
      /* check that *all* read effects are on integer scalar entities */
      /*
        if(integer_scalar_read_effects_p(ef)) {
        tf = assigned_expres`sion_to_transformer(e, rhs, ef);
        }
      */
      /* Check that *some* read or write effects are on integer
       * scalar entities. This is almost always true... Let's hope
       * assigned_expression_to_transformer() returns quickly for array
       * expressions used to initialize a scalar integer entity.
       */
      if(some_integer_scalar_read_or_write_effects_p(ef)) {
        tf = assigned_expression_to_transformer(e, rhs, pre);
      }
    }
  }
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tf=%lx\n", (unsigned long)tf);
  ifdebug(6) (void) print_transformer(tf);
  pips_debug(8,"end\n");
  return tf;
}

References assigned_expression_to_transformer(), effects_to_transformer(), entity_has_values_p(), ifdebug, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, print_transformer, some_integer_scalar_read_or_write_effects_p(), transformer_undefined, and vecteur_var.

Here is the call graph for this function:

integer_assign_to_transformer_list()

list integer_assign_to_transformer_list	(	expression	lhs,
		expression	rhs,
		transformer	pre,
		list	ef
	)

This function never returns an undefined transformer.

It is used for an assignment statement, not for an assignment operation. effects of assign

algorithm: if lhs and rhs are linear expressions on scalar integer variables, build the corresponding equation; else, use effects ef

should be extended to cope with constant integer division as in N2 = N/2 because it is used in real program; inequalities should be generated in that case 2*N2 <= N <= 2*N2+1

same remark for MOD operator

implementation: part of this function should be moved into transformer.c

&& integer_scalar_entity_p(e)

FI: the initial version was conservative because only affine scalar integer assignments were processed precisely. But non-affine operators and calls to user defined functions can also bring some information as soon as some integer read or write effect exists

check that all read effects are on integer scalar entities

Check that some read or write effects are on integer scalar entities. This is almost always true... Let's hope assigned_expression_to_transformer() returns quickly for array expressions used to initialize a scalar integer entity.

if some condition was not met and transformer derivation failed

Parameters

lhs	hs
rhs	hs
pre	re
ef	f

Definition at line 645 of file ri_to_transformer_lists.c.

{
  /* algorithm: if lhs and rhs are linear expressions on scalar integer
     variables, build the corresponding equation; else, use effects ef
 
     should be extended to cope with constant integer division as in
     N2 = N/2
     because it is used in real program; inequalities should be
     generated in that case 2*N2 <= N <= 2*N2+1
 
     same remark for MOD operator
 
     implementation: part of this function should be moved into
     transformer.c
  */
 
  list tl = NIL;
  transformer tf = transformer_undefined;
  normalized n = NORMALIZE_EXPRESSION(lhs);
 
  pips_internal_error("Not implemented yet.");
 
  pips_debug(8,"begin\n");
 
  if(normalized_linear_p(n)) {
    Pvecteur vlhs = (Pvecteur) normalized_linear(n);
    entity e = (entity) vecteur_var(vlhs);
 
    if(entity_has_values_p(e) /* && integer_scalar_entity_p(e) */) {
      /* FI: the initial version was conservative because
       * only affine scalar integer assignments were processed
       * precisely. But non-affine operators and calls to user defined
       * functions can also bring some information as soon as
       * *some* integer read or write effect exists
       */
      /* check that *all* read effects are on integer scalar entities */
      /*
        if(integer_scalar_read_effects_p(ef)) {
        tf = assigned_expres`sion_to_transformer(e, rhs, ef);
        }
      */
      /* Check that *some* read or write effects are on integer
       * scalar entities. This is almost always true... Let's hope
       * assigned_expression_to_transformer() returns quickly for array
       * expressions used to initialize a scalar integer entity.
       */
      if(some_integer_scalar_read_or_write_effects_p(ef)) {
        tf = assigned_expression_to_transformer(e, rhs, pre);
      }
    }
  }
  /* if some condition was not met and transformer derivation failed */
  if(tf==transformer_undefined)
    tf = effects_to_transformer(ef);
 
  pips_debug(6,"return tl=%lx\n", (unsigned long)tl);
  ifdebug(6) (void) print_transformers(tl);
  pips_debug(8,"end\n");
  return tl;
}

References assigned_expression_to_transformer(), effects_to_transformer(), entity_has_values_p(), ifdebug, NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, pips_internal_error, print_transformers(), some_integer_scalar_read_or_write_effects_p(), transformer_undefined, and vecteur_var.

Here is the call graph for this function:

integer_expression_and_precondition_to_integer_interval()

void integer_expression_and_precondition_to_integer_interval	(	expression	e,
		transformer	p,
		int *	plb,
		int *	pub
	)

Could be used for bool expressions too? Extended to any kind of expression?

p is assumed to be a real precondition, i.e. a transformer_range().

This function is used by semantics as well as exported to other passes. To take care of debug_on()/debug_off(), set and reset_analyzed_types(), a different wrapper is needed.

If expression e is transformer-wise side-effect free (i.e. the ABSTRACT store is not modified)

precondition p is not feasible

Parameters

plb	lb
pub	ub

Definition at line 386 of file utils.c.

{
  debug_on("SEMANTICS_DEBUG_LEVEL");
  // set_analyzed_types();
  type t = expression_to_type(e);
  entity tmp = make_local_temporary_value_entity(t);
  transformer et = integer_expression_to_transformer(tmp, e, p, true);
 
  /* If expression e is transformer-wise side-effect free (i.e. the ABSTRACT store is not modified)*/
  if(!transformer_undefined_p(et) && ENDP(transformer_arguments(et))) {
    transformer tp = transformer_range_intersection(transformer_dup(p), et);
    Psysteme s = transformer_undefined_p(tp) ?
      sc_make(CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED) :
      sc_dup((Psysteme) predicate_system(transformer_relation(tp)));
    Value lb = VALUE_ZERO, ub = VALUE_ZERO;
 
    if(sc_minmax_of_variable(s, (Variable) tmp, 
                             &lb, &ub)) {
      *plb = value_min_p(lb)? INT_MIN : VALUE_TO_INT(lb);
      *pub = value_max_p(ub)? INT_MAX : VALUE_TO_INT(ub);
    }
    else {
      /* precondition p is not feasible */
      *plb = 1;
      *pub = 0;
    }
  }
  else {
    *plb = INT_MIN;
    *pub = INT_MAX;
  }
  //reset_analyzed_types();
  debug_off();
}

References CONTRAINTE_UNDEFINED, debug_off, debug_on, ENDP, expression_to_type(), integer_expression_to_transformer(), make_local_temporary_value_entity(), predicate_system, sc_dup(), sc_make(), sc_minmax_of_variable(), transformer_arguments, transformer_dup(), transformer_range_intersection(), transformer_relation, transformer_undefined_p, value_max_p, value_min_p, VALUE_TO_INT, and VALUE_ZERO.

Referenced by eval_linear_expression(), expression_multiply_sizeof_to_transformer(), generic_abs_to_transformer(), and loop_to_enter_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_expression_to_transformer()

transformer integer_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre,
		bool	is_internal
	)

Do check wrt to value mappings...

if you are not dealing with interprocedural issues

Assume: e is a value

Is it really useful to keep using this function which does not take the precondition into acount?

vect_rm(ve);

Parameters

expr	xpr
pre	re
is_internal	s_internal

Definition at line 3476 of file expression.c.

{
  transformer tf = transformer_undefined;
  normalized n = NORMALIZE_EXPRESSION(expr);
  syntax sexpr = expression_syntax(expr);
 
  pips_debug(8, "begin with precondition %p for expression: ", pre);
  ifdebug(8) print_expression(expr);
 
  /* Assume: e is a value */
 
  if(normalized_linear_p(n)) {
    /* Is it really useful to keep using this function which does not
       take the precondition into acount? */
    if(transformer_undefined_p(pre)) {
      tf = simple_affine_to_transformer(v, (Pvecteur) normalized_linear(n), is_internal);
    }
    else {
      transformer tfl = simple_affine_to_transformer(v, (Pvecteur) normalized_linear(n), is_internal);
      if(transformer_undefined_p(tfl)) {
        tfl = expression_effects_to_transformer(expr);
      }
 
      tf = transformer_combine(copy_transformer(pre), tfl);
      free_transformer(tfl);
    }
  }
  else if(syntax_call_p(sexpr)) {
    tf = integer_call_expression_to_transformer(v, expr, pre, is_internal);
  }
  else if(syntax_reference_p(sexpr)) {
    //entity e = reference_variable(syntax_reference(sexpr));
    reference r = syntax_reference(sexpr);
    tf = generic_reference_to_transformer(v, r, pre, is_internal);
  }
  else if(syntax_cast_p(sexpr)) {
    cast c = syntax_cast(sexpr);
    type ct = cast_type(c);
    expression cexp = cast_expression(c);
    type cexpt = expression_to_type(cexp);
    if (type_equal_p(ct, cexpt))
      tf = integer_expression_to_transformer(v, cexp, pre, is_internal);
    else
      tf = transformer_undefined;
    free_type(cexpt);
 
  }
  else if(syntax_sizeofexpression_p(sexpr)) {
    if(get_bool_property("EVAL_SIZEOF")) {
      sizeofexpression soe = syntax_sizeofexpression(sexpr);
      value val = EvalSizeofexpression(soe);
      if(value_constant_p(val) && constant_int_p(value_constant(val))) {
        long long int i = constant_int(value_constant(val));
        tf = transformer_identity();
        tf = transformer_add_equality_with_integer_constant(tf, v, i);
      }
    }
    else
      tf = transformer_undefined;
  }
  else {
    /* vect_rm(ve); */
    tf = transformer_undefined;
  }
 
  pips_debug(8, "end with tf=%p\n", tf);
 
  return tf;
}

References cast_expression, cast_type, constant_int, constant_int_p, copy_transformer(), EvalSizeofexpression(), expression_effects_to_transformer(), expression_syntax, expression_to_type(), free_transformer(), free_type(), generic_reference_to_transformer(), get_bool_property(), ifdebug, integer_call_expression_to_transformer(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, print_expression(), simple_affine_to_transformer(), syntax_call_p, syntax_cast, syntax_cast_p, syntax_reference, syntax_reference_p, syntax_sizeofexpression, syntax_sizeofexpression_p, transformer_add_equality_with_integer_constant(), transformer_combine(), transformer_identity(), transformer_undefined, transformer_undefined_p, type_equal_p(), value_constant, and value_constant_p.

Referenced by any_expression_to_transformer(), iabs_to_transformer(), integer_expression_and_precondition_to_integer_interval(), integer_minmax_to_transformer(), and safe_integer_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_value_and_precondition_to_integer_interval()

void integer_value_and_precondition_to_integer_interval	(	entity	v,
		transformer	p,
		int *	plb,
		int *	pub
	)

Should be used by previous function, integer_expression_and_precondition_to_integer_interval()

precondition p is not feasible

Parameters

plb	lb
pub	ub

Definition at line 427 of file utils.c.

{
  Psysteme s = transformer_undefined_p(p) ?
    sc_make(CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED) :
    sc_dup((Psysteme) predicate_system(transformer_relation(p)));
  Value lb = VALUE_ZERO, ub = VALUE_ZERO;
 
  if(sc_minmax_of_variable(s, (Variable) v, 
                           &lb, &ub)) {
    *plb = value_min_p(lb)? INT_MIN : VALUE_TO_INT(lb);
    *pub = value_max_p(ub)? INT_MAX : VALUE_TO_INT(ub);
  }
  else {
    /* precondition p is not feasible */
    *plb = 1;
    *pub = 0;
  }
}

References CONTRAINTE_UNDEFINED, predicate_system, sc_dup(), sc_make(), sc_minmax_of_variable(), transformer_relation, transformer_undefined_p, value_max_p, value_min_p, VALUE_TO_INT, and VALUE_ZERO.

Referenced by integer_binary_operation_to_transformer(), and integer_multiply_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

interprocedural_summary_precondition()

bool interprocedural_summary_precondition

(

char *

module_name

)

The DATA statement from all modules, called or not called, are used, as well as the preconditions at all call sites.

Parameters

module_name

odule_name

Definition at line 545 of file dbm_interface.c.

{
  /* The DATA statement from all modules, called or not called, are used,
     as well as the preconditions at all call sites. */
  set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
  return summary_precondition(module_name);
}

References module_name(), SEMANTICS_INTERPROCEDURAL, set_bool_property(), and summary_precondition().

Here is the call graph for this function:

interprocedural_summary_precondition_with_points_to()

bool interprocedural_summary_precondition_with_points_to

(

char *

module_name

)

The DATA statement from all modules, called or not called, are used, as well as the preconditions at all call sites. Points_to information is required to perform a more accurate translation between callesr and callees.

Parameters

module_name

odule_name

Definition at line 571 of file dbm_interface.c.

{
  /* The DATA statement from all modules, called or not called, are
   * used, as well as the preconditions at all call sites. Points_to
   * information is required to perform a more accurate translation
   * between callesr and callees.
   */
  set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
  set_use_points_to();
  bool result_p = summary_precondition(module_name);
  reset_use_points_to();
  return result_p;
}

References module_name(), reset_use_points_to(), SEMANTICS_INTERPROCEDURAL, set_bool_property(), set_use_points_to(), and summary_precondition().

Here is the call graph for this function:

intraprocedural_summary_precondition()

bool intraprocedural_summary_precondition

(

char *

module_name

)

The current module is sufficient to derive it.

Parameters

module_name

odule_name

Definition at line 538 of file dbm_interface.c.

{
  /* The current module is sufficient to derive it. */
  set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
  return summary_precondition(module_name);
}

References module_name(), SEMANTICS_INTERPROCEDURAL, set_bool_property(), and summary_precondition().

Here is the call graph for this function:

intrinsic_to_transformer()

transformer intrinsic_to_transformer	(	entity	e,
		list	pc,
		transformer	pre,
		list	ef
	)

effects of intrinsic call

FI: this may happen, for instance with the macro definition of assert() or because the programmer writes "i>1? (i = 2): (i = 3);" instead of "i = i>1? 2 : 3;"

FI: the condition should be evaluated and considered true on exit, but this is sometimes captured by a macro definition and the code below is then useless

The result is positive and less than RAND_MAX, but it is ignored by the semantics anaysis

Parameters

pc	c
pre	re
ef	f

Definition at line 911 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
 
  pips_debug(8, "begin\n");
 
  if(ENTITY_ASSIGN_P(e)) {
    tf = any_assign_to_transformer(pc, ef, pre);
  }
  else if(ENTITY_PLUS_UPDATE_P(e) || ENTITY_MINUS_UPDATE_P(e)
      || ENTITY_MULTIPLY_UPDATE_P(e) || ENTITY_DIVIDE_UPDATE_P(e)
      || ENTITY_MODULO_UPDATE_P(e) || ENTITY_LEFT_SHIFT_UPDATE_P(e)
      || ENTITY_RIGHT_SHIFT_UPDATE_P(e) || ENTITY_BITWISE_AND_UPDATE_P(e)
      || ENTITY_BITWISE_XOR_UPDATE_P(e) || ENTITY_BITWISE_OR_UPDATE_P(e)) {
    //tf = update_addition_operation_to_transformer(pc, ef, pre);
    tf = any_update_to_transformer(e, pc, ef, pre);
  }
  else if(ENTITY_POST_INCREMENT_P(e) || ENTITY_POST_DECREMENT_P(e)
      || ENTITY_PRE_INCREMENT_P(e) || ENTITY_PRE_DECREMENT_P(e)) {
    tf = any_basic_update_to_transformer(e, pc, ef, pre);
  }
  else if(ENTITY_C_RETURN_P(e)) {
    tf = c_return_to_transformer(e, pc, ef, pre);
  }
  else if(ENTITY_STOP_P(e)||ENTITY_ABORT_SYSTEM_P(e)||ENTITY_EXIT_SYSTEM_P(e)
      || ENTITY_ASSERT_FAIL_SYSTEM_P(e))
    tf = transformer_empty();
  else if(ENTITY_COMMA_P(e)) {
    tf = expressions_to_transformer(pc, pre);
  }
  else if(ENTITY_CONDITIONAL_P(e)) {
    /* FI: this may happen, for instance with the macro definition of
       assert() or because the programmer writes "i>1? (i = 2): (i =
       3);" instead of "i = i>1? 2 : 3;" */
    expression cond = EXPRESSION(CAR(pc));
    expression e1 = EXPRESSION(CAR(CDR(pc)));
    expression e2 = EXPRESSION(CAR(CDR(CDR(pc))));
    tf = conditional_to_transformer(cond, e1, e2, pre, ef);
  }
  else if(ENTITY_ASSERT_SYSTEM_P(e)) {
    /* FI: the condition should be evaluated and considered true on
       exit, but this is sometimes captured by a macro definition and the code
       below is then useless */
    expression cond = EXPRESSION(CAR(pc));
    tf = condition_to_transformer(cond, pre, true);
  }
  else if(ENTITY_RAND_P(e)) {
    /* The result is positive and less than RAND_MAX, but it is
       ignored by the semantics anaysis */
    semantics_user_warning("Value returned by intrinsic \"rand\" is ignored.\n");
    //tf = transformer_add_inequality_with_integer_constraint(transformer_identity(),
    // e, 0, true);
    tf = transformer_identity();
  }
  else
    tf = effects_to_transformer(ef);
 
  pips_debug(8, "end\n");
 
  return tf;
}

References any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), c_return_to_transformer(), CAR, CDR, condition_to_transformer(), conditional_to_transformer(), effects_to_transformer(), ENTITY_ABORT_SYSTEM_P, ENTITY_ASSERT_FAIL_SYSTEM_P, ENTITY_ASSERT_SYSTEM_P, ENTITY_ASSIGN_P, ENTITY_BITWISE_AND_UPDATE_P, ENTITY_BITWISE_OR_UPDATE_P, ENTITY_BITWISE_XOR_UPDATE_P, ENTITY_C_RETURN_P, ENTITY_COMMA_P, ENTITY_CONDITIONAL_P, ENTITY_DIVIDE_UPDATE_P, ENTITY_EXIT_SYSTEM_P, ENTITY_LEFT_SHIFT_UPDATE_P, ENTITY_MINUS_UPDATE_P, ENTITY_MODULO_UPDATE_P, ENTITY_MULTIPLY_UPDATE_P, ENTITY_PLUS_UPDATE_P, ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_DECREMENT_P, ENTITY_PRE_INCREMENT_P, ENTITY_RAND_P, ENTITY_RIGHT_SHIFT_UPDATE_P, ENTITY_STOP_P, EXPRESSION, expressions_to_transformer(), pips_debug, semantics_user_warning, transformer_empty(), transformer_identity(), and transformer_undefined.

Referenced by call_to_postcondition(), and call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

intrinsic_to_transformer_list()

list intrinsic_to_transformer_list	(	entity	e,
		list	pc,
		transformer	pre,
		list	ef
	)

because of the conditional and the comma C intrinsics at least

effects of intrinsic call

FI: this may happen, for instance with the macro definition of assert() or because the programmer writes "i>1? (i = 2): (i = 3);" instead of "i = i>1? 2 : 3;"

FI: the condition should be evaluated and considered true on exit, but this is sometimes captured by a macro definition and the code below is then useless

Parameters

pc	c
pre	re
ef	f

Definition at line 480 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
 
  pips_internal_error("Not implemented yet.");
 
  pips_debug(8, "begin\n");
 
  if(ENTITY_ASSIGN_P(e)) {
    tf = any_assign_to_transformer(pc, ef, pre);
  }
 else if(ENTITY_PLUS_UPDATE_P(e) || ENTITY_MINUS_UPDATE_P(e)
         || ENTITY_MULTIPLY_UPDATE_P(e) || ENTITY_DIVIDE_UPDATE_P(e)
         || ENTITY_MODULO_UPDATE_P(e) || ENTITY_LEFT_SHIFT_UPDATE_P(e)
         || ENTITY_RIGHT_SHIFT_UPDATE_P(e) || ENTITY_BITWISE_AND_UPDATE_P(e)
         || ENTITY_BITWISE_XOR_UPDATE_P(e) || ENTITY_BITWISE_OR_UPDATE_P(e)) {
    //tf = update_addition_operation_to_transformer(pc, ef, pre);
   tf = any_update_to_transformer(e, pc, ef, pre);
  }
 else if(ENTITY_POST_INCREMENT_P(e) || ENTITY_POST_DECREMENT_P(e)
         || ENTITY_PRE_INCREMENT_P(e) || ENTITY_PRE_DECREMENT_P(e)) {
   tf = any_basic_update_to_transformer(e, pc, ef, pre);
  }
 else if(ENTITY_C_RETURN_P(e)) {
   tf = c_return_to_transformer(e, pc, ef, pre);
  }
  else if(ENTITY_STOP_P(e)||ENTITY_ABORT_SYSTEM_P(e)||ENTITY_EXIT_SYSTEM_P(e)
          || ENTITY_ASSERT_FAIL_SYSTEM_P(e))
    tf = transformer_empty();
  else if(ENTITY_COMMA_P(e)) {
    tf = expressions_to_transformer(pc, pre);
  }
  else if(ENTITY_CONDITIONAL_P(e)) {
    /* FI: this may happen, for instance with the macro definition of
       assert() or because the programmer writes "i>1? (i = 2): (i =
       3);" instead of "i = i>1? 2 : 3;" */
    expression cond = EXPRESSION(CAR(pc));
    expression e1 = EXPRESSION(CAR(CDR(pc)));
    expression e2 = EXPRESSION(CAR(CDR(CDR(pc))));
    tf = conditional_to_transformer(cond, e1, e2, pre, ef);
  }
  else if(ENTITY_ASSERT_SYSTEM_P(e)) {
    /* FI: the condition should be evaluated and considered true on
       exit, but this is sometimes captured by a macro definition and the code
       below is then useless */
    expression cond = EXPRESSION(CAR(pc));
    tf = condition_to_transformer(cond, pre, true);
  }
  else
    tf = effects_to_transformer(ef);
 
  pips_debug(8, "end\n");
 
  tl=CONS(TRANSFORMER,tf,NIL);
  return tl;
}

References any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), c_return_to_transformer(), CAR, CDR, condition_to_transformer(), conditional_to_transformer(), CONS, effects_to_transformer(), ENTITY_ABORT_SYSTEM_P, ENTITY_ASSERT_FAIL_SYSTEM_P, ENTITY_ASSERT_SYSTEM_P, ENTITY_ASSIGN_P, ENTITY_BITWISE_AND_UPDATE_P, ENTITY_BITWISE_OR_UPDATE_P, ENTITY_BITWISE_XOR_UPDATE_P, ENTITY_C_RETURN_P, ENTITY_COMMA_P, ENTITY_CONDITIONAL_P, ENTITY_DIVIDE_UPDATE_P, ENTITY_EXIT_SYSTEM_P, ENTITY_LEFT_SHIFT_UPDATE_P, ENTITY_MINUS_UPDATE_P, ENTITY_MODULO_UPDATE_P, ENTITY_MULTIPLY_UPDATE_P, ENTITY_PLUS_UPDATE_P, ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_DECREMENT_P, ENTITY_PRE_INCREMENT_P, ENTITY_RIGHT_SHIFT_UPDATE_P, ENTITY_STOP_P, EXPRESSION, expressions_to_transformer(), NIL, pips_debug, pips_internal_error, TRANSFORMER, transformer_empty(), and transformer_undefined.

Here is the call graph for this function:

lhs_expression_to_transformer()

transformer lhs_expression_to_transformer	(	entity	e,
		expression	lhs,
		transformer	pre
	)

This function deals with e1.e2 and e1->e2, not with simple references such as x or a[i].

This piece of code has mainly been retrieved from any_assign_to_transformer().

FI: I am not sure how to factorize it out because entity e corresponds to some memory location and is modified in an assignement environment. Here, e is likely to be a temporary value. It is not updated. It should not appear among the transformer arguments

Parameters

lhs	hs
pre	re

Definition at line 6262 of file expression.c.

{
  syntax slhs = expression_syntax(lhs);
  transformer tf = transformer_undefined;
 
  if(syntax_call_p(slhs)) {
    if (!pt_to_list_undefined_p() || constant_path_analyzed_p()) {
      list l = semantics_expression_to_points_to_sources(lhs);
      int n = (int) gen_length(l);
      // FI: I wonder what happens with side effects in the rhs and
      // with pointer dereferencing in the rhs
      FOREACH(CELL, cp, l) {
        reference rlhs = cell_any_reference(cp);
 
        // example of case which is normally filter *p when p formal
        // parameter, or dynamic allocation of p
        if(semantics_usable_points_to_reference_p(rlhs, lhs, n)) {
          if (analyzed_reference_p(rlhs)) {
            entity ecp = constant_memory_access_path_to_location_entity(rlhs);
 
            if(!entity_undefined_p(ecp)) { // the location is analyzed
              // The preconditions may make the convex hull useful when
              // different locations have known values or are
              // constrained
              transformer rt = copy_transformer(pre);
              rt = transformer_add_equality(rt, e, ecp);
 
              // NL : a better way to do this may exit but I don't know it
              if (transformer_undefined_p(tf))
                tf = rt;
              else {
                tf = transformer_convex_hull(tf, rt);
                free_transformer(rt);
              }
            }
          }
        }
      }
    }
  }
  else {
    // It might be more useful to process the reference for side effects
    pips_internal_error("Improper argument.\n");
  }
  return tf;
}

References analyzed_reference_p(), CELL, cell_any_reference(), constant_memory_access_path_to_location_entity(), constant_path_analyzed_p(), copy_transformer(), cp, entity_undefined_p, expression_syntax, FOREACH, free_transformer(), gen_length(), int, pips_internal_error, pt_to_list_undefined_p(), semantics_expression_to_points_to_sources(), semantics_usable_points_to_reference_p(), syntax_call_p, transformer_add_equality(), transformer_convex_hull(), transformer_undefined, and transformer_undefined_p.

Referenced by integer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

load_body_effects()

list load_body_effects

(

entity

e

)

Definition at line 1508 of file dbm_interface.c.

{
  string module_name = (string) module_local_name(e);
 
    pips_assert("load_summary_effects", entity_module_p(e));
 
    statement b = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
    statement_effects se = (statement_effects)
      db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true);
    effects be = (effects) (intptr_t)HASH_GET(p, p, statement_effects_hash_table(se), (void *) b);
    list bel = effects_effects(be);
 
    pips_assert("bel is defined", bel != list_undefined);
 
    return bel;
}

References db_get_memory_resource(), effects_effects, entity_module_p(), HASH_GET, intptr_t, list_undefined, module_local_name(), module_name(), pips_assert, and statement_effects_hash_table.

Referenced by user_call_to_points_to_interprocedural().

Here is the call graph for this function:

Here is the caller graph for this function:

load_completed_statement_transformer()

transformer load_completed_statement_transformer

(

statement

s

)

three mappings used throughout semantics analysis:

• transformer_map is computed in a first phase
• precondition_map is computed in a second phase
• cumulated_effects is used and assumed computed before (defined in effects.c)
• proper_effects might be useless... only DO loop analysis could use it (idem) declaration of the previously described mappings with their access functions :

(DEFINE_CURRENT_MAPPING is a macro defined in ~pips/Newgen/mapping.h)

BA, August 26, 1993 Returns the entry to exit transformer associated to a statement, since all statements in PIPS internal representation have a unique exit.

The transformers associated to loops are the transformers linking the loop precondition to the loop body precondition. When dealing with sequences or test or... the transformer linking the loop precondition to its postcondition, i.e. the precondition hodling at the loop exit, is needed.

To complete the statement transformer, a precondition is required. Different preconditions can be used:

• transformer_identity(): provides no information
• load_statement_precondition(): provides as much information as possible
• the transformer domain: provides information available when the transformers are computed, i.e. preconditions do not have to be available; this is unsafe as the loop entrance transition domain may be a subset of the precocndition, unless the loop is always entered.

Unlike load_statement_transformer(), this function allocates a new transformer. See comments associated to:

generic_complete_statement_transformer()

Definition at line 131 of file dbm_interface.c.

{
  transformer t = load_statement_transformer(s);
 
  // Unsafe if s is a loop, unless you check that the loop is always
  //entered
  //transformer pre = transformer_to_domain(t);
  transformer pre = transformer_identity();
 
  transformer te = complete_statement_transformer(t, pre, s);
 
  //pips_assert("te is defined", !transformer_undefined_p(te));
 
  free_transformer(pre);
 
  return te;
}

References complete_statement_transformer(), free_transformer(), load_statement_transformer(), and transformer_identity().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

load_cycle_fix_point()

transformer load_cycle_fix_point	(	control	c,
		hash_table	fix_point_map
	)

Parameters

fix_point_map

ix_point_map

Definition at line 544 of file unstructured.c.

{
  transformer fptf = transformer_undefined;
 
  if((fptf = (transformer) hash_get(fix_point_map, (void *) c))
     == (transformer) (HASH_UNDEFINED_VALUE)) 
    pips_assert("c is not a cycle head", false);
 
  return fptf;
}

References hash_get(), HASH_UNDEFINED_VALUE, pips_assert, and transformer_undefined.

Here is the call graph for this function:

load_cycle_temporary_precondition()

transformer load_cycle_temporary_precondition	(	control	,
		control_mapping	,
		hash_table	,
		hash_table
	)

load_module_intraprocedural_effects()

list load_module_intraprocedural_effects

(

entity

e

)

memoization could be used to improve efficiency

Definition at line 1526 of file dbm_interface.c.

{
    /* memoization could be used to improve efficiency */
    list t;
    statement s;
 
    pips_assert("is a module", entity_module_p(e));
    pips_assert("is the current module", e == get_current_module_entity());
    s = get_current_module_statement();
    pips_assert("some statement", s!=statement_undefined);
 
    t = load_cumulated_rw_effects_list(s);
 
    pips_assert("some list", t != list_undefined);
 
    return t;
}

References entity_module_p(), get_current_module_entity(), get_current_module_statement(), list_undefined, load_cumulated_rw_effects_list(), pips_assert, and statement_undefined.

Referenced by allocate_module_value_mappings(), data_to_precondition(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

load_statement_postcondition()

transformer load_statement_postcondition

(

statement

)

Referenced by statement_context().

Here is the caller graph for this function:

load_statement_precondition()

transformer load_statement_precondition

(

statement

)

Referenced by __attribute__(), add_alias_pairs_for_this_call_site(), any_complexities(), block_to_complexity(), comp_regions_of_statement(), create_step_regions(), do_array_expansion(), do_solve_hardware_constraints_on_nb_proc(), do_solve_hardware_constraints_on_volume(), effects_to_dma(), first_precondition_of_module(), formal_array_resizing_bottom_up(), interprocedural_abc_arrays(), loop_executed_approximation(), new_block_to_complexity(), out_regions_from_call_site_to_callee(), parametric_statement_feasible_p(), partial_eval_min_or_max_operator(), process_ready_node(), process_unreachable_node(), set_methods_for_convex_effects(), set_methods_for_convex_rw_pointer_effects(), statement_context(), statement_to_complexity(), statement_to_postcondition(), statement_to_total_precondition(), statement_to_transformer(), statement_to_transformer_list(), statement_weakly_feasible_p(), step_translate_and_map(), stmt_prec(), TestCoupleOfEffects(), xml_Call(), and xml_Loop().

Here is the caller graph for this function:

load_statement_semantic()

transformer load_statement_semantic

(

statement

)

Referenced by call_site_to_module_precondition_text(), memorize_precondition_for_summary_precondition(), and semantic_to_text().

Here is the caller graph for this function:

load_statement_temporary_precondition()

transformer load_statement_temporary_precondition	(	statement	s,
		statement_mapping	statement_temporary_precondition_map
	)

Parameters

statement_temporary_precondition_map

tatement_temporary_precondition_map

Definition at line 1069 of file unstructured.c.

{
  transformer t_pre = (transformer) hash_get(statement_temporary_precondition_map, (void *) s);
 
  pips_assert("The cycle precondition is available",
              t_pre != (transformer) HASH_UNDEFINED_VALUE);
 
    return t_pre;
}

References hash_get(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by cycle_to_flow_sensitive_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

load_statement_total_precondition()

transformer load_statement_total_precondition

(

statement

)

Referenced by statement_to_total_precondition().

Here is the caller graph for this function:

load_statement_transformer()

transformer load_statement_transformer

(

statement

)

Referenced by add_loop_index_exit_value(), any_loop_to_k_transformer(), comp_regions_of_statement(), complete_forloop_transformer(), complete_forloop_transformer_list(), complete_loop_transformer(), complete_loop_transformer_list(), complete_repeatloop_transformer_list(), cycle_to_flow_sensitive_preconditions(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), forloop_to_postcondition(), load_completed_statement_transformer(), loop_to_total_precondition(), loop_to_transformer(), new_complete_whileloop_transformer_list(), old_complete_whileloop_transformer(), process_ready_node(), process_unreachable_node(), recompute_loop_transformer(), repeatloop_to_postcondition(), repeatloop_to_transformer(), set_methods_for_convex_effects(), set_methods_for_convex_rw_pointer_effects(), statement_to_postcondition(), statement_to_total_precondition(), statement_to_transformer(), statement_to_transformer_list(), unreachable_node_to_transformer(), unstructured_to_flow_insensitive_transformer(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the caller graph for this function:

load_summary_effects()

list load_summary_effects

(

entity

e

)

FI->FI, FI->BC: these two functions should be moved into effects-util or effects-simple.

memorization could be used to improve efficiency

Definition at line 1492 of file dbm_interface.c.

{
    /* memorization could be used to improve efficiency */
    list t;
 
    pips_assert("load_summary_effects", entity_module_p(e));
 
    t = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_local_name(e),
                               true));
 
    pips_assert("t is defined", t != list_undefined);
 
    return t;
}

References db_get_memory_resource(), effects_to_list(), entity_module_p(), list_undefined, module_local_name(), and pips_assert.

Referenced by add_module_call_site_precondition(), call_site_to_module_precondition_text(), compute_summary_reductions(), module_to_value_mappings(), pure_function_p(), update_precondition_with_call_site_preconditions(), and user_call_to_points_to_fast_interprocedural().

Here is the call graph for this function:

Here is the caller graph for this function:

load_summary_precondition()

transformer load_summary_precondition

(

entity

e

)

summary_preconditions are expressed in any possible frame, in fact the frame of the last procedure that used/produced it

memoization could be used to improve efficiency

Not done earlier, because the value mappings were not available. On the other hand, htis assumes that the value mappings have been initialized before a call to load_summary_precondition(0 is performed.

Definition at line 1431 of file dbm_interface.c.

{
  /* memoization could be used to improve efficiency */
  transformer t;
 
  pips_assert("e is a module", entity_module_p(e));
 
  pips_debug(8, "begin\n for %s\n",
             module_local_name(e));
 
  t = (transformer)
    db_get_memory_resource(DBR_SUMMARY_PRECONDITION, module_local_name(e),
                           true);
  /* Not done earlier, because the value mappings were not available. On
     the other hand, htis assumes that the value mappings have been
     initialized before a call to load_summary_precondition(0 is
     performed.*/
  translate_global_values(e, t);
 
  pips_assert("the summary precondition t is defined", t != transformer_undefined);
 
  ifdebug(8) {
    pips_debug(8, " precondition for %s:\n",
               module_local_name(e));
    dump_transformer(t);
    pips_debug(8, " end\n");
  }
 
  return t;
}

References db_get_memory_resource(), dump_transformer, entity_module_p(), ifdebug, module_local_name(), pips_assert, pips_debug, transformer_undefined, and translate_global_values().

Referenced by generic_module_name_to_transformers(), and module_name_to_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

load_summary_total_postcondition()

transformer load_summary_total_postcondition

(

entity

e

)

summary_preconditions are expressed in any possible frame, in fact the frame of the last procedure that used/produced it

Definition at line 1465 of file dbm_interface.c.

{
    transformer t_post = transformer_undefined;;
 
    pips_assert("e is a module", entity_module_p(e));
 
    pips_debug(8, "begin\n for %s\n",
          module_local_name(e));
 
    t_post = (transformer)
        db_get_memory_resource(DBR_SUMMARY_TOTAL_POSTCONDITION, module_local_name(e),
                               true);
 
    pips_assert("t is defined", t_post != transformer_undefined);
 
    ifdebug(8) {
        pips_debug(8, " total postcondition for %s:\n",
              module_local_name(e));
        dump_transformer(t_post);
        pips_debug(8, " end\n");
    }
 
    return t_post;
}

References db_get_memory_resource(), dump_transformer, entity_module_p(), ifdebug, module_local_name(), pips_assert, pips_debug, and transformer_undefined.

Referenced by module_name_to_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

load_summary_transformer()

transformer load_summary_transformer

(

entity

e

)

FI: I had to add a guard db_resource_p() on Nov. 14, 1995. I do not understand why the problem never occured before, although it should each time the intra-procedural option is selected.

This may partially be explained because summary transformers are implicitly computed with transformers instead of using an explicit call to summary_transformer (I guess I'm going to change that).

I think it would be better not to call load_summary_transformer() at all when no interprocedural options are selected. I should change that too.

memoization could be used to improve efficiency

db_get_memory_resource never returns database_undefined or resource_undefined

Let's be careful with people using an intraprocedural analysis of the transformers and requesting an interprocedural analysis of the preconditions...

Definition at line 1327 of file dbm_interface.c.

{
    /* FI: I had to add a guard db_resource_p() on Nov. 14, 1995.
     * I do not understand why the problem never occured before,
     * although it should each time the intra-procedural option
     * is selected.
     *
     * This may partially be explained because summary transformers
     * are implicitly computed with transformers instead of using
     * an explicit call to summary_transformer (I guess I'm going
     * to change that).
     *
     * I think it would be better not to call load_summary_transformer()
     * at all when no interprocedural options are selected. I should
     * change that too.
     */
 
    /* memoization could be used to improve efficiency */
    transformer t = transformer_undefined;
 
    pips_assert("e is a module", entity_module_p(e));
 
    if(db_resource_p(DBR_SUMMARY_TRANSFORMER, module_local_name(e))) {
        t = (transformer)
            db_get_memory_resource(DBR_SUMMARY_TRANSFORMER,
                                   entity_local_name(e),
                                   true);
 
        /* db_get_memory_resource never returns database_undefined or
           resource_undefined */
        pips_assert("load_summary_transformer", t != transformer_undefined);
    }
    else {
        t = transformer_undefined;
    }
 
    /* Let's be careful with people using an intraprocedural analysis
       of the transformers and requesting an interprocedural analysis
       of the preconditions... */
    if(transformer_undefined_p(t)) {
      if(db_resource_p(DBR_SUMMARY_EFFECTS, module_local_name(e))) {
        list el = effects_effects((effects)
                                  db_get_memory_resource(DBR_SUMMARY_EFFECTS,
                                                         entity_local_name(e),
                                                         true));
        t = effects_to_transformer(el);
      }
    }
 
    return t;
}

References db_get_memory_resource(), db_resource_p(), effects_effects, effects_to_transformer(), entity_local_name(), entity_module_p(), module_local_name(), pips_assert, transformer_undefined, and transformer_undefined_p.

Referenced by c_user_call_to_transformer(), and fortran_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_expression_to_transformer()

transformer logical_expression_to_transformer	(	entity	v,
		expression	rhs,
		transformer	pre,
		bool	is_internal
	)

Could be used to compute preconditions too.

v is assumed to be a new value or a temporary value.

Is likely to be handled as a nullary intrinsics

Parameters

rhs	hs
pre	re
is_internal	s_internal

Definition at line 3938 of file expression.c.

{
  transformer tf = transformer_undefined;
  syntax srhs = expression_syntax(rhs);
 
  switch(syntax_tag(srhs)) {
  case is_syntax_call: {
    call c = syntax_call(srhs);
    entity f = call_function(c);
    if(intrinsic_entity_p(f))
      tf = logical_intrinsic_to_transformer(v, c, pre, is_internal);
    else if(call_constant_p(c)) {
      entity cf = call_function(c);
      int i;
      if(logical_constant_p(cf)) {
          /* Is likely to be handled as a nullary intrinsics */
          tf = logical_intrinsic_to_transformer(v, c, pre, is_internal);
        }
      else if(integer_constant_p(cf, &i)) {
        if(i!=0)
          i = 1;
        tf = transformer_identity();
        tf = transformer_add_equality_with_integer_constant(tf, v, i);
      }
      else
        pips_internal_error("Unexpected case.\n");
    }
    else {
      // call to a C or Fortran bool function
      //list ef = expression_to_proper_effects(rhs);
      tf = user_function_call_to_transformer(v, rhs, pre);
    }
    break;
  }
  case is_syntax_reference: {
    // FI: information in precondition pre is lost here
    transformer rtf = logical_reference_to_transformer(v, reference_variable(syntax_reference(srhs)),
                                          is_internal);
    if(!transformer_undefined_p(rtf) && !transformer_undefined_p(pre)) {
      // FI: let us assume that pre is a range, not a transformer
      tf = transformer_intersection(rtf, pre);
    }
    break;
  }
  case is_syntax_range:
    pips_internal_error("Unexpected tag %d", syntax_tag(srhs));
    break;
  default:
    pips_internal_error("Illegal tag %d", syntax_tag(srhs));
  }
  return tf;
}

References call_constant_p(), call_function, expression_syntax, f(), integer_constant_p(), intrinsic_entity_p(), is_syntax_call, is_syntax_range, is_syntax_reference, logical_constant_p(), logical_intrinsic_to_transformer(), logical_reference_to_transformer(), pips_internal_error, reference_variable, syntax_call, syntax_reference, syntax_tag, transformer_add_equality_with_integer_constant(), transformer_identity(), transformer_intersection(), transformer_undefined, transformer_undefined_p, and user_function_call_to_transformer().

Referenced by any_expression_to_transformer(), logical_binary_operation_to_transformer(), and logical_unary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_intrinsic_to_transformer()

transformer logical_intrinsic_to_transformer	(	entity	v,
		call	c,
		transformer	pre,
		bool	is_internal
	)

Parameters

pre	re
is_internal	s_internal

Definition at line 3911 of file expression.c.

{
  transformer tf = transformer_undefined;
 
  switch(gen_length(call_arguments(c))) {
  case 0:
    tf = logical_constant_to_transformer(v, call_function(c));
    break;
  case 1:
    tf = logical_unary_operation_to_transformer(v, c, pre, is_internal);
    break;
  case 2:
    tf = logical_binary_function_to_transformer(v, c, pre, is_internal);
    break;
  default:
    pips_internal_error("Too many logical arguments, %d, for operator %s",
                        gen_length(call_arguments(c)),
                        entity_name(call_function(c)));
  }
  return tf;
}

References call_arguments, call_function, entity_name, gen_length(), logical_binary_function_to_transformer(), logical_constant_to_transformer(), logical_unary_operation_to_transformer(), pips_internal_error, and transformer_undefined.

Referenced by logical_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_not_to_transformer()

transformer logical_not_to_transformer	(	entity	v,
		list	args,
		transformer	pre
	)

returns the transformer associated to a C logical not, !, applied to an integer argument, when meaningful, and transformer_undefined otherwise.

Effects must be used at a higher level to fall back on a legal transformer.

Parameters

v	is the value associated to the expression
args	is assumed to have only one expression element of type int or enum negated by !
pre	is the current precondition

Parameters

args	rgs
pre	re

Definition at line 5571 of file expression.c.

{
  expression le = EXPRESSION(CAR(args));
  //basic be = basic_of_expression(le);
  transformer tf = transformer_undefined;
 
  //if(basic_int_p(be)) {
    entity tmp_v = make_local_temporary_integer_value_entity();
    tf = safe_any_expression_to_transformer(tmp_v, le, pre, true);
    transformer tfr = transformer_range(tf);
    intptr_t lb, ub;
 
    if(precondition_minmax_of_value(tmp_v, tfr, &lb, &ub)) {
      if(lb==ub && lb==0)
        tf = transformer_add_equality_with_integer_constant(tf, v, 1);
      else if(lb>0 || ub<0)
        tf = transformer_add_equality_with_integer_constant(tf, v, 0);
      else {
        tf = transformer_add_inequality_with_integer_constraint(tf, v, 1, true);
        tf = transformer_add_inequality_with_integer_constraint(tf, v, 0, false);
      }
    }
    else {
      tf = transformer_add_inequality_with_integer_constraint(tf, v, 1, true);
      tf = transformer_add_inequality_with_integer_constraint(tf, v, 0, false);
    }
    free_transformer(tfr);
    //  }
 
    //free_basic(be);
 
  return tf;
}

References CAR, EXPRESSION, free_transformer(), intptr_t, make_local_temporary_integer_value_entity(), precondition_minmax_of_value(), safe_any_expression_to_transformer(), transformer_add_equality_with_integer_constant(), transformer_add_inequality_with_integer_constraint(), transformer_range(), and transformer_undefined.

Referenced by integer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_bound_evaluation_to_transformer()

transformer loop_bound_evaluation_to_transformer	(	loop	l,
		transformer	pre
	)

Side effects in loop bounds and increment are taken into account.

The conditions on the loop index are given by the range of this transformer.

Parameters

pre

re

Definition at line 1203 of file loop.c.

{
  transformer r = transformer_undefined;
  entity i = loop_index(l);
 
  //pips_assert("No temporary variables are allocated",
  //      number_of_temporary_values()==0);
 
  if(entity_has_values_p(i)) {
    expression lbe = range_lower(loop_range(l));
    transformer iit = loop_initialization_to_transformer(l, pre);
    entity lbv = make_local_temporary_value_entity(entity_type(i));
    transformer lbt = any_expression_to_transformer(lbv, lbe, pre, true);
 
    transformer preub = transformer_safe_apply(iit, pre);
    expression ube = range_upper(loop_range(l));
    entity ubv = make_local_temporary_value_entity(entity_type(i));
    transformer ubt = any_expression_to_transformer(ubv, ube, preub, true);
 
    transformer prei = transformer_safe_apply(ubt, preub);
    expression ie = range_increment(loop_range(l));
    entity iv = make_local_temporary_value_entity(entity_type(i));
    transformer it = any_expression_to_transformer(iv, ie, prei, true);
    transformer pre_inc = transformer_safe_intersection(prei, it);
    entity ni = entity_to_new_value(i);
    int inc_lb = 0;
    int inc_ub = 0;
    expression eiv = entity_to_expression(iv);
 
    expression_and_precondition_to_integer_interval(eiv, pre_inc, &inc_lb, &inc_ub);
    free_expression(eiv);
 
    if(inc_lb>0 || inc_ub<0) {
      Pvecteur lb_ineq = vect_new((Variable) ni, VALUE_MONE);
      Pvecteur ub_ineq = vect_new((Variable) ni, VALUE_ONE);
 
      vect_add_elem(&lb_ineq, (Variable) lbv, VALUE_ONE);
      vect_add_elem(&ub_ineq, (Variable) ubv, VALUE_MONE);
 
      if(inc_ub<0) {
        lb_ineq = vect_multiply(lb_ineq, VALUE_MONE);
        ub_ineq = vect_multiply(ub_ineq, VALUE_MONE);
      }
      r = transformer_safe_apply(it, prei);
      r = transformer_safe_image_intersection(r, lbt);
      r = transformer_safe_image_intersection(r, ubt);
      r = transformer_inequality_add(r, lb_ineq);
      r = transformer_inequality_add(r, ub_ineq);
      r = transformer_temporary_value_projection(r);
    }
    reset_temporary_value_counter();
  }
  return r;
}

References any_expression_to_transformer(), entity_has_values_p(), entity_to_expression(), entity_to_new_value(), entity_type, expression_and_precondition_to_integer_interval(), free_expression(), loop_index, loop_initialization_to_transformer(), loop_range, make_local_temporary_value_entity(), range_increment, range_lower, range_upper, reset_temporary_value_counter(), transformer_inequality_add(), transformer_safe_apply(), transformer_safe_image_intersection(), transformer_safe_intersection(), transformer_temporary_value_projection(), transformer_undefined, VALUE_MONE, VALUE_ONE, vect_add_elem(), vect_multiply(), and vect_new().

Referenced by add_good_loop_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_initialization_to_transformer()

transformer loop_initialization_to_transformer	(	loop	l,
		transformer	pre
	)

Note: It used to be implemented by computing the effect list of the lower bound expression and and new allocated effect for the loop index definition.

It turns out to be very heavy, because cells must be of kind preference to be usable by several functions because macro effect_reference() expects so without testing it.

However, it is also difficult to add a variable to the transformer t_init because of aliasing. So let's stick to the initial implementation.

over-approximation of effects

free_effects() is not enough, because it is a persistant reference

Parameters

pre

re

Definition at line 1266 of file loop.c.

{
  effect init_e = make_effect(make_cell(is_cell_preference,
                                        make_preference(make_reference(loop_index(l), NIL))),
                              make_action_write_memory(),
                              make_approximation_exact(),
                              make_descriptor_none());
  list l_init_e = CONS(EFFECT, init_e, NIL);
  //list l_expr_e = expression_to_proper_effects(range_lower(loop_range(l)));
  expression lbe = range_lower(loop_range(l));
  list l_expr_e = expression_to_proper_constant_path_effects(lbe);
  list el = list_undefined;
 
  transformer r_pre = transformer_safe_range(pre);
  transformer t_init = transformer_undefined;
 
  ifdebug(9) {
    print_effects(l_init_e);
    print_effects(l_expr_e);
  }
 
  el = gen_nconc(l_init_e, l_expr_e);
 
  ifdebug(9) {
    print_effects(el);
  }
 
  t_init =
    any_scalar_assign_to_transformer(loop_index(l),
                                     range_lower(loop_range(l)),
                                     el, /* over-approximation of effects */
                                     r_pre);
 
  ifdebug(9) {
    print_effects(el);
  }
 
  gen_free_list(el);
  /* free_effects() is not enough, because it is a persistant reference */
  free_reference(preference_reference(cell_preference(effect_cell(init_e))));
  free_effect(init_e);
  free_transformer(r_pre);
 
  return t_init;
}

References any_scalar_assign_to_transformer(), cell_preference, CONS, EFFECT, effect_cell, expression_to_proper_constant_path_effects(), free_effect(), free_reference(), free_transformer(), gen_free_list(), gen_nconc(), ifdebug, is_cell_preference, list_undefined, loop_index, loop_range, make_action_write_memory(), make_approximation_exact(), make_cell(), make_descriptor_none(), make_effect(), make_preference(), make_reference(), NIL, preference_reference, print_effects, range_lower, transformer_safe_range(), and transformer_undefined.

Referenced by loop_bound_evaluation_to_transformer(), loop_to_postcondition(), loop_to_total_precondition(), and loop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_continue_transformer()

transformer loop_to_continue_transformer	(	loop	l,
		transformer	pre
	)

FI: the function transformer_add_loop_index_incrementation should be rewritten to exploit preconditions better.

Parameters

pre

re

Definition at line 1501 of file loop.c.

{
  transformer t = transformer_identity();
  /* FI: the function transformer_add_loop_index_incrementation should
     be rewritten to exploit preconditions better. */
  t = transformer_add_loop_index_incrementation(t, l, pre);
  transformer et = loop_to_enter_transformer(l, pre);
  t = transformer_combine(t, et);
  free_transformer(et);
  return t;
}

References free_transformer(), loop_to_enter_transformer(), transformer_add_loop_index_incrementation(), transformer_combine(), and transformer_identity().

Referenced by new_loop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_enter_transformer()

transformer loop_to_enter_transformer	(	loop	l,
		transformer	pre
	)

Transformer expressiong the conditions between the index and the loop bounds according to the sign of the increment.

A zero increment is not legal because the Fortran standard imposes a division by the increment.

Only the loop bopy statement number is available...

Assumption: no side effect in loop bound expressions

The increment is strictly positive

The increment is strictly negative

The sign of the increment is unknown, no information is available

No information is available for loop indices that are not integer

This could be improved, but floating point indices should never be used.

Parameters

pre

re

Definition at line 1442 of file loop.c.

{
  entity i = loop_index(l);
  range r = loop_range(l);
  expression low = range_lower(r);
  expression up = range_upper(r);
  expression inc = range_increment(r);
  int il, iu;
  transformer t = transformer_identity();
 
  if(scalar_integer_type_p(entity_type(i))) {
 
    integer_expression_and_precondition_to_integer_interval(inc, pre, &il, &iu);
 
    if(il==iu && il==0) {
      /* A zero increment is not legal because the Fortran standard
         imposes a division by the increment. */
      /* Only the loop bopy statement number is available... */
      pips_user_error("Null increment for DO loop detected.\n");
    }
    else if(il>0||iu<0) {
      /* Assumption: no side effect in loop bound expressions */
      entity lv = make_local_temporary_value_entity(entity_type(i));
      transformer lt = safe_integer_expression_to_transformer(lv, low, pre, true);
      entity uv = make_local_temporary_value_entity(entity_type(i));
      transformer ut = safe_integer_expression_to_transformer(uv, up, pre, true);
 
      if(il>0) {
        /* The increment is strictly positive */
        t = transformer_add_inequality_with_linear_term(t, lv, i, 1, true);
        t = transformer_add_inequality_with_linear_term(t, i, uv, 1, true);
      }
      else if(iu<0) {
        /* The increment is strictly negative */
        t = transformer_add_inequality_with_linear_term(t, uv, i, 1, true);
        t = transformer_add_inequality_with_linear_term(t, i, lv, 1, true);
      }
      t = transformer_intersection(t, lt);
      t = transformer_intersection(t, ut);
      t = transformer_temporary_value_projection(t);
      //t = transformer_normalize(t, 0);
      t = transformer_normalize(t, 1);
      free_transformers(lt, ut, NULL);
    }
    else {
      /* The sign of the increment is unknown, no information is available */
      ;
    }
  }
  else {
    /* No information is available for loop indices that are not integer */
    /* This could be improved, but floating point indices should never
       be used. */
    ;
  }
 
  return t;
}

References entity_type, free_transformers(), integer_expression_and_precondition_to_integer_interval(), loop_index, loop_range, make_local_temporary_value_entity(), pips_user_error, range_increment, range_lower, range_upper, safe_integer_expression_to_transformer(), scalar_integer_type_p(), transformer_add_inequality_with_linear_term(), transformer_identity(), transformer_intersection(), transformer_normalize(), and transformer_temporary_value_projection().

Referenced by loop_to_continue_transformer(), and new_loop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_initialization_transformer()

transformer loop_to_initialization_transformer	(	loop	l,
		transformer	pre
	)

Transformer expression the loop initialization.

Parameters

pre

re

Definition at line 1430 of file loop.c.

{
  entity i = loop_index(l);
  range r = loop_range(l);
  expression low = range_lower(r);
  transformer t = assigned_expression_to_transformer(i, low, pre);
  return t;
}

References assigned_expression_to_transformer(), loop_index, loop_range, and range_lower.

Referenced by new_loop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_postcondition()

transformer loop_to_postcondition	(	transformer	pre,
		loop	l,
		transformer	tf
	)

pips_internal_error("Equality option not implemented");

the standard version should be OK for SEMANTICS_EQUALITY_INVARIANTS...

basic cheap version: add information on loop index in pre and propagate preb downwards in the loop body; compute the loop postcondition independently using the loop transformer

preb = precondition for loop body; includes a lousy fix-point

Get rid of information related to variables modified in iterations of the loop body (including loop indices).

Apparently, the loop index incrementation is not in tf... according to a test with DO I = I, N although it should be... according to the caller of this function and the display of loop transformers!

Triolet's good loop algorithm

It might be useful to normalize preb and to detect unfeasibility. I choose not to do it because:

• it almost never happens in user code
• it's time consuming
• when it happens in automatically generated code, dead code elimination is performed.

So basically, I shift the burden from precondition computation to dead code elimination. Dead loop testing must use a strong feasibility test.

If this decision is reversed, dead code elimination can be speeded-up.

Note that add_good_loop_conditions() can test trivial cases automatically generated.

Decision reverted: Francois Irigoin, 4 June 1997

preb can now be used to obtain a refined tf, for instance to show that a variable is monotonically increasing.

FI: this is not correct when an invariant is found; we should add one more incrementation of I (to modify the output of the invariant and express the fact that the loop bound is no more true, at least when the increment is one. 6 July 1993

Note 1: this comments was wrong! See Validation/Semantics/induc1.f Note 2: but the result was wrong anyway because it assumed that at least one iteration always was performed. Note 3: This is fixed by reverting the above decision.

propagate an impossible precondition in the loop body

The loop body precondition is not useful any longer

propagate preconditions in the loop body and compute its postcondition...

... or compute directly the postcondition using the loop body transformer. This second approach is slightly less precise because the transformer cannot use preconditions to avoid some convex approximations.

post = transformer_apply(tf, pre);

The loop body effects should be passed as fourth argument to check that the value of the upper bound expression is not modified when the body is executed. But it is not available and it is not yet used by ad_loop_index_exit_value()!

First version: OK, but could be better!

transformer postloop = transformer_apply(tf, pre);

pre must be copied because sc_convex_hull updates is arguments and may make them inconsistent when the two bases are merged to perform the convex hull in a common vector space

Second version: assume it is empty or non-empty and perform the convex hull of both (should be checked on Validation/Semantics/induc1.f)

propagate preconditions in the loop body

post_al = transformer_apply(tf, pre);

We should add (when possible) the non-entry condition in post_ne! For instance, DO I = 1, N leads to N <= 0

FI: Cannot be freed because it was stored for statement s: transformer_free(preb); did I mean to free pre, which is useless since it was changed into preb?

Parameters

pre	re
tf	f

Definition at line 2841 of file loop.c.

{
  transformer post = transformer_undefined;
  statement s = loop_body(l);
  range r = loop_range(l);
 
  pips_debug(8,"begin\n");
 
  if(pips_flag_p(SEMANTICS_FIX_POINT) && pips_flag_p(SEMANTICS_INEQUALITY_INVARIANT)) {
    pips_internal_error("Halbwachs not implemented");
  }
  else {
    /* pips_internal_error("Equality option not implemented"); */
    /* the standard version should be OK for SEMANTICS_EQUALITY_INVARIANTS... */
 
    /* basic cheap version: add information on loop index in pre
       and propagate preb downwards in the loop body; compute the
       loop postcondition independently using the loop transformer */
    /* preb = precondition for loop body; includes a lousy fix-point */
    transformer preb = transformer_dup(pre);
 
    /* Get rid of information related to variables modified in
     * iterations of the loop body (including loop indices).
     *
     * Apparently, the loop index incrementation is not in tf...
     * according to a test with DO I = I, N
     * although it should be... according to the caller of this function
     * and the display of loop transformers!
     */
    preb = transformer_combine(preb, tf);
 
    /* Triolet's good loop algorithm */
    preb = add_good_loop_conditions(preb, l);
 
    /* It might be useful to normalize preb and to detect unfeasibility.
     * I choose not to do it because:
     *  - it almost never happens in user code
     *  - it's time consuming
     *  - when it happens in automatically generated code,
     *    dead code elimination is performed.
     *
     * So basically, I shift the burden from precondition computation
     * to dead code elimination. Dead loop testing must use a strong
     * feasibility test.
     *
     * If this decision is reversed, dead code elimination can be
     * speeded-up.
     *
     * Note that add_good_loop_conditions() can test trivial cases
     * automatically generated.
     *
     * Decision reverted: Francois Irigoin, 4 June 1997
     */
 
    /* preb can now be used to obtain a refined tf, for instance to show that a
       variable is monotonically increasing. */
    if(get_bool_property("SEMANTICS_RECOMPUTE_FIX_POINTS_WITH_PRECONDITIONS")) {
      transformer new_tf = recompute_loop_transformer(l, preb);
 
      free_transformer(preb);
      preb = transformer_dup(pre);
      preb = transformer_combine(preb, new_tf);
      preb = add_good_loop_conditions(preb, l);
    }
 
 
    /* FI: this is not correct when an invariant is found; we should add one
     * more incrementation of I (to modify the output of the invariant and
     * express the fact that the loop bound is no more true, at least when
     * the increment is one. 6 July 1993
     *
     * Note 1: this comments was wrong! See Validation/Semantics/induc1.f
     * Note 2: but the result was wrong anyway because it assumed that at
     * least one iteration always was performed.
     * Note 3: This is fixed by reverting the above decision.
     */
    if(empty_range_wrt_precondition_p(r, pre)) {
      pips_debug(8, "The loop is never executed\n");
 
      /* propagate an impossible precondition in the loop body */
      (void) statement_to_postcondition(transformer_empty(), s);
      /* The loop body precondition is not useful any longer */
      free_transformer(preb);
 
      transformer tmp = transformer_dup(pre);
      post = add_loop_index_initialization(tmp, l, pre);
      transformer_free(tmp);
    }
    else if(non_empty_range_wrt_precondition_p(r, pre)) {
      debug(8, "loop_to_postcondition", "The loop certainly is executed\n");
 
      /* propagate preconditions in the loop body and compute its postcondition... */
      post = statement_to_postcondition(preb, s);
 
      /* ... or compute directly the postcondition using the loop body transformer.
       * This second approach is slightly less precise because the transformer
       * cannot use preconditions to avoid some convex approximations. */
      /* post = transformer_apply(tf, pre); */
 
      /* The loop body effects should be passed as fourth argument
       * to check that the value of the upper bound expression is
       * not modified when the body is executed. But it is not available
       * and it is not yet used by ad_loop_index_exit_value()!
       */
      transformer tmp = post;
      post = add_loop_index_exit_value(post, l, pre);
      transformer_free(tmp);
    }
    else {
      /* First version: OK, but could be better! */
      /* transformer postloop = transformer_apply(tf, pre); */
      /* pre must be copied because sc_convex_hull updates is arguments
       * and may make them inconsistent when the two bases are merged
       * to perform the convex hull in a common vector space
       */
      /*
        transformer preloop = transformer_dup(pre);
        debug(8, "loop_to_postcondition", "The loop may be executed or not\n");
 
        post = transformer_convex_hull(postloop, preloop);
        transformer_free(postloop);
        transformer_free(preloop);
      */
 
      /* Second version: assume it is empty or non-empty and perform
       * the convex hull of both
       * (should be checked on Validation/Semantics/induc1.f)
       */
      transformer t_init = loop_initialization_to_transformer(l, pre);
      transformer post_ne = transformer_apply(t_init, pre);
      transformer post_al = transformer_undefined;
      transformer lpre = transformer_range(post_ne);
 
      pips_debug(8, "The loop may be executed or not\n");
 
      /* propagate preconditions in the loop body */
      post_al =  statement_to_postcondition(preb, s);
      /* post_al = transformer_apply(tf, pre); */
 
      /* We should add (when possible) the non-entry condition in post_ne!
       * For instance, DO I = 1, N leads to N <= 0
       */
      post_ne = add_loop_skip_condition(post_ne, l, lpre);
      // FI: already done with t_init
      //post_ne = add_loop_index_initialization(post_ne, l, lpre);
      free_transformer(lpre);
 
      transformer tmp = post_al;
      post_al = add_loop_index_exit_value(post_al, l, post_al);
      transformer_free(tmp);
 
      ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","[loop_to_postcondition]",
                       "Never executed: post_ne %p =");
        (void) print_transformer(post_ne);
        (void) fprintf(stderr,"%s: %s\n","[loop_to_postcondition]",
                       "Always executed: post_al %p = ");
        (void) print_transformer(post_al);
      }
      post = transformer_convex_hull(post_ne, post_al);
      transformer_free(post_ne);
      transformer_free(post_al);
    }
 
    /* FI: Cannot be freed because it was stored for statement s:
       transformer_free(preb);
       did I mean to free pre, which is useless since it was changed into
       preb?
    */
  }
 
  ifdebug(8) {
    (void) fprintf(stderr,"%s: %s\n","[loop_to_postcondition]",
                   "resultat post =");
    (void) print_transformer(post);
  }
  pips_debug(8,"end\n");
  return post;
}

References add_good_loop_conditions(), add_loop_index_exit_value(), add_loop_index_initialization(), add_loop_skip_condition(), debug(), empty_range_wrt_precondition_p(), fprintf(), free_transformer(), get_bool_property(), ifdebug, loop_body, loop_initialization_to_transformer(), loop_range, non_empty_range_wrt_precondition_p(), pips_debug, pips_flag_p, pips_internal_error, print_transformer, recompute_loop_transformer(), SEMANTICS_FIX_POINT, SEMANTICS_INEQUALITY_INVARIANT, statement_to_postcondition(), transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_empty(), transformer_free(), transformer_range(), and transformer_undefined.

Referenced by instruction_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_total_precondition()

transformer loop_to_total_precondition	(	transformer	t_post,
		loop	l,
		transformer	tf,
		transformer	context
	)

Triolet's good loop algorithm

preb = transformer_dup(pre);

The loop is never executed

impact of loop index initialization, i.e. I = IT(J),.. or I = K/L,..

the loop may be entered for sure, or entered or not

We need a fix_point without the initial condition but with the exit condition

Also performs last incrementation

free_transformer(b_t_pre); it is associated to the loop body!

The loop is always entered

The loop may be skipped or entered

skipped case computed here too

Parameters

t_post	_post
tf	f
context	ontext

Definition at line 3023 of file loop.c.

{
  transformer t_pre = transformer_undefined;
  statement b = loop_body(l);
  range r = loop_range(l);
 
  pips_debug(8,"begin\n");
 
  if(get_bool_property("SEMANTICS_RECOMPUTE_FIX_POINTS_WITH_PRECONDITIONS")) {
    transformer new_tf = transformer_undefined;
    transformer preb  = transformer_dup(context);
 
    preb = transformer_combine(preb, tf);
 
    /* Triolet's good loop algorithm */
    preb = add_good_loop_conditions(preb, l);
 
    new_tf = recompute_loop_transformer(l, preb);
 
    free_transformer(preb);
    /* preb = transformer_dup(pre); */
    preb = transformer_combine(preb, new_tf);
    preb = add_good_loop_conditions(preb, l);
  }
 
  if(empty_range_wrt_precondition_p(r, context)) { /* The loop is never executed */
    transformer tf_init = loop_initialization_to_transformer(l, context);
    transformer tf_empty = transformer_empty();
    transformer b_t_pre = transformer_undefined;
 
    pips_debug(8, "The loop is never executed\n");
 
    b_t_pre = statement_to_total_precondition(tf_empty, b);
    pips_assert("The body total precondition is consistent",
                transformer_consistency_p(b_t_pre));
 
    /* impact of loop index initialization, i.e. I = IT(J),.. or I = K/L,.. */
    t_pre = transformer_inverse_apply(tf_init, t_post);
    t_pre = transformer_to_domain(t_pre);
 
    free_transformer(tf_empty);
    free_transformer(tf_init);
  }
  else /* the loop may be entered for sure, or entered or not */ {
 
    transformer t_pre_ne = transformer_undefined;
    transformer t_pre_al = transformer_undefined;
    /* We need a fix_point without the initial condition but with the exit
       condition */
    transformer btf = transformer_dup(load_statement_transformer(b));
    transformer ltf = transformer_undefined;
    transformer b_t_post = transformer_undefined;
    transformer b_t_pre = transformer_undefined;
    transformer tf_init = loop_initialization_to_transformer(l, context);
 
    btf = transformer_add_loop_index_incrementation(btf, l, context);
    ltf =  (* transformer_fix_point_operator)(btf);
    ltf = add_loop_index_exit_value(ltf, l, context); /* Also performs
                                                         last
                                                         incrementation */
    b_t_post = transformer_inverse_apply(ltf, t_post);
    b_t_post = transformer_to_domain(b_t_post);
    b_t_pre = statement_to_total_precondition(b_t_post, b);
    pips_assert("The body total precondition is consistent",
                transformer_consistency_p(b_t_pre));
    t_pre_al = transformer_inverse_apply(tf_init, b_t_pre);
    t_pre_al = transformer_to_domain(t_pre_al);
 
    /* free_transformer(b_t_pre); it is associated to the loop body!*/
    free_transformer(b_t_post);
    free_transformer(btf);
    free_transformer(ltf);
 
    if(non_empty_range_wrt_precondition_p(r, context)) {
      /* The loop is always entered */
      t_pre = t_pre_al;
 
      pips_debug(8, "The loop certainly is executed\n");
    }
    else /* The loop may be skipped or entered */ {
 
      pips_debug(8, "The loop may be executed or not\n");
 
      /* skipped case computed here too */
      t_pre_ne = transformer_inverse_apply(tf_init, t_post);
      t_pre_ne = transformer_to_domain(t_pre_ne);
      t_pre_ne = add_loop_skip_condition(t_pre_ne, l, context);
 
 
      ifdebug(8) {
        (void) fprintf(stderr,"%s: %s\n","[loop_to_postcondition]",
                       "Never executed: t_pre_ne =");
        (void) print_transformer(t_pre_ne);
        (void) fprintf(stderr,"%s: %s\n","[loop_to_postcondition]",
                       "Always executed: post_al =");
        (void) print_transformer(t_pre_al);
      }
 
      t_pre = transformer_convex_hull(t_pre_ne, t_pre_al);
      transformer_free(t_pre_ne);
      transformer_free(t_pre_al);
    }
    free_transformer(tf_init);
  }
 
  ifdebug(8) {
    pips_debug(8, "resultat t_pre =%p", t_pre);
    (void) print_transformer(t_pre);
    pips_debug(8,"end\n");
  }
  return t_pre;
}

References add_good_loop_conditions(), add_loop_index_exit_value(), add_loop_skip_condition(), empty_range_wrt_precondition_p(), fprintf(), free_transformer(), get_bool_property(), ifdebug, load_statement_transformer(), loop_body, loop_initialization_to_transformer(), loop_range, non_empty_range_wrt_precondition_p(), pips_assert, pips_debug, print_transformer, recompute_loop_transformer(), statement_to_total_precondition(), transformer_add_loop_index_incrementation(), transformer_combine(), transformer_consistency_p(), transformer_convex_hull(), transformer_dup(), transformer_empty(), transformer_free(), transformer_inverse_apply(), transformer_to_domain(), and transformer_undefined.

Referenced by instruction_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_transformer()

transformer loop_to_transformer	(	loop	l,
		transformer	pre,
		list	e
	)

The transformer associated to a DO loop does not include the exit condition because it is used to compute the precondition for any loop iteration.

There is only one attachment for the unbounded transformer and for the bounded one.

loop transformer tf = tfb* or tf = tfb+ or ...

loop body transformer

approximate loop transformer, including loop index updates

loop body precondition

Information about loop local variables is lost

range r = loop_range(l);

eliminate all information about local variables

Mostly useful for Fortran code.

In C, variables declared in the loop body do not exist before the loop is entered and so do not have to be projected. But local variables may have been introduced by a privatization phase.

compute the loop body transformer under loop body precondition preb

add indexation step under loop precondition pre

compute tfb's fix point according to pips flags

restrict the domain of tf by the range of pre, except for the loop index which is assigned in between

add initialization for the unconditional initialization of the loop index variable

we have a problem here: to compute preconditions within the loop body we need a tf using private variables; to return the loop transformer, we need a filtered out tf; only one hook is available in the ri..; let'a assume there are no private variables and that if they are privatizable they are not going to get in our way

Parameters

pre

re

Definition at line 1319 of file loop.c.

{
  /* loop transformer tf = tfb* or tf = tfb+ or ... */
  transformer tf = transformer_undefined;
  /* loop body transformer */
  transformer tfb = transformer_undefined;
  /* approximate loop transformer, including loop index updates */
  transformer abtf = effects_to_transformer(e);
  /* loop body precondition */
  transformer preb = invariant_wrt_transformer(pre, abtf);
  /* Information about loop local variables is lost */
  list lv = loop_locals(l);
  /* range r = loop_range(l); */
  statement b = loop_body(l);
  transformer t_init = transformer_undefined;
  transformer old_tf = transformer_undefined;
 
  pips_debug(8,"begin with precondition pre=%p\n", pre);
  ifdebug(8) {
    (void) print_transformer(pre);
  }
 
  /* eliminate all information about local variables
   *
   * Mostly useful for Fortran code.
   *
   * In C, variables declared in the loop body do not exist before the
   * loop is entered and so do not have to be projected. But local
   * variables may have been introduced by a privatization phase.
   */
  preb = safe_transformer_projection(preb, lv);
 
  /* compute the loop body transformer under loop body precondition preb */
  if(!transformer_undefined_p(preb))
    preb = add_good_loop_conditions(preb, l);
 
  pips_debug(8,"body precondition preb=%p\n", preb);
  ifdebug(8) {
    (void) print_transformer(preb);
  }
 
  tfb = statement_to_transformer(b, preb);
  /* add indexation step under loop precondition pre */
  tfb = transformer_add_loop_index_incrementation(tfb, l, pre);
 
  pips_debug(8,"body transformer tfb=%p\n", tfb);
  ifdebug(8) {
    (void) print_transformer(tfb);
  }
 
  /* compute tfb's fix point according to pips flags */
  tf = (* transformer_fix_point_operator)(tfb);
 
  free_transformer(tfb);
 
  ifdebug(8) {
    pips_debug(8, "intermediate fix-point tf=\n");
    fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
  }
 
  /* restrict the domain of tf by the range of pre, except for the loop
     index which is assigned in between */
  if(!transformer_undefined_p(pre)
     && get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
    list li = CONS(ENTITY, loop_index(l), NIL);
    transformer preb = transformer_filter(transformer_dup(pre), li);
    transformer r_pre = transformer_range(preb);
 
    tf = transformer_domain_intersection(tf, r_pre);
    free_transformer(r_pre);
    free_transformer(preb);
    gen_free_list(li);
  }
 
  /* add initialization for the unconditional initialization of the loop
     index variable */
  t_init = loop_initialization_to_transformer(l, pre);
  old_tf = tf;
  tf = transformer_combine(t_init, tf);
  tf = add_index_range_conditions(tf, loop_index(l), loop_range(l),
                                  load_statement_transformer(b));
  free_transformer(old_tf);
 
  /* we have a problem here: to compute preconditions within the
     loop body we need a tf using private variables; to return
     the loop transformer, we need a filtered out tf; only
     one hook is available in the ri..; let'a assume there
     are no private variables and that if they are privatizable
     they are not going to get in our way */
 
  ifdebug(8) {
    (void) fprintf(stderr,"%s: %s\n","loop_to_transformer",
                   "resultat tf =");
    (void) (void) print_transformer(tf);
    pips_debug(8,"end\n");
  }
 
  return tf;
}

References add_good_loop_conditions(), add_index_range_conditions(), CONS, effects_to_transformer(), ENTITY, external_value_name(), fprint_transformer(), fprintf(), free_transformer(), gen_free_list(), get_bool_property(), ifdebug, invariant_wrt_transformer(), load_statement_transformer(), loop_body, loop_index, loop_initialization_to_transformer(), loop_locals, loop_range, NIL, pips_debug, print_transformer, safe_transformer_projection(), statement_to_transformer(), transformer_add_loop_index_incrementation(), transformer_combine(), transformer_domain_intersection(), transformer_dup(), transformer_filter(), transformer_range(), transformer_undefined, and transformer_undefined_p.

Referenced by instruction_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_to_transformer_list()

list loop_to_transformer_list	(	loop	,
		transformer	,
		list
	)

make_postcondition_map()

void make_postcondition_map

(

void

)

make_precondition_map()

void make_precondition_map

(

void

)

make_pred_commentary_sentence()

sentence make_pred_commentary_sentence	(	string	str_pred,
		string	comment_prefix
	)

sentence make_pred_commentary_sentence(string str_pred, string comment_prefix) input : a substring formatted to be a commentary output : a sentence, containing the commentary form of this string, beginning with the comment_prefix.

modifies : nothing

Parameters

str_pred	tr_pred
comment_prefix	omment_prefix

Definition at line 678 of file prettyprint.c.

{
  /*
  char str_tmp[MAX_PRED_COMMENTARY_STRLEN + 1];
 
  str_tmp[0] = '\0';
  (void) strcat(str_tmp, comment_prefix);
  (void) strcat(str_tmp, "  ");
  (void) strcat(str_tmp, str_pred);
  (void) strcat(str_tmp, "\n");
  */
  char * str_tmp = NULL;
  sentence sent_pred = sentence_undefined;
 
  str_tmp = strdup(concatenate(comment_prefix, "  ", str_pred, "\n", NULL));
  sent_pred = make_sentence_formatted(str_tmp);
  return(sent_pred);
}

References concatenate(), make_sentence_formatted(), sentence_undefined, and strdup().

Referenced by string_predicate_to_commentary(), and text_comp_region().

Here is the call graph for this function:

Here is the caller graph for this function:

make_semantic_map()

void make_semantic_map

(

void

)

make_total_precondition_map()

void make_total_precondition_map

(

void

)

make_transformer_map()

void make_transformer_map

(

void

)

module_name_to_preconditions()

bool module_name_to_preconditions

(

const char *

module_name

)

resource module_name_to_preconditions(char * module_name): compute a transformer for each statement of a module with a given name; compute also the global transformer for the module

set_debug_level(get_int_property(SEMANTICS_DEBUG_LEVEL));

To provide information for warnings

could be a gen_find_tabulated as well...

Used to add reference information when it is trusted... which should always be, at least for automatic parallelization.

cumulated effects are used to compute the value mappings

p_inter is not used!!! FI, 9 February 1994

debug_on(SEMANTICS_DEBUG_LEVEL);

compute the mappings related to module m, that is likely to be unavailable during interprocedural analysis; a module reference should be kept with the mappings to avoid useless recomputation, allocation and frees, including those due to the prettyprinter

set the list of global values. This is a bit too restrictive in C as the formal arguments, even modified in the procedure body, will not appear in the transformer_arguments. Should we add missing formal arguments to this list? See for instance "character01.c".

debug_on(SEMANTICS_DEBUG_LEVEL);

Add declaration information: arrays cannot be empty (Fortran standard, Section 5.1.2). But according to summary_precondition(), this is now supposed to be performed by the transformer phase?

If the module is never called, its precondition is identity and by default no values are listed in its basis. Function add_type_information() has no effect.

if(transformer_identity_p(pre)) {

list el = effects_to_list(

(effects) db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));

free_transformer(pre);

// FI: memory leak

pre = transformer_range(effects_to_transformer(el));

}

debug_on(SEMANTICS_DEBUG_LEVEL);

propagate the module precondition

post could be stored in the ri for later interprocedural uses but the ri cannot be modified so early before the DRET demo; also our current interprocedural algorithm does not propagate postconditions upwards in the call tree

Parameters

module_name

odule_name

Definition at line 1073 of file dbm_interface.c.

{
    transformer t_inter;
    transformer pre;
    transformer post;
 
    /* set_debug_level(get_int_property(SEMANTICS_DEBUG_LEVEL)); */
    debug_on(SEMANTICS_DEBUG_LEVEL);
    /* To provide information for warnings */
    make_statement_global_stack();
    sc_variable_name_push((char* (*)(Variable)) readable_value_name);
 
    set_current_module_entity(module_name_to_entity(module_name) );
    /* could be a gen_find_tabulated as well... */
    set_current_module_statement(
        (statement) db_get_memory_resource(DBR_CODE, module_name, true));
    if(get_current_module_statement() == (statement) database_undefined)
        pips_internal_error("no statement for module %s", module_name);
 
    /* Used to add reference information when it is trusted... which
       should always be, at least for automatic parallelization. */
    set_proper_rw_effects((statement_effects)
        db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
 
    /* cumulated effects are used to compute the value mappings */
    set_cumulated_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
    set_methods_for_simple_effects();
 
    set_transformer_map( (statement_mapping)
        db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
 
 
    /* p_inter is not used!!! FI, 9 February 1994 */
    /*
    if(get_bool_property(SEMANTICS_INTERPROCEDURAL)) {
        p_inter = (transformer)
            db_get_memory_resource(DBR_SUMMARY_PRECONDITION,
                                   module_name, true);
    }
    */
 
    t_inter = (transformer)
        db_get_memory_resource(DBR_SUMMARY_TRANSFORMER, module_name, true);
 
    /* debug_on(SEMANTICS_DEBUG_LEVEL); */
 
    set_precondition_map( MAKE_STATEMENT_MAPPING() );
 
    /* compute the mappings related to module m, that is likely to be
       unavailable during interprocedural analysis; a module reference
       should be kept with the mappings to avoid useless recomputation,
       allocation and frees, including those due to the prettyprinter */
 
    module_to_value_mappings( get_current_module_entity() );
 
    /* set the list of global values. This is a bit too restrictive in
       C as the formal arguments, even modified in the procedure body,
       will not appear in the transformer_arguments. Should we add
       missing formal arguments to this list? See for instance
       "character01.c". */
    set_module_global_arguments(transformer_arguments(t_inter));
 
    /* debug_on(SEMANTICS_DEBUG_LEVEL); */
 
    pre = copy_transformer(load_summary_precondition(get_current_module_entity()));
 
    /* Add declaration information: arrays cannot be empty (Fortran
       standard, Section 5.1.2). But according to summary_precondition(),
       this is now supposed to be performed by the transformer phase? */
    if(get_bool_property("SEMANTICS_TRUST_ARRAY_DECLARATIONS")) {
        precondition_add_declaration_information(pre, get_current_module_entity());
    }
    if(get_bool_property("SEMANTICS_USE_TYPE_INFORMATION")
       || get_bool_property("SEMANTICS_USE_TYPE_INFORMATION_IN_PRECONDITIONS")) {
 
      /* If the module is never called, its precondition is identity
         and by default no values are listed in its basis. Function
         add_type_information() has no effect. */
 
      /* if(transformer_identity_p(pre)) { */
      /*        list el = effects_to_list( */
      /*                               (effects) db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true)); */
      /*        free_transformer(pre); */
      /*        // FI: memory leak  */
      /*        pre = transformer_range(effects_to_transformer(el)); */
      /* } */
 
      transformer_add_type_information(pre);
    }
 
    /* debug_on(SEMANTICS_DEBUG_LEVEL); */
 
    /* propagate the module precondition */
    init_reachable(get_current_module_statement());
    post = statement_to_postcondition(pre, get_current_module_statement() );
    close_reachable();
 
    /* post could be stored in the ri for later interprocedural uses
       but the ri cannot be modified so early before the DRET demo;
       also our current interprocedural algorithm does not propagate
       postconditions upwards in the call tree */
 
    DB_PUT_MEMORY_RESOURCE(DBR_PRECONDITIONS,
                           module_name,
                           (char*) get_precondition_map() );
 
    pips_debug(8, "postcondition computed for %s\n",
          entity_local_name( get_current_module_entity() ));
    ifdebug(8) (void) print_transformer(post);
    debug(1, "module_name_to_preconditions", "end\n");
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_transformer_map();
    reset_precondition_map();
    reset_proper_rw_effects();
    reset_cumulated_rw_effects();
    generic_effects_reset_all_methods();
 
    free_value_mappings();
 
    sc_variable_name_pop();
    free_statement_global_stack();
    debug_off();
 
    return true;
}

References close_reachable(), copy_transformer(), database_undefined, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, entity_local_name(), free_statement_global_stack(), free_value_mappings(), generic_effects_reset_all_methods(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), get_precondition_map(), ifdebug, init_reachable(), load_summary_precondition(), make_statement_global_stack(), MAKE_STATEMENT_MAPPING, module_name(), module_name_to_entity(), module_to_value_mappings(), pips_debug, pips_internal_error, precondition_add_declaration_information(), print_transformer, readable_value_name(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_transformer_map(), sc_variable_name_pop(), sc_variable_name_push(), SEMANTICS_DEBUG_LEVEL, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_methods_for_simple_effects(), set_module_global_arguments(), set_precondition_map(), set_proper_rw_effects(), set_transformer_map(), statement_to_postcondition(), transformer_add_type_information(), and transformer_arguments.

Referenced by preconditions_inter_fast(), preconditions_inter_full(), preconditions_inter_full_with_points_to(), preconditions_intra(), and preconditions_intra_fast().

Here is the call graph for this function:

Here is the caller graph for this function:

module_name_to_total_preconditions()

bool module_name_to_total_preconditions

(

const char *

module_name

)

set the list of global values

The program postcondition should be used DBR_PROGRAM_POSTCONDITION

that might be because we are at the call tree root or because no information is available; maybe, every module precondition should be initialized to a neutral value?

intra-procedural case, not a main module

propagate the module total postcondition

filter out local variables from the global intraprocedural effect

Parameters

module_name

odule_name

Definition at line 1203 of file dbm_interface.c.

{
  transformer t_inter = transformer_undefined;
  transformer t_pre = transformer_undefined;
  transformer t_pre_inter = transformer_undefined;
  transformer t_post = transformer_undefined;
  list e_inter = list_undefined;
 
  debug_on(SEMANTICS_DEBUG_LEVEL);
  sc_variable_name_push((char* (*)(Variable)) readable_value_name);
 
  set_current_module_entity(module_name_to_entity(module_name) );
  set_current_module_statement(
                               (statement) db_get_memory_resource(DBR_CODE, module_name, true));
  if(get_current_module_statement() == (statement) database_undefined)
    pips_internal_error("no statement for module %s", module_name);
 
  set_proper_rw_effects((statement_effects)
                        db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
 
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
  e_inter = effects_to_list((effects)
                            db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
  set_transformer_map( (statement_mapping)
                       db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
 
  set_precondition_map( (statement_mapping)
                       db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
 
 
  t_inter = (transformer)
    db_get_memory_resource(DBR_SUMMARY_TRANSFORMER, module_name, true);
 
  set_total_precondition_map( MAKE_STATEMENT_MAPPING() );
 
  module_to_value_mappings( get_current_module_entity() );
 
  /* set the list of global values */
  set_module_global_arguments(transformer_arguments(t_inter));
 
  if(entity_main_module_p(get_current_module_entity())) {
    /* The program postcondition should be used DBR_PROGRAM_POSTCONDITION */
    t_post = transformer_identity();
  }
 
  ifdebug(3) {
    pips_debug(1, "considering final total postcondition for %s\n", module_name);
    print_transformer(t_post);
  }
 
  if(get_bool_property(SEMANTICS_INTERPROCEDURAL)) {
    transformer ip =
      load_summary_total_postcondition(get_current_module_entity());
    if( ip == transformer_undefined) {
      /* that might be because we are at the call tree root
         or because no information is available;
         maybe, every module precondition should be initialized
         to a neutral value? */
      pips_user_warning("no interprocedural module total postcondition for %s\n",
                        entity_local_name(get_current_module_entity() ));
      ;
    }
    else {
      translate_global_values(get_current_module_entity(), ip);
      ifdebug(8) {
        pips_debug(8, "\t summary_total_postcondition %p after translation:\n",
                   ip);
        print_transformer(ip);
        pips_assert("The summary total postcondition is consistent",
                    transformer_consistency_p(ip));
      }
      t_post = transformer_combine(transformer_dup(ip), t_post);
    }
  }
  else if(transformer_undefined_p(t_post)) {
    /* intra-procedural case, not a main module */
    t_post = transformer_identity();
  }
 
  /* propagate the module total postcondition */
  init_reachable(get_current_module_statement());
  t_pre = statement_to_total_precondition(t_post, get_current_module_statement() );
  close_reachable();
 
  DB_PUT_MEMORY_RESOURCE(DBR_TOTAL_PRECONDITIONS,
                         module_name,
                         (char*) get_total_precondition_map() );
 
  /* filter out local variables from the global intraprocedural effect */
  t_pre_inter = transformer_intra_to_inter(t_pre, e_inter);
  t_pre_inter = transformer_normalize(t_pre_inter, 2);
  if(!transformer_consistency_p(t_pre_inter)) {
    (void) print_transformer(t_pre_inter);
    pips_internal_error("Non-consistent summary transformer");
  }
  DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_TOTAL_PRECONDITION,
                         module_local_name(get_current_module_entity()),
                         (char*) t_pre_inter);
 
  pips_debug(8, "total precondition computed for %s\n",
             entity_local_name( get_current_module_entity() ));
  ifdebug(8) (void) print_transformer(t_pre);
  pips_debug(1, "end\n");
 
  reset_current_module_entity();
  reset_current_module_statement();
  reset_transformer_map();
  reset_precondition_map();
  reset_total_precondition_map();
  reset_proper_rw_effects();
  reset_cumulated_rw_effects();
 
  free_value_mappings();
 
  sc_variable_name_pop();
  debug_off();
 
  return true;
}

References close_reachable(), database_undefined, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, effects_to_list(), entity_local_name(), entity_main_module_p(), free_value_mappings(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), get_total_precondition_map(), ifdebug, init_reachable(), list_undefined, load_summary_total_postcondition(), MAKE_STATEMENT_MAPPING, module_local_name(), module_name(), module_name_to_entity(), module_to_value_mappings(), pips_assert, pips_debug, pips_internal_error, pips_user_warning, print_transformer, readable_value_name(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_total_precondition_map(), reset_transformer_map(), sc_variable_name_pop(), sc_variable_name_push(), SEMANTICS_DEBUG_LEVEL, SEMANTICS_INTERPROCEDURAL, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_module_global_arguments(), set_precondition_map(), set_proper_rw_effects(), set_total_precondition_map(), set_transformer_map(), statement_to_total_precondition(), transformer_arguments, transformer_combine(), transformer_consistency_p(), transformer_dup(), transformer_identity(), transformer_intra_to_inter(), transformer_normalize(), transformer_undefined, transformer_undefined_p, and translate_global_values().

Referenced by total_preconditions_inter(), and total_preconditions_intra().

Here is the call graph for this function:

Here is the caller graph for this function:

module_name_to_transformers()

bool module_name_to_transformers

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 1062 of file dbm_interface.c.

{
  bool rc = false;
  rc = generic_module_name_to_transformers(module_name, false);
  return rc;
}

References generic_module_name_to_transformers(), and module_name().

Referenced by transformers_inter_fast(), transformers_inter_full(), transformers_inter_full_with_points_to(), transformers_intra_fast(), and transformers_intra_full().

Here is the call graph for this function:

Here is the caller graph for this function:

module_name_to_transformers_in_context()

bool module_name_to_transformers_in_context

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 1044 of file dbm_interface.c.

{
  bool rc = false;
  bool save_prop = get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT");
 
  if(!save_prop) {
    pips_user_warning("Although property SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"
                      " is not set, it is used because it is necessary for this "
                      "recomputation to be useful\n");
    set_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT", true);
  }
 
  rc = generic_module_name_to_transformers(module_name, true);
 
  set_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT", save_prop);
  return rc;
}

References generic_module_name_to_transformers(), get_bool_property(), module_name(), pips_user_warning, and set_bool_property().

Referenced by refine_transformers(), and refine_transformers_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

module_to_formal_analyzable_parameters()

list module_to_formal_analyzable_parameters

(

entity

f

)

returns a module's parameter's list

get unsorted list of formal analyzable parameters for f by declaration filtering; these parameters may not be used by the callee's semantics analysis, but we have no way to know it because value mappings are not available

Definition at line 232 of file interprocedural.c.

{
  /* get unsorted list of formal analyzable parameters for f by declaration
     filtering; these parameters may not be used by the callee's
     semantics analysis, but we have no way to know it because
     value mappings are not available */
 
  list formals = NIL;
  list decl = list_undefined;
 
  pips_assert("f is a module",entity_module_p(f));
 
  decl = code_declarations(entity_code(f));
  MAPL(ce, {entity e = ENTITY(CAR(ce));
  if(storage_formal_p(entity_storage(e)) &&
     analyzable_scalar_entity_p(e))
    formals = CONS(ENTITY, e, formals);},
       decl);
 
  return formals;
}

References analyzable_scalar_entity_p(), CAR, code_declarations, CONS, ENTITY, entity_code(), entity_module_p(), entity_storage, f(), list_undefined, MAPL, NIL, pips_assert, and storage_formal_p.

Referenced by add_formal_to_actual_bindings(), and fortran_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

module_to_value_mappings()

void module_to_value_mappings

(

entity

m

)

void module_to_value_mappings(entity m): build hash tables between variables and values (old, new and intermediate), and between values and names for module m, as well as equivalence equalities

NW: before calling "module_to_value_mappings" to set up the hash table to translate value into value names for module with name (string) module_name do:

set_current_module_entity( local_name_to_top_level_entity(module_name) );

(the following call is only necessary if a variable of type entity such as "module" is not already set) module = get_current_module_entity();

set_current_module_statement( (statement) db_get_memory_resource(DBR_CODE, module_name, true) ); set_cumulated_rw_effects((statement_effects) db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));

(that's it, but we musn't forget to reset everything after the call to "module_to_value_mappings", as below)

reset_current_module_statement(); reset_cumulated_rw_effects(); reset_current_module_entity(); free_value_mappings();

free_value_mappings();

reset local intermediate value counter for make_local_intermediate_value_entity and make_local_old_value_entity

module_inter_effects = code_effects(value_code(entity_initial(m)));

look for interprocedural write effects on scalar analyzable variables and generate proper entries into hash tables

In C, write effects on scalar formal parameter are masked by the value passing mode but the copy may nevertheless be written inside the function.

To keep the summary transformer consistent although the return value has no old value

look for interprocedural read effects on scalar analyzable variables and generate proper entries into hash tables

static variables have an old value too

look for intraprocedural write effects on scalar analyzable variables and generate proper entries into hash tables

look for intraprocedural read effects on scalar analyzable variables and generate proper entry into value name hash table if it has not been entered before; interprocedural read effects are implicitly dealed with since they are included; most entities are likely to have been encountered before; however in parameters and uninitialized variables have to be dealt with

FI: although it may only be read within this procedure, e might be written in another one thru a COMMON; this write is not visible from OUT, but only from a caller of out; because we have only a local intraprocedural or a global interprocedural view of aliasing, we have to create useless values:-(

add_new_value(e);

Note: this makes the control structure of this procedure obsolete!

This call is useless because it only is effective if entity_has_values_p() is true: add_intraprocedural_value_entities(e);

A stronger call to the same subroutine is included in the previous call: add_or_kill_equivalenced_variables(e, true);

scan declarations to make sure that private variables are taken into account; assume a read and write effects on these variables, although they may not even be used.

Only intraprocedural variables can be privatized (1 Aug. 92)

This should be useless if return variables are taken into account by effect analysis. No problem with Fortran because the return variable really is assigned a value. Not obvious in C because the assignment is implicit in the return statement. In C the return variable is more like a value: it cannot be re-assigned.

FI: Only return variables are forgotten by effects

FI: no, this is wrong in C; local variables are dropped from effect when their declaration statements are processed. They cannot be found in the effects of the module statement.

We need references to all fields, direct or indirect when a field is itself a struct

scan other referenced variables to make sure everyone has an entry in the symbol table

|| storage_return_p(es)

We need references to all fields, direct or indirect when a field is itself a struct

Beware of struct return values which may generate additional locations and location values

To be sure to retrieve all relevant locations, including array elements

for debug, print hash tables

Definition at line 624 of file mappings.c.

{
  list module_inter_effects;
  list module_intra_effects;
 
  pips_debug(8,"begin for module %s\n", module_local_name(m));
 
  pips_assert("m is a module", entity_module_p(m));
 
  // hook cleanup in free_value_mappings
  reset_hooks_register(error_reset_value_mappings);
  /* free_value_mappings(); */
 
  allocate_module_value_mappings(m);
 
  /* reset local intermediate value counter for
     make_local_intermediate_value_entity and
     make_local_old_value_entity */
  reset_value_counters();
  reset_equivalence_equalities();
  reset_temporary_value_counter();
  set_analyzed_types();
 
  /* module_inter_effects = code_effects(value_code(entity_initial(m))); */
  module_inter_effects = load_summary_effects(m);
 
  /* look for interprocedural write effects on scalar analyzable variables
     and generate proper entries into hash tables */
  FOREACH(EFFECT, ef, module_inter_effects) {
    if(store_effect_p(ef)) {
      reference r = effect_any_reference(ef);
      entity e = reference_variable(r);
      action a = effect_action(ef);
      if(analyzable_scalar_entity_p(e) // check type
         && !effects_package_entity_p(e)
         && (
             action_write_p(a)
             ||
             /* In C, write effects on scalar formal parameter are
                masked by the value passing mode but the copy may
                nevertheless be written inside the function. */
             (c_module_p(m) && entity_formal_p(e))
             ||
             /* To keep the summary transformer consistent
                although the return value has no old value */
             (c_module_p(m) && storage_return_p(entity_storage(e))
              ))
         )
        add_interprocedural_value_entities(e);
      else if(entity_abstract_location_p(e) && action_write_p(a)) {
        add_implicit_interprocedural_write_effects(e, module_inter_effects);
      }
      else if(constant_path_analyzed_p() && analyzed_reference_p(r)) {
        type t = points_to_reference_to_concrete_type(r);
        if(analyzed_type_p(t)) {
          entity le = make_location_entity(r);
          add_interprocedural_value_entities(le);
        }
        free_type(t);
      }
    }
  }
 
  /* look for interprocedural read effects on scalar analyzable variables
     and generate proper entries into hash tables */
  FOREACH(EFFECT, ef, module_inter_effects) {
    if(store_effect_p(ef)) {
      entity e = reference_variable(effect_any_reference(ef));
      action a = effect_action(ef);
      if(analyzable_scalar_entity_p(e) && action_read_p(a)) {
        if(c_module_p(m) && 
           ( storage_return_p(entity_storage(e))
             /* static variables have an old value too */
             ||  entity_static_variable_p(e) 
             )
           )
          add_interprocedural_value_entities(e);
        else
          add_interprocedural_new_value_entity(e);
      }
    }
  }
 
  module_intra_effects = load_module_intraprocedural_effects(m);
 
  /* look for intraprocedural write effects on scalar analyzable variables
     and generate proper entries into hash tables */
  FOREACH(EFFECT, ef, module_intra_effects) {
    if(store_effect_p(ef)) {
      entity e = reference_variable(effect_any_reference(ef));
      action a = effect_action(ef);
      if(analyzable_scalar_entity_p(e) && action_write_p(a)) {
        if(storage_return_p(entity_storage(e))) {
          add_interprocedural_value_entities(e);
        }
        else {
          if(!entity_anywhere_locations_p(e)
             && !entity_typed_anywhere_locations_p(e)
             && !entity_heap_location_p(e))
            add_intraprocedural_value_entities(e);
        }
      }
      else if(constant_path_analyzed_p() && action_write_p(a)) {
        reference rlhs = cell_any_reference(effect_cell(ef));
 
        if (analyzed_reference_p(rlhs)) {
          entity le = make_location_entity(rlhs);
          add_intraprocedural_value_entities(le);
        }
      }
    }
  }
 
  /* look for intraprocedural read effects on scalar analyzable variables
     and generate proper entry into value name hash table if it has
     not been entered before; interprocedural read effects are implicitly
     dealed with since they are included;
     most entities are likely to have been encountered before; however
     in parameters and uninitialized variables have to be dealt with */
  FOREACH(EFFECT, ef, module_intra_effects) {
    if(store_effect_p(ef)) {
      entity e = reference_variable(effect_any_reference(ef));
      if(analyzable_scalar_entity_p(e) && !entity_has_values_p(e)) {
        /* FI: although it may only be read within this procedure, e
         * might be written in another one thru a COMMON; this write
         * is not visible from OUT, but only from a caller of out;
         * because we have only a local intraprocedural or a global
         * interprocedural view of aliasing, we have to create useless
         * values:-(
         *
         * add_new_value(e);
         *
         * Note: this makes the control structure of this procedure
         * obsolete!
         */
        /* This call is useless because it only is effective if
         * entity_has_values_p() is true:
         * add_intraprocedural_value_entities(e);
         */
          if(!entity_anywhere_locations_p(e)
             && !entity_typed_anywhere_locations_p(e)
             && !entity_heap_location_p(e))
            add_intraprocedural_value_entities_unconditionally(e);
        /* A stronger call to the same subroutine is included in
         * the previous call:
         * add_or_kill_equivalenced_variables(e, true);
         */
      }
    }
  }
 
  /* scan declarations to make sure that private variables are
   * taken into account; assume a read and write effects on these
   * variables, although they may not even be used.
   *
   * Only intraprocedural variables can be privatized (1 Aug. 92)
   */
  list dl = current_module_declarations();
  FOREACH(ENTITY, e, dl) {
    if(analyzable_scalar_entity_p(e) && !entity_has_values_p(e)
       && !location_entity_p(e) && !entity_heap_location_p(e)) {
      if(storage_return_p(entity_storage(e))) {
        /* This should be useless if return variables are taken
           into account by effect analysis. No problem with
           Fortran because the return variable really is assigned
           a value. Not obvious in C because the assignment is
           implicit in the return statement. In C the return
           variable is more like a value: it cannot be re-assigned. */
        add_interprocedural_value_entities(e);
      }
      else {
        add_intraprocedural_value_entities(e);
      }
    }
    else if(entity_variable_p(e) && !entity_abstract_location_p(e)) {
      storage es = entity_storage(e);
      // FI: do not process named or derived types
      //if(storage_ram_p(es) || storage_return_p(es)) {
      /* FI: Only return variables are forgotten by effects
       *
       * FI: no, this is wrong in C; local variables are dropped
       * from effect when their declaration statements are
       * processed. They cannot be found in the effects of the
       * module statement.
       */
      if(storage_ram_p(es) || storage_return_p(es)) {
        type t = entity_basic_concrete_type(e);
        if(constant_path_analyzed_p() && struct_type_p(t)) {
          /* We need references to all fields, direct or indirect when
           * a field is itself a struct
           */
          reference r = make_reference(e, NIL);
          list fl = struct_type_to_fields(t);
          add_intraprocedural_field_entities(r, fl);
          free_reference(r);
        }
      }
    }
  }
 
  /* scan other referenced variables to make sure everyone has an
   * entry in the symbol table
   */
  set re = get_referenced_entities_filtered(get_current_module_statement(), (bool (*)(void *))gen_true, entity_for_value_mapping_p);
  SET_FOREACH(entity, e, re) {
    if(analyzable_scalar_entity_p(e) && !entity_has_values_p(e)) {
      pips_assert("should not go there ?", !storage_return_p(entity_storage(e)));
      add_interprocedural_value_entities(e);
    }
  }
 
  // FI: to analyze array elements with constant subscripts, we would
  // need to get a list of all constant atomic references with types
  // that are analyzed.
 
  // FI: for points-to analysis, we need to know all formal virtual
  // entities that have been created by the points-to pass. It is not
  // clear the information may be retrieved from the module statement
  // cumulated effect, especially if scopes are used by the
  // programmer, or the module summary cumulated effects.
  if(constant_path_analyzed_p()) {
    SET_FOREACH(entity, e, re) {
      // FI: place holder variables are supposed to have been removed
      // from internal representation by C parser?
      if(entity_variable_p(e) && !place_holder_variable_p(e)) {
        storage es = entity_storage(e);
        if(storage_ram_p(es)/* || storage_return_p(es)*/) {
          type t = entity_basic_concrete_type(e);
          if(struct_type_p(t)) {
            /* We need references to all fields, direct or indirect when
             * a field is itself a struct
             */
            reference r = make_reference(e, NIL);
            list fl = struct_type_to_fields(t);
            add_interprocedural_field_entities(r, fl);
            free_reference(r);
          }
        }
      }
    }
  }
  set_free(re);
 
  /* Beware of struct return values which may generate additional
   * locations and location values
   */
  if(constant_path_analyzed_p()) {
    const char * module_name = entity_local_name(m);
    callees c = (callees) db_get_memory_resource(DBR_CALLEES,
                                                 module_name,
                                                 true);
    list lc = callees_callees(c);
    FOREACH(STRING, callee_name, lc) {
      entity f = module_name_to_entity(callee_name);
      type ft = entity_basic_concrete_type(f);
      type rt = compute_basic_concrete_type(functional_result(type_functional(ft)));
      if(struct_type_p(rt)) {
        entity rv = function_to_return_value(f);
        reference rvr = make_reference(rv, NIL);
        list fl = struct_type_to_fields(rt);
        add_intraprocedural_field_entities(rvr, fl);
        free_reference(rvr);
      }
    }
  }
 
  /* To be sure to retrieve all relevant locations, including array elements */
  if(constant_path_analyzed_p()) {
    values_for_current_module_intraprocedural_simple_effects();
  }
 
  /* for debug, print hash tables */
  ifdebug(8) {
    pips_debug(8, "hash tables for module %s\n", module_local_name(m));
    print_value_mappings();
    test_mapping_entry_consistency();
  }
 
  pips_debug(1, "Number of analyzed variables for module %s: %d\n",
             module_local_name(m),
             aproximate_number_of_analyzed_variables());
  pips_debug(1, "Number of analyzed values for module %s: %d\n",
             module_local_name(m),
             number_of_analyzed_values());
 
  pips_debug(8,"end for module %s\n", module_local_name(m));
}

References action_read_p, action_write_p, add_implicit_interprocedural_write_effects(), add_interprocedural_field_entities(), add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), add_intraprocedural_field_entities(), add_intraprocedural_value_entities(), add_intraprocedural_value_entities_unconditionally(), allocate_module_value_mappings(), analyzable_scalar_entity_p(), analyzed_reference_p(), analyzed_type_p(), aproximate_number_of_analyzed_variables(), c_module_p(), callees_callees, cell_any_reference(), compute_basic_concrete_type(), constant_path_analyzed_p(), current_module_declarations(), db_get_memory_resource(), EFFECT, effect_action, effect_any_reference, effect_cell, effects_package_entity_p(), ENTITY, entity_abstract_location_p(), entity_anywhere_locations_p(), entity_basic_concrete_type(), entity_for_value_mapping_p(), entity_formal_p(), entity_has_values_p(), entity_heap_location_p(), entity_local_name(), entity_module_p(), entity_static_variable_p(), entity_storage, entity_typed_anywhere_locations_p(), entity_variable_p, error_reset_value_mappings(), f(), FOREACH, free_reference(), free_type(), function_to_return_value(), functional_result, gen_true(), get_current_module_statement(), get_referenced_entities_filtered(), ifdebug, load_module_intraprocedural_effects(), load_summary_effects(), location_entity_p(), make_location_entity(), make_reference(), module_local_name(), module_name(), module_name_to_entity(), NIL, number_of_analyzed_values(), pips_assert, pips_debug, place_holder_variable_p(), points_to_reference_to_concrete_type(), print_value_mappings(), reference_variable, reset_equivalence_equalities(), reset_hooks_register(), reset_temporary_value_counter(), reset_value_counters(), set_analyzed_types(), SET_FOREACH, set_free(), storage_ram_p, storage_return_p, store_effect_p(), STRING, struct_type_p(), struct_type_to_fields(), test_mapping_entry_consistency(), type_functional, and values_for_current_module_intraprocedural_simple_effects().

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(), comp_regions(), continuation_conditions(), dsc_code_parallelization(), generic_module_name_to_transformers(), generic_print_xml_application(), get_any_comp_regions_text(), get_continuation_condition_text(), get_semantic_text(), hbdsc_parallelization(), init_convex_in_out_regions(), init_convex_rw_regions(), init_convex_summary_in_out_regions(), init_convex_summary_rw_regions(), 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(), 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 caller graph for this function:

modulo_by_a_constant_to_transformer()

transformer modulo_by_a_constant_to_transformer	(	entity	v1,
		transformer	prec,
		entity	v2,
		int	k
	)

Analyze v2 % k, with v2 constrainted by tf, assuming tf is a precondition.

See if exist a set v_i such that v2 = sum_i a_i v_i + c. Then v2 can be rewritten as v2 = gcd_i(a_i) lambda + c.

if k divides gcd(a_i) then v2>0 ? v1 = v2 % k = c % k : v1 = v2 % k = ck-k

If the sign of v2 is unknown, ck-k<=v1<=ck

Parameters

v1	1
prec	rec
v2	2

Definition at line 1481 of file expression.c.

{
  transformer mtf = transformer_identity();
  Value gcd, c, K = (Value) k;
 
  // exists lambda s.t. v2 = lambda gcd + c ^ 0<=c<gcd
  if(transformer_to_1D_lattice(v2, prec, &gcd, &c)) {
 
    // The sign of gcd does not matter more than the sign of lambda
    if(gcd<0) gcd = -gcd;
 
    // Is v2's sign known ?
    // Adding the sign constraint and using LP might be more efficient
    bool is_positive_p = false;
    bool is_negative_p = false;
    intptr_t imin = 0, imax = 0;
 
    if (precondition_minmax_of_value(v2, prec, &imin, &imax)) {
      is_positive_p = imin>=0;
      is_negative_p = imax<=0;
    }
 
    if (imin==imax) {
      // This piece of code should be useless because we expect 
      // gcd = 0 and c = imin = imax in such a case
      // But it fails with Semantics-New/modulo16.c
      mtf = transformer_add_equality_with_integer_constant(mtf, v1, imin%K);
    }
    else if (gcd!=0) {
      if(gcd%k==0) {
        if(is_positive_p)
          mtf = transformer_add_equality_with_integer_constant(mtf, v1, c%K);
        else if(is_negative_p)
          mtf = transformer_add_equality_with_integer_constant(mtf, v1, c%K-K);
        else {
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, c%K, true);
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, c%K-K, false);
        }
      }
      else {
        if(is_positive_p) {
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, K-1, true);
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, 0, false);
        }
        else if(is_negative_p) {
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, 0, true);
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, -K+1, false);
        }
        else {
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, K-1, true);
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, -K+1, false);
        }
      }
    }
    else { // Same result
      // v2 = c
      if(is_positive_p)
        mtf = transformer_add_equality_with_integer_constant(mtf, v1, c%K);
      else if(is_negative_p)
        mtf = transformer_add_equality_with_integer_constant(mtf, v1, c%K-K);
      else {
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, c%K, true);
          mtf = transformer_add_inequality_with_integer_constraint(mtf, v1, c%K-K, false);
      }
    }
  }
  else {
    // There is no solution. E.g. v2==2 ^ v2==1 or 0==1
    // This case should be detected earlier and this piece of code is
    // probably unreachable
    mtf = empty_transformer(mtf);
  }
  return mtf;
}

References empty_transformer(), intptr_t, precondition_minmax_of_value(), transformer_add_equality_with_integer_constant(), transformer_add_inequality_with_integer_constraint(), transformer_identity(), and transformer_to_1D_lattice().

Referenced by modulo_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

new_add_formal_to_actual_bindings()

transformer new_add_formal_to_actual_bindings	(	call	c,
		transformer	pre,
		entity	caller
	)

Take side effects into account:

pre := (t(expr )...(t_expr ))(pre) U {f = expr } n 1 i i for all i such that formal f_i is an analyzable scalar variable and as far as expression expr_i is analyzable and of the same type.

The algorithmic structure has to be different from the previous one.

pre is modified by side effects.

Parameters

pre	re
caller	aller

Definition at line 375 of file interprocedural.c.

{
  entity f = call_function(c);
  list args = call_arguments(c);
 
  transformer tf = any_user_call_site_to_transformer(f, args, pre, NIL);
  transformer new_pre = transformer_apply(tf, pre);
 
  ifdebug(6) {
    pips_debug(6, "new pre=%p\n", new_pre);
    dump_transformer(new_pre);
    pips_debug(6, "end for call to %s from %s\n", module_local_name(f),
               module_local_name(caller));
  }
 
  free_transformer(tf);
 
  return new_pre;
}

References any_user_call_site_to_transformer(), call_arguments, call_function, dump_transformer, f(), free_transformer(), ifdebug, module_local_name(), NIL, pips_debug, and transformer_apply().

Referenced by process_call_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

new_array_element_backward_substitution_in_transformer()

transformer new_array_element_backward_substitution_in_transformer	(	transformer	tf,
		entity	l,
		reference	fr,
		reference	ar
	)

Substitute formal location entity l by a location entity corresponding to ar, if it is possible.

Parameters

tf	f
fr	r
ar	r

Definition at line 1723 of file ri_to_transformers.c.

{
  reference nar = copy_reference(ar);
  list nsl = gen_full_copy_list(reference_indices(fr));
  reference_indices(nar) =
    gen_nconc(reference_indices(nar), nsl);
  entity al = constant_memory_access_path_to_location_entity(nar);
  if(entity_undefined_p(al)) {
    semantics_user_warning("Untranslatable reference \"%s\" because of"
                           " imprecise effects.\n",
                           reference_to_string(nar));
    list pl = CONS(ENTITY, l, NIL);
    tf = transformer_projection(tf, pl);
    gen_free_list(pl);
  }
  else {
    list pl = NIL;
    tf = substitute_scalar_stub_in_transformer(tf, l, al, true, &pl);
    if(ENDP(pl)) {
      ;
    }
    else {
      semantics_user_warning("Translation issues for location \"%s\"\n.",
                             entity_user_name(l));
      tf = transformer_projection(tf, pl);
      gen_free_list(pl);
    }
  }
  free_reference(nar);
  return tf;
}

References CONS, constant_memory_access_path_to_location_entity(), copy_reference(), ENDP, ENTITY, entity_undefined_p, entity_user_name(), free_reference(), gen_free_list(), gen_full_copy_list(), gen_nconc(), NIL, pl, reference_indices, reference_to_string(), semantics_user_warning, substitute_scalar_stub_in_transformer(), and transformer_projection().

Referenced by new_array_elements_backward_substitution_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

new_array_elements_backward_substitution_in_transformer()

transformer new_array_elements_backward_substitution_in_transformer	(	transformer	,
		entity	,
		type	,
		expression	,
		transformer	,
		list
	)

new_array_elements_forward_substitution_in_transformer()

transformer new_array_elements_forward_substitution_in_transformer	(	transformer	,
		entity	,
		type	,
		expression	,
		transformer	,
		list
	)

new_array_elements_substitution_in_transformer()

transformer new_array_elements_substitution_in_transformer	(	transformer	,
		entity	,
		type	,
		expression	,
		transformer	,
		list	,
		bool
	)

new_complete_whileloop_transformer()

transformer new_complete_whileloop_transformer	(	transformer	t_body_star,
		transformer	pre,
		whileloop	wl,
		bool	entered_p
	)

entered_p is used to for the execution of at least one iteration

Parameters

t_body_star	_body_star
pre	re
wl	l
entered_p	ntered_p

Definition at line 1833 of file loop.c.

{
  list tfl =
    new_complete_whileloop_transformer_list(t_body_star, pre, wl, entered_p);
  transformer ct = transformer_list_to_transformer(tfl);
  // tfl is destroyed by transformer_list_to_transformer()
  return ct;
}

References new_complete_whileloop_transformer_list(), and transformer_list_to_transformer().

Referenced by complete_whileloop_transformer(), and generic_complete_statement_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

new_complete_whileloop_transformer_list()

list new_complete_whileloop_transformer_list	(	transformer	,
		transformer	,
		whileloop	,
		bool
	)

new_loop_to_transformer()

transformer new_loop_to_transformer	(	loop	l,
		transformer	pre,
		list	lel
	)

loop_to_transformer() was developed first but is not as powerful as the new algorithm used for all kinds of loops.

See flip-flop01.c.

Equation:

t_body_star = t_init ; t_enter ;(t_body ; t_inc; t_continue)*

t_init, t_enter and t_continue, which includes t_inc, must be computed from the loop and its precondition, pre, and extended body effects, lel. In case the loop index appears in the bound or increment expressions, the Fortran standard should be used to determine the precondition to use. The same is true in case of side-effects in the loop expressions.

t_body must be computed from the loop body and a preliminary loop invariant.

Deal with initialization expression, which may be included in the condition as in while(i++, j=0, i<m)? No because the expression is going to be evaluated at each cycle. The ised effects must be part of the condition transformer, tcond

Deal with enter transformers

An effort could be made to compute the precondition for t_continue. Precondition pre and the loop effect list lel could be used.

approximate loop transformer, including loop index updates

first approximation of the loop body precondition

FI: could do better with body_transformer

Let's clean up the memory

Parameters

pre	re
lel	el

Definition at line 1516 of file loop.c.

{
  /* Equation:
   *
   * t_body_star =  t_init ; t_enter ;(t_body ; t_inc; t_continue)*
   *
   * t_init, t_enter and t_continue, which includes t_inc, must be
   * computed from the loop and its precondition, pre, and extended
   * body effects, lel. In case the loop index appears in the bound or
   * increment expressions, the Fortran standard should be used to
   * determine the precondition to use. The same is true in case of
   * side-effects in the loop expressions.
   *
   * t_body must be computed from the loop body and a preliminary loop
   * invariant.
   */
  transformer t_body_star = transformer_undefined;
  statement body_s = loop_body(l);
 
  /* Deal with initialization expression, which may be included in
     the condition as in while(i++, j=0, i<m)? No because the
     expression is going to be evaluated at each cycle. The ised
     effects must be part of the condition transformer, tcond */
  transformer t_init = loop_to_initialization_transformer(l, pre);
  // FI Memory leak
  transformer post_i = transformer_range(transformer_apply(t_init, pre));
 
  /* Deal with enter transformers */
  transformer t_enter = loop_to_enter_transformer(l, post_i);
  transformer pre_b = transformer_apply(t_enter, post_i);
 
  /* An effort could be made to compute the precondition for t_continue. 
   * Precondition pre and the loop effect list lel could be used.
   */
  //transformer p_continue = transformer_identity();
  /* approximate loop transformer, including loop index updates */
  transformer abtf = effects_to_transformer(lel);
  /* first approximation of the loop body precondition */
  // invariant_wrt_transformer() seems to add arguments to the
  // filtered precondition...
  // FI: memory leak
  transformer p_continue = transformer_range(invariant_wrt_transformer(pre_b, abtf));
  /* FI: could do better with body_transformer */
  transformer t_continue = loop_to_continue_transformer(l, p_continue);
 
  t_body_star = any_loop_to_transformer(t_init, t_enter, t_continue, body_s, lel, pre_b);
 
  /* Let's clean up the memory */
 
  free_transformer(p_continue);
  free_transformer(t_enter);
  free_transformer(t_continue);
  free_transformer(post_i);
  free_transformer(pre_b);
 
  return t_body_star;
}

References any_loop_to_transformer(), effects_to_transformer(), free_transformer(), invariant_wrt_transformer(), loop_body, loop_to_continue_transformer(), loop_to_enter_transformer(), loop_to_initialization_transformer(), transformer_apply(), transformer_range(), and transformer_undefined.

Here is the call graph for this function:

new_substitute_stubs_in_transformer()

transformer new_substitute_stubs_in_transformer	(	transformer	tf,
		call	c,
		statement	s,
		bool	backward_p
	)

This leads to an empty transformer because the statement is unreachable. Some kind of dereferencement error has occured earlier in the execution

Parameters

tf	f
backward_p	ackward_p

Definition at line 417 of file points_to.c.

{
  if(pt_to_list_undefined_p()) {
    // Return tf as is
  }
  else {
    points_to_graph ptg = get_points_to_graph_from_statement(s);
    bool bottom_p = points_to_graph_bottom(ptg);
 
    if(bottom_p) {
      /* This leads to an empty transformer because the statement is
       * unreachable. Some kind of dereferencement error has occured
       * earlier in the execution
       */
      free_transformer(tf);
      tf = transformer_empty();
    }
    else {
      set binding = user_call_to_points_to_interprocedural_binding_set(c, ptg);
      pt_map binding_g = make_points_to_graph(false, binding);
      tf = substitute_stubs_in_transformer_with_translation_binding(tf, binding_g, backward_p);
      free_points_to_graph(binding_g);
    }
  }
  return tf;
}

References free_points_to_graph(), free_transformer(), get_points_to_graph_from_statement(), make_points_to_graph(), points_to_graph_bottom, pt_to_list_undefined_p(), substitute_stubs_in_transformer_with_translation_binding(), transformer_empty(), and user_call_to_points_to_interprocedural_binding_set().

Referenced by c_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

new_whileloop_to_k_transformer()

transformer new_whileloop_to_k_transformer	(	whileloop	wl,
		transformer	pre,
		list	wlel,
		int	k
	)

t_body_star = t_init ; t_enter ;(t_body ; t_next)*

Deal with initialization expression

Deal with condition expression

An effort could be made to compute the precondition for t_continue.

Let's clean up the memory

Parameters

wl	l
pre	re
wlel	lel
k	effects of whileloop wl

Definition at line 416 of file loop.c.

{
  /* t_body_star =  t_init ; t_enter ;(t_body ; t_next)* */
  transformer t_body_star = transformer_undefined;
  statement body_s = whileloop_body(wl);
 
  /* Deal with initialization expression */
  transformer t_init = transformer_identity();
 
  /* Deal with condition expression */
  expression cond_e = whileloop_condition(wl);
  transformer t_enter = condition_to_transformer(cond_e, pre, true);
  /* An effort could be made to compute the precondition for t_continue. */
  transformer p_continue = transformer_identity();
  transformer t_continue = condition_to_transformer(cond_e, p_continue, true);
 
  t_body_star = any_loop_to_k_transformer(t_init, t_enter, t_continue, body_s, wlel, pre, k);
 
  /* Let's clean up the memory */
 
  free_transformer(p_continue);
 
  free_transformer(t_enter);
  free_transformer(t_continue);
 
  return t_body_star;
}

References any_loop_to_k_transformer(), condition_to_transformer(), free_transformer(), transformer_identity(), transformer_undefined, whileloop_body, and whileloop_condition.

Referenced by whileloop_to_k_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

new_whileloop_to_transformer()

transformer new_whileloop_to_transformer	(	whileloop	wl,
		transformer	pre,
		list	wlel
	)

effects of whileloop wl

Equation:

t_body_star = t_init ; t_enter ;(t_body ; t_continue)*

Deal with initialization expression, which may be included in the condition as in while(i++, j=0, i<m)? No because the expression is going to be evaluated at each cycle. The ised effects must be part of the condition transformer, tcond

Deal with condition expression

An effort could be made to compute the precondition for t_continue.

Let's clean up the memory

Parameters

wl	l
pre	re
wlel	lel

Definition at line 380 of file loop.c.

{
  /* Equation:
   *
   * t_body_star =  t_init ; t_enter ;(t_body ; t_continue)*
   */
  transformer t_body_star = transformer_undefined;
  statement body_s = whileloop_body(wl);
 
  /* Deal with initialization expression, which may be included in
     the condition as in while(i++, j=0, i<m)? No because the
     expression is going to be evaluated at each cycle. The ised
     effects must be part of the condition transformer, tcond */
  transformer t_init = transformer_identity();
 
  /* Deal with condition expression */
  expression cond_e = whileloop_condition(wl);
  transformer t_enter = condition_to_transformer(cond_e, pre, true);
  /* An effort could be made to compute the precondition for t_continue. */
  transformer p_continue = transformer_identity();
  transformer t_continue = condition_to_transformer(cond_e, p_continue, true);
 
  t_body_star = any_loop_to_transformer(t_init, t_enter, t_continue, body_s, wlel, pre);
 
  /* Let's clean up the memory */
 
  free_transformer(p_continue);
 
  free_transformer(t_enter);
  free_transformer(t_continue);
 
  return t_body_star;
}

References any_loop_to_transformer(), condition_to_transformer(), free_transformer(), transformer_identity(), transformer_undefined, whileloop_body, and whileloop_condition.

Referenced by whileloop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

non_empty_range_wrt_precondition_p()

bool non_empty_range_wrt_precondition_p	(	range	r,
		transformer	p
	)

Definition at line 121 of file utils.c.

{
  bool non_empty = false;
 
  non_empty = check_range_wrt_precondition(r, p, false);
 
  return non_empty;
}

References check_range_wrt_precondition().

Referenced by complete_loop_transformer(), complete_loop_transformer_list(), loop_to_postcondition(), and loop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_usable_functional_parameters()

unsigned int number_of_usable_functional_parameters

(

list

pl

)

Number of formal parameters in pl before a vararg is reached.

The varargs are not analyzed.

Parameters

pl

l

Definition at line 1518 of file ri_to_transformers.c.

{
  int n = 0;
  bool void_p = false;
  FOREACH(PARAMETER, p, pl) {
    type lpt = ultimate_type(parameter_type(p));
    if(type_void_p(lpt)) 
      void_p = true;
    else if(type_varargs_p(lpt))
      break;
    else
      n++;
  }
  if(void_p && n!=0)
    pips_internal_error("Inconsistent internal representation: \"void\" type used among several formal parameters.\n");
  return n;
}

References FOREACH, PARAMETER, parameter_type, pips_internal_error, pl, type_varargs_p, type_void_p, and ultimate_type().

Referenced by any_user_call_site_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

old_complete_whileloop_transformer()

transformer old_complete_whileloop_transformer	(	transformer	ltf,
		transformer	pre,
		whileloop	l
	)

loop body transformer

Recompute the exact loop body transformer. This is weird: it should have already been done by statement_to_transformer and propagated bask. However, we need to recompute it because it has not been stored and cannot be retrieved. It might be better to use complete_statement_transformer(retrieved t, preb, s).

Since it is not stored, we need to go down recursively. A way to avoid this would be to always have sequences as loop bodies... Let's hope that perfectly nested loops are neither frequent nor deep!

The proper transformer has been stored.

btf = transformer_add_condition_information(btf, cond, preb, true);

add the exit condition

add initialization for the unconditional initialization of the loop index variable

It might be better not to compute useless transformer, but it's more readable that way. Since pre is information free, only loops with constant lower and upper bound and constant increment can benefit from this.

Parameters

ltf	tf
pre	re

Definition at line 2213 of file loop.c.

{
  transformer tf = transformer_undefined;
  transformer t_enter = transformer_undefined;
  transformer t_skip = transformer_undefined;
  /* loop body transformer */
  transformer btf = transformer_undefined;
  expression cond = whileloop_condition(l);
  statement s = whileloop_body(l);
  transformer preb = invariant_wrt_transformer(pre, ltf);
 
  pips_debug(8,"begin with whileloop precondition\n");
  ifdebug(8) {
    (void) print_transformer(pre);
    pips_debug(8,"and whileloop transformer:\n");
    (void) print_transformer(ltf);
  }
 
  /* Recompute the exact loop body transformer. This is weird: it
     should have already been done by statement_to_transformer and
     propagated bask. However, we need to recompute it because it has
     not been stored and cannot be retrieved. It might be better to
     use complete_statement_transformer(retrieved t, preb, s). */
  if(statement_loop_p(s)) {
    /* Since it is not stored, we need to go down recursively. A way to
       avoid this would be to always have sequences as loop
       bodies... Let's hope that perfectly nested loops are neither
       frequent nor deep! */
    loop il = instruction_loop(statement_instruction(s));
    btf = complete_loop_transformer(load_statement_transformer(s), pre, il);
  }
  else if(statement_whileloop_p(s)) {
    whileloop il = instruction_whileloop(statement_instruction(s));
    btf = complete_whileloop_transformer(load_statement_transformer(s), pre, il);
  }
  else { /* The proper transformer has been stored. */
    btf = transformer_dup(load_statement_transformer(s));
  }
 
  /* btf = transformer_add_condition_information(btf, cond, preb, true); */
  t_enter = transformer_combine(transformer_dup(ltf), btf);
 
  ifdebug(8) {
    pips_debug(8, "entered loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add the exit condition */
  t_enter =  transformer_add_condition_information(t_enter, cond, preb, false);
 
  ifdebug(8) {
    pips_debug(8, "entered and exited loop transformer t_enter=\n");
    fprint_transformer(stderr, t_enter, (get_variable_name_t) external_value_name);
  }
 
  /* add initialization for the unconditional initialization of the loop
     index variable */
  t_skip = transformer_undefined_p(pre)?
    transformer_identity() :
    transformer_dup(pre);
  t_skip = transformer_add_condition_information(t_skip, cond, pre, false);
 
  ifdebug(8) {
    pips_debug(8, "skipped loop transformer t_skip=\n");
    fprint_transformer(stderr, t_skip, (get_variable_name_t) external_value_name);
  }
 
  /* It might be better not to compute useless transformer, but it's more
     readable that way. Since pre is information free, only loops with
     constant lower and upper bound and constant increment can benefit
     from this. */
  if(!transformer_undefined_p(pre) && condition_false_wrt_precondition_p(cond, pre)) {
    tf = t_skip;
    free_transformer(t_enter);
  }
  else if(!transformer_undefined_p(pre) && condition_true_wrt_precondition_p(cond, pre)) {
    tf = t_enter;
    free_transformer(t_skip);
  }
  else {
    tf = transformer_convex_hull(t_enter, t_skip);
    free_transformer(t_enter);
    free_transformer(t_skip);
  }
 
  ifdebug(8) {
    pips_debug(8, "full refined loop transformer tf=\n");
    fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
    pips_debug(8, "end\n");
  }
 
  return tf;
}

References complete_loop_transformer(), complete_whileloop_transformer(), condition_false_wrt_precondition_p(), condition_true_wrt_precondition_p(), external_value_name(), fprint_transformer(), free_transformer(), ifdebug, instruction_loop, instruction_whileloop, invariant_wrt_transformer(), load_statement_transformer(), pips_debug, print_transformer, statement_instruction, statement_loop_p(), statement_whileloop_p(), transformer_add_condition_information(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_identity(), transformer_undefined, transformer_undefined_p, whileloop_body, and whileloop_condition.

Here is the call graph for this function:

old_summary_precondition()

bool old_summary_precondition

(

char *

module_name

)

do not nothing because it has been computed by side effects; or provide an empty precondition for root modules; maybe a touch to look nicer?

touch it

Parameters

module_name

odule_name

Definition at line 500 of file dbm_interface.c.

{
  /* do not nothing because it has been computed by side effects;
   * or provide an empty precondition for root modules;
   * maybe a touch to look nicer?
   */
 
  transformer t;
 
  debug_on(SEMANTICS_DEBUG_LEVEL);
 
  debug(8, "summary_precondition", "begin\n");
 
  if(db_resource_p(DBR_SUMMARY_PRECONDITION, module_name)) {
    /* touch it */
    t = (transformer) db_get_memory_resource(DBR_SUMMARY_PRECONDITION,
                                             module_name,
                                             true);
  }
  else {
    t = transformer_identity();
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_PRECONDITION,
                         module_name, (char * )t);
 
  ifdebug(8) {
    pips_debug(8, "initial summary precondition %p for %s:\n",
               t, module_name);
    dump_transformer(t);
    pips_debug(8, "end\n");
  }
 
  debug_off();
 
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_resource_p(), debug(), debug_off, debug_on, dump_transformer, ifdebug, module_name(), pips_debug, SEMANTICS_DEBUG_LEVEL, and transformer_identity().

Here is the call graph for this function:

path_initialize()

void path_initialize	(	statement	,
		statement	,
		statement	,
		path *	,
		path *
	)

path_transformer.c

Referenced by sequence_dg().

Here is the caller graph for this function:

path_transformer()

bool path_transformer

(

const

string

)

Parameters

string

odule_name

path_transformer_on()

transformer path_transformer_on	(	statement	,
		path	,
		path	,
		int
	)

pointer_expression_to_transformer()

transformer pointer_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre,
		bool	is_internal
	)

This function may return an undefined transformers if it fails to capture the semantics of expr in the polyhedral framework. cf any_expression_to_transformer which call it

Parameters

v	value of the expression
expr	pointer expression
pre	transformer, no side effect
is_internal	?? use in generic_reference_to_transformer

Returns

transformer with the pointer expression or transformer_undefined if failed

Assume: v is a value

Parameters

expr	xpr
pre	re
is_internal	s_internal

Definition at line 4582 of file expression.c.

{
  transformer tf = transformer_undefined;
  syntax sexpr = expression_syntax(expr);
 
  ifdebug(8) {
    pips_debug(8, "begin with precondition %p for expression: ", pre);
    print_expression(expr);
  }
 
  /* Assume: v is a value */
    switch (syntax_tag(sexpr)) {
    case is_syntax_call:
    {
      tf = transformer_undefined;
      tf = pointer_call_expression_to_transformer(v, expr, pre, is_internal);
      break;
    }
    case is_syntax_reference:
    {
      // pips_user_warning("reference for pointer analysis not be tested\n");
      // can occur for arithmetic for pointer
      reference rexpr = syntax_reference(sexpr);
 
      entity rvexpr = reference_variable(rexpr);
      type texpr = entity_type(rvexpr);
      type bctexpr = compute_basic_concrete_type(texpr);
      if(type_variable_p(bctexpr)) {
        variable vexpr = type_variable(bctexpr);
        if (!volatile_variable_p(vexpr)
            && ENDP(variable_dimensions(vexpr))
            && !basic_pointer_p(variable_basic(vexpr))) {
          // compute the multiply with sizeof
          tf = expression_multiply_sizeof_to_transformer(v, expr, pre, is_internal);
        }
        else
          tf = generic_reference_to_transformer(v, rexpr, pre, is_internal);
      }
      break;
    }
    case is_syntax_cast:
    {
      cast c = syntax_cast(sexpr);
      type ct = cast_type(c);
      expression cexp = cast_expression(c);
      type cexpt = expression_to_type(cexp);
 
      if (expression_null_p(expr)) {
        // make the transformer for the equality (take from generic_reference_to_transformer)
        transformer tfr =  simple_equality_to_transformer(v, null_pointer_value_entity(), false);
        if(!transformer_undefined_p(pre)) {
          // FI: assume pre is a range
          tf = transformer_intersection(tfr, pre);
        }
        free_transformer(tfr);
      } else {
        semantics_user_warning("Cast for pointer analysis not tested "
                               "(except for NULL pointer).\n");
        if (type_equal_p(ct, cexpt))
          tf = pointer_expression_to_transformer(v, cexp, pre, is_internal);
        else
          tf = transformer_undefined;
        //pips_internal_error("Illegal tag %d", syntax_tag(sexpr));
        free_type(cexpt);
      }
      break;
    }
    default:
      tf = transformer_undefined;
      //pips_internal_error("Illegal tag %d", syntax_tag(sexpr));
    }
 
  pips_debug(8, "end with tf=%p\n", tf);
 
  return tf;
}

References basic_pointer_p, cast_expression, cast_type, compute_basic_concrete_type(), ENDP, entity_type, expression_multiply_sizeof_to_transformer(), expression_null_p(), expression_syntax, expression_to_type(), free_transformer(), free_type(), generic_reference_to_transformer(), ifdebug, is_syntax_call, is_syntax_cast, is_syntax_reference, null_pointer_value_entity(), pips_debug, pointer_call_expression_to_transformer(), print_expression(), reference_variable, semantics_user_warning, simple_equality_to_transformer(), syntax_cast, syntax_reference, syntax_tag, transformer_intersection(), transformer_undefined, transformer_undefined_p, type_equal_p(), type_variable, type_variable_p, variable_basic, variable_dimensions, and volatile_variable_p().

Referenced by any_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

points_to_unary_operation_to_transformer()

transformer points_to_unary_operation_to_transformer	(	entity	e,
		entity	op,
		expression	e1,
		transformer	pre,
		bool	is_internal,
		bool	is_pointer
	)

This function is redundant with generic_unary_operation_to_transformer() except for its use of parameter is_pointer.

Parameters

op	p
e1	1
pre	re
is_internal	s_internal
is_pointer	s_pointer

Definition at line 2770 of file expression.c.

{
  pips_debug(8, "begin \n");
  transformer tf = transformer_undefined;
 
  if (!pt_to_list_undefined_p()) {
    // FI: may have to be adapted to implement ANALYZE_CONSTANT_PATHS
    //statement curstat =  get_current_statement_from_statement_global_stack();
    //points_to_graph ptg = get_points_to_graph_from_statement(curstat);
 
    list l = semantics_expression_to_points_to_sinks(e1);
    // compute the assignment for each cell pointed with the convex hull
    FOREACH(CELL, cp, l) {
      reference rrhs = cell_preference_p(cp)? preference_reference(cell_preference(cp)) : cell_reference(cp) ;
      entity rhs = reference_variable(rrhs);
 
      if (!is_pointer && entity_null_locations_p(rhs)) {
        if (gen_length(l) == 1) {
          tf = transformer_empty();
          pips_user_error("The pointer %s points to NULL\n", expression_to_string(e1));
        }
        else {
          semantics_user_warning("The pointer %s can points to NULL\n", expression_to_string(e1));
        }
      } else if (entity_typed_nowhere_locations_p(rhs)) {
        if (gen_length(l) == 1) {
          tf = transformer_empty();
          pips_user_error("The pointer %s points to undefined/indeterminate (%s)\n", expression_to_string(e1), reference_to_string(rrhs));
        }
        else {
          semantics_user_warning("The pointer %s can points to undefined/indeterminate (%s)\n", expression_to_string(e1), reference_to_string(rrhs));
        }
      }
      else {
        // check if rrhs is a constant path and can be analyze or not
        // (not really exact, see detail in analyzed_reference_p)
        if (analyzed_reference_p(rrhs)) {
          transformer rt = generic_reference_to_transformer(e, rrhs, pre, is_internal);
          // NL : It must have be a better way to do that but I don't know how
          if (transformer_undefined_p(tf))
            tf = rt;
          else {
            tf = transformer_convex_hull(tf, rt);
            free_transformer(rt);
          }
        }
      }
    }
  }
 
  if (transformer_undefined_p(tf)) {
    if(ENTITY_DEREFERENCING_P(op) || ENTITY_FIELD_P(op) || ENTITY_POINT_TO_P(op)) {
      if(test_warning_counters())  {
        extern bool active_phase_p(const char *);
        if(active_phase_p("TRANSFORMERS_INTER_FULL_WITH_POINTS_TO")) {
          if(get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH"))
            ;
          else
            semantics_user_warning("Set property SEMANTICS_ANALYZE_CONSTANT_PATH TRUE."
                                   " It might generate more accurate transformers.\n");
        }
        else {
          if(get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH"))
            semantics_user_warning("Activate TRANSFORMERS_INTER_FULL_WITH_POINTS_TO."
                                   " It might generate more accurate transformers.\n");
          else
            semantics_user_warning("Activate TRANSFORMERS_INTER_FULL_WITH_POINTS_TO and "
                                   "setproperty SEMANTICS_ANALYZE_CONSTANT_PATH TRUE."
                                   " It might generate more accurate transformers.\n");
        }
      }
    }
  }
 
  ifdebug (8) dump_transformer(tf);
  pips_debug(8, "end \n");
  return tf;
}

References active_phase_p(), analyzed_reference_p(), CELL, cell_preference, cell_preference_p, cell_reference, cp, dump_transformer, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, entity_null_locations_p(), ENTITY_POINT_TO_P, entity_typed_nowhere_locations_p(), expression_to_string(), FOREACH, free_transformer(), gen_length(), generic_reference_to_transformer(), get_bool_property(), ifdebug, pips_debug, pips_user_error, preference_reference, pt_to_list_undefined_p(), reference_to_string(), reference_variable, semantics_expression_to_points_to_sinks(), semantics_user_warning, test_warning_counters(), transformer_convex_hull(), transformer_empty(), transformer_undefined, and transformer_undefined_p.

Here is the call graph for this function:

postcondition_map_undefined_p()

bool postcondition_map_undefined_p

(

void

)

postcondition.c

precondition_add_condition_information()

transformer precondition_add_condition_information	(	transformer	pre,
		expression	c,
		transformer	context,
		bool	veracity
	)

context might be derivable from pre as transformer_range(pre) but this is sometimes very computationally intensive, e.g.

in ocean.

Parameters

pre	re
context	ontext
veracity	eracity

Definition at line 1111 of file expression.c.

{
  transformer post = transformer_undefined;
 
  if(transformer_undefined_p(context)
     || ENDP(transformer_arguments(context))) {
    post = transformer_add_condition_information_updown
      (pre, c, context, veracity, false);
  }
  else {
    transformer new_context = transformer_range(context);
 
    post = transformer_add_condition_information_updown
      (pre, c, new_context, veracity, false);
    free_transformer(new_context);
  }
 
  post = transformer_temporary_value_projection(post);
  reset_temporary_value_counter();
 
  return post;
}

References ENDP, free_transformer(), reset_temporary_value_counter(), transformer_add_condition_information_updown(), transformer_arguments, transformer_range(), transformer_temporary_value_projection(), transformer_undefined, and transformer_undefined_p.

Referenced by dag_to_flow_sensitive_preconditions(), eval_condition_wrt_precondition_p(), load_arc_precondition(), process_ready_node(), standard_whileloop_to_transformer(), transformer_add_range_condition(), unstructured_to_postconditions(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

precondition_add_reference_information()

void precondition_add_reference_information	(	transformer	pre,
		statement	s
	)

Parameters

pre

re

Definition at line 695 of file ri_to_preconditions.c.

{
  add_reference_information(pre, s, false);
}

References add_reference_information().

Referenced by statement_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

precondition_add_type_information()

void precondition_add_type_information

(

transformer

pre

)

Parameters

pre

re

Definition at line 705 of file ri_to_preconditions.c.

{
  transformer_add_type_information(pre);
}

References transformer_add_type_information().

Here is the call graph for this function:

precondition_filter_old_values()

transformer precondition_filter_old_values

(

transformer

pre

)

Parameters

pre

re

Definition at line 1065 of file loop.c.

{
    Psysteme sc = predicate_system(transformer_relation(pre));
    Pbase b = BASE_UNDEFINED;
 
    for(b = sc_base(sc); !BASE_NULLE_P(b); b = vecteur_succ(b)) {
      entity old_v = (entity) vecteur_var(b);
 
      if(old_value_entity_p(old_v)) {
        pips_assert("No old values are left", false);
      }
    }
 
    return pre;
}

References BASE_NULLE_P, BASE_UNDEFINED, old_value_entity_p(), pips_assert, predicate_system, transformer_relation, vecteur_succ, and vecteur_var.

Here is the call graph for this function:

precondition_intra_to_inter()

transformer precondition_intra_to_inter	(	entity	callee,
		transformer	pre,
		list	le
	)

precondition cannot be printed because equations linking formal parameters have been added to the real precondition

make sure you do not export a (potentially) meaningless old value

Thru DATA statements, old values of other modules may appear

get rid of old_values

sc_elim_redund

no_elim

get rid of pre's variables that do not appear in effects le

we should not have to know about these internal objects, Psysteme and Pvecteur!

build a list of values to suppress

get rid of variables that are not referenced, directly or indirectly, by the callee; translate what you can

For clarity, all cases are presented

No need to substitute or eliminate this value

This is a short term improvement for partial_eval01-02 that works only for values local to the callee not for values updated indirectedly by callees of "callee".

It resulted in many core dumps in array privatization

no conflicts

list of conflicting entities

case 1: only one entity

case 1.1: one conflicting integer entity

Type mismatch

case 1.22: one conflicting non analyzable scalar entity

case 2: at least 2 conflicting entities

case 2.1: all entities have the same type, according to mapping_values the subtitution is made with the first list element e_callee

case 2.2: all entities do not have the same type

Get rid of variables local to the caller

Get rid of unused or untouched variables, even though they may appear as global variables or formal parameters

This happens with automatically generated modules and for routine XERCLT in KIVA (Renault) because it has been emptied.

No information but feasibility can be preserved

Get rid of the basis and arguments to define the empty set

No information: the all value space is OK

sc_elim_redund

no_elim

free the temporary list of entities

get rid of arguments because they are meaningless for a module precondition: v_new == v_old by definition

Parameters

callee	allee
pre	re
le	e

Definition at line 395 of file interprocedural.c.

{
#define DEBUG_PRECONDITION_INTRA_TO_INTER 1
  list values = NIL;
  list lost_values = NIL;
  list preserved_values = NIL;
  Psysteme r;
  Pbase b;
  cons * ca;
 
  ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER)
    {
      pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
            "begin for call to %s\nwith precondition:\n",
            module_local_name(callee));
      /* precondition cannot be printed because equations linking formal
       * parameters have been added to the real precondition
       */
      dump_transformer(pre);
    }
 
  r = (Psysteme) predicate_system(transformer_relation(pre));
 
  /* make sure you do not export a (potentially) meaningless old value */
  for( ca = transformer_arguments(pre); !ENDP(ca); POP(ca) )
    {
      entity e = ENTITY(CAR(ca));
      entity e_old;
 
      /* Thru DATA statements, old values of other modules may appear */
      if(!same_string_p(entity_module_name(e),
                        module_local_name(get_current_module_entity()))) {
        pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
              "entitiy %s not belonging to module %s\n",
              entity_name(e),
              module_local_name(get_current_module_entity()));
      }
 
      e_old  = entity_to_old_value(e);
 
      if(base_contains_variable_p(sc_base(r), (Variable) e_old))
        lost_values = arguments_add_entity(lost_values,
                                           e_old);
    }
 
  ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER)
    {
      pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
            "meaningless old value(s):\n");
      dump_arguments(lost_values);
    }
 
  /* get rid of old_values */
  pre = transformer_projection_with_redundancy_elimination
    (pre, lost_values, /* sc_elim_redund */ /* no_elim */ sc_safe_normalize);
 
  gen_free_list(lost_values);
 
 
  translate_global_values(callee, pre);
 
  /* get rid of pre's variables that do not appear in effects le */
  /* we should not have to know about these internal objects, Psysteme
     and Pvecteur! */
  lost_values = NIL;
  r = (Psysteme) predicate_system(transformer_relation(pre));
  for(b = r->base; b != NULL; b = b->succ) {
    entity v = (entity) vecteur_var(b);
 
    if(!entity_constant_p(v))
      values = arguments_add_entity(values, v);
  }
 
  /* build a list of values to suppress*/
  if(true || fortran_language_module_p(callee)) {
  /* get rid of variables that are not referenced, directly or indirectly,
     by the callee; translate what you can */
  pips_debug(9, "Module effect list:");
  ifdebug(9) print_effects(le);
 
  for(ca = values; !ENDP(ca);  POP(ca))    {
    entity e = ENTITY(CAR(ca));
    // FI: concrete effects are now killed by abstract effects
    list l_callee =
      (list) concrete_effects_entities_which_may_conflict_with_scalar_entity(le, e);
    // FI: the association with an abstract effect kills the
    // translation process below
    // list l_callee = (list) effects_entities_which_may_conflict_with_scalar_entity(le, e);
    /* For clarity, all cases are presented */
    if(c_language_module_p(callee) && local_entity_of_module_p(e, callee)) {
      /* No need to substitute or eliminate this value */
      /* This is a short term improvement for partial_eval01-02
         that works only for values local to the callee not for
         values updated indirectedly by callees of "callee". */
      /* It resulted in many core dumps in array privatization */
        ;
    }
    else if (ENDP(l_callee)) {   /* no conflicts */
      lost_values = arguments_add_entity(lost_values, e);
      pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
            "value %s lost according to effect list\n",
            entity_name(e));
    }
    else {
      /* list of conflicting entities */
      entity e_callee = ENTITY(CAR(l_callee));
      /* case 1: only one entity*/
      if (gen_length(l_callee)==1) {
        /*  case 1.1: one conflicting integer entity */
        if (analyzable_scalar_entity_p(e_callee)) {
          if(e_callee != e) {
            if(type_equal_p(entity_type(e_callee), entity_type(e))) {
              pre = transformer_value_substitute(pre,
                                                 e, e_callee);
              ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER) {
                pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
                      "value %s substituted by %s according to effect list le:\n",
                      entity_name(e), entity_name(e_callee));
                dump_arguments(lost_values);
              }
            }
            else {
              /* Type mismatch */
              lost_values = arguments_add_entity(lost_values, e);
              pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
                    "value %s lost because non analyzable scalar entity\n",
                    entity_name(e));
            }
          }
        }
        /* case 1.22: one conflicting non analyzable scalar entity*/
        else {
          lost_values = arguments_add_entity(lost_values, e);
          pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
                "value %s lost because non analyzable scalar entity\n",
                entity_name(e));
        }
      }
      else  { /* case 2: at least 2 conflicting entities */
        if (same_analyzable_type_scalar_entity_list_p(l_callee)) {
          /* case 2.1: all entities have the same type,
             according to mapping_values the subtitution
             is made with the first list element e_callee*/
          if(e_callee != e) {
            pre = transformer_value_substitute(pre,
                                               e, e_callee);
            ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER) {
              pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
                    "value %s substituted by %s the first element list according to effect list le:\n",
                    entity_name(e), entity_name(e_callee));
              dump_arguments(lost_values);
            }
          }
        }
 
        else { /* case 2.2: all entities do not have the same type*/
          lost_values = arguments_add_entity(lost_values, e);
          pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
                "value %s lost - list of conflicting entities with different types\n",
                entity_name(e));
        }
      }
    }
 
  }
  }
  else if(false && c_language_module_p(callee)) {
    /* Get rid of variables local to the caller */
    ;
  }
 
  preserved_values = arguments_difference(values, lost_values);
 
  ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER) {
    pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
          "values lost because they do not appear in the effect list le:\n");
    dump_arguments(lost_values);
    pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
          "values preserved because they do appear in the effect list le"
          " and in the transformer basis:\n");
    dump_arguments(preserved_values);
  }
 
  /* Get rid of unused or untouched variables, even though they may
   * appear as global variables or formal parameters
   *
   * This happens with automatically generated modules and for routine
   * XERCLT in KIVA (Renault) because it has been emptied.
   *
   */
  if(ENDP(preserved_values)) {
    /* No information but feasibility can be preserved */
    if(transformer_empty_p(pre)) {
      /* Get rid of the basis and arguments to define the empty set */
      free_transformer(pre);
      pre = transformer_empty();
    }
    else{
      /* No information: the all value space is OK */
      free_transformer(pre);
      pre = transformer_identity();
    }
  }
  else {
    pre = transformer_projection_with_redundancy_elimination
      (pre, lost_values, /* sc_elim_redund */ /* no_elim */ sc_safe_normalize);
  }
 
  /* free the temporary list of entities */
  gen_free_list(preserved_values);
  gen_free_list(lost_values);
  gen_free_list(values);
 
  /* get rid of arguments because they are meaningless for
     a module precondition: v_new == v_old by definition */
  gen_free_list(transformer_arguments(pre));
  transformer_arguments(pre) = NIL;
 
  ifdebug(DEBUG_PRECONDITION_INTRA_TO_INTER) {
    pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER,
               "return pre=%p\n",pre);
    dump_transformer(pre);
    pips_debug(DEBUG_PRECONDITION_INTRA_TO_INTER, "end\n");
  }
 
  return pre;
}

References analyzable_scalar_entity_p(), arguments_add_entity(), arguments_difference(), Ssysteme::base, base_contains_variable_p(), c_language_module_p(), callee, CAR, concrete_effects_entities_which_may_conflict_with_scalar_entity(), DEBUG_PRECONDITION_INTRA_TO_INTER, dump_arguments(), dump_transformer, ENDP, ENTITY, entity_constant_p, entity_module_name(), entity_name, entity_to_old_value(), entity_type, fortran_language_module_p(), free_transformer(), gen_free_list(), gen_length(), get_current_module_entity(), ifdebug, local_entity_of_module_p(), module_local_name(), NIL, pips_debug, POP, predicate_system, print_effects, same_analyzable_type_scalar_entity_list_p(), same_string_p, sc_safe_normalize(), Svecteur::succ, transformer_arguments, transformer_empty(), transformer_empty_p(), transformer_identity(), transformer_projection_with_redundancy_elimination(), transformer_relation, transformer_value_substitute(), translate_global_values(), type_equal_p(), and vecteur_var.

Referenced by add_module_call_site_precondition(), call_site_to_module_precondition_text(), and process_call_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

precondition_map_undefined_p()

bool precondition_map_undefined_p

(

void

)

precondition_minmax_of_expression()

bool precondition_minmax_of_expression	(	expression	exp,
		transformer	tr,
		intptr_t *	pmin,
		intptr_t *	pmax
	)

compute integer bounds pmax, pmin of expression exp under preconditions tr require value mappings set !

create a temporary value

compute its preconditions

tidy & return

Parameters

exp	xp
tr	r
pmin	min
pmax	max

Definition at line 5818 of file expression.c.

{
    bool success;
    /* create a temporary value */
    basic bas = basic_of_expression(exp);
    entity var = make_local_temporary_value_entity_with_basic(bas);
    free_basic(bas);
 
    /* compute its preconditions */
    transformer var_tr = safe_any_expression_to_transformer(var,exp,tr,false);
    transformer pre = transformer_apply(var_tr, tr);
 
    //success = precondition_minmax_of_value(var, var_tr, pmin, pmax);
    success = precondition_minmax_of_value(var, pre, pmin, pmax);
 
    /* tidy & return */
    predicate_system(transformer_relation(var_tr))=SC_UNDEFINED;
    free_transformer(var_tr);
    free_entity(var);
    return success;
}

References basic_of_expression(), exp, free_basic(), free_entity(), free_transformer(), make_local_temporary_value_entity_with_basic(), precondition_minmax_of_value(), predicate_system, safe_any_expression_to_transformer(), transformer_apply(), and transformer_relation.

Referenced by bounds_of_expression(), integer_minmax_to_transformer(), integer_power_to_transformer(), partial_eval_min_or_max_operator(), and simplify_minmax_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

precondition_minmax_of_value()

bool precondition_minmax_of_value	(	entity	val,
		transformer	tr,
		intptr_t *	pmin,
		intptr_t *	pmax
	)

compute integer bounds pmax, pmin of value val under preconditions tr require value mappings set !

retrieve the associated psysteme

compute min / max bounds

special case to handle VMIN and VMAX in 32 bits

Parameters

val	al
tr	r
pmin	min
pmax	max

Definition at line 5790 of file expression.c.

{
    bool success;
    /* retrieve the associated psysteme*/
    Psysteme ps = sc_dup(predicate_system(transformer_relation(tr)));
    /* compute min / max bounds */
    Value vmin,vmax;
    if((success=sc_minmax_of_variable(ps,val,&vmin,&vmax)))
    {
        /* special case to handle VMIN and VMAX in 32 bits*/
        if(vmax != (Value)(intptr_t)(vmax) && vmax == VALUE_MAX) vmax= INT_MAX;
        if(vmin != (Value)(intptr_t)(vmin) && vmin == VALUE_MIN) vmin= INT_MIN;
        pips_assert("no data loss", vmin == (Value)(intptr_t)(vmin));
        pips_assert("no data loss", vmax == (Value)(intptr_t)(vmax));
        *pmin=(intptr_t)vmin;
        *pmax=(intptr_t)vmax;
    }
    // FI: ps is destroyed by sc_minmax_of_variable(). Should it
    // nevertheless be freed?
    return success;
}

References intptr_t, pips_assert, predicate_system, sc_dup(), sc_minmax_of_variable(), transformer_relation, VALUE_MAX, and VALUE_MIN.

Referenced by add_type_information(), bitwise_xor_to_transformer(), integer_left_shift_to_transformer(), logical_binary_function_to_transformer(), logical_not_to_transformer(), modulo_by_a_constant_to_transformer(), and precondition_minmax_of_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

preconditions_inter_fast()

bool preconditions_inter_fast

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 435 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, false);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_preconditions(module_name);
}

References module_name(), module_name_to_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

preconditions_inter_full()

bool preconditions_inter_full

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 447 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_preconditions(module_name);
}

References module_name(), module_name_to_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

preconditions_inter_full_with_points_to()

bool preconditions_inter_full_with_points_to

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 459 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    set_pt_to_list( (statement_points_to)
                    db_get_memory_resource(DBR_POINTS_TO, module_name, true) );
    bool result_p = module_name_to_preconditions(module_name);
    reset_pt_to_list();
    return result_p;
}

References db_get_memory_resource(), module_name(), module_name_to_preconditions(), reset_pt_to_list(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, set_bool_property(), and set_pt_to_list().

Here is the call graph for this function:

preconditions_intra()

bool preconditions_intra

(

char *

module_name

)

nothing to do: transformers are preconditions for this intraprocedural option

Maybe we should have an intra fast and an intra full as with other semantics entries

set_bool_property(SEMANTICS_FIX_POINT, false);

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 399 of file dbm_interface.c.

{
    /* nothing to do: transformers are preconditions for this
       intraprocedural option */
 
    set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    /* Maybe we should have an intra fast and an intra full as with other
       semantics entries */
    /* set_bool_property(SEMANTICS_FIX_POINT, false); */
    set_bool_property(SEMANTICS_FIX_POINT, true);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_preconditions(module_name);
}

References module_name(), module_name_to_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

preconditions_intra_fast()

bool preconditions_intra_fast

(

char *

module_name

)

nothing to do: transformers are preconditions for this intraprocedural option

Maybe we should have an intra fast and an intra full as with other semantics entries

set_bool_property(SEMANTICS_FIX_POINT, false);

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 417 of file dbm_interface.c.

{
    /* nothing to do: transformers are preconditions for this
       intraprocedural option */
 
    set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    /* Maybe we should have an intra fast and an intra full as with other
       semantics entries */
    /* set_bool_property(SEMANTICS_FIX_POINT, false); */
    set_bool_property(SEMANTICS_FIX_POINT, false);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_preconditions(module_name);
}

References module_name(), module_name_to_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

print_call_graph_with_preconditions()

bool print_call_graph_with_preconditions

(

const

string

)

Parameters

string

odule_name

Definition at line 712 of file prettyprint.c.

{
  bool success = false;
  success = print_decorated_call_graph(module_name, get_text_preconditions);
  return success;
}

References get_text_preconditions(), module_name(), and print_decorated_call_graph().

Here is the call graph for this function:

print_call_graph_with_total_preconditions()

bool print_call_graph_with_total_preconditions

(

const

string

)

Parameters

string

odule_name

Definition at line 722 of file prettyprint.c.

{
  bool success = false;
  success = print_decorated_call_graph(module_name,
                                       get_text_total_preconditions);
  return success;
}

References get_text_total_preconditions(), module_name(), and print_decorated_call_graph().

Here is the call graph for this function:

print_call_graph_with_transformers()

bool print_call_graph_with_transformers

(

const

string

)

Parameters

string

odule_name

Definition at line 702 of file prettyprint.c.

{
  bool success = false;
  success = print_decorated_call_graph(module_name, get_text_transformers);
  return success;
}

References get_text_transformers(), module_name(), and print_decorated_call_graph().

Here is the call graph for this function:

print_code_as_a_graph_preconditions()

bool print_code_as_a_graph_preconditions

(

const

string

)

Parameters

string

od_name

Definition at line 120 of file prettyprint.c.

{
    bool success;
 
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", true);
    success = print_code_preconditions(mod_name);
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", false);
 
    return success;
}

References print_code_preconditions(), and set_bool_property().

Here is the call graph for this function:

print_code_as_a_graph_total_preconditions()

bool print_code_as_a_graph_total_preconditions

(

const

string

)

Parameters

string

od_name

Definition at line 144 of file prettyprint.c.

{
    bool success;
 
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", true);
    success = print_code_total_preconditions(mod_name);
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", false);
 
    return success;
}

References print_code_total_preconditions(), and set_bool_property().

Here is the call graph for this function:

print_code_as_a_graph_transformers()

bool print_code_as_a_graph_transformers

(

const

string

)

Parameters

string

od_name

Definition at line 99 of file prettyprint.c.

{
    bool success;
 
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", true);
    success = print_code_transformers(mod_name);
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", false);
 
    return success;
}

References print_code_transformers(), and set_bool_property().

Here is the call graph for this function:

print_code_preconditions()

bool print_code_preconditions

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 110 of file prettyprint.c.

{
  is_user_view = false;
  is_transformer = false;
  is_total_precondition = false;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  return print_code_semantics(module_name);
}

References get_bool_property(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Referenced by print_code_as_a_graph_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

print_code_total_preconditions()

bool print_code_total_preconditions

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 131 of file prettyprint.c.

{
  bool success;
 
  is_user_view = false;
  is_transformer = false;
  is_total_precondition = true;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  success = print_code_semantics(module_name);
  return success;
}

References get_bool_property(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Referenced by print_code_as_a_graph_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

print_code_transformers()

bool print_code_transformers

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 90 of file prettyprint.c.

{
  is_user_view = false;
  is_transformer = true;
  is_total_precondition = false;
  is_transformer_filtered = false;
  return print_code_semantics(module_name);
}

References is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Referenced by print_code_as_a_graph_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

print_control_postcondition_map()

void print_control_postcondition_map

(

control_mapping

control_postcondition_map

)

unstructured.c

Parameters

control_postcondition_map

ontrol_postcondition_map

Definition at line 294 of file unstructured.c.

{
  if(hash_table_entry_count(control_postcondition_map)>0) {
    HASH_MAP(c, p, {
      statement s = control_statement((control) c);
      fprintf(stderr, "Control %p, Statement %s, Temporary postcondition:\n",
              c, statement_identification(s));
      print_transformer((transformer) p);
    }, control_postcondition_map);
  }
  else {
    pips_assert("The CFG contains at least one node with one statement",
                false);
  }
}

References control_statement, fprintf(), HASH_MAP, hash_table_entry_count(), pips_assert, print_transformer, and statement_identification().

Referenced by dag_to_flow_sensitive_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

print_icfg_with_control_preconditions()

bool print_icfg_with_control_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_control_total_preconditions()

bool print_icfg_with_control_total_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_control_transformers()

bool print_icfg_with_control_transformers

(

const

string

)

Parameters

string

odule_name

print_icfg_with_loops_preconditions()

bool print_icfg_with_loops_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_loops_total_preconditions()

bool print_icfg_with_loops_total_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_loops_transformers()

bool print_icfg_with_loops_transformers

(

const

string

)

Parameters

string

odule_name

print_icfg_with_preconditions()

bool print_icfg_with_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_total_preconditions()

bool print_icfg_with_total_preconditions

(

const

string

)

Parameters

string

odule_name

print_icfg_with_transformers()

bool print_icfg_with_transformers

(

const

string

)

Parameters

string

odule_name

print_initial_precondition()

bool print_initial_precondition

(

const

string

)

Parameters

string

ame

Definition at line 261 of file initial.c.

{
    bool ok;
    entity module = module_name_to_entity(name);
    transformer t = (transformer) 
        db_get_memory_resource(DBR_INITIAL_PRECONDITION, name, true);
    
    debug_on("SEMANTICS_DEBUG_LEVEL");
 
    set_current_module_entity(module);
    set_current_module_statement( (statement) 
        db_get_memory_resource(DBR_CODE, name, true));
    set_cumulated_rw_effects((statement_effects) 
                   db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                          name,
                                          true));
    module_to_value_mappings(module);
 
    ok = make_text_resource_and_free(name, DBR_PRINTED_FILE, ".ipred",
                                     text_transformer(t));
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
 
    free_value_mappings();
 
    debug_off();
 
    return ok;
}

References db_get_memory_resource(), debug_off, debug_on, free_value_mappings(), make_text_resource_and_free(), module, module_name_to_entity(), module_to_value_mappings(), ok, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and text_transformer().

Here is the call graph for this function:

print_program_precondition()

bool print_program_precondition

(

const

string

)

A small function that would require pipsdbm and ri-util

Parameters

string

ame

Definition at line 293 of file initial.c.

{
    bool ok;
    transformer t = (transformer) 
        db_get_memory_resource(DBR_PROGRAM_PRECONDITION, "", true);
 
    /* A small function that would require pipsdbm and ri-util*/
    const string mn = get_main_entity_name();
    entity m = module_name_to_entity(mn);
    free(mn);
    
    debug_on("SEMANTICS_DEBUG_LEVEL");
    pips_debug(1, "for \"%s\"\n", name);
 
    set_current_module_entity(m);
    set_current_module_statement( (statement) 
        db_get_memory_resource(DBR_CODE,
                               module_local_name(m),
                               true));
    set_cumulated_rw_effects((statement_effects) 
                   db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                          module_local_name(m),
                                          true));
    module_to_value_mappings(m);
 
    ok = make_text_resource_and_free(name, DBR_PRINTED_FILE, ".pipred",
                                     text_transformer(t));
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
 
    free_value_mappings();
 
    debug_off();
 
    return ok;
}

References db_get_memory_resource(), debug_off, debug_on, free(), free_value_mappings(), get_main_entity_name(), make_text_resource_and_free(), module_local_name(), module_name_to_entity(), module_to_value_mappings(), ok, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and text_transformer().

Here is the call graph for this function:

print_source_preconditions()

bool print_source_preconditions

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 164 of file prettyprint.c.

{
  is_user_view = true;
  is_transformer = false;
  is_total_precondition = false;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  return print_code_semantics(module_name);
}

References get_bool_property(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Here is the call graph for this function:

print_source_total_preconditions()

bool print_source_total_preconditions

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 174 of file prettyprint.c.

{
  is_user_view = true;
  is_transformer = false;
  is_total_precondition = true;
  is_transformer_filtered =
    get_bool_property("SEMANTICS_FILTERED_PRECONDITIONS");
  return print_code_semantics(module_name);
}

References get_bool_property(), is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Here is the call graph for this function:

print_source_transformers()

bool print_source_transformers

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 155 of file prettyprint.c.

{
  is_user_view = true;
  is_transformer = true;
  is_total_precondition = false;
  is_transformer_filtered = false;
  return print_code_semantics(module_name);
}

References is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, module_name(), and print_code_semantics().

Here is the call graph for this function:

print_statement_temporary_precondition()

void print_statement_temporary_precondition

(

statement_mapping

statement_temporary_precondition_map

)

Parameters

statement_temporary_precondition_map

tatement_temporary_precondition_map

Definition at line 1006 of file unstructured.c.

{
  if(hash_table_entry_count(statement_temporary_precondition_map)>0) {
    HASH_MAP(s, p, {
      fprintf(stderr, "Statement %s, Temporary precondition:\n",
              statement_identification((statement) s));
      print_transformer((transformer) p);
    }, statement_temporary_precondition_map);
  }
  else {
    pips_assert("The DAG contains at least one control node with one statement", false);
  }
}

References fprintf(), HASH_MAP, hash_table_entry_count(), pips_assert, print_transformer, and statement_identification().

Referenced by dag_to_flow_sensitive_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

program_postcondition()

bool program_postcondition

(

const string

name

)

The program correctness postcondition cannot be infered.

It should be provided by the user.

A small function that would require pipsdbm and ri-util

Parameters

name

ame

Definition at line 233 of file initial.c.

{
  transformer post = transformer_identity();
 
  /* A small function that would require pipsdbm and ri-util*/
  const string mn = get_main_entity_name();
  entity the_main = module_name_to_entity(mn);
  free(mn);
 
  debug_on("SEMANTICS_DEBUG_LEVEL");
  pips_debug(1, "considering program \"%s\" with main \"%s\"\n", name,
             module_local_name(the_main));
 
  pred_debug(1, "assumed program postcondition:\n", post);
 
  ifdebug(1) 
    pips_assert("consistent program postcondition", 
                transformer_consistency_p(post));
 
  DB_PUT_MEMORY_RESOURCE(DBR_PROGRAM_POSTCONDITION, "", post);
 
  debug_off();
  return true;
}

References DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, free(), get_main_entity_name(), ifdebug, module_local_name(), module_name_to_entity(), pips_assert, pips_debug, pred_debug, transformer_consistency_p(), and transformer_identity().

Here is the call graph for this function:

program_precondition()

bool program_precondition

(

const

string

)

Compute the union of all initial preconditions.

A small function that would require pipsdbm and ri-util

e_inter = effects_to_list(get_cumulated_rw_effects(get_current_module_statement()));

Unavoidable pitfall: initializations in uncalled modules may be taken into account. It all depends on the "create" command.

no dup & false => core

modifies tm!

tm = transformer_normalize(tm, 2);

Parameters

string

ame

Definition at line 134 of file initial.c.

{
    transformer t = transformer_identity();
 
    /* A small function that would require pipsdbm and ri-util*/
    const string mn = get_main_entity_name();
    entity the_main = module_name_to_entity(mn);
 
    pips_assert("main was found", the_main!=entity_undefined);
 
    free(mn);
 
    int i, nmodules;
    gen_array_t modules;
    list e_inter = NIL;
 
    debug_on("SEMANTICS_DEBUG_LEVEL");
    pips_debug(1, "considering program \"%s\" with main \"%s\"\n", name,
               module_local_name(the_main));
 
    set_current_module_entity(the_main);
    set_current_module_statement( (statement)
                                  db_get_memory_resource(DBR_CODE,
                                                         module_local_name(the_main),
                                                         true));
    make_statement_global_stack();
    set_cumulated_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                                    module_local_name(the_main),
                                                    true));
    set_proper_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_PROPER_EFFECTS,
                                                    module_local_name(the_main),
                                                    true));
 
    /* e_inter = effects_to_list(get_cumulated_rw_effects(get_current_module_statement())); */
 
    e_inter = effects_to_list( (effects)
                               db_get_memory_resource(DBR_SUMMARY_EFFECTS,
                                                      module_local_name(the_main),
                                                      true));
 
    module_to_value_mappings(the_main);
 
    /* Unavoidable pitfall: initializations in uncalled modules may be
     * taken into account. It all depends on the "create" command.
     */
    modules = db_get_module_list();
    nmodules = gen_array_nitems(modules);
    pips_assert("some modules in the program", nmodules>0);
 
    for(i=0; i<nmodules; i++) {
        transformer tm;
        string mname = gen_array_item(modules, i);
        pips_debug(1, "considering module %s\n", mname);
 
        tm = transformer_dup((transformer) /* no dup & false => core */
                             db_get_memory_resource(DBR_INITIAL_PRECONDITION,
                                                    mname, true));
 
        pred_debug(3, "current: t =\n", t);
        pred_debug(2, "to be added: tm =\n", tm);
        translate_global_values(the_main, tm); /* modifies tm! */
        pred_debug(3, "to be added after translation:\n", tm);
        tm = transformer_intra_to_inter(tm, e_inter);
        /* tm = transformer_normalize(tm, 2); */
        if(!transformer_consistency_p(tm)) {
            (void) print_transformer(tm);
            pips_internal_error("Non-consistent filtered initial precondition");
        }
        pred_debug(3, "to be added after filtering:\n", tm);
 
        intersect(t, tm);
        free_transformer(tm);
    }
 
    pred_debug(1, "resulting program precondition:\n", t);
 
    ifdebug(1)
        pips_assert("consistent program precondition",
                    transformer_consistency_p(t));
 
    DB_PUT_MEMORY_RESOURCE(DBR_PROGRAM_PRECONDITION, "", t);
 
    reset_current_module_entity();
    reset_current_module_statement();
    free_statement_global_stack();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    free_value_mappings();
    gen_array_full_free(modules);
 
    debug_off();
    return true;
}

References db_get_memory_resource(), db_get_module_list(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, effects_to_list(), entity_undefined, free(), free_statement_global_stack(), free_transformer(), free_value_mappings(), gen_array_full_free(), gen_array_item(), gen_array_nitems(), get_main_entity_name(), ifdebug, intersect(), make_statement_global_stack(), module_local_name(), module_name_to_entity(), module_to_value_mappings(), NIL, pips_assert, pips_debug, pips_internal_error, pred_debug, print_transformer, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), transformer_consistency_p(), transformer_dup(), transformer_identity(), transformer_intra_to_inter(), and translate_global_values().

Here is the call graph for this function:

propagate_preconditions_in_declarations()

transformer propagate_preconditions_in_declarations	(	list	dl,
		transformer	pre,
		void(*)(expression, transformer)	process_initial_expression
	)

This function is mostly copied from declarations_to_transformer().

It is used to recompute intermediate preconditions and to process the initialization expressions with the proper precondition. For instance, in:

int i = 10, j = i+1, a[i], k = foo(i);

you need to collect information about i's value to initialize j, dimension a and compute the summary precondition of function foo().

We assume that the precondition does not change within the expression as in:

int k = i++ + foo(i);

I do not remember if the standard prohibits this or not, but it may well forbid such expressions or state that the result is undefined.

But you can also have:

int a[i++][foo(i)];

or

int a[i++][j=foo(i)];

and the intermediate steps are overlooked by declaration_to_transformer() but can be checked with a proper process_dimensions() function.

This function can be called from ri_to_preconditions.c to propagate preconditions or from interprocedural.c to compute summary preconditions. In the second case, the necessary side effects are provided by the two functional parameters.

post = transformer_safe_normalize(post, 4);

post = transformer_safe_normalize(post, 4);

btf = transformer_normalize(btf, 4);

Parameters

dl	l
pre	re

Definition at line 977 of file ri_to_preconditions.c.

{
  //entity v = entity_undefined;
  //transformer btf = transformer_undefined;
  //transformer stf = transformer_undefined;
  transformer post = transformer_undefined;
  list l = dl;
 
  pips_debug(8,"begin\n");
 
  if(ENDP(l))
    post = copy_transformer(pre);
  else {
    entity v = ENTITY(CAR(l));
    expression ie = variable_initial_expression(v);
    transformer stf = declaration_to_transformer(v, pre);
    // FI: ongoing implementation
    //transformer stf = (*process_dimensions)(v, pre);
    transformer btf = transformer_dup(stf);
    transformer next_pre = transformer_undefined;
 
    if(!expression_undefined_p(ie)) {
      (*process_initial_expression)(ie, pre);
      free_expression(ie);
    }
 
    post = transformer_safe_apply(stf, pre);
/*     post = transformer_safe_normalize(post, 4); */
    post = transformer_safe_normalize(post, 2);
 
    for (POP(l) ; !ENDP(l); POP(l)) {
      v = ENTITY(CAR(l));
      ie = variable_initial_expression(v);
      if(!expression_undefined_p(ie)) {
        (*process_initial_expression)(ie, post);
        free_expression(ie);
      }
 
      if(!transformer_undefined_p(next_pre))
        free_transformer(next_pre);
      next_pre = post;
      stf = declaration_to_transformer(v, next_pre);
      post = transformer_safe_apply(stf, next_pre);
/*       post = transformer_safe_normalize(post, 4); */
      post = transformer_safe_normalize(post, 2);
      btf = transformer_combine(btf, stf);
/*       btf = transformer_normalize(btf, 4); */
      btf = transformer_normalize(btf, 2);
 
      ifdebug(1)
        pips_assert("btf is a consistent transformer", transformer_consistency_p(btf));
      pips_assert("post is a consistent transformer if pre is defined",
                    transformer_undefined_p(pre) || transformer_consistency_p(post));
    }
    free_transformer(btf);
  }
 
  pips_debug(8, "end\n");
  return post;
}

References CAR, copy_transformer(), declaration_to_transformer(), ENDP, ENTITY, expression_undefined_p, free_expression(), free_transformer(), ifdebug, pips_assert, pips_debug, POP, stf(), transformer_combine(), transformer_consistency_p(), transformer_dup(), transformer_normalize(), transformer_safe_apply(), transformer_safe_normalize(), transformer_undefined, transformer_undefined_p, and variable_initial_expression().

Referenced by memorize_precondition_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

refine_transformers()

bool refine_transformers

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 354 of file dbm_interface.c.

{
  bool res;
  set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
  set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
  set_bool_property(SEMANTICS_FIX_POINT, true);
  select_fix_point_operator();
  set_bool_property(SEMANTICS_STDOUT, false);
  /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
  refine_transformers_p = true;
  res = module_name_to_transformers_in_context(module_name);
  refine_transformers_p = false;
  return res;
}

References module_name(), module_name_to_transformers_in_context(), refine_transformers_p, select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

refine_transformers_with_points_to()

bool refine_transformers_with_points_to

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 369 of file dbm_interface.c.

{
  bool res;
  set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
  set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
  set_bool_property(SEMANTICS_FIX_POINT, true);
  select_fix_point_operator();
  set_bool_property(SEMANTICS_STDOUT, false);
  /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
  set_pt_to_list( (statement_points_to)
                  db_get_memory_resource(DBR_POINTS_TO, module_name, true) );
  refine_transformers_p = true;
  res = module_name_to_transformers_in_context(module_name);
  refine_transformers_p = false;
  reset_pt_to_list();
  return res;
}

References db_get_memory_resource(), module_name(), module_name_to_transformers_in_context(), refine_transformers_p, reset_pt_to_list(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, set_bool_property(), and set_pt_to_list().

Here is the call graph for this function:

repeatloop_to_postcondition()

transformer repeatloop_to_postcondition	(	transformer	pre,
		whileloop	wl,
		transformer	t_body_star
	)

An effort could be made to compute the precondition for t_exit, especially if the precondition to t_inc is available.

The repeat loop does not fit well in the current generic approach. Most of the basic transformers such as t_init, t_skip, t_enter,... are meaningless. Instead of dealing with zero or at least one iteration, we have to deal with one or at least two.

post = (t_body_c ; t_exit)(pre) + (t_body_c ; t_continue ; t_body_star ; t_body_c ; t_exit)(pre)

where we assume that t_body_star includes the continuation condition.

Clean up memory

Parameters

pre	re
wl	l
t_body_star	_body_star

Definition at line 2760 of file loop.c.

{
  transformer post = transformer_undefined;
 
  statement body_s = whileloop_body(wl);
  transformer t_body = load_statement_transformer(body_s);
  transformer t_body_c = complete_statement_transformer(t_body, pre, body_s);
  transformer t_init = transformer_identity();
  transformer post_init = copy_transformer(pre);
  expression cond_e = whileloop_condition(wl);
  transformer t_continue = condition_to_transformer(cond_e, transformer_undefined, true);
  transformer t_exit = condition_to_transformer(cond_e, transformer_undefined, false);
  transformer t_skip = transformer_empty();
  //transformer t_skip = transformer_combine(copy_transformer(t_body), t_exit);
  transformer t_enter = transformer_identity();
  //transformer t_enter = transformer_combine(copy_transformer(t_body), t_continue);
  /* An effort could be made to compute the precondition for t_exit,
     especially if the precondition to t_inc is available. */
  transformer t_inc = transformer_identity();
  transformer post_1 = transformer_undefined;
  transformer post_2 = transformer_undefined;
  transformer post_3 = transformer_undefined;
  transformer post_4 = transformer_undefined;
  transformer post_5 = transformer_undefined;
  transformer post_6 = transformer_undefined;
 
  post = any_loop_to_postcondition(body_s,
                                   t_init,
                                   t_enter,
                                   t_skip,
                                   t_body_star,
                                   t_body_c,
                                   t_continue, //since t_inc is ineffective
                                   t_inc,
                                   t_exit,
                                   pre);
 
  /* The repeat loop does not fit well in the current generic
   * approach. Most of the basic transformers such as t_init, t_skip,
   * t_enter,... are meaningless. Instead of dealing with zero or at
   * least one iteration, we have to deal with one or at least two.
   *
   * post = (t_body_c ; t_exit)(pre) +
   *        (t_body_c ; t_continue ; t_body_star ; t_body_c ; t_exit)(pre)
   *
   * where we assume that t_body_star includes the continuation condition. 
   */
 
  free_transformer(post);
 
  post_1 = transformer_apply(t_body_c, pre);
  post_2 = transformer_apply(t_exit, post_1);
 
  post_3 = transformer_apply(t_continue, post_1);
  post_4 = transformer_apply(t_body_star, post_3);
  post_5 = transformer_apply(t_body_c, post_4);
  post_6 = transformer_apply(t_exit, post_5);
 
  post = transformer_convex_hull(post_2, post_6);
 
  /* Clean up memory */
 
  free_transformer(t_init);
  free_transformer(post_init);
  free_transformer(t_skip);
  free_transformer(t_enter);
  free_transformer(t_continue);
  free_transformer(t_exit);
  free_transformer(t_inc);
  free_transformer(t_body_c);
 
  free_transformer(post_1);
  free_transformer(post_2);
  free_transformer(post_3);
  free_transformer(post_4);
  free_transformer(post_5);
  free_transformer(post_6);
 
    return post;
}

References any_loop_to_postcondition(), complete_statement_transformer(), condition_to_transformer(), copy_transformer(), free_transformer(), load_statement_transformer(), transformer_apply(), transformer_convex_hull(), transformer_empty(), transformer_identity(), transformer_undefined, whileloop_body, and whileloop_condition.

Referenced by instruction_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

repeatloop_to_transformer()

transformer repeatloop_to_transformer	(	whileloop	wl,
		transformer	pre,
		list	wlel
	)

effects of whileloop wl

t_body_star = t_init ; t_enter ; (t_body ; t_next)+

t_once = t_body; t_exit

t_repeat = t_body_star + t_once

An effort could be made to compute the precondition for t_continue, especially if the precondition to t_inc is available.

FI: it should be computed with the postcondition of the body

The loop is executed at least twice; FI: I'm note sure the twice is captured

FI: example dowhile02 seems to show this is wrong with t_next empty, in spite of the star

The loop is executed only once

global transformer

Parameters

wl	l
pre	re
wlel	lel

Definition at line 449 of file loop.c.

{
  /* t_body_star =  t_init ; t_enter ; (t_body ; t_next)+
   *
   * t_once = t_body; t_exit
   *
   * t_repeat = t_body_star + t_once
   */
  transformer t_body_star = transformer_undefined;
  statement body_s = whileloop_body(wl);
  transformer t_body = transformer_undefined; // load_statement_transformer(body_s);
  transformer t_init = transformer_identity();
  expression cond_e = whileloop_condition(wl);
  transformer t_enter = transformer_identity();
  /* An effort could be made to compute the precondition for t_continue,
     especially if the precondition to t_inc is available. */
  transformer t_continue = condition_to_transformer(cond_e, transformer_undefined, true);
  /* FI: it should be computed with the postcondition of the body */
  transformer t_exit = condition_to_transformer(cond_e, transformer_undefined, false);
  //transformer t_inc = transformer_identity();
  transformer t_next = t_continue;
 
  /* The loop is executed at least twice; FI: I'm note sure the twice is captured */
  /* FI: example dowhile02 seems to show this is wrong with t_next
     empty, in spite of the star */
  t_body_star = any_loop_to_transformer(t_init, t_enter, t_next, body_s, wlel, pre);
 
  /* The loop is executed only once */
  // any_loop_to_transformer() has computed the body transformer
  t_body = load_statement_transformer(body_s);
  transformer t_once = transformer_combine(copy_transformer(t_body), t_exit);
 
  /* global transformer */
  transformer t_repeat = transformer_convex_hull(t_once, t_body_star);
 
  // free_transformer(t_once), free_transformer(t_body_star), free_transformer(t_next), free_transformer(t_exit), free_transformer(t_enter);
 
  return t_repeat;
}

References any_loop_to_transformer(), condition_to_transformer(), copy_transformer(), load_statement_transformer(), transformer_combine(), transformer_convex_hull(), transformer_identity(), transformer_undefined, whileloop_body, and whileloop_condition.

Referenced by whileloop_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_call_site_number()

void reset_call_site_number

(

void

)

Definition at line 1126 of file interprocedural.c.

{
    number_of_call_sites = 0;
}

References number_of_call_sites.

Referenced by ordinary_summary_precondition(), and summary_total_postcondition().

Here is the caller graph for this function:

reset_postcondition_map()

void reset_postcondition_map

(

void

)

reset_precondition_map()

void reset_precondition_map

(

void

)

Referenced by add_alias_pairs_for_this_caller(), any_complexities(), array_bound_check_interprocedural(), array_expansion(), bdsc_code_instrumentation(), comp_regions(), dsc_code_parallelization(), formal_array_resizing_bottom_up(), generic_module_name_to_transformers(), generic_print_xml_application(), hbdsc_parallelization(), ikernel_load_store(), 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(), pragma_outliner(), reset_convex_in_out_regions(), reset_convex_rw_regions(), reset_resources_for_module(), reset_static_phase_variables(), rice_dependence_graph(), sequence_dependence_graph(), solve_hardware_constraints(), and spire_distributed_unstructured_to_structured().

Here is the caller graph for this function:

reset_semantic_map()

void reset_semantic_map

(

void

)

Referenced by call_site_to_module_precondition_text(), get_semantic_text(), and update_precondition_with_call_site_preconditions().

Here is the caller graph for this function:

reset_total_precondition_map()

void reset_total_precondition_map

(

void

)

Referenced by module_name_to_total_preconditions(), and reset_static_phase_variables().

Here is the caller graph for this function:

reset_transformer_map()

void reset_transformer_map

(

void

)

Referenced by bdsc_code_instrumentation(), comp_regions(), continuation_conditions(), dsc_code_parallelization(), generic_module_name_to_transformers(), hbdsc_parallelization(), module_name_to_preconditions(), module_name_to_total_preconditions(), pragma_outliner(), reset_convex_in_out_regions(), reset_convex_rw_regions(), reset_static_phase_variables(), sequence_dependence_graph(), and spire_distributed_unstructured_to_structured().

Here is the caller graph for this function:

safe_any_assign_operation_to_transformer()

transformer safe_any_assign_operation_to_transformer	(	entity	tmp,
		list	args,
		transformer	pre,
		bool	is_internal
	)

Parameters

tmp	mp
args	rgs
pre	re
is_internal	s_internal

Definition at line 575 of file expression.c.

{
  transformer tf = any_assign_operation_to_transformer(tmp, args, pre, is_internal);
  if(transformer_undefined_p(tf)) {
    // FI: I'd like tmp to appear in the basis...
    tf = transformer_identity();
  }
  return tf;
}

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

Here is the call graph for this function:

safe_any_expression_side_effects_to_transformer()

transformer safe_any_expression_side_effects_to_transformer	(	expression	e,
		transformer	p,
		bool	is_internal
	)

Same as any_expression_side_effects_to_transformer() but effects are used to always generate a transformer.

FI: I do not know how effects should be used. It might be useful to allow special transformers using location abstraction to simplify the recurrence. Currently, effects are used or not. It might be necessary to use only some of them at a given time in the evaluation process as variables can be assigned almost anywhere in C.

Parameters

is_internal

s_internal

Definition at line 4947 of file expression.c.

{
  transformer tf =
    any_expression_side_effects_to_transformer(e, p, is_internal);
  if(transformer_undefined_p(tf)) {
    tf = expression_effects_to_transformer(e);
  }
 
  return tf;
}

References any_expression_side_effects_to_transformer(), expression_effects_to_transformer(), and transformer_undefined_p.

Here is the call graph for this function:

safe_any_expression_to_transformer()

transformer safe_any_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre,
		bool	is_internal
	)

Always return a usable transformer.

Use effects if no better transformer can be found

Parameters

expr	xpr
pre	re
is_internal	s_internal

Definition at line 5156 of file expression.c.

{
  transformer npre = transformer_undefined_p(pre)?
    transformer_identity() : copy_transformer(pre);
  transformer tf = any_expression_to_transformer(v, expr, npre, is_internal);
 
  if(transformer_undefined_p(tf)) {
    //list el = expression_to_proper_effects(expr);
    list el = expression_to_proper_constant_path_effects(expr);
    tf = effects_to_transformer(el);
 
    /*
      pips_assert("effect references are protected by persistant",
      effect_list_can_be_safely_full_freed_p(el));*/
 
    (void) effect_list_can_be_safely_full_freed_p(el);
 
    gen_full_free_list(el);
  }
  free_transformer(npre);
 
  return tf;
}

References any_expression_to_transformer(), copy_transformer(), effect_list_can_be_safely_full_freed_p(), effects_to_transformer(), expression_to_proper_constant_path_effects(), free_transformer(), gen_full_free_list(), transformer_identity(), and transformer_undefined_p.

Referenced by add_index_bound_conditions(), addition_operation_to_transformer(), any_conditional_to_transformer(), any_expressions_to_transformer(), any_user_call_site_to_transformer(), bitwise_xor_to_transformer(), condition_to_transformer(), fortran_data_to_prec_for_variables(), logical_not_to_transformer(), modulo_to_transformer(), precondition_minmax_of_expression(), transformer_add_any_relation_information(), and update_cp_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_assigned_expression_to_transformer()

transformer safe_assigned_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre
	)

Always returns a fully defined transformer.

FI: The property to compute transformers in context is not taken into account to add information from pre within tf. pre is used to evaluate expr, but is not made part of tf.

Side effects in expression ?

Parameters

expr	xpr
pre	re

Definition at line 2651 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
 
  if(expression_undefined_p(expr)) {
    ; // That is fixed below
  }
  else
    tf = assigned_expression_to_transformer(v, expr, pre);
 
  if(transformer_undefined_p(tf)) {
    if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"))
      tf = transformer_range(pre);
    else
      tf = transformer_identity();
 
    /* Side effects in expression ? */
    transformer setf = expression_effects_to_transformer(expr);
    tf = transformer_combine(tf, setf);
    free_transformer(setf);
 
    // FI: need to investigate interplay between typedef and
    // qualifier?
    // FI: Issue: a static variable qualified with const and accessed thru
    // a function. See hs_list_smoothing() in hyantes
    // Or you see the issue as using assignment analysis for static definition...
    if(entity_has_values_p(v) && !type_with_const_qualifier_p(entity_type(v))) {
      tf = transformer_add_modified_variable_entity(tf, v);
    }
  }
 
  pips_assert("tf is defined", !transformer_undefined_p(tf));
  pips_assert("tf is consistent", transformer_consistency_p(tf));
 
  return tf;
}

References assigned_expression_to_transformer(), entity_has_values_p(), entity_type, expression_effects_to_transformer(), expression_undefined_p, free_transformer(), get_bool_property(), pips_assert, transformer_add_modified_variable_entity(), transformer_combine(), transformer_consistency_p(), transformer_identity(), transformer_range(), transformer_undefined, transformer_undefined_p, and type_with_const_qualifier_p().

Referenced by declaration_to_transformer(), and declaration_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_assigned_expression_to_transformer_list()

list safe_assigned_expression_to_transformer_list	(	entity	v,
		expression	expr,
		transformer	pre
	)

Always returns a fully defined transformer.

FI: The property to compute transformers in context is not taken into account to add information from pre within tf. pre is used to evaluate expr, but is not made part of tf.

Parameters

expr	xpr
pre	re

Definition at line 610 of file ri_to_transformer_lists.c.

{
  list tl = NIL;
  transformer tf = transformer_undefined;
 
  pips_internal_error("Not implemented yet.");
 
  if(expression_undefined_p(expr)) {
    ; // That is fixed below
  }
  else
    tf = assigned_expression_to_transformer(v, expr, pre);
 
  if(transformer_undefined_p(tf)) {
    if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"))
      tf = transformer_range(pre);
    else
      tf = transformer_identity();
 
    if(entity_has_values_p(v)) {
      tf = transformer_add_modified_variable_entity(tf, v);
    }
  }
 
  //pips_assert("tf is defined", !transformer_undefined_p(tf));
  pips_assert("tl is consistent", transformers_consistency_p(tl));
 
  return tl;
}

References assigned_expression_to_transformer(), entity_has_values_p(), expression_undefined_p, get_bool_property(), NIL, pips_assert, pips_internal_error, transformer_add_modified_variable_entity(), transformer_identity(), transformer_range(), transformer_undefined, transformer_undefined_p, and transformers_consistency_p().

Here is the call graph for this function:

safe_expression_to_transformer()

transformer safe_expression_to_transformer	(	expression	exp,
		transformer	pre
	)

This simple function does not take points-to information into account. Furthermore, precise points-to information is not available when side effects occur as in comma expressions.

FI: I do not see a simple way out. I can try to fix partly the problem in statement_to_transformer where the effects are known... Or I can play safer and use an effect function that replaces dereferencements by anywhere effects.

See anywhere03.c as an example of the issue.

Parameters

exp	xp
pre	re

Definition at line 5307 of file expression.c.

{
  /* This simple function does not take points-to information into
     account. Furthermore, precise points-to information is not
     available when side effects occur as in comma expressions.
 
     FI: I do not see a simple way out. I can try to fix partly the
     problem in statement_to_transformer where the effects are
     known... Or I can play safer and use an effect function that
     replaces dereferencements by anywhere effects.
 
     See anywhere03.c as an example of the issue.
  */
  transformer tf = transformer_undefined;
  // To be careful with extended expressions generated by points-to information
  if(expression_reference_p(exp)) {
    reference r = expression_reference(exp);
    entity v = reference_variable(r);
    if(entity_field_p(v)) { // s[var1], not effect no a constant
      tf = transformer_identity();
    }
  }
 
  if(transformer_undefined_p(tf)) {
    //list el = expression_to_proper_effects(exp);
    list el = expression_to_proper_constant_path_effects(exp);
    tf = expression_to_transformer(exp, pre, el);
 
    gen_full_free_list(el);
  }
 
  return tf;
}

References entity_field_p(), exp, expression_reference(), expression_reference_p(), expression_to_proper_constant_path_effects(), expression_to_transformer(), gen_full_free_list(), reference_variable, transformer_identity(), transformer_undefined, and transformer_undefined_p.

Referenced by any_assign_to_transformer(), any_expressions_to_transformer(), assign_rhs_to_reflhs_to_transformer(), complete_forloop_transformer(), complete_forloop_transformer_list(), condition_to_transformer(), conditional_to_transformer(), dimensions_to_transformer(), expression_to_transformer(), expressions_to_transformer(), forloop_to_postcondition(), forloop_to_transformer(), and struct_reference_assignment_or_equality_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_integer_expression_to_transformer()

transformer safe_integer_expression_to_transformer	(	entity	v,
		expression	expr,
		transformer	pre,
		bool	is_internal
	)

Always return a defined transformer, using effects in case a more precise analysis fails.

Do check wrt to value mappings... if you are not dealing with interprocedural issues

Parameters

expr	xpr
pre	re
is_internal	s_internal

Definition at line 3552 of file expression.c.

{
  transformer tf = integer_expression_to_transformer(v, expr, pre, is_internal);
 
  if(transformer_undefined_p(tf))
    tf = expression_effects_to_transformer(expr);
 
  return tf;
}

References expression_effects_to_transformer(), integer_expression_to_transformer(), and transformer_undefined_p.

Referenced by expression_multiply_sizeof_to_transformer(), integer_binary_operation_to_transformer(), integer_left_shift_to_transformer(), integer_multiply_to_transformer(), loop_to_enter_transformer(), and transformer_add_condition_information_updown().

Here is the call graph for this function:

Here is the caller graph for this function:

same_analyzable_type_scalar_entity_list_p()

bool same_analyzable_type_scalar_entity_list_p

(

list

l

)

Definition at line 255 of file interprocedural.c.

{
  bool result = true;
 
  if (!ENDP(l)) {
    entity e1 = ENTITY(CAR(l));
    type t1 = entity_type(e1);
    result = analyzable_scalar_entity_p(e1);
 
    MAP(ENTITY,el, {
      if (result) {
        type t = entity_type(el);
        result = result && analyzable_scalar_entity_p(el)
          && type_equal_p(t1, t);
      }
    },
        CDR(l));
  }
  return result;
}

References analyzable_scalar_entity_p(), CAR, CDR, ENDP, ENTITY, entity_type, MAP, and type_equal_p().

Referenced by precondition_intra_to_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

semantic_map_undefined_p()

bool semantic_map_undefined_p

(

void

)

prettyprint.c

semantic_to_text()

text semantic_to_text	(	entity	module,
		int	margin,
		statement	stmt
	)

this function name is VERY misleading - it should be changed, sometime FI

Parameters

module	odule
margin	argin
stmt	tmt

Definition at line 354 of file prettyprint.c.

{
    transformer t;
    text txt;
 
    pips_assert("To please the compiler", module==module && margin==margin);
 
    if(is_user_view) {
        statement i = apply_number_to_statement(nts, statement_number(stmt));
 
        if(!statement_undefined_p(i)) {
            t = load_statement_semantic(i);
        }
        else
            t = (transformer) HASH_UNDEFINED_VALUE;
    }
    else
        t = load_statement_semantic(stmt);
 
    if(is_transformer_filtered && !transformer_undefined_p(t)
        && t != (transformer) HASH_UNDEFINED_VALUE) {
        list ef = load_cumulated_rw_effects_list(stmt);
        t = filter_transformer(t, ef);
    }
 
    txt = text_transformer(t);
 
    if (is_transformer)
        attach_transformers_decoration_to_text(txt);
    else if (is_total_precondition)
        attach_total_preconditions_decoration_to_text(txt);
    else
        attach_preconditions_decoration_to_text(txt);
 
    return txt;
}

References apply_number_to_statement(), attach_preconditions_decoration_to_text(), attach_total_preconditions_decoration_to_text(), attach_transformers_decoration_to_text(), filter_transformer(), HASH_UNDEFINED_VALUE, is_total_precondition, is_transformer, is_transformer_filtered, is_user_view, load_cumulated_rw_effects_list(), load_statement_semantic(), module, nts, pips_assert, statement_number, statement_undefined_p, text_transformer(), and transformer_undefined_p.

Referenced by get_semantic_text().

Here is the call graph for this function:

Here is the caller graph for this function:

semantics_expression_to_points_to_sinks()

list semantics_expression_to_points_to_sinks

(

expression

e

)

Returns a list of cells.

Definition at line 112 of file points_to.c.

{
  list ll = list_undefined;
  if(pt_to_list_undefined_p()) {
    type t = points_to_expression_to_concrete_type(e);
    cell c = make_anywhere_points_to_cell(t);
    ll = CONS(CELL, c, NIL);
  }
  else {
    statement curstat =  get_current_statement_from_statement_global_stack();
    points_to_graph ptg = get_points_to_graph_from_statement(curstat);
    ll = expression_to_points_to_sinks(e, ptg);
  }
  return ll;
}

References CELL, CONS, expression_to_points_to_sinks(), get_current_statement_from_statement_global_stack(), get_points_to_graph_from_statement(), list_undefined, make_anywhere_points_to_cell(), NIL, points_to_expression_to_concrete_type(), and pt_to_list_undefined_p().

Referenced by generic_unary_operation_to_transformer(), and points_to_unary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

semantics_expression_to_points_to_sources()

list semantics_expression_to_points_to_sources

(

expression

e

)

points_to.c

points_to.c

FI: check if new cells are allocated to build the returned location list ll...

Definition at line 94 of file points_to.c.

{
  points_to_graph ptg = points_to_graph_undefined;
  if (!pt_to_list_undefined_p()) {
    statement curstat =  get_current_statement_from_statement_global_stack();
    if(statement_undefined_p(curstat)) {
      // The points-to IN information should be used
      ;
    }
    else
      ptg = get_points_to_graph_from_statement(curstat);
  }
 
  list ll = expression_to_points_to_sources(e, ptg);
  return ll;
}

References expression_to_points_to_sources(), get_current_statement_from_statement_global_stack(), get_points_to_graph_from_statement(), points_to_graph_undefined, pt_to_list_undefined_p(), and statement_undefined_p.

Referenced by any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), lhs_expression_to_transformer(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), and struct_reference_assignment_or_equality_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

semantics_usable_points_to_reference_p()

bool semantics_usable_points_to_reference_p	(	reference	rlhs,
		expression	lhs,
		int	n
	)

See if references rlhs is usable and process null, undefined and anywhere locations defined by rlhs.

Expression lhs is passed to clarify the error and warning messages.

n is the number of alternative references. It is used to check the severity of unusable references. If n=1, a NULL rlhs implies a bug. If n>1, the points-to analysis could not determine precisely the target location.

This function is designed to check constant references in a loop over a list of references returned by the points-to analysis.

A heap location may represent several locations. p==heap ^ q==heap does not imply p==q

An anywhere location may represent several locations. p==heap ^ q==heap does not imply p==q

Parameters

rlhs	lhs
lhs	hs

Definition at line 6194 of file expression.c.

{
  bool usable_p = false;
  entity source_lhs = reference_variable(rlhs);
  string lhss = expression_undefined_p(lhs)?
    reference_to_string(rlhs) : expression_to_string(lhs);
 
  ifdebug(7) {
    pips_debug(7, "source reference : %s\n", reference_to_string(rlhs));
  }
 
  if (entity_null_locations_p(source_lhs)) {
    if (n == 1)
      // An empty transformer should be returned...
      pips_user_error("The pointer expression \"%s\" always points to NULL\n",
                      lhss);
    else
      semantics_user_warning("The pointer \"%s\" can point to NULL\n",
                             lhss);
  }
  else if (entity_typed_nowhere_locations_p(source_lhs)) {
    if (n == 1)
      pips_user_error("The pointer expression \"%s\" always points to undefined/indeterminate (%s)\n", lhss, reference_to_string(rlhs));
    else {
      semantics_user_warning("The pointer expression \"%s\" can point to undefined/indeterminate (%s)\n", lhss, reference_to_string(rlhs));
    }
  }
  else if(entity_heap_location_p(source_lhs)) {
    // entity_all_heap_locations_p()
    // entity_all_module_heap_locations_p()
    // entity_all_module_heap_locations_typed : the predicate does not seem to exist
    /* A heap location may represent several locations. p==heap ^
       q==heap does not imply p==q */
    usable_p = false;
  }
  else if(entity_anywhere_locations_p(source_lhs)
          || entity_typed_anywhere_locations_p(source_lhs)) {
    /* An anywhere location may represent several locations. p==heap ^
       q==heap does not imply p==q */
    usable_p = false;
  }
  else {
    // usable_p = atomic_points_to_reference_p(rlhs);
    type t = points_to_reference_to_concrete_type(rlhs);
    usable_p = analyzed_type_p(t)
      || (type_variable_p(t) && type_struct_variable_p(t));
  }
 
  ifdebug(7) {
    pips_debug(7, "source reference \"%s\" is %s\n", reference_to_string(rlhs),
               usable_p ? "usable" : "not usable");
  }
 
  return usable_p;
}

References analyzed_type_p(), entity_anywhere_locations_p(), entity_heap_location_p(), entity_null_locations_p(), entity_typed_anywhere_locations_p(), entity_typed_nowhere_locations_p(), expression_to_string(), expression_undefined_p, ifdebug, pips_debug, pips_user_error, points_to_reference_to_concrete_type(), reference_to_string(), reference_variable, semantics_user_warning, type_struct_variable_p(), and type_variable_p.

Referenced by any_assign_to_transformer(), generic_unary_operation_to_transformer(), lhs_expression_to_transformer(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), and struct_reference_assignment_or_equality_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

semantics_user_warning_func()

void semantics_user_warning_func	(	const char *	func_name,
		const char *	format,
			...
	)

Parameters

func_name	unc_name
format	ormat

Definition at line 118 of file misc.c.

{
  va_list args;
  va_start(args, format);
  semantics_user_warning_alist(func_name, format, &args);
  va_end(args);
}

References semantics_user_warning_alist().

Here is the call graph for this function:

semantics_user_warning_func2()

void semantics_user_warning_func2	(	const char *	format,
			...
	)

Parameters

format

ormat

Definition at line 129 of file misc.c.

{
  va_list args;
  va_start(args, format);
  semantics_user_warning_alist(pips_unknown_function, format, &args);
  va_end(args);
}

References pips_unknown_function, and semantics_user_warning_alist().

Here is the call graph for this function:

set_module_global_arguments()

void set_module_global_arguments

(

list

args

)

Parameters

args

rgs

Definition at line 103 of file ri_to_preconditions.c.

{
    module_global_arguments = args;
}

References module_global_arguments.

Referenced by module_name_to_preconditions(), and module_name_to_total_preconditions().

Here is the caller graph for this function:

set_postcondition_map()

void set_postcondition_map

(

statement_mapping

)

Referenced by set_resources_for_module().

Here is the caller graph for this function:

set_precondition_map()

void set_precondition_map

(

statement_mapping

)

Referenced by add_alias_pairs_for_this_caller(), any_complexities(), array_bound_check_interprocedural(), array_expansion(), bdsc_code_instrumentation(), comp_regions(), dsc_code_parallelization(), formal_array_resizing_bottom_up(), generic_module_name_to_transformers(), generic_print_xml_application(), hbdsc_parallelization(), ikernel_load_store(), init_convex_in_out_regions(), init_convex_rw_regions(), init_use_preconditions(), isolate_statement(), kernel_data_mapping(), kernel_load_store_engine(), module_name_to_preconditions(), module_name_to_total_preconditions(), out_regions_from_caller_to_callee(), pragma_outliner(), rice_dependence_graph(), sequence_dependence_graph(), set_resources_for_module(), solve_hardware_constraints(), and spire_distributed_unstructured_to_structured().

Here is the caller graph for this function:

set_prettyprint_transformer()

void set_prettyprint_transformer

(

void

)

Definition at line 77 of file prettyprint.c.

{
  is_transformer = true;
  is_total_precondition = false;
  is_transformer_filtered = false;
}

References is_total_precondition, is_transformer, and is_transformer_filtered.

set_semantic_map()

void set_semantic_map

(

statement_mapping

)

Referenced by call_site_to_module_precondition_text(), get_semantic_text(), and update_precondition_with_call_site_preconditions().

Here is the caller graph for this function:

set_total_precondition_map()

void set_total_precondition_map

(

statement_mapping

)

Referenced by module_name_to_total_preconditions().

Here is the caller graph for this function:

set_transformer_map()

void set_transformer_map

(

statement_mapping

)

Referenced by bdsc_code_instrumentation(), comp_regions(), continuation_conditions(), dsc_code_parallelization(), generic_module_name_to_transformers(), hbdsc_parallelization(), init_convex_in_out_regions(), init_convex_rw_regions(), module_name_to_preconditions(), module_name_to_total_preconditions(), pragma_outliner(), sequence_dependence_graph(), and spire_distributed_unstructured_to_structured().

Here is the caller graph for this function:

set_warning_counters()

void set_warning_counters

(

void

)

Definition at line 903 of file dbm_interface.c.

{
  wc = 0;
}

References wc.

Referenced by generic_module_name_to_transformers().

Here is the caller graph for this function:

simple_affine_to_transformer()

transformer simple_affine_to_transformer	(	entity	e,
		Pvecteur	a,
		bool	is_internal
	)

INTEGER EXPRESSIONS.

FI: I do no longer understand the semantics of "is_internal"... although I designed it. The intent was probably to manage temporary values: they should be preserved as long as the analysis is internal and else projected.

Furthermore, this function is no longer very useful as normalization can be performed dynamically again and again at a low cost.

The renaming from variables in a to new values in ve and vexpr is performed as a side-effect by value_mappings_compatible_vector_p() which fails when a renaming fails.

This is very dangerous when is_internal==false

Parameters

is_internal

s_internal

Definition at line 1167 of file expression.c.

{
  transformer tf = transformer_undefined;
  Pvecteur ve = vect_new((Variable) e, VALUE_ONE);
  Pvecteur vexpr = vect_dup(a);
  Pcontrainte c;
  Pvecteur eq = VECTEUR_NUL;
 
  pips_debug(8, "begin with is_internal=%s\n", bool_to_string(is_internal));
 
  ifdebug(9) {
    pips_debug(9, "\nLinearized expression:\n");
    vect_dump(vexpr);
  }
 
  /* The renaming from variables in a to new values in ve and vexpr is
   * performed as a side-effect by
   * value_mappings_compatible_vector_p() which fails when a
   * renaming fails.
   *
   * This is very dangerous when is_internal==false
   */
  if(!is_internal
     || (value_mappings_compatible_vector_p(ve) &&
         value_mappings_compatible_vector_p(vexpr))) {
    eq = vect_substract(ve, vexpr);
    vect_rm(ve);
    vect_rm(vexpr);
    c = contrainte_make(eq);
    tf = make_transformer(NIL,
                          make_predicate(sc_make(c, CONTRAINTE_UNDEFINED)));
  }
  else {
    vect_rm(eq);
    vect_rm(ve);
    vect_rm(vexpr);
    tf = transformer_undefined;
  }
 
  pips_debug(8, "end with tf=%p\n", tf);
  ifdebug(8) dump_transformer(tf);
 
  return tf;
}

References bool_to_string(), contrainte_make(), CONTRAINTE_UNDEFINED, dump_transformer, eq, ifdebug, make_predicate(), make_transformer(), NIL, pips_debug, sc_make(), transformer_undefined, value_mappings_compatible_vector_p(), VALUE_ONE, vect_dump(), vect_dup(), vect_new(), vect_rm(), vect_substract(), and VECTEUR_NUL.

Referenced by integer_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_dead_loop_p()

bool simple_dead_loop_p	(	expression	lower,
		expression	upper
	)

Parameters

lower	ower
upper	pper

Definition at line 1028 of file loop.c.

{
  bool dead_loop_p = false;
  normalized n_lower = NORMALIZE_EXPRESSION(lower);
  normalized n_upper = NORMALIZE_EXPRESSION(upper);
 
  if(normalized_linear_p(n_upper) && normalized_linear_p(n_lower)) {
    Pvecteur v_lower = normalized_linear(n_lower);
    Pvecteur v_upper = normalized_linear(n_upper);
 
    if(VECTEUR_NUL_P(v_lower)) {
      if (!VECTEUR_NUL_P(v_upper)) {
        if(term_cst(v_upper)
           && VECTEUR_NUL_P(vecteur_succ(v_upper))) {
          dead_loop_p =  value_neg_p(vecteur_val(v_upper));
        }
      }
    }
    else if(VECTEUR_NUL_P(v_upper)) {
      if (!VECTEUR_NUL_P(v_lower)) {
        if(term_cst(v_lower)
           && VECTEUR_NUL_P(vecteur_succ(v_lower))) {
          dead_loop_p =  value_pos_p(vecteur_val(v_lower));
        }
      }
    }
    else if(term_cst(v_upper) && term_cst(v_lower)
            && VECTEUR_NUL_P(vecteur_succ(v_upper))
            && VECTEUR_NUL_P(vecteur_succ(v_lower))) {
      dead_loop_p =
        value_gt(vecteur_val(v_lower),vecteur_val(v_upper));
    }
  }
 
  return dead_loop_p;
}

References NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, term_cst, value_gt, value_neg_p, value_pos_p, VECTEUR_NUL_P, vecteur_succ, and vecteur_val.

Referenced by add_index_range_conditions().

Here is the caller graph for this function:

simplify_boolean_expression_with_precondition()

int simplify_boolean_expression_with_precondition	(	expression	e,
		transformer	p
	)

Simplification of bool expressions with precondition.

Expression e is modified, if necessary, by side effect.

The value returned is 1 if the expression e is always true (never false) under condition p, 0 if is the expression is always false (never true), and -1 otherwise.

This function is not used within the semantics library. It is exported for partial_eval and suppress_dead_code or similar passes.

Because of C flexibility, all kinds of "boolean" expressions may arise. Think of the conditional and comma operators, think of all kinds of side effects, think of integer expressions,...

FI: In the short term, I only need to deal with bool operators and, or and not.

Definition at line 6080 of file expression.c.

{
  int validity = -1; // unknown
  bool done = false;
  if(logical_operator_expression_p(e)) {
    // We could try the global simplification as in the other case...
    syntax s = expression_syntax(e);
    call c = syntax_call(s);
    entity op = call_function(c);
    if(ENTITY_NOT_P(op)) {
      expression a = EXPRESSION(CAR(call_arguments(c)));
      validity = simplify_boolean_expression_with_precondition(a,p);
      if(validity>=0)
        validity = 1 - validity;
      done = true;
    }
    else if(ENTITY_OR_P(op)) {
      expression a1 = EXPRESSION(CAR(call_arguments(c)));
      int v1 = simplify_boolean_expression_with_precondition(a1,p);
      if(v1==1)
        validity = 1;
      else {
        expression a2 = EXPRESSION(CAR(CDR(call_arguments(c))));
        int v2 = simplify_boolean_expression_with_precondition(a2,p);
        if(v2==1)
          validity = 1;
        else if(v2==0) { // a2 has no impact
          if(v1==0)
            validity = 0;
          else {
            validity = -1;
            replace_expression_content(e, copy_expression(a1));
          }
        }
        else // v2==-1
          if(v1==0) { // a1 has no impact
            validity = -1;
            replace_expression_content(e, copy_expression(a2));
          }
          else
            validity = -1;
      }
      done =true;
    }
    else if(ENTITY_AND_P(op)) {
      expression a1 = EXPRESSION(CAR(call_arguments(c)));
      int v1 = simplify_boolean_expression_with_precondition(a1,p);
      if(v1==0)
        validity = 0;
      else { // v1 == -1 or 1, no conclusion yet
        expression a2 = EXPRESSION(CAR(CDR(call_arguments(c))));
        int v2 = simplify_boolean_expression_with_precondition(a2,p);
        if(v2==0)
          validity = 0;
        else if(v2==1) {
          if(v1==1)
            validity = 1;
          else { // get rid of a2
            validity = -1;
            replace_expression_content(e, copy_expression(a1));
          }
        }
        else { // v2==-1
          if(v1==1) {// a1 is useless
            validity = -1;
            replace_expression_content(e, copy_expression(a2));
          }
          else {
            validity = -1;
          }
        }
      }
      done =true;
    }
  }
  if (!done) {
    transformer tt = condition_to_transformer(e,p, true);
    transformer ft = condition_to_transformer(e,p, false);
 
    if(transformer_empty_p(tt)) {
      // Then the condition is always false
      validity = 0;
    }
    if(transformer_empty_p(ft)) {
      // Then the condition is always true
      validity = 1;
    }
    // Both can be true simultaneously when the precondition p is
    // empty... but it does not matter
  }
 
  if(validity==0||validity==1) {
    // e must be replaced by a call to true or false
    expression ne = validity?make_true_expression():make_false_expression();
    replace_expression_content(e, ne);
  }
 
  return validity;
}

References call_arguments, call_function, CAR, CDR, condition_to_transformer(), copy_expression(), ENTITY_AND_P, ENTITY_NOT_P, ENTITY_OR_P, EXPRESSION, expression_syntax, logical_operator_expression_p(), make_false_expression(), make_true_expression(), replace_expression_content(), syntax_call, and transformer_empty_p().

Here is the call graph for this function:

simplify_minmax_expression()

void simplify_minmax_expression	(	expression	e,
		transformer	tr
	)

tries hard to simplify expression e if it is a min or a max operator, by evaluating it under preconditions tr.

Two approaches are tested: check bounds of lhs-rhs, or compare bounds of lhs and rhs

Parameters

tr

r

Definition at line 5849 of file expression.c.

{
    if(expression_minmax_p(e)) {
        call c =expression_call(e);
        bool is_max = ENTITY_MAX_P(call_function(c));
 
        expression lhs = binary_call_lhs(c);
        expression rhs = binary_call_rhs(c);
        expression diff = make_op_exp(
                MINUS_OPERATOR_NAME,
                copy_expression(lhs),
                copy_expression(rhs)
                );
        intptr_t lhs_lbound,lhs_ubound,rhs_lbound,rhs_ubound,diff_lbound,diff_ubound;
        if(precondition_minmax_of_expression(diff,tr,&diff_lbound,&diff_ubound) &&
            (diff_lbound>=0 || diff_ubound<=0)) {
            if(is_max) {
                if(diff_lbound>=0) local_assign_expression(e,lhs);
                else local_assign_expression(e,rhs);
            }
            else {
                if(diff_lbound>=0) local_assign_expression(e,rhs);
                else local_assign_expression(e,lhs);
            }
        }
        else if(precondition_minmax_of_expression(lhs,tr,&lhs_lbound,&lhs_ubound) &&
                precondition_minmax_of_expression(rhs,tr,&rhs_lbound,&rhs_ubound))
        {
            if(is_max)
            {
                if(lhs_lbound >=rhs_ubound) local_assign_expression(e,lhs);
                else if(rhs_lbound >= lhs_ubound) local_assign_expression(e,rhs);
            }
            else
            {
                if(lhs_lbound >=rhs_ubound) local_assign_expression(e,rhs);
                else if(rhs_lbound >= lhs_ubound) local_assign_expression(e,lhs);
            }
        }
    }
}

References binary_call_lhs, binary_call_rhs, call_function, copy_expression(), ENTITY_MAX_P, expression_call(), expression_minmax_p(), intptr_t, is_max, local_assign_expression(), make_op_exp(), MINUS_OPERATOR_NAME, and precondition_minmax_of_expression().

Referenced by do_array_expansion(), do_solve_hardware_constraints_on_nb_proc(), and region_to_minimal_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

standard_whileloop_to_transformer()

transformer standard_whileloop_to_transformer	(	whileloop	l,
		transformer	pre,
		list	e
	)

This function computes the effect of K loop iteration, with K positive.

This function does not take the loop exit into account because its result is used to compute the precondition of the loop body. Hence the loop exit condition only is added when preconditions are computed. This is confusing when transformers are prettyprinted with the source code.

loop transformer tf = tfb* or tf = tfb+ or ...

loop body transformer

Make sure not to leave too much information in pre. Perform a very simplistic fix point based on effects.

If the while entry condition is usable, it must be added on the old values

I'd like to use pre_n as context to evaluate the condition cond, but I'm not sure it's safe (Francois Irigoin)

Side effects in cond are ignored!

compute the whileloop body transformer, including the initial conditions

The convex hull of the image of pre and of the image of tfb can be added as conditions on tfb's domain, if some information is available in pre

compute tfb's fix point according to pips flags

The second clause is probably stronger than the first one

The loop is never entered

Side effects of the condition evaluation should be taken into account

A temporary variable is expected as first argument. There is something to fix.

tf = any_expression_to_transformer();

The loop is never exited, e.g. because there is a STOP or an infinite loop inside

Dirty looking fix for a fix point computation error: sometimes, the basis is restricted to a subset of the integer scalar variables. Should be useless with proper fixpoint opertors.

we have a problem here: to compute preconditions within the whileloop body we need a tf using private variables; to return the loop transformer, we need a filtered out tf; only one hook is available in the ri..; let'a assume there are no private variables and that if they are privatizable they are not going to get in our way

basic cheap version: do not use the whileloop body transformer and avoid fix-points; local variables do not have to be filtered out because this was already done while computing effects

The loop body transformers could benefit from pre_n instead of transformer_undefined, but who would think of combining these two options?

Parameters

pre

re

Definition at line 2456 of file loop.c.

{
  /* loop transformer tf = tfb* or tf = tfb+ or ... */
  transformer tf;
  /* loop body transformer */
  transformer tfb;
  expression cond = whileloop_condition(l);
  statement s = whileloop_body(l);
 
  pips_debug(8,"begin\n");
 
  if(pips_flag_p(SEMANTICS_FIX_POINT)) {
    transformer pre_n = transformer_undefined;
 
    if(transformer_undefined_p(pre)) {
      pre_n = transformer_identity();
    }
    else {
      /* Make sure not to leave too much information in pre. Perform a very
         simplistic fix point based on effects. */
      transformer tf_star = effects_to_transformer(e);
 
      pre_n = invariant_wrt_transformer(pre, tf_star);
      free_transformer(tf_star);
    }
    /* If the while entry condition is usable, it must be added
     * on the old values
     */
    /* I'd like to use pre_n as context to evaluate the condition cond,
       but I'm not sure it's safe (Francois Irigoin) */
    /* Side effects in cond are ignored! */
    pre_n = precondition_add_condition_information(pre_n, cond,
                                                   transformer_undefined, true);
 
    ifdebug(8) {
      pips_debug(8, "Precondition for loop body pre_n=\n");
      fprint_transformer(stderr, pre_n, (get_variable_name_t) external_value_name);
    }
 
    /* compute the whileloop body transformer, including the initial conditions */
    tfb = transformer_dup(statement_to_transformer(s, pre_n));
 
    /* The convex hull of the image of pre and of the image of tfb can be
       added as conditions on tfb's domain, if some information is available in pre */
    if(!transformer_undefined_p(pre))
      tfb = loop_body_transformer_add_entry_and_iteration_information(tfb, pre);
 
    /* compute tfb's fix point according to pips flags */
    if(pips_flag_p(SEMANTICS_INEQUALITY_INVARIANT)) {
      tf = transformer_halbwachs_fix_point(tfb);
    }
    else if ((!transformer_undefined_p(pre)
             && condition_false_wrt_precondition_p(cond, pre))
             /* The second clause is probably stronger than the first one */
             || transformer_empty_p(pre_n)) {
      /* The loop is never entered */
      /* Side effects of the condition evaluation should be taken into account */
      tf = transformer_identity();
      /* A temporary variable is expected as first argument. There is something to fix. */
      /* tf = any_expression_to_transformer(); */
    }
    else if(transformer_empty_p(tfb)) {
      /* The loop is never exited, e.g. because there is a STOP or an infinite loop inside */
      tf = transformer_empty();
    }
    else {
      transformer ftf = (* transformer_fix_point_operator)(tfb);
 
      if(*transformer_fix_point_operator==transformer_equality_fix_point) {
        Psysteme fsc = predicate_system(transformer_relation(ftf));
        Psysteme sc = SC_UNDEFINED;
 
        /* Dirty looking fix for a fix point computation error:
         * sometimes, the basis is restricted to a subset of
         * the integer scalar variables. Should be useless with proper
         * fixpoint opertors.
         */
        tf = effects_to_transformer(e);
        sc = (Psysteme) predicate_system(transformer_relation(tf));
 
        sc = sc_append(sc, fsc);
 
        free_transformer(ftf);
      }
      else {
        tf = ftf;
      }
 
      ifdebug(8) {
        pips_debug(8, "intermediate fix-point tf=\n");
        fprint_transformer(stderr, tf, (get_variable_name_t) external_value_name);
      }
 
    }
 
    free_transformer(pre_n);
 
    /* we have a problem here: to compute preconditions within the
       whileloop body we need a tf using private variables; to return
       the loop transformer, we need a filtered out tf; only
       one hook is available in the ri..; let'a assume there
       are no private variables and that if they are privatizable
       they are not going to get in our way */
  }
  else {
    /* basic cheap version: do not use the whileloop body transformer and
       avoid fix-points; local variables do not have to be filtered out
       because this was already done while computing effects */
 
    /* The loop body transformers could benefit from pre_n instead of
       transformer_undefined, but who would think of combining these
       two options? */
    (void) statement_to_transformer(s, transformer_undefined);
    tf = effects_to_transformer(e);
  }
 
  ifdebug(8) {
    (void) fprintf(stderr,"%s: %s\n","standard_whileloop_to_transformer",
                   "resultat tf =");
    (void) print_transformer(tf);
  }
  pips_debug(8,"end\n");
  return tf;
}

References condition_false_wrt_precondition_p(), effects_to_transformer(), external_value_name(), fprint_transformer(), fprintf(), free_transformer(), ifdebug, invariant_wrt_transformer(), loop_body_transformer_add_entry_and_iteration_information(), pips_debug, pips_flag_p, precondition_add_condition_information(), predicate_system, print_transformer, sc_append(), SEMANTICS_FIX_POINT, SEMANTICS_INEQUALITY_INVARIANT, statement_to_transformer(), transformer_dup(), transformer_empty(), transformer_empty_p(), transformer_equality_fix_point(), transformer_fix_point_operator, transformer_halbwachs_fix_point(), transformer_identity(), transformer_relation, transformer_undefined, transformer_undefined_p, whileloop_body, and whileloop_condition.

Here is the call graph for this function:

statement_feasible_p()

bool statement_feasible_p

(

statement

s

)

Return true if statement s is reachable according to its precondition.

Definition at line 92 of file utils.c.

{
  bool feasible_p = parametric_statement_feasible_p(s, transformer_empty_p);
  return feasible_p;
}

References parametric_statement_feasible_p(), and transformer_empty_p().

Here is the call graph for this function:

statement_postcondition_undefined_p()

bool statement_postcondition_undefined_p

(

statement

)

statement_precondition_undefined_p()

bool statement_precondition_undefined_p

(

statement

)

statement_semantic_undefined_p()

bool statement_semantic_undefined_p

(

statement

)

statement_strongly_feasible_p()

bool statement_strongly_feasible_p

(

statement

s

)

Return true if statement s is reachable according to its precondition.

Definition at line 99 of file utils.c.

{
  bool feasible_p =
    parametric_statement_feasible_p(s, transformer_strongly_empty_p);
  return feasible_p;
}

References parametric_statement_feasible_p(), and transformer_strongly_empty_p().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_to_postcondition()

transformer statement_to_postcondition	(	transformer	pre,
		statement	s
	)

end of the non recursive section

Refine the precondition pre of s using side effects and compute its postcondition post.

Postcondition post is returned.

FI: if the statement s is a loop, the transformer tf is not the statement transformer but the transformer T* which maps the precondition pre onto the loop body precondition. The real statement transformer is obtained by executing the loop till it is exited. See complete_any_loop_transformer()

ACHTUNG! "pre" is likely to be misused! FI, Sept. 3, 1990

To provide information for warnings

FC: if the code is not reachable (thanks to STOP or GOTO), which is a structural information, the precondition is just empty.

keep only global initial scalar integer values; else, you might end up giving the same xxx::old name to two different local values

FI: OK, to be fixed when the declaration representation is frozen.

add array references information

add type information

Add information from declarations when useful

FI: it might be better to have another function, declarations_to_postconditions(), which might be slightly more accurate? Note that declarations_to_transformer() does compute the postcondition, but free it before returning the transformer

Remove information when leaving a block

add equivalence equalities

eliminate redundancy, rational redundancy but not integer redundancy.

FI: nice... but time consuming!

Version 3 is OK. Equations are over-used and make inequalities uselessly conplex

pre = transformer_normalize(pre, 3);

pre = transformer_normalize(pre, 6);

pre = transformer_normalize(pre, 7);

The double normalization could be avoided with a non-heuristics approach. For ocean, its overhead is 34s out of 782.97 to give 816.62s: 5 %. The double normalization is also useful for some exit conditions of WHILE loops (w05, w06, w07). It is not powerful enough for preconditions containing equations with three or more variables such as fraer01,...

BC: pre = transformer_normalize(pre, 4);

FI->BC: why keep a first normalization before the next one? FI: Because a level 2 normalization does things that a level 4 does not perform! Although level 2 is much faster...

pre = transformer_normalize(pre, 2);

Do not keep too many initial variables in the preconditions: not so smart? invariance01.c: information is lost... Since C passes values, it is usually useless to keep track of the initial values of arguments because programmers usually do not modify them. However, when they do modify the formal parameter, information is lost.

See character01.c, but other counter examples above about non_initial_values.

FI: redundancy possibly added. See asopt02. Maybe this should be moved up before the normalization step.

store the precondition in the ri

pre = statement_precondition(s);

post = instruction_to_postcondition(pre, i, tf);

Parameters

pre	re
s	postcondition of predecessor

Definition at line 712 of file ri_to_preconditions.c.

{
    transformer post = transformer_undefined;
    instruction i = statement_instruction(s);
    /* FI: if the statement s is a loop, the transformer tf is not the
       statement transformer but the transformer T* which maps the
       precondition pre onto the loop body precondition. The real
       statement transformer is obtained by executing the loop till
       it is exited. See complete_any_loop_transformer() */
    transformer tf = load_statement_transformer(s);
 
    /* ACHTUNG! "pre" is likely to be misused! FI, Sept. 3, 1990 */
 
    pips_debug(1,"begin\n");
 
    pips_assert("The statement precondition is defined",
                pre != transformer_undefined);
 
    ifdebug(1) {
        int so = statement_ordering(s);
        (void) fprintf(stderr, "statement %03td (%d,%d), precondition %p:\n",
                       statement_number(s), ORDERING_NUMBER(so),
                       ORDERING_STATEMENT(so), pre);
        (void) print_transformer(pre) ;
    }
 
    pips_assert("The statement transformer is defined",
                tf != transformer_undefined);
    ifdebug(1) {
        int so = statement_ordering(s);
        (void) fprintf(stderr, "statement %03td (%d,%d), transformer %p:\n",
                       statement_number(s), ORDERING_NUMBER(so),
                       ORDERING_STATEMENT(so), tf);
        (void) print_transformer(tf) ;
    }
 
    /* To provide information for warnings */
    push_statement_on_statement_global_stack(s);
 
    if (!statement_reachable_p(s))
    {
        /* FC: if the code is not reachable (thanks to STOP or GOTO), which
         * is a structural information, the precondition is just empty.
         */
      pre = empty_transformer(pre);
    }
 
    if (load_statement_precondition(s) == transformer_undefined) {
        /* keep only global initial scalar integer values;
           else, you might end up giving the same xxx#old name to
           two different local values */
        list non_initial_values =
            arguments_difference(transformer_arguments(pre),
                                 get_module_global_arguments());
        list dl = declaration_statement_p(s) ? statement_declarations(s) : NIL;
 
        /* FI: OK, to be fixed when the declaration representation is
           frozen. */
        if(!ENDP(statement_declarations(s)) && !statement_block_p(s)
           && !declaration_statement_p(s)) {
          // FI: Just to gain some time before dealing with controlizer and declarations updates
          //pips_internal_error("Statement %p carries declarations");
          pips_user_warning("Statement %p with instruction carries declarations\n",
                            instruction_identification(statement_instruction(s)));
        }
 
        MAPL(cv,
         {
           entity v = ENTITY(CAR(cv));
           ENTITY_(CAR(cv)) = entity_to_old_value(v);
         },
             non_initial_values);
 
        /* add array references information */
        if(get_bool_property("SEMANTICS_TRUST_ARRAY_REFERENCES")) {
            precondition_add_reference_information(pre, s);
        }
 
        /* add type information */
        if(get_bool_property("SEMANTICS_USE_TYPE_INFORMATION")
          || get_bool_property("SEMANTICS_USE_TYPE_INFORMATION_IN_PRECONDITIONS")) {
          transformer_add_type_information(pre);
        }
 
        /* Add information from declarations when useful */
        if(declaration_statement_p(s) && !ENDP(dl)) {
          /* FI: it might be better to have another function,
             declarations_to_postconditions(), which might be
             slightly more accurate? Note that
             declarations_to_transformer() does compute the
             postcondition, but free it before returning the transformer */
          transformer dt = declarations_to_transformer(dl, pre);
          transformer dpre = transformer_apply(dt, pre);
 
          //post = instruction_to_postcondition(dpre, i, tf);
          //free_transformer(dpre);
          // FI: Let's assume that declaration statement do not
          //require further analysis
          post = dpre;
        }
        else {
          post = instruction_to_postcondition(pre, i, tf);
        }
 
        /* Remove information when leaving a block */
        if(statement_block_p(s) && !ENDP(statement_declarations(s))) {
          list vl = variables_to_values(statement_declarations(s));
 
          if(!ENDP(vl))
            post = safe_transformer_projection(post, vl);
        }
        else if(statement_loop_p(s)
                && !get_bool_property("SEMANTICS_KEEP_DO_LOOP_EXIT_CONDITION")) {
          loop l = statement_loop(s);
          entity i = loop_index(l);
          list vl = variable_to_values(i);
          post = safe_transformer_projection(post, vl);
        }
 
        /* add equivalence equalities */
        pre = tf_equivalence_equalities_add(pre);
 
        /* eliminate redundancy, rational redundancy but not integer redundancy.  */
 
        /* FI: nice... but time consuming! */
        /* Version 3 is OK. Equations are over-used and make
         * inequalities uselessly conplex
         */
        /* pre = transformer_normalize(pre, 3); */
 
        /* pre = transformer_normalize(pre, 6); */
        /* pre = transformer_normalize(pre, 7); */
 
        /* The double normalization could be avoided with a non-heuristics
           approach. For ocean, its overhead is 34s out of 782.97 to give
           816.62s: 5 %. The double normalization is also useful for some
           exit conditions of WHILE loops (w05, w06, w07). It is not
           powerful enough for preconditions containing equations with
           three or more variables such as fraer01,...*/
 
        if(!transformer_consistency_p(pre)) {
          ;
        }
        /* BC: pre = transformer_normalize(pre, 4); */
        /* FI->BC: why keep a first normalization before the next
           one? FI: Because a level 2 normalization does things that
           a level 4 does not perform! Although level 2 is much
           faster... */
        pre = transformer_normalize(pre, 2);
 
        if(!transformer_consistency_p(pre)) {
          ;
        }
        /* pre = transformer_normalize(pre, 2); */
        if(get_int_property("SEMANTICS_NORMALIZATION_LEVEL_BEFORE_STORAGE")
           == 4)
          // FI HardwareAccelerator/freia_52: this level does not
          // handle the signs properly for simple equations like -i==0
          // and it does not sort constraints lexicographically!
          pre = transformer_normalize(pre, 4);
        else
          pre = transformer_normalize(pre, 2);
 
        if(!transformer_consistency_p(pre)) {
            int so = statement_ordering(s);
            fprintf(stderr, "statement %03td (%d,%d), precondition %p end:\n",
                           statement_number(s), ORDERING_NUMBER(so),
                           ORDERING_STATEMENT(so), pre);
            print_transformer(pre);
            pips_internal_error("Non-consistent precondition after update");
        }
 
        /* Do not keep too many initial variables in the
         * preconditions: not so smart? invariance01.c: information is
         * lost... Since C passes values, it is usually useless to
         * keep track of the initial values of arguments because
         * programmers usually do not modify them. However, when they
         * do modify the formal parameter, information is lost.
         *
         * See character01.c, but other counter examples above about
         * non_initial_values.
         *
         * FI: redundancy possibly added. See asopt02. Maybe this
         * should be moved up before the normalization step.
         */
        if(get_bool_property("SEMANTICS_FILTER_INITIAL_VALUES")) {
          pre = transformer_filter(pre, non_initial_values);
          pre = transformer_normalize(pre, 2);
        }
 
        /* store the precondition in the ri */
        store_statement_precondition(s, pre);
 
        gen_free_list(non_initial_values);
    }
    else {
        pips_debug(8,"precondition already available\n");
        /* pre = statement_precondition(s); */
        (void) print_transformer(pre);
        pips_internal_error("precondition already computed");
    }
 
    /* post = instruction_to_postcondition(pre, i, tf); */
 
    ifdebug(1) {
        int so = statement_ordering(s);
        fprintf(stderr, "statement %03td (%d,%d), precondition %p end:\n",
                statement_number(s), ORDERING_NUMBER(so),
                ORDERING_STATEMENT(so), load_statement_precondition(s));
        print_transformer(load_statement_precondition(s)) ;
    }
 
    ifdebug(1) {
        int so = statement_ordering(s);
        fprintf(stderr, "statement %03td (%d,%d), postcondition %p:\n",
                statement_number(s), ORDERING_NUMBER(so),
                ORDERING_STATEMENT(so), post);
        print_transformer(post) ;
    }
 
    pips_assert("no sharing",post!=pre);
    pop_statement_global_stack();
 
    pips_debug(1, "end\n");
 
    return post;
}

References arguments_difference(), CAR, declaration_statement_p(), declarations_to_transformer(), empty_transformer(), ENDP, ENTITY, ENTITY_, entity_to_old_value(), fprintf(), gen_free_list(), get_bool_property(), get_int_property(), get_module_global_arguments(), ifdebug, instruction_identification(), instruction_to_postcondition(), load_statement_precondition(), load_statement_transformer(), loop_index, MAPL, NIL, ORDERING_NUMBER, ORDERING_STATEMENT, pips_assert, pips_debug, pips_internal_error, pips_user_warning, pop_statement_global_stack(), precondition_add_reference_information(), print_transformer, push_statement_on_statement_global_stack(), safe_transformer_projection(), statement_block_p, statement_declarations, statement_instruction, statement_loop(), statement_loop_p(), statement_number, statement_ordering, statement_reachable_p(), store_statement_precondition(), tf_equivalence_equalities_add(), transformer_add_type_information(), transformer_apply(), transformer_arguments, transformer_consistency_p(), transformer_filter(), transformer_normalize(), transformer_undefined, variable_to_values(), and variables_to_values().

Referenced by any_loop_to_postcondition(), block_to_postcondition(), dag_to_flow_sensitive_preconditions(), loop_to_postcondition(), module_name_to_preconditions(), process_unreachable_node(), test_to_postcondition(), unstructured_to_postcondition(), unstructured_to_postconditions(), whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_to_total_precondition()

transformer statement_to_total_precondition	(	transformer	t_post,
		statement	s
	)

ri_to_total_preconditions.c

ri_to_total_preconditions.c

phasis 3: propagate total preconditions from statement to sub-statement, starting from the module unique return statement. Total preconditions are over-approximation of the theoretical total preconditions, i.e. the conditions that must be met by the store before a statement is executed to reach the end of the module (intra-procedural) or the end of the program (interprocedural). Since over-approximations are computed, the end of the module or of the program cannot be reached if it is not met.

For (simple) interprocedural analysis, this phasis should be performed top-down on the call tree.

Most functions are called xxx_to_total_precondition. They receive a total postcondition as input and use a transformer to convert it into a total precondition.

Total preconditions are NEVER shared. Sharing would introduce desastrous side effects when they are updated as for equivalenced variables and would make freeing them impossible. Thus on a recursive path from statement_to_total_precondition() to itself the precondition must have been reallocated even when its value is not changed as between a block precondition and the first statement of the block precondition. In the same way statement_to_total_precondition() should never returned a total_precondition aliased with its precondition argument. Somewhere in the recursive call down the data structures towards call_to_total_precondition() some allocation must take place even if the statement as no effect on preconditions.

Ambiguity: the type "transformer" is used to abstract statement effects as well as effects combined from the beginning of the module to just before the current statement (precondition) to just after the current statement (total_precondition). This is because it was not realized that preconditions could advantageously be seen as transformers of the initial state when designing the ri. include <stdlib.h>

Preconditions may be useful to deal with tests and loops and to find out if some control paths do not exist

transformer context = transformer_undefined;

If the code is not reachable, thanks to STOP or GOTO, which is a structural information, the total precondition is just empty.

keep only global initial scalar integer values; else, you might end up giving the same xxx::old name to two different local values (?)

add equivalence equalities

t_pre = transformer_normalize(t_pre, 4);

store the total precondition in the ri

Parameters

t_post

_post

Definition at line 355 of file ri_to_total_preconditions.c.

{
  transformer t_pre = transformer_undefined;
  instruction i = statement_instruction(s);
  transformer tf = load_statement_transformer(s);
  /* Preconditions may be useful to deal with tests and loops and to find
     out if some control paths do not exist */
  /* transformer context = transformer_undefined; */
  transformer pre = load_statement_precondition(s);
  transformer context = transformer_range(pre);
 
  pips_debug(1,"begin\n");
 
  pips_assert("The statement total postcondition is defined", t_post != transformer_undefined);
 
  ifdebug(1) {
    _int so = statement_ordering(s);
    (void) fprintf(stderr, "statement %03td (%td,%td), total postcondition %p:\n",
                   statement_number(s), ORDERING_NUMBER(so),
                   ORDERING_STATEMENT(so), t_post);
    (void) print_transformer(t_post) ;
  }
 
  pips_assert("The statement transformer is defined", tf != transformer_undefined);
  ifdebug(1) {
    _int so = statement_ordering(s);
    pips_debug(9,"statement %03td (%td,%td), transformer %p:\n",
               statement_number(s), ORDERING_NUMBER(so),
               ORDERING_STATEMENT(so), tf);
    (void) print_transformer(tf) ;
  }
 
  if (!statement_reachable_p(s))
    {
      /* If the code is not reachable, thanks to STOP or GOTO, which
       * is a structural information, the total precondition is just empty.
       */
 
      t_pre = transformer_empty();
    }
 
  if (load_statement_total_precondition(s) == transformer_undefined) {
    list non_initial_values = list_undefined;
 
    t_pre = instruction_to_total_precondition(t_post, i, tf, context);
 
    /* keep only global initial scalar integer values;
       else, you might end up giving the same xxx#old name to
       two different local values (?) */
    non_initial_values =
      arguments_difference(transformer_arguments(t_pre),
                           get_module_global_arguments());
 
    MAPL(cv,
    {
      entity v = ENTITY(CAR(cv));
      ENTITY_(CAR(cv)) = entity_to_old_value(v);
    },
         non_initial_values);
 
    /* add equivalence equalities */
    t_pre = tf_equivalence_equalities_add(t_pre);
 
/*     t_pre = transformer_normalize(t_pre, 4); */
    t_pre = transformer_normalize(t_pre, 2);
 
    if(!transformer_consistency_p(t_pre)) {
      _int so = statement_ordering(s);
      fprintf(stderr, "statement %03td (%td,%td), precondition %p end:\n",
              statement_number(s), ORDERING_NUMBER(so),
              ORDERING_STATEMENT(so), t_pre);
      print_transformer(t_pre);
      pips_internal_error("Non-consistent precondition after update");
    }
 
    t_pre = transformer_filter(t_pre, non_initial_values);
 
    /* store the total precondition in the ri */
    store_statement_total_precondition(s, t_pre);
 
    gen_free_list(non_initial_values);
  }
  else {
    _int so = statement_ordering(s);
    pips_debug(8, "total precondition already available:\n");
    (void) print_transformer(t_pre);
    pips_debug(8, "for statement %03td (%td,%td), total precondition %p end:\n",
            statement_number(s), ORDERING_NUMBER(so),
            ORDERING_STATEMENT(so), load_statement_total_precondition(s));
    pips_internal_error("total precondition already computed");
  }
 
  ifdebug(1) {
    _int so = statement_ordering(s);
    fprintf(stderr, "statement %03td (%td,%td), total precondition %p end:\n",
            statement_number(s), ORDERING_NUMBER(so),
            ORDERING_STATEMENT(so), load_statement_total_precondition(s));
    print_transformer(load_statement_total_precondition(s)) ;
  }
 
  ifdebug(1) {
    _int so = statement_ordering(s);
    fprintf(stderr, "statement %03td (%td,%td), total_precondition %p:\n",
            statement_number(s), ORDERING_NUMBER(so),
            ORDERING_STATEMENT(so), t_pre);
    print_transformer(t_pre) ;
  }
 
  free_transformer(context);
 
  pips_assert("unexpected sharing",t_post!=t_pre);
 
  pips_debug(1,"end\n");
 
  return t_pre;
}

References arguments_difference(), CAR, ENTITY, ENTITY_, entity_to_old_value(), fprintf(), free_transformer(), gen_free_list(), get_module_global_arguments(), ifdebug, instruction_to_total_precondition(), list_undefined, load_statement_precondition(), load_statement_total_precondition(), load_statement_transformer(), MAPL, ORDERING_NUMBER, ORDERING_STATEMENT, pips_assert, pips_debug, pips_internal_error, print_transformer, statement_instruction, statement_number, statement_ordering, statement_reachable_p(), store_statement_total_precondition(), tf_equivalence_equalities_add(), transformer_arguments, transformer_consistency_p(), transformer_empty(), transformer_filter(), transformer_normalize(), transformer_range(), and transformer_undefined.

Referenced by block_to_total_precondition(), loop_to_total_precondition(), module_name_to_total_preconditions(), test_to_total_precondition(), and unstructured_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_to_transformer()

transformer statement_to_transformer	(	statement	s,
		transformer	spre
	)

stmt precondition

old transformer for s

new transformer for s under spre

nt updated with loop exit information

Transformation REFINE_TRANSFORMERS is being executed: add information available from the statement precondition

it would be nicer to control warning_on_redefinition

FI: OK, we will have to switch to the new declaration representation some day, but the old representation is still fine.

not very smart because declarations_to_transformer() computes post and free it...

add type information

FI: how do we want to handle declarations:

int i = 1; => T() {i==1}

or

int i = 1; => T(i) {i==1}

What is the impact of this choice? BC prefers the second one because it it consistent for convex effect computation.

Note: this issue could be dealt with earlier in declarations_to_transformer()

FI: the code below might be useful again when declarations are carried by any kind of statement

Option 1

Option 2, currently bugged

Currently, the preconditions is useless as only the effects will be used to compute the CONTINUE transformer.

Remove information cancelled by abstract effects

This correction should be moved down in test_to_transformer(), loop_to_transformer() and call_to_transformer() to reduce its impact. See Ticket 792.

add array references information using proper effects

nt = transformer_normalize(nt, 0);

add type information

nt = transformer_normalize(nt, 0);

When we leave a block the local stack allocated variables disappear

Get rid of the dynamic and stack variables declared in this block statement. No stack variable should be analyzed as the stack area is used only for dependent types.

nt = transformer_normalize(nt, 7);

nt = transformer_normalize(nt, 4);

(void) print_transformer(load_statement_transformer(s));

When the statement is virtually replicated via control nodes, the statement transformer is the convex hull of all its replicate transformers.

This implies that transformers are computed in context and that we are dealing with a non-deterministic unstructured with several nodes for a unique statement.

Written abstract locations may require some information destruction

The current implementation is too crude. A new function is needed, abstract_effects_to_transformer(). The current implementation is OK for anywhere effects.

Also, abstract effects should not be applied several times. For instance, a block statement cannot add new effects that have not already been taken into account. A test or a loop only add abstract effects linked to the condition or the loop control. Which leaves us mostly with call statements. Which means that abstract effects should be taken into account at a lower level.

This is mathematically correct but very inefficient (see ticket 644) and useless as long anymodule:anywhere is the only abstract effect we have to deal with.

Not a sufficient solution: free_transformer(t); t = etf;

store or update the statement transformer

delete_statement_transformer(s);

store_statement_transformer(s, t);

The transformer returned for the statement is not always the transformer stored for the statement. This happens for loops and for context sensitive transformers for replicated statements in CFG/unstructured. See comments in loop.c

Parameters

spre

pre

Definition at line 3759 of file ri_to_transformers.c.

{
  instruction i = statement_instruction(s);
  list e = NIL;
  transformer t = transformer_undefined;
  transformer ot = transformer_undefined; /* old transformer for s */
  transformer nt = transformer_undefined; /* new transformer for s under spre */
  transformer te = transformer_undefined; /* nt updated with loop exit information */
  transformer pre = transformer_undefined;
 
  pips_debug(8,"begin for statement %03td (%td,%td) with precondition %p:\n",
             statement_number(s), ORDERING_NUMBER(statement_ordering(s)),
             ORDERING_STATEMENT(statement_ordering(s)), spre);
  ifdebug(8) {
    pips_assert("The statement and its substatements are fully defined",
                all_statements_defined_p(s));
    (void) print_transformer(spre);
  }
 
  pips_assert("spre is a consistent precondition",
              transformer_consistent_p(spre));
 
  if (statement_global_stack_defined_p())
    push_statement_on_statement_global_stack(s);
 
  if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
    pre = transformer_undefined_p(spre)? transformer_identity() :
      transformer_range(spre); // FI: transformer_range() implies
                               // projection(s) and a possibly strong
                               // increase of the number of
                               // constraints. Many constraints may be
                               // redundant as far as integer points
                               // are concerned, but not redundant for
                               // rational numbers. We could use an
                               // approximate projection, elimination
                               // of all constraints containing an old value...
    if(refine_transformers_p) {
      /* Transformation REFINE_TRANSFORMERS is being executed: add
         information available from the statement precondition */
      transformer srpre = load_statement_precondition(s);
      transformer srpre_r = transformer_range(srpre);
 
      pre = transformer_domain_intersection(pre, srpre_r);
      pre = transformer_normalize(pre, 2); // FI: redundancy
                                               // elimination required
      free_transformer(srpre_r);
    }
  }
  else {
    // Avoid lots of test in the callees ot statement_to_transformer
    // pre = transformer_undefined;
    pre = transformer_identity();
  }
 
  pips_assert("pre is a consistent precondition",
              transformer_consistent_p(pre));
 
  pips_debug(8,"Range precondition pre:\n");
  ifdebug(8) {
    (void) print_transformer(pre);
  }
 
  e = load_cumulated_rw_effects_list(s);
  ot = load_statement_transformer(s);
 
  /* it would be nicer to control warning_on_redefinition */
  if (transformer_undefined_p(ot)
      || get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
    //list dl = declaration_statement_p(s) ? statement_declarations(s) : NIL;
    list dl = declaration_statement_p(s) ? statement_declarations(s) : NIL;
 
    /* FI: OK, we will have to switch to the new declaration
       representation some day, but the old representation is still
       fine.*/
    if(!ENDP(statement_declarations(s)) && !statement_block_p(s)
       && !declaration_statement_p(s)) {
      // FI: Just to gain some time before dealing with controlizer and declarations updates
      //pips_internal_error("Statement %p carries declarations");
      semantics_user_warning("Statement %d (%p) carries declarations\n",
                             statement_number(s), s);
    }
 
    if(!ENDP(dl)) {
      transformer dt = declarations_to_transformer(dl, pre);
      /* not very smart because declarations_to_transformer() computes post and free it...*/
      transformer post = transformer_apply(dt, pre);
      transformer ipre = transformer_range(post);
      transformer it = transformer_undefined;
 
      // FI: this should not be duplicated. Temporary fix for modulo07.c
      /* add type information */
      /*
      if(get_bool_property("SEMANTICS_USE_TYPE_INFORMATION")) {
        transformer_add_type_information(nt);
      }
      */
 
      ifdebug(8) {
        pips_debug(8, "Statement local preconditions due to declarations:");
        print_transformer(ipre);
      }
 
      /* FI: how do we want to handle declarations:
      *
      * int i = 1; => T() {i==1}
      *
      * or
      *
      * int i = 1; => T(i) {i==1}
      *
      * What is the impact of this choice? BC prefers the second one
      * because it it consistent for convex effect computation.
      *
      * Note: this issue could be dealt with earlier in
      * declarations_to_transformer()
      */
      /* FI: the code below might be useful again when declarations
         are carried by any kind of statement */
      //it = instruction_to_transformer(i, ipre, e);
      //nt = transformer_combine(dt, it);
      //free_transformer(it);
      if(false) {
        /* Option 1 */
        nt = dt;
      }
      else if(false) {
        /* Option 2, currently bugged */
        /* Currently, the preconditions is useless as only the
           effects will be used to compute the CONTINUE transformer. */
        it = instruction_to_transformer(i, pre, e);
        nt = transformer_image_intersection(it, dt);
        free_transformer(it);
        free_transformer(dt);
      }
      else {
        nt = dt; // Do nothing because everything has been taken care of by
          // declaration_to_transformer()
      }
      free_transformer(post);
      // free_transformer(ipre);
    }
    else {
      nt = instruction_to_transformer(i, pre, e);
    }
 
    /* Remove information cancelled by abstract effects */
    /* This correction should be moved down in test_to_transformer(),
       loop_to_transformer() and call_to_transformer() to reduce its
       impact. See Ticket 792. */
    if(effects_abstract_location_p(e) && !statement_block_p(s)) {
       nt = apply_abstract_effects_to_transformer(nt, e);
    }
 
    /* add array references information using proper effects */
    if(get_bool_property("SEMANTICS_TRUST_ARRAY_REFERENCES")) {
      transformer_add_reference_information(nt, s);
      /* nt = transformer_normalize(nt, 0); */
    }
 
    /* add type information */
    if(get_bool_property("SEMANTICS_USE_TYPE_INFORMATION")
      || get_bool_property("SEMANTICS_USE_TYPE_INFORMATION_IN_TRANSFORMERS")) {
      transformer_add_type_information(nt);
      /* nt = transformer_normalize(nt, 0); */
    }
 
    /* When we leave a block the local stack allocated variables
       disappear */
    if(statement_block_p(s) && !ENDP(dl=statement_declarations(s))) {
      /* Get rid of the dynamic and stack variables declared in this block
         statement. No stack variable should be analyzed as the stack
         area is used only for dependent types. */
      bool location_p = get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH");
      if(location_p) {
        // This is a general case that should always work
        // The complexity is controlled by the length of the transformer basis
        list vl = transformer_to_local_values(nt, dl);
        if(!ENDP(vl))
          nt = safe_transformer_projection(nt, vl);
      }
      else { // The complexity is controlled by the length of dl
        list vl = dynamic_variables_to_values(dl);
        if(!ENDP(vl))
          nt = safe_transformer_projection(nt, vl);
      }
    }
    /* nt = transformer_normalize(nt, 7); */
    /* nt = transformer_normalize(nt, 4); */
    nt = transformer_normalize(nt, 2);
 
    if(!transformer_consistency_p(nt)) {
      _int so = statement_ordering(s);
      (void) fprintf(stderr, "statement %03td (%td,%td):\n",
                     statement_number(s),
                     ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
      /* (void) print_transformer(load_statement_transformer(s)); */
      (void) print_transformer(nt);
      dump_transformer(nt);
      pips_internal_error("Inconsistent transformer detected");
    }
    ifdebug(1) {
      pips_assert("Transformer is internally consistent",
                  transformer_internal_consistency_p(nt));
    }
 
    /* When the statement is virtually replicated via control nodes, the
       statement transformer is the convex hull of all its replicate
       transformers. */
    if(transformer_undefined_p(ot)) {
      if (get_int_property("SEMANTICS_NORMALIZATION_LEVEL_BEFORE_STORAGE") == 4)
        nt = transformer_normalize(nt, 4);
      t = copy_transformer(nt);
    }
    else {
      /* This implies that transformers are computed in context and that
         we are dealing with a non-deterministic unstructured with several
         nodes for a unique statement. */
      t = transformer_convex_hull(nt, ot);
 
      ifdebug(1) {
        pips_assert("transformers are computed in context",
                    get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"));
        pips_debug(1, "Convex hull for transformer of statement  %03td (%td,%td)\n",
                   statement_number(s), ORDERING_NUMBER(statement_ordering(s)), 
                   ORDERING_STATEMENT(statement_ordering(s)));
        pips_debug(1, "Previous transformer:\n");
        (void) print_transformer(ot);
        pips_debug(1, "New transformer:\n");
        (void) print_transformer(nt);
        pips_debug(1, "Resulting transformer:\n");
        (void) print_transformer(t);
      }
    }
  
    /* Written abstract locations may require some information destruction 
   *
   * The current implementation is too crude. A new function is
   * needed, abstract_effects_to_transformer(). The current
   * implementation is OK for anywhere effects.
   *
   * Also, abstract effects should not be applied several times. For
   * instance, a block statement cannot add new effects that have not
   * already been taken into account. A test or a loop only add
   * abstract effects linked to the condition or the loop
   * control. Which leaves us mostly with call statements. Which means
   * that abstract effects should be taken into account at a lower
   * level.
   */
 
    //if(effects_abstract_location_p(e) && !statement_block_p(s)) {
      // FI: it would be better to use directly
      // apply_effects_to_transformer() and maybe legal to use
      // apply_additional_effects_to_transformer().  FI: it might be
      // safer to define apply_abstract_effects_to_transformer() as
      // suggested above.
      //transformer etf = effects_to_transformer(e);
      /* This is mathematically correct but very inefficient (see ticket
         644) and useless as long *anymodule*:*anywhere* is the only
         abstract effect we have to deal with.
      */
      //t = transformer_combine(t, etf);
      //nt = transformer_combine(nt, etf);
      //free_transformer(etf);
      //t = apply_abstract_effects_to_transformer(t, e);
      //nt = apply_abstract_effects_to_transformer(nt, e);
      /* Not a sufficient solution:
         free_transformer(t);
         t = etf;
      */
      //}
 
    /* store or update the statement transformer */
    if(transformer_undefined_p(ot)) {
      store_statement_transformer(s, t);
    }
    else {
      transformer_free(ot);
       update_statement_transformer(s, t);
      /* delete_statement_transformer(s); */
      /* store_statement_transformer(s, t); */
    }
  }
  else {
    semantics_user_warning("redefinition for statement %03d (%d,%d)\n",
                 statement_number(s), ORDERING_NUMBER(statement_ordering(s)), 
                 ORDERING_STATEMENT(statement_ordering(s)));
    pips_internal_error("transformer redefinition");
  }
 
  ifdebug(1) {
    _int so = statement_ordering(s);
    transformer stf = load_statement_transformer(s);
 
    (void) fprintf(stderr, "statement %03td (%td,%td), transformer %p:\n",
                   statement_number(s),
                   ORDERING_NUMBER(so), ORDERING_STATEMENT(so),
                   stf);
    (void) print_transformer(stf);
    pips_assert("same pointer", stf==t);
  }
 
  /* The transformer returned for the statement is not always the
     transformer stored for the statement. This happens for loops and for
     context sensitive transformers for replicated statements in
     CFG/unstructured. See comments in loop.c */
 
  te = complete_statement_transformer(nt, pre, s);
 
  free_transformer(pre);
 
  ifdebug(8) {
    pips_assert("The statement and its substatements are still fully defined",
                all_statements_defined_p(s));
  }
 
  pips_debug(8,"end for statement %03td (%td,%td) with t=%p, nt=%p and te=%p\n",
             statement_number(s), ORDERING_NUMBER(statement_ordering(s)), 
             ORDERING_STATEMENT(statement_ordering(s)), t, nt, te);
 
  if (statement_global_stack_defined_p())
    (void) pop_statement_global_stack();
 
  return te;
}

References all_statements_defined_p(), apply_abstract_effects_to_transformer(), complete_statement_transformer(), copy_transformer(), declaration_statement_p(), declarations_to_transformer(), dump_transformer, dynamic_variables_to_values(), effects_abstract_location_p(), ENDP, fprintf(), free_transformer(), get_bool_property(), get_int_property(), ifdebug, instruction_to_transformer(), load_cumulated_rw_effects_list(), load_statement_precondition(), load_statement_transformer(), NIL, ORDERING_NUMBER, ORDERING_STATEMENT, pips_assert, pips_debug, pips_internal_error, pop_statement_global_stack(), print_transformer, push_statement_on_statement_global_stack(), refine_transformers_p, safe_transformer_projection(), semantics_user_warning, statement_block_p, statement_declarations, statement_global_stack_defined_p(), statement_instruction, statement_number, statement_ordering, stf(), store_statement_transformer(), transformer_add_reference_information(), transformer_add_type_information(), transformer_apply(), transformer_consistency_p(), transformer_consistent_p(), transformer_convex_hull(), transformer_domain_intersection(), transformer_free(), transformer_identity(), transformer_image_intersection(), transformer_internal_consistency_p(), transformer_normalize(), transformer_range(), transformer_to_local_values(), transformer_undefined, transformer_undefined_p, and update_statement_transformer().

Referenced by any_loop_to_k_transformer(), block_to_transformer(), dag_or_cycle_to_flow_sensitive_postconditions_or_transformers(), generic_module_name_to_transformers(), loop_to_transformer(), process_ready_node(), process_unreachable_node(), standard_whileloop_to_transformer(), test_to_transformer(), test_to_transformer_list(), unreachable_node_to_transformer(), and unstructured_to_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_to_transformer_list()

list statement_to_transformer_list	(	statement	s,
		transformer	spre
	)

A transformer is already available for statement s, but it is going to be refined into a list of transformers to isolate at least the identity transformer from effective transformers.

stmt precondition

Transformation REFINE_TRANSFORMERS is being executed: add information available from the statement precondition

it would be nicer to control warning_on_redefinition

FI: an empty tl means that s does not return. An undefined tl means that instruction_to_transformer() is not implemented in a satisfactory way. So the existing transformer is used by default.

add array references information using proper effects

nt = transformer_normalize(nt, 0);

When we leave a block the local stack allocated variables disappear

Get rid of the dynamic and stack variables declared in this block statement. No stack variable should be analyzed as the stack area is used only for dependent types.

nt = transformer_normalize(nt, 7);

nt = transformer_normalize(nt, 4);

(void) print_transformer(load_statement_transformer(s));

The transformer returned for the statement is not always the transformer stored for the statement. This happens for loops and for context sensitive transformers for replicated statements in CFG/unstructured. See comments in loop.c

Parameters

spre

pre

Definition at line 978 of file ri_to_transformer_lists.c.

{
  transformer tf = load_statement_transformer(s);
  instruction i = statement_instruction(s);
  list tl = NIL;
  list e = NIL;
  //transformer t = transformer_undefined;
  //transformer ot = transformer_undefined; /* old transformer for s */
  //transformer nt = transformer_undefined; /* new transformer for s under spre */
  //transformer te = transformer_undefined; /* nt updated with loop exit information */
  transformer pre = transformer_undefined;
 
  pips_debug(8,"begin for statement %03td (%td,%td) with precondition %p:\n",
             statement_number(s), ORDERING_NUMBER(statement_ordering(s)),
             ORDERING_STATEMENT(statement_ordering(s)), spre);
  ifdebug(8) {
    pips_assert("The statement and its substatements are fully defined",
                all_statements_defined_p(s));
    (void) print_transformer(spre);
  }
 
  pips_assert("spre is a consistent precondition",
              transformer_consistent_p(spre));
 
  if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
    pre = transformer_undefined_p(spre)? transformer_identity() :
      transformer_range(spre);
    if(refine_transformers_p) {
      /* Transformation REFINE_TRANSFORMERS is being executed: add
         information available from the statement precondition */
      transformer srpre = load_statement_precondition(s);
      transformer srpre_r = transformer_range(srpre);
 
      pre = transformer_domain_intersection(pre, srpre_r);
      free_transformer(srpre_r);
    }
  }
  else {
    // Avoid lots of test in the callees
    // pre = transformer_undefined;
    pre = transformer_identity();
  }
 
  pips_assert("pre is a consistent precondition",
              transformer_consistent_p(pre));
 
  pips_debug(8,"Range precondition pre:\n");
  ifdebug(8) {
    (void) print_transformer(pre);
  }
 
  // Probably not useful
  e = load_cumulated_rw_effects_list(s);
 
  /* it would be nicer to control warning_on_redefinition */
  if (true) {
    list dl = declaration_statement_p(s) ? statement_declarations(s) : NIL;
 
    if(!ENDP(dl)) {
      transformer dt = declarations_to_transformer(dl, pre);
      tl = CONS(TRANSFORMER, dt, NIL);
    }
    else {
      tl = instruction_to_transformer_list(i, tf, pre, e);
      /* FI: an empty tl means that s does not return. An undefined
         tl means that instruction_to_transformer() is not
         implemented in a satisfactory way. So the existing
         transformer is used by default. */
      if(list_undefined_p(tl)) {
        transformer tf = load_statement_transformer(s);
        tl = CONS(TRANSFORMER, copy_transformer(tf), NIL);
      }
    }
 
    FOREACH(TRANSFORMER, nt, tl) {
      /* add array references information using proper effects */
      if(get_bool_property("SEMANTICS_TRUST_ARRAY_REFERENCES")) {
        transformer_add_reference_information(nt, s);
        /* nt = transformer_normalize(nt, 0); */
      }
 
      /* When we leave a block the local stack allocated variables
         disappear */
      if(statement_block_p(s) && !ENDP(dl=statement_declarations(s))) {
        /* Get rid of the dynamic and stack variables declared in this block
           statement. No stack variable should be analyzed as the stack
           area is used only for dependent types. */
        list vl = dynamic_variables_to_values(dl);
        if(!ENDP(vl))
          nt = safe_transformer_projection(nt, vl);
      }
      /* nt = transformer_normalize(nt, 7); */
      /*     nt = transformer_normalize(nt, 4); */
      nt = transformer_normalize(nt, 2);
 
      if(!transformer_consistency_p(nt)) {
        _int so = statement_ordering(s);
        (void) fprintf(stderr, "statement %03td (%td,%td):\n",
                       statement_number(s),
                       ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
        /* (void) print_transformer(load_statement_transformer(s)); */
        (void) print_transformer(nt);
        dump_transformer(nt);
        pips_internal_error("Inconsistent transformer detected");
      }
      ifdebug(1) {
        pips_assert("Transformer is internally consistent",
                    transformer_internal_consistency_p(nt));
      }
    }
 
#if 0
    /* When the statement is virtually replicated via control nodes, the
       statement transformer is the convex hull of all its replicate
       transformers. */
    if(transformer_undefined_p(ot)) {
      if (get_int_property("SEMANTICS_NORMALIZATION_LEVEL_BEFORE_STORAGE") == 4)
        nt = transformer_normalize(nt, 4);
      t = copy_transformer(nt);
    }
    else {
      /* This implies that transformers are computed in context and that
         we are dealing with a non-deterministic unstructured with several
         nodes for a unique statement. */
      t = transformer_convex_hull(nt, ot);
 
      ifdebug(1) {
        pips_assert("transformers are computed in context",
                    get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT"));
        pips_debug(1, "Convex hull for transformer of statement  %03td (%td,%td)\n",
                   statement_number(s), ORDERING_NUMBER(statement_ordering(s)),
                   ORDERING_STATEMENT(statement_ordering(s)));
        pips_debug(1, "Previous transformer:\n");
        (void) print_transformer(ot);
        pips_debug(1, "New transformer:\n");
        (void) print_transformer(nt);
        pips_debug(1, "Resulting transformer:\n");
        (void) print_transformer(t);
      }
    }
 
    /* store or update the statement transformer */
    if(transformer_undefined_p(ot)) {
      store_statement_transformer(s, t);
    }
    else {
      transformer_free(ot);
      update_statement_transformer(s, t);
      /* delete_statement_transformer(s); */
      /* store_statement_transformer(s, t); */
    }
#endif
  }
  else {
    semantics_user_warning("redefinition for statement %03d (%d,%d)\n",
                      statement_number(s),
                      ORDERING_NUMBER(statement_ordering(s)),
                      ORDERING_STATEMENT(statement_ordering(s)));
    pips_internal_error("transformer redefinition");
  }
 
  /* The transformer returned for the statement is not always the
     transformer stored for the statement. This happens for loops and for
     context sensitive transformers for replicated statements in
     CFG/unstructured. See comments in loop.c */
 
  // FI: Should not be useful for transformer lists? Why?
  // te = complete_statement_transformer(nt, pre, s);
 
  free_transformer(pre);
 
  ifdebug(8) {
    pips_assert("The statement and its substatements are still fully defined",
                all_statements_defined_p(s));
  }
 
  //pips_debug(8,"end for statement %03td (%td,%td) with t=%p, nt=%p and te=%p\n",
  //     statement_number(s), ORDERING_NUMBER(statement_ordering(s)),
  //     ORDERING_STATEMENT(statement_ordering(s)), t, nt, te);
 
  ifdebug(1) {
    pips_debug(1, "Transformer list has %zd elements:\n", gen_length(tl));
    print_transformers(tl);
  }
 
  return tl;
}

References all_statements_defined_p(), CONS, copy_transformer(), declaration_statement_p(), declarations_to_transformer(), dump_transformer, dynamic_variables_to_values(), ENDP, FOREACH, fprintf(), free_transformer(), gen_length(), get_bool_property(), get_int_property(), ifdebug, instruction_to_transformer_list(), list_undefined_p, load_cumulated_rw_effects_list(), load_statement_precondition(), load_statement_transformer(), NIL, ORDERING_NUMBER, ORDERING_STATEMENT, pips_assert, pips_debug, pips_internal_error, print_transformer, print_transformers(), refine_transformers_p, safe_transformer_projection(), semantics_user_warning, statement_block_p, statement_declarations, statement_instruction, statement_number, statement_ordering, store_statement_transformer(), TRANSFORMER, transformer_add_reference_information(), transformer_consistency_p(), transformer_consistent_p(), transformer_convex_hull(), transformer_domain_intersection(), transformer_free(), transformer_identity(), transformer_internal_consistency_p(), transformer_normalize(), transformer_range(), transformer_undefined, transformer_undefined_p, and update_statement_transformer().

Referenced by block_to_transformer_list(), test_to_transformer_list(), and whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_total_precondition_undefined_p()

bool statement_total_precondition_undefined_p

(

statement

)

statement_transformer_undefined_p()

bool statement_transformer_undefined_p

(

statement

)

statement_weakly_feasible_p()

bool statement_weakly_feasible_p

(

statement

s

)

utils.c

utils.c

bool feasible_p = !transformer_empty_p(pre);

FI: this test is much stronger than I intended. I just wanted to check that the predicate of pre was exactly sc_empty()!

Now I'm afraid to change it. suppress_dead_code isn't that slow on ocean. I'm not sure that I could validate Transformations.

Definition at line 72 of file utils.c.

{
  transformer pre = load_statement_precondition(s);
  /* bool feasible_p = !transformer_empty_p(pre); */
 
  /* FI: this test is much stronger than I intended. I just wanted
   * to check that the predicate of pre was exactly sc_empty()!
   *
   * Now I'm afraid to change it. suppress_dead_code isn't that slow
   * on ocean. I'm not sure that I could validate Transformations.
   */
 
  Psysteme sc = predicate_system(transformer_relation(pre));
 
  bool feasible_p = !sc_empty_p(sc);
 
  return feasible_p;
}

References load_statement_precondition(), predicate_system, sc_empty_p(), and transformer_relation.

Referenced by interprocedural_abc_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

store_statement_postcondition()

void store_statement_postcondition	(	statement	,
		transformer
	)

store_statement_precondition()

void store_statement_precondition	(	statement	,
		transformer
	)

Referenced by statement_to_postcondition().

Here is the caller graph for this function:

store_statement_semantic()

void store_statement_semantic	(	statement	,
		transformer
	)

store_statement_total_precondition()

void store_statement_total_precondition	(	statement	,
		transformer
	)

Referenced by statement_to_total_precondition().

Here is the caller graph for this function:

store_statement_transformer()

void store_statement_transformer	(	statement	,
		transformer
	)

Referenced by statement_to_transformer(), and statement_to_transformer_list().

Here is the caller graph for this function:

string_expression_to_transformer()

transformer string_expression_to_transformer	(	entity	v,
		expression	rhs
	)

tf = constant_to_transformer(v, call_function(syntax_call(srhs)));

Parameters

rhs

hs

Definition at line 3994 of file expression.c.

{
  transformer tf = transformer_undefined;
  syntax srhs = expression_syntax(rhs);
 
  switch(syntax_tag(srhs)) {
  case is_syntax_call:
    switch(gen_length(call_arguments(syntax_call(srhs)))) {
    case 0:
      /* tf = constant_to_transformer(v, call_function(syntax_call(srhs))); */
      tf = constant_to_transformer(v, rhs);
      break;
    case 1:
      break;
    case 2:
      break;
    case 3:
      break;
    default:
      pips_internal_error("Too many arguments, %d, for operator %s",
                          gen_length(call_arguments(syntax_call(srhs))),
                          entity_name(call_function(syntax_call(srhs))));
    }
    break;
  case is_syntax_reference:
    {
      entity r = reference_variable(syntax_reference(srhs));
 
      if(entity_has_values_p(r)) {
        basic bv = variable_basic(type_variable(entity_type(v)));
        basic br = variable_basic(type_variable(entity_type(r)));
 
        if(basic_string_p(bv) && basic_string_p(br)) {
          int llhs = string_type_size(bv);
          int lrhs = string_type_size(br);
 
          if(llhs == -1 || llhs >= lrhs) {
            entity r_new = entity_to_new_value(r);
            tf =  simple_equality_to_transformer(v, r_new, false);
          }
        }
        else {
          pips_user_error("Incompatible type in CHARACTER assignment: %s\n",
                          basic_to_string(br));
        }
      }
    break;
    }
  case is_syntax_range:
    pips_internal_error("Unexpected tag %d", syntax_tag(srhs));
    break;
  default:
    pips_internal_error("Illegal tag %d", syntax_tag(srhs));
  }
 
  return tf;
}

References basic_string_p, basic_to_string(), call_arguments, call_function, constant_to_transformer(), entity_has_values_p(), entity_name, entity_to_new_value(), entity_type, expression_syntax, gen_length(), is_syntax_call, is_syntax_range, is_syntax_reference, pips_internal_error, pips_user_error, reference_variable, simple_equality_to_transformer(), string_type_size(), syntax_call, syntax_reference, syntax_tag, transformer_undefined, type_variable, and variable_basic.

Referenced by any_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

string_predicate_to_commentary()

text string_predicate_to_commentary	(	string	str_pred,
		string	comment_prefix
	)

text string_predicate_to_commentary(string str_pred, string comment_prefix) input : a string, part of which represents a predicate.

output : a text consisting of several lines of commentaries, containing the string str_pred, and beginning with comment_prefix. modifies : str_pred;

if str_pred is too long, it must be splitted in several lines; the hyphenation must be done only between the constraints of the predicate, when there is a "," or a ")". A space is added at the beginning of extra lines, for indentation.

search the maximal substring which length is less than longueur_max

add it to the text

if the remaining string fits in one line

Parameters

str_pred	tr_pred
comment_prefix	omment_prefix

Definition at line 570 of file prettyprint.c.

{
  text t_pred = make_text(NIL);
  string str_suiv = NULL;
  string str_prefix = comment_prefix;
  char str_tmp[MAX_PRED_COMMENTARY_STRLEN];
  int len, new_str_pred_len, longueur_max;
  bool premiere_ligne = true;
  bool foresys = get_bool_property("PRETTYPRINT_FOR_FORESYS");
  longueur_max = MAX_PRED_COMMENTARY_STRLEN - strlen(str_prefix) - 2;
 
  /* if str_pred is too long, it must be splitted in several lines;
   * the hyphenation must be done only between the constraints of the
   * predicate, when there is a "," or a ")". A space is added at the beginning
   * of extra lines, for indentation. */
  while((len = strlen(str_pred)) > 0) {
    if (len > longueur_max) {
 
      /* search the maximal substring which length
       * is less than longueur_max */
      str_tmp[0] = '\0';
      (void) strncat(str_tmp, str_pred, longueur_max);
 
      if (foresys)
        str_suiv = strrchr(str_tmp, ')');
      else
        str_suiv = strrchr(str_tmp, ',');
 
      new_str_pred_len = (strlen(str_tmp) - strlen(str_suiv)) + 1;
      str_suiv = strdup(&(str_pred[new_str_pred_len]));
 
      str_tmp[0] = '\0';
      if (!premiere_ligne)
        (void) strcat(str_tmp, " ");
      (void) strncat(str_tmp, str_pred, new_str_pred_len);
 
      /* add it to the text */
      ADD_SENTENCE_TO_TEXT(t_pred,
                           make_pred_commentary_sentence(strdup(str_tmp),
                                                         str_prefix));
      str_pred =  str_suiv;
    }
    else {
      /* if the remaining string fits in one line */
      str_tmp[0] = '\0';
      if (!premiere_ligne)
        (void) strcat(str_tmp, " ");
      (void) strcat(str_tmp, str_pred);
 
      ADD_SENTENCE_TO_TEXT(t_pred,
                           make_pred_commentary_sentence(str_tmp,
                                                         str_prefix));
      str_pred[0] = '\0';
    }
 
    if (premiere_ligne) {
      premiere_ligne = false;
      longueur_max = longueur_max - 1;
      if (foresys){
        int i;
        int nb_espaces = strlen(str_prefix) -
          strlen(FORESYS_CONTINUATION_PREFIX);
 
        str_prefix = strdup(str_prefix);
        str_prefix[0] = '\0';
        (void) strcat(str_prefix, FORESYS_CONTINUATION_PREFIX);
        for (i=1; i <= nb_espaces; i++)
          (void) strcat(str_prefix, " ");
      }
    }
  }
 
  return(t_pred);
}

References ADD_SENTENCE_TO_TEXT, FORESYS_CONTINUATION_PREFIX, get_bool_property(), make_pred_commentary_sentence(), make_text(), MAX_PRED_COMMENTARY_STRLEN, NIL, and strdup().

Referenced by words_predicate_to_commentary().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_reference_assignment_to_transformer()

transformer struct_reference_assignment_to_transformer	(	reference	r,
		type	t,
		expression	rhs,
		transformer	pre,
		list	ef
	)

Parameters

rhs	hs
pre	re
ef	f

Definition at line 3078 of file ri_to_transformers.c.

{
  return struct_reference_assignment_or_equality_to_transformer(r, t, rhs, pre, ef, true);
}

References struct_reference_assignment_or_equality_to_transformer().

Referenced by assign_rhs_to_reflhs_to_transformer(), and struct_variable_assignment_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_reference_equality_to_transformer()

transformer struct_reference_equality_to_transformer	(	reference	r,
		type	t,
		expression	rhs,
		transformer	pre,
		list	ef
	)

Parameters

rhs	hs
pre	re
ef	f

Definition at line 3083 of file ri_to_transformers.c.

{
  return struct_reference_assignment_or_equality_to_transformer(r, t, rhs, pre, ef, false);
}

References struct_reference_assignment_or_equality_to_transformer().

Referenced by struct_variable_equality_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_variable_assignment_to_transformer()

transformer struct_variable_assignment_to_transformer	(	entity	v,
		type	t,
		expression	rhs,
		transformer	pre,
		list	ef
	)

Parameters

v	assigned struct variable (does not handle the general case, "e1==e2;" where e1 and e2 are lhs expressions
t	type of v, which much be matched by rhs expression type and which must not contain any named type
rhs	right-hand side expression
ef	list of effects
pre	precondition of the assignment

Returns

a transformer that must be defined as some field assignments may be analyzable whereas others just generate side-effects

Parameters

rhs	hs
pre	re
ef	f

Definition at line 3100 of file ri_to_transformers.c.

{
  reference r = make_reference(v, NIL);
  transformer tf = struct_reference_assignment_to_transformer(r, t, rhs, pre, ef);
  free_reference(r);
  return tf;
}

References free_reference(), make_reference(), NIL, and struct_reference_assignment_to_transformer().

Referenced by assign_rhs_to_reflhs_to_transformer(), and c_return_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_variable_equality_to_transformer()

transformer struct_variable_equality_to_transformer	(	entity	v,
		type	t,
		expression	rhs,
		transformer	pre,
		list	ef
	)

Parameters

rhs	hs
pre	re
ef	f

Definition at line 3108 of file ri_to_transformers.c.

{
  reference r = make_reference(v, NIL);
  transformer tf = struct_reference_equality_to_transformer(r, t, rhs, pre, ef);
  free_reference(r);
  return tf;
}

References free_reference(), make_reference(), NIL, and struct_reference_equality_to_transformer().

Referenced by any_user_call_site_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_formal_array_elements_in_precondition()

transformer substitute_formal_array_elements_in_precondition	(	transformer	tf,
		entity	f,
		list	pc,
		transformer	pre,
		list	ef
	)

Parameters

tf	f
pc	c
pre	re
ef	f

Definition at line 2014 of file ri_to_transformers.c.

{
  return generic_substitute_formal_array_elements_in_transformer(tf, f, pc, pre, ef, false);
}

References f(), and generic_substitute_formal_array_elements_in_transformer().

Referenced by process_call_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_formal_array_elements_in_transformer()

transformer substitute_formal_array_elements_in_transformer	(	transformer	tf,
		entity	f,
		list	pc,
		transformer	pre,
		list	ef
	)

Parameters

tf	f
pc	c
pre	re
ef	f

Definition at line 2009 of file ri_to_transformers.c.

{
  return generic_substitute_formal_array_elements_in_transformer(tf, f, pc, pre, ef, true);
}

References f(), and generic_substitute_formal_array_elements_in_transformer().

Referenced by c_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_scalar_stub_in_transformer()

transformer substitute_scalar_stub_in_transformer	(	transformer	tf,
		entity	se,
		entity	de,
		bool	backward_p,
		list *	ppl
	)

If both "se", source entity, and "de", destination entity, are defined, substitute the values of "se" by the values of "de" in "backward_p" mode, when translating a callee transformer at a call site of a caller.

If the "se" entity cannot be substituted, its value must be project.

Parameters

tf	f
se	e
de	e
backward_p	ackward_p
ppl	pl

Definition at line 136 of file points_to.c.

{
  if(entity_undefined_p(se))
    ;
  else if(entity_undefined_p(de))
    *ppl = CONS(ENTITY, se, *ppl);
  else if(entity_has_values_p(de)) {
    // Not in the caller's frame
    // entity nsv = entity_to_new_value(se);
    entity nsv = se;
    entity ndv = entity_to_new_value(de);
    if(backward_p) { // For transformers
      tf = transformer_value_substitute(tf, nsv, ndv);
    }
    else { // For preconditions
      tf = transformer_value_substitute(tf, ndv, nsv);
    }
    // Careful, se has been substituted in the argument too
    if(entity_is_argument_p(de, transformer_arguments(tf))) {
      entity osv = global_new_value_to_global_old_value(nsv);
      entity odv = entity_to_old_value(de);
      if(backward_p) { // For transformers
        tf = transformer_value_substitute(tf, osv, odv);
      }
      else { // For preconditions
        tf = transformer_value_substitute(tf, odv, osv);
      }
    }
  }
  else {
    // FI: could be some debugging stuff
    pips_user_warning("Stub \"%s\" cannot be substituted.\n",
                      entity_user_name(de));
    // FI: entity "de" must be projected
    *ppl = CONS(ENTITY, se, *ppl);
  }
  return tf;
}

References CONS, ENTITY, entity_has_values_p(), entity_is_argument_p(), entity_to_new_value(), entity_to_old_value(), entity_undefined_p, entity_user_name(), global_new_value_to_global_old_value(), pips_user_warning, transformer_arguments, and transformer_value_substitute().

Referenced by forward_substitute_array_location_in_transformer(), new_array_element_backward_substitution_in_transformer(), substitute_struct_stub_in_transformer(), and substitute_stubs_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_struct_stub_in_transformer()

transformer substitute_struct_stub_in_transformer	(	transformer	,
		reference	,
		type	,
		reference	,
		type	,
		bool	,
		list *
	)

substitute_stubs_in_transformer()

transformer substitute_stubs_in_transformer	(	transformer	tf,
		call	c,
		statement	s,
		bool	backward_p
	)

Exploit the binding map to substitute calles's stubs by actual arguments, which may be stubs of the callers,.

backward_p request a substitution from the callees' frame into the caller's frame, which is useful for transformers. Flag backward_p is set to false to compute summary preconditions.

FI: this function is now only used for preconditions. It has been rewritten for transformers to speed up the process when array elements are involved. It is better to start from the needs, the stubs used in the transformer, than from all possible stubs, but it is much easier for a backward translation. With a forward translation, regular variables may have to be translated into stubs.

FI: A quick improvement would to return when no translation is needed... but you do not always know it when backward_p is set to false.

Parameters

tf	f
backward_p	ackward_p

Definition at line 256 of file points_to.c.

{
  entity m = get_current_module_entity();
  list ll = backward_p? transformer_to_analyzed_locations(tf)
    : transformer_to_potential_stub_translation(tf, m);
  if(ENDP(ll)) {
    // Return tf as is
    ;
  }
  else if(pt_to_list_undefined_p()) {
    // Return tf as is
  }
  else {
    points_to_graph ptg = get_points_to_graph_from_statement(s);
    bool bottom_p = points_to_graph_bottom(ptg);
 
    if(bottom_p) {
      // FI: should this lead to an empty transformer?
      pips_internal_error("Not implemented yet.\n");
    }
    else {
      set binding = user_call_to_points_to_interprocedural_binding_set(c, ptg);
      list pl = NIL; // FI: I am not sure we can managed forward and
                     // backward projections with one variable
      SET_FOREACH(points_to, pt, binding) {
        approximation ap = points_to_approximation(pt);
        if(relevant_translation_pair_p(pt, ll) 
           && (approximation_exact_p(ap) || approximation_must_p(ap))) {
          cell s = points_to_source(pt); // callee if backward_p
          cell d = points_to_sink(pt); // caller if backward_p
          reference sr = cell_any_reference(s);
          reference dr = cell_any_reference(d);
          // This test should be useless because this is guaranteed by
          // the approximation, except if binding is corrupted.
          if(atomic_points_to_reference_p(dr)) {
            list srs = reference_indices(sr);
            list drs = reference_indices(dr);
            if(ENDP(srs) && ENDP(drs)) {
              entity se = reference_variable(sr);
              entity de = reference_variable(dr);
              //type se_t = entity_basic_concrete_type(se);
              //type de_t = entity_basic_concrete_type(de);
              if(entity_has_values_p(de))
                tf = substitute_scalar_stub_in_transformer(tf, se, de, backward_p, &pl);
              else {
                type se_t = entity_basic_concrete_type(se);
                type de_t = entity_basic_concrete_type(de);
                if(type_struct_variable_p(se_t)) {
                  tf = substitute_struct_stub_in_transformer(tf, sr, se_t, dr, de_t, backward_p, &pl);
                }
                else
                  pl = CONS(ENTITY, se, pl);
              }
            }
            else if(ENDP(srs) && !ENDP(drs)) {
              entity se = reference_variable(sr);
              if(analyzed_reference_p(dr)) {
                entity de = constant_memory_access_path_to_location_entity(dr);
                tf = substitute_scalar_stub_in_transformer(tf, se, de, backward_p, &pl);
              }
              else {
                pl = CONS(ENTITY, se, pl);
              }
            }
            else if(!ENDP(srs) && ENDP(drs)) {
              entity de = reference_variable(dr);
              if(entity_has_values_p(de)) {
                entity se = constant_memory_access_path_to_location_entity(sr);
                if(!entity_undefined_p(se))
                  tf = substitute_scalar_stub_in_transformer(tf, se, de, backward_p, &pl);
                else
                  pips_internal_error("Not implemented yet.\n");
              }
              else {
                type de_t = entity_basic_concrete_type(de);
                if(type_struct_variable_p(de_t)) {
                  tf = substitute_struct_stub_in_transformer(tf, sr, de_t, dr, de_t, backward_p, &pl);
                  // tf = substitute_struct_stub_reference_in_transformer(tf, sr, de, backward_p, &pl);
                }
                else {
                  // Do nothing
                  // entity se = reference_variable(sr);
                  // pl = CONS(ENTITY, se, pl);
                  ;
                }
              }
            }
            else { // !ENDP(srs) & !ENDP(drs)
              if(analyzed_reference_p(dr)) {
                entity se = constant_memory_access_path_to_location_entity(sr);
                entity de = constant_memory_access_path_to_location_entity(dr);
                tf = substitute_scalar_stub_in_transformer(tf, se, de, backward_p, &pl);
              }
              else {
                type st = reference_to_type(sr);
                type cst = compute_basic_concrete_type(st);
                if(type_struct_variable_p(cst))
                  tf = substitute_struct_stub_in_transformer(tf, sr, cst, dr, cst, backward_p, &pl);
                else {
                  // No useful information in this binding
                  ;
                }
              }
            }
          }
        }
      }
      if(!ENDP(pl)) {
        // Get rid on untranslatable entities
        tf = safe_transformer_projection(tf, pl);
      }
    }
  }
 
  gen_free_list(ll);
 
  return tf;
}

References analyzed_reference_p(), approximation_exact_p, approximation_must_p, atomic_points_to_reference_p(), cell_any_reference(), compute_basic_concrete_type(), CONS, constant_memory_access_path_to_location_entity(), ENDP, ENTITY, entity_basic_concrete_type(), entity_has_values_p(), entity_undefined_p, gen_free_list(), get_current_module_entity(), get_points_to_graph_from_statement(), NIL, pips_internal_error, pl, points_to_approximation, points_to_graph_bottom, points_to_sink, points_to_source, pt_to_list_undefined_p(), reference_indices, reference_to_type(), reference_variable, relevant_translation_pair_p(), safe_transformer_projection(), SET_FOREACH, substitute_scalar_stub_in_transformer(), substitute_struct_stub_in_transformer(), transformer_to_analyzed_locations(), transformer_to_potential_stub_translation(), type_struct_variable_p(), and user_call_to_points_to_interprocedural_binding_set().

Referenced by process_call_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

summary_precondition()

bool summary_precondition

(

char *

module_name

)

transformer t = transformer_identity();

Add declaration information: arrays cannot be empty (Fortran standard, Section 5.1.2)

It does not seem to be a good idea for the semantics of SUMMARY_PRECONDITION. It seems better to have this information in the summary transformer as an input validity condition.

Try to put the summary precondition in a (partially) canonical form.

Parameters

module_name

odule_name

Definition at line 719 of file dbm_interface.c.

{
  /* transformer t = transformer_identity(); */
  transformer t = transformer_undefined;
  entity callee = module_name_to_entity(module_name);
 
  debug_on(SEMANTICS_DEBUG_LEVEL);
 
  make_statement_global_stack();
  set_current_module_entity(callee);
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true));
 
  if(entity_main_module_p(callee)) {
    t = main_summary_precondition(callee);
  }
  else {
    t = ordinary_summary_precondition(module_name, callee);
  }
 
  /* Add declaration information: arrays cannot be empty (Fortran
   * standard, Section 5.1.2)
   *
   * It does not seem to be a good idea for the semantics of
   * SUMMARY_PRECONDITION. It seems better to have this information in the
   * summary transformer as an input validity condition.
   *
   */
  if(false && get_bool_property("SEMANTICS_TRUST_ARRAY_DECLARATIONS")) {
    set_cumulated_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings( get_current_module_entity() );
    transformer_add_declaration_information(t,
                                            get_current_module_entity());
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    free_value_mappings();
  }
 
  pips_assert("t is defined", !transformer_undefined_p(t));
 
  /* Try to put the summary precondition in a (partially) canonical form. */
  t = transformer_normalize(t, 4);
  t = transformer_normalize(t, 4);
 
  ifdebug(3) {
    pips_debug(1, "considering summary precondition for %s\n", module_name);
    dump_transformer(t);
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_PRECONDITION,
                         module_name, (char * )t);
 
  ifdebug(1) {
    pips_debug(1,
               "initial summary precondition %p for %s (%d call sites):\n",
               t, module_name, get_call_site_number());
    dump_transformer(t);
    pips_debug(1, "end for module %s\n", module_name);
  }
 
  reset_current_module_statement();
  reset_current_module_entity();
  free_statement_global_stack();
  debug_off();
 
  return true;
}

References callee, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dump_transformer, entity_main_module_p(), free_statement_global_stack(), free_value_mappings(), get_bool_property(), get_call_site_number(), get_current_module_entity(), ifdebug, main_summary_precondition(), make_statement_global_stack(), module_name(), module_name_to_entity(), module_to_value_mappings(), ordinary_summary_precondition(), pips_assert, pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), SEMANTICS_DEBUG_LEVEL, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), transformer_add_declaration_information(), transformer_normalize(), transformer_undefined, and transformer_undefined_p.

Referenced by interprocedural_summary_precondition(), interprocedural_summary_precondition_with_points_to(), and intraprocedural_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

summary_total_postcondition()

bool summary_total_postcondition

(

char *

module_name

)

Look for all call sites in the callers

transformer t = transformer_identity();

no callers => empty precondition (but the main). FC. 08/01/1999.

try to eliminate (some) redundancy at a reasonnable cost

t = transformer_normalize(t, 2);

what cost?

Add declaration information: arrays cannot be empty (Fortran standard, Section 5.1.2)

It does not seem to be a good idea for the semantics of SUMMARY_PRECONDITION. It seems better to have this information in the summary transformer as an input validity condition.

Parameters

module_name

odule_name

Definition at line 789 of file dbm_interface.c.

{
  /* Look for all call sites in the callers
   */
  callees callers = (callees) db_get_memory_resource(DBR_CALLERS,
                                                     module_name,
                                                     true);
  entity callee = module_name_to_entity(module_name);
  /* transformer t = transformer_identity(); */
  transformer t = transformer_undefined;
 
  debug_on(SEMANTICS_DEBUG_LEVEL);
 
  pips_assert("Not implemented yet", false);
 
  set_current_module_entity(callee);
 
  ifdebug(1) {
    debug(1, "summary_precondition", "begin for %s with %d callers\n",
          module_name,
          gen_length(callees_callees(callers)));
    MAP(STRING, caller_name, {
      (void) fprintf(stderr, "%s, ", caller_name);
    }, callees_callees(callers));
    (void) fprintf(stderr, "\n");
  }
 
  reset_call_site_number();
 
  MAP(STRING, caller_name,
  {
    entity caller = module_name_to_entity(caller_name);
    t = update_precondition_with_call_site_preconditions(t, caller, callee);
  }, callees_callees(callers));
 
  if (!callees_callees(callers) &&
      !entity_main_module_p(callee) &&
      some_main_entity_p())
    {
      /* no callers => empty precondition (but the main).
         FC. 08/01/1999.
      */
      pips_user_warning("empty precondition to %s "
                        "because not in call tree from main.\n", module_name);
      t = transformer_empty();
    } else if (transformer_undefined_p(t)) {
      t = transformer_identity();
    } else {
      /* try to eliminate (some) redundancy at a reasonnable cost */
      /* t = transformer_normalize(t, 2); */
 
      /* what cost? */
      t = transformer_normalize(t, 7);
    }
 
  /* Add declaration information: arrays cannot be empty (Fortran
   * standard, Section 5.1.2)
   *
   * It does not seem to be a good idea for the semantics of
   * SUMMARY_PRECONDITION. It seems better to have this information in the
   * summary transformer as an input validity condition.
   *
   */
  if(false && get_bool_property("SEMANTICS_TRUST_ARRAY_DECLARATIONS")) {
    set_current_module_statement(
                                 (statement) db_get_memory_resource(DBR_CODE, module_name, true));
    set_cumulated_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_rw_effects((statement_effects)
                             db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings( get_current_module_entity() );
    transformer_add_declaration_information(t,
                                            get_current_module_entity());
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_current_module_statement();
    free_value_mappings();
  }
 
  DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_TOTAL_POSTCONDITION,
                         module_name, (char * )t);
 
  ifdebug(1) {
    pips_debug(1,
               "summary total postcondition %p for %s (%d call sites):\n",
               t, module_name, get_call_site_number());
    dump_transformer(t);
    pips_debug(1, "end for module %s\n", module_name);
  }
 
  reset_current_module_entity();
  debug_off();
 
  return true;
}

References callee, callees_callees, caller_name, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, dump_transformer, entity_main_module_p(), fprintf(), free_value_mappings(), gen_length(), get_bool_property(), get_call_site_number(), get_current_module_entity(), ifdebug, MAP, module_name(), module_name_to_entity(), module_to_value_mappings(), pips_assert, pips_debug, pips_user_warning, reset_call_site_number(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), SEMANTICS_DEBUG_LEVEL, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), some_main_entity_p(), STRING, transformer_add_declaration_information(), transformer_empty(), transformer_identity(), transformer_normalize(), transformer_undefined, transformer_undefined_p, and update_precondition_with_call_site_preconditions().

Here is the call graph for this function:

summary_total_precondition()

bool summary_total_precondition

(

char *

module_name

)

there is a choice: do nothing and leave the effective computation in module_name_to_total_preconditions or move it here

Parameters

module_name

odule_name

Definition at line 885 of file dbm_interface.c.

{
    /* there is a choice: do nothing and leave the effective computation
       in module_name_to_total_preconditions or move it here */
  pips_debug(1, "considering module %s\n", module_name);
  return true;
}

References module_name(), and pips_debug.

Here is the call graph for this function:

summary_transformer()

bool summary_transformer

(

char *

module_name

)

There is a choice: do nothing and leave the effective computation in module_name_to_transformers, or move it here

There is another choice: distinguish between inter- and intra-procedural analyses at the summary level or in module_name_to_transformers(). The choice does not have to be consistent with the similar choice made for summary_precondition.

Parameters

module_name

odule_name

Definition at line 387 of file dbm_interface.c.

{
  /* There is a choice: do nothing and leave the effective computation
     in module_name_to_transformers, or move it here */
  /* There is another choice: distinguish between inter- and
     intra-procedural analyses at the summary level or in
     module_name_to_transformers(). The choice does not have to be
     consistent with the similar choice made for summary_precondition. */
  pips_debug(1, "considering module %s\n", module_name);
  return true;
}

References module_name(), and pips_debug.

Here is the call graph for this function:

test_warning_counters()

bool test_warning_counters

(

void

)

Definition at line 908 of file dbm_interface.c.

{
  return wc++==0;
}

References wc.

Referenced by points_to_unary_operation_to_transformer().

Here is the caller graph for this function:

text_for_a_transformer()

text text_for_a_transformer	(	transformer	tran,
		bool	is_a_transformer
	)

call this one from outside.

Parameters

tran	ran
is_a_transformer	s_a_transformer

Definition at line 540 of file prettyprint.c.

{
  bool save_is_transformer = is_transformer;
  bool save_is_total_precondition = is_total_precondition;
  text t = text_undefined;
 
  is_transformer = is_a_transformer;
  is_total_precondition = false;
  t = text_transformer(tran);
  is_transformer = save_is_transformer;
  is_total_precondition = save_is_total_precondition;
  return t;
}

References is_total_precondition, is_transformer, text_transformer(), and text_undefined.

Referenced by call_site_to_module_precondition_text().

Here is the call graph for this function:

Here is the caller graph for this function:

text_transformer()

text text_transformer

(

transformer

tran

)

text text_transformer(transformer tran) input : a transformer representing a transformer or a precondition output : a text containing commentaries representing the transformer modifies : nothing.

Modification: AP, Nov 10th, 1995. Instead of building a (very long) string, I directly use the transformer to build the prettyprint in text format. This is to avoid the problem occuring when the buffer used in transformer[precondition]_to_string() is too small. I also use a static buffer to build each constraint; we are restricted to constraints of lengths smaller than the line length.

If in EMACS mode, does not add any separator line:

Parameters

tran

ran

Definition at line 464 of file prettyprint.c.

{
  text txt = make_text(NIL);
  bool foresys = get_bool_property("PRETTYPRINT_FOR_FORESYS");
  string str_prefix;
  char crt_line[MAX_LINE_LENGTH];
 
  /* If in EMACS mode, does not add any separator line: */
  if (get_bool_property("PRETTYPRINT_ANALYSES_WITH_LF")
      && !get_bool_property("PRETTYPRINT_ADD_EMACS_PROPERTIES"))
    ADD_SENTENCE_TO_TEXT(txt, make_sentence(is_sentence_formatted,
                                            strdup("\n")));
 
  str_prefix = foresys? FORESYS_CONTINUATION_PREFIX: get_comment_continuation();
  crt_line[0] = '\0';
 
  if (foresys)
    append(is_transformer? TRAN_FORESYS_PREFIX: PREC_FORESYS_PREFIX);
  else
    append(get_comment_sentinel());
 
  if(tran != (transformer) HASH_UNDEFINED_VALUE &&
     tran != (transformer) list_undefined) {
    if(tran==transformer_undefined) {
      if (is_transformer)
        append(" TRANSFORMER: TRANSFORMER_UNDEFINED");
      else if(is_total_precondition)
        append(" TOTAL PRECONDITION: TRANSFORMER_UNDEFINED");
      else
        append(" PRECONDITION: TRANSFORMER_UNDEFINED");
    }
    else {
      Psysteme ps;
      list args = transformer_arguments(tran);
 
      append(is_transformer? "  T(": (is_total_precondition? " TP(" : "  P("));
 
      entity_list_text_format(crt_line, str_prefix, txt,
                              args, entity_minimal_name);
 
      append(")");
      if (foresys) append(",");
      append(" ");
 
      ps = sc_copy(predicate_system(transformer_relation(tran)));
      sc_lexicographic_sort(ps, semantics_is_inferior_pvarval);
 
      ifdebug(7) {
        pips_debug(7, "sys %p\n", ps);
        sc_syst_debug(ps);
      }
 
      system_text_format(crt_line, str_prefix, txt, ps,
                         (char * (*)(Variable)) pips_user_value_name, foresys);
 
      sc_rm(ps);
    }
 
    close_current_line(crt_line, txt, str_prefix);
  }
 
  if (get_bool_property("PRETTYPRINT_ANALYSES_WITH_LF")
      && !get_bool_property("PRETTYPRINT_ADD_EMACS_PROPERTIES"))
    ADD_SENTENCE_TO_TEXT(txt, make_sentence(is_sentence_formatted,
                                            strdup("\n")));
 
  ifdebug(7){
    pips_debug(7, "final txt: \n");
    dump_text(txt);
  }
 
  return txt;
}

References ADD_SENTENCE_TO_TEXT, append, close_current_line(), dump_text(), entity_list_text_format(), entity_minimal_name(), FORESYS_CONTINUATION_PREFIX, get_bool_property(), get_comment_continuation(), get_comment_sentinel(), HASH_UNDEFINED_VALUE, ifdebug, is_sentence_formatted, is_total_precondition, is_transformer, list_undefined, make_sentence(), make_text(), MAX_LINE_LENGTH, NIL, pips_debug, pips_user_value_name(), PREC_FORESYS_PREFIX, predicate_system, sc_copy(), sc_lexicographic_sort(), sc_rm(), sc_syst_debug(), semantics_is_inferior_pvarval(), strdup(), system_text_format(), TRAN_FORESYS_PREFIX, transformer_arguments, transformer_relation, and transformer_undefined.

Referenced by get_semantic_text(), print_initial_precondition(), print_program_precondition(), semantic_to_text(), and text_for_a_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

tf_equivalence_equalities_add()

transformer tf_equivalence_equalities_add

(

transformer

tf

)

mappings.c

I need here a contraintes_dup() that is not yet available in Linear and I cannot change Linear just before the DRET meeting; I've got to modify transformer_equalities_add() and to give it a behavior different from transformer_equality_add()

Parameters

tf

f

Definition at line 83 of file mappings.c.

{
    /* I need here a contraintes_dup() that is not yet available
       in Linear and I cannot change Linear just before the DRET meeting;
       I've got to modify transformer_equalities_add() and to give it
       a behavior different from transformer_equality_add() */
    tf = transformer_equalities_add(tf, equivalence_equalities);
    return tf;
}

References equivalence_equalities, and transformer_equalities_add().

Referenced by statement_to_postcondition(), and statement_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

total_precondition_map_undefined_p()

bool total_precondition_map_undefined_p

(

void

)

total_preconditions_inter()

bool total_preconditions_inter

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 487 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_total_preconditions(module_name);
}

References module_name(), module_name_to_total_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

total_preconditions_intra()

bool total_preconditions_intra

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 475 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    set_bool_property(SEMANTICS_INEQUALITY_INVARIANT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_total_preconditions(module_name);
}

References module_name(), module_name_to_total_preconditions(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INEQUALITY_INVARIANT, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

transformer_add_any_relation_information()

transformer transformer_add_any_relation_information	(	transformer	pre,
		entity	op,
		expression	e1,
		expression	e2,
		transformer	context,
		bool	veracity,
		bool	upwards
	)

compute transformer or precondition

This is not satisfactory: when going upwards you might nevertheless benefit from some precondition information. But you would then need to pass two transformers as argument: a context transformer and a to-be-modified transformer

context = upwards? transformer_undefined : pre;

context = transformer_range(pre);

Logical are represented by integer values

PIPS does not represent negative constants: call to unary_minus

PIPS does not represent complex constants: call to CMPLX

Only constant string are processed

Pointer analysis

This is not correct if side effects occur in e1 or e2

This is very complicated to add constraints from tf1, tf2 and rel in pre!

tf1 may modify the initial context. See w10.f

tf1 disappears into cond

try to break rel it into two convex components

pre disappears into newpre2

pre disappears into newpre

newpre stays undefined or newpre is pre

free_transformer(tf1); already gone

Nothing to be done with struct and union

pre may be unchanged when no information is derived

Parameters

pre	re
op	p
e1	1
e2	2
context	ontext
veracity	eracity
upwards	pwards

Definition at line 4686 of file expression.c.

{
  basic b1 = basic_of_expression(e1);
  basic b2 = basic_of_expression(e2);
  int t1 = semantics_basic_tag(b1);
  int t2 = semantics_basic_tag(b2);
 
  pips_debug(8, "begin %s with pre=%p\n",
             upwards? "upwards" : "downwards", pre);
 
  /* This is not satisfactory: when going upwards you might nevertheless
     benefit from some precondition information. But you would then need
     to pass two transformers as argument: a context transformer and a
     to-be-modified transformer */
 
  /* context = upwards? transformer_undefined : pre; */
  /* context = transformer_range(pre); */
 
  if( (t1==t2)
      || (t1==is_basic_int && t2==is_basic_string)
      ||  (t2==is_basic_int && t1==is_basic_string) ) {
 
    switch(t1) {
    case is_basic_logical:
      /* Logical are represented by integer values*/
    case is_basic_float:
      /* PIPS does not represent negative constants: call to unary_minus */
    case is_basic_complex:
      /* PIPS does not represent complex constants: call to CMPLX */
    case is_basic_string:
      /* Only constant string are processed */
    case is_basic_pointer:
      /* Pointer analysis */
    case is_basic_int:
      {
        /* This is not correct if side effects occur in e1 or e2 */
        /* This is very complicated to add constraints from tf1, tf2 and
           rel in pre! */
        entity tmp1 = make_local_temporary_value_entity_with_basic(b1);
        entity tmp2 = make_local_temporary_value_entity_with_basic(b2);
        transformer tf1 = safe_any_expression_to_transformer(tmp1, e1, context, true);
        /* tf1 may modify the initial context. See w10.f */
        transformer pcontext = transformer_undefined_p(context)? transformer_identity()
          : transformer_apply(tf1, context);
        transformer ncontext = transformer_range(pcontext);
        transformer tf2 = safe_any_expression_to_transformer(tmp2, e2, ncontext, true);
        // FI: not precise because the context is not taken into
        // account when non-convex information is available,
        // non-convex information that could be convex within the
        // context. But see below.
        transformer rel = relation_to_transformer(op, tmp1, tmp2, veracity);
        transformer cond = transformer_undefined;
        transformer newpre = transformer_undefined;
 
        free_transformer(pcontext);
        free_transformer(ncontext);
 
        /* tf1 disappears into cond */
        cond = transformer_safe_combine_with_warnings(tf1, tf2);
 
        if(transformer_undefined_p(rel) && !transformer_undefined_p(cond)) {
          /* try to break rel it into two convex components */
          if((ENTITY_NON_EQUAL_P(op) && veracity)
             || (ENTITY_EQUAL_P(op) && !veracity)) {
            entity lt = local_name_to_top_level_entity(LESS_THAN_OPERATOR_NAME);
            entity gt = local_name_to_top_level_entity(GREATER_THAN_OPERATOR_NAME);
            transformer rel1 = relation_to_transformer(lt, tmp1, tmp2, true);
            transformer rel2 = relation_to_transformer(gt, tmp1, tmp2, true);
            transformer full_cond1 = transformer_safe_image_intersection(cond, rel1);
            transformer full_cond2 = transformer_safe_image_intersection(cond, rel2);
            /* pre disappears into newpre2 */
            transformer newpre1 = transformer_combine(transformer_dup(pre), full_cond1);
            transformer newpre2 = transformer_combine(pre, full_cond2);
 
            free_transformer(rel1);
            free_transformer(rel2);
 
            newpre = transformer_convex_hull(newpre1, newpre2);
 
            free_transformer(full_cond1);
            free_transformer(full_cond2);
            free_transformer(newpre1);
            free_transformer(newpre2);
          }
        }
        else if (!transformer_undefined_p(cond)){
          transformer full_cond = transformer_safe_image_intersection(cond, rel);
          /* pre disappears into newpre */
          newpre = transformer_combine(pre, full_cond);
          free_transformer(full_cond);
        }
        else {
          /* newpre stays undefined or newpre is pre*/
          newpre = pre;
        }
 
        transformer_free(cond);
        pre = newpre;
 
        pips_assert("Pre is still consistent with tf1 and tf2 and rel",
                    transformer_argument_consistency_p(pre));
 
        /* free_transformer(tf1); already gone */
        free_transformer(tf2);
        free_transformer(rel);
        break;
      }
    case is_basic_overloaded:
      pips_internal_error("illegal overloaded type for operator %s",
                 entity_name(op));
      break;
    case is_basic_bit:
      // Do not emit the same message during the second analysis of
      // the condition
      if(veracity)
        semantics_user_warning("bit type not analyzed for operator %s\n",
                               entity_name(op));
      break;
//    case is_basic_pointer:
//      if(veracity)
//      semantics_user_warning("pointer type not analyzed for operator %s\n",
//                        entity_name(op));
//      break;
    case is_basic_derived:
      /* Nothing to be done with struct and union */
      break;
    case is_basic_typedef:
      pips_internal_error("typedef should ne converted to concrete types for operator %s",
                        entity_name(op));
      break;
    default:
      pips_internal_error("unknown basic b=%d", basic_tag(b1));
    }
  }
 
  free_basic(b1);
  free_basic(b2);
 
  pre = transformer_normalize(pre, 2);
 
  /* pre may be unchanged when no information is derived */
  pips_debug(8, "end with pre=%p\n", pre);
 
  return pre;
}

References b1, b2, basic_of_expression(), basic_tag, ENTITY_EQUAL_P, entity_name, ENTITY_NON_EQUAL_P, free_basic(), free_transformer(), GREATER_THAN_OPERATOR_NAME, is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, LESS_THAN_OPERATOR_NAME, local_name_to_top_level_entity(), make_local_temporary_value_entity_with_basic(), pips_assert, pips_debug, pips_internal_error, relation_to_transformer(), safe_any_expression_to_transformer(), semantics_basic_tag(), semantics_user_warning, transformer_apply(), transformer_argument_consistency_p(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_free(), transformer_identity(), transformer_normalize(), transformer_range(), transformer_safe_combine_with_warnings(), transformer_safe_image_intersection(), transformer_undefined, and transformer_undefined_p.

Referenced by logical_binary_function_to_transformer(), and transformer_add_call_condition_information_updown().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_condition_information()

transformer transformer_add_condition_information	(	transformer	pre,
		expression	c,
		transformer	context,
		bool	veracity
	)

Parameters

pre	re
context	ontext
veracity	eracity

Definition at line 1092 of file expression.c.

{
    transformer post =
        transformer_add_condition_information_updown(pre, c, context,
                                                     veracity, true);
 
    post = transformer_temporary_value_projection(post);
    reset_temporary_value_counter();
 
    return post;
}

References reset_temporary_value_counter(), transformer_add_condition_information_updown(), and transformer_temporary_value_projection().

Referenced by check_condition_wrt_precondition(), old_complete_whileloop_transformer(), and transformer_add_domain_condition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_domain_condition()

transformer transformer_add_domain_condition	(	transformer	tf,
		expression	c,
		transformer	context,
		bool	veracity
	)

Parameters

tf	f
context	ontext
veracity	eracity

Definition at line 1138 of file expression.c.

{
  tf = transformer_add_condition_information(tf, c, context, veracity);
  return tf;
}

References transformer_add_condition_information().

Referenced by test_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_integer_relation_information()

transformer transformer_add_integer_relation_information	(	transformer	pre,
		entity	relop,
		expression	e1,
		expression	e2,
		bool	veracity,
		bool	upwards
	)

It is supposed to be obsolete but is still called.

Maybe, it's only partly obsolete... If upwards is false, it is worth performing more convex hulls because the precondition on entry may restrain the space. upwards = transformer, !upwards = precondition

default: no change

both expressions e1 and e2 must be affine

Make sure that new values only are used in v1 and v2

v1 - v2 == 0

v2 - v1 + 1 <= 0 ou v1 - v2 + 1 <= 0

FI: I do not know if this is valid when your are moving upwards variables in v2 and v1 may have to be renamed as init values (i.e. old values)

FI: I think that this should be programmed (see comment above) but I'm waiting for a bug to occur... (6 July 1993)

FI: Well, the bug was eventually seen:-) (8 November 1995)

free_transformer(prea);

free_transformer(preb);

v2 - v1 + 1 <= 0

v1 - v2 <= 0

v2 - v1 <= 0

v1 - v2 + 1 <= 0

do nothing... although Malik may have tried harder!

do nothing, although MODULO and INTEGER DIVIDE could be handled

Parameters

pre	re
relop	elop
e1	1
e2	2
veracity	eracity
upwards	pwards

Definition at line 5929 of file expression.c.

{
#   define DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION 7
  /* default: no change */
  transformer newpre = pre;
  /* both expressions e1 and e2 must be affine */
  normalized n1 = NORMALIZE_EXPRESSION(e1);
  normalized n2 = NORMALIZE_EXPRESSION(e2);
 
  ifdebug(DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION) {
    pips_debug(DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION,
               "begin upwards=%s veracity=%s relop=%s e1=", 
               bool_to_string(upwards), bool_to_string(veracity),
               entity_local_name(relop));
    print_expression(e1);
    (void) fprintf(stderr,"e2=");
    print_expression(e2);
    (void) fprintf(stderr,"pre=");
    print_transformer(pre);
  }
 
  if(normalized_linear_p(n1) && normalized_linear_p(n2)
     && value_mappings_compatible_vector_p((Pvecteur) normalized_linear(n1))
     && value_mappings_compatible_vector_p((Pvecteur) normalized_linear(n2))) {
    Pvecteur v1 = vect_dup((Pvecteur) normalized_linear(n1));
    Pvecteur v2 = vect_dup((Pvecteur) normalized_linear(n2));
 
    /* Make sure that new values only are used in v1 and v2 */
    variables_to_new_values(v1);
    variables_to_new_values(v2);
 
    if((ENTITY_EQUAL_P(relop) && veracity) ||
       (ENTITY_NON_EQUAL_P(relop) && !veracity)) {
      /* v1 - v2 == 0 */
      Pvecteur v = vect_substract(v1, v2);
      if(upwards) {
        upwards_vect_rename(v, pre);
      }
      newpre = transformer_equality_add(pre, v);
    }
    else if((ENTITY_EQUAL_P(relop) && !veracity) ||
            (ENTITY_NON_EQUAL_P(relop) && veracity)) {
      /* v2 - v1 + 1 <= 0 ou v1 - v2 + 1 <= 0 */
      /* FI: I do not know if this is valid when your are moving upwards
       * variables in v2 and v1 may have to be renamed as #init values (i.e. old values)
       */
      transformer prea = transformer_dup(pre);
      transformer preb = pre;
      Pvecteur va = vect_substract(v2, v1);
      Pvecteur vb = vect_substract(v1, v2);
      vect_add_elem(&va, TCST, VALUE_ONE);
      vect_add_elem(&vb, TCST, VALUE_ONE);
      /* FI: I think that this should be programmed (see comment above)
       * but I'm waiting for a bug to occur... (6 July 1993)
       *
       * FI: Well, the bug was eventually seen:-) (8 November 1995)
       */
      if(upwards) {
        upwards_vect_rename(va, pre);
        upwards_vect_rename(vb, pre);
      }
      prea = transformer_inequality_add(prea, va);
      preb = transformer_inequality_add(preb, vb);
      newpre = transformer_convex_hull(prea, preb);
      /* free_transformer(prea); */
      /* free_transformer(preb); */
    }
    else if ((ENTITY_GREATER_THAN_P(relop) && veracity) ||
             (ENTITY_LESS_OR_EQUAL_P(relop) && !veracity)) {
      /* v2 - v1 + 1 <= 0 */
      Pvecteur v = vect_substract(v2, v1);
      vect_add_elem(&v, TCST, VALUE_ONE);
      if(upwards) {
        upwards_vect_rename(v, pre);
      }
      newpre = transformer_inequality_add(pre, v);
    }
    else if ((ENTITY_GREATER_THAN_P(relop) && !veracity) ||
             (ENTITY_LESS_OR_EQUAL_P(relop) && veracity)) {
      /* v1 - v2 <= 0 */
      Pvecteur v = vect_substract(v1, v2);
      if(upwards) {
        upwards_vect_rename(v, pre);
      }
      newpre = transformer_inequality_add(pre, v);
    }
    else if ((ENTITY_GREATER_OR_EQUAL_P(relop) && veracity) ||
             (ENTITY_LESS_THAN_P(relop) && !veracity)) {
      /* v2 - v1 <= 0 */
      Pvecteur v = vect_substract(v2, v1);
      if(upwards) {
        upwards_vect_rename(v, pre);
      }
      newpre = transformer_inequality_add(pre, v);
    }
    else if ((ENTITY_GREATER_OR_EQUAL_P(relop) && !veracity) ||
             (ENTITY_LESS_THAN_P(relop) && veracity)) {
      /* v1 - v2 + 1 <= 0 */
      Pvecteur v = vect_substract(v1, v2);
      vect_add_elem(&v, TCST, VALUE_ONE);
      if(upwards) {
        upwards_vect_rename(v, pre);
      }
      newpre = transformer_inequality_add(pre, v);
    }
    else {
      /* do nothing... although Malik may have tried harder! */
      newpre = pre;
    }
    vect_rm(v1);
    vect_rm(v2);
  }
  else
    /* do nothing, although MODULO and INTEGER DIVIDE could be handled */
    newpre = pre;
 
  ifdebug(DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION) {
    pips_debug(DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION,
               "end newpre=\n");
    print_transformer(newpre);
    pips_assert("Transformer is internally consistent",
                transformer_internal_consistency_p(newpre));
  }
 
  return newpre;
}

References bool_to_string(), DEBUG_TRANSFORMER_ADD_RELATION_INFORMATION, 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_NON_EQUAL_P, fprintf(), ifdebug, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_assert, pips_debug, print_expression(), print_transformer, TCST, transformer_convex_hull(), transformer_dup(), transformer_equality_add(), transformer_inequality_add(), transformer_internal_consistency_p(), upwards_vect_rename(), value_mappings_compatible_vector_p(), VALUE_ONE, variables_to_new_values(), vect_add_elem(), vect_dup(), vect_rm(), and vect_substract().

Here is the call graph for this function:

transformer_add_loop_index_incrementation()

transformer transformer_add_loop_index_incrementation	(	transformer	tf,
		loop	l,
		transformer	pre
	)

SHOULD BE REWRITTEN WITH EXPRESSION_TO_TRANSFORMER

it does not contain the loop index update the loop increment expression must be linear to find inductive variables related to the loop index

Parameters

tf	f
pre	re

Definition at line 1136 of file loop.c.

{
  entity i = loop_index(l);
  range r = loop_range(l);
  expression incr = range_increment(r);
  Pvecteur v_incr = VECTEUR_UNDEFINED;
 
  /* SHOULD BE REWRITTEN WITH EXPRESSION_TO_TRANSFORMER */
 
  pips_assert("To please the compiler", pre==pre);
 
  pips_assert("Transformer tf is consistent before update",
              transformer_consistency_p(tf));
 
  /* it does not contain the loop index update the loop increment
     expression must be linear to find inductive variables related to
     the loop index */
  if(!VECTEUR_UNDEFINED_P(v_incr = expression_to_affine(incr))) {
    if(entity_has_values_p(i)) {
      if(value_mappings_compatible_vector_p(v_incr)) {
        tf = transformer_add_variable_incrementation(tf, i, v_incr);
      }
      else {
        entity i_old = entity_to_old_value(i);
        entity i_new = entity_to_new_value(i);
        Psysteme sc = predicate_system(transformer_relation(tf));
        Pbase b = sc_base(sc);
 
        transformer_arguments(tf) = arguments_add_entity(transformer_arguments(tf), i);
        b = base_add_variable(b, (Variable) i_old);
        b = base_add_variable(b, (Variable) i_new);
        sc_base(sc) = b;
        sc_dimension(sc) = base_dimension(sc_base(sc));
      }
    }
    else {
      pips_user_warning("non-integer or equivalenced loop index %s?\n",
                        entity_local_name(i));
    }
  }
  else {
    if(entity_has_values_p(i)) {
      entity i_old = entity_to_old_value(i);
      entity i_new = entity_to_new_value(i);
      Psysteme sc = predicate_system(transformer_relation(tf));
      Pbase b = sc_base(sc);
 
      transformer_arguments(tf) = arguments_add_entity(transformer_arguments(tf), i);
      b = base_add_variable(b, (Variable) i_old);
      b = base_add_variable(b, (Variable) i_new);
      sc_base(sc) = b;
      sc_dimension(sc) = base_dimension(sc_base(sc));
    }
  }
 
  pips_assert("Transformer tf is consistent after update",
              transformer_consistency_p(tf));
 
  return tf;
}

References arguments_add_entity(), base_add_variable(), base_dimension, entity_has_values_p(), entity_local_name(), entity_to_new_value(), entity_to_old_value(), expression_to_affine(), loop_index, loop_range, pips_assert, pips_user_warning, predicate_system, range_increment, transformer_add_variable_incrementation(), transformer_arguments, transformer_consistency_p(), transformer_relation, value_mappings_compatible_vector_p(), VECTEUR_UNDEFINED, and VECTEUR_UNDEFINED_P.

Referenced by loop_to_continue_transformer(), loop_to_total_precondition(), loop_to_transformer(), and recompute_loop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_loop_index_initialization()

transformer transformer_add_loop_index_initialization	(	transformer	tf,
		loop	l,
		transformer	pre
	)

The loop initialization is performed before tf.

EXPRESSION_TO_TRANSFORMER SHOULD BE USED

The new variables in eq must be added to sc; otherwise, further consistency checks core dump. bc.

sc_add_egalite(sc, eq);

The call to sc_projection_with_eq frees eq

FI: a NULL is not acceptable; I assume that we cannot end up with a SC_EMPTY...

Get rid of the initial value since it is unknowable

Parameters

tf	f
pre	re

Definition at line 1082 of file loop.c.

{
  entity i = loop_index(l);
  range r = loop_range(l);
  normalized nlb = NORMALIZE_EXPRESSION(range_lower(r));
 
  /* EXPRESSION_TO_TRANSFORMER SHOULD BE USED */
  pips_assert("To please the compiler", pre==pre);
 
  if(entity_has_values_p(i) && normalized_linear_p(nlb)) {
    Psysteme sc = (Psysteme) predicate_system(transformer_relation(tf));
    Pcontrainte eq = CONTRAINTE_UNDEFINED;
    Pvecteur v_lb = vect_dup(normalized_linear(nlb));
    Pbase b_tmp, b_lb = make_base_from_vect(v_lb);
    entity i_init = entity_to_old_value(i);
 
    vect_add_elem(&v_lb, (Variable) i_init, VALUE_MONE);
    eq = contrainte_make(v_lb);
    /* The new variables in eq must be added to sc; otherwise,
     * further consistency checks core dump. bc.
     */
    /* sc_add_egalite(sc, eq); */
    /* The call to sc_projection_with_eq frees eq */
    sc = sc_projection_by_eq(sc, eq, (Variable) i_init);
    b_tmp = sc_base(sc);
    sc_base(sc) = base_union(b_tmp, b_lb);
    sc_dimension(sc) = base_dimension(sc_base(sc));
    base_rm(b_tmp);
    base_rm(b_lb);
    if(SC_RN_P(sc)) {
      /* FI: a NULL is not acceptable; I assume that we cannot
       * end up with a SC_EMPTY...
       */
      predicate_system_(transformer_relation(tf)) =
        newgen_Psysteme
        (sc_make(CONTRAINTE_UNDEFINED, CONTRAINTE_UNDEFINED));
    }
    else
      predicate_system_(transformer_relation(tf)) =
        newgen_Psysteme(sc);
  }
  else if(entity_has_values_p(i)) {
    /* Get rid of the initial value since it is unknowable */
    entity i_init = entity_to_old_value(i);
    list l_i_init = CONS(ENTITY, i_init, NIL);
 
    tf = transformer_projection(tf, l_i_init);
  }
 
return tf;
}

References base_dimension, base_rm, base_union(), CONS, contrainte_make(), CONTRAINTE_UNDEFINED, ENTITY, entity_has_values_p(), entity_to_old_value(), eq, loop_index, loop_range, make_base_from_vect(), newgen_Psysteme, NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_assert, predicate_system, predicate_system_, range_lower, sc_make(), transformer_projection(), transformer_relation, VALUE_MONE, vect_add_elem(), and vect_dup().

Referenced by recompute_loop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_range_condition()

transformer transformer_add_range_condition	(	transformer	tf,
		expression	c,
		transformer	context,
		bool	veracity
	)

Parameters

tf	f
context	ontext
veracity	eracity

Definition at line 1147 of file expression.c.

{
  tf = precondition_add_condition_information(tf, c, context, veracity);
  return tf;
}

References precondition_add_condition_information().

Here is the call graph for this function:

transformer_add_reference_information()

void transformer_add_reference_information	(	transformer	tf,
		statement	s
	)

Parameters

tf

f

Definition at line 700 of file ri_to_preconditions.c.

{
  add_reference_information(tf, s, true);
}

References add_reference_information().

Referenced by statement_to_transformer(), and statement_to_transformer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_type_information()

void transformer_add_type_information

(

transformer

tf

)

type.c

Parameters

tf

f

Definition at line 162 of file type.c.

{
  add_type_information(tf);
  return;
}

References add_type_information().

Referenced by module_name_to_preconditions(), precondition_add_type_information(), statement_to_postcondition(), statement_to_transformer(), and transformer_add_variable_type_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_variable_type_information()

void transformer_add_variable_type_information	(	transformer	tf,
		entity	v
	)

Parameters

tf

f

Definition at line 168 of file type.c.

{
  pips_assert("entity has values", entity_has_values_p(v));
  entity vv = entity_to_new_value(v);
  if(!value_belongs_to_transformer_space(vv, tf))
    add_value_to_transformer_space(vv, tf);
  transformer_add_type_information(tf);
  return;
}

References add_value_to_transformer_space(), entity_has_values_p(), entity_to_new_value(), pips_assert, transformer_add_type_information(), and value_belongs_to_transformer_space().

Referenced by declaration_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_apply_field_assignments()

transformer transformer_apply_field_assignments	(	transformer	t,
		reference	l,
		reference	r,
		type	st
	)

Parameters

st

t

Definition at line 2925 of file ri_to_transformers.c.

{
  return transformer_apply_field_assignments_or_equalities(t, l, r, st, true);
}

References transformer_apply_field_assignments_or_equalities().

Referenced by struct_reference_assignment_or_equality_to_transformer(), and transformer_apply_field_assignments_or_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_apply_field_assignments_or_equalities()

transformer transformer_apply_field_assignments_or_equalities	(	transformer	t,
		reference	l,
		reference	r,
		type	st,
		bool	assign_p
	)

For all analyzable fields f, apply the assignment "le.f = re.f;" to transformer t.

If s1.f is a struct, go down recursively.

It is assumed that s1 and s2 have the exact same concrete struct type, st.

Transformer t is updated. It is assumed to contain the current precondition.

Parameters

st	t
assign_p	ssign_p

Definition at line 2876 of file ri_to_transformers.c.

{
  list fl = struct_type_to_fields(st);
  FOREACH(ENTITY, f, fl) {
    type ft = entity_basic_concrete_type(f);
    if(analyzed_type_p(ft)) {
      reference r1 = add_subscript_to_reference(copy_reference(l), 
                                                entity_to_expression(f));
      reference r2 = add_subscript_to_reference(copy_reference(r), 
                                                entity_to_expression(f));
      entity l1 = constant_memory_access_path_to_location_entity(r1);
      entity l2 = constant_memory_access_path_to_location_entity(r2);
 
      if(!entity_undefined_p(l1)) {
        transformer tf = transformer_identity();
        // The value of location l1 is changed
        if(assign_p)
          tf = transformer_add_modified_variable(tf, l1);
        if(!entity_undefined_p(l2)) {
          // both locations are analyzed
          tf = transformer_add_equality(tf, l1, l2);
        }
        t = transformer_combine(t, tf);
        free_transformer(tf);
      }
      else {
        pips_internal_error("Not implemented yet.\n");
      }
      free_reference(r1);
      free_reference(r2); // another option would be to remove the last subscript
    }
    else if(type_struct_p(ft)) {
      // This piece of code could be integrate in the previous
      // alternative to share most of its code
      reference l1 = add_subscript_to_reference(copy_reference(l), 
                                                entity_to_expression(f));
      reference r1 = add_subscript_to_reference(copy_reference(r), 
                                                entity_to_expression(f));
      transformer tf = transformer_identity();
      // GO down recursively
      tf = transformer_apply_field_assignments(tf, l1, r1, ft);
      if(!transformer_undefined_p(tf))
        t = transformer_combine(t, tf);
      free_transformer(tf), free_reference(r1), free_reference(l1);
    }
  }
  return t;
}

References add_subscript_to_reference(), analyzed_type_p(), constant_memory_access_path_to_location_entity(), copy_reference(), ENTITY, entity_basic_concrete_type(), entity_to_expression(), entity_undefined_p, f(), FOREACH, free_reference(), free_transformer(), pips_internal_error, struct_type_to_fields(), transformer_add_equality(), transformer_add_modified_variable(), transformer_apply_field_assignments(), transformer_combine(), transformer_identity(), transformer_undefined_p, and type_struct_p.

Referenced by transformer_apply_field_assignments(), and transformer_apply_field_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_apply_field_equalities()

transformer transformer_apply_field_equalities	(	transformer	t,
		reference	l,
		reference	r,
		type	st
	)

Parameters

st

t

Definition at line 2930 of file ri_to_transformers.c.

{
  return transformer_apply_field_assignments_or_equalities(t, l, r, st, false);
}

References transformer_apply_field_assignments_or_equalities().

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_apply_unknown_field_assignments()

transformer transformer_apply_unknown_field_assignments	(	transformer	t,
		reference	l,
		type	st
	)

Parameters

st

t

Definition at line 2976 of file ri_to_transformers.c.

{
  return transformer_apply_unknown_field_assignments_or_equalities(t, l, st, true);
}

References transformer_apply_unknown_field_assignments_or_equalities().

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_apply_unknown_field_equalities()

transformer transformer_apply_unknown_field_equalities	(	transformer	t,
		reference	l,
		type	st
	)

Parameters

st

t

Definition at line 2981 of file ri_to_transformers.c.

{
  return transformer_apply_unknown_field_assignments_or_equalities(t, l, st, false);
}

References transformer_apply_unknown_field_assignments_or_equalities().

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_formal_parameter_projection()

transformer transformer_formal_parameter_projection	(	entity	f,
		transformer	t
	)

Dealing with an interprocedural transformer, weak consistency is not true

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

Definition at line 1537 of file ri_to_transformers.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);
    if(!location_entity_p(var)) {
      storage s = entity_storage(var);
 
      if(storage_formal_p(s) && formal_function(storage_formal(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(), formal_function, fprintf(), gen_free_list(), ifdebug, location_entity_p(), NIL, pips_assert, pips_debug, predicate_system, print_entities(), sc_weak_consistent_p(), storage_formal, storage_formal_p, transformer_projection(), transformer_relation, transformer_weak_consistency_p(), value_to_variable(), vecteur_succ, and vecteur_var.

Referenced by c_user_call_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_intra_to_inter()

transformer transformer_intra_to_inter	(	transformer	tf,
		list	le
	)

Parameters

tf	f
le	e

Definition at line 1510 of file ri_to_transformers.c.

{
  return generic_transformer_intra_to_inter(tf, le, true);
}

References generic_transformer_intra_to_inter().

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

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_logical_inequalities_add()

transformer transformer_logical_inequalities_add	(	transformer	tf,
		entity	v
	)

PROCESSING OF LOGICAL EXPRESSIONS.

the values of v are between 0 and 1

Parameters

tf

f

Definition at line 3569 of file expression.c.

{
  /* the values of v are between 0 and 1 */
  Pvecteur ineq1 = vect_new((Variable) v, VALUE_ONE);
  Pvecteur ineq2 = vect_new((Variable) v, VALUE_MONE);
 
  vect_add_elem(&ineq1, TCST, VALUE_MONE);
 
  tf = transformer_inequality_add(tf, ineq1);
  tf = transformer_inequality_add(tf, ineq2);
 
  return tf;
}

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

Referenced by logical_binary_operation_to_transformer(), logical_reference_to_transformer(), and logical_unary_operation_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_map_undefined_p()

bool transformer_map_undefined_p

(

void

)

dbm_interface.c

transformers_inter_fast()

bool transformers_inter_fast

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 310 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, false);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_transformers(module_name);
}

References module_name(), module_name_to_transformers(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

transformers_inter_full()

bool transformers_inter_full

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 321 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_transformers(module_name);
}

References module_name(), module_name_to_transformers(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

transformers_inter_full_with_points_to()

bool transformers_inter_full_with_points_to

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 332 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    set_pt_to_list( (statement_points_to)
                    db_get_memory_resource(DBR_POINTS_TO, module_name, true) );
    bool result = module_name_to_transformers(module_name);
    reset_pt_to_list();
 
    return result;
}

References db_get_memory_resource(), module_name(), module_name_to_transformers(), reset_pt_to_list(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, set_bool_property(), and set_pt_to_list().

Here is the call graph for this function:

transformers_intra_fast()

bool transformers_intra_fast

(

char *

module_name

)

Functions to make transformers.

Set properties as required for a very fast semantics analysis

No need to select a fix point operator given the above property, but just in case...

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Restaure initial values of modified properties

Parameters

module_name

odule_name

Definition at line 254 of file dbm_interface.c.

{
  bool si = get_bool_property(SEMANTICS_INTERPROCEDURAL);
  bool sfs = get_bool_property(SEMANTICS_FLOW_SENSITIVE);
  bool sfp = get_bool_property(SEMANTICS_FIX_POINT);
  bool result = true;
 
  /* Set properties as required for a very fast semantics analysis */
  if(si) {
    pips_user_warning("Property SEMANTICS_INTERPROCEDURAL is ignored\n");
    set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
  }
  if(!sfs) {
    pips_user_warning("Property SEMANTICS_FLOW_SENSITIVE is ignored\n");
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
  }
  if(sfp) {
    pips_user_warning("Property SEMANTICS_FIX_POINT is ignored\n");
    set_bool_property(SEMANTICS_FIX_POINT, false);
  }
  /* No need to select a fix point operator given the above property, but just in case... */
  select_fix_point_operator();
 
  set_bool_property(SEMANTICS_STDOUT, false);
  /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
 
  if(get_bool_property("SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT")) {
    pips_user_warning("If you really want to set property "
                      "SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT, "
                      "you should activate TRANSFORMERS_INTER_FULL\n");
  }
 
  result =  module_name_to_transformers(module_name);
 
  /* Restaure initial values of modified properties */
  if(si)
    set_bool_property(SEMANTICS_INTERPROCEDURAL, true);
  if(!sfs)
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, false);
  if(sfp)
    set_bool_property(SEMANTICS_FIX_POINT, true);
 
  return result;
}

References get_bool_property(), module_name(), module_name_to_transformers(), pips_user_warning, select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

transformers_intra_full()

bool transformers_intra_full

(

char *

module_name

)

set_int_property(SEMANTICS_DEBUG_LEVEL, 0);

Parameters

module_name

odule_name

Definition at line 299 of file dbm_interface.c.

{
    set_bool_property(SEMANTICS_INTERPROCEDURAL, false);
    set_bool_property(SEMANTICS_FLOW_SENSITIVE, true);
    set_bool_property(SEMANTICS_FIX_POINT, true);
    select_fix_point_operator();
    set_bool_property(SEMANTICS_STDOUT, false);
    /* set_int_property(SEMANTICS_DEBUG_LEVEL, 0); */
    return module_name_to_transformers(module_name);
}

References module_name(), module_name_to_transformers(), select_fix_point_operator(), SEMANTICS_FIX_POINT, SEMANTICS_FLOW_SENSITIVE, SEMANTICS_INTERPROCEDURAL, SEMANTICS_STDOUT, and set_bool_property().

Here is the call graph for this function:

translate_global_value()

void translate_global_value	(	entity	m,
		transformer	tf,
		entity	v
	)

Try to convert an value on a non-local variable into an value on a local variable using a guessed name (instead of a location identity: M and N declared as COMMON/FOO/M and COMMON/FOO/N are not identified as a unique variable/location).

Mo more true: It might also fail to translate variable C:M into A:M if C is indirectly called from A thru B and if M is not defined in B.

This routine is not too safe. It accepts non-translatable variable as input and does not refuse them, most of the time.

Filter out constant and values local to the current module

FI: to be modified to account for global values that have a name but that should nevertheless be translated on their canonical representant; this occurs for non-visible global variables

FI: to be completed later... 3 December 1993 entity var = value_to_variable(v);

pips_debug(7, "%s is translated into %s\n", entity_name(v), entity_name(e)); transformer_value_substitute(tf, v, e);

Filter out old values: they are translated when the new value is encountered, and the new value has to appear if the old value does appear.

Instead, old values could be translated into new values and processing could go on...

FI, 26 October 1994

Should it be projected? No, this should occur later for xxxx::init variables when the xxxx is translated. Or before if xxxx has been translated

must be a common; dynamic and static area must have been filtered out before

try to find an equivalent entity by its name (whereas we should use locations)

no equivalent name found, get rid of v

transformer_projection(tf, CONS(ENTITY, v_old, NIL));

no equivalent location found, get rid of v

no equivalent location found, get rid of v

e has already been introduced and v eliminated; this happens when a COMMON variable is also passed as real argument

FI: v may still appear in the constraints as in spice.f (Perfect Club) and spice01.f (Validation)

this cannot happen when the summary transformer of a called procedure is translated because the write effect in the callee that is implied by v_init existence must have been passed upwards and must have led to the creation of e_init

this should not happen when a caller precondition at a call site is transformed into a piece of a summary precondition for the callee because v_init becomes meaningless; at the callee's entry point, by definition, e == e_init; v_init should have been projected before

forget e_init: there is no v_init in tf

there is no v_init to worry about; v is not changed in the caller (or its subtree of callees)

this value does not need to be translated

Parameters

tf

f

Definition at line 657 of file interprocedural.c.

{
  storage store = storage_undefined;
  ram r = ram_undefined;
  entity rf = entity_undefined;
  entity section = entity_undefined;
 
  ifdebug(7) {
    pips_debug(7, "begin v = %s and tf = %p\n", entity_name(v), tf);
  }
 
 
  if(v == NULL) {
    pips_internal_error("Trying to translate TCST");
    return;
  }
 
  /* Filter out constant and values *local* to the current module */
  if(value_entity_p(v) || entity_constant_p(v)) {
    /* FI: to be modified to account for global values that have a name
     * but that should nevertheless be translated on their canonical
     * representant; this occurs for non-visible global variables
     */
    /* FI: to be completed later... 3 December 1993
       entity var = value_to_variable(v);
 
       pips_debug(7,
       "%s is translated into %s\n",
       entity_name(v), entity_name(e));
       transformer_value_substitute(tf, v, e);
    */
 
    pips_debug(7, "end: No need to translate %s\n", entity_name(v));
    return;
  }
 
  /* Filter out old values: they are translated when the new value is
   * encountered, and the new value has to appear if the old value does
   * appear.
   *
   * Instead, old values could be translated into new values and processing
   * could go on...
   *
   * FI, 26 October 1994
   */
  if(global_old_value_p(v)) {
    pips_debug(7, "end: No need to translate %s yet\n",
               entity_name(v));
    return;
  }
 
  store = entity_storage(v);
 
  pips_debug(7, "Trying to translate %s\n", entity_name(v));
 
  if(!storage_ram_p(store)) {
    if(storage_rom_p(store)) {
      pips_debug(7, "%s is not translatable: store tag %d\n",
                 entity_name(v), storage_tag(store));
      /* Should it be projected? No, this should occur later for
       * xxxx#init variables when the xxxx is translated. Or before if
       * xxxx has been translated
       */
      return;
    }
    else
      if(storage_formal_p(store)) {
        pips_debug(7, "formal %s is not translatable\n",
                   entity_name(v));
        return;
      }
    if(storage_return_p(store)) {
      pips_debug(7, "return %s is not translatable\n",
                 entity_name(v));
      return;
    }
    else
      pips_internal_error("%s is not translatable: store tag %d",
                          entity_name(v), storage_tag(store));
  }
 
  ifdebug(7) {
    pips_debug(7, "let's do it for v = %s and tf =\n",
               entity_name(v));
    dump_transformer(tf);
  }
 
  r = storage_ram(store);
  rf = ram_function(r);
  section = ram_section(r);
 
  if(rf != m && top_level_entity_p(section)) {
    /* must be a common; dynamic and static area must
       have been filtered out before */
    entity e;
    entity v_init = entity_undefined;
    Psysteme sc = SC_UNDEFINED;
    Pbase b = BASE_UNDEFINED;
 
    if(top_level_entity_p(v)) {
      // No need to translate
      return;
    }
 
    /* try to find an equivalent entity by its name
       (whereas we should use locations) */
    /*
      e = FindEntity(module_local_name(m),
      entity_local_name(v));
      e = value_alias(value_to_variable(v));
    */
    e = value_alias(v);
    if(e == entity_undefined) {
      /* no equivalent name found, get rid of v */
      pips_debug(7, "No equivalent for %s in %s: project %s\n",
                 entity_name(v), entity_name(m), entity_name(v));
      user_warning("translate_global_value",
                   "Information about %s lost,\n"
                   "check structure of common /%s/ in modules %s and %s\n",
                   entity_name(v), module_local_name(section), entity_module_name(v),
                   module_local_name(m));
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        entity v_old = global_new_value_to_global_old_value(v);
        /* transformer_projection(tf, CONS(ENTITY, v_old, NIL)); */
        (void) transformer_filter(tf, CONS(ENTITY, v_old, NIL));
      }
      transformer_projection(tf, CONS(ENTITY, v, NIL));
      return;
    }
 
    if(!same_scalar_location_p(v, e)) {
      /* no equivalent location found, get rid of v */
      pips_debug(7, "No equivalent location for %s and %s: project %s\n",
                 entity_name(v), entity_name(e), entity_name(v));
      transformer_projection(tf, CONS(ENTITY, v, NIL));
      user_warning("translate_global_value",
                   "Information about %s lost,\n"
                   "check structure of common /%s/ in modules %s and %s\n",
                   entity_name(v), entity_local_name(section), entity_module_name(v),
                   module_local_name(m));
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        entity v_old = global_new_value_to_global_old_value(v);
        transformer_projection(tf, CONS(ENTITY, v_old, NIL));
      }
      transformer_projection(tf, CONS(ENTITY, v, NIL));
      return;
    }
 
    if(!type_equal_p(entity_type(v), entity_type(e))) {
      /* no equivalent location found, get rid of v */
      pips_debug(7, "Same location but different types for %s (%s) and %s (%s):"
                 " project both %s and %s\n",
                 entity_name(v), type_to_string(entity_type(v)),
                 entity_name(e), type_to_string(entity_type(e)),
                 entity_name(e), entity_name(v));
      transformer_projection(tf, CONS(ENTITY, v, NIL));
      user_warning("translate_global_value",
                   "Information about %s lost,\n"
                   "check types for variables in common /%s/ in modules %s and %s\n",
                   entity_name(v), entity_module_name(section), entity_module_name(v),
                   module_local_name(m));
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        entity v_old = global_new_value_to_global_old_value(v);
        transformer_projection(tf, CONS(ENTITY, v_old, NIL));
      }
      if(entity_is_argument_p(e, transformer_arguments(tf))) {
        entity e_old = global_new_value_to_global_old_value(e);
        transformer_filter(tf, CONS(ENTITY, e_old, NIL));
      }
      transformer_filter(tf, CONS(ENTITY, v, NIL));
      transformer_filter(tf, CONS(ENTITY, e, NIL));
      return;
     }
 
    sc = (Psysteme)
      predicate_system(transformer_relation(tf));
    b = sc_base(sc);
    if(base_contains_variable_p(b, (Variable) e)) {
      /* e has already been introduced and v eliminated;
         this happens when a COMMON variable is
         also passed as real argument */
      /* FI: v may still appear in the constraints as in spice.f
         (Perfect Club) and spice01.f (Validation) */
      Pvecteur subst = vect_new((Variable) v, (Value) 1);
      Pcontrainte eq = CONTRAINTE_UNDEFINED;
      list args = CONS(ENTITY, v, NIL);
 
      vect_add_elem(&subst, (Variable) e, (Value) -1);
      eq = contrainte_make(subst);
      sc_add_egalite(sc, eq);
 
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        entity v_old = global_new_value_to_global_old_value(v);
        entity e_old = global_new_value_to_global_old_value(e);
        Pvecteur subst_old = vect_new((Variable) v_old, (Value) 1);
        Pcontrainte eq_old = CONTRAINTE_UNDEFINED;
 
       args = CONS(ENTITY, v_old, args);
 
       vect_add_elem(&subst_old, (Variable) e_old, (Value) -1);
       eq_old = contrainte_make(subst_old);
       sc_equation_add(sc, eq_old);
      }
 
      pips_debug(7, "%s has already been translated into %s\n",
                 entity_name(v), entity_name(e));
      if(!language_c_p(module_language(m))) {
        user_warning("translate_global_value",
                     "Variable %s is probably aliased with a formal parameter"
                     " by the current call to %s from %s.\n"
                     "This is forbidden by the Fortran 77 standard.\n",
                     entity_name(v), entity_module_name(v), module_local_name(m));
      }
      ifdebug(7) {
        pips_debug(7,
                   "%s should again be translated into %s by projection of %s\n",
                   entity_name(v), entity_name(e), entity_name(v));
        dump_transformer(tf);
      }
 
      if(entity_is_argument_p(v, transformer_arguments(tf))) {
        transformer_arguments(tf) =
          arguments_add_entity(transformer_arguments(tf), e);
      }
 
      tf = transformer_projection(tf, args);
      gen_free_list(args);
 
      ifdebug(7) {
        pips_debug(7, "After projection of %s\n",
                   entity_name(v));
        dump_transformer(tf);
      }
    }
    else {
      pips_debug(7, "%s is translated into %s\n",
                 entity_name(v), entity_name(e));
      transformer_value_substitute(tf, v, e);
    }
 
    v_init = (entity)
      gen_find_tabulated(concatenate(entity_name(v),
                                     OLD_VALUE_SUFFIX,
                                     (char *) NULL),
                         entity_domain);
    if(v_init != entity_undefined) {
      entity e_init = (entity)
        gen_find_tabulated(concatenate(entity_name(e),
                                       OLD_VALUE_SUFFIX,
                                       (char *) NULL),
                           entity_domain);
      if(e_init == entity_undefined) {
        /* this cannot happen when the summary transformer
           of a called procedure is translated because
           the write effect in the callee that is implied
           by v_init existence must have been passed
           upwards and must have led to the creation
           of e_init */
        /* this should not happen when a caller
           precondition at a call site is transformed
           into a piece of a summary precondition for
           the callee because v_init becomes meaningless;
           at the callee's entry point, by definition,
           e == e_init; v_init should have been projected
           before
        */
        Psysteme r =
          (Psysteme) predicate_system(transformer_relation(tf));
 
        if(base_contains_variable_p(sc_base(r), (Variable) v_init))
          pips_internal_error("Cannot find value %s",
                     strdup(
                            concatenate(
                                        module_local_name(m),
                                        MODULE_SEP_STRING,
                                        entity_local_name(v),
                                        OLD_VALUE_SUFFIX,
                                        (char *) NULL)));
        else {
          /* forget e_init: there is no v_init in tf */
          ;
          pips_debug(7, "%s is not used in tf\n",
                     entity_name(v_init));
        }
      }
      else {
        pips_debug(7, "%s is translated into %s\n",
                   entity_name(v), entity_name(e));
        if(transformer_value_substitutable_p(tf, v_init, e_init))
          transformer_value_substitute(tf, v_init, e_init);
        else {
          pips_user_error("Unsupported aliasing linked to %s and %s\n",
                          entity_name(v_init), entity_name(e_init));
        }
      }
    }
    else {
      /* there is no v_init to worry about; v is not changed in
         the caller (or its subtree of callees) */
    }
  }
  else {
    /* this value does not need to be translated */
  }
}

References arguments_add_entity(), base_contains_variable_p(), BASE_UNDEFINED, concatenate(), CONS, contrainte_make(), CONTRAINTE_UNDEFINED, dump_transformer, ENTITY, entity_constant_p, entity_domain, entity_is_argument_p(), entity_local_name(), entity_module_name(), entity_name, entity_storage, entity_type, entity_undefined, eq, gen_find_tabulated(), gen_free_list(), global_new_value_to_global_old_value(), global_old_value_p(), ifdebug, language_c_p, module_language, module_local_name(), MODULE_SEP_STRING, NIL, OLD_VALUE_SUFFIX, pips_debug, pips_internal_error, pips_user_error, predicate_system, ram_function, ram_section, ram_undefined, same_scalar_location_p(), sc_add_egalite(), sc_equation_add(), storage_formal_p, storage_ram, storage_ram_p, storage_return_p, storage_rom_p, storage_tag, storage_undefined, strdup(), top_level_entity_p(), transformer_arguments, transformer_filter(), transformer_projection(), transformer_relation, transformer_value_substitutable_p(), transformer_value_substitute(), type_equal_p(), type_to_string(), user_warning, value_alias(), value_entity_p(), vect_add_elem(), and vect_new().

Referenced by translate_global_values().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_global_values()

void translate_global_values	(	entity	m,
		transformer	tf
	)

a copy of sc_base(s) is needed because translate_global_value() modifies it at the same time

Parameters

tf

f

Definition at line 625 of file interprocedural.c.

{
    Psysteme s = (Psysteme) predicate_system(transformer_relation(tf));
    /* a copy of sc_base(s) is needed because translate_global_value()
       modifies it at the same time */
    Pbase b = (Pbase) vect_dup(sc_base(s));
    Pbase bv;
 
    ifdebug(6) {
        pips_debug(6, "Predicate for tf:\n");
        sc_fprint(stderr, s, (char * (*)(Variable)) dump_value_name);
    }
 
    for(bv = b; bv != NULL; bv = bv->succ) {
        translate_global_value(m, tf, (entity) vecteur_var(bv));
 
    }
 
    base_rm(b);
}

References base_rm, dump_value_name(), ifdebug, pips_debug, predicate_system, sc_fprint(), Svecteur::succ, transformer_relation, translate_global_value(), vect_dup(), and vecteur_var.

Referenced by add_module_call_site_precondition(), fortran_user_call_to_transformer(), get_semantic_text(), load_summary_precondition(), module_name_to_total_preconditions(), precondition_intra_to_inter(), process_call_for_summary_precondition(), and program_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

true_condition_wrt_precondition_p()

bool true_condition_wrt_precondition_p	(	expression	c,
		transformer	pre
	)

Parameters

pre

re

Definition at line 5900 of file expression.c.

{
  bool result = false;
 
  result = eval_condition_wrt_precondition_p(c, pre, true);
 
  return result;
}

References eval_condition_wrt_precondition_p().

Referenced by whileloop_to_postcondition(), and whileloop_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_flow_insensitive_transformer()

transformer unstructured_to_flow_insensitive_transformer

(

unstructured

u

)

This simple fix-point over-approximates the CFG by a fully connected graph.

Each vertex can be executed at any time any number of times.

The fix point is easy to compute because it is the fix point of the convex hull all each node transformers.

The result is sometimes surprising as users see the real paths and cannot understand why a variable is declared modified when it obviously is not. This mostly choses in node preconditions since the overall unstructured transformer is not displayed usually and since it is globally correct.

But it is a perfectly valid over-approximation usable by automatic analyses.

Using the effects of the unstructured to derive a fix point leads to the same surprise although it is as correct, using the same over approximation of the control flow graph but a cruder version of the transformers.

This function is also used when computing preconditions if the exit node is not reached (?). It assumes that transformers for all statements in the unstructured have already been computed.

Two modes are possible: the transitive closure of the convex hull of all elementary transformers, or the transitive closure of the transformer list.

Assume any reachable node is executed at each iteration. A fix-point of the result can be used to approximate the node preconditions. Some nodes can be discarded because they do not modify the store such as IF statements (always) and CONTINUE statements (if they do not link the entry and the exit nodes).

Entry node

transformer_convex_hull has side effects on its arguments:-(

Should be fixed now, 29 June 2000

transformer tf_st = copy_transformer(load_statement_transformer(st));

Any side effect?

test

continue

other

Definition at line 2206 of file unstructured.c.

{
  /* Assume any reachable node is executed at each iteration. A fix-point
     of the result can be used to approximate the node preconditions. Some
     nodes can be discarded because they do not modify the store such as
     IF statements (always) and CONTINUE statements (if they do not link
     the entry and the exit nodes). */
 
  list nodes = NIL;
  /* Entry node */
  control entry_node = unstructured_control(u);
  control exit_node = unstructured_exit(u);
  transformer tf_u = transformer_empty();
  transformer fp_tf_u = transformer_undefined;
  bool tfl_p = get_bool_property("SEMANTICS_USE_TRANSFORMER_LISTS");
  list tfl = NIL;
 
  pips_debug(8,"begin\n");
 
  FORWARD_CONTROL_MAP(c, {
    statement st = control_statement(c);
    /* transformer_convex_hull has side effects on its arguments:-( */
    /* Should be fixed now, 29 June 2000 */
    /* transformer tf_st = copy_transformer(load_statement_transformer(st)); */
    transformer tf_st = load_statement_transformer(st);
    transformer tf_old = tf_u;
 
    if(statement_test_p(st)) {
      /* Any side effect? */
      if(!ENDP(transformer_arguments(tf_st))) {
        if(tfl_p) {
          tfl = CONS(TRANSFORMER, tf_st, tfl);
        }
        else {
          tf_u = transformer_convex_hull(tf_old, tf_st); /* test */
          free_transformer(tf_old);
        }
      }
    }
    else {
      if(continue_statement_p(st)) {
        if(gen_find_eq(entry_node, control_predecessors(c))!=chunk_undefined
           && gen_find_eq(exit_node, control_successors(c))!=chunk_undefined) {
        if(tfl_p) {
          tfl = CONS(TRANSFORMER, tf_st, tfl);
        }
        else {
          tf_u = transformer_convex_hull(tf_old, tf_st); /* continue */
          free_transformer(tf_old);
        }
        }
      }
      else {
        if(tfl_p) {
          tfl = CONS(TRANSFORMER, tf_st, tfl);
        }
        else {
        tf_u = transformer_convex_hull(tf_old, tf_st); /* other */
        free_transformer(tf_old);
        }
      }
    }
 
    ifdebug(1) {
      pips_assert("tf_st is internally consistent",
                  transformer_internal_consistency_p(tf_st));
      if(!tfl_p)
        pips_assert("tf_u is internally consistent",
                    transformer_internal_consistency_p(tf_u));
    }
 
  }, entry_node, nodes) ;
 
  gen_free_list(nodes) ;
 
  if(tfl_p) {
    // FI: apparently, we need T* rather than T+
      fp_tf_u = transformer_list_transitive_closure(tfl);
      gen_free_list(tfl);
  }
  else
    fp_tf_u = (*transformer_fix_point_operator)(tf_u);
 
  ifdebug(8) {
    pips_debug(8,"Result for one step tf_u:\n");
    print_transformer(tf_u);
    pips_assert("tf_u is internally consistent",
                transformer_internal_consistency_p(tf_u));
    pips_debug(8,"Result for fix-point fp_tf_u:\n");
    print_transformer(fp_tf_u);
    pips_assert("fp_tf_u is internally consistent",
                transformer_internal_consistency_p(fp_tf_u));
  }
 
  pips_debug(8,"end\n");
 
  return fp_tf_u;
}

References chunk_undefined, CONS, continue_statement_p(), control_predecessors, control_statement, control_successors, ENDP, FORWARD_CONTROL_MAP, free_transformer(), gen_find_eq(), gen_free_list(), get_bool_property(), ifdebug, load_statement_transformer(), NIL, pips_assert, pips_debug, print_transformer, statement_test_p(), TRANSFORMER, transformer_arguments, transformer_convex_hull(), transformer_empty(), transformer_internal_consistency_p(), transformer_list_transitive_closure(), transformer_undefined, unstructured_control, and unstructured_exit.

Referenced by 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:

unstructured_to_flow_sensitive_postconditions()

transformer unstructured_to_flow_sensitive_postconditions	(	transformer	pre_u,
		transformer	pre,
		unstructured	u
	)

compute pre- and post-conditions in an unstructured from the entry precondition pre and return the exit postcondition.

pre_u is pre filtered by the u's transformer and can be used for any node.

control tail = unstructured_exit(u);

Parameters

pre_u	re_u
pre	re

Definition at line 2040 of file unstructured.c.

{
  transformer post = transformer_undefined;
  list succs = NIL;
  control head = unstructured_control(u);
  /* control tail = unstructured_exit(u); */
 
  forward_control_map_get_blocs(head, &succs);
 
  if(((int)gen_length(succs))>get_int_property("SEMANTICS_MAX_CFG_SIZE1")) {
      semantics_user_warning("\nControl flow graph too large for an accurate analysis (%d nodes)\n"
                        "Have you fully restructured your code?\n", gen_length(succs));
    post = unstructured_to_postconditions(pre, pre_u, u);
  }
  else if(!get_bool_property("SEMANTICS_ANALYZE_UNSTRUCTURED")) {
    semantics_user_warning("\nControl flow graph not analyzed accurately"
                      " because property SEMANTICS_ANALYZE_UNSTRUCTURED is not set\n");
    post = unstructured_to_postconditions(pre_u, pre, u);
  }
  else if(!get_bool_property("SEMANTICS_FIX_POINT")) {
    post = unstructured_to_postconditions(pre_u, pre, u);
  }
  else {
    post = unstructured_to_flow_sensitive_postconditions_or_transformers
      (pre_u, pre, u, true);
  }
  gen_free_list(succs);
 
  pips_assert("Postcondition for unstructured is consistent",
              transformer_consistency_p(post));
 
  return post;
}

References forward_control_map_get_blocs(), gen_free_list(), gen_length(), get_bool_property(), get_int_property(), NIL, pips_assert, semantics_user_warning, transformer_consistency_p(), transformer_undefined, unstructured_control, unstructured_to_flow_sensitive_postconditions_or_transformers(), and unstructured_to_postconditions().

Referenced by unstructured_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_flow_sensitive_postconditions_or_transformers()

transformer unstructured_to_flow_sensitive_postconditions_or_transformers	(	transformer	pre_u,
		transformer	pre,
		unstructured	u,
		bool	postcondition_p
	)

compute either the postconditions in an unstructured or the transformer of this unstructured.

In both cases, transformers for all nodes used to be supposed to be available.

Do not go down into nested unstructured

Propagate the precondition in the DAG and recompute the cycle transformers or compute the path transformers and the cycle fix point transformers.

Compute the real precondition for each statement and propagate postconditions in it.

Take care of unreachable nodes

Get rid of the auxiliary data structures

Parameters

pre_u	re_u
pre	precondition at entry: e_pre
u	precondition true for every node: n_pre
postcondition_p	ostcondition_p

Definition at line 1821 of file unstructured.c.

{
  transformer post = transformer_undefined;
  hash_table ancestor_map = hash_table_undefined;
  hash_table scc_map = hash_table_undefined;
  control_mapping fix_point_map  = make_control_fix_point_map();
  unstructured ndu = unstructured_undefined;
  list partition = bourdoncle_partition(u, &ndu, &ancestor_map, &scc_map);
  control_mapping control_postcondition_map = make_control_postcondition_map();
  transformer pre_u_r = transformer_range(pre_u);
  transformer pre_r = transformer_range(pre);
 
  recursive_context context = { postcondition_p, control_postcondition_map };
 
  recursive_context fcontext = { postcondition_p, fix_point_map };
 
  ifdebug(2) {
    pips_debug(2, "Begin for %s with nodes:\n",
               postcondition_p? "postconditions" : "transformer");
    /* Do not go down into nested unstructured */
    gen_multi_recurse(u, statement_domain, gen_false, gen_null,
                      control_domain, gen_true, print_control_node_uns, NULL);
    pips_debug(2, "With entry nodes\n");
    print_control_node_uns(unstructured_control(u));
    pips_debug(2, "And exit node\n");
    print_control_node_uns(unstructured_exit(u));
    pips_debug(2, "And embedding graph:\n");
    gen_multi_recurse(ndu, statement_domain, gen_false, gen_null,
                      control_domain, gen_true, print_control_node_uns, NULL);
  }
 
  /* Propagate the precondition in the DAG and recompute the cycle
     transformers or compute the path transformers and the cycle fix point
     transformers. */
  (void) dag_to_flow_sensitive_postconditions_or_transformers
    (partition, ndu, ancestor_map, scc_map, fix_point_map,
     postcondition_p? pre_u : pre_u_r, postcondition_p? pre : pre_r,
     control_postcondition_map, postcondition_p);
 
  if(postcondition_p) {
    /* Compute the real precondition for each statement and propagate
       postconditions in it. */
 
    dag_to_flow_sensitive_preconditions
    (partition, ndu, ancestor_map, scc_map, fix_point_map, pre_u, pre,
     control_postcondition_map);
  }
 
  /* Take care of unreachable nodes */
  gen_context_multi_recurse(
                            ndu, (void *) & context,
                            statement_domain, gen_false, gen_null,
                            control_domain, gen_true, local_process_unreachable_node,
                            NULL);
 
  ifdebug(2) {
    pips_debug(2, "%s for unstructured\n",
               postcondition_p? "Postconditions": "Path transformer");
    gen_context_multi_recurse(
                              ndu, (void *) & context,
                              statement_domain, gen_false, gen_null,
                              control_domain, gen_true,
                              node_to_path_transformer_or_postcondition,
                              NULL);
    pips_debug(2, "End of map\n");
    if(hash_table_entry_count(fix_point_map)>0) {
      pips_debug(2, "Fix point map:\n");
      gen_context_multi_recurse(
                                u, (void *) & fcontext,
                                statement_domain, gen_false, gen_null,
                                control_domain, gen_true,
                                print_cycle_head_to_fixpoint,
                                NULL);
      pips_debug(2, "End of fix point map\n");
      pips_debug(2, "Dump fix point map %p:\n", fix_point_map);
      HASH_MAP(k, v, {
        control c = (control) k;
        statement s = control_statement(c);
        transformer fp_tf = (transformer) v;
 
        print_control_node_uns(c);
        fprintf(stderr, "Statement %s", statement_identification(s));
        print_transformer(fp_tf);
      }, fix_point_map);
      pips_debug(2, "End of fix point map dump\n");
    }
    else {
      fprintf(stderr, "No fix point. Empty fix point map\n");
    }
  }
 
  post = copy_transformer
    (load_control_postcondition(unstructured_exit(ndu),
                                control_postcondition_map));
  control_postcondition_map = free_control_postcondition_map(control_postcondition_map);
  fix_point_map = free_control_fix_point_map(fix_point_map);
 
  ifdebug(2) {
    pips_assert("The postcondition post is defined", !transformer_undefined_p(post));
    pips_debug(2, "End with unstructured postcondition:\n");
    print_transformer(post);
  }
 
  /* Get rid of the auxiliary data structures */
  bourdoncle_free(ndu, ancestor_map, scc_map);
 
  return post;
}

References bourdoncle_free(), bourdoncle_partition(), control_domain, control_statement, copy_transformer(), dag_to_flow_sensitive_postconditions_or_transformers(), dag_to_flow_sensitive_preconditions(), fprintf(), free_control_fix_point_map(), free_control_postcondition_map(), gen_context_multi_recurse(), gen_false(), gen_multi_recurse(), gen_null(), gen_true(), HASH_MAP, hash_table_entry_count(), hash_table_undefined, ifdebug, load_control_postcondition(), local_process_unreachable_node(), make_control_fix_point_map(), make_control_postcondition_map(), node_to_path_transformer_or_postcondition(), pips_assert, pips_debug, print_control_node_uns(), print_cycle_head_to_fixpoint(), print_transformer, statement_domain, statement_identification(), transformer_range(), transformer_undefined, transformer_undefined_p, unstructured_control, unstructured_exit, and unstructured_undefined.

Referenced by unstructured_to_flow_sensitive_postconditions(), and unstructured_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_flow_sensitive_total_preconditions()

transformer unstructured_to_flow_sensitive_total_preconditions	(	transformer	t_post_u,
		transformer	pre,
		unstructured	u
	)

control tail = unstructured_exit(u);

Parameters

t_post_u	_post_u
pre	re

Definition at line 2473 of file unstructured.c.

{
  transformer t_pre = transformer_undefined;
  transformer post = transformer_undefined;
  /* control tail = unstructured_exit(u); */
 
  pips_assert("Not implemented yet", false);
  pips_assert("Shut up the compiler", t_post_u==t_post_u && pre==pre && u==u);
 
  pips_assert("Total precondition for unstructured is consistent",
              transformer_consistency_p(t_pre));
 
  return post;
}

References pips_assert, transformer_consistency_p(), and transformer_undefined.

Referenced by unstructured_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_postcondition()

transformer unstructured_to_postcondition	(	transformer	pre,
		unstructured	u,
		transformer	tf
	)

there is only one statement and no arcs in u; no need for a fix-point

FI: pre should not be duplicated because statement_to_postcondition() means that pre is not going to be changed, just post produced.

Do not try anything clever! God knows what may happen in unstructured code. Postcondition post is not computed recursively from its components but directly derived from u's transformer. Preconditions associated to its components are then computed independently, hence the name unstructured_to_postconditionS instead of unstructured_to_postcondition

propagate as precondition an invariant for the whole unstructured u assuming that all nodes in the CFG are fully connected, unless tf is not feasible because the unstructured is never exited or exited thru a call to STOP which invalidates the previous assumption.

FI: I do not know if I should duplicate pre or not.

FI: well, dumdum, you should have duplicated tf!

FI: euh... why? According to comments about transformer_apply() neither arguments are modified...

post = unstructured_to_postconditions(pre_n, pre, u);

Parameters

pre	re
tf	f

Definition at line 2075 of file unstructured.c.

{
    transformer post;
    control c;
 
    pips_debug(8, "begin\n");
 
    pips_assert("unstructured u is defined", u!=unstructured_undefined);
 
    c = unstructured_control(u);
    if(control_predecessors(c) == NIL && control_successors(c) == NIL) {
        /* there is only one statement and no arcs in u; no need for a
           fix-point */
        pips_debug(8, "unique node\n");
        /* FI: pre should not be duplicated because
         * statement_to_postcondition() means that pre is not
         * going to be changed, just post produced.
         */
        post = statement_to_postcondition(transformer_dup(pre),
                                          control_statement(c));
    }
    else {
        /* Do not try anything clever! God knows what may happen in
           unstructured code. Postcondition post is not computed recursively
           from its components but directly derived from u's transformer.
           Preconditions associated to its components are then computed
           independently, hence the name unstructured_to_postconditionS
           instead of unstructured_to_postcondition */
        /* propagate as precondition an invariant for the whole
           unstructured u assuming that all nodes in the CFG are fully
           connected, unless tf is not feasible because the unstructured
           is never exited or exited thru a call to STOP which invalidates
           the previous assumption. */
      transformer tf_u = transformer_undefined;
      transformer pre_n = transformer_undefined;
 
        pips_debug(8, "complex: based on transformer\n");
        if(transformer_empty_p(tf)) {
          tf_u = unstructured_to_flow_insensitive_transformer(u);
        }
        else {
          tf_u = tf;
        }
        pre_n = invariant_wrt_transformer(pre, tf_u);
        ifdebug(8) {
          pips_debug(8, "filtered over approximated precondition holding for any node pre_n:\n");
          (void) print_transformer(pre_n) ;
        }
        /* FI: I do not know if I should duplicate pre or not. */
        /* FI: well, dumdum, you should have duplicated tf! */
        /* FI: euh... why? According to comments about transformer_apply()
         * neither arguments are modified...
         */
        /* post = unstructured_to_postconditions(pre_n, pre, u); */
        post = unstructured_to_flow_sensitive_postconditions(pre, pre_n, u);
        pips_assert("A valid postcondition is returned",
                    !transformer_undefined_p(post));
        if(transformer_undefined_p(post)) {
          post = transformer_apply(transformer_dup(tf), pre);
        }
        transformer_free(pre_n);
    }
 
    pips_debug(8, "end\n");
 
    return post;
}

References control_predecessors, control_statement, control_successors, ifdebug, invariant_wrt_transformer(), NIL, pips_assert, pips_debug, print_transformer, statement_to_postcondition(), transformer_apply(), transformer_dup(), transformer_empty_p(), transformer_free(), transformer_undefined, transformer_undefined_p, unstructured_control, unstructured_to_flow_insensitive_transformer(), unstructured_to_flow_sensitive_postconditions(), and unstructured_undefined.

Referenced by instruction_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_transformer()

transformer unstructured_to_transformer	(	unstructured	u,
		transformer	e_pre,
		list	e
	)

effects of u

approximate store condition for all control nodes: simple context for improved transformer derivation; it is not a precondition and should have no arguments.

Same as previous one for the store on entry in the unstructured. This the entry node usually has predecessors in the CFG, this is not the context for the entry node. It is not a precondition.

No information available on entrance

Cheapest fix point transformer. The flow insensitive fix point could be used instead.

pre is replaced by its range condition later when needed

Transformers should be computed precisely whether the unstructured is left by the exit node or by an explicit or implicit call to STOP.

computing the transformer for u is like computing the postcondition with no information on entry: no, the input context may be used to refine the transformer.

pre_u is restricted to its range later when needed.

These tests should be performed at the scc level

Not really linked to fix point issue, but a way to know we are using a FAST option.

Do something for nodes unreachable from the entry but linked to the exit

The control flow graph is never exited... by the exit node

The unstructured is never exited, but all nodes are supposed to have transformers. This would never occur if the control restructuration were clean unless an infinite loop is stopped within a called procedure. Control effects are not reported.

FI: pre should be used!

Might be useless because it's now performed just above and more generally by a gen_multi_recurse()

Parameters

e_pre	_pre
e	precondition on entrance

Definition at line 2332 of file unstructured.c.

{
  transformer tf = transformer_undefined;
  list succs = NIL;
  control head = unstructured_control(u);
  control tail = unstructured_exit(u);
  /* approximate store condition for all control nodes: simple context for
     improved transformer derivation; it is not a precondition and should have no
     arguments. */
  transformer pre = transformer_undefined;
  /* Same as previous one for the store on entry in the unstructured. This
     the entry node usually has predecessors in the CFG, this is not the
     context for the entry node. It is not a precondition. */
  transformer pre_u = transformer_undefined;
 
  if(transformer_undefined_p(e_pre)) {
    /* No information available on entrance */
    pre = transformer_identity();
  }
  else {
    /* Cheapest fix point transformer. The flow insensitive fix point
       could be used instead. */
    transformer fpf = effects_to_transformer(e);
 
    /* pre is replaced by its range condition later when needed*/
    pre = transformer_safe_apply(fpf, e_pre);
    free_transformer(fpf);
  }
 
  pips_debug(8,"begin\n");
 
  forward_control_map_get_blocs(head, &succs);
 
  /* Transformers should be computed precisely whether the unstructured is
     left by the exit node or by an explicit or implicit call to STOP. */
  if(true || gen_in_list_p(tail, succs)) {
    /* computing the transformer for u is like computing the postcondition
       with no information on entry: no, the input context may be used to
       refine the transformer. */
 
    if(transformer_undefined_p(e_pre)) {
      pre_u = transformer_identity();
    }
    else {
      /* pre_u is restricted to its range later when needed. */
      pre_u = transformer_dup(e_pre);
    }
 
    /* These tests should be performed at the scc level */
    if(((int)gen_length(succs))>get_int_property("SEMANTICS_MAX_CFG_SIZE2")) {
      semantics_user_warning("\nControl flow graph too large for any analysis (%d nodes)\n"
                        "Have you fully restructured your code?\n", gen_length(succs));
      unstructured_to_transformers(u, pre);
 
      if(!gen_in_list_p(tail, succs)) {
        tf = transformer_empty();
      }
      else {
        tf = effects_to_transformer(e);
      }
    }
    else if(((int)gen_length(succs))>get_int_property("SEMANTICS_MAX_CFG_SIZE1")) {
      semantics_user_warning("\nControl flow graph too large for an accurate analysis (%d nodes)\n"
                        "Have you fully restructured your code?\n", gen_length(succs));
      unstructured_to_transformers(u, pre);
 
      if(!gen_in_list_p(tail, succs)) {
        tf = transformer_empty();
      }
      else {
        tf = unstructured_to_flow_insensitive_transformer(u);
      }
    }
    else if(!get_bool_property("SEMANTICS_ANALYZE_UNSTRUCTURED")) {
      semantics_user_warning("\nControl flow graph not analyzed accurately"
                        " because property SEMANTICS_ANALYZE_UNSTRUCTURED is not set\n");
      unstructured_to_transformers(u, pre);
 
      if(!gen_in_list_p(tail, succs)) {
        tf = transformer_empty();
      }
      else {
        tf = unstructured_to_flow_insensitive_transformer(u);
      }
    }
    else if(!get_bool_property("SEMANTICS_FIX_POINT")) {
      /* Not really linked to fix point issue, but a way to know we are
         using a FAST option. */
      unstructured_to_transformers(u, pre);
 
      if(!gen_in_list_p(tail, succs)) {
        tf = transformer_empty();
      }
      else {
        tf = unstructured_to_flow_insensitive_transformer(u);
      }
    }
    else {
      tf = unstructured_to_flow_sensitive_postconditions_or_transformers
        (pre_u, pre, u, false);
    }
    free_transformer(pre_u);
  }
 
  if(!gen_in_list_p(tail, succs)) {
  /* Do something for nodes unreachable from the entry but linked to the exit */
    /* The control flow graph is never exited... by the exit node */
    /* The unstructured is never exited, but all nodes are supposed to
       have transformers. This would never occur if the control
       restructuration were clean unless an infinite loop is stopped
       within a called procedure. Control effects are not reported. */
    /* FI: pre should be used! */
    gen_multi_recurse(
                      u,
                      statement_domain, gen_false, gen_null,
                      control_domain, gen_true, unreachable_node_to_transformer,
                      NULL);
  }
 
  /* Might be useless because it's now performed just above and more
     generally by a gen_multi_recurse() */
  if(!gen_in_list_p(tail, succs)) {
    pips_assert("if exit is not reached, tf is empty", transformer_empty_p(tf));
    tf = transformer_empty();
  }
 
  gen_free_list(succs);
  free_transformer(pre);
 
  pips_debug(8,"end\n");
 
  return tf;
}

References control_domain, effects_to_transformer(), forward_control_map_get_blocs(), free_transformer(), gen_false(), gen_free_list(), gen_in_list_p(), gen_length(), gen_multi_recurse(), gen_null(), gen_true(), get_bool_property(), get_int_property(), NIL, pips_assert, pips_debug, semantics_user_warning, statement_domain, transformer_dup(), transformer_empty(), transformer_empty_p(), transformer_identity(), transformer_safe_apply(), transformer_undefined, transformer_undefined_p, unreachable_node_to_transformer(), unstructured_control, unstructured_exit, unstructured_to_flow_insensitive_transformer(), unstructured_to_flow_sensitive_postconditions_or_transformers(), and unstructured_to_transformers().

Referenced by instruction_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

update_cycle_temporary_precondition()

void update_cycle_temporary_precondition	(	control	c,
		transformer	pre,
		control_mapping	cycle_temporary_precondition_map
	)

Parameters

pre	re
cycle_temporary_precondition_map	ycle_temporary_precondition_map

Definition at line 1021 of file unstructured.c.

{
  statement s = control_statement(c);
 
  pips_debug(2, "For control %p with statement %s:\n", c, statement_identification(s));
  update_temporary_precondition
    ((void *) c, pre, (hash_table) cycle_temporary_precondition_map);
 
  ifdebug(6) {
    pips_debug(6, "Precondition %p for cycle %p:\n", pre, c);
    print_transformer(pre);
  }
}

References control_statement, ifdebug, pips_debug, print_transformer, statement_identification(), and update_temporary_precondition().

Referenced by cycle_to_flow_sensitive_preconditions(), and dag_to_flow_sensitive_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

update_precondition_with_call_site_preconditions()

transformer update_precondition_with_call_site_preconditions	(	transformer	t,
		entity	caller,
		entity	callee
	)

Update precondition t for callee with preconditions of call sites to callee in caller.

Call sites are found in the statement of caller, but also in its declarations. Return the updated precondition t.

summary effects for the callee

calls hidden in dimension declarations are not caught because entities are not traversed by gen_recurse().

This normalization seems pretty uneffective for fraer01.tpips

Parameters

caller	aller
callee	allee

Definition at line 1371 of file interprocedural.c.

{
  statement caller_statement = (statement) db_get_memory_resource
    (DBR_CODE, module_local_name(caller), true);
  /* summary effects for the callee */
  summary_effects_of_callee = load_summary_effects(callee);
 
  pips_assert("callee is the current module",
              get_current_module_entity() == callee);
 
  entity old_entity = get_current_module_entity();
  statement old_statement = get_current_module_statement();
 
  reset_current_module_entity();
  reset_current_module_statement();
 
  set_current_module_entity(caller);
  set_current_module_statement(caller_statement);
  current_summary_precondition = t;
  current_caller = caller;
  current_callee = callee;
 
  if(use_points_to_p())
    set_pt_to_list( (statement_points_to)
                    db_get_memory_resource(DBR_POINTS_TO,
                                           module_local_name(caller), true) );
 
  set_cumulated_rw_effects((statement_effects)
                           db_get_memory_resource
                           (DBR_CUMULATED_EFFECTS,
                            module_local_name(caller), true));
 
  set_proper_rw_effects((statement_effects)
                           db_get_memory_resource
                           (DBR_PROPER_EFFECTS,
                            module_local_name(caller), true));
 
  set_semantic_map((statement_mapping)
                   db_get_memory_resource
                   (DBR_PRECONDITIONS,
                    module_local_name(caller),
                    true) );
 
  module_to_value_mappings(caller);
 
  /* calls hidden in dimension declarations are not caught because
     entities are not traversed by gen_recurse(). */
  gen_multi_recurse(caller_statement,
                    statement_domain, memorize_precondition_for_summary_precondition, pop_statement_global_stack,
                    call_domain, process_call_for_summary_precondition, gen_null,
                    // FI: to be checked. Should be useless.
                    //statement_domain, process_declaration_for_summary_precondition, gen_null,
                    NULL);
 
  free_value_mappings();
  reset_current_module_entity();
  reset_current_module_statement();
  if(use_points_to_p())
    reset_pt_to_list();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_semantic_map();
  set_current_module_entity(old_entity);
  set_current_module_statement(old_statement);
 
  current_caller = entity_undefined;
  current_callee = entity_undefined;
  current_precondition = transformer_undefined;
  summary_effects_of_callee = list_undefined;
 
  if( ! transformer_defined_p(current_summary_precondition)) {
    // Problem: the initializer pass does not notify pipsmake that the
    // module list, a.k.a. %ALL, has been changed.
    // I do not know how to fix pipsmake. Add a new exception to
    // restart the computation of the requested resource list? How can
    // we combine this one with the pips_user_error() exception?
    pips_user_error("No summary precondition for module \"%s\". The callgraph "
                    "is probably broken because stubs have been generated."
                    "Please (re)compute the call graph,"
                    " e.g. display CALLGRAPH_FILE.\n",
                    entity_name(caller));
  }
 
  /* This normalization seems pretty uneffective for fraer01.tpips */
  t = transformer_normalize(current_summary_precondition, 4);
  current_summary_precondition = transformer_undefined;
 
  return t;
}

References call_domain, callee, current_callee, current_caller, current_precondition, current_summary_precondition, db_get_memory_resource(), entity_name, entity_undefined, free_value_mappings(), gen_multi_recurse(), gen_null(), get_current_module_entity(), get_current_module_statement(), list_undefined, load_summary_effects(), memorize_precondition_for_summary_precondition(), module_local_name(), module_to_value_mappings(), pips_assert, pips_user_error, pop_statement_global_stack(), process_call_for_summary_precondition(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), reset_pt_to_list(), reset_semantic_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), set_pt_to_list(), set_semantic_map(), statement_domain, summary_effects_of_callee, transformer_defined_p(), transformer_normalize(), transformer_undefined, and use_points_to_p().

Referenced by ordinary_summary_precondition(), and summary_total_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

update_statement_postcondition()

void update_statement_postcondition	(	statement	,
		transformer
	)

update_statement_precondition()

void update_statement_precondition	(	statement	,
		transformer
	)

update_statement_semantic()

void update_statement_semantic	(	statement	,
		transformer
	)

update_statement_temporary_precondition()

void update_statement_temporary_precondition	(	statement	s,
		transformer	pre,
		statement_mapping	statement_temporary_precondition_map
	)

Parameters

pre	re
statement_temporary_precondition_map	tatement_temporary_precondition_map

Definition at line 997 of file unstructured.c.

{
  pips_debug(2, "For statement %s:\n", statement_identification(s));
  update_temporary_precondition
    ((void *) s, pre, (hash_table) statement_temporary_precondition_map);
}

References pips_debug, statement_identification(), and update_temporary_precondition().

Referenced by cycle_to_flow_sensitive_preconditions(), and dag_to_flow_sensitive_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

update_statement_total_precondition()

void update_statement_total_precondition	(	statement	,
		transformer
	)

update_statement_transformer()

void update_statement_transformer	(	statement	,
		transformer
	)

Referenced by statement_to_transformer(), and statement_to_transformer_list().

Here is the caller graph for this function:

update_summary_precondition()

void update_summary_precondition	(	entity	e,
		transformer	t
	)

void update_summary_precondition(e, t): t is supposed to be a precondition related to one of e's call sites and translated into e's basis;

the current global precondition for e is replaced by its convex hull with t;

t may be slightly modified by transformer_convex_hull because of bad design (FI)

Definition at line 1390 of file dbm_interface.c.

{
    transformer t_old = transformer_undefined;
    transformer t_new = transformer_undefined;
 
    pips_assert("update_summary_precondition", entity_module_p(e));
 
    debug(8, "update_summary_precondition", "begin\n");
 
    t_old = (transformer)
        db_get_memory_resource(DBR_SUMMARY_PRECONDITION, module_local_name(e),
                               true);
 
    ifdebug(8) {
        debug(8, "update_summary_precondition", " old precondition for %s:\n",
              entity_local_name(e));
        print_transformer(t_old);
    }
 
    if(t_old == transformer_undefined)
        t_new = transformer_dup(t);
    else {
        t_new = transformer_convex_hull(t_old, t);
        transformer_free(t_old);
    }
 
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_PRECONDITION,
                           module_local_name(e),
                           (char*) t_new );
 
    ifdebug(8) {
        debug(8, "update_summary_precondition", "new precondition for %s:\n",
              entity_local_name(e));
        print_transformer(t_new);
        debug(8, "update_summary_precondition", "end\n");
    }
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), entity_local_name(), entity_module_p(), ifdebug, module_local_name(), pips_assert, print_transformer, transformer_convex_hull(), transformer_dup(), transformer_free(), and transformer_undefined.

Here is the call graph for this function:

update_summary_precondition_in_declaration()

void update_summary_precondition_in_declaration	(	expression	e,
		transformer	pre
	)

This function is called to deal with call sites located in initialization expressions carried by declarations.

Parameters

pre

re

Definition at line 1356 of file interprocedural.c.

{
  current_precondition = pre;
  gen_recurse(e,
              call_domain,
              (bool (*)(void *)) process_call_for_summary_precondition,
              gen_null);
}

References call_domain, current_precondition, gen_null(), gen_recurse, and process_call_for_summary_precondition().

Referenced by memorize_precondition_for_summary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

update_temporary_precondition()

void update_temporary_precondition	(	void *	k,
		transformer	pre,
		hash_table	precondition_map
	)

Parameters

pre	re
precondition_map	recondition_map

Definition at line 975 of file unstructured.c.

{
  transformer t_pre = (transformer) hash_get(precondition_map, k);
 
  if(t_pre == (transformer) HASH_UNDEFINED_VALUE) {
    pips_debug(2, "No previous precondition. Current one %p:\n", pre);
    ifdebug(2) print_transformer(pre);
    hash_put(precondition_map, k, (void *) transformer_dup(pre));
  }
  else {
    transformer n_t_pre = transformer_convex_hull(pre, t_pre);
    hash_update(precondition_map, k, (void *) n_t_pre);
    pips_debug(2, "Previous precondition %p:\n", t_pre);
    ifdebug(2) print_transformer(t_pre);
    pips_debug(2, "New precondition %p:\n", n_t_pre);
    ifdebug(2) print_transformer(n_t_pre);
    free_transformer(t_pre);
  }
}

References free_transformer(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_update(), ifdebug, pips_debug, print_transformer, transformer_convex_hull(), and transformer_dup().

Referenced by update_cycle_temporary_precondition(), and update_statement_temporary_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

upwards_vect_rename()

void upwards_vect_rename	(	Pvecteur	v,
		transformer	post
	)

Renaming of variables in v according to transformations occuring later.

If a variable is modified by post, its old value must be used in v

FI: it would probably ne more efficient to scan va and vb than the argument list...

Parameters

post

ost

Definition at line 1062 of file mappings.c.

{
    /* FI: it would probably ne more efficient to
     * scan va and vb than the argument list...
     */
    list modified_values = transformer_arguments(post);
 
    FOREACH(ENTITY, v_new, modified_values) {
        entity v_init = new_value_to_old_value(v_new);
 
        (void) vect_variable_rename(v, (Variable) v_new,
                                    (Variable) v_init);
    }
}

References ENTITY, FOREACH, new_value_to_old_value(), transformer_arguments, and vect_variable_rename().

Referenced by add_declaration_list_information(), add_reference_information(), and transformer_add_integer_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

use_points_to_p()

bool use_points_to_p

(

void

)

Definition at line 565 of file dbm_interface.c.

{
  return use_points_to_information_p;
}

References use_points_to_information_p.

Referenced by update_precondition_with_call_site_preconditions().

Here is the caller graph for this function:

user_call_to_transformer()

transformer user_call_to_transformer	(	entity	f,
		list	pc,
		transformer	pre,
		list	ef
	)

Parameters

pc	c
pre	re
ef	f

Definition at line 2506 of file ri_to_transformers.c.

{
  transformer t_caller = transformer_undefined;
 
  pips_debug(7, "begin\n");
  pips_assert("f is a module", entity_module_p(f));
 
  if(!get_bool_property(SEMANTICS_INTERPROCEDURAL)) {
    t_caller = effects_to_transformer(ef);
  }
  else {
    if(c_module_p(f))
      t_caller = c_user_call_to_transformer(f, pc, pre, ef);
    else
      t_caller = fortran_user_call_to_transformer(f, pc, ef);
  }
  pips_debug(7, "end\n");
  return t_caller;
}

References c_module_p(), c_user_call_to_transformer(), effects_to_transformer(), entity_module_p(), f(), fortran_user_call_to_transformer(), get_bool_property(), pips_assert, pips_debug, SEMANTICS_INTERPROCEDURAL, and transformer_undefined.

Referenced by call_to_transformer(), and expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

user_function_call_to_transformer()

transformer user_function_call_to_transformer	(	entity	e,
		expression	expr,
		transformer	pre
	)

a function call is a call to a non void function in C and to a FUNCTION in Fortran

its precondition

Parameters

expr	a value
pre	a call to a function

Definition at line 1373 of file ri_to_transformers.c.

{
  transformer tf = transformer_undefined;
  call c = expression_call(expr);
  entity f = call_function(c);
 
  if(c_module_p(f))
    tf = c_user_function_call_to_transformer(e, expr, pre);
  else
    tf = fortran_user_function_call_to_transformer(e, expr, pre);
 
  return tf;
}

References c_module_p(), c_user_function_call_to_transformer(), call_function, expression_call(), f(), fortran_user_function_call_to_transformer(), and transformer_undefined.

Referenced by call_to_transformer(), float_call_expression_to_transformer(), integer_call_expression_to_transformer(), logical_expression_to_transformer(), and pointer_call_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

value_mappings_compatible_vector_p()

bool value_mappings_compatible_vector_p

(

Pvecteur

iv

)

transform a vector based on variable entities into a vector based on new value entities when possible; does nothing most of the time; does a little in the presence of equivalenced variables

Ugly because it has a hidden side effect on v to handle Fortran equivalences and because its implementation is dependent on type Pvecteur.

Assume that the value mappings are available (as implied by the function's name!), which may not be true when dealing with call sites.

The variable may denote a constant with compatible type

or a temporary variable

Or a variable value

Or a phi variable, when transformers are computed by the region analysis

Or the vector cannot be used in the semantics analysis

Parameters

iv

v

Definition at line 924 of file mappings.c.

{
  Pvecteur v = iv;
  for(;!VECTEUR_NUL_P(v); v = v->succ) {
    if(vecteur_var(v) != TCST) {
      entity e = (entity) vecteur_var(v);
 
      /* The variable may denote a constant with compatible type */
      if(entity_constant_p(e) && !analyzed_constant_p(e)) {
        return false;
      }
 
      /* or a temporary variable */
      else if(local_temporary_value_entity_p(e)) {
        ;
      }
 
      /* Or a variable value */
      else if(entity_has_values_p(e)) {
        entity new_v = entity_to_new_value(e);
 
        if(new_v != entity_undefined)
          vecteur_var(v) = (Variable) new_v;
        else
          return false;
      }
 
      /* Or a phi variable, when transformers are computed by the
         region analysis */
      else if(variable_phi_p(e)) {
        ;
      }
 
      /* Or the vector cannot be used in the semantics analysis */
      else {
        return false;
      }
    }
  }
  return true;
}

References analyzed_constant_p(), entity_constant_p, entity_has_values_p(), entity_to_new_value(), entity_undefined, local_temporary_value_entity_p(), Svecteur::succ, TCST, variable_phi_p, VECTEUR_NUL_P, and vecteur_var.

Referenced by add_affine_bound_conditions(), add_declaration_list_information(), add_loop_index_exit_value(), add_loop_skip_condition(), add_reference_information(), affine_to_transformer(), integer_divide_to_transformer(), integer_right_shift_to_transformer(), simple_affine_to_transformer(), transformer_add_integer_relation_information(), and transformer_add_loop_index_incrementation().

Here is the call graph for this function:

Here is the caller graph for this function:

value_passing_summary_transformer()

transformer value_passing_summary_transformer	(	entity	f,
		transformer	tf
	)

With value passing, writes on formal parameters are not effective interprocedurally unless an array is passed as parameter.

All new values corresponding to formal arguments of f must be projected out and removed from the arguments list.

Performed by side-effect on tf.

The old values cannot be renamed directly after projection, because the transformer projection opearator detects an inconsistency.

Rename old values as temporary values in the caller frame.

Updates the argument list after the projections

Rename tmp values as new values in the caller frame.

oav renamed oav1 because of FOREACH macro implementation

Parameters

tf

f

Definition at line 1471 of file interprocedural.c.

{
  list al = transformer_arguments(tf); // argument list
  list mfl = NIL; // modified formal list
  list omfl = NIL; // modified formal list
  list tvl = NIL; // temporary value list
  list ctvl = NIL; // current pointer in tvl
 
  FOREACH(ENTITY, a, al) {
    storage s = entity_storage(a);
 
    if(storage_formal_p(s)) {
      formal fs = storage_formal(s);
      if(formal_function(fs)==f) {
        //value v = entity_initial(a);
        if(!location_entity_p(a)) {
          // We are not dealing with a location entity, such as an
          // element of a formal array, which may be written in spite
          // of the value passing scheme
          entity nav = entity_to_new_value(a);
          entity oav = entity_to_old_value(a);
          mfl = CONS(ENTITY, nav, mfl);
          omfl = CONS(ENTITY, oav, omfl);
        }
      }
    }
  }
 
  /* The old values cannot be renamed directly after projection,
     because the transformer projection opearator detects an
     inconsistency. */
 
  /* Rename old values as temporary values in the caller frame. */
  FOREACH(ENTITY, oav, omfl) {
    entity tv = make_local_temporary_value_entity(ultimate_type(entity_type(oav)));
 
    tvl = CONS(ENTITY, tv, tvl);
    tf = transformer_value_substitute(tf, oav, tv);
  }
 
  /* Updates the argument list after the projections */
  tf = transformer_projection(tf, mfl);
 
  /* Rename tmp values as new values in the caller frame. */
  tvl = gen_nreverse(tvl);
  ctvl = tvl;
  /* oav renamed oav1 because of FOREACH macro implementation */
  FOREACH(ENTITY, oav1, omfl) {
    entity tv = ENTITY(CAR(ctvl));
    entity v = value_to_variable(oav1);
    entity nav = entity_to_new_value(v);
 
    tf = transformer_value_substitute(tf, tv, nav);
    POP(ctvl);
  }
 
  gen_free_list(tvl);
 
  return tf;
}

References CAR, CONS, ENTITY, entity_storage, entity_to_new_value(), entity_to_old_value(), entity_type, f(), FOREACH, formal_function, gen_free_list(), gen_nreverse(), location_entity_p(), make_local_temporary_value_entity(), NIL, POP, storage_formal, storage_formal_p, transformer_arguments, transformer_projection(), transformer_value_substitute(), ultimate_type(), and value_to_variable().

Referenced by generic_module_name_to_transformers().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_to_values()

list variable_to_values

(

entity

e

)

Definition at line 982 of file mappings.c.

{
  list list_val = NIL;
 
  if(entity_has_values_p(e)) {
    entity v_old = entity_to_old_value(e);
    entity v_new = entity_to_new_value(e);
 
    list_val = CONS(ENTITY, v_old, list_val);
    list_val = CONS(ENTITY, v_new, list_val);
  }
 
  return list_val;
}

References CONS, ENTITY, entity_has_values_p(), entity_to_new_value(), entity_to_old_value(), and NIL.

Referenced by statement_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

variables_to_new_values()

void variables_to_new_values

(

Pvecteur

v

)

replace variables by new values which is necessary for equivalenced variables

Definition at line 1038 of file mappings.c.

{
  Pvecteur elem = VECTEUR_UNDEFINED;
 
  for(elem = v; !VECTEUR_NUL_P(elem); elem = vecteur_succ(elem)) {
    entity var = (entity) vecteur_var(elem);
 
    if(vecteur_var(elem)!=TCST) {
      entity v_new = entity_to_new_value(var);
 
      if(v_new!=var) {
        (void) vect_variable_rename(v, (Variable) var,
                                    (Variable) v_new);
      }
    }
  }
}

References entity_to_new_value(), TCST, vect_variable_rename(), VECTEUR_NUL_P, vecteur_succ, VECTEUR_UNDEFINED, and vecteur_var.

Referenced by transformer_add_integer_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

variables_to_old_values()

list variables_to_old_values

(

list

list_mod

)

Parameters

list_mod

ist_mod

Definition at line 1024 of file mappings.c.

{
  list list_val = NIL;
 
  MAP(ENTITY, e, {
    entity v_old = entity_to_old_value(e);
 
    list_val = CONS(ENTITY, v_old, list_val);
  }, list_mod);
  return list_val;
}

References CONS, ENTITY, entity_to_old_value(), MAP, and NIL.

Referenced by recompute_loop_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

variables_to_values()

list variables_to_values

(

list

list_mod

)

Parameters

list_mod

ist_mod

Definition at line 966 of file mappings.c.

{
  list list_val = NIL;
 
  FOREACH(ENTITY, e, list_mod) {
    if(entity_has_values_p(e)) {
      entity v_old = entity_to_old_value(e);
      entity v_new = entity_to_new_value(e);
 
      list_val = CONS(ENTITY, v_old, list_val);
      list_val = CONS(ENTITY, v_new, list_val);
    }
  }
  return list_val;
}

References CONS, ENTITY, entity_has_values_p(), entity_to_new_value(), entity_to_old_value(), FOREACH, and NIL.

Referenced by recompute_loop_transformer(), and statement_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

whileloop_to_k_transformer()

transformer whileloop_to_k_transformer	(	whileloop	l,
		transformer	pre,
		list	e,
		int	k
	)

Parameters

pre	re
k	effects of whileloop l

Definition at line 2617 of file loop.c.

{
  transformer t = transformer_undefined;
  evaluation lt = whileloop_evaluation(l);
 
  if(evaluation_before_p(lt))
    t = new_whileloop_to_k_transformer(l, pre, e, k);
  else
    pips_internal_error("repeatloop_to_k_transformer() not implemented.");
    //t = repeatloop_to_k_transformer(l, pre, e);
  return t;
}

References evaluation_before_p, new_whileloop_to_k_transformer(), pips_internal_error, transformer_undefined, and whileloop_evaluation.

Referenced by whileloop_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

whileloop_to_postcondition()

transformer whileloop_to_postcondition	(	transformer	pre,
		whileloop	l,
		transformer	tf
	)

propagate an impossible precondition in the loop body

do not add the exit condition since it is redundant with pre, but take care of side effects in the condition c

transformer_apply() generates a lot of warnings

The loop may be entered at least once.

The standard transformer tb is not enough, especially if the loop body s is a loop since then it is not even the statement transformer, but more generally we do not want the identity to be taken into account in tb since it is already added with P0. So we would like to guarantee that at least one state change occurs: we are not interested in identity iterations. For instance, if s is a loop, this means that the loop is entered, except if the loop condition has side effects.

To recompute this transformer, we use a pre_fuzzy=T*(P0) because we have nothing better.

complete_statement_transformer() is not really useful here because we usually do not have tighly nested while loops.

Nothing special in the loop body: no tests, no while,...

Recompute the body transformer without taking identity transformers into account. This is not enough because the decision about "activity" should be made dimension by dimension. We cannot get good result in general with a convex hull performed here: only specific cases are handled. We need instead a complex formulae to compute the loop precondition as a function of p_0 and all t_i

btl is copied because the function below frees at least its components

The loop fix point transformer T* could be used to obtain the set of stores for any number of iterations, including 0. Instead, use T+ and a convex hull with the precondition for the first iteration, which preserves more information when the fixpoint is not precise:

P^* = P_0 U cond(c)(tb(cond(c)(tb^*(P_0))))

Bertrand Jeannet suggests that we compute P0 U T(P0) U T^2(P0) U T_3(P0) where T_3 is the transitive closure obtained for iterations 3 to infinity by setting the initial iteration number k to 3 before projection. NSAD 2010. No test case has been forwarded to show that this would be useful.

We need the loop effects to recompute the unrolled transformer. Let's use NIL to start with... disaster. Let's use the body effects and hope for no side effects in loop condition.

FI: since pre_next is no longer useful, pre_next2 could be avoided. It just makes debugging easier.

propagate preconditions in the loop body and get its postcondition

At least one iteration is executed. The postcondition can be computed into three different ways:

• use the loop body postcondition and apply the loop exit condition transformer or precondition_add_condition_information;
• or use the loop precondition, the loop transformer, the loop entry condition, the loop body transformer and the loop exit transformer;

or use both and use their intersection as unique postcondition (the added redundant information seems to result in less information after a projection for w09.f, Halbwachs car example).

The second way is more likely to suffer from non-convexity as it uses many more steps.

Also, note that precondition_add_condition_information() is more geared towards Fortran as it assumes no side effects in the condition evaluation. However, it is better at handling non-convex condition than condition_to_transformer(), but condition_to_transformer(), which is built on top of precondition_add_condition_information() could be improved/might be improvable... In case the condition is not convex, there is no single transformer which fits it. But the postcondition can be updated with different convex components and then different results united in a unique postcondition by a convex hull.

Let's execute the last iteration since it certainly exists

Assume the loop is entered, post_al, or not, post_ne, and perform the convex hull of both

The loop is executed at least once: let's execute the last iteration

The loop is never executed

Parameters

pre	re
tf	f

Definition at line 3141 of file loop.c.

{
  transformer post = transformer_undefined;
  statement s = whileloop_body(l);
  expression c = whileloop_condition(l);
 
  pips_debug(8, "begin\n");
 
  if(pips_flag_p(SEMANTICS_FIX_POINT)
     && pips_flag_p(SEMANTICS_INEQUALITY_INVARIANT)) {
    pips_internal_error("Halbwachs not implemented");
  }
 
  if(false_condition_wrt_precondition_p(c, pre)) {
    transformer c_t = condition_to_transformer(c, pre, false);
    pips_debug(8, "The loop is never executed\n");
 
    /* propagate an impossible precondition in the loop body */
    (void) statement_to_postcondition(transformer_empty(), s);
    /* do not add the exit condition since it is redundant with pre,
       but take care of side effects in the condition c */
    /* transformer_apply() generates a lot of warnings */
    post = transformer_combine(copy_transformer(pre), c_t);
    //post = transformer_apply(c_t, pre);
    free_transformer(c_t);
  }
  else { /* The loop may be entered at least once. */
    transformer pre_next = transformer_dup(pre);
    transformer pre_init =
      precondition_add_condition_information(transformer_dup(pre),
                                             c, pre, true);
    // FI: this should work but is not compatible with the following
    //code; by definition, tf also include the side effect of pre
    //transformer pre_init = transformer_apply(c_t, pre);
    transformer preb = transformer_undefined; // body precondition
    transformer postb = transformer_undefined; // body postcondition
    transformer tb = load_statement_transformer(s); // body transformer
    int k = get_int_property("SEMANTICS_K_FIX_POINT");
 
    /* The standard transformer tb is not enough, especially if the
       loop body s is a loop since then it is not even the statement
       transformer, but more generally we do not want the identity to
       be taken into account in tb since it is already added with
       P0. So we would like to guarantee that at least one state change
       occurs: we are not interested in identity iterations. For
       instance, if s is a loop, this means that the loop is entered,
       except if the loop condition has side effects.
 
       To recompute this transformer, we use a pre_fuzzy=T*(P0)
       because we have nothing better.
 
       complete_statement_transformer() is not really useful here
       because we usually do not have tighly nested while loops.
    */
    transformer pre_fuzzy = transformer_apply(tf, pre);
    //tb = complete_non_identity_statement_transformer(tb, pre_fuzzy, s);
    list btl = list_undefined;
    int fbtll = 0;
 
    if(get_bool_property("SEMANTICS_USE_TRANSFORMER_LISTS")) {
      list fbtl = statement_to_transformer_list(s, pre_fuzzy);
      fbtll = (int) gen_length(fbtl);
      // filter out transformers that do not modify the state
      // FI: this is not a general approach since it depends on the
      // framework used and on the other variables, but it helps!
      btl = transformer_list_to_active_transformer_list(fbtl);
      gen_full_free_list(fbtl);
 
      if(gen_length(btl)==0) {
        tb = empty_transformer(transformer_identity());
      }
      else if(gen_length(btl)==1) {
        /* Nothing special in the loop body: no tests, no while,... */
        if(fbtll==1)
          tb = complete_statement_transformer(tb, pre_fuzzy, s);
        else
          // FI: not to sure about reuse and memory leaks...
          tb = copy_transformer(TRANSFORMER(CAR(btl)));
      }
      else {
        /* Recompute the body transformer without taking identity
           transformers into account. This is not enough because the
           decision about "activity" should be made dimension by
           dimension. We cannot get good result in general with a
           convex hull performed here: only specific cases are
           handled. We need instead a complex formulae to compute the
           loop precondition as a function of p_0 and all t_i*/
        /* btl is copied because the function below frees at least
           its components */
        tb = active_transformer_list_to_transformer(gen_full_copy_list(btl));
      }
    }
    else {
      tb = complete_statement_transformer(tb, pre_fuzzy, s);
    }
 
    pips_debug(8, "The loop may be executed and preconditions must"
               " be propagated in the loop body\n");
 
    if(k==1) {
      if(!get_bool_property("SEMANTICS_USE_TRANSFORMER_LISTS")
         || gen_length(btl)==1) {
        /* The loop fix point transformer T* could be used to obtain the
         * set of stores for any number of iterations, including
         * 0. Instead, use T+ and a convex hull with the precondition for
         * the first iteration, which preserves more information when the
         * fixpoint is not precise:
         *
         * P^* = P_0 U cond(c)(tb(cond(c)(tb^*(P_0))))
         *
         * Bertrand Jeannet suggests that we compute P0 U T(P0) U
         * T^2(P0) U T_3(P0) where T_3 is the transitive closure
         * obtained for iterations 3 to infinity by setting the initial
         * iteration number k to 3 before projection. NSAD 2010. No test
         * case has been forwarded to show that this would be useful.
         */
        // FI: I do not know why pre_next==pre is used instead of
        // pre_init==P_0 in the statement just below
        pre_next = transformer_combine(pre_next, tf);
        pre_next = precondition_add_condition_information(pre_next, c,
                                                          pre_next, true);
        pre_next = transformer_combine(pre_next, tb);
        pre_next = precondition_add_condition_information(pre_next, c,
                                                          pre_next, true);
        preb = transformer_convex_hull(pre_init, pre_next);
      }
      else { // transformer lists are used and at least two
             // transformers have been found
        transformer c_t = condition_to_transformer(c, pre_fuzzy, true);
        //transformer preb1 = transformer_list_closure_to_precondition(btl, c_t, pre_init);
        transformer preb1 = transformer_list_multiple_closure_to_precondition(btl, c_t, pre_init);
        //pre_next = transformer_combine(pre_next, tf);
        //pre_next = precondition_add_condition_information(pre_next, c,
        //                                                pre_next, true);
      //pre_next = transformer_combine(pre_next, tb);
      //pre_next = precondition_add_condition_information(pre_next, c,
        //                                        pre_next, true);
    //transformer preb2 = transformer_convex_hull(pre_init, pre_next);
    //pips_assert("The two preconditions have the same arguments",
    //              arguments_equal_p(transformer_arguments(preb1),
    //                        transformer_arguments(preb2)));
        // FI: the intersection generates overflows
        //preb = transformer_intersection(preb1, preb2);
        preb = preb1;
      }
    }
    else if (k==2) {
      /* We need the loop effects to recompute the unrolled
         transformer. Let's use NIL to start with... disaster.
         Let's use the body effects and hope for no side effects in
         loop condition.
      */
      list bel = load_cumulated_rw_effects_list(s); // Should be lel
      transformer tf2 = whileloop_to_k_transformer(l, pre, bel, 2);
      transformer pre_next2 = transformer_undefined;
      pre_next = transformer_combine(pre_next, tf2);
      pre_next = precondition_add_condition_information(pre_next, c,
                                                        pre_next, true);
      pre_next = transformer_combine(pre_next, tb);
      pre_next = precondition_add_condition_information(pre_next, c,
                                                        pre_next, true);
      preb = transformer_convex_hull(pre_init, pre_next);
 
      /* FI: since pre_next is no longer useful, pre_next2 could be
         avoided. It just makes debugging easier. */
      pre_next2 = copy_transformer(pre_next);
      pre_next2 = precondition_add_condition_information(pre_next2, c,
                                                         pre_next2, true);
      pre_next2 = transformer_combine(pre_next2, tb);
      pre_next2 = precondition_add_condition_information(pre_next2, c,
                                                         pre_next2, true);
      preb = transformer_convex_hull(preb, pre_next2);
      free_transformer(tf2);
      free_transformer(pre_next2);
    }
    else
      pips_user_error("Unexpected value %d for k.\n", k);
 
    free_transformer(pre_fuzzy);
 
    /* propagate preconditions in the loop body and get its postcondition */
 
    postb = statement_to_postcondition(preb, s);
 
    if(true_condition_wrt_precondition_p(c, pre)) {
      /* At least one iteration is executed. The postcondition can be
       * computed into three different ways:
       *
       *  - use the loop body postcondition and apply the loop exit
       * condition transformer or precondition_add_condition_information;
       *
       *  - or use the loop precondition, the loop transformer, the loop
       * entry condition, the loop body transformer and the loop exit
       * transformer;
       *
       * - or use both and use their intersection as unique
       * postcondition (the added redundant information seems to
       * result in *less* information after a projection for w09.f,
       * Halbwachs car example).
       *
       * The second way is more likely to suffer from non-convexity as
       * it uses many more steps.
       *
       * Also, note that precondition_add_condition_information() is
       * more geared towards Fortran as it assumes no side effects in
       * the condition evaluation. However, it is better at handling
       * non-convex condition than condition_to_transformer(), but
       * condition_to_transformer(), which is built on top of
       * precondition_add_condition_information() could be
       * improved/might be improvable... In case the condition is not
       * convex, there is no single transformer which fits it. But the
       * postcondition can be updated with different convex components
       * and then different results united in a unique postcondition
       * by a convex hull.
       */
 
      pips_debug(8, "The loop certainly is executed.\n");
 
      if(false) {
        transformer ntl = transformer_undefined;
        transformer cpost = transformer_undefined; // combined postcondition
        ntl = transformer_apply(tf, pre);
        /* Let's execute the last iteration since it certainly exists */
        ntl = precondition_add_condition_information(ntl, c, ntl, true);
        post = transformer_apply(tb, ntl);
        free_transformer(ntl);
        post = precondition_add_condition_information(post, c, post, false);
 
        postb = precondition_add_condition_information(postb, c, postb, false);
 
        cpost = transformer_intersection(post, postb);
 
        free_transformer(post);
        free_transformer(postb);
 
        post = cpost;
      }
      else {
        // FI: does not work with side effects
        //post = precondition_add_condition_information(postb, c, postb, false);
        transformer pre_c = transformer_range(postb);
        transformer ctf = condition_to_transformer(c, pre_c, false);
        post = transformer_apply(ctf, postb);
        free_transformer(pre_c);
        free_transformer(ctf);
      }
    }
    else {
      /* Assume the loop is entered, post_al, or not, post_ne, and perform
       * the convex hull of both
       */
      transformer post_ne = transformer_dup(pre);
      transformer post_al = transformer_undefined;
      //transformer tb = load_statement_transformer(s);
 
      pips_debug(8, "The loop may be executed or not\n");
 
      /* The loop is executed at least once: let's execute the last iteration */
      //post_al = transformer_apply(tb, preb);
 
        // FI: does not work with side effects
        //post = precondition_add_condition_information(postb, c, postb, false);
        transformer pre_c = transformer_range(postb);
        transformer ctf = condition_to_transformer(c, pre_c, false);
        // Mmeory leak? Do we still need postb?
        post_al = transformer_apply(ctf, postb);
        free_transformer(pre_c);
        free_transformer(ctf);
        // post_al = precondition_add_condition_information(postb, c, postb, false);
 
      /* The loop is never executed */
        // FI: does not work with side effects
        // post_ne = precondition_add_condition_information(post_ne, c, post_ne, false);
        pre_c = transformer_range(post_ne);
        ctf = condition_to_transformer(c, pre_c, false);
        // Mmeory leak
        post_ne = transformer_apply(ctf, post_ne);
        free_transformer(pre_c);
        free_transformer(ctf);
 
      post = transformer_convex_hull(post_ne, post_al);
      // free for postb too? hidden within post_al?
      transformer_free(post_ne);
      transformer_free(post_al);
    }
  }
 
  ifdebug(8) {
    pips_debug(8, "resultat post =");
    (void) print_transformer(post);
  }
  pips_debug(8, "end\n");
  return post;
}

References active_transformer_list_to_transformer(), CAR, complete_statement_transformer(), condition_to_transformer(), copy_transformer(), empty_transformer(), false_condition_wrt_precondition_p(), free_transformer(), gen_full_copy_list(), gen_full_free_list(), gen_length(), get_bool_property(), get_int_property(), ifdebug, int, list_undefined, load_cumulated_rw_effects_list(), load_statement_transformer(), pips_debug, pips_flag_p, pips_internal_error, pips_user_error, precondition_add_condition_information(), print_transformer, SEMANTICS_FIX_POINT, SEMANTICS_INEQUALITY_INVARIANT, statement_to_postcondition(), statement_to_transformer_list(), TRANSFORMER, transformer_apply(), transformer_combine(), transformer_convex_hull(), transformer_dup(), transformer_empty(), transformer_free(), transformer_identity(), transformer_intersection(), transformer_list_multiple_closure_to_precondition(), transformer_list_to_active_transformer_list(), transformer_range(), transformer_undefined, true_condition_wrt_precondition_p(), whileloop_body, whileloop_condition, and whileloop_to_k_transformer().

Referenced by instruction_to_postcondition().

Here is the call graph for this function:

Here is the caller graph for this function:

whileloop_to_total_precondition()

transformer whileloop_to_total_precondition	(	transformer	t_post,
		whileloop	l,
		transformer	tf,
		transformer	context
	)

transformer_dup(pre)

Apply the loop fix point transformer T* to obtain the set of stores for any number of iteration, including 0.

propagate an impossible precondition in the loop body

The loop body precondition is not useful any longer

do not add the exit condition since it is redundant with pre

post = transformer_dup(pre);

At least one iteration is executed. The transformer of the loop body is not useful!

transformer tb = load_statement_transformer(s);

propagate preconditions in the loop body

ntl = transformer_apply(tf, pre);

Let's execute the last iteration since it certainly exists

post = transformer_apply(tb, ntl);

post = precondition_add_condition_information(post, c, post, false);

Assume the loop is entered, post_al, or not, post_ne, and perform the convex hull of both

= transformer_dup(pre)

propagate preconditions in the loop body

The loop is executed at least once: let's execute the last iteration

The loop is never executed

post = transformer_convex_hull(post_ne, post_al);

Parameters

t_post	_post
tf	f
context	ontext

Definition at line 3439 of file loop.c.

{
  transformer t_pre = transformer_undefined;
  statement s = whileloop_body(l);
  expression c = whileloop_condition(l);
 
  pips_assert("not implemented yet", false && t_post==t_post);
 
  pips_debug(8,"begin\n");
 
  if(pips_flag_p(SEMANTICS_FIX_POINT) && pips_flag_p(SEMANTICS_INEQUALITY_INVARIANT)) {
    pips_internal_error("Halbwachs not implemented");
  }
  else {
    transformer preb = transformer_undefined /*= transformer_dup(pre)*/ ;
 
    /* Apply the loop fix point transformer T* to obtain the set of stores
     * for any number of iteration, including 0.
     */
    preb = transformer_combine(preb, tf);
 
    if(false_condition_wrt_precondition_p(c, context)) {
      pips_debug(8, "The loop is never executed\n");
 
      /* propagate an impossible precondition in the loop body */
      (void) statement_to_postcondition(transformer_empty(), s);
      /* The loop body precondition is not useful any longer */
      free_transformer(preb);
      /* do not add the exit condition since it is redundant with pre */
      /* post = transformer_dup(pre); */
    }
    else if(true_condition_wrt_precondition_p(c, context)) {
      /* At least one iteration is executed. The transformer of
       * the loop body is not useful!
       */
      /* transformer tb = load_statement_transformer(s); */
      transformer ntl = transformer_undefined;
 
      pips_debug(8, "The loop certainly is executed\n");
 
      /* propagate preconditions in the loop body */
      preb = precondition_add_condition_information(preb, c, preb, true);
      (void) statement_to_postcondition(preb, s);
 
      /* ntl = transformer_apply(tf, pre); */
      /* Let's execute the last iteration since it certainly exists */
      ntl = precondition_add_condition_information(ntl, c, ntl, true);
      /* post = transformer_apply(tb, ntl); */
      free_transformer(ntl);
      /* post = precondition_add_condition_information(post, c, post, false); */
    }
    else {
      /* Assume the loop is entered, post_al, or not, post_ne, and perform
       * the convex hull of both
       */
      transformer post_ne = transformer_undefined /* = transformer_dup(pre) */ ;
      transformer post_al = transformer_undefined;
      transformer tb = load_statement_transformer(s);
 
      pips_debug(8, "The loop may be executed or not\n");
 
      /* propagate preconditions in the loop body */
      precondition_add_condition_information(preb, c, preb, true);
      (void) statement_to_postcondition(preb, s);
 
      /* The loop is executed at least once: let's execute the last iteration */
      post_al = transformer_apply(tb, preb);
      post_al = precondition_add_condition_information(post_al, c, post_al, false);
 
      /* The loop is never executed */
      post_ne = precondition_add_condition_information(post_ne, c, post_ne, false);
 
      /* post = transformer_convex_hull(post_ne, post_al); */
      transformer_free(post_ne);
      transformer_free(post_al);
    }
  }
 
  ifdebug(8) {
    pips_debug(8, "resultat t_pre=%p\n", t_pre);
    (void) print_transformer(t_pre);
    pips_debug(8,"end\n");
  }
 
  return t_pre;
}

References false_condition_wrt_precondition_p(), free_transformer(), ifdebug, load_statement_transformer(), pips_assert, pips_debug, pips_flag_p, pips_internal_error, precondition_add_condition_information(), print_transformer, SEMANTICS_FIX_POINT, SEMANTICS_INEQUALITY_INVARIANT, statement_to_postcondition(), transformer_apply(), transformer_combine(), transformer_empty(), transformer_free(), transformer_undefined, true_condition_wrt_precondition_p(), whileloop_body, and whileloop_condition.

Referenced by instruction_to_total_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

whileloop_to_transformer()

transformer whileloop_to_transformer	(	whileloop	l,
		transformer	pre,
		list	e
	)

effects of whileloop l

Parameters

pre

re

Definition at line 2583 of file loop.c.

{
  transformer t = transformer_undefined;
  evaluation lt = whileloop_evaluation(l);
 
  if(evaluation_before_p(lt))
    t = new_whileloop_to_transformer(l, pre, e);
  else
    t = repeatloop_to_transformer(l, pre, e);
  return t;
}

References evaluation_before_p, new_whileloop_to_transformer(), repeatloop_to_transformer(), transformer_undefined, and whileloop_evaluation.

Referenced by instruction_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

words_predicate_to_commentary()

text words_predicate_to_commentary	(	list	w_pred,
		string	comment_prefix
	)

text words_predicate_to_commentary(list w_pred, string comment_prefix) input : a list of strings, one of them representing a predicate.

output : a text of several lines of commentaries containing this list of strings, and beginning with comment_prefix. modifies : nothing.

str_pred is the string corresponding to the concatenation of the strings in w_pred

Parameters

w_pred	_pred
comment_prefix	omment_prefix

Definition at line 653 of file prettyprint.c.

{
  string str_pred;
  text t_pred;
 
  /* str_pred is the string corresponding to the concatenation
   * of the strings in w_pred */
  str_pred = words_to_string(w_pred);
 
  t_pred = string_predicate_to_commentary(str_pred, comment_prefix);
 
  return(t_pred);
}

References string_predicate_to_commentary(), and words_to_string().

Referenced by print_any_reductions(), text_comp_region(), text_points_to(), and text_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

refine_transformers_p

bool refine_transformers_p

extern

Transformer recomputation cannot be of real use unless an interprocedural analysis is performed.

For intraprocedural analyses, using property SEMANTICS_COMPUTE_TRANSFORMERS_IN_CONTEXT is sufficient.

Definition at line 198 of file semantics.h.

Referenced by process_ready_node(), refine_transformers(), refine_transformers_with_points_to(), statement_to_transformer(), and statement_to_transformer_list().