call.c

Go to the documentation of this file.

/*
 
  $Id: call.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  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/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
 * Fabien COELHO
 */
 
#include "local-header.h"
 
/* these functions must translate external reductions into local ones if
 * must be. thus it is similar to summary effects call translations.
 * I do reuse some functions there by generating fake effects...
 * I think they should be cleaned so as to offer reference plus predicate
 * translations, and then would be used by reductions and effects.
 * Fabien.
 */
 
/* translation of a reference, based on effect translations...
 * such an interface should be available?
 */
list /* of reference */
summary_to_proper_reference(
    call c,
    reference r)
{
    effect e = make_simple_effect(r, /* persistent! */
                                  make_action_write_memory(),
                           make_approximation(is_approximation_exact, UU));
    list /* of effect */ lef, /* of reference */ lref = NIL;
 
    pips_debug(7, "reference to %s\n", entity_name(reference_variable(r)));
 
    lef = summary_effect_to_proper_effect(c, e);
 
    FOREACH (EFFECT, ef, lef) {
      lref = CONS(REFERENCE, effect_any_reference(ef), lref);
    }
 
    gen_map((gen_iter_func_t)gen_free, lef);
    gen_free_list(lef);
    return lref;
}
 
static list /* of reduction */
translate_reduction(call c, reduction external_red) {
 
  reference ref = reduction_reference(external_red);
  entity var = reference_variable(ref);
  list /* of reference */ lref = summary_to_proper_reference(c, ref);
  list /* of reduction */ lrds = NIL;
 
  pips_debug(7, "reduction %s[%s] (%td reductions)\n",
             reduction_name(external_red),
             entity_name(var), gen_length(lref));
 
  FOREACH (REFERENCE, r, lref) {
    reduction red = copy_reduction(external_red);
 
    free_reference(reduction_reference(red));
    reduction_reference(red) = copy_reference(r);
 
    gen_free_list(reduction_dependences(red));
    reduction_dependences(red) = NIL;
 
    gen_map((gen_iter_func_t)gen_free, reduction_trusted(red));
    gen_free_list(reduction_trusted(red));
    reduction_trusted(red) = NIL;
 
    /* ??? what about effects on commons hidden in the call?
     * I do not know the reference to trust in the effects...
     */
    reduction_trusted(red) = CONS(PREFERENCE, make_preference(r), NIL);
 
    pips_debug(7, "reduction on %s translated on %s\n",
               entity_name(var), entity_name(reduction_variable(red)));
 
    lrds = CONS(REDUCTION, red, lrds);
  }
 
  gen_free_list(lref); /* just the backbone, refs are real in the code? */
  return lrds;
}
 
/**@return the list of proper reduction applicable to the call according to
 * the summary reduction computed earlier.
 * @param c, the call to check for proper reductions
 */
list /* of reduction */
translate_reductions(
    call c)
{
    entity fun = call_function(c);
    list /* of reduction */ lr = NIL;
 
    if (!entity_module_p(fun))
        return NIL;
 
    FOREACH (REDUCTION, r, reductions_list(load_summary_reductions(fun))) {
      lr = gen_nconc(translate_reduction(c, r), lr);
    }
 
    return lr;
}
/* end of it
 */