pointer_values_operators.c File Reference

#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_operators.c:

Go to the source code of this file.

Functions
list	make_simple_pv_from_simple_effects (effect lhs_eff, effect rhs_eff, cell_interpretation ci, list l_in)
	pointer_values_operators.c More...
list	kill_pointer_values (list l_in, list l_kill, pv_context *ctxt)
	eliminate the cells of l_kill from l_in More...
list	kill_pointer_value (effect eff_kill, list l_in, pv_context *ctxt)
	eliminate the cell of eff_kill from l_in More...
cell_relation	simple_pv_translate (cell_relation pv_in, bool in_first_p, cell_relation pv_old)
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. More...
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 More...
void	pointer_values_remove_var (entity e, bool may_p, list l_in, pv_results *pv_res, pv_context *ctxt)
cell_relation	simple_pv_composition_with_transformer (cell_relation pv, transformer __attribute__((unused)) t)
list	pvs_composition_with_transformer (list l_pv, transformer t, pv_context *ctxt)
list	cell_relation_to_list (cell_relation cr)
list	cell_relation_to_may_list (cell_relation cr)
list	simple_pv_must_union (cell_relation pv1, cell_relation pv2)
list	simple_pv_may_union (cell_relation pv1, cell_relation pv2)
bool	pvs_union_combinable_p (cell_relation pv1, cell_relation pv2)
list	simple_pvs_must_union (list l_pv1, list l_pv2)
list	simple_pvs_may_union (list l_pv1, list l_pv2)
bool	simple_pvs_syntactically_equal_p (list l_pv1, list l_pv2)

Function Documentation

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:

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:

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.

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:

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:

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:

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:

simple_pv_composition_with_transformer()

cell_relation simple_pv_composition_with_transformer	(	cell_relation	pv,
		transformer __attribute__((unused))	t
	)

Definition at line 766 of file pointer_values_operators.c.

{
  cell c1 = cell_relation_first_cell(pv);
  cell c2 = cell_relation_second_cell(pv);
 
  bool b1, b2;
 
  cell_relation_first_cell(pv) = simple_cell_to_store_independent_cell(c1, &b1);
  cell_relation_second_cell(pv) = simple_cell_to_store_independent_cell(c2, &b2);
 
  if (cell_relation_exact_p(pv) && (b1 || b2))
    cell_relation_approximation_tag(pv) = is_approximation_may;
  return pv;
}

References b1, b2, cell_relation_approximation_tag, cell_relation_exact_p, cell_relation_first_cell, cell_relation_second_cell, is_approximation_may, and simple_cell_to_store_independent_cell().

Here is the call 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

not generic here

not generic here

not generic here

not generic here

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: