cell_relations.c File Reference

#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "effects.h"
#include "effects-util.h"
#include "misc.h"

Include dependency graph for cell_relations.c:

Go to the source code of this file.

Functions
list	cell_relations_generic_binary_op (list l1, list l2, bool(*cr1_cr2_combinable_p)(cell_relation, cell_relation), list(*cr1_cr2_binary_op)(cell_relation, cell_relation), list(*cr1_unary_op)(cell_relation), list(*cr2_unary_op)(cell_relation), list(*union_op)(list, list))
	functions specific to cell_relations More...

Function Documentation

cell_relations_generic_binary_op()

list cell_relations_generic_binary_op	(	list	l1,
		list	l2,
		bool(*)(cell_relation, cell_relation)	cr1_cr2_combinable_p,
		list(*)(cell_relation, cell_relation)	cr1_cr2_binary_op,
		list(*)(cell_relation)	cr1_unary_op,
		list(*)(cell_relation)	cr2_unary_op,
		list(*)(list, list)	union_op
	)

functions specific to cell_relations

cell_relations.c

beware : modifies l1, l2 and their effects

Parameters

l1	and l2 are two lists of cell_relations.
cr1_cr2_combinable_p	is a bool function that takes two individual cell_relations as arguments and renders true when they are considered as combinable ;
cr1_cr2_binary_op	is a binary operator that combines two individual cell_relations;
cr1_unary_op	is a unary operators that deal with the remnants of l1, that is those cell_relations that are not combinable with any effect of l2;
cr2_unary_op	is a unary operators that deal with the remnants of l2, that is those cell_relations that are not combinable with any effect of l1;

Returns

a list of cell_relations, combination of l1 and l2.

we first deal with the elements of l1 : those that are combinable with the elements of l2, and the others, which we call the remnants of l1

gen_remove(&l2, EFFECT(CAR(l_cr2)));

cr1 belongs to the remnants of l1 : it is combinable with no effects of l2

we must then deal with the remnants of l2

no memory leaks: l1 and l2 won't be used anymore

Parameters

l1	1
l2	2

Definition at line 59 of file cell_relations.c.

{
  list l_res = NIL;
  list l_cr1 = list_undefined;
  list l_cr2 = list_undefined;
 
  debug_on("CELL_RELATIONS_OPERATORS_DEBUG_LEVEL");
 
  pips_debug_pvs(1, "l1:\n", l1);
  pips_debug_pvs(1, "l2:\n", l2);
 
  /* we first deal with the elements of l1 : those that are combinable with
   * the elements of l2, and the others, which we call the remnants of l1 */
  for(l_cr1 = l1; !ENDP(l_cr1); POP(l_cr1))
    {
      cell_relation cr1 = CELL_RELATION(CAR(l_cr1));
      list prec_l_cr2 = NIL;
      bool combinable = false;
 
      pips_debug_pv(2, "dealing with cr1:\n", cr1);
 
      l_cr2 = l2;
      while(!ENDP(l_cr2))
        {
          cell_relation cr2 = CELL_RELATION(CAR(l_cr2));
 
          pips_debug_pv(2, "considering cr2:\n", cr2);
 
          if ( (*cr1_cr2_combinable_p)(cr1,cr2) )
            {
              pips_debug(2, "combinable\n");
              combinable = true;
              list l_res_tmp = (*cr1_cr2_binary_op)(cr1,cr2);
              l_res = (*union_op)(l_res, l_res_tmp);
 
              /* gen_remove(&l2, EFFECT(CAR(l_cr2))); */
              if (prec_l_cr2 != NIL)
                CDR(prec_l_cr2) = CDR(l_cr2);
              else
                l2 = CDR(l_cr2);
 
              free(l_cr2); l_cr2 = NIL;
              /* */
              //free_cell_relation(cr1); cr1=cell_relation_undefined;
              free_cell_relation(cr2); cr2=cell_relation_undefined;
            }
          else
            {
              pips_debug(2, "not combinable\n");
              prec_l_cr2 = l_cr2;
              l_cr2 = CDR(l_cr2);
            }
        }
 
      pips_debug_pvs(2, "intermediate l_res 1:\n", l_res);
 
      if(!combinable)
        {
          /* cr1 belongs to the remnants of l1 : it is combinable
           * with no effects of l2 */
          if ( (*cr1_cr2_combinable_p)(cr1,cell_relation_undefined) )
            l_res = gen_nconc(l_res, (*cr1_unary_op)(cr1));
        }
      else
        {
          free_cell_relation(cr1); cr1=cell_relation_undefined;
        }
    }
 
  pips_debug_pvs(2, "intermediate l_res 2:\n", l_res);
 
  /* we must then deal with the remnants of l2 */
  for(l_cr2 = l2; !ENDP(l_cr2); POP(l_cr2))
    {
      cell_relation cr2 = CELL_RELATION(CAR(l_cr2));
 
      if ( (*cr1_cr2_combinable_p)(cell_relation_undefined,cr2) )
        l_res = gen_nconc(l_res, (*cr2_unary_op)(cr2));
    }
 
  pips_debug_pvs(1, "final pvs:\n", l_res);
 
  /* no memory leaks: l1 and l2 won't be used anymore */
  gen_free_list(l1);
  gen_free_list(l2);
 
  debug_off();
 
  return l_res;
}

References CAR, CDR, CELL_RELATION, cell_relation_undefined, debug_off, debug_on, ENDP, free(), free_cell_relation(), gen_free_list(), gen_nconc(), list_undefined, NIL, pips_debug, pips_debug_pv, pips_debug_pvs, and POP.

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: