This graph shows which files directly or indirectly include this file:

Data Structures
struct	pv_context
	pv_context is a structure holding the methods to use during pointer values analyses More...

struct	pv_results
	pv_results is a structure holding the different results of an expression pointer values analysis More...

Macros
#define	pips_debug_pv_results(level, message, pv_res)

Functions
bool	pv_undefined_p (void)
	cproto-generated files More...

void	reset_pv (void)

void	error_reset_pv (void)

void	set_pv (statement_cell_relations)

statement_cell_relations	get_pv (void)

void	init_pv (void)

void	close_pv (void)

void	store_pv (statement, cell_relations)

void	update_pv (statement, cell_relations)

cell_relations	load_pv (statement)

cell_relations	delete_pv (statement)

bool	bound_pv_p (statement)

void	store_or_update_pv (statement, cell_relations)

bool	gen_pv_undefined_p (void)

void	reset_gen_pv (void)

void	error_reset_gen_pv (void)

void	set_gen_pv (statement_cell_relations)

statement_cell_relations	get_gen_pv (void)

void	init_gen_pv (void)

void	close_gen_pv (void)

void	store_gen_pv (statement, cell_relations)

void	update_gen_pv (statement, cell_relations)

cell_relations	load_gen_pv (statement)

cell_relations	delete_gen_pv (statement)

bool	bound_gen_pv_p (statement)

void	store_or_update_gen_pv (statement, cell_relations)

bool	kill_pv_undefined_p (void)

void	reset_kill_pv (void)

void	error_reset_kill_pv (void)

void	set_kill_pv (statement_effects)

statement_effects	get_kill_pv (void)

void	init_kill_pv (void)

void	close_kill_pv (void)

void	store_kill_pv (statement, effects)

void	update_kill_pv (statement, effects)

effects	load_kill_pv (statement)

effects	delete_kill_pv (statement)

bool	bound_kill_pv_p (statement)

void	store_or_update_kill_pv (statement, effects)

statement_cell_relations	db_get_simple_pv (const char *)
	I don't know how to deal with these mappings if we have to analyse several modules at the same time when performing an interprocedural analysis. More...

void	db_put_simple_pv (const char *, statement_cell_relations)

list	db_get_in_simple_pv (const char *)

void	db_put_in_simple_pv (const char *, list)

list	db_get_out_simple_pv (const char *)

void	db_put_out_simple_pv (const char *, list)

list	db_get_initial_simple_pv (const char *)

void	db_put_initial_simple_pv (const char *, list)

list	db_get_program_simple_pv (void)

void	db_put_program_simple_pv (list)

pv_context	make_simple_pv_context (void)

void	reset_pv_context (pv_context *)

void	pv_context_statement_push (statement, pv_context *)

void	pv_context_statement_pop (pv_context *)

statement	pv_context_statement_head (pv_context *)

pv_results	make_pv_results (void)

void	free_pv_results_paths (pv_results *)

void	print_pv_results (pv_results)

list	make_anywhere_anywhere_pvs (void)

void	range_to_post_pv (range, list, pv_results , pv_context )

void	expression_to_post_pv (expression, list, pv_results , pv_context )

void	single_pointer_assignment_to_post_pv (effect, list, list, bool, list, pv_results , pv_context )

void	multiple_pointer_assignment_to_post_pv (effect, type, list, list, bool, list, pv_results , pv_context )

void	assignment_to_post_pv (expression, bool, expression, bool, list, pv_results , pv_context )

bool	simple_pointer_values (const string)
	interface to compute the simple pointer values of a given module More...

bool	initial_simple_pointer_values (const string)

bool	program_simple_pointer_values (const string)

list	make_simple_pv_from_simple_effects (effect, effect, cell_interpretation, list)
	pointer_values_operators.c More...

list	kill_pointer_values (list, list, pv_context *)
	eliminate the cells of l_kill from l_in More...

list	kill_pointer_value (effect, list, pv_context *)
	eliminate the cell of eff_kill from l_in More...

cell_relation	simple_pv_translate (cell_relation, bool, cell_relation)

list	effect_find_equivalent_pointer_values (effect, list, cell_relation , list )
	find pointer_values in l_in which give (possible or exact) paths equivalent to eff. More...

list	effect_find_aliased_paths_with_pointer_values (effect, list, pv_context *)
	find all paths equivalent to eff cell in l_pv by performing a transitive closure More...

void	pointer_values_remove_var (entity, bool, list, pv_results , pv_context )

cell_relation	simple_pv_composition_with_transformer (cell_relation, transformer)

list	pvs_composition_with_transformer (list, transformer, pv_context *)

list	cell_relation_to_list (cell_relation)

list	cell_relation_to_may_list (cell_relation)

list	simple_pv_must_union (cell_relation, cell_relation)

list	simple_pv_may_union (cell_relation, cell_relation)

bool	pvs_union_combinable_p (cell_relation, cell_relation)

list	simple_pvs_must_union (list, list)

list	simple_pvs_may_union (list, list)

bool	simple_pvs_syntactically_equal_p (list, list)

void	intrinsic_to_post_pv (entity, list, list, pv_results , pv_context )
	pointer_values_intrinsics.c More...

text	text_pv (entity, int, statement)
	prettyprint.c More...

bool	generic_print_code_pv (char , pv_context )

bool	print_code_simple_pointer_values (char *)

void	generic_print_code_gen_kill_pv (char *)

bool	print_code_simple_gen_kill_pointer_values (char *)

Macro Definition Documentation

◆ pips_debug_pv_results

#define pips_debug_pv_results	(	level,
		message,
		pv_res
	)

Value:

ifdebug(level) { pips_debug(level, "%s\n", message); \

print_pv_results(pv_res);}

pips_debug

#define pips_debug

these macros use the GNU extensions that allow variadic macros, including with an empty list.

Definition: misc-local.h:145

level

#define level

ifdebug

#define ifdebug(n)

Definition: sg.c:47

_newgen_struct_message_

Definition: message.h:65

Definition at line 91 of file pointer_values.h.

Function Documentation

◆ assignment_to_post_pv()

void assignment_to_post_pv	(	expression	lhs,
		bool	may_lhs_p,
		expression	rhs,
		bool	declaration_p,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

first convert the rhs and lhs into memory paths, rhs is evaluated first

this is done even if this is a non-pointer assignment, becasue there maybe side effects on alising hidden in sub-expressions, function calls...

we should test here that lhs_pv_res.result_paths has only one element. well is it correct? can a relational operator expression be a lhs ?

l_gen = NIL; l_kill = NIL;

simple case first: lhs is a pointer

hidden pointer assignments

if (type_variable_p(lhs_type)

Parameters

lhs	hs
may_lhs_p	ay_lhs_p
rhs	hs
declaration_p	eclaration_p
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 1582 of file pointer_values_analyses.c.

 {
   list l_in_cur = NIL;
   effect lhs_eff = effect_undefined;
  
   pips_debug(1, "begin with may_lhs_p = %s and declaration_p = %s\n", bool_to_string(may_lhs_p), bool_to_string(declaration_p));
   pips_debug_pvs(2, "input pointer values:\n", l_in);
   type lhs_type = expression_to_type(lhs);
  
   /* first convert the rhs and lhs into memory paths, rhs is evaluated first */
   /* this is done even if this is a non-pointer assignment, becasue there
      maybe side effects on alising hidden in sub-expressions, function calls...
   */
   pv_results lhs_pv_res = make_pv_results();
   pv_results rhs_pv_res = make_pv_results();
  
   expression_to_post_pv(rhs, l_in, &rhs_pv_res, ctxt);
   list l_rhs_eff = rhs_pv_res.result_paths;
   list l_rhs_kind = rhs_pv_res.result_paths_interpretations;
   l_in_cur = rhs_pv_res.l_out;
  
   expression_to_post_pv(lhs, l_in_cur, &lhs_pv_res, ctxt);
   l_in_cur = lhs_pv_res.l_out;
   /* we should test here that lhs_pv_res.result_paths has only one element.
      well is it correct? can a relational operator expression be a lhs ?
   */
   lhs_eff = EFFECT(CAR(lhs_pv_res.result_paths));
   if (may_lhs_p) effect_to_may_effect(lhs_eff);
   pv_res->result_paths = CONS(EFFECT, copy_effect(lhs_eff), NIL);
   pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION,
                                               make_cell_interpretation_value_of(), NIL);
  
   if (type_fundamental_basic_p(lhs_type) || !basic_concrete_type_leads_to_pointer_p(lhs_type))
     {
       pips_debug(2, "non-pointer assignment\n");
       /* l_gen = NIL; l_kill = NIL; */
       pv_res->l_out = l_in_cur;
     }
   else
     {
       if(type_variable_p(lhs_type))
         {
           if (pointer_type_p(lhs_type)) /* simple case first: lhs is a pointer */
             {
               single_pointer_assignment_to_post_pv(lhs_eff, l_rhs_eff,
                                                        l_rhs_kind,
                                                        declaration_p, l_in_cur,
                                                        pv_res, ctxt);
             }
           else /* hidden pointer assignments */
             {
               multiple_pointer_assignment_to_post_pv(lhs_eff, lhs_type, l_rhs_eff,
                                                          l_rhs_kind,
                                                          declaration_p, l_in_cur,
                                                          pv_res, ctxt);
             }
         } /* if (type_variable_p(lhs_type) */
       else if(type_functional_p(lhs_type))
         {
           pips_internal_error("not yet implemented");
         }
       else
         pips_internal_error("unexpected_type");
     }
  
  
   free_pv_results_paths(&lhs_pv_res);
   free_pv_results_paths(&rhs_pv_res);
  
   pips_debug_pv_results(1, "end with pv_res =\n", *pv_res);
   return;
 }

References basic_concrete_type_leads_to_pointer_p(), bool_to_string(), CAR, CELL_INTERPRETATION, CONS, copy_effect(), EFFECT, effect_to_may_effect(), effect_undefined, expression_to_post_pv(), expression_to_type(), free_pv_results_paths(), pv_results::l_out, make_cell_interpretation_value_of(), make_pv_results(), multiple_pointer_assignment_to_post_pv(), NIL, pips_debug, pips_debug_pv_results, pips_debug_pvs, pips_internal_error, pointer_type_p(), pv_results::result_paths, pv_results::result_paths_interpretations, single_pointer_assignment_to_post_pv(), type_functional_p, type_fundamental_basic_p(), and type_variable_p.

Referenced by assignment_intrinsic_to_post_pv(), declaration_to_post_pv(), and pointer_values_remove_var().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bound_gen_pv_p()

bool bound_gen_pv_p ( statement )

◆ bound_kill_pv_p()

bool bound_kill_pv_p ( statement )

◆ bound_pv_p()

bool bound_pv_p ( statement )

Referenced by sequence_to_post_pv(), and statement_to_post_pv().

Here is the caller graph for this function:

◆ cell_relation_to_list()

list cell_relation_to_list ( cell_relation cr )

Parameters

cr r

Definition at line 800 of file pointer_values_operators.c.

 {
   return CONS(CELL_RELATION, cr, NIL);
 }

References CELL_RELATION, CONS, and NIL.

Referenced by simple_pvs_must_union().

Here is the caller graph for this function:

◆ cell_relation_to_may_list()

list cell_relation_to_may_list ( cell_relation cr )

Parameters

cr r

Definition at line 805 of file pointer_values_operators.c.

 {
   cell_relation_approximation_tag(cr) = is_approximation_may;
   return CONS(CELL_RELATION, cr, NIL);
 }

References CELL_RELATION, cell_relation_approximation_tag, CONS, is_approximation_may, and NIL.

Referenced by simple_pvs_may_union().

Here is the caller graph for this function:

◆ close_gen_pv()

void close_gen_pv ( void )

◆ close_kill_pv()

void close_kill_pv ( void )

◆ close_pv()

void close_pv ( void )

◆ db_get_in_simple_pv()

list db_get_in_simple_pv ( const char * module_name )

Parameters

module_name odule_name

Definition at line 73 of file pointer_values_analyses.c.

 {
   return (list) cell_relations_list((cell_relations) db_get_memory_resource(DBR_IN_SIMPLE_POINTER_VALUES, module_name, true));
 }

References cell_relations_list, db_get_memory_resource(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_get_initial_simple_pv()

list db_get_initial_simple_pv ( const char * module_name )

Parameters

module_name odule_name

Definition at line 93 of file pointer_values_analyses.c.

 {
   return cell_relations_list((cell_relations) db_get_memory_resource(DBR_INITIAL_SIMPLE_POINTER_VALUES, module_name, true));
 }

References cell_relations_list, db_get_memory_resource(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_get_out_simple_pv()

list db_get_out_simple_pv ( const char * module_name )

Parameters

module_name odule_name

Definition at line 83 of file pointer_values_analyses.c.

 {
   return cell_relations_list((cell_relations) db_get_memory_resource(DBR_OUT_SIMPLE_POINTER_VALUES, module_name, true));
 }

References cell_relations_list, db_get_memory_resource(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_get_program_simple_pv()

list db_get_program_simple_pv ( void )

Definition at line 103 of file pointer_values_analyses.c.

 {
   return cell_relations_list((cell_relations) db_get_memory_resource(DBR_PROGRAM_SIMPLE_POINTER_VALUES, "", true));
 }

References cell_relations_list, and db_get_memory_resource().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_get_simple_pv()

statement_cell_relations db_get_simple_pv ( const char * module_name )

I don't know how to deal with these mappings if we have to analyse several modules at the same time when performing an interprocedural analysis.

We may need a stack of mappings, or a global mapping for the whole program, and a temporary mapping to store the resources one module at a time

Parameters

module_name odule_name

Definition at line 63 of file pointer_values_analyses.c.

 {
   return (statement_cell_relations) db_get_memory_resource(DBR_SIMPLE_POINTER_VALUES, module_name, true);
 }

References db_get_memory_resource(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_put_in_simple_pv()

void db_put_in_simple_pv	(	const char *	module_name,
		list	l_pv
	)

Parameters

module_name	odule_name
l_pv	_pv

Definition at line 78 of file pointer_values_analyses.c.

 {
   DB_PUT_MEMORY_RESOURCE(DBR_IN_SIMPLE_POINTER_VALUES, module_name, (char*) make_cell_relations(l_pv));
 }

References DB_PUT_MEMORY_RESOURCE, make_cell_relations(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_put_initial_simple_pv()

void db_put_initial_simple_pv	(	const char *	module_name,
		list	l_pv
	)

Parameters

module_name	odule_name
l_pv	_pv

Definition at line 98 of file pointer_values_analyses.c.

 {
   DB_PUT_MEMORY_RESOURCE(DBR_INITIAL_SIMPLE_POINTER_VALUES, module_name, (char*) make_cell_relations(l_pv));
 }

References DB_PUT_MEMORY_RESOURCE, make_cell_relations(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_put_out_simple_pv()

void db_put_out_simple_pv	(	const char *	module_name,
		list	l_pv
	)

Parameters

module_name	odule_name
l_pv	_pv

Definition at line 88 of file pointer_values_analyses.c.

 {
   DB_PUT_MEMORY_RESOURCE(DBR_OUT_SIMPLE_POINTER_VALUES, module_name, (char*) make_cell_relations(l_pv));
 }

References DB_PUT_MEMORY_RESOURCE, make_cell_relations(), and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_put_program_simple_pv()

void db_put_program_simple_pv ( list l_pv )

Parameters

l_pv _pv

Definition at line 108 of file pointer_values_analyses.c.

 {
   DB_PUT_MEMORY_RESOURCE(DBR_PROGRAM_SIMPLE_POINTER_VALUES, "", (char*) make_cell_relations(l_pv));
 }

References DB_PUT_MEMORY_RESOURCE, and make_cell_relations().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_put_simple_pv()

void db_put_simple_pv	(	const char *	module_name,
		statement_cell_relations	scr
	)

Parameters

module_name	odule_name
scr	cr

Definition at line 68 of file pointer_values_analyses.c.

 {
    DB_PUT_MEMORY_RESOURCE(DBR_SIMPLE_POINTER_VALUES, module_name, (char*) scr);
 }

References DB_PUT_MEMORY_RESOURCE, and module_name().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_gen_pv()

cell_relations delete_gen_pv ( statement )

◆ delete_kill_pv()

effects delete_kill_pv ( statement )

◆ delete_pv()

cell_relations delete_pv ( statement )

◆ effect_find_aliased_paths_with_pointer_values()

list effect_find_aliased_paths_with_pointer_values	(	effect	eff,
		list	l_pv,
		pv_context *	ctxt
	)

find all paths equivalent to eff cell in l_pv by performing a transitive closure

Parameters

eff	is the input effect
l_pv	is the list of current pointer_values relations
ctxt	is the pv analysis context

Returns: a list of effects whose cells are equivalent to eff_kill cell according to l_pv. Their approximation does not depend on the approximation of the input effect, but only on the exactness of the finding process.

Parameters

eff	ff
l_pv	_pv
ctxt	txt

Definition at line 678 of file pointer_values_operators.c.

 {
   bool exact_p;
   // for gcc
   pips_assert("true", ctxt==ctxt);
   return generic_effect_find_aliases_with_simple_pointer_values(eff, l_pv, &exact_p, transformer_undefined,
                                                                 simple_cell_preceding_p,
                                                                 simple_cell_with_address_of_cell_translation,
                                                                 simple_cell_with_value_of_cell_translation,
                                                                 simple_cells_intersection_p,
                                                                 simple_cells_inclusion_p,
                                                                 simple_cell_to_simple_cell_conversion);
 }

References generic_effect_find_aliases_with_simple_pointer_values(), pips_assert, simple_cell_preceding_p(), simple_cell_to_simple_cell_conversion(), simple_cell_with_address_of_cell_translation(), simple_cell_with_value_of_cell_translation(), simple_cells_inclusion_p(), simple_cells_intersection_p(), and transformer_undefined.

Referenced by simple_effect_to_constant_path_effects_with_pointer_values(), and single_pointer_assignment_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ effect_find_equivalent_pointer_values()

list effect_find_equivalent_pointer_values	(	effect	eff,
		list	l_in,
		cell_relation *	exact_aliased_pv,
		list *	l_in_remnants
	)

find pointer_values in l_in which give (possible or exact) paths equivalent to eff.

Parameters

eff	is the considered input path.
l_in	is the input pointer values list.
exact_aliased_pv	gives an exact equivalent path found in l_in if it exists.
l_in_remnants	contains the elemnts of l_in which are neither exact_aliased_pv nor in the returned list.

Returns: a list of elements of l_in which give (possible or exact) paths equivalent to eff, excluding exact_aliased_pv if one exact equivalent path can be found in l_in.

Parameters

eff	ff
l_in	_in
exact_aliased_pv	xact_aliased_pv
l_in_remnants	_in_remnants

Definition at line 658 of file pointer_values_operators.c.

 {
   return generic_effect_find_equivalent_simple_pointer_values(eff, l_in, exact_aliased_pv, l_in_remnants,
                                                               simple_cells_intersection_p,
                                                               simple_cells_inclusion_p,
                                                               simple_cell_to_simple_cell_conversion);
 }

References generic_effect_find_equivalent_simple_pointer_values(), simple_cell_to_simple_cell_conversion(), simple_cells_inclusion_p(), and simple_cells_intersection_p().

Referenced by free_to_post_pv(), kill_pointer_value(), and make_simple_pv_from_simple_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error_reset_gen_pv()

void error_reset_gen_pv ( void )

◆ error_reset_kill_pv()

void error_reset_kill_pv ( void )

◆ error_reset_pv()

void error_reset_pv ( void )

◆ expression_to_post_pv()

void expression_to_post_pv	(	expression	exp,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

we assume no effects on aliases due to subscripts evaluations for the moment

we assume no effects on aliases due to sizeof argument expression for the moment

aborts if there are calls in subscript expressions

free the spine

we assume no effects on aliases due to subscripts evaluations for the moment

Parameters

exp	xp
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 930 of file pointer_values_analyses.c.

 {
   if (expression_undefined_p(exp))
   {
     pips_debug(1, "begin for undefined expression, returning undefined pointer_value\n");
     pv_res->l_out = l_in;
     pv_res->result_paths = CONS(EFFECT, make_effect(make_undefined_pointer_value_cell(),
         make_action_write_memory(),
         make_approximation_exact(),
         make_descriptor_none()),NIL);
     pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION,
         make_cell_interpretation_value_of(), NIL);
   }
   else
   {
     pips_debug(1, "begin for expression : %s\n",
                expression_to_string(exp));
  
     syntax exp_syntax = expression_syntax(exp);
  
     switch(syntax_tag(exp_syntax))
     {
     case is_syntax_reference:
       pips_debug(5, "reference case\n");
       reference exp_ref = syntax_reference(exp_syntax);
       if (same_string_p(entity_local_name(reference_variable(exp_ref)), "NULL"))
       {
         pv_res->result_paths = CONS(EFFECT, make_effect(make_null_pointer_value_cell(),
             make_action_read_memory(),
             make_approximation_exact(),
             make_descriptor_none()), NIL);
         pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION,
             make_cell_interpretation_value_of(),
             NIL);
       }
       else
       {
         // functions that can be pointed by reference_to_effect_func:
         // reference_to_simple_effect
         // reference_to_convex_region
         // reference_to_reference_effect
         pv_res->result_paths = CONS(EFFECT,
             (*reference_to_effect_func)
             (copy_reference(exp_ref),
                 make_action_write_memory(),
                 false), NIL);
         pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION,
             make_cell_interpretation_value_of(),
             NIL);
       }
       /* we assume no effects on aliases due to subscripts evaluations for the moment */
       pv_res->l_out = l_in;
       break;
     case is_syntax_range:
       pips_internal_error("not yet implemented");
       break;
     case is_syntax_call:
     {
       call_to_post_pv(syntax_call(exp_syntax), l_in, pv_res, ctxt);
       break;
     }
     case is_syntax_cast:
     {
       expression_to_post_pv(cast_expression(syntax_cast(exp_syntax)),
           l_in, pv_res, ctxt);
       pips_debug(5, "cast case\n");
       break;
     }
     case is_syntax_sizeofexpression:
     {
       /* we assume no effects on aliases due to sizeof argument expression
        * for the moment */
       pv_res->l_out = l_in;
       break;
     }
     case is_syntax_subscript:
     {
       pips_debug(5, "subscript case\n");
       /* aborts if there are calls in subscript expressions */
       list l_eff = NIL;
       list l_tmp = generic_proper_effects_of_complex_address_expression(exp, &l_eff, true);
       gen_full_free_list(l_tmp);
       FOREACH(EFFECT, eff, l_eff)
       {
         pv_res->result_paths = CONS(EFFECT, eff, NIL);
         pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION,
             make_cell_interpretation_value_of(),
             NIL);
       }
       gen_free_list(l_eff); /* free the spine */
       /* we assume no effects on aliases due to subscripts evaluations for the moment */
       pv_res->l_out = l_in;
       break;
     }
     case is_syntax_application:
       pips_internal_error("not yet implemented");
       break;
     case is_syntax_va_arg:
     {
       pips_internal_error("not yet implemented");
       break;
     }
     default:
       pips_internal_error("unexpected tag %d", syntax_tag(exp_syntax));
       break;
     }
   }
  
   pips_debug_pv_results(1, "end with pv_results =\n", *pv_res);
   pips_debug(1, "end\n");
   return;
 }

References call_to_post_pv(), cast_expression, CELL_INTERPRETATION, CONS, copy_reference(), EFFECT, entity_local_name(), exp, expression_syntax, expression_to_post_pv(), expression_to_string(), expression_undefined_p, FOREACH, gen_free_list(), gen_full_free_list(), generic_proper_effects_of_complex_address_expression(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, pv_results::l_out, make_action_read_memory(), make_action_write_memory(), make_approximation_exact(), make_cell_interpretation_value_of(), make_descriptor_none(), make_effect(), make_null_pointer_value_cell(), make_undefined_pointer_value_cell(), NIL, pips_debug, pips_debug_pv_results, pips_internal_error, reference_to_effect_func, reference_variable, pv_results::result_paths, pv_results::result_paths_interpretations, same_string_p, syntax_call, syntax_cast, syntax_reference, and syntax_tag.

Referenced by address_of_to_post_pv(), assignment_to_post_pv(), binary_arithmetic_operator_to_post_pv(), c_return_to_post_pv(), conditional_operator_to_post_pv(), default_intrinsic_to_post_pv(), dereferencing_to_post_pv(), expression_to_post_pv(), external_call_to_post_pv(), field_to_post_pv(), forloop_to_post_pv(), heap_intrinsic_to_post_pv(), instruction_to_post_pv(), logical_operator_to_post_pv(), point_to_to_post_pv(), range_to_post_pv(), safe_intrinsic_to_post_pv(), test_to_post_pv(), unary_arithmetic_operator_to_post_pv(), update_operator_to_post_pv(), and whileloop_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_pv_results_paths()

void free_pv_results_paths ( pv_results * pv_res )

Parameters

pv_res v_res

Definition at line 203 of file pointer_values_analyses.c.

 {
   gen_full_free_list(pv_res->result_paths);
   pv_res->result_paths = NIL;
   gen_full_free_list(pv_res->result_paths_interpretations);
   pv_res->result_paths_interpretations = NIL;
 }

References gen_full_free_list(), NIL, pv_results::result_paths, and pv_results::result_paths_interpretations.

Referenced by assignment_to_post_pv(), binary_arithmetic_operator_to_post_pv(), declaration_to_post_pv(), default_intrinsic_to_post_pv(), forloop_to_post_pv(), free_to_post_pv(), heap_intrinsic_to_post_pv(), instruction_to_post_pv(), logical_operator_to_post_pv(), loop_to_post_pv(), range_to_post_pv(), safe_intrinsic_to_post_pv(), sequence_to_post_pv(), single_pointer_assignment_to_post_pv(), test_to_post_pv(), and whileloop_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gen_pv_undefined_p()

bool gen_pv_undefined_p ( void )

◆ generic_print_code_gen_kill_pv()

void generic_print_code_gen_kill_pv ( char * module_name )

Parameters

module_name odule_name

Definition at line 90 of file prettyprint.c.

 {
   pips_assert("true", module_name==module_name);
 }

References module_name(), and pips_assert.

Referenced by print_code_simple_gen_kill_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generic_print_code_pv()

bool generic_print_code_pv	(	char *	module_name,
		pv_context *	ctxt
	)

Parameters

module_name	odule_name
ctxt	txt

Definition at line 53 of file prettyprint.c.

 {
   bool success;
  
   set_current_module_statement( (statement)
                                 db_get_memory_resource(DBR_CODE, module_name, true));
   set_current_module_entity(module_name_to_entity(module_name));
  
   set_pv((*ctxt->db_get_pv_func)(module_name));
  
   list l_in = (*ctxt->db_get_in_pv_func)(module_name);
   list l_out = (*ctxt->db_get_in_pv_func)(module_name);
  
   init_prettyprint(text_pv);
   text t = make_text(NIL);
   MERGE_TEXTS(t, text_pointer_values(l_in, "IN Pointer values:"));
   MERGE_TEXTS(t, text_pointer_values(l_out, "OUT Pointer values:"));
   MERGE_TEXTS(t, text_module(get_current_module_entity(),
                              get_current_module_statement()));
   success = make_text_resource_and_free(module_name, DBR_PRINTED_FILE, ".pv", t);
   close_prettyprint();
  
   reset_current_module_entity();
   reset_current_module_statement();
   reset_pv();
   return success;
 }

References close_prettyprint(), pv_context::db_get_in_pv_func, db_get_memory_resource(), pv_context::db_get_pv_func, get_current_module_entity(), get_current_module_statement(), init_prettyprint(), make_text(), make_text_resource_and_free(), MERGE_TEXTS, module_name(), module_name_to_entity(), NIL, reset_current_module_entity(), reset_current_module_statement(), reset_pv(), set_current_module_entity(), set_current_module_statement(), set_pv(), text_module(), text_pointer_values(), and text_pv().

Referenced by print_code_simple_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_gen_pv()

statement_cell_relations get_gen_pv ( void )

◆ get_kill_pv()

statement_effects get_kill_pv ( void )

◆ get_pv()

statement_cell_relations get_pv ( void )

Referenced by generic_module_pointer_values().

Here is the caller graph for this function:

◆ init_gen_pv()

void init_gen_pv ( void )

◆ init_kill_pv()

void init_kill_pv ( void )

◆ init_pv()

void init_pv ( void )

Referenced by generic_module_initial_pointer_values(), and generic_module_pointer_values().

Here is the caller graph for this function:

◆ initial_simple_pointer_values()

bool initial_simple_pointer_values ( const string )

Parameters

string odule_name

Definition at line 1925 of file pointer_values_analyses.c.

 {
   pv_context ctxt = make_simple_pv_context();
   ctxt.initial_pointer_values_p = true;
   set_methods_for_simple_effects();
   generic_module_initial_pointer_values(module_name, &ctxt);
   reset_pv_context(&ctxt);
   generic_effects_reset_all_methods();
   return(true);
 }

References generic_effects_reset_all_methods(), generic_module_initial_pointer_values(), pv_context::initial_pointer_values_p, make_simple_pv_context(), module_name(), reset_pv_context(), and set_methods_for_simple_effects().

Here is the call graph for this function:

◆ intrinsic_to_post_pv()

void intrinsic_to_post_pv	(	entity	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

pointer_values_intrinsics.c

Parameters

func	unc
func_args	unc_args
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 1969 of file pointer_values_intrinsics.c.

 {
   const char* func_name = entity_local_name(func);
   pips_debug(1, "begin for %s\n", func_name);
  
   IntrinsicToPostPVDescriptor *pid = IntrinsicToPostPVDescriptorTable;
  
   while (pid->name != NULL)
     {
       if (strcmp(pid->name, func_name) == 0)
         {
           (*(pid->to_post_pv_function))(func, func_args, l_in, pv_res, ctxt);
           pips_debug_pv_results(2, "resulting pv_res:", *pv_res);
           pips_debug(1, "end\n");
           return;
         }
       pid += 1;
   }
  
   pips_internal_error("unknown intrinsic %s", func_name);
   pips_debug(1, "end\n");
   return;
 }

References entity_local_name(), IntrinsicToPostPVDescriptorTable, IntrinsicDescriptor::name, pips_debug, pips_debug_pv_results, pips_internal_error, and IntrinsicDescriptor::to_post_pv_function.

Referenced by call_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kill_pointer_value()

list kill_pointer_value	(	effect	eff_kill,
		list	l_in,
		pv_context *	ctxt
	)

eliminate the cell of eff_kill from l_in

Parameters

eff_kill	is the effect describing the cell to be killed
l_in	is the input list of pointer_values.
ctxt	is a pointer on the pointer values analysis contex.

Returns: a list of newly allocated pointer_values Not yet very generic: either should be made generic or a specific version made for convex pointer values/effects.

all pointers may be killed

eff_kill characteristics

using old_values, take into account the impact of eff_kill on l_in pointer values second cells which must be expressed in terms of unchanged paths.

should we translate the first or the second pv_in cell

must it be translated ?

pv_in first cell characteristics

pv_in second cell characteristics

pointer value relation is still valid

This should be made generic

we must translate ref_in using the old_values

if there is an exact candidate, it is ranked first and we can use it

generate a new pv for each element of old_values

FOREACH(CELL_RELATION, old_pv, l_old_values)

else branch of if (exact_first_pv)

if (to_be_translated)

FOREACH (CELL_RELATION, pv_in, l_remnants)

Second, take into account the impact of eff_kill on l_old_values relations. We only have to keep those which are not completely killed by kill_eff, and set their approximation to may (this is also true for exact_old_pv)

first use exact_old_pv to translate exact old_values

Then the other old_values

we already know that there may be a non-empty intersection with cell_kill

some more work is necessary

some more precise work could be done here by computing the difference between the pv_old first cell and cell_kill. I don't know if it would be really useful. So let us avoid too complex things for the moment.

Parameters

eff_kill	ff_kill
l_in	of cell_relations
ctxt	txt

Definition at line 193 of file pointer_values_operators.c.

 {
   list l_out = NIL;
  
   pips_debug_pvs(1, "begin with l_in:", l_in);
   pips_debug_effect(1, "and eff_kill:", eff_kill);
  
  
   if (anywhere_effect_p(eff_kill))
   {
     /* all pointers may be killed */
     pips_debug(5, "anywhere case \n");
  
     FOREACH(CELL_RELATION, pv_in, l_in)
     {
       cell_relation pv_out = copy_cell_relation(pv_in);
       cell_relation_approximation_tag(pv_out) = is_approximation_may;
       l_out = CONS(CELL_RELATION, pv_out, l_out);
     }
   }
   else
   {
     /* eff_kill characteristics */
     cell cell_kill = effect_cell(eff_kill);
     tag app_kill = effect_approximation_tag(eff_kill);
     reference ref_kill = effect_any_reference(eff_kill);
     entity e_kill = reference_variable(ref_kill);
     list ind_kill = reference_indices(ref_kill);
     size_t nb_ind_kill = gen_length(ind_kill);
     /******/
  
     /* using old_values, take into account the impact of eff_kill on
      * l_in pointer values second cells which must be expressed in terms of
      * unchanged paths.
      */
     list l_remnants = NIL;
     cell_relation exact_old_pv = cell_relation_undefined;
     list l_old_values = NIL;
  
     pips_debug(4, "begin, looking for an exact old value for eff_orig\n");
  
     l_old_values = effect_find_equivalent_pointer_values(eff_kill, l_in,
         &exact_old_pv,
         &l_remnants);
     pips_debug_pvs(3, "l_old_values:", l_old_values);
     pips_debug_pvs(3, "l_remnants:", l_remnants);
     pips_debug_pv(3, "exact_old_pv:", exact_old_pv);
  
     list l_keep = NIL;
     FOREACH(CELL_RELATION, pv_in, l_remnants)
     {
       bool first_p = false; /* should we translate the first or the second pv_in cell */
       bool to_be_translated = false; /* must it be translated ? */
       bool exact_preceding_test = true;
  
       /* pv_in first cell characteristics */
       cell cell_in_1 = cell_relation_first_cell(pv_in);
       reference ref_in_1 = cell_reference(cell_in_1);
       entity e_in_1 = reference_variable(ref_in_1);
       list ind_in_1 = reference_indices(ref_in_1);
       size_t nb_ind_in_1 = gen_length(ind_in_1);
       /******/
  
       /* pv_in second cell characteristics */
       cell cell_in_2 = cell_relation_second_cell(pv_in);
       reference ref_in_2 = cell_reference(cell_in_2);
       entity e_in_2 = reference_variable(ref_in_2);
       list ind_in_2 = reference_indices(ref_in_2);
       size_t nb_ind_in_2 = gen_length(ind_in_2);
       /******/
  
       pips_debug_pv(3, "considering pv_in:", pv_in);
  
       if (same_entity_p(e_kill, e_in_2) && nb_ind_kill <= nb_ind_in_2)
       {
         if (cell_relation_second_address_of_p(pv_in) && nb_ind_kill == nb_ind_in_2)
         {
           /* pointer value relation is still valid */
           pips_debug(3, "address_of case, and nb_ind_in == nb_ind_kill_2\n");
           to_be_translated = false;
         }
         else
         {
           pips_debug(3, "second cell is candidate for translation\n");
           first_p = false;
           bool inclusion_test_exact_p = false;
           if ( (nb_ind_kill == nb_ind_in_2 &&
               simple_cells_inclusion_p(cell_in_2, descriptor_undefined,
                   cell_kill, descriptor_undefined, &inclusion_test_exact_p))
               ||
               (nb_ind_kill < nb_ind_in_2 &&
                   simple_cell_reference_preceding_p(ref_kill, descriptor_undefined,
                       ref_in_2, descriptor_undefined,
                       transformer_undefined,
                       true,
                       &exact_preceding_test)))
             to_be_translated = true;
           else to_be_translated = false;
         }
       }
       else if (same_entity_p(e_kill, e_in_1) && nb_ind_kill <= nb_ind_in_1)
       {
         pips_debug(3, "first cell is candidate for translation\n");
         first_p = true;
         bool inclusion_test_exact_p = false;
         if ( (nb_ind_kill == nb_ind_in_1 &&
             simple_cells_inclusion_p(cell_in_1, descriptor_undefined,
                 cell_kill, descriptor_undefined,
                 &inclusion_test_exact_p) )
             ||
             (nb_ind_kill < nb_ind_in_1 &&
                 simple_cell_reference_preceding_p(ref_kill, descriptor_undefined,
                     ref_in_1, descriptor_undefined,
                     transformer_undefined,
                     true,
                     &exact_preceding_test)))
           to_be_translated = true;
         else to_be_translated = false;
       }
       else
       {
         to_be_translated = false;
       }
  
       if (to_be_translated)
       {
         pips_debug(3, "%s cell must be translated\n", first_p ? "first" : "second");
  
         /* This should be made generic */
  
         /* we must translate ref_in using the old_values */
         /* if there is an exact candidate, it is ranked first
          * and we can use it */
         if (exact_old_pv != cell_relation_undefined)
         {
           cell_relation new_pv = simple_pv_translate(pv_in, first_p, exact_old_pv);
           pips_debug_pv(3, "translated to:", new_pv);
           l_out = CONS(CELL_RELATION, new_pv, l_out);
         }
         else /* generate a new pv for each element of old_values */
         {
           FOREACH(CELL_RELATION, old_pv, l_old_values) {
             cell_relation new_pv = simple_pv_translate(pv_in, first_p, old_pv);
             pips_debug_pv(3, "translated to:", new_pv);
             l_out = CONS(CELL_RELATION, new_pv, l_out);
           } /*  FOREACH(CELL_RELATION, old_pv, l_old_values) */
         } /* else branch of if (exact_first_pv) */
       } /*  if (to_be_translated) */
       else
       {
         pips_debug(3, "non matching case, keep as is\n");
         l_keep = CONS(CELL_RELATION, copy_cell_relation(pv_in), l_keep);
       }
     } /* FOREACH (CELL_RELATION, pv_in, l_remnants) */
  
     list l_tmp = (*ctxt->pvs_must_union_func)(l_out, l_keep);
     //gen_full_free_list(l_out);
     //gen_full_free_list(l_keep);
     l_out = l_tmp;
  
     /* Second, take into account the impact of eff_kill on l_old_values relations.
      * We only have to keep those which are not completely killed by kill_eff, and
      * set their approximation to may (this is also true for exact_old_pv)
      */
  
     /* first use exact_old_pv to translate exact old_values */
     cell_relation tmp_old_pv = cell_relation_undefined;
     if (!cell_relation_undefined_p(exact_old_pv))
     {
       pips_debug(3, "handling exact_old_pv\n");
       reference ref_old =
           cell_reference(cell_relation_second_cell(exact_old_pv));
       if(same_entity_p(reference_variable(ref_old),e_kill))
       {
         pips_debug(3, "exact_old_pv is inverted -> translate\n");
         tmp_old_pv = make_value_of_pointer_value
             (copy_cell(cell_relation_second_cell(exact_old_pv)),
                 copy_cell(cell_relation_first_cell(exact_old_pv)),
                 cell_relation_approximation_tag(exact_old_pv),
                 make_descriptor_none());
       }
       else
       {
         pips_debug(3, "exact_old_pv is not inverted\n");
         tmp_old_pv = copy_cell_relation(exact_old_pv);
       }
     }
  
     /* Then the other old_values */
     pips_debug(3, "dealing with old values\n");
     FOREACH(CELL_RELATION, pv_old, l_old_values)
     {
       pips_debug_pv(3, "dealing with pv_old:", pv_old);
       /* we already know that there may be a non-empty
        * intersection with cell_kill */
       if (app_kill == is_approximation_may)
       {
         pips_debug(3, "may kill, just change the approximation\n");
         cell_relation pv_out = copy_cell_relation(pv_old);
         cell_relation_approximation_tag(pv_out) = is_approximation_may;
         l_out = CONS(CELL_RELATION, pv_out, l_out);
       }
       else /* some more work is necessary */
       {
         cell first_cell_old = cell_relation_first_cell(pv_old);
         bool exact_inclusion_p = false;
         bool inclusion_p = simple_cells_inclusion_p(first_cell_old, descriptor_undefined,
             cell_kill, descriptor_undefined,
             &exact_inclusion_p);
  
         if (inclusion_p && exact_inclusion_p)
         {
           pips_debug(3, "first_cell_old exactly included in cell_kill"
               " -> pv_old is translated or killed\n");
           if(!cell_relation_undefined_p(tmp_old_pv)
               && !(cell_relation_second_address_of_p(pv_old)
                   && (abstract_pointer_value_cell_p(cell_relation_second_cell(tmp_old_pv))
                       || cell_relation_second_address_of_p(tmp_old_pv))))
           {
             cell_relation new_pv = simple_pv_translate(tmp_old_pv,
                 true,
                 pv_old);
             pips_debug_pv(3, "translating to:", new_pv);
             l_out = CONS(CELL_RELATION, new_pv, l_out);
           }
         }
         else
         {
           cell second_cell_old = cell_relation_second_cell(pv_old);
           bool exact_inclusion_p = false;
           bool inclusion_p = simple_cells_inclusion_p(second_cell_old, descriptor_undefined,
               cell_kill, descriptor_undefined,
               &exact_inclusion_p);
           if (inclusion_p && exact_inclusion_p)
           {
             pips_debug(3, "second_cell_old exactly included in "
                 "cell_kill -> pv_old is translated or killed\n");
  
             if(!cell_relation_undefined_p(tmp_old_pv))
             {
               cell_relation new_pv = simple_pv_translate(tmp_old_pv,
                   true,
                   pv_old);
               pips_debug_pv(3, "translating to:", new_pv);
               l_out = CONS(CELL_RELATION, new_pv, l_out);
             }
           }
           else
           {
             pips_debug(3, "may be included case"
                 " -> keep with may approximation\n");
             /* some more precise work could be done here by
              * computing the difference between the pv_old
              * first cell and cell_kill. I don't know if it
              * would be really useful.  So let us avoid too
              * complex things for the moment.
              */
             cell_relation pv_out = copy_cell_relation(pv_old);
             cell_relation_approximation_tag(pv_out) =
                 is_approximation_may;
             l_out = CONS(CELL_RELATION, pv_out, l_out);
           }
         }
       }
     }
     gen_free_list(l_old_values);
  
     pips_debug(3, "dealing with exact_old_pv\n");
     if (!cell_relation_undefined_p(tmp_old_pv))
     {
       cell first_cell_old = cell_relation_first_cell(tmp_old_pv);
       bool exact_inclusion_p = false;
       if (app_kill == is_approximation_may)
       {
         pips_debug(3,
             "may kill, keep exact_old_pv with may approximation\n");
         cell_relation pv_out = copy_cell_relation(exact_old_pv);
         cell_relation_approximation_tag(pv_out) = is_approximation_may;
         l_out = CONS(CELL_RELATION, pv_out, l_out);
       }
       else if (simple_cells_inclusion_p(first_cell_old, descriptor_undefined,
           cell_kill, descriptor_undefined,
           &exact_inclusion_p)
           && exact_inclusion_p)
       {
         pips_debug(3, "first cell of exact_old_pv exactly included in cell_kill "
             "-> exact_old_pv is killed\n");
       }
       else
       {
         pips_debug(3, "may be included case"
             " -> keep with may approximation\n");
         /* some more precise work could be done here by
          * computing the difference between the pv_old
          * first cell and cell_kill. I don't know if it
          * would be really useful.  So let us avoid too
          * complex things for the moment.
          */
         cell_relation pv_out = copy_cell_relation(tmp_old_pv);
         cell_relation_approximation_tag(pv_out) =
             is_approximation_may;
         l_out = CONS(CELL_RELATION, pv_out, l_out);
       }
       free_cell_relation(tmp_old_pv);
     }
  
   }
   pips_debug_pvs(1, "returning:", l_out);
  
   return l_out;
 }

References abstract_pointer_value_cell_p(), anywhere_effect_p(), cell_reference, CELL_RELATION, cell_relation_approximation_tag, cell_relation_first_cell, cell_relation_second_address_of_p, cell_relation_second_cell, cell_relation_undefined, cell_relation_undefined_p, CONS, copy_cell(), copy_cell_relation(), descriptor_undefined, effect_any_reference, effect_approximation_tag, effect_cell, effect_find_equivalent_pointer_values(), FOREACH, free_cell_relation(), gen_free_list(), gen_length(), is_approximation_may, make_descriptor_none(), make_value_of_pointer_value(), NIL, pips_debug, pips_debug_effect, pips_debug_pv, pips_debug_pvs, pv_context::pvs_must_union_func, reference_indices, reference_variable, same_entity_p(), simple_cell_reference_preceding_p(), simple_cells_inclusion_p(), simple_pv_translate(), and transformer_undefined.

Referenced by kill_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kill_pointer_values()

list kill_pointer_values	(	list	l_in,
		list	l_kill,
		pv_context *	ctxt
	)

eliminate the cells of l_kill from l_in

Parameters

l_kill	is the list of effects describing the cells to eliminated from l_in
l_in	is the input list of pointer_values.
ctxt	is a pointer on the pointer values analysis contex.

Returns: a list of newly allocated pointer_values

Parameters

l_in	of cell_relations
l_kill	of effects
ctxt	txt

Definition at line 155 of file pointer_values_operators.c.

 {
   list l_res = NIL;
   pips_debug_pvs(5, "l_in =", l_in);
   pips_debug_effects(5, "l_kill =", l_kill);
  
   if (ENDP(l_kill))
     {
       l_res = gen_full_copy_list(l_in);
     }
   else
     {
       l_res = l_in;
       FOREACH(EFFECT, eff_kill, l_kill)
         {
           list l_cur = kill_pointer_value(eff_kill, l_res, ctxt);
           if (l_res != l_in) gen_full_free_list(l_res);
           l_res = l_cur;
         }
     }
  
   pips_debug_pvs(5, "returning :", l_res);
   return l_res;
 }

References EFFECT, ENDP, FOREACH, gen_full_copy_list(), gen_full_free_list(), kill_pointer_value(), NIL, pips_debug_effects, and pips_debug_pvs.

Referenced by single_pointer_assignment_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kill_pv_undefined_p()

bool kill_pv_undefined_p ( void )

◆ load_gen_pv()

cell_relations load_gen_pv ( statement )

◆ load_kill_pv()

effects load_kill_pv ( statement )

◆ load_pv()

cell_relations load_pv ( statement )

Referenced by convex_effect_find_aliased_paths_with_pointer_values(), simple_effect_to_constant_path_effects_with_pointer_values(), and text_pv().

Here is the caller graph for this function:

◆ make_anywhere_anywhere_pvs()

list make_anywhere_anywhere_pvs ( void )

Definition at line 237 of file pointer_values_analyses.c.

 {
   cell anywhere_c = make_cell_reference(make_reference(entity_all_locations(), NIL));
   cell_relation pv = make_address_of_pointer_value(anywhere_c,
                                                    copy_cell(anywhere_c),
                                                    is_approximation_may,
                                                    make_descriptor_none());
   return (CONS(CELL_RELATION, pv, NIL));
 }

References CELL_RELATION, CONS, copy_cell(), entity_all_locations(), is_approximation_may, make_address_of_pointer_value(), make_cell_reference(), make_descriptor_none(), make_reference(), and NIL.

Referenced by unstructured_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_pv_results()

pv_results make_pv_results ( void )

Definition at line 194 of file pointer_values_analyses.c.

 {
   pv_results pv_res;
   pv_res.l_out = NIL;
   pv_res.result_paths = NIL;
   pv_res.result_paths_interpretations = NIL;
   return pv_res;
 }

References pv_results::l_out, NIL, pv_results::result_paths, and pv_results::result_paths_interpretations.

Referenced by assignment_to_post_pv(), binary_arithmetic_operator_to_post_pv(), conditional_operator_to_post_pv(), declaration_to_post_pv(), external_call_to_post_pv(), forloop_to_post_pv(), heap_intrinsic_to_post_pv(), instruction_to_post_pv(), logical_operator_to_post_pv(), loop_to_post_pv(), safe_intrinsic_to_post_pv(), sequence_to_post_pv(), test_to_post_pv(), and whileloop_to_post_pv().

Here is the caller graph for this function:

◆ make_simple_pv_context()

pv_context make_simple_pv_context ( void )

Definition at line 119 of file pointer_values_analyses.c.

 {
   pv_context ctxt;
  
   ctxt.initial_pointer_values_p = false;
  
   ctxt.db_get_pv_func = db_get_simple_pv;
   ctxt.db_put_pv_func = db_put_simple_pv;
   ctxt.db_get_in_pv_func = db_get_in_simple_pv;
   ctxt.db_put_in_pv_func = db_put_in_simple_pv;
   ctxt.db_get_out_pv_func = db_get_out_simple_pv;
   ctxt.db_put_out_pv_func = db_put_out_simple_pv;
   ctxt.db_get_initial_pv_func = db_get_initial_simple_pv;
   ctxt.db_put_initial_pv_func = db_put_initial_simple_pv;
   ctxt.db_get_program_pv_func = db_get_program_simple_pv;
   ctxt.db_put_program_pv_func = db_put_program_simple_pv;
  
   ctxt.make_pv_from_effects_func = make_simple_pv_from_simple_effects;
   ctxt.cell_preceding_p_func = simple_cell_preceding_p;
   ctxt.cell_reference_with_value_of_cell_reference_translation_func =
     simple_cell_reference_with_value_of_cell_reference_translation;
   ctxt.cell_reference_with_address_of_cell_reference_translation_func =
     simple_cell_reference_with_address_of_cell_reference_translation;
   ctxt.pv_composition_with_transformer_func = simple_pv_composition_with_transformer;
   ctxt.pvs_must_union_func = simple_pvs_must_union;
   ctxt.pvs_may_union_func = simple_pvs_may_union;
   ctxt.pvs_equal_p_func = simple_pvs_syntactically_equal_p;
   ctxt.stmt_stack = stack_make(statement_domain, 0, 0);
   return ctxt;
 }

Referenced by convex_effect_find_aliased_paths_with_pointer_values(), initial_simple_pointer_values(), print_code_simple_gen_kill_pointer_values(), print_code_simple_pointer_values(), program_simple_pointer_values(), simple_effect_to_constant_path_effects_with_pointer_values(), and simple_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_simple_pv_from_simple_effects()

list make_simple_pv_from_simple_effects	(	effect	lhs_eff,
		effect	rhs_eff,
		cell_interpretation	ci,
		list	l_in
	)

pointer_values_operators.c

Parameters

lhs_eff	hs_eff
rhs_eff	hs_eff
ci	i
l_in	_in

Definition at line 57 of file pointer_values_operators.c.

 {
   cell_relation pv;
   list l_pv = NIL;
  
   pips_debug(1,"begin for %s cell_interpretation and effects :\n", cell_interpretation_value_of_p(ci)? "value_of" : "address_of");
   pips_debug_effect(2, "lhs_eff:", lhs_eff);
   pips_debug_effect(2, "rhs_eff:", rhs_eff);
  
   tag lhs_t = effect_approximation_tag(lhs_eff);
   tag rhs_t = effect_approximation_tag(rhs_eff);
   tag t = approximation_and(lhs_t, rhs_t);
  
   pips_debug(5,"approximation before converting to store independent cells: %s\n",
       t == is_approximation_exact ? "must": "may");
  
   if (t == is_approximation_exact) t = is_approximation_exact;
  
   cell lhs_c = make_cell(is_cell_reference, copy_reference(effect_any_reference(lhs_eff)));
  
   cell rhs_c = effect_cell(rhs_eff);
   bool changed_rhs_p = false;
   bool changed_lhs_p = false;
  
   if (undefined_pointer_value_cell_p(rhs_c))
     rhs_c = make_undefined_pointer_value_cell();
   else
   {
     rhs_c = make_cell(is_cell_reference, copy_reference(effect_any_reference(rhs_eff)));
     lhs_c = simple_cell_to_store_independent_cell(lhs_c, &changed_lhs_p);
     rhs_c = simple_cell_to_store_independent_cell(rhs_c, &changed_rhs_p);
   }
  
   if (changed_lhs_p || changed_rhs_p)
   {
     pips_debug(5, "approximation set to may after change to store independent cell\n");
     t = is_approximation_may;
   }
  
   if (cell_interpretation_value_of_p(ci))
     pv = make_value_of_pointer_value(lhs_c,
         rhs_c,
         t,
         make_descriptor_none());
   else
     pv = make_address_of_pointer_value(lhs_c,
         rhs_c,
         t,
         make_descriptor_none());
  
   bool exact_preceding_p;
   if (simple_cell_reference_preceding_p(cell_reference(lhs_c), descriptor_undefined,
       cell_reference(rhs_c), descriptor_undefined,
       transformer_undefined,
       true,
       & exact_preceding_p))
   {
     list l_remnants = NIL;
     cell_relation exact_old_pv = cell_relation_undefined;
     list l_old_values = NIL;
  
     pips_debug(4, "lhs path is a predecessor of rhs path, looking for an exact old value for rhs_eff\n");
  
     l_old_values = effect_find_equivalent_pointer_values(lhs_eff, l_in,
         &exact_old_pv,
         &l_remnants);
     gen_free_list(l_remnants);
     if (!cell_relation_undefined_p(exact_old_pv))
     {
       cell_relation new_pv = simple_pv_translate(pv, false, exact_old_pv);
       l_pv = CONS(CELL_RELATION, new_pv, l_pv);
     }
     else
     {
       FOREACH(CELL_RELATION, old_pv, l_old_values) {
         cell_relation new_pv = simple_pv_translate(pv, false, old_pv);
         l_pv = CONS(CELL_RELATION, new_pv, l_pv);
       }
     }
     free_cell_relation(pv);
     gen_free_list(l_old_values);
   }
   else
     l_pv = CONS(CELL_RELATION, pv, l_pv);
  
   pips_debug_pvs(2, "generating:", l_pv);
   pips_debug(1,"end\n");
   return l_pv;
 }

References approximation_and(), cell_interpretation_value_of_p, cell_reference, CELL_RELATION, cell_relation_undefined, cell_relation_undefined_p, CONS, copy_reference(), descriptor_undefined, effect_any_reference, effect_approximation_tag, effect_cell, effect_find_equivalent_pointer_values(), FOREACH, free_cell_relation(), gen_free_list(), is_approximation_exact, is_approximation_may, is_cell_reference, make_address_of_pointer_value(), make_cell(), make_descriptor_none(), make_undefined_pointer_value_cell(), make_value_of_pointer_value(), NIL, pips_debug, pips_debug_effect, pips_debug_pvs, simple_cell_reference_preceding_p(), simple_cell_to_store_independent_cell(), simple_pv_translate(), transformer_undefined, and undefined_pointer_value_cell_p().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ multiple_pointer_assignment_to_post_pv()

void multiple_pointer_assignment_to_post_pv	(	effect	lhs_base_eff,
		type	lhs_type,
		list	l_rhs_base_eff,
		list	l_rhs_base_kind,
		bool	declaration_p,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

we could be more precise here on abstract locations

if (!anywhere_lhs_p)

lhs is not a pointer, but it is an array of pointers or an aggregate type with pointers....

In this case, it cannot be an address_of case

First, search for all accessible pointers

to work around the fact that exact effects are must effects

Then for each found pointer, do as if there were an assignment by translating the rhs path accordingly

build the list of corresponding rhs

should be refined

general case at least :-)

This is not generic, I should use a translation algorithm here I guess

first skip dimensions of kill_ref similar to lhs_base_ref

add the remaining dimensions to the copy of rhs_base_eff

while

if (!ENDP(l_lhs))

if (!anywhere_lhs_p)

Parameters

lhs_base_eff	hs_base_eff
lhs_type	hs_type
l_rhs_base_eff	_rhs_base_eff
l_rhs_base_kind	_rhs_base_kind
declaration_p	eclaration_p
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 1444 of file pointer_values_analyses.c.

 {
   list l_in_cur = l_in;
   cell rhs_base_cell = gen_length(l_rhs_base_eff) > 0
       ? effect_cell(EFFECT(CAR(l_rhs_base_eff))): cell_undefined;
   bool anywhere_lhs_p = false;
  
   pips_debug(1, "begin\n");
  
   pips_assert("assigning NULL to several pointers"
       " at the same time is forbidden!\n", !(!cell_undefined_p(rhs_base_cell) && null_pointer_value_cell_p(rhs_base_cell)));
  
   /* we could be more precise here on abstract locations */
   if (anywhere_effect_p(lhs_base_eff))
   {
     pips_assert("we cannot have an anywhere lhs for a declaration\n", !declaration_p);
     pips_debug(3, "anywhere lhs\n");
     anywhere_lhs_p = true;
  
     list l_rhs_eff = CONS(EFFECT, make_anywhere_effect(make_action_write_memory()), NIL);
     list l_rhs_kind = CONS(CELL_INTERPRETATION, make_cell_interpretation_address_of(), NIL);
  
     single_pointer_assignment_to_post_pv(lhs_base_eff, l_rhs_eff, l_rhs_kind, declaration_p, l_in_cur, pv_res, ctxt);
  
     gen_full_free_list(l_rhs_eff);
     gen_full_free_list(l_rhs_kind);
   }
   else /* if (!anywhere_lhs_p) */
   {
     /* lhs is not a pointer, but it is an array of pointers or an aggregate type
          with pointers.... */
     /* In this case, it cannot be an address_of case */
  
     /* First, search for all accessible pointers */
     list l_lhs = generic_effect_generate_all_accessible_paths_effects_with_level
         (lhs_base_eff, lhs_type, is_action_write, false, 0, true);
     if(effect_exact_p(lhs_base_eff))
       effects_to_must_effects(l_lhs); /* to work around the fact that exact effects are must effects */
     pips_debug_effects(2, "l_lhs = ", l_lhs);
  
     /* Then for each found pointer, do as if there were an assignment by translating
          the rhs path accordingly 
      */
     if (!ENDP(l_lhs))
     {
       list l_lhs_tmp = l_lhs;
       while (!anywhere_lhs_p && !ENDP(l_lhs_tmp))
       {
         /* build the list of corresponding rhs */
         effect lhs_eff = EFFECT(CAR(l_lhs_tmp));
         reference lhs_ref = effect_any_reference(lhs_eff);
         list lhs_dims = reference_indices(lhs_ref);
  
         reference lhs_base_ref = effect_any_reference(lhs_base_eff);
         size_t lhs_base_nb_dim = gen_length(reference_indices(lhs_base_ref));
         list l_rhs_eff = NIL;
         list l_rhs_kind = NIL;
  
         bool free_rhs_kind = false;
         list l_rhs_base_kind_tmp = l_rhs_base_kind;
         FOREACH(EFFECT, rhs_base_eff, l_rhs_base_eff)
         {
           effect rhs_eff = copy_effect(rhs_base_eff);
           cell_interpretation rhs_kind = CELL_INTERPRETATION(CAR(l_rhs_base_kind));
  
           if (!undefined_pointer_value_cell_p(rhs_base_cell)
               && !anywhere_effect_p(rhs_base_eff))
           {
             reference rhs_ref = effect_any_reference(rhs_eff);
             bool to_be_freed = false;
             type rhs_type = cell_reference_to_type(rhs_ref, &to_be_freed);
  
             if (!type_equal_p(lhs_type, rhs_type))
             {
               pips_debug(5, "not same lhs and rhs types generating anywhere rhs\n");
               rhs_eff = make_anywhere_effect(make_action_write_memory()); /* should be refined */
               rhs_kind = make_cell_interpretation_address_of();
               free_rhs_kind = true;
             }
             else /* general case at least :-) */
             {
               /* This is not generic, I should use a translation algorithm here I guess */
               /* first skip dimensions of kill_ref similar to lhs_base_ref */
               list lhs_dims_tmp = lhs_dims;
               for(size_t i = 0; i < lhs_base_nb_dim; i++, POP(lhs_dims_tmp));
               /* add the remaining dimensions to the copy of rhs_base_eff */
               FOREACH(EXPRESSION, dim, lhs_dims_tmp)
               {
                 // functions that can be pointed by effect_add_expression_dimension_func:
                 // simple_effect_add_expression_dimension
                 // convex_region_add_expression_dimension
                 (*effect_add_expression_dimension_func)(rhs_eff, dim);
               }
             }
             if (to_be_freed) free_type(rhs_type);
           }
           l_rhs_eff = CONS(EFFECT, rhs_eff, l_rhs_eff);
           l_rhs_kind = CONS(CELL_INTERPRETATION, rhs_kind, l_rhs_kind);
           POP(l_rhs_base_kind_tmp);
         }
  
         single_pointer_assignment_to_post_pv(lhs_eff, l_rhs_eff, l_rhs_kind, declaration_p, l_in_cur, pv_res, ctxt);
  
         gen_full_free_list(l_rhs_eff);
         if (free_rhs_kind) gen_full_free_list(l_rhs_kind); else gen_free_list(l_rhs_kind);
  
         list l_out = pv_res->l_out;
         if (l_out != l_in_cur)
           gen_full_free_list(l_in_cur);
         l_in_cur = l_out;
  
         list l_result_paths = pv_res->result_paths;
  
         if (gen_length(l_result_paths) > 0 && anywhere_effect_p(EFFECT(CAR(l_result_paths))))
           anywhere_lhs_p = true;
  
         POP(l_lhs_tmp);
       } /* while */
     } /* if (!ENDP(l_lhs)) */
     gen_full_free_list(l_lhs);
   } /* if (!anywhere_lhs_p) */
  
   return;
 }

References anywhere_effect_p(), CAR, CELL_INTERPRETATION, cell_reference_to_type(), cell_undefined, cell_undefined_p, CONS, copy_effect(), EFFECT, effect_any_reference, effect_cell, effect_exact_p, effects_to_must_effects(), ENDP, EXPRESSION, FOREACH, free_type(), gen_free_list(), gen_full_free_list(), gen_length(), generic_effect_generate_all_accessible_paths_effects_with_level(), is_action_write, pv_results::l_out, make_action_write_memory(), make_anywhere_effect(), make_cell_interpretation_address_of(), NIL, null_pointer_value_cell_p(), pips_assert, pips_debug, pips_debug_effects, POP, reference_indices, pv_results::result_paths, single_pointer_assignment_to_post_pv(), type_equal_p(), and undefined_pointer_value_cell_p().

Referenced by assignment_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pointer_values_remove_var()

void pointer_values_remove_var	(	entity	e,
		bool	may_p,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

possibly assign an undefined value to pointers reachable from e without dereferencements)

Then replace all occurrences of e by an undefined value if it's not a may kill

Parameters

may_p	ay_p
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 693 of file pointer_values_operators.c.

 {
   pips_debug(5, "begin for entity %s\n", entity_name(e));
   pips_debug_pvs(5, "input l_in\n", l_in);
  
   /* possibly assign an undefined value to pointers reachable
      from e without dereferencements) */
   expression exp = entity_to_expression(e);
   assignment_to_post_pv(exp, may_p,
                         expression_undefined,
                         false, l_in, pv_res, ctxt);
   l_in = pv_res->l_out;
   free_expression(exp);
  
   /* Then replace all occurrences of e by an
      undefined value if it's not a may kill */
   if (!may_p)
     {
       list l_out = NIL;
       FOREACH(CELL_RELATION, pv, l_in)
         {
           pips_debug_pv(5, "considering pv:", pv);
           cell_relation new_pv = copy_cell_relation(pv);
           cell c1 = cell_relation_first_cell(new_pv);
           entity e1 = reference_variable(cell_reference(c1));
  
           cell c2 = cell_relation_second_cell(new_pv);
           entity e2 = reference_variable(cell_reference(c2));
           bool keep = true;
  
           if (same_entity_p(e1, e))
             {
               if (!undefined_pointer_value_cell_p(c2))
                 {
                   free_cell(c1);
                   cell_relation_first_cell(new_pv)
                     = make_undefined_pointer_value_cell();
                 }
               else
                 keep = false;
             }
           else if (same_entity_p(e2, e))
             {
               if (!undefined_pointer_value_cell_p(c1))
                 {
                   free_cell(c2);
                   cell_relation_second_cell(new_pv)
                     = make_undefined_pointer_value_cell();
                   cell_relation_second_interpretation_tag(new_pv)
                     = is_cell_interpretation_value_of;
                 }
               else keep = false;
             }
           if (keep)
             l_out = CONS(CELL_RELATION, new_pv, l_out);
           else
             free_cell_relation(new_pv);
         }
       gen_full_free_list(l_in);
       pv_res->l_out = l_out;
     }
   pips_debug_pvs(5, "end with pv_res->l_out = \n", pv_res->l_out );
 }

References assignment_to_post_pv(), cell_reference, CELL_RELATION, cell_relation_first_cell, cell_relation_second_cell, cell_relation_second_interpretation_tag, CONS, copy_cell_relation(), entity_name, entity_to_expression(), exp, expression_undefined, FOREACH, free_cell(), free_cell_relation(), free_expression(), gen_full_free_list(), is_cell_interpretation_value_of, keep, pv_results::l_out, make_undefined_pointer_value_cell(), NIL, pips_debug, pips_debug_pv, pips_debug_pvs, reference_variable, same_entity_p(), and undefined_pointer_value_cell_p().

Referenced by free_to_post_pv(), and sequence_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_code_simple_gen_kill_pointer_values()

bool print_code_simple_gen_kill_pointer_values ( char * module_name )

Parameters

module_name odule_name

Definition at line 95 of file prettyprint.c.

 {
   pv_context ctxt = make_simple_pv_context();
   generic_print_code_gen_kill_pv(module_name);
   reset_pv_context(&ctxt);
   return(true);
 }

References generic_print_code_gen_kill_pv(), make_simple_pv_context(), module_name(), and reset_pv_context().

Here is the call graph for this function:

◆ print_code_simple_pointer_values()

bool print_code_simple_pointer_values ( char * module_name )

Parameters

module_name odule_name

Definition at line 82 of file prettyprint.c.

 {
   pv_context ctxt = make_simple_pv_context();
   bool success = generic_print_code_pv(module_name, &ctxt);
   reset_pv_context(&ctxt);
   return success;
 }

References generic_print_code_pv(), make_simple_pv_context(), module_name(), and reset_pv_context().

Here is the call graph for this function:

◆ print_pv_results()

void print_pv_results ( pv_results pv_res )

Parameters

pv_res v_res

Definition at line 211 of file pointer_values_analyses.c.

 {
   fprintf(stderr, "l_out =");
   print_pointer_values(pv_res.l_out);
   list l_rp = pv_res.result_paths;
   list l_rpi = pv_res.result_paths_interpretations;
  
   if (!ENDP(l_rp))
     {
       fprintf(stderr, "result_paths are:\n");
       for(; !ENDP(l_rp); POP(l_rp), POP(l_rpi))
         {
           effect eff = EFFECT(CAR(l_rp));
           cell_interpretation ci = CELL_INTERPRETATION(CAR(l_rpi));
           fprintf(stderr, "%s:",
                   cell_interpretation_value_of_p(ci)
                   ? "value of" : "address of");
           (*effect_prettyprint_func)(eff);
         }
     }
   else
     fprintf(stderr, "result_path is undefined\n");
 }

References CAR, CELL_INTERPRETATION, cell_interpretation_value_of_p, EFFECT, ENDP, fprintf(), pv_results::l_out, POP, print_pointer_values(), pv_results::result_paths, and pv_results::result_paths_interpretations.

Here is the call graph for this function:

◆ program_simple_pointer_values()

bool program_simple_pointer_values ( const string )

Parameters

string rog_name

Definition at line 1936 of file pointer_values_analyses.c.

 {
   pv_context ctxt = make_simple_pv_context();
   set_methods_for_simple_effects();
   generic_program_pointer_values(prog_name, &ctxt);
   reset_pv_context(&ctxt);
   generic_effects_reset_all_methods();
   return(true);
 }

References generic_effects_reset_all_methods(), generic_program_pointer_values(), make_simple_pv_context(), reset_pv_context(), and set_methods_for_simple_effects().

Here is the call graph for this function:

◆ pv_context_statement_head()

statement pv_context_statement_head ( pv_context * ctxt )

Parameters

ctxt txt

Definition at line 187 of file pointer_values_analyses.c.

 {
   return ((statement) stack_head(ctxt->stmt_stack));
 }

References stack_head(), and pv_context::stmt_stack.

Referenced by heap_intrinsic_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pv_context_statement_pop()

void pv_context_statement_pop ( pv_context * ctxt )

Parameters

ctxt txt

Definition at line 182 of file pointer_values_analyses.c.

 {
   (void) stack_pop( ctxt->stmt_stack);
 }

References stack_pop(), and pv_context::stmt_stack.

Referenced by sequence_to_post_pv(), and statement_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pv_context_statement_push()

void pv_context_statement_push	(	statement	s,
		pv_context *	ctxt
	)

Parameters

ctxt txt

Definition at line 177 of file pointer_values_analyses.c.

 {
   stack_push((void *) s, ctxt->stmt_stack);
 }

References stack_push(), and pv_context::stmt_stack.

Referenced by sequence_to_post_pv(), and statement_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pv_undefined_p()

bool pv_undefined_p ( void )

cproto-generated files

pointer_values_analyses.c

◆ pvs_composition_with_transformer()

list pvs_composition_with_transformer	(	list	l_pv,
		transformer	t,
		pv_context *	ctxt
	)

Parameters

l_pv	_pv
ctxt	txt

Definition at line 788 of file pointer_values_operators.c.

 {
   FOREACH(CELL_RELATION, pv, l_pv)
     {
      pv = (*ctxt->pv_composition_with_transformer_func)(pv, t);
     }
  
   return l_pv;
 }

References CELL_RELATION, FOREACH, and pv_context::pv_composition_with_transformer_func.

Referenced by statement_to_post_pv().

Here is the caller graph for this function:

◆ pvs_union_combinable_p()

bool pvs_union_combinable_p	(	cell_relation	pv1,
		cell_relation	pv2
	)

Parameters

pv1	v1
pv2	v2

Definition at line 965 of file pointer_values_operators.c.

 {
   bool undef1 = cell_relation_undefined_p(pv1);
   bool undef2 = cell_relation_undefined_p(pv2);
  
   pips_assert("error: there should be no undefined cell_relations in lists\n", !(undef1 && undef2));
  
   if (undef1 || undef2) return true;
   if (pv_cells_mergeable_p(pv1, pv2)) return true;
  
  
   cell c_first_1 = cell_relation_first_cell(pv1);
   cell c_second_1 = cell_relation_second_cell(pv1);
  
   cell c_first_2 = cell_relation_first_cell(pv2);
   cell c_second_2 = cell_relation_second_cell(pv2);
  
   if (entity_all_locations_p(cell_entity(c_second_1))
       && ! cell_relation_second_value_of_p(pv2))
     {
       int n_first_first = cell_compare(&c_first_1, &c_first_2);
       if (n_first_first == 0) return true;
       int n_first_second = cell_compare(&c_first_1, &c_second_2);
       if (n_first_second == 0) return true;
     }
   if (entity_all_locations_p(cell_entity(c_second_2))
       && ! cell_relation_second_value_of_p(pv1))
     {
       int n_first_first = cell_compare(&c_first_1, &c_first_2);
       if (n_first_first == 0) return true;
       int n_second_first = cell_compare(&c_second_1, &c_first_2);
       if (n_second_first == 0) return true;
     }
  
   return false;
  
 }

References cell_compare(), cell_entity(), cell_relation_first_cell, cell_relation_second_cell, cell_relation_second_value_of_p, cell_relation_undefined_p, entity_all_locations_p(), pips_assert, and pv_cells_mergeable_p().

Referenced by simple_pvs_may_union(), and simple_pvs_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ range_to_post_pv()

void range_to_post_pv	(	range	r,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

Parameters

l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 913 of file pointer_values_analyses.c.

 {
     expression el = range_lower(r);
     expression eu = range_upper(r);
     expression ei = range_increment(r);
  
     pips_debug(1, "begin\n");
  
     expression_to_post_pv(el, l_in, pv_res, ctxt);
     expression_to_post_pv(eu, pv_res->l_out, pv_res, ctxt);
     expression_to_post_pv(ei, pv_res->l_out, pv_res, ctxt);
  
     free_pv_results_paths(pv_res);
  
     pips_debug_pvs(1, "end with pv_res->l_out:\n", pv_res->l_out);
 }

References expression_to_post_pv(), free_pv_results_paths(), pv_results::l_out, pips_debug, pips_debug_pvs, range_increment, range_lower, and range_upper.

Referenced by loop_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_gen_pv()

void reset_gen_pv ( void )

◆ reset_kill_pv()

void reset_kill_pv ( void )

◆ reset_pv()

void reset_pv ( void )

Referenced by generic_module_initial_pointer_values(), generic_module_pointer_values(), and generic_print_code_pv().

Here is the caller graph for this function:

◆ reset_pv_context()

void reset_pv_context ( pv_context * p_ctxt )

p_ctxt->db_get_gen_pv_func =(statement_cell_relations_function) UNDEF ;

p_ctxt->db_put_gen_pv_func = (void_function) UNDEF;

p_ctxt->db_get_kill_pv_func = (statement_effects_function) UNDEF;

p_ctxt->db_put_kill_pv_func = (void_function) UNDEF;

Parameters

p_ctxt _ctxt

Definition at line 162 of file pointer_values_analyses.c.

 {
   p_ctxt->db_get_pv_func = (statement_cell_relations_function) UNDEF;
   p_ctxt->db_put_pv_func = (void_function) UNDEF;
 /*   p_ctxt->db_get_gen_pv_func =(statement_cell_relations_function) UNDEF ; */
 /*   p_ctxt->db_put_gen_pv_func = (void_function) UNDEF; */
 /*   p_ctxt->db_get_kill_pv_func = (statement_effects_function) UNDEF; */
 /*   p_ctxt->db_put_kill_pv_func = (void_function) UNDEF; */
   p_ctxt->make_pv_from_effects_func = (list_function) UNDEF;
   p_ctxt->pv_composition_with_transformer_func = (cell_relation_function) UNDEF;
   p_ctxt->pvs_must_union_func = (list_function) UNDEF;
   p_ctxt->pvs_may_union_func = (list_function) UNDEF;
   p_ctxt->pvs_equal_p_func = (bool_function) UNDEF;
 }

References pv_context::db_get_pv_func, pv_context::db_put_pv_func, pv_context::make_pv_from_effects_func, pv_context::pv_composition_with_transformer_func, pv_context::pvs_equal_p_func, pv_context::pvs_may_union_func, pv_context::pvs_must_union_func, and UNDEF.

Referenced by convex_effect_find_aliased_paths_with_pointer_values(), initial_simple_pointer_values(), print_code_simple_gen_kill_pointer_values(), print_code_simple_pointer_values(), program_simple_pointer_values(), simple_effect_to_constant_path_effects_with_pointer_values(), and simple_pointer_values().

Here is the caller graph for this function:

◆ set_gen_pv()

void set_gen_pv ( statement_cell_relations )

◆ set_kill_pv()

void set_kill_pv ( statement_effects )

◆ set_pv()

void set_pv ( statement_cell_relations )

Referenced by generic_print_code_pv().

Here is the caller graph for this function:

◆ simple_pointer_values()

bool simple_pointer_values ( const string )

interface to compute the simple pointer values of a given module

Parameters

string odule_name

Definition at line 1915 of file pointer_values_analyses.c.

 {
   pv_context ctxt = make_simple_pv_context();
   set_methods_for_simple_effects();
   generic_module_pointer_values(module_name, &ctxt);
   reset_pv_context(&ctxt);
   generic_effects_reset_all_methods();
   return(true);
 }

References generic_effects_reset_all_methods(), generic_module_pointer_values(), make_simple_pv_context(), module_name(), reset_pv_context(), and set_methods_for_simple_effects().

Here is the call graph for this function:

◆ simple_pv_composition_with_transformer()

cell_relation simple_pv_composition_with_transformer	(	cell_relation	,
		transformer
	)

Referenced by make_simple_pv_context().

Here is the caller graph for this function:

◆ simple_pv_may_union()

list simple_pv_may_union	(	cell_relation	pv1,
		cell_relation	pv2
	)

Parameters

pv1	v1
pv2	v2

Definition at line 891 of file pointer_values_operators.c.

 {
   cell c_first_1 = cell_relation_first_cell(pv1);
   cell c_second_1 = cell_relation_second_cell(pv1);
  
   cell c_first_2 = cell_relation_first_cell(pv2);
   cell c_second_2 = cell_relation_second_cell(pv2);
  
   cell_relation pv;
   if (entity_all_locations_p(cell_entity(c_second_1)))
     {
       pips_debug(5, "pv1 second cell is anywhere\n");
       pv = make_address_of_pointer_value(copy_cell(c_first_1),
                                          copy_cell(c_second_1),
                                          cell_relation_approximation_tag(pv1),
                                          make_descriptor_none());
     }
   else if (entity_all_locations_p(cell_entity(c_second_2)))
     {
       pips_debug(5, "pv2 second cell is anywhere\n");
       pv = make_address_of_pointer_value(copy_cell(c_first_2),
                                          copy_cell(c_second_2),
                                          cell_relation_approximation_tag(pv2),
                                          make_descriptor_none());
     }
   else
     {
       if ((cell_compare(&c_first_1, &c_first_2) == 0
            && cell_compare(&c_second_1, &c_second_2) == 0)
           || (cell_compare(&c_first_1, &c_second_2) == 0
               && cell_compare(&c_second_1, &c_first_2) == 0)
           )
         {
  
           tag t1 = cell_relation_approximation_tag(pv1);
           tag t2 = cell_relation_approximation_tag(pv2);
           tag t;
  
           if (t1 == t2) t = t1;
           else t = is_approximation_may;
  
           pv = copy_cell_relation(pv1);
           cell_relation_approximation_tag(pv) = t;
         }
       else
         {
           // first cells are equal, but not second cells indices
           // generate a pv with an unbounded dimension wherever dimensions
           // are not equal
           pv = copy_cell_relation(pv1);
           cell_relation_approximation_tag(pv) = is_approximation_may;
  
           cell c_second_pv = cell_relation_second_cell(pv);
           list l_ind_c_second_pv = reference_indices(cell_any_reference(c_second_pv));
           list l_ind_c_second_2 = reference_indices(cell_any_reference(c_second_2));
  
           for(; !ENDP(l_ind_c_second_pv); POP(l_ind_c_second_pv), POP(l_ind_c_second_2))
             {
               expression ind_pv = EXPRESSION(CAR(l_ind_c_second_pv));
               expression ind_2 = EXPRESSION(CAR(l_ind_c_second_2));
  
               if (!expression_equal_p(ind_pv, ind_2))
                 {
                   EXPRESSION_(CAR(l_ind_c_second_pv)) = make_unbounded_expression();
                 }
             }
  
         }
     }
   list l_res = CONS(CELL_RELATION, pv, NIL);
   pips_debug_pvs(5, "returning:\n", l_res);
   return l_res;
 }

References CAR, cell_any_reference(), cell_compare(), cell_entity(), CELL_RELATION, cell_relation_approximation_tag, cell_relation_first_cell, cell_relation_second_cell, CONS, copy_cell(), copy_cell_relation(), ENDP, entity_all_locations_p(), EXPRESSION, EXPRESSION_, expression_equal_p(), is_approximation_may, make_address_of_pointer_value(), make_descriptor_none(), make_unbounded_expression(), NIL, pips_debug, pips_debug_pvs, POP, and reference_indices.

Referenced by simple_pvs_may_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_pv_must_union()

list simple_pv_must_union	(	cell_relation	pv1,
		cell_relation	pv2
	)

Parameters

pv1	v1
pv2	v2

Definition at line 811 of file pointer_values_operators.c.

 {
   pips_debug_pv(5, "pv1 =\n", pv1);
   pips_debug_pv(5, "pv2 =\n", pv2);
  
   cell c_first_1 = cell_relation_first_cell(pv1);
   cell c_second_1 = cell_relation_second_cell(pv1);
  
   cell c_first_2 = cell_relation_first_cell(pv2);
   cell c_second_2 = cell_relation_second_cell(pv2);
  
   cell_relation pv = cell_relation_undefined;
   if (entity_all_locations_p(cell_entity(c_second_1)))
     {
       pips_debug(5, "pv1 second cell is anywhere\n");
       pv = make_address_of_pointer_value(copy_cell(c_first_1),
                                          copy_cell(c_second_1),
                                          cell_relation_approximation_tag(pv1),
                                          make_descriptor_none());
     }
   else if (entity_all_locations_p(cell_entity(c_second_2)))
     {
       pips_debug(5, "pv2 second cell is anywhere\n");
       pv = make_address_of_pointer_value(copy_cell(c_first_2),
                                          copy_cell(c_second_2),
                                          cell_relation_approximation_tag(pv2),
                                          make_descriptor_none());
     }
   else
     {
       pips_debug(5, "general case\n");
       if ((cell_compare(&c_first_1, &c_first_2) == 0
            && cell_compare(&c_second_1, &c_second_2) == 0)
           || (cell_compare(&c_first_1, &c_second_2) == 0
               && cell_compare(&c_second_1, &c_first_2) == 0)
           )
         {
  
           tag t1 = cell_relation_approximation_tag(pv1);
           tag t2 = cell_relation_approximation_tag(pv2);
           tag t;
  
           if (t1 == t2) t = t1;
           else t = is_approximation_exact;
  
           pv = copy_cell_relation(pv1);
           cell_relation_approximation_tag(pv) = t;
         }
      else
        {
  
           // first cells are equal, but not second cells indices
           // generate a pv with an unbounded dimension wherever dimensions
           // are not equal
           pv = copy_cell_relation(pv1);
           cell_relation_approximation_tag(pv) = is_approximation_may;
  
           cell c_second_pv = cell_relation_second_cell(pv);
           list l_ind_c_second_pv = reference_indices(cell_any_reference(c_second_pv));
           list l_ind_c_second_2 = reference_indices(cell_any_reference(c_second_2));
  
           for(; !ENDP(l_ind_c_second_pv); POP(l_ind_c_second_pv), POP(l_ind_c_second_2))
             {
               expression ind_pv = EXPRESSION(CAR(l_ind_c_second_pv));
               expression ind_2 = EXPRESSION(CAR(l_ind_c_second_2));
  
               if (!expression_equal_p(ind_pv, ind_2))
                 {
                   EXPRESSION_(CAR(l_ind_c_second_pv)) = make_unbounded_expression();
                 }
             }
  
        }
     }
   pips_debug_pv(5, "pv =\n", pv);
   list l_res = CONS(CELL_RELATION, pv, NIL);
   pips_debug_pvs(5, "returning:\n", l_res);
   return l_res;
 }

References CAR, cell_any_reference(), cell_compare(), cell_entity(), CELL_RELATION, cell_relation_approximation_tag, cell_relation_first_cell, cell_relation_second_cell, cell_relation_undefined, CONS, copy_cell(), copy_cell_relation(), ENDP, entity_all_locations_p(), EXPRESSION, EXPRESSION_, expression_equal_p(), is_approximation_exact, is_approximation_may, make_address_of_pointer_value(), make_descriptor_none(), make_unbounded_expression(), NIL, pips_debug, pips_debug_pv, pips_debug_pvs, POP, and reference_indices.

Referenced by simple_pvs_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_pv_translate()

cell_relation simple_pv_translate	(	cell_relation	pv_in,
		bool	in_first_p,
		cell_relation	pv_old
	)

Parameters

pv_in	a the input pointer_value relation
in_first_p	is true (false) if the first (second) cell of pv_in has to be translated
pv_old	is the cell relation that gives the value of a prefix path of the first (second) cell of pv_in

Returns: a newly allocated pointer_value relation in which the first (second) has been translated.

pv_in first or second cell characteristics

pv_old characteristics

is the first cell of pv_old the prefix of ref_in?

act as if there were a [0] indice at the end of ref_old_1

not generic here

Parameters

pv_in	v_in
in_first_p	n_first_p
pv_old	v_old

Definition at line 513 of file pointer_values_operators.c.

 {
   cell_relation pv_new;
  
   pips_debug_pv(5, "pv_in =", pv_in);
   pips_debug(5, "translating %s cell\n", in_first_p? "first": "second");
   pips_debug_pv(5, "pv_old =", pv_old);
  
   /* pv_in first or second cell characteristics */
   cell cell_in = in_first_p ? cell_relation_first_cell(pv_in) : cell_relation_second_cell(pv_in);
   reference ref_in = cell_reference(cell_in);
   entity e_in = reference_variable(ref_in);
   list ind_in = reference_indices(ref_in);
   size_t nb_ind_in = gen_length(ind_in);
   /******/
  
   /* pv_old characteristics */
   reference ref_old_1 =
     cell_reference(cell_relation_first_cell(pv_old));
   list ind_old_1 = reference_indices(ref_old_1);
   size_t nb_ind_old_1 = gen_length(ind_old_1);
  
   reference ref_old_2 =
     cell_reference(cell_relation_second_cell(pv_old));
   list ind_old_2 = reference_indices(ref_old_2);
   size_t nb_ind_old_2 = gen_length(ind_old_2);
   bool anywhere_old_p = cell_relation_second_address_of_p(pv_old)
     && entity_all_locations_p(reference_variable(ref_old_2)) ;
   /******/
  
   bool old_first_p = same_entity_p(reference_variable(ref_old_1), e_in); /* is the first cell of pv_old the prefix of ref_in? */
  
   //reference prefix_ref = old_first_p ? ref_old_1 : ref_old_2;
   reference target_ref = old_first_p ? ref_old_2 : ref_old_1;
  
   reference ref;
   descriptor d;
   bool exact_translation_p;
   int nb_common_indices;
   bool address_of_ref = false;
  
   if (old_first_p && anywhere_old_p)
     {
       cell c1 =  in_first_p ? copy_cell(cell_relation_second_cell(pv_in)) :
         copy_cell(cell_relation_first_cell(pv_in));
       cell c2 = copy_cell(cell_relation_second_cell(pv_old));
       pv_new = make_address_of_pointer_value(c1, c2,
                                              is_approximation_may, make_descriptor_none());
     }
   else
     {
       if ( (!old_first_p) && cell_relation_second_address_of_p(pv_old))
         {
           /* act as if there were a [0] indice at the end of ref_old_1 */
           nb_common_indices = (int) nb_ind_old_1 + 1;
  
           simple_cell_reference_with_value_of_cell_reference_translation
             (ref_in, descriptor_undefined, /* not generic here */
              target_ref, descriptor_undefined, /* not generic here */
              nb_common_indices,
              &ref, &d, &exact_translation_p);
  
         }
       else
         {
           nb_common_indices = old_first_p ? (int) nb_ind_old_1 : (int) nb_ind_old_2;
  
           if (cell_relation_second_address_of_p(pv_old))
             {
               if (nb_ind_in == 0)
                 {
                   ref = copy_reference(target_ref);
                   exact_translation_p = true;
                   address_of_ref = true;
                 }
               else
                 simple_cell_reference_with_address_of_cell_reference_translation
                   (ref_in, descriptor_undefined, /* not generic here */
                    target_ref, descriptor_undefined, /* not generic here */
                    nb_common_indices,
                    &ref, &d, &exact_translation_p);
             }
           else
             simple_cell_reference_with_value_of_cell_reference_translation
               (ref_in, descriptor_undefined, /* not generic here */
                target_ref, descriptor_undefined, /* not generic here */
                nb_common_indices,
                &ref, &d, &exact_translation_p);
         }
       pips_debug(5, "ref after translation %s\n",
                  reference_to_string(ref));
  
       tag new_t = (cell_relation_may_p(pv_in) || cell_relation_may_p(pv_old) || !exact_translation_p)
         ? is_approximation_may : is_approximation_exact;
  
       if (in_first_p)
         {
           if(cell_relation_second_value_of_p(pv_in))
             {
               if (!address_of_ref)
                 pv_new = make_value_of_pointer_value(make_cell_reference(ref),
                                                      copy_cell(cell_relation_second_cell(pv_in)),
                                                      new_t, make_descriptor_none());
               else
                 pv_new = make_address_of_pointer_value(copy_cell(cell_relation_second_cell(pv_in)),
                                                        make_cell_reference(ref),
                                                        new_t, make_descriptor_none());
             }
           else
             {
               pips_assert("pointer values do not have two address of cells\n", !address_of_ref);
               pv_new = make_address_of_pointer_value(make_cell_reference(ref),
                                                      copy_cell(cell_relation_second_cell(pv_in)),
                                                      new_t, make_descriptor_none());
             }
         }
       else
         {
           if(cell_relation_second_value_of_p(pv_in) && !address_of_ref )
             pv_new = make_value_of_pointer_value(copy_cell(cell_relation_first_cell(pv_in)),
                                                  make_cell_reference(ref),
                                                  new_t, make_descriptor_none());
           else
             pv_new = make_address_of_pointer_value(copy_cell(cell_relation_first_cell(pv_in)),
                                                    make_cell_reference(ref),
                                                    new_t, make_descriptor_none());
         }
     }
   return pv_new;
 }

References cell_reference, cell_relation_first_cell, cell_relation_may_p, cell_relation_second_address_of_p, cell_relation_second_cell, cell_relation_second_value_of_p, copy_cell(), copy_reference(), descriptor_undefined, entity_all_locations_p(), gen_length(), int, is_approximation_exact, is_approximation_may, make_address_of_pointer_value(), make_cell_reference(), make_descriptor_none(), make_value_of_pointer_value(), pips_assert, pips_debug, pips_debug_pv, ref, reference_indices, reference_to_string(), reference_variable, same_entity_p(), simple_cell_reference_with_address_of_cell_reference_translation(), and simple_cell_reference_with_value_of_cell_reference_translation().

Referenced by kill_pointer_value(), and make_simple_pv_from_simple_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_pvs_may_union()

list simple_pvs_may_union	(	list	l_pv1,
		list	l_pv2
	)

Parameters

l_pv1	_pv1
l_pv2	_pv2

Definition at line 1029 of file pointer_values_operators.c.

 {
  
   list l_res = cell_relations_generic_binary_op(
     l_pv1,
     l_pv2,
     pvs_union_combinable_p,
     simple_pv_may_union,
     cell_relation_to_may_list,
     cell_relation_to_may_list, simple_pvs_must_union);
   return l_res;
 }

References cell_relation_to_may_list(), cell_relations_generic_binary_op(), pvs_union_combinable_p(), simple_pv_may_union(), and simple_pvs_must_union().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_pvs_must_union()

list simple_pvs_must_union	(	list	l_pv1,
		list	l_pv2
	)

Parameters

l_pv1	_pv1
l_pv2	_pv2

Definition at line 1010 of file pointer_values_operators.c.

 {
  
   list l_res = cell_relations_generic_binary_op(
     l_pv1,
     l_pv2,
     pvs_union_combinable_p,
     simple_pv_must_union,
     cell_relation_to_list,
     cell_relation_to_list, simple_pvs_must_union);
   return l_res;
 }

References cell_relation_to_list(), cell_relations_generic_binary_op(), pvs_union_combinable_p(), simple_pv_must_union(), and simple_pvs_must_union().

Referenced by make_simple_pv_context(), simple_pvs_may_union(), and simple_pvs_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simple_pvs_syntactically_equal_p()

bool simple_pvs_syntactically_equal_p	(	list	l_pv1,
		list	l_pv2
	)

first sort lists

then compare members syntactically

Parameters

l_pv1	_pv1
l_pv2	_pv2

Definition at line 1042 of file pointer_values_operators.c.

 {
   bool result = true;
  
   if (gen_length(l_pv1) != gen_length(l_pv2))
     result = false;
  
   if (result)
     {
       /* first sort lists */
       gen_sort_list(l_pv1, (gen_cmp_func_t) pointer_value_compare);
       gen_sort_list(l_pv2, (gen_cmp_func_t) pointer_value_compare);
  
       /* then compare members syntactically */
       while(result && !ENDP(l_pv1))
         {
           cell_relation pv1 = CELL_RELATION(CAR(l_pv1));
           cell_relation pv2 = CELL_RELATION(CAR(l_pv2));
  
           result = pv_cells_syntactically_equal_p(pv1, pv2);
           POP(l_pv1);
           POP(l_pv2);
         }
     }
   return result;
 }

References CAR, CELL_RELATION, ENDP, gen_length(), gen_sort_list(), pointer_value_compare(), POP, and pv_cells_syntactically_equal_p().

Referenced by make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ single_pointer_assignment_to_post_pv()

void single_pointer_assignment_to_post_pv	(	effect	lhs_eff,
		list	l_rhs_eff,
		list	l_rhs_kind,
		bool	declaration_p,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

First search for all killed paths

we could be more precise/generic on abstract locations

no aliases for a newly declared entity

if lhs_eff is a may-be-killed, then all aliased effects are also may-be-killed effects

we must find in l_in all pointers p and generate p == rhs for all rhs if p is of a type compatible with rhs, and p == &*anywhere* otherwise. in fact, for the moment we generate p == &*anywhere* in all cases

dealing with first cell

not generic

generate for all alias p in l_kill p == rhs_eff

except for p==undefined or p==null (should other abstract values/locations be ignored here?)

now take kills into account

and add gen

Parameters

lhs_eff	hs_eff
l_rhs_eff	_rhs_eff
l_rhs_kind	_rhs_kind
declaration_p	eclaration_p
l_in	_in
pv_res	v_res
ctxt	txt

Definition at line 1253 of file pointer_values_analyses.c.

 {
   list l_out = NIL;
   list l_aliased = NIL;
   list l_kill = NIL;
   list l_gen = NIL;
  
   pips_debug_effect(1, "begin for lhs_eff =", lhs_eff);
   pips_debug(1, "and l_rhs_eff:\n");
   ifdebug(1)
   {
     list l_tmp = l_rhs_kind;
     FOREACH(EFFECT, rhs_eff, l_rhs_eff)
     {
       cell_interpretation ci = CELL_INTERPRETATION(CAR(l_tmp));
       pips_debug(1, "%s of:\n", cell_interpretation_value_of_p(ci)?"value": "address");
       pips_debug_effect(1, "\t", rhs_eff);
       POP(l_tmp);
     }
   }
   pips_debug_pvs(1, "and l_in =", l_in);
   bool anywhere_lhs_p = false;
  
   /* First search for all killed paths */
   /* we could be more precise/generic on abstract locations */
   if (anywhere_effect_p(lhs_eff))
   {
     pips_assert("we cannot have an anywhere lhs for a declaration\n", !declaration_p);
     pips_debug(3, "anywhere lhs\n");
     anywhere_lhs_p = true;
     l_kill = CONS(EFFECT, copy_effect(lhs_eff), NIL);
     l_aliased = l_kill;
   }
   else
   {
     if (!declaration_p) /* no aliases for a newly declared entity */
     {
       l_aliased = effect_find_aliased_paths_with_pointer_values(lhs_eff, l_in, ctxt);
       if (!ENDP(l_aliased) && anywhere_effect_p(EFFECT(CAR(l_aliased))))
       {
         pips_debug(3, "anywhere lhs (from aliases)\n");
         anywhere_lhs_p = true;
         l_kill = l_aliased;
       }
       else if (!ENDP(l_aliased) && ((int) gen_length(l_aliased) == 1)
           && (null_pointer_value_effect_p(EFFECT(CAR(l_aliased)))))
       {
         // dereferencing a null pointer is considered as undefined by the standard
         // with gcc (without any option) the compiler does not complain, but the execution aborts
         // I make the choice here that if the pointer value is exactly NULL, then
         // the program abort; hence there is no pointer anymore and the pointer values list is empty.
         pips_user_warning("null pointer is dereferenced on lhs(%s)\n",
             effect_to_string(lhs_eff));
         gen_full_free_list(l_in);
         l_in = NIL;
         l_kill = NIL;
       }
       else if (!ENDP(l_aliased) && ((int) gen_length(l_aliased) == 1)
           && (undefined_pointer_value_effect_p(EFFECT(CAR(l_aliased)))))
       {
         // dereferencing a non-initialized pointer is considered as undefined by the standard
         // However, with gcc (without any option), the compiler does not complain,
         // and the execution is sometimes correct.
         // I make the choice here that if the pointer value is (exactly) undefined
         // then the program does not necessarily abort;
         // as I can keep dereferencements in pointer values (I'm not limited
         // to constant paths), I still generate a kill and a gen. BC.
         pips_user_warning("undefined pointer is dereferenced on lhs(%s)\n",
             effect_to_string(lhs_eff));
         l_kill = CONS(EFFECT, copy_effect(lhs_eff), NIL);
       }
       else
       {
         /* if lhs_eff is a may-be-killed, then all aliased effects are also
                  may-be-killed effects */
         if (effect_may_p(lhs_eff))
         {
           pips_debug(3, "may lhs effect, changing all aliased effects to may\n");
           effects_to_may_effects(l_aliased);
         }
         l_kill = CONS(EFFECT, copy_effect(lhs_eff), l_aliased);
       }
     }
     else
     {
       l_kill = CONS(EFFECT, copy_effect(lhs_eff), NIL);
     }
   }
  
   pips_debug_effects(2, "l_kill =", l_kill);
  
   if (anywhere_lhs_p)
   {
     free_pv_results_paths(pv_res);
     pv_res->result_paths = l_aliased;
     pv_res->result_paths_interpretations = CONS(CELL_INTERPRETATION, make_cell_interpretation_address_of(), NIL);
  
     /* we must find in l_in all pointers p and generate p == rhs for all rhs if p is
      * of a type compatible with rhs, and p == &*anywhere* otherwise.
      * in fact, for the moment we generate p == &*anywhere* in all cases
      */
     effect anywhere_eff = make_anywhere_effect(make_action_write_memory());
     cell_interpretation rhs_kind = make_cell_interpretation_address_of();
     FOREACH(CELL_RELATION, pv_in, l_in)
     {
       /* dealing with first cell */
       /* not generic */
       effect eff_alias = make_effect(copy_cell(cell_relation_first_cell(pv_in)),
           make_action_write_memory(),
           make_approximation_may(),
           make_descriptor_none());
  
       list l_gen_pv = (* ctxt->make_pv_from_effects_func)
                         (eff_alias, anywhere_eff, rhs_kind, l_in);
       l_gen = (*ctxt->pvs_must_union_func)(l_gen_pv, l_gen);
       free_effect(eff_alias);
  
       if (cell_relation_second_value_of_p(pv_in)
           && !undefined_pointer_value_cell_p(cell_relation_second_cell(pv_in))
           && !null_pointer_value_cell_p(cell_relation_second_cell(pv_in)) )
       {
         /* not generic */
         effect eff_alias = make_effect(copy_cell(cell_relation_second_cell(pv_in)),
             make_action_write_memory(),
             make_approximation_may(),
             make_descriptor_none());
  
         list l_gen_pv = (* ctxt->make_pv_from_effects_func)
                             (eff_alias, anywhere_eff, rhs_kind, l_in);
         l_gen = (*ctxt->pvs_must_union_func)(l_gen_pv, l_gen);
         free_effect(eff_alias);
       }
     }
     free_effect(anywhere_eff);
     free_cell_interpretation(rhs_kind);
   }
   else
   {
     /* generate for all alias p in l_kill p == rhs_eff */
     /* except for p==undefined or p==null (should other abstract values/locations be ignored here?) */
     FOREACH(EFFECT, eff_alias, l_kill) {
       if (!null_pointer_value_effect_p(eff_alias)
           && ! undefined_pointer_value_effect_p(eff_alias))
       {
         list l_rhs_kind_tmp = l_rhs_kind;
         FOREACH(EFFECT, rhs_eff, l_rhs_eff)
         {
           cell_interpretation rhs_kind =
               CELL_INTERPRETATION(CAR(l_rhs_kind_tmp));
           //bool exact_preceding_p = true;
           list l_gen_pv = (* ctxt->make_pv_from_effects_func)
                                 (eff_alias, rhs_eff, rhs_kind, l_in);
           l_gen = gen_nconc(l_gen_pv, l_gen);
           POP(l_rhs_kind_tmp);
         }
       }
     }
     if (declaration_p)
     {
       gen_full_free_list(l_kill);
       l_kill = NIL;
     }
     pips_debug_pvs(2, "l_gen =", l_gen);
   }
  
   /* now take kills into account */
   l_out = kill_pointer_values(l_in, l_kill, ctxt);
   pips_debug_pvs(2, "l_out_after kill:", l_out);
  
   /* and add gen */
   l_out = (*ctxt->pvs_must_union_func)(l_out, l_gen);
  
   pv_res->l_out = l_out;
  
   return;
 }

References anywhere_effect_p(), CAR, CELL_INTERPRETATION, cell_interpretation_value_of_p, CELL_RELATION, cell_relation_first_cell, cell_relation_second_cell, cell_relation_second_value_of_p, CONS, copy_cell(), copy_effect(), EFFECT, effect_find_aliased_paths_with_pointer_values(), effect_may_p, effect_to_string(), effects_to_may_effects(), ENDP, FOREACH, free_cell_interpretation(), free_effect(), free_pv_results_paths(), gen_full_free_list(), gen_length(), gen_nconc(), ifdebug, kill_pointer_values(), pv_results::l_out, make_action_write_memory(), make_anywhere_effect(), make_approximation_may(), make_cell_interpretation_address_of(), make_descriptor_none(), make_effect(), pv_context::make_pv_from_effects_func, NIL, null_pointer_value_cell_p(), null_pointer_value_effect_p(), pips_assert, pips_debug, pips_debug_effect, pips_debug_effects, pips_debug_pvs, pips_user_warning, POP, pv_context::pvs_must_union_func, pv_results::result_paths, pv_results::result_paths_interpretations, undefined_pointer_value_cell_p(), and undefined_pointer_value_effect_p().

Referenced by assignment_to_post_pv(), external_call_to_post_pv(), forloop_to_post_pv(), free_to_post_pv(), loop_to_post_pv(), multiple_pointer_assignment_to_post_pv(), safe_intrinsic_to_post_pv(), update_operator_to_post_pv(), and whileloop_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_gen_pv()

void store_gen_pv	(	statement	,
		cell_relations
	)

◆ store_kill_pv()

void store_kill_pv	(	statement	,
		effects
	)

◆ store_or_update_gen_pv()

void store_or_update_gen_pv	(	statement	,
		cell_relations
	)

◆ store_or_update_kill_pv()

void store_or_update_kill_pv	(	statement	,
		effects
	)

◆ store_or_update_pv()

void store_or_update_pv	(	statement	,
		cell_relations
	)

◆ store_pv()

void store_pv	(	statement	,
		cell_relations
	)

Referenced by sequence_to_post_pv(), and statement_to_post_pv().

Here is the caller graph for this function:

◆ text_pv()

text text_pv	(	entity	,
		int	,
		statement
	)

prettyprint.c

◆ update_gen_pv()

void update_gen_pv	(	statement	,
		cell_relations
	)

◆ update_kill_pv()

void update_kill_pv	(	statement	,
		effects
	)

◆ update_pv()

void update_pv	(	statement	,
		cell_relations
	)

Referenced by sequence_to_post_pv(), and statement_to_post_pv().

Here is the caller graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ pips_debug_pv_results

Function Documentation

◆ assignment_to_post_pv()

◆ bound_gen_pv_p()

◆ bound_kill_pv_p()

◆ bound_pv_p()

◆ cell_relation_to_list()

◆ cell_relation_to_may_list()

◆ close_gen_pv()

◆ close_kill_pv()

◆ close_pv()

◆ db_get_in_simple_pv()

◆ db_get_initial_simple_pv()

◆ db_get_out_simple_pv()

◆ db_get_program_simple_pv()

◆ db_get_simple_pv()

◆ db_put_in_simple_pv()

◆ db_put_initial_simple_pv()

◆ db_put_out_simple_pv()

◆ db_put_program_simple_pv()

◆ db_put_simple_pv()

◆ delete_gen_pv()

◆ delete_kill_pv()

◆ delete_pv()

◆ effect_find_aliased_paths_with_pointer_values()

◆ effect_find_equivalent_pointer_values()

◆ error_reset_gen_pv()

◆ error_reset_kill_pv()

◆ error_reset_pv()

◆ expression_to_post_pv()

◆ free_pv_results_paths()

◆ gen_pv_undefined_p()

◆ generic_print_code_gen_kill_pv()

◆ generic_print_code_pv()

◆ get_gen_pv()

◆ get_kill_pv()

◆ get_pv()

◆ init_gen_pv()

◆ init_kill_pv()

◆ init_pv()

◆ initial_simple_pointer_values()

◆ intrinsic_to_post_pv()

◆ kill_pointer_value()

◆ kill_pointer_values()

◆ kill_pv_undefined_p()

◆ load_gen_pv()

◆ load_kill_pv()

◆ load_pv()

◆ make_anywhere_anywhere_pvs()

◆ make_pv_results()

◆ make_simple_pv_context()

◆ make_simple_pv_from_simple_effects()

◆ multiple_pointer_assignment_to_post_pv()

◆ pointer_values_remove_var()

◆ print_code_simple_gen_kill_pointer_values()

◆ print_code_simple_pointer_values()

◆ print_pv_results()

◆ program_simple_pointer_values()

◆ pv_context_statement_head()

◆ pv_context_statement_pop()

◆ pv_context_statement_push()

◆ pv_undefined_p()

◆ pvs_composition_with_transformer()

◆ pvs_union_combinable_p()

◆ range_to_post_pv()

◆ reset_gen_pv()

◆ reset_kill_pv()

◆ reset_pv()

◆ reset_pv_context()

◆ set_gen_pv()

◆ set_kill_pv()

◆ set_pv()

◆ simple_pointer_values()

◆ simple_pv_composition_with_transformer()

◆ simple_pv_may_union()

◆ simple_pv_must_union()