utils.c File Reference

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

Include dependency graph for utils.c:

Go to the source code of this file.

Macros
#define	OKAY(op, com)   do { *op_tag=op; *commutative=com; return true;} while(false)
#define	OKAY_WO_COMM(op)   do { *op_tag=op; return true;} while(false)

Functions
static syntax	make_star_syntax ()
	??? some arrangements with words_range to print a star in this case:-) More...
bool	reduction_star_p (reduction r)
	utils.c More...
static void	ref_rwt (reference r)
static list	referenced_variables (reference r)
	of entity More...
static bool	expr_flt (expression e)
	stack of reference expressions (if there is no call) More...
static void	expr_rwt (expression e)
static bool	ref_flt (reference r)
void	remove_variable_from_reduction (reduction red, entity var)
bool	update_reduction_under_effect (reduction red, effect eff)
static bool	find_reduction_of_var (entity var, reductions reds, reduction *pr)
	looks for a reduction about var in reds, and returns it. More...
static bool	merge_two_reductions (reduction first, reduction second)
	merge two reductions into first so as to be compatible with both. More...
bool	update_compatible_reduction_with (reduction *pr, entity var, reduction r)
	update *pr according to r for variable var r is not touched. More...
bool	update_compatible_reduction (reduction *pr, entity var, list le, reductions reds)
	what to do with reduction *pr for variable var under effects le and reductions reds. More...
bool	pure_function_p (entity f)
	extract the proper reduction of a call (instruction) if any. More...
static bool	call_flt (call c)
static bool	functional_object_p (gen_chunk *obj)
static bool	function_reduction_operator_p (entity f, tag *op_tag, bool *commutative)
	tells whether entity f is a reduction operator function also returns the corresponding tag, and if commutative More...
static bool	extract_reduction_operator (expression e, tag *op_tag, bool *commutative)
	returns the possible operator of expression e if it is a reduction, and the operation commutative. More...
static bool	extract_reduction_update_operator (entity operator, tag *op_tag, bool *commutative)
	Test if the operator is an update operator compatible with reduction This also returns the corresponding tag, and if commutative. More...
static bool	extract_reduction_unary_update_operator (entity operator, tag *op_tag)
	Test if the operator is an unary update operator compatible with reduction This also returns the corresponding tag. More...
static bool	reduction_function_compatible_p (entity f, tag op, bool *pcomm)
static bool	fsr_reference_flt (reference r)
static bool	fsr_call_flt (call c)
static bool	equal_reference_in_expression_p (reference r, expression e, tag rop, bool red_up_op, reference *pfound)
	returned More...
bool	no_other_effects_on_references (statement s, list lr)
	checks that the references are the only touched within this statement. More...
bool	call_proper_reduction_p (statement s, call c, reduction *red)
	This function look for a reduction and return it if found mallocs are avoided if nothing is found... More...
expression	get_complement_expression (statement s, reference reduced)
	Return the "other part" of the reduction. More...

Variables
static list	referenced
	returns the list of referenced variables More...
static entity	variable_to_remove
	must be able to remove a modified variable from a reduction: More...
static list	dead_expressions
	list of expressions to be deleted (at rwt) More...
static expression	first_encountered_call
	the first expression encountered which is a function call, so as to avoid "*+J" results More...
static bool	is_functional
	tells whether r is a functional reference... More...
static reference	fsr_ref
	looks for an equal reference in e, for reduction rop. More...
static reference	fsr_found
static tag	fsr_op

Macro Definition Documentation

OKAY

#define OKAY	(		op,
			com
	)		do { *op_tag=op; *commutative=com; return true;} while(false)

Definition at line 388 of file utils.c.

OKAY_WO_COMM

#define OKAY_WO_COMM

(

op

)

do { *op_tag=op; return true;} while(false)

Definition at line 389 of file utils.c.

Function Documentation

call_flt()

static bool call_flt ( call  c )

static

else

Definition at line 369 of file utils.c.

{
    if (pure_function_p(call_function(c)))
        return true;
    /* else */
    is_functional = false;
    gen_recurse_stop(NULL);
    return false;
}

References call_function, gen_recurse_stop(), is_functional, and pure_function_p().

Referenced by functional_object_p().

Here is the call graph for this function:

Here is the caller graph for this function:

call_proper_reduction_p()

bool call_proper_reduction_p	(	statement	s,
		call	c,
		reduction *	red
	)

This function look for a reduction and return it if found mallocs are avoided if nothing is found...

looks for v = v OP y or v OP= y, where y is independent of v.

Returns

true if the call in s a reduction

Parameters

s

Parameters

c	needed to query about proper effects
red	the call of interest

Definition at line 633 of file utils.c.

{
  tag op; // The operator tag (sum, mul ...)
  list le = NIL; // list of expression
  list lr = NIL; // list of reference
  list lp = NIL; // list of Preference
  bool comm      = false; // The commutatity operator flag
  bool assign_op = false; // The assign operator flag
  bool update_op = false; // The reduction update operator flag;
  bool unary_op  = false; // The reduction unary update operator flag;
  entity fct = call_function(c); // the call function to test for reduction
  reference  lhs   = reference_undefined;
  reference  other = reference_undefined;
  expression elhs  = expression_undefined;
  expression erhs  = expression_undefined;
 
  pips_debug(7, "call to %s (%p)\n", entity_name(call_function(c)), s);
 
  // First init the operation flags
  // only check the operator type if the previous test failed
  if ((assign_op = ENTITY_ASSIGN_P (fct)) == false)
    if ((update_op=extract_reduction_update_operator(fct, &op, &comm))==false)
      unary_op = extract_reduction_unary_update_operator (fct, &op);
 
  // if no suitable operator has been found : return false
  if ((unary_op == false) && (update_op == false) && (assign_op == false)) {
    pips_debug(5,"No unary, nor update, no assign !\n");
    return false;
  }
 
  // get the left and right operands
  le = call_arguments(c);
  elhs = EXPRESSION(CAR(le));
  //no right operand for unary operator
  if (unary_op == false) erhs = EXPRESSION(CAR(CDR(le)));
  if (syntax_reference_p(expression_syntax(elhs)) == false) {
    pips_user_warning ("The left hand side of assignment is not a reference, "
        "this is not handled and no reduction will be detected\n");
    return false;
  }
  lhs = syntax_reference(expression_syntax(elhs));
 
  // the lhs and rhs (if exits) must be functionnal
  // (same location on different evaluations)
  if (!functional_object_p((gen_chunk *) lhs)   ||
      ((unary_op == false) && !functional_object_p((gen_chunk *) erhs))) {
    pips_debug(5,"Lhs or Rhs not functional !\n");
    return false;
  }
  pips_debug(8, "lhs and rhs are functional\n");
 
  // Check that the operation performed is valid for a reduction,
  // The check is useless for reduction update and unary operator because
  // already done previously by "extract_reduction_update_operator" and
  // "extract_reduction_unary_update_operator"
  if ((unary_op == false) && (update_op == false) &&
      (extract_reduction_operator(erhs, &op, &comm) == false)) {
    pips_debug(5,"extract_reduction_operator returned false !!\n");
    return false;
  }
  pips_debug(8, "reduction operator %s\n", reduction_operator_tag_name(op));
 
  // there should be another direct reference to lhs if not unary
  // !!! syntax is a call if extract_reduction_operator returned TRUE
  if (unary_op == false) {
    if (!equal_reference_in_expression_p(lhs, erhs, op, update_op, &other)) {
      pips_debug(5,"!equal_reference_in_expression_p !!\n");
      return false;
    }
    pips_debug(8, "matching reference found (%p)\n", other);
  }
 
  // build the list of found reference to the reduced variable
  if ((update_op == true) || (unary_op == true))
    lr = CONS(REFERENCE, lhs, NIL);
  else
    lr = CONS(REFERENCE, lhs, CONS(REFERENCE, other, NIL));
  pips_debug(7,"list lr is: %p and %p\n", other, lhs);
  // there should be no extra effects on the reduced variable
  if (!no_other_effects_on_references (s, lr)) {
    pips_debug(5,"Other effects on references !!\n");
    gen_free_list(lr);
    return false;
  }
  pips_debug(8, "no other effects\n");
 
  FOREACH (REFERENCE, r, lr) {
    lp = CONS(PREFERENCE, make_preference(r), lp);
  }
  gen_free_list(lr), lr = NIL;
 
  // well, it is ok for a reduction now!
  *red = make_reduction(copy_reference(lhs),
                        make_reduction_operator(op, UU),
                        referenced_variables(lhs),
                        lp);
 
  DEBUG_REDUCTION(7, "returning\n", *red);
  return true;
}

References call_arguments, call_function, CAR, CDR, CONS, copy_reference(), DEBUG_REDUCTION, ENTITY_ASSIGN_P, entity_name, equal_reference_in_expression_p(), EXPRESSION, expression_syntax, expression_undefined, extract_reduction_operator(), extract_reduction_unary_update_operator(), extract_reduction_update_operator(), FOREACH, functional_object_p(), gen_free_list(), make_preference(), make_reduction(), make_reduction_operator(), NIL, no_other_effects_on_references(), pips_debug, pips_user_warning, PREFERENCE, reduction_operator_tag_name(), REFERENCE, reference_undefined, referenced_variables(), syntax_reference, syntax_reference_p, update_op(), and UU.

Referenced by pr_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

equal_reference_in_expression_p()

static bool equal_reference_in_expression_p ( reference  r, expression  e, tag  rop, bool  red_up_op, reference *  pfound  )

static

returned

Parameters

e	looked for
rop	visited object
red_up_op	assumed reduction

Definition at line 570 of file utils.c.

{
    fsr_ref = r;
    fsr_op  = rop;
    fsr_found = NULL;
 
    gen_multi_recurse(e,
                      call_domain, fsr_call_flt, gen_null,
                      reference_domain, fsr_reference_flt, gen_null,
                      NULL);
 
    *pfound = fsr_found;
    return (red_up_op || (fsr_found != NULL));
}

References call_domain, fsr_call_flt(), fsr_found, fsr_op, fsr_ref, fsr_reference_flt(), gen_multi_recurse(), gen_null(), and reference_domain.

Referenced by call_proper_reduction_p().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_flt()

static bool expr_flt ( expression  e )

static

stack of reference expressions (if there is no call)

REFERENCE

CALL

Definition at line 94 of file utils.c.

{
    if (expression_reference_p(e)) /* REFERENCE */
        ref_exprs_push(e);
    else if (!first_encountered_call && expression_call_p(e)) /* CALL */
        first_encountered_call = e;
    return true;
}

References expression_call_p(), expression_reference_p(), and first_encountered_call.

Referenced by remove_variable_from_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_rwt()

static void expr_rwt ( expression  e )

static

Definition at line 103 of file utils.c.

{
    if (expression_reference_p(e))
        ref_exprs_pop();
    else if (first_encountered_call==e)
        first_encountered_call = NULL;
 
    if (gen_in_list_p(e, dead_expressions))
    {
        free_syntax(expression_syntax(e));
        expression_syntax(e) = make_star_syntax();
    }
}

References dead_expressions, expression_reference_p(), expression_syntax, first_encountered_call, free_syntax(), gen_in_list_p(), and make_star_syntax().

Referenced by remove_variable_from_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_reduction_operator()

static bool extract_reduction_operator ( expression  e, tag *  op_tag, bool *  commutative  )

static

returns the possible operator of expression e if it is a reduction, and the operation commutative.

(- and / are not)

Definition at line 437 of file utils.c.

{
    syntax s = expression_syntax(e);
    call c;
    entity f;
 
    if (!syntax_call_p(s)) return false;
    c = syntax_call(s);
    f = call_function(c);
    return function_reduction_operator_p(f, op_tag, commutative);
}

References call_function, expression_syntax, f(), function_reduction_operator_p(), syntax_call, and syntax_call_p.

Referenced by call_proper_reduction_p().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_reduction_unary_update_operator()

static bool extract_reduction_unary_update_operator ( entity  operator, tag *  op_tag  )

static

Test if the operator is an unary update operator compatible with reduction This also returns the corresponding tag.

Returns

true if the operator is an update operator compatible with reduction

Parameters

operator,the	operator (as an entity) to look at
op_tag,used	to return the reduction operator (+, ...)

Definition at line 487 of file utils.c.

{
  if (ENTITY_POST_INCREMENT_P(operator) ||
      ENTITY_POST_DECREMENT_P(operator) ||
      ENTITY_PRE_INCREMENT_P(operator) ||
      ENTITY_PRE_DECREMENT_P(operator))
    OKAY_WO_COMM (is_reduction_operator_sum);
 
  return false;
}

References ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_DECREMENT_P, ENTITY_PRE_INCREMENT_P, is_reduction_operator_sum, and OKAY_WO_COMM.

Referenced by call_proper_reduction_p(), and get_complement_expression().

Here is the caller graph for this function:

extract_reduction_update_operator()

static bool extract_reduction_update_operator ( entity  operator, tag *  op_tag, bool *  commutative  )

static

Test if the operator is an update operator compatible with reduction This also returns the corresponding tag, and if commutative.

Returns

true if the operator is an update operator compatible with reduction

Parameters

operator,the	operator (as an entity) to look at
op_tag,used	to return the reduction operator (+, * ...)
commutative,used	to return the operator commutativity

Definition at line 459 of file utils.c.

{
  if (ENTITY_PLUS_UPDATE_P (operator))
    OKAY(is_reduction_operator_sum, true);
  else if (ENTITY_MINUS_UPDATE_P (operator))
    OKAY(is_reduction_operator_sum, true);
  else if (ENTITY_MULTIPLY_UPDATE_P (operator))
    OKAY(is_reduction_operator_prod, true);
  else if (ENTITY_DIVIDE_UPDATE_P (operator))
    OKAY(is_reduction_operator_prod, true);
  else if (ENTITY_BITWISE_OR_UPDATE_P (operator))
    OKAY (is_reduction_operator_bitwise_or, true);
  else if (ENTITY_BITWISE_AND_UPDATE_P (operator))
    OKAY(is_reduction_operator_bitwise_and, true);
  else if (ENTITY_BITWISE_XOR_UPDATE_P (operator))
    OKAY(is_reduction_operator_bitwise_xor, true);
 
  return false;
}

References ENTITY_BITWISE_AND_UPDATE_P, ENTITY_BITWISE_OR_UPDATE_P, ENTITY_BITWISE_XOR_UPDATE_P, ENTITY_DIVIDE_UPDATE_P, ENTITY_MINUS_UPDATE_P, ENTITY_MULTIPLY_UPDATE_P, ENTITY_PLUS_UPDATE_P, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, is_reduction_operator_prod, is_reduction_operator_sum, and OKAY.

Referenced by call_proper_reduction_p(), and get_complement_expression().

Here is the caller graph for this function:

find_reduction_of_var()

static bool find_reduction_of_var ( entity  var, reductions  reds, reduction *  pr  )

static

looks for a reduction about var in reds, and returns it.

tells whether it worths keeping on. It does not if there may be some conflicts with other reduced variables...

I will not combine them...

Definition at line 209 of file utils.c.

{
  FOREACH (REDUCTION, r, reductions_list(reds)) {
    entity red_var = reduction_variable(r);
    if (red_var==var) {
      *pr = copy_reduction(r);
      return true;
    }
    else if (entities_may_conflict_p(red_var, var))
      return false; /* I will not combine them... */
  }
  return true;
}

References copy_reduction(), entities_may_conflict_p(), FOREACH, REDUCTION, reduction_variable, and reductions_list.

Referenced by update_compatible_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

fsr_call_flt()

static bool fsr_call_flt ( call  c )

static

Returns

true if the all operators are compatible with the detected reduction operator

Parameters

c,the

call to search for operators

else

of expression

Definition at line 553 of file utils.c.

{
    bool comm;
    if (!reduction_function_compatible_p(call_function(c), fsr_op, &comm))
      return false;
    /* else */
    if (!comm)
    {
      list /* of expression */ le = call_arguments(c);
      pips_assert("length is two", gen_length(le)==2);
      gen_recurse_stop(EXPRESSION(CAR(CDR(le))));
    }
 
    return true;
}

References call_arguments, call_function, CAR, CDR, EXPRESSION, fsr_op, gen_length(), gen_recurse_stop(), pips_assert, and reduction_function_compatible_p().

Referenced by equal_reference_in_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

fsr_reference_flt()

static bool fsr_reference_flt ( reference  r )

static

stop the recursion if does not need to check int div

no candidate refs within a ref!

Definition at line 532 of file utils.c.

{
  pips_debug(7,"r: %s, fsr_ref: %s\n",
             entity_name(reference_variable(r)),
             entity_name(reference_variable(fsr_ref)));
   if (reference_equal_p(r, fsr_ref))
    {
     fsr_found = r;
     /* stop the recursion if does not need to check int div
      */
     if (!basic_int_p(entity_basic(reference_variable(fsr_ref))) ||
         (fsr_op!=is_reduction_operator_prod))
       gen_recurse_stop(NULL);
    }
 
    return false; /* no candidate refs within a ref! */
}

References basic_int_p, entity_basic(), entity_name, fsr_found, fsr_op, fsr_ref, gen_recurse_stop(), is_reduction_operator_prod, pips_debug, reference_equal_p(), and reference_variable.

Referenced by equal_reference_in_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

function_reduction_operator_p()

static bool function_reduction_operator_p ( entity  f, tag *  op_tag, bool *  commutative  )

static

tells whether entity f is a reduction operator function also returns the corresponding tag, and if commutative

Returns

true if the entity f is a reduction operator function

Parameters

f,the	entity to look at
op_tag,use	to return the reduction operator (+, * ...)
commutative,use	to return the operator commutativity

Definition at line 398 of file utils.c.

{
    if (ENTITY_PLUS_P(f))
      OKAY(is_reduction_operator_sum, true);
    else if (ENTITY_MINUS_P(f))
      OKAY(is_reduction_operator_sum, false);
    else if (ENTITY_MULTIPLY_P(f))
      OKAY(is_reduction_operator_prod, true);
    else if (ENTITY_DIVIDE_P(f))
      OKAY(is_reduction_operator_prod, false);
    else if (ENTITY_MIN_P(f) || ENTITY_MIN0_P(f))
      OKAY(is_reduction_operator_min, true);
    else if (ENTITY_MAX_P(f) || ENTITY_MAX0_P(f))
      OKAY(is_reduction_operator_max, true);
    else if (ENTITY_AND_P(f))
      OKAY(is_reduction_operator_and, true);
    else if (ENTITY_OR_P(f))
      OKAY(is_reduction_operator_or, true);
    else if (ENTITY_BITWISE_AND_P(f))
      OKAY(is_reduction_operator_bitwise_and, true);
    else if (ENTITY_BITWISE_OR_P(f))
      OKAY(is_reduction_operator_bitwise_or, true);
    else if (ENTITY_BITWISE_XOR_P(f))
      OKAY(is_reduction_operator_bitwise_xor, true);
    else if (ENTITY_EQUIV_P(f))
      OKAY(is_reduction_operator_eqv, true);
    else if (ENTITY_NON_EQUIV_P(f))
      OKAY(is_reduction_operator_neqv, true);
    else
      return false;
}

References ENTITY_AND_P, ENTITY_BITWISE_AND_P, ENTITY_BITWISE_OR_P, ENTITY_BITWISE_XOR_P, ENTITY_DIVIDE_P, ENTITY_EQUIV_P, ENTITY_MAX0_P, ENTITY_MAX_P, ENTITY_MIN0_P, ENTITY_MIN_P, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_NON_EQUIV_P, ENTITY_OR_P, ENTITY_PLUS_P, f(), is_reduction_operator_and, is_reduction_operator_bitwise_and, is_reduction_operator_bitwise_or, is_reduction_operator_bitwise_xor, 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, and OKAY.

Referenced by extract_reduction_operator(), and reduction_function_compatible_p().

Here is the call graph for this function:

Here is the caller graph for this function:

functional_object_p()

static bool functional_object_p ( gen_chunk *  obj )

static

Definition at line 379 of file utils.c.

{
    is_functional = true;
    gen_recurse(obj, call_domain, call_flt, gen_null);
    return is_functional;
}

References call_domain, call_flt(), gen_null(), gen_recurse, and is_functional.

Referenced by call_proper_reduction_p().

Here is the call graph for this function:

Here is the caller graph for this function:

get_complement_expression()

expression get_complement_expression	(	statement	s,
		reference	reduced
	)

Return the "other part" of the reduction.

If the statement is : sum = sum + a[i]; then we'll return a[i]

try to find out which of the two expression corresponds to the reduced reference. We'll return the other...

Parameters

reduced

educed

Definition at line 743 of file utils.c.

                                                                     {
  expression complement = expression_undefined;
  // We handle only trivial cases
  if(statement_call_p(s)) {
    call c = statement_call(s);
    entity fct = call_function(c);
    list le = call_arguments(c);
    tag op;
    bool comm = false; // Commutativity
    // Differentiate unary && update && binary operators
    if (ENTITY_ASSIGN_P (fct)){
      // Normal case, binary expected
      expression rhs = EXPRESSION(CAR(CDR(le)));
      if(expression_call_p(rhs)) {
        list args = call_arguments(expression_call(rhs));
        pips_assert("Have a binary operator\n", gen_length(args)==2);
        /* try to find out which of the two expression corresponds to the
         * reduced reference. We'll return the other...
         */
        expression e1 = EXPRESSION(CAR(args));
        expression e2 = EXPRESSION(CAR(CDR(args)));
        if(expression_reference_p(e1) &&
            same_ref_name_p(reduced,expression_reference(e1))) {
          complement = e2;
        } else if(expression_reference_p(e2) &&
            same_ref_name_p(reduced,expression_reference(e2))) {
          complement = e2;
        } else {
          pips_user_warning("Atomic operation replacement seems less general"
              " than reduction detection. This merits a bug report !\n");
        }
      } else {
        pips_user_warning("Atomic operation replacement seems less general than"
            " reduction detection. This merits a bug report !\n");
      }
    } else if(extract_reduction_unary_update_operator(fct, &op)) {
      // ++ or --  : we return 1
      pips_debug(3,"We have an unary operator\n");
      complement = int_to_expression(1);
    } else if(extract_reduction_update_operator(fct, &op, &comm)) {
      // += or similar, return directly rhs
      pips_debug(3,"We have an update operator\n");
      complement = EXPRESSION(CAR(CDR(le)));
    } else {
      pips_internal_error("We have a reduction, but the statement is neither an"
          " unary nor a binary ? It's a bug, sorry no choice but abort !\n");
    }
  }
  return complement;
}

References call_arguments, call_function, CAR, CDR, ENTITY_ASSIGN_P, EXPRESSION, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_undefined, extract_reduction_unary_update_operator(), extract_reduction_update_operator(), gen_length(), int_to_expression(), pips_assert, pips_debug, pips_internal_error, pips_user_warning, same_ref_name_p(), statement_call(), and statement_call_p().

Referenced by replace_reductions_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_star_syntax()

static syntax make_star_syntax ( )

static

??? some arrangements with words_range to print a star in this case:-)

Definition at line 39 of file utils.c.

{
    return make_syntax(is_syntax_range,
                       make_range(expression_undefined,
                                  expression_undefined,
                                  expression_undefined));
}

References expression_undefined, is_syntax_range, make_range(), and make_syntax().

Referenced by expr_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_two_reductions()

static bool merge_two_reductions ( reduction  first, reduction  second  )

static

merge two reductions into first so as to be compatible with both.

deletes the second. tells whether they where compatibles quite basic at the time

actually merges, very simple at the time

Definition at line 231 of file utils.c.

{
    pips_assert("same variable",
                reduction_variable(first)==reduction_variable(second));
 
    if (reduction_operator_tag(reduction_op(first))!=
        reduction_operator_tag(reduction_op(second)))
    {
        free_reduction(second);
        return false;
    }
 
    if (!reference_equal_p(reduction_reference(first),
                           reduction_reference(second)))
    {
        /* actually merges, very simple at the time
         */
        free_reference(reduction_reference(first));
        reduction_reference(first) =
            make_reference(reduction_variable(second), NIL);
    }
 
    free_reduction(second);
    return true;
}

References free_reduction(), free_reference(), make_reference(), NIL, pips_assert, reduction_op, reduction_operator_tag, reduction_reference, reduction_variable, and reference_equal_p().

Referenced by update_compatible_reduction(), and update_compatible_reduction_with().

Here is the call graph for this function:

Here is the caller graph for this function:

no_other_effects_on_references()

bool no_other_effects_on_references	(	statement	s,
		list	lr
	)

checks that the references are the only touched within this statement.

I trust the proper effects to store all references...

of effect

Parameters

lr	of reference on the same variable

Definition at line 596 of file utils.c.

{
    list /* of effect */ le;
    entity var;
    if (ENDP(lr)) return true;
 
    le = effects_effects(load_proper_references(s));
    var = reference_variable(REFERENCE(CAR(lr)));
 
    pips_debug(7,"entity name: %s\n", entity_name(var));
 
    FOREACH (EFFECT, e, le) {
      if(!store_effect_p(e)) continue;
      reference r = effect_any_reference(e);
      if (!gen_in_list_p(r, lr) && store_effect_p(e) &&
          entities_may_conflict_p(reference_variable(r), var)) {
        pips_debug(7,"Effect may touch variable : ");print_effect(e);
        return false;
      }
      pips_debug(7,"refrence r: %p of entity: %s\n", r, entity_name (reference_variable(r)));
    }
 
    return true;
}

References CAR, EFFECT, effect_any_reference, effects_effects, ENDP, entities_may_conflict_p(), entity_name, FOREACH, gen_in_list_p(), load_proper_references(), pips_debug, print_effect, REFERENCE, reference_variable, and store_effect_p().

Referenced by call_proper_reduction_p().

Here is the call graph for this function:

Here is the caller graph for this function:

pure_function_p()

bool pure_function_p

(

entity

f

)

extract the proper reduction of a call (instruction) if any.

I trust intrinsics (operations?) and summary effects...

else

a side effect!?

LUNS

Definition at line 343 of file utils.c.

{
    value v = entity_initial(f);
 
    if (value_symbolic_p(v) || value_constant_p(v) || value_intrinsic_p(v))
      return true;
    /* else */
 
    if (entity_module_p(f))
    {
      FOREACH (EFFECT, e, load_summary_effects(f)) {
        if(!store_effect_p(e)) continue;
        if (effect_write_p(e)) /* a side effect!? */
          return false;
        if (io_effect_entity_p(effect_variable(e))) /* LUNS */
          return false;
      }
    }
 
    return true;
}

References EFFECT, effect_variable, effect_write_p, entity_initial, entity_module_p(), f(), FOREACH, io_effect_entity_p(), load_summary_effects(), store_effect_p(), value_constant_p, value_intrinsic_p, and value_symbolic_p.

Referenced by call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_function_compatible_p()

static bool reduction_function_compatible_p ( entity  f, tag  op, bool *  pcomm  )

static

Returns

true if f is compatible with tag op.

Parameters

f	the entity to check.
op	the tag to check against.
pcomm	the commutative return value.

Definition at line 505 of file utils.c.

{
    tag nop;
    if (!function_reduction_operator_p(f, &nop, pcomm))
        return false;
    return nop==op;
}

References f(), and function_reduction_operator_p().

Referenced by fsr_call_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_star_p()

bool reduction_star_p

(

reduction

r

)

utils.c

Definition at line 46 of file utils.c.

                                   {
    reference ref = reduction_reference(r);
    FOREACH(EXPRESSION,exp,reference_indices(ref))
        if( syntax_range_p(expression_syntax(exp)) ) {
            range ran = syntax_range(expression_syntax(exp));
            if(expression_undefined_p(range_upper(ran)))
                return true;
        }
    return false;
}

References exp, EXPRESSION, expression_syntax, expression_undefined_p, FOREACH, range_upper, reduction_reference, ref, reference_indices, syntax_range, and syntax_range_p.

Referenced by rename_statement_reductions().

Here is the caller graph for this function:

ref_flt()

static bool ref_flt ( reference  r )

static

Definition at line 117 of file utils.c.

