binary_operators.c File Reference

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

Include dependency graph for binary_operators.c:

Go to the source code of this file.

Functions
list	ReferenceUnion (list l1, list l2, bool(*union_combinable_p)(effect, effect) __attribute__((unused)))
	package effect: new version by Beatrice Creusillet More...
list	ReferenceTestUnion (list l1, list l2, bool(*union_combinable_p)(effect, effect) __attribute__((unused)))
list	EffectsMayUnion (list l1, list l2, bool(*union_combinable_p)(effect, effect))
	list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, may union of the two initial lists modifies : l1 and l2 and their effects. More...
list	ProperEffectsMustUnion (list l1, list l2, bool(*union_combinable_p)(effect, effect))
	list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...
list	EffectsMustUnion (list l1, list l2, bool(*union_combinable_p)(effect, effect))
	list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects. More...
list	effects_may_union (effect eff1, effect eff2)
list	effects_must_union (effect eff1, effect eff2)
effect	effect_may_union (effect eff1, effect eff2)
	Preserve store independent information as long as you can. More...
effect	effect_must_union (effect eff1, effect eff2)
	computes the must union of two combinable effects More...
static list	effect_sup_difference (effect eff1, effect eff2)
static list	effect_inf_difference (effect eff1 __attribute__((unused)), effect eff2 __attribute__((unused)))
list	EffectsSupDifference (list l1, list l2, bool(*difference_combinable_p)(effect, effect))
	list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the sup_difference of the initial effects. More...
list	EffectsInfDifference (list l1, list l2, bool(*difference_combinable_p)(effect, effect))
	list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the inf_difference of the initial effects. More...
effect	proper_to_summary_simple_effect (effect eff)
	FI: the goal is to get rid of array subscripts to handle the arrays atomically. More...
bool	simple_cells_intersection_p (cell c1, descriptor __attribute__((__unused__)) d1, cell c2, descriptor __attribute__((__unused__)) d2, bool *exact_p)
bool	simple_cells_inclusion_p (cell c1, __attribute__((__unused__)) descriptor d1, cell c2, __attribute__((__unused__)) descriptor d2, bool *exact_p)
	Inclusion test : More...

Function Documentation

effect_inf_difference()

static list effect_inf_difference ( effect eff1   __attribute__(unused), effect eff2   __attribute__(unused)  )

static

Definition at line 419 of file binary_operators.c.

{
    list l_res = NIL;
    return(l_res);
}

References NIL.

Referenced by EffectsInfDifference().

Here is the caller graph for this function:

effect_may_union()

effect effect_may_union	(	effect	eff1,
		effect	eff2
	)

Preserve store independent information as long as you can.

I should have some order on references to absorb, for instance, x[1] by x[*].

computes the may union of two combinable effects

Parameters

[in]	eff1	effect
[in]	eff2

See also

effects_combinable_p

Returns

a new effect with no sharing with the input effects

Abstract locations cases

In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);

new_ent = entity_locations_max(e1, e2);

eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }

but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))

concrete locations cases

it's a preference : we change for a reference cell

let us check the indices

Parameters

eff1	ff1
eff2	ff2

Definition at line 163 of file binary_operators.c.

{
  effect eff;
  tag app1 = effect_approximation_tag(eff1);
  tag app2 = effect_approximation_tag(eff2);
 
  bool al1_p = effect_abstract_location_p(eff1);
  bool al2_p = effect_abstract_location_p(eff2);
 
  /* Abstract locations cases */
  /* In fact, we could have :
       if (al1_p || al_2_p)
       {
         entity e1 = effect_entity(e1);
         entity e2 = effect_entity(e2);
 
         new_ent = entity_locations_max(e1, e2);
 
         eff = make_simple_effect(make_reference(new_ent, NIL),
                          copy_action(effect_action(eff1)),
                          make_approximation(approximation_and(app1,app2), UU));
       }
 
       but entity_locations_max involves string manipulations, which are always costly.
       So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because
       we already know that the abstract location is the max of both locations
       (because they are combinable (see effects_combinable_p))
 
   */
  if (al1_p && al2_p)
  {
    entity e1 = effect_entity(eff1);
    entity e2 = effect_entity(eff2);
 
    entity new_ent = entity_locations_max(e1, e2);
 
    eff = make_simple_effect(make_reference(new_ent, NIL),
        copy_action(effect_action(eff1)),
        make_approximation(approximation_and(app1,app2), UU));
  }
  else if (al1_p) {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff1);
  }
  else if (al2_p) {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff2);
  }
 
  /* concrete locations cases */
  else if (effect_scalar_p(eff1))
  {
    eff = make_simple_effect(make_reference(effect_entity(eff1), NIL),
        copy_action(effect_action(eff1)),
        make_approximation(approximation_and(app1,app2), UU));
  }
  else
  {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff1);
    cell eff_c = effect_cell(eff);
 
    if (cell_preference_p(eff_c))
    {
      /* it's a preference : we change for a reference cell */
      pips_debug(8, "It's a preference\n");
      reference ref = copy_reference(preference_reference(cell_preference(eff_c)));
      free_cell(eff_c);
      effect_cell(eff) = make_cell_reference(ref);
    }
 
    /* let us check the indices */
    list l1 = reference_indices(effect_any_reference(eff));
    list l2 = reference_indices(effect_any_reference(eff2));
 
    tag app_tag =  approximation_and(app1,app2);
 
    for(; !ENDP(l1); POP(l1), POP(l2))
    {
      expression exp1 = EXPRESSION(CAR(l1));
      expression exp2 = EXPRESSION(CAR(l2));
      if (!expression_equal_p(exp1, exp2))
      {
        EXPRESSION_(CAR(l1)) =  make_unbounded_expression();
        app_tag = is_approximation_may;
      }
    }
 
    approximation_tag(effect_approximation(eff)) = app_tag;
  }
  return(eff);
}

References approximation_and(), approximation_tag, CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.

Referenced by effects_may_union().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_must_union()

effect effect_must_union	(	effect	eff1,
		effect	eff2
	)

computes the must union of two combinable effects

Parameters

[in]	eff1	effect
[in]	eff2

See also

effects_combinable_p

Returns

a new effect with no sharing with the input effects

Abstract locations cases

In fact, we could have : if (al1_p || al_2_p) { entity e1 = effect_entity(e1); entity e2 = effect_entity(e2);

new_ent = entity_locations_max(e1, e2);

eff = make_simple_effect(make_reference(new_ent, NIL), copy_action(effect_action(eff1)), make_approximation(approximation_and(app1,app2), UU)); }

but entity_locations_max involves string manipulations, which are always costly. So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because we already know that the abstract location is the max of both locations (because they are combinable (see effects_combinable_p))

concrete locations cases

it's a preference : we change for a reference cell

let us check the indices

Parameters

eff1	ff1
eff2	ff2

Definition at line 272 of file binary_operators.c.

{
  effect eff;
  tag app1 = effect_approximation_tag(eff1);
  tag app2 = effect_approximation_tag(eff2);
 
  bool al1_p = effect_abstract_location_p(eff1);
  bool al2_p = effect_abstract_location_p(eff2);
 
  /* Abstract locations cases */
  /* In fact, we could have :
       if (al1_p || al_2_p)
       {
         entity e1 = effect_entity(e1);
         entity e2 = effect_entity(e2);
 
         new_ent = entity_locations_max(e1, e2);
 
         eff = make_simple_effect(make_reference(new_ent, NIL),
                          copy_action(effect_action(eff1)),
                          make_approximation(approximation_and(app1,app2), UU));
       }
 
       but entity_locations_max involves string manipulations, which are always costly.
       So we treat apart the cases where (al1_p and ! al2_p) and (al2_p and ! al1_p) because
       we already know that the abstract location is the max of both locations
       (because they are combinable (see effects_combinable_p))
 
   */
  if (al1_p && al2_p)
  {
    entity e1 = effect_entity(eff1);
    entity e2 = effect_entity(eff2);
 
    entity new_ent = entity_locations_max(e1, e2);
 
    eff = make_simple_effect(make_reference(new_ent, NIL),
        copy_action(effect_action(eff1)),
        make_approximation(approximation_and(app1,app2), UU));
  }
  else if (al1_p) {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff1);
  }
  else if (al2_p) {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff2);
  }
 
  /* concrete locations cases */
  else if (effect_scalar_p(eff1))
  {
    eff = make_simple_effect(make_reference(effect_entity(eff1), NIL),
        copy_action(effect_action(eff1)),
        make_approximation(approximation_or(app1,app2), UU));
  }
  else
  {
    // functions that can be pointed by effect_dup_func:
    // simple_effect_dup
    // region_dup
    // copy_effect
    eff = (*effect_dup_func)(eff1);
    cell eff_c = effect_cell(eff);
    if (cell_preference_p(eff_c))
    {
      /* it's a preference : we change for a reference cell */
      pips_debug(8, "It's a preference\n");
      reference ref = copy_reference(preference_reference(cell_preference(eff_c)));
      free_cell(eff_c);
      effect_cell(eff) = make_cell_reference(ref);
    }
 
    /* let us check the indices */
    list l1 = reference_indices(effect_any_reference(eff));
    list l2 = reference_indices(effect_any_reference(eff2));
 
    tag app_tag = approximation_or(app1,app2);
 
    for(; !ENDP(l1); POP(l1), POP(l2))
    {
      expression exp1 = EXPRESSION(CAR(l1));
      expression exp2 = EXPRESSION(CAR(l2));
      if (!expression_equal_p(exp1, exp2))
      {
        EXPRESSION_(CAR(l1)) =  make_unbounded_expression();
        app_tag = is_approximation_may;
      }
    }
 
    effect_approximation_tag(eff) = app_tag;
  }
  return(eff);
}

References approximation_and(), approximation_or(), CAR, cell_preference, cell_preference_p, copy_action(), copy_reference(), effect_abstract_location_p(), effect_action, effect_any_reference, effect_approximation_tag, effect_cell, effect_entity(), effect_scalar_p(), ENDP, entity_locations_max(), EXPRESSION, EXPRESSION_, expression_equal_p(), free_cell(), is_approximation_may, make_approximation(), make_cell_reference(), make_reference(), make_simple_effect, make_unbounded_expression(), NIL, pips_debug, POP, preference_reference, ref, reference_indices, and UU.

Referenced by effects_must_union().

Here is the call graph for this function:

Here is the caller graph for this function:

effect_sup_difference()

static list effect_sup_difference ( effect  eff1, effect  eff2  )

static

We already know that effects are combinable and they are not abstract locations (or they are context_sensitive heap locations)

Parameters

eff1	const
eff2	const

Definition at line 375 of file binary_operators.c.

{
  list l_res = NIL;
  reference ref1 = effect_any_reference(eff1);
  reference ref2 = effect_any_reference(eff2);
 
  /* We already know that effects are combinable and they are not abstract locations
   * (or they are context_sensitive heap locations)
   */
  if (reference_equal_p(ref1, ref2)) // a[1] - a[1] or a[*] - a[*]_may
  {
    if (effect_may_p(eff2)) {
      // functions that can be pointed by effect_dup_func:
      // simple_effect_dup
      // region_dup
      // copy_effect
      l_res = effect_to_may_effect_list((*effect_dup_func)(eff1));
    }
    // else: empty list
  }
  else
  {
    if (effect_exact_p(eff1) && effect_exact_p(eff2)) {// a[1] - a[2]
      // functions that can be pointed by effect_dup_func:
      // simple_effect_dup
      // region_dup
      // copy_effect
      l_res = effect_to_list((*effect_dup_func)(eff1));
    }
    else
    {
      // a[*] - a[1] or a[1] - a[*]_may for instance
      // functions that can be pointed by effect_dup_func:
      // simple_effect_dup
      // region_dup
      // copy_effect
      l_res = effect_to_may_effect_list((*effect_dup_func)(eff1));
    }
  }
 
  return(l_res);
}

References effect_any_reference, effect_dup_func, effect_exact_p, effect_may_p, effect_to_list(), effect_to_may_effect_list(), NIL, and reference_equal_p().

Referenced by EffectsSupDifference().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_may_union()

list effects_may_union	(	effect	eff1,
		effect	eff2
	)

Parameters

eff1	ff1
eff2	ff2

Definition at line 138 of file binary_operators.c.

{
    list l_res = NIL;
    l_res = CONS(EFFECT, effect_may_union(eff1,eff2), NIL);
    return(l_res);
}

References CONS, EFFECT, effect_may_union(), and NIL.

Referenced by EffectsMayUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

effects_must_union()

list effects_must_union	(	effect	eff1,
		effect	eff2
	)

Parameters

eff1	ff1
eff2	ff2

Definition at line 145 of file binary_operators.c.

{
    list l_res = NIL;
    l_res = CONS(EFFECT, effect_must_union(eff1,eff2), NIL);
    return(l_res);
}

References CONS, EFFECT, effect_must_union(), and NIL.

Referenced by EffectsMustUnion(), and ProperEffectsMustUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

EffectsInfDifference()

list EffectsInfDifference	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	difference_combinable_p
	)

list EffectsInfDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the inf_difference of the initial effects.

modifies : the effects of l2 may be freed. comment : we keep the effects of l1 that are not combinable with those of l2, but we don't keep the effects of l2 that are not combinable with those of l_reg1.

Parameters

l1	1
l2	2

Definition at line 462 of file binary_operators.c.

{
    list l_res = NIL;
 
    debug(3, "EffectsInfDifference", "begin\n");
    l_res = list_of_effects_generic_inf_difference_op(l1, l2,
                                           difference_combinable_p,
                                           effect_inf_difference);
    debug(3, "EffectsInfDifference", "end\n");
 
    return l_res;
}

References debug(), effect_inf_difference(), list_of_effects_generic_inf_difference_op(), and NIL.

Here is the call graph for this function:

EffectsMayUnion()

list EffectsMayUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMayUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, may union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.nothing (no sharing introduced).

Parameters

l1	1
l2	2

Definition at line 87 of file binary_operators.c.

{
    list lr;
 
    lr = list_of_effects_generic_union_op(l1, l2,
                                           union_combinable_p,
                                           effects_may_union,
                                           effect_to_may_sdfi_list);
    return(lr);
}

References effect_to_may_sdfi_list(), effects_may_union(), and list_of_effects_generic_union_op().

Referenced by unstructured_to_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

EffectsMustUnion()

list EffectsMustUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.

Parameters

l1	1
l2	2

Definition at line 126 of file binary_operators.c.

{
    list lr;
 
    lr = list_of_effects_generic_union_op(l1, l2,
                                           union_combinable_p,
                                           effects_must_union,
                                           effect_to_sdfi_list);
    return(lr);
}

References effect_to_sdfi_list(), effects_must_union(), and list_of_effects_generic_union_op().

Here is the call graph for this function:

EffectsSupDifference()

list EffectsSupDifference	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	difference_combinable_p
	)

list EffectsSupDifference(list l1, l2) input : two lists of effects output : a list of effect, representing the sup_difference of the initial effects.

modifies : the effects of l2 may be freed. comment : we keep the effects of l1 that are not combinable with those of l2, but we don't keep the effects of l2 that are not combinable with those of l_reg1.

Parameters

l1	1
l2	2

Definition at line 438 of file binary_operators.c.

{
    list l_res = NIL;
 
    debug(3, "EffectsSupDifference", "begin\n");
    l_res = list_of_effects_generic_sup_difference_op(l1, l2,
                                           difference_combinable_p,
                                           effect_sup_difference);
    debug(3, "EffectsSupDifference", "end\n");
 
    return l_res;
}

References debug(), effect_sup_difference(), list_of_effects_generic_sup_difference_op(), and NIL.

Here is the call graph for this function:

proper_to_summary_simple_effect()

effect proper_to_summary_simple_effect

(

effect

eff

)

FI: the goal is to get rid of array subscripts to handle the arrays atomically.

This is not possible with pointer indexing. For instance, p[0] is reduced the Fortran way into p, which is wrong. It could be reduced to p[*] and lead to an anywhere effects. Or we must preserve constant indices (store independent), which is the way to go with C since we transform lots of scalar accesses into array accesses.

FI: I do not understand the mix of side effects on eff, free and alloc conditionnaly for some fields. To be checked.

it's a preference : we change for a reference cell

it's a reference : let'us modify it

it may still be a field entity

Parameters

eff

ff

Definition at line 488 of file binary_operators.c.

{
  if (!effect_scalar_p(eff)) {
    cell eff_c = effect_cell(eff);
    bool may_p = false;
    reference ref = reference_undefined;
 
    if (cell_preference_p(eff_c))
    {
      /* it's a preference : we change for a reference cell */
      pips_debug(8, "It's a preference\n");
      ref = copy_reference(preference_reference(cell_preference(eff_c)));
      free_cell(eff_c);
      effect_cell(eff) = make_cell_reference(ref);
    }
    else
    {
      /* it's a reference : let'us modify it */
      ref = cell_reference(eff_c);
    }
 
    ifdebug(8) {
      pips_debug(8, "Proper effect %p with reference %p: %s\n", eff, ref,
          words_to_string(words_effect(eff)));
    }
 
    list inds = reference_indices(ref);
    list cind = list_undefined;
    for(cind = inds; !ENDP(cind); POP(cind)) {
      expression se = EXPRESSION(CAR(cind));
 
      ifdebug(8) {
        pips_debug(8, "Subscript expression :\n");
        print_expression(se);
      }
 
      if(!extended_integer_constant_expression_p(se)) {
        if(!unbounded_expression_p(se))
        {
          /* it may still be a field entity */
          if (!(expression_reference_p(se) &&
              entity_field_p(expression_variable(se))))
          {
            may_p = true;
            free_expression(se);
            EXPRESSION_(CAR(cind)) = make_unbounded_expression();
          }
        }
      }
    }
 
    if(may_p)
      effect_approximation_tag(eff) = is_approximation_may;
 
    ifdebug(8) {
      pips_debug(8, "Summary simple effect %p with reference %p: %s\n", eff, ref,
          words_to_string(words_effect(eff)));
    }
 
    /*
    if(!reference_with_constant_indices_p(r)) {
      reference nr = pointer_type_p(ut)?
        make_reference(e, CONS(EXPRESSION, make_unbounded_expression(), NIL))
        : make_reference(e, NIL);
      free_reference(effect_any_reference(eff));
      if(cell_preference_p(c)) {
        preference p = cell_preference(c);
        preference_reference(p) = nr;
      }
      else {
        cell_reference(c) = nr;
      }
    }
     */
  }
  return(eff);
}

References CAR, cell_preference, cell_preference_p, cell_reference, copy_reference(), effect_approximation_tag, effect_cell, effect_scalar_p(), ENDP, entity_field_p(), EXPRESSION, EXPRESSION_, expression_reference_p(), expression_variable(), extended_integer_constant_expression_p(), free_cell(), free_expression(), ifdebug, is_approximation_may, list_undefined, make_cell_reference(), make_unbounded_expression(), pips_debug, POP, preference_reference, print_expression(), ref, reference_indices, reference_undefined, unbounded_expression_p(), words_effect(), and words_to_string().

Here is the call graph for this function:

ProperEffectsMustUnion()

list ProperEffectsMustUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect)	union_combinable_p
	)

list EffectsMustUnion(list l1, list l2, union_combinable_p) input : two lists of effects output : a list of effects, must union of the two initial lists modifies : l1 and l2 and their effects.

Effects that are not reused in the output list of effects are freed.

Parameters

l1	1
l2	2

Definition at line 107 of file binary_operators.c.

{
    list lr;
 
    lr = list_of_effects_generic_union_op(l1, l2,
                                           union_combinable_p,
                                           effects_must_union,
                                           effect_to_list);
    return(lr);
}

References effect_to_list(), effects_must_union(), and list_of_effects_generic_union_op().

Here is the call graph for this function:

ReferenceTestUnion()

list ReferenceTestUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect) __attribute__ union_combinable_p((unused))
	)

somthing more clever should be done here - bc.

Definition at line 67 of file binary_operators.c.

{
    list l_res;
 
    /* somthing more clever should be done here - bc. */
    l_res = gen_nconc(l1,l2);
    effects_to_may_effects(l_res);
    return l_res;
}

References effects_to_may_effects(), and gen_nconc().

Here is the call graph for this function:

ReferenceUnion()

list ReferenceUnion	(	list	l1,
		list	l2,
		bool(*)(effect, effect) __attribute__ union_combinable_p((unused))
	)

package effect: new version by Beatrice Creusillet

This File contains several functions to combine effects

Definition at line 60 of file binary_operators.c.

{
    return gen_nconc(l1,l2);
}

References gen_nconc().

Here is the call graph for this function:

simple_cells_inclusion_p()

bool simple_cells_inclusion_p	(	cell	c1,
		__attribute__((__unused__)) descriptor	d1,
		cell	c2,
		__attribute__((__unused__)) descriptor	d2,
		bool *	exact_p
	)

Inclusion test :

returns true if c1 is included into c2, false otherwise. returns false if c1 may only be included into c2.

Parameters

exact_p

target is set to true if the result is exact, false otherwise.

In fact, this parameter would be useful only if there are overflows during the systems inclusion test. But it is not currently used.

default result

we have combinable concrete locations or assimilated (context sensitive heap locations)

Definition at line 644 of file binary_operators.c.

{
  bool res = true; /* default result */
  *exact_p = true;
 
  bool concrete_locations_p = true;
 
  if (cells_combinable_p(c1, c2))
    {
      bool c1_abstract_location_p = cell_abstract_location_p(c1);
      bool c2_abstract_location_p = cell_abstract_location_p(c2);
 
      if (c1_abstract_location_p || c2_abstract_location_p)
        {
          entity e1 = cell_entity(c1);
          entity e2 = cell_entity(c2);
          bool heap1_context_sensitive_p = c1_abstract_location_p && entity_flow_or_context_sentitive_heap_location_p(e1);
          bool heap2_context_sensitive_p = c2_abstract_location_p && entity_flow_or_context_sentitive_heap_location_p(e2);
 
          if (heap1_context_sensitive_p && heap2_context_sensitive_p)
            {
              concrete_locations_p = true;
            }
          else
            {
              entity al_max = abstract_locations_max(e1, e2);
              res = same_entity_p(e2, al_max);
              concrete_locations_p = false;
            }
        }
 
      if (concrete_locations_p)
        {
          /* we have combinable concrete locations or assimilated (context sensitive heap locations) */
          list inds1 = cell_indices(c1);
          list inds2 = cell_indices(c2);
 
 
          for(;!ENDP(inds1) && res == true; POP(inds1), POP(inds2))
            {
              expression exp1 = EXPRESSION(CAR(inds1));
              expression exp2 = EXPRESSION(CAR(inds2));
 
              if (unbounded_expression_p(exp1))
                {
                  pips_debug(8, "case 4.1\n");
                  if (!unbounded_expression_p(exp2))
                    {
                      pips_debug(8, "case 4.2\n");
                      res = false;
                    }
                }
              else if (!unbounded_expression_p(exp2) && !expression_equal_p(exp1, exp2) )
                {
                  pips_debug(8, "case 4.3\n");
                  res = false;
                }
            }
        }
    }
  else
    {
      res = false;
    }
  return res;
}

References abstract_locations_max(), CAR, cell_abstract_location_p(), cell_entity(), cell_indices(), cells_combinable_p(), ENDP, entity_flow_or_context_sentitive_heap_location_p(), EXPRESSION, expression_equal_p(), pips_debug, POP, same_entity_p(), and unbounded_expression_p().

Referenced by effect_find_aliased_paths_with_pointer_values(), effect_find_equivalent_pointer_values(), and kill_pointer_value().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_cells_intersection_p()

bool simple_cells_intersection_p	(	cell	c1,
		descriptor __attribute__((__unused__))	d1,
		cell	c2,
		descriptor __attribute__((__unused__))	d2,
		bool *	exact_p
	)

default safe result

we have combinable concrete locations or assimilated (context sensitive heap locations)

they intersect if their corresponding indices are unbounded or equal

Definition at line 567 of file binary_operators.c.

{
  bool res = true; /* default safe result */
  bool concrete_locations_p = true;
 
  if (cells_combinable_p(c1, c2))
    {
      bool c1_abstract_location_p = cell_abstract_location_p(c1);
      bool c2_abstract_location_p = cell_abstract_location_p(c2);
 
      if (c1_abstract_location_p || c2_abstract_location_p)
        {
          entity e1 = cell_entity(c1);
          entity e2 = cell_entity(c2);
          bool heap1_context_sensitive_p = c1_abstract_location_p && entity_flow_or_context_sentitive_heap_location_p(e1);
          bool heap2_context_sensitive_p = c2_abstract_location_p && entity_flow_or_context_sentitive_heap_location_p(e2);
 
          if (heap1_context_sensitive_p && heap2_context_sensitive_p)
            {
              concrete_locations_p = true;
            }
          else
            {
              concrete_locations_p = false;
 
              res = true;
              *exact_p = true;
            }
        }
 
      if (concrete_locations_p)
        {
          /* we have combinable concrete locations or assimilated (context sensitive heap locations) */
          list l1 = cell_indices(c1);
          list l2 = cell_indices(c2);
 
          /* they intersect if their corresponding indices are unbounded or equal */
          res = true; *exact_p = true;
          while(res && !ENDP(l1))
            {
              expression exp1 = EXPRESSION(CAR(l1));
              expression exp2 = EXPRESSION(CAR(l2));
 
              if (unbounded_expression_p(exp1) || unbounded_expression_p(exp2))
                *exact_p = false;
              else if (!expression_equal_p(exp1, exp2))
                {
                  res = false;
                  *exact_p = true;
                }
              POP(l1);
              POP(l2);
            }
        }
    }
  else
    {
      res = false;
      *exact_p = true;
    }
  return res;
}

References CAR, cell_abstract_location_p(), cell_entity(), cell_indices(), cells_combinable_p(), ENDP, entity_flow_or_context_sentitive_heap_location_p(), EXPRESSION, expression_equal_p(), POP, and unbounded_expression_p().

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: