eval.c File Reference

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

Include dependency graph for eval.c:

Go to the source code of this file.

Functions
bool	simple_cell_reference_preceding_p (reference r1, descriptor __attribute__((unused)) d1, reference r2, descriptor __attribute__((unused)) d2, transformer __attribute__((unused)) current_precondition, bool strict_p, bool *exact_p)
bool	simple_cell_preceding_p (cell c1, descriptor d1, cell c2, descriptor d2, transformer current_precondition, bool strict_p, bool *exact_p)
bool	path_preceding_p (effect eff1, effect eff2, transformer current_precondition, bool strict_p, bool *exact_p)
void	simple_reference_to_simple_reference_conversion (reference ref, reference *output_ref, descriptor *output_desc)
void	simple_cell_to_simple_cell_conversion (cell input_cell, cell *output_cell, descriptor *output_desc)
list	eval_simple_cell_with_points_to (cell c, descriptor __attribute__((unused)) d, list ptl, bool *exact_p, transformer __attribute__((unused)) t)
list	simple_effect_to_constant_path_effects_with_pointer_values (effect eff)
list	effect_to_constant_path_effects_with_points_to (effect eff, statement s, transformer context)
list	simple_effect_to_constant_path_effects_with_points_to (effect eff)
list	eval_cell_with_points_to (cell c, list ptl, bool *exact_p)
	for backward compatibility More...

Function Documentation

effect_to_constant_path_effects_with_points_to()

list effect_to_constant_path_effects_with_points_to	(	effect	eff,
		statement	s,
		transformer	context
	)

We have not found any equivalent constant path : it may point anywhere

We should maybe contract these effects later. Is it done by the callers ?

make the resulting effects action to the current effect action

This is dead code: no effects, do not modify le

Parameters

eff	ff
context	ontext

Definition at line 284 of file eval.c.

{
  list le = NIL;
  bool exact_p;
  reference ref = effect_any_reference(eff);
 
  pips_debug_effect(5, "input effect", eff);
 
  points_to_list ptl = load_pt_to_list(s);
  if(!points_to_list_bottom(ptl)) {
    if (effect_reference_dereferencing_p(ref, &exact_p))
    {
      pips_debug(8, "dereferencing case \n");
      bool exact_p = false;
#if false
      transformer context;
      if (effects_private_current_context_empty_p())
        context = transformer_undefined;
      else {
        context = effects_private_current_context_head();
      }
#endif
 
      list l_eval = eval_simple_cell_with_points_to(effect_cell(eff), effect_descriptor(eff),
          points_to_list_list(ptl),
          &exact_p, context);
      if (ENDP(l_eval))
      {
        pips_debug(8, "no equivalent constant path found -> anywhere effect\n");
        /* We have not found any equivalent constant path : it may point anywhere */
        /* We should maybe contract these effects later. Is it done by the callers ? */
        // le = CONS(EFFECT, make_anywhere_effect(copy_action(effect_action(eff))), le);
        le = NIL; // A translation failure means an execution
        // failure, at least according to the standard
      }
      else
      {
        /* make the resulting effects action to the current effect action */
        // list l_eval_eff = cells_to_effects_according_to_effect(l_eval, eff, exact_p);
 
        if (effect_read_p(eff))
          effects_to_read_effects(l_eval);
        if (effect_may_p(eff))
          effects_to_may_effects(l_eval);
        le = gen_nconc(l_eval,le);
      }
    }
    else
      le = CONS(EFFECT, copy_effect(eff), le);
  }
  else {
    /* This is dead code: no effects, do not modify le */
    ;
  }
  return le;
 
}

References CONS, copy_effect(), EFFECT, effect_any_reference, effect_cell, effect_descriptor, effect_may_p, effect_read_p, effect_reference_dereferencing_p(), effects_private_current_context_empty_p(), effects_private_current_context_head(), effects_to_may_effects(), effects_to_read_effects(), ENDP, eval_simple_cell_with_points_to(), gen_nconc(), load_pt_to_list(), NIL, pips_debug, pips_debug_effect, points_to_list_bottom, points_to_list_list, ref, and transformer_undefined.

Referenced by add_values_for_simple_effects_of_statement(), c_user_call_to_transformer(), and simple_effect_to_constant_path_effects_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

eval_cell_with_points_to()

list eval_cell_with_points_to	(	cell	c,
		list	ptl,
		bool *	exact_p
	)

for backward compatibility

Parameters

ptl	tl
exact_p	xact_p

Definition at line 352 of file eval.c.

{
  list l_eff = eval_simple_cell_with_points_to(c, descriptor_undefined, ptl, exact_p, transformer_undefined);
  list l = NIL;
 
  FOREACH(EFFECT,eff, l_eff)
    {
      l = CONS(CELL, effect_cell(eff), l);
      effect_cell(eff) = cell_undefined;
    }
  gen_full_free_list(l_eff);
  return l;
}

References CELL, cell_undefined, CONS, descriptor_undefined, EFFECT, effect_cell, eval_simple_cell_with_points_to(), FOREACH, gen_full_free_list(), NIL, and transformer_undefined.

Here is the call graph for this function:

eval_simple_cell_with_points_to()

list eval_simple_cell_with_points_to	(	cell	c,
		descriptor __attribute__((unused))	d,
		list	ptl,
		bool *	exact_p,
		transformer __attribute__((unused))	t
	)

Definition at line 194 of file eval.c.

{
  return generic_eval_cell_with_points_to(c, descriptor_undefined, ptl, exact_p,
      transformer_undefined,
      simple_cell_reference_preceding_p,
      simple_cell_reference_with_address_of_cell_reference_translation,
      simple_reference_to_simple_reference_conversion);
}

References descriptor_undefined, generic_eval_cell_with_points_to(), simple_cell_reference_preceding_p(), simple_cell_reference_with_address_of_cell_reference_translation(), simple_reference_to_simple_reference_conversion(), and transformer_undefined.

Referenced by effect_to_constant_path_effects_with_points_to(), and eval_cell_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

path_preceding_p()

bool path_preceding_p	(	effect	eff1,
		effect	eff2,
		transformer	current_precondition,
		bool	strict_p,
		bool *	exact_p
	)

Parameters

eff1	ff1
eff2	ff2
current_precondition	urrent_precondition
strict_p	trict_p
exact_p	xact_p

Definition at line 132 of file eval.c.

{
  reference r1 = effect_any_reference(eff1);
  descriptor d1 = effect_descriptor(eff1);
  reference r2 = effect_any_reference(eff2);
  descriptor d2 = effect_descriptor(eff2);
 
  return simple_cell_reference_preceding_p(r1, d1, r2, d2, current_precondition,
                                           strict_p, exact_p);
}

References current_precondition, effect_any_reference, effect_descriptor, and simple_cell_reference_preceding_p().

Referenced by c_convex_effects_on_actual_parameter_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_cell_preceding_p()

bool simple_cell_preceding_p	(	cell	c1,
		descriptor	d1,
		cell	c2,
		descriptor	d2,
		transformer	current_precondition,
		bool	strict_p,
		bool *	exact_p
	)

Parameters

c1	1
d1	1
c2	2
d2	2
current_precondition	urrent_precondition
strict_p	trict_p
exact_p	xact_p

Definition at line 119 of file eval.c.

{
  reference r1 = cell_any_reference(c1);
  reference r2 = cell_any_reference(c2);
 
  return simple_cell_reference_preceding_p(r1, d1, r2, d2, current_precondition,
                                           strict_p, exact_p);
}

References cell_any_reference(), current_precondition, and simple_cell_reference_preceding_p().

Referenced by effect_find_aliased_paths_with_pointer_values(), and make_simple_pv_context().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_cell_reference_preceding_p()

bool simple_cell_reference_preceding_p	(	reference	r1,
		descriptor __attribute__((unused))	d1,
		reference	r2,
		descriptor __attribute__((unused))	d2,
		transformer __attribute__((unused))	current_precondition,
		bool	strict_p,
		bool *	exact_p
	)

same entity and the path length of r1 is shorter than the path length of r2. we now have to check that each common index matches

Definition at line 60 of file eval.c.

{
  bool res = true;
  entity e1 = reference_variable(r1);
  list ind1 = reference_indices(r1);
  size_t r1_path_length = gen_length(ind1);
  entity e2 = reference_variable(r2);
  list ind2 = reference_indices(r2);
  size_t r2_path_length = gen_length(ind2);
 
  pips_debug(8, "input references r1 : %s, r2: %s \n",
             reference_to_string(r1),
             reference_to_string(r2));
 
  *exact_p = true;
  if (same_entity_p(e1, e2)
      && ((r1_path_length < r2_path_length)
          || (!strict_p && r1_path_length == r2_path_length)))
    {
      /* same entity and the path length of r1 is shorter than the path length of r2.
         we now have to check that each common index matches
      */
      pips_debug(8,"same entities, and r1 path is shorter than r2 path\n");
      while (res && !ENDP(ind1))
        {
          expression exp1 = EXPRESSION(CAR(ind1));
          expression exp2 = EXPRESSION(CAR(ind2));
 
          if (unbounded_expression_p(exp1) || unbounded_expression_p(exp2))
            {
              res = true;
              *exact_p = false;
            }
          else if(!expression_equal_p(exp1, exp2))
            {
              res = false;
              *exact_p = true;
            }
 
          POP(ind1);
          POP(ind2);
        }
    }
  else
    {
      res = false;
      *exact_p = true;
    }
 
  pips_debug(8, "end : r1 is %s a predecessor of r2 (%s exact)\n",
             res ? "":"not", *exact_p ? "":"not");
  return res;
}

References CAR, ENDP, EXPRESSION, expression_equal_p(), gen_length(), pips_debug, POP, reference_indices, reference_to_string(), reference_variable, same_entity_p(), and unbounded_expression_p().

Referenced by eval_simple_cell_with_points_to(), path_preceding_p(), and simple_cell_preceding_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_cell_to_simple_cell_conversion()

void simple_cell_to_simple_cell_conversion	(	cell	input_cell,
		cell *	output_cell,
		descriptor *	output_desc
	)

Parameters

input_cell	nput_cell
output_cell	utput_cell
output_desc	utput_desc

Definition at line 154 of file eval.c.

{
  *output_cell = input_cell;
  *output_desc = make_descriptor(is_descriptor_none,UU);
}

References is_descriptor_none, make_descriptor(), and UU.

Referenced by effect_find_aliased_paths_with_pointer_values(), and effect_find_equivalent_pointer_values().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_effect_to_constant_path_effects_with_pointer_values()

list simple_effect_to_constant_path_effects_with_pointer_values

(

effect

eff

)

it should be a union here. However, we expect the caller to perform the contraction afterwards.

Parameters

eff

ff

Definition at line 206 of file eval.c.

{
  list le = NIL;
  bool exact_p;
  reference ref = effect_any_reference(eff);
 
  if (effect_reference_dereferencing_p(ref, &exact_p))
  {
    pips_debug(8, "dereferencing case \n");
    bool exact_p = false;
    list l_pv = cell_relations_list( load_pv(effects_private_current_stmt_head()) );
    pv_context ctxt = make_simple_pv_context();
    list l_aliased = effect_find_aliased_paths_with_pointer_values(eff, l_pv, &ctxt);
    pips_debug_effects(8, "aliased effects\n", l_aliased);
    reset_pv_context(&ctxt);
 
    FOREACH(EFFECT, eff_alias, l_aliased)
    {
      entity ent_alias = effect_entity(eff_alias);
      if (undefined_pointer_value_entity_p(ent_alias)
          || null_pointer_value_entity_p(ent_alias))
      {
        // currently interpret them as anywhere effects since these values
        // are not yet well integrated in abstract locations lattice
        // and in effects computations
        // to be FIXED later.
        le = CONS(EFFECT, make_anywhere_effect(copy_action(effect_action(eff_alias))), le);
        free_effect(eff_alias);
      }
      else if (entity_abstract_location_p(effect_entity(eff_alias))
          || !effect_reference_dereferencing_p(effect_any_reference(eff_alias), &exact_p)) {
        le = CONS(EFFECT, eff_alias, le);
        /* it should be a union here.
         * However, we expect the caller
         * to perform the contraction afterwards. */
      }
      else
        free_effect(eff_alias);
    }
    gen_free_list(l_aliased);
  }
  else {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    le = CONS(EFFECT, (*effect_dup_func)(eff), le);
  }
 
  return le;
}

References cell_relations_list, CONS, copy_action(), EFFECT, effect_action, effect_any_reference, effect_dup_func, effect_entity(), effect_find_aliased_paths_with_pointer_values(), effect_reference_dereferencing_p(), effects_private_current_stmt_head(), entity_abstract_location_p(), FOREACH, free_effect(), gen_free_list(), load_pv(), make_anywhere_effect(), make_simple_pv_context(), NIL, null_pointer_value_entity_p(), pips_debug, pips_debug_effects, ref, reset_pv_context(), and undefined_pointer_value_entity_p().

Here is the call graph for this function:

simple_effect_to_constant_path_effects_with_points_to()

list simple_effect_to_constant_path_effects_with_points_to

(

effect

eff

)

Parameters

eff

ff

Definition at line 343 of file eval.c.

{
  statement s = effects_private_current_stmt_head();
  transformer c = effects_private_current_context_head();
  return effect_to_constant_path_effects_with_points_to(eff, s, c);
}

References effect_to_constant_path_effects_with_points_to(), effects_private_current_context_head(), and effects_private_current_stmt_head().

Here is the call graph for this function:

simple_reference_to_simple_reference_conversion()

void simple_reference_to_simple_reference_conversion	(	reference	ref,
		reference *	output_ref,
		descriptor *	output_desc
	)

Parameters

ref	ef
output_ref	utput_ref
output_desc	utput_desc

Definition at line 146 of file eval.c.

{
  *output_ref = ref;
  *output_desc = make_descriptor(is_descriptor_none,UU);
}

References is_descriptor_none, make_descriptor(), ref, and UU.

Referenced by eval_simple_cell_with_points_to().

Here is the call graph for this function:

Here is the caller graph for this function: