cell_relations.c

Go to the documentation of this file.

/*
 
  $Id: cell_relations.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
  Copyright 2010 HPC Project
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/* functions specific to cell_relations */
 
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#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"
 
/**
   beware : modifies l1, l2 and their effects
 
  @param l1 and l2 are two lists of cell_relations.
  @param  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 ;
  @param  cr1_cr2_binary_op is a binary operator that combines two
          individual cell_relations;
  @param  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;
  @param  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;
 
  @return a list of cell_relations, combination of l1 and l2.
 
*/
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))
{
  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;
}