{
    if (reference_variable(r)==variable_to_remove)
    {
        dead_expressions =
            gen_once(first_encountered_call? first_encountered_call:
                     ref_exprs_head(), dead_expressions);
        return false;
    }
    return true;
}

References dead_expressions, first_encountered_call, gen_once(), reference_variable, and variable_to_remove.

Referenced by remove_variable_from_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_rwt()

static void ref_rwt ( reference  r )

static

Definition at line 61 of file utils.c.

{ referenced = gen_once(reference_variable(r), referenced);}

References gen_once(), reference_variable, and referenced.

Referenced by referenced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

referenced_variables()

static list referenced_variables ( reference  r )

static

of entity

Definition at line 65 of file utils.c.

{
    referenced = NIL;
    gen_recurse(r, reference_domain, gen_true, ref_rwt);
    return referenced;
}

References gen_recurse, gen_true(), NIL, ref_rwt(), reference_domain, and referenced.

Referenced by call_proper_reduction_p(), and update_reduction_under_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_variable_from_reduction()

void remove_variable_from_reduction	(	reduction	red,
		entity	var
	)

Parameters

red	ed
var	ar

Definition at line 130 of file utils.c.

{
    variable_to_remove = var;
    dead_expressions = NIL;
    first_encountered_call = NULL;
    make_ref_exprs_stack();
 
    pips_debug(8, "removing %s from %s[%s]\n",
               entity_name(var),
               reduction_operator_tag_name
                  (reduction_operator_tag(reduction_op(red))),
               entity_name(reduction_variable(red)));
 
    gen_multi_recurse(reduction_reference(red),
                      expression_domain, expr_flt, expr_rwt,
                      reference_domain, ref_flt, gen_null,
                      NULL);
 
    gen_free_list(dead_expressions);
    free_ref_exprs_stack();
}

References dead_expressions, entity_name, expr_flt(), expr_rwt(), expression_domain, first_encountered_call, gen_free_list(), gen_multi_recurse(), gen_null(), NIL, pips_debug, reduction_op, reduction_operator_tag, reduction_operator_tag_name(), reduction_reference, reduction_variable, ref_flt(), reference_domain, and variable_to_remove.

Referenced by compute_one_summary_reduction(), update_compatible_reduction(), and update_reduction_under_effect().

Here is the call graph for this function:

Here is the caller graph for this function:

update_compatible_reduction()

bool update_compatible_reduction	(	reduction *	pr,
		entity	var,
		list	le,
		reductions	reds
	)

what to do with reduction *pr for variable var under effects le and reductions reds.

returns whether worth to go on. conditions:

some reduction already available

must update the reduction with the encountered effects

else now no new reduction waas found, must check *pr against effects

some reduction

stores for latter cleaning

Parameters

pr	r
var	ar
le	of effect
reds	eds

Definition at line 285 of file utils.c.

{
    reduction found = NULL;
 
    if (!find_reduction_of_var(var, reds, &found))
        return false;
 
    if (found)
    {
      if (!reduction_none_p(*pr)) /* some reduction already available */
        return merge_two_reductions(*pr, found);
      else { /* must update the reduction with the encountered effects */
        FOREACH (ENTITY, e,reduction_dependences(*pr)) {
          remove_variable_from_reduction(found, e);
        }
        free_reduction(*pr); *pr = found;
        return true;
      }
    }
    /* else
     * now no new reduction waas found, must check *pr against effects
     */
    if (!reduction_none_p(*pr)) /* some reduction */
      {
        FOREACH (EFFECT, e, le) {
    if(!store_effect_p(e)) continue;
          if (!update_reduction_under_effect(*pr, e)) {
            DEBUG_REDUCTION(8, "kill of ", *pr);
            pips_debug(8, "under effect to %s\n",
                       entity_name(effect_variable(e)));
            return false;
          }
        }
    }
    else
    {
      FOREACH (EFFECT, e, le) {
        if(!store_effect_p(e)) continue;
        if (entities_may_conflict_p(effect_variable(e), var))
          return false;
        else if (effect_write_p(e)) /* stores for latter cleaning */
          reduction_dependences(*pr) = gen_once(effect_variable(e),
                                                reduction_dependences(*pr));
      }
    }
    return true;
}

References DEBUG_REDUCTION, EFFECT, effect_variable, effect_write_p, entities_may_conflict_p(), ENTITY, entity_name, find_reduction_of_var(), FOREACH, free_reduction(), gen_once(), merge_two_reductions(), pips_debug, reduction_dependences, reduction_none_p, remove_variable_from_reduction(), store_effect_p(), and update_reduction_under_effect().

Referenced by build_reduction_of_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

update_compatible_reduction_with()

bool update_compatible_reduction_with	(	reduction *	pr,
		entity	var,
		reduction	r
	)

update *pr according to r for variable var r is not touched.

else same var and no conflict

else are they compatible?

ok, let us merge them

Parameters

pr	r
var	ar

Definition at line 260 of file utils.c.

                                                                              {
  if(reduction_variable(r) != var)
    return !entities_may_conflict_p(var, reduction_variable(r));
 
  /* else same var and no conflict */
  if(reduction_none_p(*pr)) {
    free_reduction(*pr);
    *pr = copy_reduction(r);
    return true;
  }
  /* else are they compatible?
   */
  if(reduction_tag(*pr) != reduction_tag(r))
    return false;
  /* ok, let us merge them
   */
  return merge_two_reductions(*pr, copy_reduction(r));
}

References copy_reduction(), entities_may_conflict_p(), free_reduction(), merge_two_reductions(), reduction_none_p, reduction_tag, and reduction_variable.

Referenced by compatible_reduction_of_var().

Here is the call graph for this function:

Here is the caller graph for this function:

update_reduction_under_effect()

bool update_reduction_under_effect	(	reduction	red,
		effect	eff
	)

REDUCTION is dead if the reduction variable is affected

else

now var is written

Parameters

red	ed
eff	ff

Definition at line 155 of file utils.c.

{
    entity var = effect_variable(eff);
    bool updated = false;
 
    pips_debug(7, "reduction %s[%s] under effect %s on %s\n",
               reduction_operator_tag_name
                  (reduction_operator_tag(reduction_op(red))),
               entity_name(reduction_variable(red)),
               effect_write_p(eff)? "W": "R",
               entity_name(effect_variable(eff)));
 
    if(!store_effect_p(eff)) {
      return true;
    }
 
 
    /* REDUCTION is dead if the reduction variable is affected
     */
    if (entities_may_conflict_p(reduction_variable(red),var))
    {
        reduction_operator_tag(reduction_op(red)) =
            is_reduction_operator_none;
        return false;
    }
    /* else */
 
    if (effect_read_p(eff)) return true;
 
    /* now var is written */
    FOREACH (ENTITY, e, reduction_dependences(red)) {
      if (entities_may_conflict_p(var, e)) {
        updated = true;
        remove_variable_from_reduction(red, e);
      }
    }
 
    if (updated)
    {
        gen_free_list(reduction_dependences(red));
        reduction_dependences(red) =
             referenced_variables(reduction_reference(red));
    }
 
    return true;
}

References effect_read_p, effect_variable, effect_write_p, entities_may_conflict_p(), ENTITY, entity_name, FOREACH, gen_free_list(), is_reduction_operator_none, pips_debug, reduction_dependences, reduction_op, reduction_operator_tag, reduction_operator_tag_name(), reduction_reference, reduction_variable, referenced_variables(), remove_variable_from_reduction(), and store_effect_p().

Referenced by update_compatible_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

dead_expressions

list dead_expressions

static

list of expressions to be deleted (at rwt)

of expression

Definition at line 85 of file utils.c.

Referenced by expr_rwt(), ref_flt(), and remove_variable_from_reduction().

first_encountered_call

expression first_encountered_call

static

the first expression encountered which is a function call, so as to avoid "*+J" results

Definition at line 89 of file utils.c.

Referenced by expr_flt(), expr_rwt(), ref_flt(), and remove_variable_from_reduction().

fsr_found

reference fsr_found

static

Definition at line 529 of file utils.c.

Referenced by equal_reference_in_expression_p(), and fsr_reference_flt().

fsr_op

tag fsr_op

static

Definition at line 530 of file utils.c.

Referenced by equal_reference_in_expression_p(), fsr_call_flt(), and fsr_reference_flt().

fsr_ref

reference fsr_ref

static

looks for an equal reference in e, for reduction rop.

the reference found is also returned. caution:

• for integers, / is not a valid reduction operator:-( this case is detected here... static variables:
• refererence looked for fsr_ref,
• reduction operator tag fsr_op,
• returned reference fsr_found,

Definition at line 528 of file utils.c.

Referenced by equal_reference_in_expression_p(), and fsr_reference_flt().

is_functional

bool is_functional

static

tells whether r is a functional reference...

actually I would need to recompute somehow the proper effects of obj?

Definition at line 368 of file utils.c.

Referenced by call_flt(), and functional_object_p().

referenced

list referenced

static

returns the list of referenced variables

of entity

Definition at line 60 of file utils.c.

Referenced by collect_images(), freia_cleanup_main_sequence(), freia_cleanup_sequence_rec(), ref_rwt(), and referenced_variables().

variable_to_remove

entity variable_to_remove

static

must be able to remove a modified variable from a reduction:

A(I) / I -> A(*) . A(B(C(I))) / C -> A(B(*)) . A(I+J) / I -> A(*) . A(B(I)+C(I)) / I -> A(*) or A(B(*)+C(*)) ? former looks better the variable that must be removed is stored here

Definition at line 82 of file utils.c.

Referenced by ref_flt(), and remove_variable_from_reduction().