reductions.c File Reference

#include "local-header.h"
#include "control.h"
#include "semantics.h"

Include dependency graph for reductions.c:

Go to the source code of this file.

Functions
static void	set_generic_effects_as_needed (void)
	for CONTROL_MAP() More...
reductions	load_summary_reductions (entity f)
	Fortran 77 anti aliasing rules implies that sg that looks like a reduction within a subroutine can be perceived as so from outside because no aliasing may cause the accumulator to be linked to the rhs of the accumulation... More...
static reduction	compute_one_summary_reduction (reduction model, list le)
static reductions	compute_summary_reductions (entity f)
bool	summary_reductions (const char *module_name)
	handler for pipsmake input: module name output: TRUE side effects: stores the summary reductions to pipsdbm More...
static list	add_reduced_variables (list le, reductions rs)
	Function storing Proper Reductions. More...
static list	list_of_reduced_variables (statement node, list ls)
	of entity More...
static reduction	compatible_reduction_of_var (entity var, reductions rs)
	Returns NULL if not ok. More...
static list	list_of_compatible_reductions (reductions rs)
	returns NIL on any problem More...
static list	list_of_trusted_references (reductions rs)
static bool	safe_effects_for_reductions (statement s, reductions rs)
	argh... More...
static void	check_proper_reductions (statement s)
	must check that the found reductions are (1) without side effects (no W on any other than accumulators), MA: why? If the W doesn't conflict with the accumulators it should be safe ! safe_effects_for_reductions seems overkill to me (2) compatible one with respect to the other. More...
static bool	pr_statement_flt (statement s)
static void	pr_statement_wrt (statement s)
static bool	pr_call_flt (call c)
static void	compute_proper_reductions (statement s)
	performs the computation of proper reductions for statement s. More...
bool	proper_reductions (const char *module_name)
	handler for pipsmake input: module name output: TRUE side effects: some More...
static bool	build_reduction_of_variable (entity var, statement node, list ls, reduction *pr)
	Function storing Cumulated Reductions. More...
static void	build_creductions_of_statement (statement node, list ls)
	builds cumulated reductions for node, depending on node and list of statement ls. More...
static void	compute_cumulated_reductions (instruction i)
	Cumulated Reduction propagation functions for each possible instructions. More...
bool	cumulated_reductions (const char *module_name)
	handler for pipsmake input: the module name output: TRUE side effects: some More...
entity	reduction_operator_entity (reduction_operator op)
	match a reduction operator against operator entity More...
bool	same_reduction_p (reduction r1, reduction r2)

Variables
static call	last_translated_module_call = call_undefined
	hack: no check for direct translations ("call foo") thus in this case effects reductions will be okay... More...

Function Documentation

add_reduced_variables()

static list add_reduced_variables ( list  le, reductions  rs  )

static

Function storing Proper Reductions.

list of entities that may be reduced of entity

Parameters

le

of entity

Definition at line 144 of file reductions.c.

{
  FOREACH (REDUCTION, r, reductions_list(rs)) {
    le = gen_once(reduction_variable(r), le);
  }
  return le;
}

References FOREACH, gen_once(), REDUCTION, reduction_variable, and reductions_list.

Referenced by list_of_compatible_reductions(), and list_of_reduced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

build_creductions_of_statement()

static void build_creductions_of_statement ( statement  node, list  ls  )

static

builds cumulated reductions for node, depending on node and list of statement ls.

of entity

of reduction

list of candidate entities

for each candidate, extract the reduction if any

store the result

Parameters

ls	of statement

Definition at line 451 of file reductions.c.

{
    list /* of entity */ le;
    list /* of reduction */ lr=NIL;
    reduction r;
 
    /* list of candidate entities */
    le = list_of_reduced_variables(node, ls);
 
    pips_debug(5, "stat %s %p: %td candidate(s)\n",
               note_for_statement(node), node, gen_length(le));
 
    /* for each candidate, extract the reduction if any */
    FOREACH (ENTITY, var, le)
      if (build_reduction_of_variable(var, node, ls, &r))
        lr = CONS(REDUCTION, r, lr);
 
    /* store the result */
    pips_debug(5, "stat %s %p -> %td reductions\n",
               note_for_statement(node), node, gen_length(lr));
 
    store_cumulated_reductions(node, make_reductions(lr));
    gen_free_list(le);
}

References build_reduction_of_variable(), CONS, ENTITY, FOREACH, gen_free_list(), gen_length(), list_of_reduced_variables(), make_reductions(), NIL, node(), note_for_statement(), pips_debug, REDUCTION, and store_cumulated_reductions().

Referenced by compute_cumulated_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

build_reduction_of_variable()

static bool build_reduction_of_variable ( entity  var, statement  node, list  ls, reduction *  pr  )

static

Function storing Cumulated Reductions.

returns a r reduction of any compatible with { node } u ls input: var, node and ls output: true and some *pr, or FALSE

Parameters

ls	of statement

Definition at line 410 of file reductions.c.

{
    *pr = make_reduction
        (reference_undefined,
         make_reduction_operator_none(),
         NIL, NIL);
 
    if (!update_compatible_reduction
        (pr, var, effects_effects(load_proper_references(node)),
         load_proper_reductions(node)))
    {
        free_reduction(*pr);
        return false;
    }
 
    FOREACH (STATEMENT, s, ls) {
      if (bound_cumulated_reductions_p(s) ) {
        if (!update_compatible_reduction (pr, var, load_rw_effects_list(s),
                                          load_cumulated_reductions(s)))
          {
            free_reduction(*pr);
            return false;
          }
      }
      else {
        pips_debug(5, "stat %s %p\n", note_for_statement(s), s);
        pips_assert ("should not happen, all statements should have been visited for reduction", false);
      }
    }
 
    return true;
}

References bound_cumulated_reductions_p(), effects_effects, FOREACH, free_reduction(), load_cumulated_reductions(), load_proper_reductions(), load_proper_references(), load_rw_effects_list(), make_reduction(), make_reduction_operator_none(), NIL, node(), note_for_statement(), pips_assert, pips_debug, reference_undefined, STATEMENT, and update_compatible_reduction().

Referenced by build_creductions_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

check_proper_reductions()

static void check_proper_reductions ( statement  s )

static

must check that the found reductions are (1) without side effects (no W on any other than accumulators), MA: why? If the W doesn't conflict with the accumulators it should be safe ! safe_effects_for_reductions seems overkill to me (2) compatible one with respect to the other.

(3) not killed by other proper effects on accumulators. to avoid these checks, I can stop on expressions...

of reduction

all must be compatible, otherwise some side effect!

checks (2)

now lnr is the new list of reductions.

checks (1) and (3)

Definition at line 250 of file reductions.c.

                                                 {
  reductions rs = load_proper_reductions(s);
  list /* of reduction */ lr = reductions_list(rs), lnr;
  if(ENDP(lr))
    return;
 
  /* all must be compatible, otherwise some side effect!
   */
  lnr = list_of_compatible_reductions(rs); /* checks (2) */
 
  /* now lnr is the new list of reductions.
   */
  if(lnr && !safe_effects_for_reductions(s, rs)) { /* checks (1) and (3) */
    gen_full_free_list(lnr);
    lnr = NIL;
  }
 
  gen_full_free_list(lr);
  // update the reduction list
  reductions_list(rs) = lnr;
}

References ENDP, gen_full_free_list(), list_of_compatible_reductions(), load_proper_reductions(), NIL, reductions_list, and safe_effects_for_reductions().

Referenced by pr_statement_wrt().

Here is the call graph for this function:

Here is the caller graph for this function:

compatible_reduction_of_var()

static reduction compatible_reduction_of_var ( entity  var, reductions  rs  )

static

Returns NULL if not ok.

Definition at line 174 of file reductions.c.

                                                                        {
  reduction rnew = make_none_reduction(var);
 
  FOREACH(REDUCTION, r,reductions_list(rs)) {
    if (!update_compatible_reduction_with(&rnew, var, r)) {
      free_reduction(rnew);
      return NULL;
    }
  }
  return rnew;
}

References FOREACH, free_reduction(), make_none_reduction, REDUCTION, reductions_list, and update_compatible_reduction_with().

Referenced by list_of_compatible_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_cumulated_reductions()

static void compute_cumulated_reductions ( instruction  i )

static

Cumulated Reduction propagation functions for each possible instructions.

Statement s cumulated reduction computation involves :

• its own proper reductions and effects
• the cumulated reductions and effects of its sons the computation is performed by build_reductions_of_statement. the current statement is retrieved thru the crt_stat stack. Perform the bottom-up propagation of cumulated reductions

of control

it is important to return here

Definition at line 486 of file reductions.c.

{
    statement parent = (statement)gen_get_ancestor(statement_domain,i);
    list l = NIL;
    bool tofree = true;
    switch(instruction_tag(i)) {
        case is_instruction_sequence:
            tofree=false;
            l=instruction_block(i);break;
        case is_instruction_loop:
            l=make_statement_list(loop_body(instruction_loop(i)));break;
        case is_instruction_forloop:
            l=make_statement_list(forloop_body(instruction_forloop(i)));break;
        case is_instruction_whileloop:
            l=make_statement_list(whileloop_body(instruction_whileloop(i)));break;
        case is_instruction_test:
            l=make_statement_list(test_true(instruction_test(i)),test_false(instruction_test(i)));break;
        case is_instruction_unstructured:
            {
                list /* of control */ lc = NIL;
                CONTROL_MAP( c, lc=CONS(CONTROL,c,lc), unstructured_control(instruction_unstructured(i)), lc);
                l = control_list_to_statement_list(lc);
                gen_free_list(lc);
            } ; break ;
        case is_instruction_call:
        case is_instruction_expression:
            store_cumulated_reductions(parent,copy_reductions(load_proper_reductions(parent)));
            pips_debug(5, "stat %s %p\n", note_for_statement(parent), parent);
            return ; /* it is important to return here */
        default:
            pips_internal_error("should not happen");
    };
    build_creductions_of_statement(parent,l);
    if(tofree) gen_free_list(l);
}

References build_creductions_of_statement(), CONS, CONTROL, control_list_to_statement_list(), CONTROL_MAP, copy_reductions(), forloop_body, gen_free_list(), gen_get_ancestor(), instruction_block, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, load_proper_reductions(), loop_body, make_statement_list, NIL, note_for_statement(), pips_debug, pips_internal_error, return(), statement_domain, store_cumulated_reductions(), test_false, test_true, unstructured_control, and whileloop_body.

Referenced by cumulated_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_one_summary_reduction()

static reduction compute_one_summary_reduction ( reduction  model, list  le  )

static

keep the entities that are exported...

Parameters

le

of effect

Definition at line 63 of file reductions.c.

{
  reduction r = copy_reduction(model);
 
  /* keep the entities that are exported... */
  FOREACH(ENTITY, e,reduction_dependences(model)) {
    if (!effects_may_read_or_write_memory_paths_from_entity_p(le,e))
            remove_variable_from_reduction(r, e);
  }
 
  gen_free_list(reduction_dependences(r));
  reduction_dependences(r) = NIL;
 
  DEBUG_REDUCTION(3, "result\n", r);
  return r;
}

References copy_reduction(), DEBUG_REDUCTION, effects_may_read_or_write_memory_paths_from_entity_p(), ENTITY, FOREACH, gen_free_list(), NIL, reduction_dependences, and remove_variable_from_reduction().

Referenced by compute_summary_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_proper_reductions()

static void compute_proper_reductions ( statement  s )

static

performs the computation of proper reductions for statement s.

this is a direct computation, throught gen_multi_recurse.

Definition at line 342 of file reductions.c.

{
    make_crt_stat_stack();
    gen_multi_recurse(s,
                      statement_domain, pr_statement_flt, pr_statement_wrt,
                      call_domain, pr_call_flt, gen_null,
                      NULL);
    free_crt_stat_stack();
}

References call_domain, gen_multi_recurse(), gen_null(), pr_call_flt(), pr_statement_flt(), pr_statement_wrt(), and statement_domain.

Referenced by proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_summary_reductions()

static reductions compute_summary_reductions ( entity  f )

static

of effect

of reduction

Definition at line 81 of file reductions.c.

{
    list /* of effect */ le = load_summary_effects(f);
    list /* of reduction */ lr = NIL, lc;
 
    lc = reductions_list
        (load_cumulated_reductions(get_current_module_statement()));
 
    pips_debug(3, "module %s: %td cumulated reductions\n",
               entity_name(f), gen_length(lc));
 
    FOREACH(REDUCTION, r,lc) {
      DEBUG_REDUCTION(4, "considering\n", r);
      if (effects_may_read_or_write_memory_paths_from_entity_p(le, reduction_variable(r)))
        lr = CONS(REDUCTION, compute_one_summary_reduction(r, le), lr);
    }
 
    return make_reductions(lr);
}

References compute_one_summary_reduction(), CONS, DEBUG_REDUCTION, effects_may_read_or_write_memory_paths_from_entity_p(), entity_name, f(), FOREACH, gen_length(), get_current_module_statement(), load_cumulated_reductions(), load_summary_effects(), make_reductions(), NIL, pips_debug, REDUCTION, reduction_variable, and reductions_list.

Referenced by summary_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

cumulated_reductions()

bool cumulated_reductions

(

const char *

module_name

)

handler for pipsmake input: the module name output: TRUE side effects: some

• requires CODE, PROPER_{EFFECTS,REDUCTIONS} and CUMULATED_EFFECTS
• returns CUMULATED_REDUCTIONS to pips dbm

gets what is needed from PIPS DBM

do the job here

returns the result to the DBM...

Parameters

module_name

odule_name

Definition at line 529 of file reductions.c.

{
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    init_cumulated_reductions();
    set_generic_effects_as_needed();
 
    /* gets what is needed from PIPS DBM
     */
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_current_module_statement((statement)
        db_get_memory_resource(DBR_CODE, module_name, true));
    set_proper_references((statement_effects)
        db_get_memory_resource(DBR_PROPER_REFERENCES, module_name, true));
    set_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_reductions((pstatement_reductions)
        db_get_memory_resource(DBR_PROPER_REDUCTIONS, module_name, true));
 
    /* do the job here
     */
    gen_recurse(get_current_module_statement(),instruction_domain,gen_true,compute_cumulated_reductions);
 
    /* returns the result to the DBM...
     */
    DB_PUT_MEMORY_RESOURCE
        (DBR_CUMULATED_REDUCTIONS, module_name, get_cumulated_reductions());
 
    reset_cumulated_reductions();
    reset_proper_reductions();
    reset_proper_references();
    reset_rw_effects();
    reset_current_module_entity();
    reset_current_module_statement();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_cumulated_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), generic_effects_reset_all_methods(), get_cumulated_reductions(), get_current_module_statement(), init_cumulated_reductions(), instruction_domain, local_name_to_top_level_entity(), module_name(), pips_debug, reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_reductions(), reset_proper_references(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_generic_effects_as_needed(), set_proper_reductions(), set_proper_references(), and set_rw_effects().

Here is the call graph for this function:

list_of_compatible_reductions()

static list list_of_compatible_reductions ( reductions  rs )

static

returns NIL on any problem

Definition at line 187 of file reductions.c.

                                                         {
  list lnr=NIL, le = add_reduced_variables(NIL, rs);
 
  FOREACH(ENTITY, var,le) {
    reduction r = compatible_reduction_of_var(var, rs);
    if (r) {
      lnr = CONS(REDUCTION, r, lnr);
    } else {
      gen_free_list(le);
      gen_full_free_list(lnr);
      return NIL;
    }
  }
  gen_free_list(le);
 
  return lnr;
}

References add_reduced_variables(), compatible_reduction_of_var(), CONS, ENTITY, FOREACH, gen_free_list(), gen_full_free_list(), NIL, and REDUCTION.

Referenced by check_proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_reduced_variables()

static list list_of_reduced_variables ( statement  node, list  ls  )

static

of entity

of entity

Parameters

ls	of statement

Definition at line 155 of file reductions.c.

{
    list /* of entity */ le = NIL;
    le = add_reduced_variables(le, load_proper_reductions(node));
    FOREACH (STATEMENT, s, ls) {
      if (bound_cumulated_reductions_p(s) )
        le = add_reduced_variables(le, load_cumulated_reductions(s));
      else {
        pips_debug(5, "stat %s %p\n", note_for_statement(s), s);
        pips_assert ("should not happen, all statements should have been visited for reduction", false);
      }
    }
    return le;
}

References add_reduced_variables(), bound_cumulated_reductions_p(), FOREACH, load_cumulated_reductions(), load_proper_reductions(), NIL, node(), note_for_statement(), pips_assert, pips_debug, and STATEMENT.

Referenced by build_creductions_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_trusted_references()

static list list_of_trusted_references ( reductions  rs )

static

???

Definition at line 205 of file reductions.c.

                                                      {
  list lr = NIL;
  FOREACH(REDUCTION, r,reductions_list(rs)) {
    FOREACH(PREFERENCE, p,reduction_trusted(r)) {
      lr = CONS(REFERENCE, preference_reference(p), lr);
    }
    lr = CONS(REFERENCE, reduction_reference(r), lr); /* ??? */
  }
  return lr;
}

References CONS, FOREACH, NIL, PREFERENCE, preference_reference, REDUCTION, reduction_reference, reduction_trusted, reductions_list, and REFERENCE.

Referenced by safe_effects_for_reductions().

Here is the caller graph for this function:

load_summary_reductions()

reductions load_summary_reductions

(

entity

f

)

Fortran 77 anti aliasing rules implies that sg that looks like a reduction within a subroutine can be perceived as so from outside because no aliasing may cause the accumulator to be linked to the rhs of the accumulation...

reductions.c

thus summary reductions can be propagated with no harm... just the usual conditions must be checked (no other effect on the variable)

Definition at line 55 of file reductions.c.

{
    pips_assert("is a module", entity_module_p(f));
    return (reductions) db_get_memory_resource
        (DBR_SUMMARY_REDUCTIONS, module_local_name(f), true);
}

References db_get_memory_resource(), entity_module_p(), f(), module_local_name(), and pips_assert.

Referenced by translate_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

pr_call_flt()

static bool pr_call_flt ( call  c )

static

Definition at line 309 of file reductions.c.

{
    statement head = crt_stat_head();
    reductions reds = load_proper_reductions(head);
    reduction red;
 
    pips_debug(9, "considering call to %s\n", entity_name(call_function(c)));
 
    if (call_proper_reduction_p(head, c, &red)) {
      // direct proper reduction
      reductions_list(reds) =
        CONS(REDUCTION, red, reductions_list(reds));
    }
    else if (entity_module_p(call_function(c)))
    {
      last_translated_module_call = c;
      reductions_list(reds) =
            gen_nconc(translate_reductions(c), reductions_list(reds));
    } else {
      ifdebug(4) {
        pips_debug(4,"Reductions for statement are:\n");
        FOREACH(REDUCTION, r,reductions_list(reds)) {
          DEBUG_REDUCTION(0, "considering\n", r);
        }
      }
    }
 
    return true;
}

References call_function, call_proper_reduction_p(), CONS, DEBUG_REDUCTION, entity_module_p(), entity_name, FOREACH, gen_nconc(), ifdebug, last_translated_module_call, load_proper_reductions(), pips_debug, REDUCTION, reductions_list, and translate_reductions().

Referenced by compute_proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

pr_statement_flt()

static bool pr_statement_flt ( statement  s )

static

Definition at line 288 of file reductions.c.

{
    store_proper_reductions(s, make_reductions(NIL));
    // crt_stat_filter simply push on the stack and return true
    return crt_stat_filter(s);
}

References make_reductions(), NIL, and store_proper_reductions().

Referenced by compute_proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

pr_statement_wrt()

static void pr_statement_wrt ( statement  s )

static

Definition at line 298 of file reductions.c.

{
    instruction i = statement_instruction(s);
    if (instruction_call_p(i) &&
        instruction_call(i)!=last_translated_module_call)
        check_proper_reductions(s);
    // crt_stat_rewrite pops from the stack and chek that s
    // was the latest pushed object
    crt_stat_rewrite(s);
}

References check_proper_reductions(), instruction_call, instruction_call_p, last_translated_module_call, and statement_instruction.

Referenced by compute_proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

proper_reductions()

bool proper_reductions

(

const char *

module_name

)

handler for pipsmake input: module name output: TRUE side effects: some

• requires CODE PROPER_EFFECTS and callees' SUMMARY_{EFFECTS,REDUCTIONS}
• returns PROPER_REDUCTIONS to pips dbm

gets what is needed from PIPS DBM

do the job

returns the result to the DBM...

Parameters

module_name

odule_name

Definition at line 359 of file reductions.c.

{
    entity module;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    init_proper_reductions();
    set_generic_effects_as_needed();
 
    /* gets what is needed from PIPS DBM
     */
    module = local_name_to_top_level_entity(module_name);
    set_current_module_entity(module);
    set_current_module_statement
        ((statement) db_get_memory_resource(DBR_CODE, module_name, true));
    set_proper_references((statement_effects)
        db_get_memory_resource(DBR_PROPER_REFERENCES, module_name, true));
 
    /* do the job
     */
    compute_proper_reductions(get_current_module_statement());
 
    /* returns the result to the DBM...
     */
    DB_PUT_MEMORY_RESOURCE
        (DBR_PROPER_REDUCTIONS, module_name, get_proper_reductions());
 
    reset_proper_reductions();
    reset_proper_references();
    reset_current_module_entity();
    reset_current_module_statement();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_proper_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), get_current_module_statement(), get_proper_reductions(), init_proper_reductions(), local_name_to_top_level_entity(), module, module_name(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_proper_reductions(), reset_proper_references(), set_current_module_entity(), set_current_module_statement(), set_generic_effects_as_needed(), and set_proper_references().

Here is the call graph for this function:

reduction_operator_entity()

entity reduction_operator_entity

(

reduction_operator

op

)

match a reduction operator against operator entity

Parameters

op	reduction operator

Returns

entity representing corresponding operator

Parameters

op

p

Definition at line 577 of file reductions.c.

{
    string opname = string_undefined;
    switch( reduction_operator_tag(op) ) {
        case is_reduction_operator_sum:
            opname=PLUS_OPERATOR_NAME;break;
        case is_reduction_operator_and:
            opname=AND_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_and:
            opname=BITWISE_AND_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_or:
            opname=BITWISE_OR_OPERATOR_NAME;break;
        case is_reduction_operator_bitwise_xor:
            opname=BITWISE_XOR_OPERATOR_NAME;break;
        case is_reduction_operator_csum:
            opname=PLUS_C_OPERATOR_NAME;break;
        case is_reduction_operator_eqv:
            opname=EQUIV_OPERATOR_NAME;break;
        case is_reduction_operator_max:
            opname=MAX_OPERATOR_NAME;break;
        case is_reduction_operator_min:
            opname=MIN_OPERATOR_NAME;break;
        case is_reduction_operator_neqv:
            opname=NON_EQUIV_OPERATOR_NAME;break;
        case is_reduction_operator_or:
            opname=OR_OPERATOR_NAME;break;
        case is_reduction_operator_prod:
            opname=MULTIPLY_OPERATOR_NAME;break;
        default:
            pips_internal_error("unhandled case");
    }
    return entity_intrinsic(opname);
}

References AND_OPERATOR_NAME, BITWISE_AND_OPERATOR_NAME, BITWISE_OR_OPERATOR_NAME, BITWISE_XOR_OPERATOR_NAME, entity_intrinsic(), EQUIV_OPERATOR_NAME, is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_csum, is_reduction_operator_eqv, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_neqv, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, MAX_OPERATOR_NAME, MIN_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NON_EQUIV_OPERATOR_NAME, opname(), OR_OPERATOR_NAME, pips_internal_error, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, reduction_operator_tag, and string_undefined.

Referenced by do_expression_reduction(), do_reduction_atomization(), and do_reduction_propagation().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_effects_for_reductions()

static bool safe_effects_for_reductions ( statement  s, reductions  rs  )

static

argh...

what about side effect related reductions ??? There are no relevant pointer to trust in such a case... What I can do as a (temporary) fix is not to check direct side effects (that is "call foo" ones) because they do not need to be checked...

of effect

of reference

Definition at line 222 of file reductions.c.

                                                                    {
  list /* of effect */ le = effects_effects(load_proper_references(s)),
      /* of reference */ lr = list_of_trusted_references(rs);
 
  FOREACH(EFFECT, e,le) {
    if ((effect_write_p(e) && store_effect_p(e) && !gen_in_list_p(effect_any_reference(e), lr)) ||
        io_effect_entity_p(effect_variable(e))) {
      pips_debug(8, "effect on %s (ref %p) not trusted\n",
                 entity_name(effect_variable(e)),
                 effect_any_reference(e));
 
      gen_free_list(lr);
      return false;
    }
  }
 
  gen_free_list(lr);
  return true;
}

References EFFECT, effect_any_reference, effect_variable, effect_write_p, effects_effects, entity_name, FOREACH, gen_free_list(), gen_in_list_p(), io_effect_entity_p(), list_of_trusted_references(), load_proper_references(), pips_debug, and store_effect_p().

Referenced by check_proper_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

same_reduction_p()

bool same_reduction_p	(	reduction	r1,
		reduction	r2
	)

Parameters

r1	1
r2	2

Definition at line 611 of file reductions.c.

{
    return ( (reference_equal_p(reduction_reference(r1),reduction_reference(r2))) &&
            (reduction_operator_tag(reduction_op(r1)) == reduction_operator_tag(reduction_op(r2))) );
}

References reduction_op, reduction_operator_tag, reduction_reference, and reference_equal_p().

Referenced by add_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

set_generic_effects_as_needed()

static void set_generic_effects_as_needed ( void  )

static

for CONTROL_MAP()

for load_summary_effects()

Definition at line 41 of file reductions.c.

{
    effect_dup_func = simple_effect_dup;
}

References effect_dup_func, and simple_effect_dup().

Referenced by cumulated_reductions(), proper_reductions(), and summary_reductions().

Here is the call graph for this function:

Here is the caller graph for this function:

summary_reductions()

bool summary_reductions

(

const char *

module_name

)

handler for pipsmake input: module name output: TRUE side effects: stores the summary reductions to pipsdbm

Parameters

module_name

odule_name

Definition at line 106 of file reductions.c.

{
    reductions red;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s\n", module_name);
 
    set_generic_effects_as_needed();
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_current_module_statement((statement)
        db_get_memory_resource(DBR_CODE, module_name, true));
    set_cumulated_reductions((pstatement_reductions)
        db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, module_name, true));
 
    red = compute_summary_reductions(get_current_module_entity());
 
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_REDUCTIONS, module_name, red);
 
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
    generic_effects_reset_all_methods();
 
    debug_off();
    return true;
}

References compute_summary_reductions(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), get_current_module_entity(), local_name_to_top_level_entity(), module_name(), pips_debug, reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), and set_generic_effects_as_needed().

Here is the call graph for this function:

Variable Documentation

last_translated_module_call

call last_translated_module_call = call_undefined

static

hack: no check for direct translations ("call foo") thus in this case effects reductions will be okay...

the reason for the patch is that I do not know how to preserve easily such "invisible" reductions against proper effects. FC.

Definition at line 279 of file reductions.c.

Referenced by pr_call_flt(), and pr_statement_wrt().