call.c File Reference

#include "local-header.h"

Include dependency graph for call.c:

Go to the source code of this file.

Functions
list	summary_to_proper_reference (call c, reference r)
	these functions must translate external reductions into local ones if must be. More...
static list	translate_reduction (call c, reduction external_red)
	of reduction More...
list	translate_reductions (call c)
	of reduction More...

Function Documentation

summary_to_proper_reference()

list summary_to_proper_reference	(	call	c,
		reference	r
	)

these functions must translate external reductions into local ones if must be.

call.c

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? of reference

persistent!

of effect

of reference

Definition at line 45 of file call.c.

{
    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;
}

References CONS, EFFECT, effect_any_reference, entity_name, FOREACH, gen_free(), gen_free_list(), gen_map(), is_approximation_exact, make_action_write_memory(), make_approximation(), make_simple_effect, NIL, pips_debug, REFERENCE, reference_variable, summary_effect_to_proper_effect(), and UU.

Referenced by translate_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_reduction()

static list translate_reduction ( call  c, reduction  external_red  )

static

of reduction

of reference

of reduction

??? what about effects on commons hidden in the call? I do not know the reference to trust in the effects...

just the backbone, refs are real in the code?

Definition at line 68 of file call.c.

                                                    {
 
  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;
}

References CONS, copy_reduction(), copy_reference(), entity_name, FOREACH, free_reference(), gen_free(), gen_free_list(), gen_length(), gen_map(), make_preference(), NIL, pips_debug, PREFERENCE, REDUCTION, reduction_dependences, reduction_name(), reduction_reference, reduction_trusted, reduction_variable, ref, REFERENCE, reference_variable, and summary_to_proper_reference().

Referenced by translate_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_reductions()

list translate_reductions

(

call

c

)

of reduction

Returns

the list of proper reduction applicable to the call according to the summary reduction computed earlier.

Parameters

c,the

call to check for proper reductions

of reduction

Definition at line 112 of file 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;
}

References call_function, entity_module_p(), FOREACH, gen_nconc(), load_summary_reductions(), NIL, REDUCTION, reductions_list, and translate_reduction().

Referenced by pr_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function: