#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects.h"
#include "effects-util.h"
#include "text-util.h"
#include "effects-simple.h"
#include "effects-generic.h"
#include "misc.h"
#include "pointer_values.h"

Include dependency graph for pointer_values_intrinsics.c:

Data Structures
struct	IntrinsicDescriptor
	The following data structure describes an intrinsic function: its name and its arity and its type, a function to type it (?) and a function to obtain its name if it is different from the entity user name, e.g. More...

Typedefs
typedef struct IntrinsicDescriptor	IntrinsicToPostPVDescriptor
	the following data structure describes an intrinsic function: its name and the function to apply on a call to this intrinsic to get the post pointer values of the call More...

Functions
static void	assignment_intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	binary_arithmetic_operator_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	unary_arithmetic_operator_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	update_operator_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	logical_operator_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	conditional_operator_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	dereferencing_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	field_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	point_to_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	address_of_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	c_io_function_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	unix_io_function_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	string_function_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	va_list_function_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	heap_intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	c_return_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	safe_intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	intrinsic_to_identical_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	unknown_intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	default_intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	assignment_intrinsic_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	unary_arithmetic_operator_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	logical_operator_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	conditional_operator_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	dereferencing_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	field_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	point_to_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	address_of_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	free_to_post_pv (list l_free_eff, list l_in, pv_results pv_res, pv_context ctxt)

static void	c_return_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	safe_intrinsic_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

static void	intrinsic_to_identical_post_pv (entity __attribute__((unused)) func, list __attribute__((unused)) func_args, list l_in, pv_results pv_res, pv_context __attribute__((unused)) ctxt)

static void	unknown_intrinsic_to_post_pv (entity __attribute__((unused)) func, list __attribute__((unused)) func_args, list __attribute__((unused)) l_in, pv_results __attribute__((unused)) pv_res, pv_context __attribute__((unused)) ctxt)

static void	default_intrinsic_to_post_pv (entity __attribute__((unused)) func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)

void	intrinsic_to_post_pv (entity func, list func_args, list l_in, pv_results pv_res, pv_context ctxt)
	pointer_values_intrinsics.c More...

Variables
static IntrinsicToPostPVDescriptor	IntrinsicToPostPVDescriptorTable []

Typedef Documentation

◆ IntrinsicToPostPVDescriptor

typedef struct IntrinsicDescriptor IntrinsicToPostPVDescriptor

the following data structure describes an intrinsic function: its name and the function to apply on a call to this intrinsic to get the post pointer values of the call

These intrinsics are arranged in the order of the standard ISO/IEC 9899:TC2. MB

Function Documentation

◆ address_of_to_post_pv() [1/2]

static void address_of_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

Definition at line 1485 of file pointer_values_intrinsics.c.

 {
   expression_to_post_pv(EXPRESSION(CAR(func_args)), l_in, pv_res, ctxt);
   FOREACH(CELL_INTERPRETATION, ci, pv_res->result_paths_interpretations)
     {
       cell_interpretation_tag(ci) = is_cell_interpretation_address_of;
     }
 }

References CAR, CELL_INTERPRETATION, cell_interpretation_tag, EXPRESSION, expression_to_post_pv(), FOREACH, is_cell_interpretation_address_of, and pv_results::result_paths_interpretations.

Here is the call graph for this function:

◆ address_of_to_post_pv() [2/2]

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

static

◆ assignment_intrinsic_to_post_pv() [1/2]

static void assignment_intrinsic_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

Definition at line 1100 of file pointer_values_intrinsics.c.

 {
   expression lhs = EXPRESSION(CAR(func_args));
   expression rhs = EXPRESSION(CAR(CDR(func_args)));
   assignment_to_post_pv(lhs, false, rhs, false, l_in, pv_res, ctxt);
 }

References assignment_to_post_pv(), CAR, CDR, and EXPRESSION.

Here is the call graph for this function:

◆ assignment_intrinsic_to_post_pv() [2/2]

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

static

◆ binary_arithmetic_operator_to_post_pv()

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

static

From ISO/IEC 9899:TC3 :

For addition, either both operands shall have arithmetic type, or one operand shall be a pointer to an object type and the other shall have integer type.
For substraction, one of the following shall hold :
- both operands have arithmetic types
- both operands are pointers to qualified or unqualified versions of compatible object types; (in this case, both pointers shall point to elements of the same array object, or one past the last element of the array object; the result is the difference of the subscripts of the two array elements) (as a consequence the result is not of a pointer type)
- the left operand is a pointer to an object type and the right operand has integer type

pointer arithmetic, the pointer is in the first expression

build new effects

Definition at line 1110 of file pointer_values_intrinsics.c.

 {
   list l_in_cur;
  
   pips_debug(1, "begin\n");
  
   pv_results pv_res1 = make_pv_results();
   expression arg1 = EXPRESSION(CAR(func_args));
   expression_to_post_pv(arg1, l_in, &pv_res1, ctxt);
  
   l_in_cur = pv_res1.l_out;
   if (l_in != l_in_cur) gen_full_free_list(l_in);
  
   pv_results pv_res2 = make_pv_results();
   expression arg2 = EXPRESSION(CAR(CDR(func_args)));
   expression_to_post_pv(arg2, l_in_cur, &pv_res2, ctxt);
   if (pv_res2.l_out != l_in_cur) gen_full_free_list(l_in_cur);
  
  
   type t1 = expression_to_type(arg1);
   bool pointer_t1 = pointer_type_p(t1);
   bool array_t1 = array_type_p(t1);
   pips_debug(5, "type t1 is: %s (%s)\n", string_of_type(t1),
       type_to_string(t1));
  
   type t2 = expression_to_type(arg2);
   bool pointer_t2 = pointer_type_p(t2);
   bool array_t2 = array_type_p(t2);
   pips_debug(5, "type t2 is: %s (%s)\n", string_of_type(t2),
       type_to_string(t2));
  
   int nb_dims = 0;
  
   const char* func_name = entity_local_name(func);
  
   /* From ISO/IEC 9899:TC3 :
  
      - For addition, either both operands shall have arithmetic type,
      or one operand shall be a pointer to an object type and the other
      shall have integer type.
  
      - For substraction, one of the following shall hold :
  
        - both operands have arithmetic types
        - both operands are pointers to qualified or unqualified versions of
          compatible object types;
          (in this case, both pointers shall point to elements of the same array object,
          or one past the last element of the array object; the result is the difference
          of the subscripts of the two array elements)
          (as a consequence the result is not of a pointer type)
        - the left operand is a pointer to an object type and the right operand has
          integer type
    */
   list l_eff1 = pv_res1.result_paths;
   list l_eff2 = pv_res2.result_paths;
  
   bool pointer_arithmetic = false;
   list l_eff_pointer = NIL;
   expression other_arg = expression_undefined;
  
   if ((pointer_t1 || array_t1) && !(pointer_t2 || array_t2))
     /* pointer arithmetic, the pointer is in the first expression */
   {
     pointer_arithmetic = true;
     l_eff_pointer = l_eff1;
     other_arg = arg2;
     nb_dims = pointer_t1 ? 1 : gen_length(variable_dimensions(type_variable(t1)));
   }
   else if ((pointer_t2 || array_t2) && !(pointer_t1 || array_t1))
   {
     pointer_arithmetic = true;
     l_eff_pointer = l_eff2;
     other_arg = arg1;
     nb_dims = pointer_t2 ? 1 : gen_length(variable_dimensions(type_variable(t2)));
   }
   free_type(t1);
   free_type(t2);
  
   if (pointer_arithmetic)
   {
     free_pv_results_paths(pv_res);
     if (!anywhere_effect_p(EFFECT(CAR(l_eff_pointer))))
     {
       /* build new effects */
       list l_new_eff = NIL;
       list l_new_eff_kind = NIL;
  
       if (nb_dims == 1)
       {
  
         pips_debug(3, "one dimension case\n");
         expression new_arg = copy_expression(other_arg);
  
         if (same_string_p(func_name, MINUS_C_OPERATOR_NAME))
         {
           entity unary_minus_ent =
               gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                   UNARY_MINUS_OPERATOR_NAME),
                   entity_domain);
           new_arg = MakeUnaryCall(unary_minus_ent, new_arg);
         }
  
         FOREACH(EFFECT, eff, l_eff_pointer)
         {
           effect new_eff = copy_effect(eff);
           reference new_ref = effect_any_reference(new_eff);
           list l_inds = reference_indices(new_ref);
           if (ENDP(l_inds))
           {
             // 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)(new_eff, new_arg);
           }
           else
           {
             expression last_exp = EXPRESSION(CAR(gen_last(l_inds)));
             entity binary_plus_ent = gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                 PLUS_C_OPERATOR_NAME),
                 entity_domain);
             new_arg = MakeBinaryCall(binary_plus_ent, copy_expression(last_exp), new_arg);
             // functions that can be pointed by effect_change_ith_dimension_expression_func:
             // simple_effect_change_ith_dimension_expression
             // convex_region_change_ith_dimension_expression
             (*effect_change_ith_dimension_expression_func)(new_eff, new_arg, (int) gen_length(l_inds));
           }
           l_new_eff = CONS(EFFECT, new_eff, l_new_eff);
           l_new_eff_kind = CONS(CELL_INTERPRETATION,
               make_cell_interpretation_address_of(), NIL);
         }
         free_expression(new_arg);
  
       }
       else
       {
         pips_debug(3, "several dimensions (%d) case\n", nb_dims);
  
         // we could do more work to be more precise
         expression new_ind = make_unbounded_expression();
         FOREACH(EFFECT, eff, l_eff_pointer)
         {
           effect new_eff = copy_effect(eff);
  
           for(int i = 1; i <= nb_dims; i++) {
             // 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)(new_eff, copy_expression(new_ind));
           }
           l_new_eff = CONS(EFFECT, new_eff, l_new_eff);
           l_new_eff_kind = CONS(CELL_INTERPRETATION,
               make_cell_interpretation_address_of(), NIL);
         }
         free_expression(new_ind);
       }
       gen_nreverse(l_new_eff);
       gen_nreverse(l_new_eff_kind);
       pv_res->result_paths = l_new_eff;
       pv_res->result_paths_interpretations = l_new_eff_kind;
     }
   }
   pv_res->l_out = pv_res2.l_out;
   free_pv_results_paths(&pv_res1);
   free_pv_results_paths(&pv_res2);
   pips_debug_pv_results(1, "end with pv_res =\n", *pv_res);
 }

References anywhere_effect_p(), array_type_p(), CAR, CDR, CELL_INTERPRETATION, CONS, copy_effect(), copy_expression(), EFFECT, effect_any_reference, ENDP, entity_domain, entity_local_name(), EXPRESSION, expression_to_post_pv(), expression_to_type(), expression_undefined, FOREACH, free_expression(), free_pv_results_paths(), free_type(), gen_find_tabulated(), gen_full_free_list(), gen_last(), gen_length(), gen_nreverse(), int, pv_results::l_out, make_cell_interpretation_address_of(), make_entity_fullname(), make_pv_results(), make_unbounded_expression(), MakeBinaryCall(), MakeUnaryCall(), MINUS_C_OPERATOR_NAME, NIL, pips_debug, pips_debug_pv_results, PLUS_C_OPERATOR_NAME, pointer_type_p(), reference_indices, pv_results::result_paths, pv_results::result_paths_interpretations, same_string_p, string_of_type(), TOP_LEVEL_MODULE_NAME, type_to_string(), type_variable, UNARY_MINUS_OPERATOR_NAME, and variable_dimensions.

Here is the call graph for this function:

◆ c_io_function_to_post_pv()

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

static

first argument is a FILE*

last argument is a FILE*

we assume that there is no effects on aliasing due to FILE* argument if any

Definition at line 1495 of file pointer_values_intrinsics.c.

 {
   const char* func_name = entity_local_name(func);
   list general_args = NIL;
   bool free_general_args = false;
   list l_in_cur = l_in;
  
   /* first argument is a FILE*  */
   if (same_string_p(func_name,FCLOSE_FUNCTION_NAME)
       || same_string_p(func_name,FPRINTF_FUNCTION_NAME)
       || same_string_p(func_name,FSCANF_FUNCTION_NAME)
       || same_string_p(func_name,VFPRINTF_FUNCTION_NAME)
       || same_string_p(func_name,VFSCANF_FUNCTION_NAME)
       || same_string_p(func_name,ISOC99_VFSCANF_FUNCTION_NAME)
       || same_string_p(func_name,FGETC_FUNCTION_NAME)
       || same_string_p(func_name,GETC_FUNCTION_NAME)
       || same_string_p(func_name,_IO_GETC_FUNCTION_NAME)
       || same_string_p(func_name,FGETPOS_FUNCTION_NAME)
       || same_string_p(func_name,FSEEK_FUNCTION_NAME)
       || same_string_p(func_name,FSETPOS_FUNCTION_NAME)
       || same_string_p(func_name,FTELL_FUNCTION_NAME)
       || same_string_p(func_name,C_REWIND_FUNCTION_NAME)
       || same_string_p(func_name,CLEARERR_FUNCTION_NAME)
       || same_string_p(func_name,FEOF_FUNCTION_NAME)
       || same_string_p(func_name,FERROR_FUNCTION_NAME))
     {
       general_args = CDR(func_args);
     }
   /* last argument is a FILE*  */
   else if (same_string_p(func_name,FGETS_FUNCTION_NAME)
            || same_string_p(func_name,FPUTC_FUNCTION_NAME)
            || same_string_p(func_name,FPUTS_FUNCTION_NAME)
            || same_string_p(func_name,PUTC_FUNCTION_NAME)
            || same_string_p(func_name,_IO_PUTC_FUNCTION_NAME)
            || same_string_p(func_name,UNGETC_FUNCTION_NAME)
            || same_string_p(func_name,FREAD_FUNCTION_NAME)
            || same_string_p(func_name,FWRITE_FUNCTION_NAME))
     {
       for(; !ENDP(CDR(func_args)); POP(func_args))
         {
           general_args = CONS(EXPRESSION, EXPRESSION(CAR(func_args)), general_args);
         }
       free_general_args = true;
     }
  
   /* we assume that there is no effects on aliasing due to FILE* argument if any */
  
   safe_intrinsic_to_post_pv(func, general_args, l_in_cur, pv_res, ctxt);
  
   if (free_general_args)
     gen_free_list(general_args);
 }

References _IO_GETC_FUNCTION_NAME, _IO_PUTC_FUNCTION_NAME, C_REWIND_FUNCTION_NAME, CAR, CDR, CLEARERR_FUNCTION_NAME, CONS, ENDP, entity_local_name(), EXPRESSION, FCLOSE_FUNCTION_NAME, FEOF_FUNCTION_NAME, FERROR_FUNCTION_NAME, FGETC_FUNCTION_NAME, FGETPOS_FUNCTION_NAME, FGETS_FUNCTION_NAME, FPRINTF_FUNCTION_NAME, FPUTC_FUNCTION_NAME, FPUTS_FUNCTION_NAME, FREAD_FUNCTION_NAME, FSCANF_FUNCTION_NAME, FSEEK_FUNCTION_NAME, FSETPOS_FUNCTION_NAME, FTELL_FUNCTION_NAME, FWRITE_FUNCTION_NAME, gen_free_list(), GETC_FUNCTION_NAME, ISOC99_VFSCANF_FUNCTION_NAME, NIL, POP, PUTC_FUNCTION_NAME, safe_intrinsic_to_post_pv(), same_string_p, UNGETC_FUNCTION_NAME, VFPRINTF_FUNCTION_NAME, and VFSCANF_FUNCTION_NAME.

Here is the call graph for this function:

◆ c_return_to_post_pv() [1/2]

static void c_return_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

but we have to evaluate the impact of the argument evaluation on pointer values eliminate local variables, retrieve the value of the returned pointer if any...

Definition at line 1853 of file pointer_values_intrinsics.c.

 {
   /* but we have to evaluate the impact
      of the argument evaluation on pointer values
      eliminate local variables, retrieve the value of the returned pointer if any...
   */
   if (!ENDP(func_args))
     expression_to_post_pv(EXPRESSION(CAR(func_args)), l_in, pv_res, ctxt);
 }

References CAR, ENDP, EXPRESSION, and expression_to_post_pv().

Here is the call graph for this function:

◆ c_return_to_post_pv() [2/2]

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

static

◆ conditional_operator_to_post_pv() [1/2]

static void conditional_operator_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

well, it should be a union, but there may not be such stupid things as (..)? a:a; I cannot use the effects test union operator because I must also merge interpretations

Definition at line 1382 of file pointer_values_intrinsics.c.

 {
   pips_debug(1, "begin for conditional operator\n");
  
   expression t_cond = EXPRESSION(CAR(func_args));
   POP(func_args);
   expression t_true = EXPRESSION(CAR(func_args));
   POP(func_args);
   expression t_false = EXPRESSION(CAR(func_args));
  
   pv_results pv_res_cond = make_pv_results();
   expression_to_post_pv(t_cond, l_in, &pv_res_cond, ctxt);
  
   list l_in_branches = pv_res_cond.l_out;
  
   pv_results pv_res_true = make_pv_results();
   list l_in_true = gen_full_copy_list(l_in_branches);
   expression_to_post_pv(t_true, l_in_true, &pv_res_true, ctxt);
   if (pv_res_true.l_out != l_in_true) gen_full_free_list(l_in_true);
  
   pv_results pv_res_false = make_pv_results();
   list l_in_false = gen_full_copy_list(l_in_branches);
   expression_to_post_pv(t_false, l_in_false, &pv_res_false, ctxt);
   if (pv_res_false.l_out != l_in_false) gen_full_free_list(l_in_false);
  
  
   pv_res->l_out = (*ctxt->pvs_may_union_func)(pv_res_true.l_out,
                                               gen_full_copy_list(pv_res_false.l_out));
  
   /* well, it should be a union, but there may not be such stupid things as (..)? a:a;
    I cannot use the effects test union operator because I must also merge
    interpretations */
   pv_res->result_paths = gen_nconc(pv_res_true.result_paths, pv_res_false.result_paths);
   effects_to_may_effects(pv_res->result_paths);
   pv_res->result_paths_interpretations =
     gen_nconc(pv_res_true.result_paths_interpretations,
               pv_res_false.result_paths_interpretations);
  
   pips_debug_pv_results(1, "end with pv_results =\n", *pv_res);
   pips_debug(1, "end\n");
  
 }

References CAR, effects_to_may_effects(), EXPRESSION, expression_to_post_pv(), gen_full_copy_list(), gen_full_free_list(), gen_nconc(), pv_results::l_out, make_pv_results(), pips_debug, pips_debug_pv_results, POP, pv_context::pvs_may_union_func, pv_results::result_paths, and pv_results::result_paths_interpretations.

Here is the call graph for this function:

◆ conditional_operator_to_post_pv() [2/2]

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

static

◆ default_intrinsic_to_post_pv() [1/2]

static void default_intrinsic_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

free the result paths of the previous expression evaluation

Definition at line 1954 of file pointer_values_intrinsics.c.

 {
   list l_in_cur = l_in;
   FOREACH(EXPRESSION, arg, func_args)
     {
       /* free the result paths of the previous expression evaluation */
       free_pv_results_paths(pv_res);
       expression_to_post_pv(arg, l_in_cur, pv_res, ctxt);
       l_in_cur = pv_res->l_out;
     }
 }

References EXPRESSION, expression_to_post_pv(), FOREACH, free_pv_results_paths(), and pv_results::l_out.

Here is the call graph for this function:

◆ default_intrinsic_to_post_pv() [2/2]

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

static

◆ dereferencing_to_post_pv() [1/2]

static void dereferencing_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

Definition at line 1429 of file pointer_values_intrinsics.c.

 {
   expression_to_post_pv(EXPRESSION(CAR(func_args)), l_in, pv_res, ctxt);
   list l_eff_ci = pv_res->result_paths_interpretations;
   FOREACH(EFFECT, eff, pv_res->result_paths)
     {
       cell_interpretation ci = CELL_INTERPRETATION(CAR(l_eff_ci));
       if (cell_interpretation_value_of_p(ci))
         effect_add_dereferencing_dimension(eff);
       else
         cell_interpretation_tag(ci) = is_cell_interpretation_value_of;
       POP(l_eff_ci);
     }
 }

References CAR, CELL_INTERPRETATION, cell_interpretation_tag, cell_interpretation_value_of_p, EFFECT, effect_add_dereferencing_dimension(), EXPRESSION, expression_to_post_pv(), FOREACH, is_cell_interpretation_value_of, POP, pv_results::result_paths, and pv_results::result_paths_interpretations.

Here is the call graph for this function:

◆ dereferencing_to_post_pv() [2/2]

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

static

◆ field_to_post_pv() [1/2]

static void field_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

Definition at line 1445 of file pointer_values_intrinsics.c.

 {
   expression e2 = EXPRESSION(CAR(CDR(func_args)));
   syntax s2 = expression_syntax(e2);
   reference r2 = syntax_reference(s2);
   entity f = reference_variable(r2);
  
   pips_assert("e2 is a reference", syntax_reference_p(s2));
   pips_debug(4, "It's a field operator\n");
  
   expression_to_post_pv(EXPRESSION(CAR(func_args)), l_in, pv_res, ctxt);
   FOREACH(EFFECT, eff, pv_res->result_paths)
     {
       effect_add_field_dimension(eff,f);
     }
 }

References CAR, CDR, EFFECT, effect_add_field_dimension(), EXPRESSION, expression_syntax, expression_to_post_pv(), f(), FOREACH, pips_assert, pips_debug, reference_variable, pv_results::result_paths, syntax_reference, and syntax_reference_p.

Here is the call graph for this function:

◆ field_to_post_pv() [2/2]

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

static

◆ free_to_post_pv()

static void free_to_post_pv	(	list	l_free_eff,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

for each freed pointer, find it's targets

try to find the heap location

try to find the heap target in remants

try first to find another target

try to find the heap location

assign an undefined_value to freed pointer

no flow or context sensitive variable found

FOREACH

Definition at line 1568 of file pointer_values_intrinsics.c.

 {
   pips_debug_effects(5, "begin with input effects :\n", l_free_eff);
  
   FOREACH(EFFECT, eff, l_free_eff)
   {
     /* for each freed pointer, find it's targets */
  
     list l_remnants = NIL;
     cell_relation exact_eff_pv = cell_relation_undefined;
     list l_values = NIL;
  
     pips_debug_effect(4, "begin, looking for an exact target for eff:\n",
         eff);
  
     l_values = effect_find_equivalent_pointer_values(eff, l_in,
         &exact_eff_pv,
         &l_remnants);
     pips_debug_pvs(3, "l_values:\n", l_values);
     pips_debug_pvs(3, "l_remnants:\n", l_remnants);
     pips_debug_pv(3, "exact_eff_pv:\n", exact_eff_pv);
  
     list l_heap_eff = NIL;
  
     if (exact_eff_pv != cell_relation_undefined)
     {
       cell heap_c = cell_undefined;
       /* try to find the heap location */
       cell c1 = cell_relation_first_cell(exact_eff_pv);
       entity e1 = reference_variable(cell_reference(c1));
  
       cell c2 = cell_relation_second_cell(exact_eff_pv);
       entity e2 = reference_variable(cell_reference(c2));
  
       if (entity_flow_or_context_sentitive_heap_location_p(e1))
         heap_c = c1;
       else if (entity_flow_or_context_sentitive_heap_location_p(e2))
         heap_c = c2;
       if (!cell_undefined_p(heap_c))
         l_heap_eff =
             CONS(EFFECT,
                 make_effect(copy_cell(heap_c),
                     make_action_write_memory(),
                     copy_approximation(effect_approximation(eff)),
                     make_descriptor_none()),
                     NIL);
       else
       {
         /* try to find the heap target in remants */
         cell other_c = cell_undefined;
         if (same_entity_p(effect_entity(eff), e1))
           other_c = c2;
         else other_c = c1;
         list l_tmp =
             CONS(EFFECT,
                 make_effect(copy_cell(other_c),
                     make_action_write_memory(),
                     copy_approximation(effect_approximation(eff)),
                     make_descriptor_none()),
                     NIL);
         free_to_post_pv(l_tmp, l_remnants, pv_res, ctxt);
         pv_res->l_out = CONS(CELL_RELATION,
             copy_cell_relation(exact_eff_pv),
             pv_res->l_out);
         gen_free_list(l_tmp);
         return;
       }
     }
     else
     {
       /* try first to find another target */
       FOREACH(CELL_RELATION, pv_tmp, l_values) {
         cell heap_c = cell_undefined;
         /* try to find the heap location */
         cell c1 = cell_relation_first_cell(pv_tmp);
         entity e1 = reference_variable(cell_reference(c1));
  
         cell c2 = cell_relation_second_cell(pv_tmp);
         entity e2 = reference_variable(cell_reference(c2));
  
         if (entity_flow_or_context_sentitive_heap_location_p(e1))
           heap_c = c1;
         else if (entity_flow_or_context_sentitive_heap_location_p(e2))
           heap_c = c2;
         if (!cell_undefined_p(heap_c))
           l_heap_eff =
               CONS(EFFECT,
                   make_effect(copy_cell(heap_c),
                       make_action_write_memory(),
                       cell_relation_exact_p(pv_tmp)
                       ? copy_approximation
                           (effect_approximation(eff))
                           :make_approximation_may(),
                            make_descriptor_none()),
                            NIL);
  
       }
     }
  
     if (!ENDP(l_heap_eff))
     {
       /* assign an undefined_value to freed pointer */
       list l_rhs =
           CONS(EFFECT,
               make_effect( make_undefined_pointer_value_cell(),
                   make_action_write_memory(),
                   make_approximation_exact(),
                   make_descriptor_none()),
                   NIL);
       list l_kind = CONS(CELL_INTERPRETATION,
           make_cell_interpretation_value_of(),
           NIL);
       single_pointer_assignment_to_post_pv(eff, l_rhs, l_kind,
           false, l_in, pv_res, ctxt);
       gen_full_free_list(l_rhs);
       gen_full_free_list(l_kind);
       free_pv_results_paths(pv_res);
       if (l_in != pv_res->l_out)
       {
         gen_full_free_list(l_in);
         l_in = pv_res->l_out;
       }
       pips_debug_pvs(5, "l_in after assigning "
           "undefined value to freed pointer:\n",
           l_in);
  
       FOREACH(EFFECT, heap_eff, l_heap_eff)
       {
         entity heap_e =
             reference_variable(effect_any_reference(heap_eff));
         pips_debug(5, "heap entity found (%s)\n", entity_name(heap_e));
  
         pointer_values_remove_var(heap_e,
             effect_may_p(eff)
             || effect_may_p(heap_eff),
             l_in,
             pv_res, ctxt);
         l_in= pv_res->l_out;
       }
     }
     else /* no flow or context sensitive variable found */
     {
       list l_rhs =
           CONS(EFFECT,
               make_effect( make_undefined_pointer_value_cell(),
                   make_action_write_memory(),
                   make_approximation_exact(),
                   make_descriptor_none()),
                   NIL);
       list l_kind = CONS(CELL_INTERPRETATION,
           make_cell_interpretation_value_of(),
           NIL);
       single_pointer_assignment_to_post_pv(eff, l_rhs, l_kind,
           false, l_in, pv_res, ctxt);
       gen_full_free_list(l_rhs);
       gen_full_free_list(l_kind);
       free_pv_results_paths(pv_res);
       if (l_in != pv_res->l_out)
       {
         gen_full_free_list(l_in);
         l_in = pv_res->l_out;
       }
       pips_debug_pvs(5, "l_in after assigning "
           "undefined value to freed pointer:\n",
           l_in);
     }
  
   } /* FOREACH */
   pips_debug_pvs(5, "end with pv_res->l_out:", pv_res->l_out);
 }

References CELL_INTERPRETATION, cell_reference, CELL_RELATION, cell_relation_exact_p, cell_relation_first_cell, cell_relation_second_cell, cell_relation_undefined, cell_undefined, cell_undefined_p, CONS, copy_approximation(), copy_cell(), copy_cell_relation(), EFFECT, effect_any_reference, effect_approximation, effect_entity(), effect_find_equivalent_pointer_values(), effect_may_p, ENDP, entity_flow_or_context_sentitive_heap_location_p(), entity_name, FOREACH, free_pv_results_paths(), gen_free_list(), gen_full_free_list(), pv_results::l_out, make_action_write_memory(), make_approximation_exact(), make_approximation_may(), make_cell_interpretation_value_of(), make_descriptor_none(), make_effect(), make_undefined_pointer_value_cell(), NIL, pips_debug, pips_debug_effect, pips_debug_effects, pips_debug_pv, pips_debug_pvs, pointer_values_remove_var(), reference_variable, same_entity_p(), and single_pointer_assignment_to_post_pv().

Referenced by heap_intrinsic_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ heap_intrinsic_to_post_pv()

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

static

free the previously allocated path if need be

Then retrieve the allocated path if any

first, impact of argument evaluation on pointer values

Definition at line 1740 of file pointer_values_intrinsics.c.

 {
   const char* func_name = entity_local_name(func);
   expression malloc_arg = expression_undefined;
   bool free_malloc_arg = false;
   list l_in_cur = l_in;
  
  
   /* free the previously allocated path if need be */
   if (same_string_p(func_name, FREE_FUNCTION_NAME)
       || same_string_p(func_name, REALLOC_FUNCTION_NAME))
     {
       expression free_ptr_exp = EXPRESSION(CAR(func_args));
  
       pv_results pv_res_arg = make_pv_results();
       expression_to_post_pv(free_ptr_exp, l_in_cur, &pv_res_arg, ctxt);
       if (pv_res_arg.l_out != l_in_cur)
         {
           gen_full_free_list(l_in_cur);
           l_in_cur = pv_res_arg.l_out;
         }
       free_to_post_pv(pv_res_arg.result_paths, l_in_cur, pv_res, ctxt);
       l_in_cur = pv_res->l_out;
     }
  
   /* Then retrieve the allocated path if any */
   if(same_string_p(func_name, MALLOC_FUNCTION_NAME))
     {
       malloc_arg = EXPRESSION(CAR(func_args));
     }
   else if(same_string_p(func_name, CALLOC_FUNCTION_NAME))
     {
       malloc_arg =
         make_op_exp("*",
                    copy_expression(EXPRESSION(CAR(func_args))),
                    copy_expression(EXPRESSION(CAR(CDR(func_args)))));
       free_malloc_arg = true;
     }
   else if (same_string_p(func_name, REALLOC_FUNCTION_NAME))
     {
       malloc_arg = EXPRESSION(CAR(CDR(func_args)));
     }
   else if (same_string_p(func_name, STRDUP_FUNCTION_NAME))
   {
       malloc_arg = MakeBinaryCall(
               entity_intrinsic(PLUS_OPERATOR_NAME),
               int_to_expression(1),
               MakeUnaryCall(
                   entity_intrinsic(STRLEN_FUNCTION_NAME),
                   copy_expression(EXPRESSION(CAR(func_args)))
                   )
               );
       free_malloc_arg = true;
   }
  
   if (!expression_undefined_p(malloc_arg))
     {
  
       /* first, impact of argument evaluation on pointer values */
       pv_results pv_res_arg = make_pv_results();
       expression_to_post_pv(malloc_arg, l_in_cur, &pv_res_arg, ctxt);
       free_pv_results_paths(&pv_res_arg);
       if (pv_res_arg.l_out != l_in_cur)
         {
           gen_full_free_list(l_in_cur);
           l_in_cur = pv_res_arg.l_out;
         }
  
       sensitivity_information si =
         make_sensitivity_information(pv_context_statement_head(ctxt),
                                      get_current_module_entity(),
                                      NIL);
       entity e = malloc_to_abstract_location(malloc_arg, &si);
  
       effect eff = make_effect(make_cell_reference(make_reference(e, NIL)),
                                make_action_write_memory(),
                                make_approximation_exact(),
                                make_descriptor_none());
  
       if (!entity_all_heap_locations_p(e) &&
           !entity_all_module_heap_locations_p(e))
         {
           if (!entity_scalar_p(e))
             effect_add_dereferencing_dimension(eff); // well, in fact, it's a [0] array dimension!
         }
       else
         effect_to_may_effect(eff);
       pv_res->result_paths = CONS(EFFECT, eff, NIL);
       pv_res->result_paths_interpretations =
         CONS(CELL_INTERPRETATION,
              make_cell_interpretation_address_of(),
              NIL);
       if (free_malloc_arg)
         free_expression(malloc_arg);
     }
  
   pv_res->l_out = l_in_cur;
 }

References CALLOC_FUNCTION_NAME, CAR, CDR, CELL_INTERPRETATION, CONS, copy_expression(), EFFECT, effect_add_dereferencing_dimension(), effect_to_may_effect(), entity_all_heap_locations_p(), entity_all_module_heap_locations_p(), entity_intrinsic(), entity_local_name(), entity_scalar_p(), EXPRESSION, expression_to_post_pv(), expression_undefined, expression_undefined_p, free_expression(), FREE_FUNCTION_NAME, free_pv_results_paths(), free_to_post_pv(), gen_full_free_list(), get_current_module_entity(), int_to_expression(), pv_results::l_out, make_action_write_memory(), make_approximation_exact(), make_cell_interpretation_address_of(), make_cell_reference(), make_descriptor_none(), make_effect(), make_op_exp(), make_pv_results(), make_reference(), make_sensitivity_information(), MakeBinaryCall(), MakeUnaryCall(), MALLOC_FUNCTION_NAME, malloc_to_abstract_location(), NIL, PLUS_OPERATOR_NAME, pv_context_statement_head(), REALLOC_FUNCTION_NAME, pv_results::result_paths, pv_results::result_paths_interpretations, same_string_p, STRDUP_FUNCTION_NAME, and STRLEN_FUNCTION_NAME.

Here is the call graph for this function:

◆ intrinsic_to_identical_post_pv() [1/2]

static void intrinsic_to_identical_post_pv	(	entity __attribute__((unused))	func,
		list __attribute__((unused))	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context __attribute__((unused)) *	ctxt
	)

static

Definition at line 1938 of file pointer_values_intrinsics.c.

 {
   pv_res->l_out = l_in;
 }

References pv_results::l_out.

◆ intrinsic_to_identical_post_pv() [2/2]

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

static

◆ 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:

◆ logical_operator_to_post_pv() [1/2]

static void logical_operator_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

If it is a pure logical operator (&& or ||), there is a sequence point just after the evaluation of the first operand so we must evaluate the second operand in the memory store resulting from the evaluation of the first operand. If it's a relational operator, the evaluation order is not important, so let's do the same !

first operand

second operand

the resulting path of a relational expression is not a pointer value

Definition at line 1353 of file pointer_values_intrinsics.c.

 {
   expression e1 = EXPRESSION(CAR(func_args));
   expression e2 = EXPRESSION(CAR(CDR(func_args)));
   pv_results pv_res1 = make_pv_results();
  
   /* If it is a pure logical operator (&& or ||), there is a
      sequence point just after the evaluation of the first operand
      so we must evaluate the second operand in the memory store
      resulting from the evaluation of the first operand.
      If it's a relational operator, the evaluation order is not important,
      so let's do the same !
   */
   /* first operand */
   expression_to_post_pv(e1, l_in, &pv_res1, ctxt);
   list l_in_cur = pv_res1.l_out;
   if (l_in != l_in_cur) gen_full_free_list(l_in);
   free_pv_results_paths(&pv_res1);
  
   /* second operand */
   expression_to_post_pv(e2, l_in_cur, pv_res, ctxt);
   free_pv_results_paths(pv_res);
   /* the resulting path of a relational expression is not a pointer value */
   pv_res->result_paths = NIL;
   pv_res->result_paths_interpretations = NIL;
 }

References CAR, CDR, EXPRESSION, expression_to_post_pv(), free_pv_results_paths(), gen_full_free_list(), pv_results::l_out, make_pv_results(), NIL, pv_results::result_paths, and pv_results::result_paths_interpretations.

Here is the call graph for this function:

◆ logical_operator_to_post_pv() [2/2]

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

static

◆ point_to_to_post_pv() [1/2]

static void point_to_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

We add a dereferencing

we add the field dimension

Definition at line 1463 of file pointer_values_intrinsics.c.

 {
   expression e2 = EXPRESSION(CAR(CDR(func_args)));
   syntax s2 = expression_syntax(e2);
   entity f;
  
   pips_assert("e2 is a reference", syntax_reference_p(s2));
   f = reference_variable(syntax_reference(s2));
  
   pips_debug(4, "It's a point to operator\n");
   expression_to_post_pv(EXPRESSION(CAR(func_args)), l_in, pv_res, ctxt);
  
   FOREACH(EFFECT, eff, pv_res->result_paths)
     {
       /* We add a dereferencing */
       effect_add_dereferencing_dimension(eff);
       /* we add the field dimension */
       effect_add_field_dimension(eff,f);
     }
 }

References CAR, CDR, EFFECT, effect_add_dereferencing_dimension(), effect_add_field_dimension(), EXPRESSION, expression_syntax, expression_to_post_pv(), f(), FOREACH, pips_assert, pips_debug, reference_variable, pv_results::result_paths, syntax_reference, and syntax_reference_p.

Here is the call graph for this function:

◆ point_to_to_post_pv() [2/2]

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

static

◆ safe_intrinsic_to_post_pv() [1/2]

static void safe_intrinsic_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

first assume that all pointers reachable from arguments are written and set to anywhere

this should be quickly refined

well this is not safe in case of arguments with external function calls I should use the result paths of pv_res_arg, but there is a lot of work done in c_actual_argument_to_may_ summary_effect about arrays, and I'm not sure expression_to_post_pv does the same job

assume all pointers now point to anywhere

then retrieve the return value type to set pv_res->result_paths

if it is a pointer type, set it to anywhere for the moment specific work should be done for each intrinsic

Definition at line 1864 of file pointer_values_intrinsics.c.

 {
   /* first assume that all pointers reachable from arguments are written and set to
      anywhere */
   /* this should be quickly refined */
   list l_anywhere_eff = CONS(EFFECT, make_anywhere_effect(make_action_write_memory()),
                              NIL);
   list l_rhs_kind = CONS(CELL_INTERPRETATION,
                          make_cell_interpretation_address_of(), NIL);
  
   pips_debug(1, "begin\n");
  
   if (!ENDP(func_args))
     {
       list lw = NIL;
       list l_in_cur = l_in;
       FOREACH(EXPRESSION, arg, func_args)
         {
           pv_results pv_res_arg = make_pv_results();
           expression_to_post_pv(arg, l_in_cur, &pv_res_arg, ctxt);
           free_pv_results_paths(&pv_res_arg);
           if (pv_res_arg.l_out != l_in_cur)
             {
               //gen_full_free_list(l_in_cur);
               l_in_cur = pv_res_arg.l_out;
             }
           /* well this is not safe in case of arguments with external function calls
              I should use the result paths of pv_res_arg, but there is a lot of work
              done in c_actual_argument_to_may_ summary_effect about arrays, and I'm not
              sure expression_to_post_pv does the same job
           */
           lw = gen_nconc(lw, c_actual_argument_to_may_summary_effects(arg, 'w'));
         }
  
       pips_debug_effects(3, "effects to be killed: \n", lw);
  
       /* assume all pointers now point to anywhere */
  
       FOREACH(EFFECT, eff, lw)
         {
           bool to_be_freed = false;
           type t = cell_to_type(effect_cell(eff), &to_be_freed);
           if (pointer_type_p(t))
             {
               single_pointer_assignment_to_post_pv(eff,
                                                    l_anywhere_eff, l_rhs_kind,
                                                    false, l_in_cur,
                                                    pv_res, ctxt);
               if (pv_res->l_out != l_in_cur)
                 {
                   gen_full_free_list(l_in_cur);
                   l_in_cur = pv_res->l_out;
                 }
               free_pv_results_paths(pv_res);
             }
           if (to_be_freed) free_type(t);
         }
       pv_res->l_out = l_in_cur;
     }
   else
     pv_res->l_out = l_in;
   /* then retrieve the return value type to set pv_res->result_paths */
   /* if it is a pointer type, set it to anywhere for the moment
      specific work should be done for each intrinsic
   */
   pv_res->result_paths = l_anywhere_eff;
   pv_res->result_paths_interpretations = l_rhs_kind;
  
   pips_debug_pv_results(1, "ending with pv_res:", *pv_res);
  
 }

References c_actual_argument_to_may_summary_effects(), CELL_INTERPRETATION, cell_to_type(), CONS, EFFECT, effect_cell, ENDP, EXPRESSION, expression_to_post_pv(), FOREACH, free_pv_results_paths(), free_type(), gen_full_free_list(), gen_nconc(), pv_results::l_out, make_action_write_memory(), make_anywhere_effect(), make_cell_interpretation_address_of(), make_pv_results(), NIL, pips_debug, pips_debug_effects, pips_debug_pv_results, pointer_type_p(), pv_results::result_paths, pv_results::result_paths_interpretations, and single_pointer_assignment_to_post_pv().

Here is the call graph for this function:

◆ safe_intrinsic_to_post_pv() [2/2]

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

static

Referenced by c_io_function_to_post_pv(), string_function_to_post_pv(), unix_io_function_to_post_pv(), and va_list_function_to_post_pv().

Here is the caller graph for this function:

◆ string_function_to_post_pv()

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

static

Definition at line 1555 of file pointer_values_intrinsics.c.

 {
   safe_intrinsic_to_post_pv(func, func_args, l_in, pv_res, ctxt);
 }

References safe_intrinsic_to_post_pv().

Here is the call graph for this function:

◆ unary_arithmetic_operator_to_post_pv() [1/2]

static void unary_arithmetic_operator_to_post_pv	(	entity __attribute__((unused))	func,
		list	func_args,
		list	l_in,
		pv_results *	pv_res,
		pv_context *	ctxt
	)

static

Definition at line 1279 of file pointer_values_intrinsics.c.

 {
   expression arg = EXPRESSION(CAR(func_args));
   expression_to_post_pv(arg, l_in, pv_res, ctxt);
   ifdebug(1)
   {
     type t = expression_to_type(arg);
     pips_assert("unary arithmetic operators should not have pointer arguments",
         !pointer_type_p(t));
     free_type(t);
   }
 }

References CAR, EXPRESSION, expression_to_post_pv(), expression_to_type(), free_type(), ifdebug, pips_assert, and pointer_type_p().

Here is the call graph for this function:

◆ unary_arithmetic_operator_to_post_pv() [2/2]

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

static

◆ unix_io_function_to_post_pv()

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

static

Definition at line 1549 of file pointer_values_intrinsics.c.

 {
   safe_intrinsic_to_post_pv(func, func_args, l_in, pv_res, ctxt);
 }

References safe_intrinsic_to_post_pv().

Here is the call graph for this function:

◆ unknown_intrinsic_to_post_pv() [1/2]

static void unknown_intrinsic_to_post_pv	(	entity __attribute__((unused))	func,
		list __attribute__((unused))	func_args,
		list __attribute__((unused))	l_in,
		pv_results __attribute__((unused)) *	pv_res,
		pv_context __attribute__((unused)) *	ctxt
	)

static

Definition at line 1945 of file pointer_values_intrinsics.c.

 {
   pips_internal_error("not a C intrinsic");
 }

References pips_internal_error.

◆ unknown_intrinsic_to_post_pv() [2/2]

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

static

◆ update_operator_to_post_pv()

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

static

build rhs

_lhs_kind = CONS(CELL_INTERPRETATION, make_cell_interpretation_address_of(), NIL);

Definition at line 1295 of file pointer_values_intrinsics.c.

 {
   pips_debug(1, "begin for update operator\n");
  
   expression arg = EXPRESSION(CAR(func_args));
   expression_to_post_pv(arg, l_in, pv_res, ctxt);
   list l_in_cur = pv_res->l_out;
   if (l_in != l_in_cur) gen_full_free_list(l_in);
  
   type t = expression_to_type(arg);
   if (pointer_type_p(t))
   {
     list l_lhs_eff = pv_res->result_paths;
     //list l_lhs_kind = pv_res->result_paths_interpretations;
     const char* func_name = entity_local_name(func);
  
     pips_assert("update operators admit a single path\n",
         gen_length(l_lhs_eff) == (size_t) 1);
  
     effect lhs_eff = EFFECT(CAR(l_lhs_eff));
     effect rhs_eff = copy_effect(lhs_eff);
     list l_rhs_kind = CONS(CELL_INTERPRETATION, make_cell_interpretation_address_of(),
         NIL);
  
     if (!anywhere_effect_p(lhs_eff))
     {
       /* build rhs */
       expression new_dim = expression_undefined;
  
       if (same_string_p(func_name, POST_INCREMENT_OPERATOR_NAME)
           || same_string_p(func_name, PRE_INCREMENT_OPERATOR_NAME))
       {
         new_dim = int_to_expression(1);
       }
       else if (same_string_p(func_name, POST_DECREMENT_OPERATOR_NAME)
           || same_string_p(func_name, PRE_DECREMENT_OPERATOR_NAME))
       {
         new_dim = int_to_expression(-1);
       }
       else
         //pips_internal_error("unexpected update operator on pointers");
         new_dim = make_unbounded_expression();
  
       // 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, new_dim);
       /*l_lhs_kind = CONS(CELL_INTERPRETATION, make_cell_interpretation_address_of(),
                           NIL);*/
     }
     list l_rhs_eff = CONS(EFFECT, rhs_eff, NIL);
     single_pointer_assignment_to_post_pv(lhs_eff, l_rhs_eff, l_rhs_kind, false,
         l_in_cur, pv_res, ctxt);
   }
   pips_debug_pv_results(1, "end with pv_res:\n", *pv_res);
 }

References anywhere_effect_p(), CAR, CELL_INTERPRETATION, CONS, copy_effect(), EFFECT, entity_local_name(), EXPRESSION, expression_to_post_pv(), expression_to_type(), expression_undefined, gen_full_free_list(), gen_length(), int_to_expression(), pv_results::l_out, make_cell_interpretation_address_of(), make_unbounded_expression(), NIL, pips_assert, pips_debug, pips_debug_pv_results, pointer_type_p(), POST_DECREMENT_OPERATOR_NAME, POST_INCREMENT_OPERATOR_NAME, PRE_DECREMENT_OPERATOR_NAME, PRE_INCREMENT_OPERATOR_NAME, pv_results::result_paths, same_string_p, and single_pointer_assignment_to_post_pv().

Here is the call graph for this function:

◆ va_list_function_to_post_pv()

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

static

Definition at line 1561 of file pointer_values_intrinsics.c.

 {
   safe_intrinsic_to_post_pv(func, func_args, l_in, pv_res, ctxt);
 }

References safe_intrinsic_to_post_pv().

Here is the call graph for this function:

Variable Documentation

◆ IntrinsicToPostPVDescriptorTable

IntrinsicToPostPVDescriptor IntrinsicToPostPVDescriptorTable[]

static

Definition at line 92 of file pointer_values_intrinsics.c.

Referenced by intrinsic_to_post_pv().

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

◆ IntrinsicToPostPVDescriptor

Function Documentation

◆ address_of_to_post_pv() [1/2]

◆ address_of_to_post_pv() [2/2]

◆ assignment_intrinsic_to_post_pv() [1/2]

◆ assignment_intrinsic_to_post_pv() [2/2]

◆ binary_arithmetic_operator_to_post_pv()

◆ c_io_function_to_post_pv()

◆ c_return_to_post_pv() [1/2]

◆ c_return_to_post_pv() [2/2]

◆ conditional_operator_to_post_pv() [1/2]

◆ conditional_operator_to_post_pv() [2/2]

◆ default_intrinsic_to_post_pv() [1/2]

◆ default_intrinsic_to_post_pv() [2/2]

◆ dereferencing_to_post_pv() [1/2]

◆ dereferencing_to_post_pv() [2/2]

◆ field_to_post_pv() [1/2]

◆ field_to_post_pv() [2/2]

◆ free_to_post_pv()

◆ heap_intrinsic_to_post_pv()

◆ intrinsic_to_identical_post_pv() [1/2]

◆ intrinsic_to_identical_post_pv() [2/2]

◆ intrinsic_to_post_pv()

◆ logical_operator_to_post_pv() [1/2]

◆ logical_operator_to_post_pv() [2/2]

◆ point_to_to_post_pv() [1/2]

◆ point_to_to_post_pv() [2/2]

◆ safe_intrinsic_to_post_pv() [1/2]

◆ safe_intrinsic_to_post_pv() [2/2]

◆ string_function_to_post_pv()

◆ unary_arithmetic_operator_to_post_pv() [1/2]

◆ unary_arithmetic_operator_to_post_pv() [2/2]

◆ unix_io_function_to_post_pv()

◆ unknown_intrinsic_to_post_pv() [1/2]

◆ unknown_intrinsic_to_post_pv() [2/2]

◆ update_operator_to_post_pv()

◆ va_list_function_to_post_pv()

Variable Documentation

◆ IntrinsicToPostPVDescriptorTable