normalize.c File Reference

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "misc.h"
#include "ri-util.h"
#include "properties.h"
#include "operator.h"

Include dependency graph for normalize.c:

Go to the source code of this file.

Functions
static normalized	_NormalizeExpression (expression e)
	this function shouldn't be called. More...
normalized	NormalizeExpression (expression e)
	normalize.c More...
normalized	NormalizeSyntax (syntax s)
normalized	NormalizeCast (cast c)
normalized	NormalizeCall (call c)
normalized	NormalizeConstant (constant c)
normalized	NormalizeReference (reference r)
normalized	NormalizeIntrinsic (entity e, list la)
normalized	binary_to_normalized (list la, int op)
bool	EvalNormalized (normalized n, int *pv)
void	FreeNormalized (normalized n)
void	free_expression_normalized (expression e)
void	unnormalize_expression (void *st)
	void unnormalize_expression(expression exp): puts all the normalized field of expressions in "st" to undefined and does the unnormalization recursively More...
Pvecteur	expression_to_affine (expression e)
static bool	normalized_constant_p (normalized n, int *pv)
static normalized	normalize_intrinsic (entity f, list la)
static normalized	normalize_constant (constant c)
normalized	normalize_reference (reference r)
static normalized	normalize_call (call c)
static void	norm_all_rewrite (expression e)
	Look for affine expressions and encode them as vectors when possible. More...
void	normalize_all_expressions_of (void *obj)
static bool	normalize_first_expressions_filter (expression e)
void	normalize_first_expressions_of (void *obj)

Function Documentation

_NormalizeExpression()

static normalized _NormalizeExpression ( expression  e )

static

this function shouldn't be called.

Use macro NORMALIZE_EXPRESSION(e) instead.

Definition at line 76 of file normalize.c.

{
        return NormalizeSyntax(expression_syntax(e));
}

References expression_syntax, and NormalizeSyntax().

Referenced by binary_to_normalized(), expression_to_affine(), NormalizeExpression(), and NormalizeIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

binary_to_normalized()

normalized binary_to_normalized	(	list	la,
		int	op
	)

initialized to please gcc

FI: the C operator is different from the Fortran operator for non-positive arguments.

FI: the C operator is different from the Fortran operator for non-positive arguments.

Parameters

la	a
op	p

Definition at line 320 of file normalize.c.

{
    normalized ng;
    normalized nd;
    normalized n;
    int val1;
    int val2;
    int val = 0; /* initialized to please gcc */
 
    pips_assert("binary_to_normalize", gen_length(la) == 2);
 
    ng = _NormalizeExpression(EXPRESSION(CAR(la)));
    if (normalized_complex_p(ng))
        return(ng);
 
    nd = _NormalizeExpression(EXPRESSION(CAR(CDR(la))));
    if (normalized_complex_p(nd)) {
        FreeNormalized(ng);
        return(nd);
    }
 
    if (EvalNormalized(nd, &val2) && EvalNormalized(ng, &val1)) {
        bool succeed = true;
 
        FreeNormalized(nd);
        FreeNormalized(ng);
        switch(op) {
        case MINIMUM:
            val = MIN(val1, val2);
            break;
        case MAXIMUM:
            val = MAX(val1, val2);
            break;
        case MOD:
            /* FI: the C operator is different from the Fortran operator
             * for non-positive arguments.
             */
            if(val2==0) {
                user_error("binary_to_normalize",
                           "0 divide in modulo evaluation\n");
            }
            else {
                val = val1%val2;
            }
            break;
        case SLASH:
            /* FI: the C operator is different from the Fortran operator
             * for non-positive arguments.
             */
            if(val2==0) {
                user_error("binary_to_normalize",
                           "0 divide\n");
            }
            else {
                val = val1/val2;
            }
            break;
        case POWER:
            if(val2<0) {
                succeed = false;
            }
            else {
                val = ipow(val1,val2);
            }
            break;
        default:
            pips_internal_error("Unknown binary operator %d", op);
        }
        if(succeed) {
            n = make_normalized(is_normalized_linear,
                                vect_new(TCST, val));
        }
        else {
            n = make_normalized(is_normalized_complex, UU);
        }
    }
    else {
        FreeNormalized(ng);
        FreeNormalized(nd);
        n = make_normalized(is_normalized_complex, UU);
    }
    return n;
}

References _NormalizeExpression(), CAR, CDR, EvalNormalized(), EXPRESSION, FreeNormalized(), gen_length(), ipow(), is_normalized_complex, is_normalized_linear, make_normalized(), MAX, MAXIMUM, MIN, MINIMUM, MOD, normalized_complex_p, pips_assert, pips_internal_error, POWER, SLASH, TCST, user_error, UU, and vect_new().

Referenced by NormalizeIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalNormalized()

bool EvalNormalized	(	normalized	n,
		int *	pv
	)

Parameters

pv

v

Definition at line 404 of file normalize.c.

{
    if (normalized_linear_p(n)) {
        Pvecteur v = (Pvecteur) normalized_linear(n);
        if (vect_size(v) == 1 && var_of(v) == TCST) {
            *pv = VALUE_TO_INT(val_of(v));
            return(true);
        }
    }
 
    return(false);              
}

References normalized_linear, normalized_linear_p, TCST, val_of, VALUE_TO_INT, var_of, and vect_size().

Referenced by binary_to_normalized(), loop_increment_value(), NormalizeIntrinsic(), and words_numerical_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_affine()

Pvecteur expression_to_affine

(

expression

e

)

As long as VECTEUR_UNDEFINED is not different from VECTEUR_NUL this routine cannot be used safely; either 0 will be considered not linear or every non linear expression will be equal to 0

should it also perform the conversion from variable entities to new value entities?

Definition at line 461 of file normalize.c.

{
    normalized n;
    Pvecteur v;
 
    /* As long as VECTEUR_UNDEFINED is not different from VECTEUR_NUL
       this routine cannot be used safely; either 0 will be considered
       not linear or every non linear expression will be equal to 0 */
 
    /* should it also perform the conversion from variable entities
       to new value entities? */
 
    if(expression_normalized(e)==normalized_undefined)
        n = _NormalizeExpression(e);
    else
        n = expression_normalized(e);
 
    if(normalized_linear_p(n))
        v = vect_dup((Pvecteur) normalized_linear(n));
    else
        v = VECTEUR_UNDEFINED;
 
    return v;
}

References _NormalizeExpression(), expression_normalized, normalized_linear, normalized_linear_p, normalized_undefined, vect_dup(), and VECTEUR_UNDEFINED.

Referenced by transformer_add_loop_index_incrementation().

Here is the call graph for this function:

Here is the caller graph for this function:

free_expression_normalized()

void free_expression_normalized

(

expression

e

)

Definition at line 432 of file normalize.c.

{
    normalized n = normalized_undefined;
 
    if((n = expression_normalized(e)) != normalized_undefined) {
        FreeNormalized(n);
        expression_normalized(e) = normalized_undefined;
    }
}

References expression_normalized, FreeNormalized(), and normalized_undefined.

Referenced by unnormalize_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeNormalized()

void FreeNormalized

(

normalized

n

)

FI: theoretically, free_normalized() performs the next three lines...

gen_free(n);

Definition at line 419 of file normalize.c.

{
    /* FI: theoretically, free_normalized() performs the next three lines... */
    if (normalized_linear_p(n)) {
        vect_rm(normalized_linear(n));
        normalized_linear_(n) = NULL;
    }
 
    free_normalized(n);
    /* gen_free(n); */
}

References free_normalized(), normalized_linear, normalized_linear_, normalized_linear_p, and vect_rm().

Referenced by binary_to_normalized(), free_expression_normalized(), and NormalizeIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

norm_all_rewrite()

static void norm_all_rewrite ( expression  e )

static

Look for affine expressions and encode them as vectors when possible.

Definition at line 635 of file normalize.c.

{
  syntax s = expression_syntax(e);
  tag t = syntax_tag(s);
 
  if (normalized_undefined_p(expression_normalized(e))) {
    normalized n = normalized_undefined;
 
    switch(t) {
    case is_syntax_range:
      n = make_normalized(is_normalized_complex, UU);
      break;
    case is_syntax_reference:
      n = normalize_reference(syntax_reference(s));
      break;
    case is_syntax_call:
      n = normalize_call(syntax_call(s));
      break;
    case is_syntax_cast:
    case is_syntax_sizeofexpression:
    case is_syntax_subscript:
    case is_syntax_application:
    case is_syntax_va_arg:
      n = make_normalized(is_normalized_complex, UU);
      break;
    default:
      n = normalized_undefined;
      pips_internal_error("undefined syntax tag (%d)", t);
    }
    expression_normalized(e) = n;
  }
}

References expression_normalized, expression_syntax, is_normalized_complex, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_normalized(), normalize_call(), normalize_reference(), normalized_undefined, normalized_undefined_p, pips_internal_error, syntax_call, syntax_reference, syntax_tag, and UU.

Referenced by normalize_all_expressions_of().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_all_expressions_of()

void normalize_all_expressions_of

(

void *

obj

)

Parameters

obj

bj

Definition at line 668 of file normalize.c.

{
    gen_multi_recurse(obj, expression_domain, gen_true, norm_all_rewrite,
                      NULL);
}

References expression_domain, gen_multi_recurse(), gen_true(), and norm_all_rewrite().

Referenced by array_overflow(), atom_cse_expression(), atomize_this_expression(), call_rwt(), free_guards(), handle_align_and_realign_directive(), handle_distribute_and_redistribute_directive(), loop_flt(), normalize_wp65_code(), NormalizeCodeForHpfc(), and simd_atomize_this_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_call()

static normalized normalize_call ( call  c )

static

Definition at line 604 of file normalize.c.

{
    normalized n = normalized_undefined;
    entity f = call_function(c);
    value v = entity_initial(f);
    tag t = value_tag(v);
 
    switch (t)
    {
    case is_value_intrinsic:
        n = normalize_intrinsic(f, call_arguments(c));
        break;
      case is_value_constant:
        n = normalize_constant(value_constant(v));
        break;
      case is_value_symbolic:
        n = normalize_constant(symbolic_constant(value_symbolic(v)));
        break;
      case is_value_unknown:
      case is_value_code:
        n = make_normalized(is_normalized_complex, UU);
        break;
      default:
        pips_internal_error("unexpected value tag (%d)", t);
    }
 
    return(n);
}

References call_arguments, call_function, entity_initial, f(), is_normalized_complex, is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_normalized(), normalize_constant(), normalize_intrinsic(), normalized_undefined, pips_internal_error, symbolic_constant, UU, value_constant, value_symbolic, and value_tag.

Referenced by norm_all_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_constant()

static normalized normalize_constant ( constant  c )

static

Definition at line 583 of file normalize.c.

{
    return((constant_int_p(c)) ?
           make_normalized(is_normalized_linear,
                           vect_new(TCST, constant_int(c))) :
           make_normalized(is_normalized_complex, UU));
}

References constant_int, constant_int_p, is_normalized_complex, is_normalized_linear, make_normalized(), TCST, UU, and vect_new().

Referenced by normalize_call().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_first_expressions_filter()

static bool normalize_first_expressions_filter ( expression  e )

static

---

the first expressions encountered are normalized

normalized

n = NORMALIZE_EXPRESSION(e);

ifdebug(8)

fprintf(stderr, "[NormExpr] result (%p)\n", n),

print_expression(e);

Definition at line 679 of file normalize.c.

{
    if (normalized_undefined_p(expression_normalized(e)))
    {
        // FI: to avoid cycles betwen librairies ri-util and prettyprint
        /* normalized */
        /*     n = NORMALIZE_EXPRESSION(e); */
        /* ifdebug(8) */
        /*     fprintf(stderr, "[NormExpr] result (%p)\n", n), */
        /*     print_expression(e); */
    }
 
    return false;
}

References expression_normalized, and normalized_undefined_p.

Referenced by normalize_first_expressions_of().

Here is the caller graph for this function:

normalize_first_expressions_of()

void normalize_first_expressions_of

(

void *

obj

)

Parameters

obj

bj

Definition at line 694 of file normalize.c.

{
    gen_multi_recurse(obj,
                      expression_domain,
                      normalize_first_expressions_filter,
                      gen_null,
                      NULL);
}

References expression_domain, gen_multi_recurse(), gen_null(), and normalize_first_expressions_filter().

Referenced by normalize_align(), normalize_distribute(), and normalize_hpf_object().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_intrinsic()

static normalized normalize_intrinsic ( entity  f, list  la  )

static

else

else

else

else

else multiply (caution: vect_multiply does not allocate...)

else

Definition at line 517 of file normalize.c.

{
    bool minus;
        
    if (! top_level_entity_p(f))
        return(make_normalized(is_normalized_complex, UU));
 
    if (ENTITY_UNARY_MINUS_P(f))
    {
        Pvecteur tmp = VECTEUR_NUL;
        normalized n = expression_normalized(EXPRESSION(CAR(la)));
 
        return(normalized_complex_p(n) ?
               make_normalized(is_normalized_complex, UU) :
               make_normalized(is_normalized_linear,
                   (vect_chg_sgn(tmp=vect_dup(normalized_linear(n))), tmp)));
    }
    /* else */
    if ((minus=ENTITY_MINUS_P(f)) || (ENTITY_PLUS_P(f)))
    {
        normalized
            n1 = expression_normalized(EXPRESSION(CAR(la))),
            n2 = expression_normalized(EXPRESSION(CAR(CDR(la))));
        Pvecteur (*operation)() = minus ? vect_substract : vect_add;
 
        assert(!normalized_undefined_p(n1) && !normalized_undefined_p(n2));
 
        if (normalized_complex_p(n1) || normalized_complex_p(n2))
            return(make_normalized(is_normalized_complex, UU));
        /* else */
        return(make_normalized(is_normalized_linear,
                               operation(normalized_linear(n1),
                                         normalized_linear(n2))));
    }
    /* else */
    if (ENTITY_MULTIPLY_P(f))
    {
        normalized
            n1 = expression_normalized(EXPRESSION(CAR(la))),
            n2 = expression_normalized(EXPRESSION(CAR(CDR(la))));
        bool b1, b2;
        int i1, i2;
        Pvecteur v;
 
        if (normalized_complex_p(n1) || normalized_complex_p(n2))
            return(make_normalized(is_normalized_complex, UU));
        /* else */
        b1 = normalized_constant_p(n1, &i1),
        b2 = normalized_constant_p(n2, &i2);
 
        if (! (b1 || b2)) return(make_normalized(is_normalized_complex, UU));
 
        /* else multiply (caution: vect_multiply does not allocate...)
         */
        v = vect_dup(b1 ? normalized_linear(n2) : normalized_linear(n1));
 
        return(make_normalized(is_normalized_linear,
                               vect_multiply(v, b1 ? i1 : i2)));
    }
    /* else */
    return(make_normalized(is_normalized_complex, UU));
}

References assert, b1, b2, CAR, CDR, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_P, ENTITY_UNARY_MINUS_P, EXPRESSION, expression_normalized, f(), is_normalized_complex, is_normalized_linear, make_normalized(), normalized_complex_p, normalized_constant_p(), normalized_linear, normalized_undefined_p, top_level_entity_p(), UU, vect_add(), vect_chg_sgn(), vect_dup(), vect_multiply(), vect_substract(), and VECTEUR_NUL.

Referenced by normalize_call().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_reference()

normalized normalize_reference

(

reference

r

)

Definition at line 592 of file normalize.c.

{
    entity var = reference_variable(r);
 
    pips_assert("The entity var is a variable", entity_variable_p(var));
 
    return(entity_integer_scalar_p(var) ?
           make_normalized(is_normalized_linear, vect_new((Variable) var, 1)) :
           make_normalized(is_normalized_complex, UU));
}

References entity_integer_scalar_p(), entity_variable_p, is_normalized_complex, is_normalized_linear, make_normalized(), pips_assert, reference_variable, UU, and vect_new().

Referenced by norm_all_rewrite(), and reference_to_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeCall()

normalized NormalizeCall

(

call

c

)

Definition at line 145 of file normalize.c.

{
    normalized n=normalized_undefined;
    entity f = call_function(c);
    value v = entity_initial(f);
 
    switch (value_tag(v)) {
      case is_value_intrinsic:
        n = NormalizeIntrinsic(f, call_arguments(c));
        break;
      case is_value_constant:
        n = NormalizeConstant((value_constant(v)));
        break;
      case is_value_symbolic:
        if(get_bool_property("EVAL_SYMBOLIC_CONSTANT"))
          n = NormalizeConstant((symbolic_constant(value_symbolic(v))));
        else
          n= make_normalized_linear( vect_new(f, VALUE_ONE) );
        break;
      case is_value_unknown:
      case is_value_code:
        n = make_normalized(is_normalized_complex, UU);
        break;
      default:
        pips_internal_error("case default");
    }
 
    return(n);
}

References call_arguments, call_function, entity_initial, f(), get_bool_property(), is_normalized_complex, is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_normalized(), make_normalized_linear(), NormalizeConstant(), normalized_undefined, NormalizeIntrinsic(), pips_internal_error, symbolic_constant, UU, value_constant, VALUE_ONE, value_symbolic, value_tag, and vect_new().

Referenced by NormalizeSyntax().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeCast()

normalized NormalizeCast

(

cast

c

)

Definition at line 130 of file normalize.c.

{
  normalized n=normalized_undefined;
   type ct = cast_type(c);
   expression cexp = cast_expression(c);
   type cexpt = expression_to_type(cexp);
 
   if (type_equal_p(ct, cexpt))
     n = NormalizeExpression(cexp);
   else
     n = make_normalized_complex();
   free_type(cexpt);
   return(n);
}

References cast_expression, cast_type, expression_to_type(), free_type(), make_normalized_complex(), normalized_undefined, NormalizeExpression(), and type_equal_p().

Referenced by NormalizeSyntax().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeConstant()

normalized NormalizeConstant

(

constant

c

)

Definition at line 175 of file normalize.c.

{
    return((constant_int_p(c)) ?
           make_normalized_linear(vect_new(TCST, constant_int(c))) :
           make_normalized_complex());
}

References constant_int, constant_int_p, make_normalized_complex(), make_normalized_linear(), TCST, and vect_new().

Referenced by NormalizeCall().

Here is the call graph for this function:

Here is the caller graph for this function:

normalized_constant_p()

static bool normalized_constant_p ( normalized  n, int *  pv  )

static

---

New Stuff to normalize all expressions - bottom-up

FC 09/06/94

Definition at line 494 of file normalize.c.

{
    if (normalized_linear_p(n))
    {
        Pvecteur v = normalized_linear(n);
        int length = vect_size(v);
        
        if (length==0)
        {
            *pv=0;
            return true;
        }
        else if (length==1 && var_of(v)==TCST)
        {
          *pv=VALUE_TO_INT(val_of(v));
          return true;
        }
    }
 
    return false;
}

References normalized_linear, normalized_linear_p, TCST, val_of, VALUE_TO_INT, var_of, and vect_size().

Referenced by normalize_intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeExpression()

normalized NormalizeExpression

(

expression

e

)

normalize.c

Definition at line 81 of file normalize.c.

{
    normalized n;
 
    if (expression_normalized(e) != normalized_undefined)
        user_warning("NormalizeExpression",
                     "expression is already normalized\n");
 
    n = _NormalizeExpression(e);
    // expression_normalized(e) = n;
    return(n);
}

References _NormalizeExpression(), expression_normalized, normalized_undefined, and user_warning.

Referenced by force_renormalize(), NormalizeCast(), xml_Connection(), and xml_ConstOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeIntrinsic()

normalized NormalizeIntrinsic	(	entity	e,
		list	la
	)

There is no point in normalizing ng since this cannot be expressed by a normalized expression

Parameters

la

a

Definition at line 221 of file normalize.c.

{
  normalized n;
 
  if (! top_level_entity_p(e))
    return(make_normalized(is_normalized_complex, UU));
 
  if (ENTITY_UNARY_MINUS_P(e)) {
    n = _NormalizeExpression(EXPRESSION(CAR(la)));
 
    if (normalized_complex_p(n))
      return(n);
 
    vect_chg_sgn(normalized_linear(n));
  }
  else if (ENTITY_MINUS_P(e) || ENTITY_MINUS_C_P(e) || ENTITY_PLUS_P(e) || ENTITY_PLUS_C_P(e)) {
    normalized ng, nd;
 
    ng = _NormalizeExpression(EXPRESSION(CAR(la)));
    if (normalized_complex_p(ng))
      return(ng);
 
    nd = _NormalizeExpression(EXPRESSION(CAR(CDR(la))));
    if (normalized_complex_p(nd)) {
      FreeNormalized(ng);
      return(nd);
    }
 
    n = (ENTITY_PLUS_P(e) || ENTITY_PLUS_C_P(e)) ?
      make_normalized(is_normalized_linear,
                      vect_add(normalized_linear(ng),
                               normalized_linear(nd))) :
      make_normalized(is_normalized_linear,
                      vect_substract(normalized_linear(ng),
                                     normalized_linear(nd)));
 
    FreeNormalized(ng);
    FreeNormalized(nd);
  }
  else if (ENTITY_MINUS_UPDATE_P(e) || ENTITY_PLUS_UPDATE_P(e)) {
    /* There is no point in normalizing ng since this cannot be
       expressed by a normalized expression */
    //normalized nd;
 
    (void) _NormalizeExpression(EXPRESSION(CAR(CDR(la))));
    return make_normalized_complex();
  }
  else if (ENTITY_MULTIPLY_P(e)) {
    normalized ng, nd;
    int val;
 
    ng = _NormalizeExpression(EXPRESSION(CAR(la)));
    if (normalized_complex_p(ng))
      return(ng);
 
    nd = _NormalizeExpression(EXPRESSION(CAR(CDR(la))));
    if (normalized_complex_p(nd)) {
      FreeNormalized(ng);
      return(nd);
    }
 
    if (EvalNormalized(nd, &val)) {
      FreeNormalized(nd);
      normalized_linear(n = ng) =
        vect_multiply(normalized_linear(ng), val);
    }
    else if (EvalNormalized(ng, &val)) {
      FreeNormalized(ng);
      normalized_linear(n = nd) =
        vect_multiply(normalized_linear(nd), val);
    }
    else {
      FreeNormalized(ng);
      FreeNormalized(nd);
      return(make_normalized(is_normalized_complex, UU));
    }
  }
  else if((ENTITY_MIN_P(e) || ENTITY_MIN0_P(e)) && gen_length(la) == 2) {
    n = binary_to_normalized(la, MINIMUM);
  }
  else if((ENTITY_MAX_P(e) || ENTITY_MAX0_P(e)) && gen_length(la) == 2) {
    n = binary_to_normalized(la, MAXIMUM);
  }
  else if(ENTITY_MODULO_P(e)) {
    n = binary_to_normalized(la, MOD);
  }
  else if(ENTITY_DIVIDE_P(e)) {
    n = binary_to_normalized(la, SLASH);
  }
  else if(ENTITY_POWER_P(e)) {
    n = binary_to_normalized(la, POWER);
  }
  else {
    return(make_normalized(is_normalized_complex, UU));
  }
 
  return(n);
}

References _NormalizeExpression(), binary_to_normalized(), CAR, CDR, ENTITY_DIVIDE_P, ENTITY_MAX0_P, ENTITY_MAX_P, ENTITY_MIN0_P, ENTITY_MIN_P, ENTITY_MINUS_C_P, ENTITY_MINUS_P, ENTITY_MINUS_UPDATE_P, ENTITY_MODULO_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_C_P, ENTITY_PLUS_P, ENTITY_PLUS_UPDATE_P, ENTITY_POWER_P, ENTITY_UNARY_MINUS_P, EvalNormalized(), EXPRESSION, FreeNormalized(), gen_length(), is_normalized_complex, is_normalized_linear, make_normalized(), make_normalized_complex(), MAXIMUM, MINIMUM, MOD, normalized_complex_p, normalized_linear, POWER, SLASH, top_level_entity_p(), UU, vect_add(), vect_chg_sgn(), vect_multiply(), and vect_substract().

Referenced by NormalizeCall().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeReference()

normalized NormalizeReference

(

reference

r

)

SG is there any good reason to exclude pointer arithmetic ?

Definition at line 182 of file normalize.c.

{
  normalized n = normalized_undefined;
  entity e = reference_variable(r);
  type t = entity_type(e);
 
  pips_assert("constant term ore is an entity",
              entity_domain_number(e)==entity_domain);
 
  if (!type_variable_p(t)) {
    if(type_functional_p(t)) {
      // FI: we might not want to keep the warning for C code...
      pips_user_warning("Reference to function \"%s\" cannot be normalized.\n"
                        "Is it an undeclared variable?\n",
                        entity_user_name(e));
      n = make_normalized(is_normalized_complex, UU);
    }
    else {
      pips_user_warning("Reference to entity \"%s\" cannot be normalized because of its type tag %d\n",
                        entity_name(e), type_tag(t));
      pips_user_error("Referenced entity should be a variable!\n");
    }
  }
  else {
    Variable v = (Variable) e;
    Value val = VALUE_ONE;
 
    /* SG is there any good reason to exclude pointer arithmetic ?*/
    n = (entity_integer_scalar_p(e) || 
            entity_enum_variable_p(e) ||
            ( entity_pointer_p(e) && ENDP(reference_indices(r))) ) ?
      make_normalized(is_normalized_linear,
                      vect_new(v, val)) :
      make_normalized(is_normalized_complex, UU);
  }
 
  return n;
}

References ENDP, entity_domain, entity_domain_number, entity_enum_variable_p(), entity_integer_scalar_p(), entity_name, entity_pointer_p(), entity_type, entity_user_name(), is_normalized_complex, is_normalized_linear, make_normalized(), normalized_undefined, pips_assert, pips_user_error, pips_user_warning, reference_indices, reference_variable, type_functional_p, type_tag, type_variable_p, UU, VALUE_ONE, and vect_new().

Referenced by NormalizeSyntax().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeSyntax()

normalized NormalizeSyntax

(

syntax

s

)

Definition at line 94 of file normalize.c.

{
    normalized n=normalized_undefined;
 
    switch (syntax_tag(s)) {
      case is_syntax_reference:
        n = NormalizeReference(syntax_reference(s));
        break;
      case is_syntax_range:
        n = make_normalized_complex();
        break;
      case is_syntax_call:
        n = NormalizeCall((syntax_call(s)));
        break;
    case is_syntax_cast:
      n = NormalizeCast(syntax_cast(s));
      break;
    case is_syntax_sizeofexpression:
        n = make_normalized_complex();
      break;
    case is_syntax_subscript:
        n = make_normalized_complex();
      break;
    case is_syntax_application:
        n = make_normalized_complex();
      break;
    case is_syntax_va_arg:
        n = make_normalized_complex();
      break;
      default:
        pips_internal_error("cas default");
    }
 
    return(n);
}

References is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_normalized_complex(), NormalizeCall(), NormalizeCast(), normalized_undefined, NormalizeReference(), pips_internal_error, syntax_call, syntax_cast, syntax_reference, and syntax_tag.

Referenced by _NormalizeExpression(), and array_indices_communication().

Here is the call graph for this function:

Here is the caller graph for this function:

unnormalize_expression()

void unnormalize_expression

(

void *

st

)

void unnormalize_expression(expression exp): puts all the normalized field of expressions in "st" to undefined and does the unnormalization recursively

This is very useful when you combine expressions. It prohibits unnormalized expressions with normalized sub-expressions.

FI: any chunk* can be passed; this function could be applied to an expression

Parameters

st

t

Definition at line 452 of file normalize.c.

{
    gen_multi_recurse(st,
                      expression_domain,
                      gen_true,
                      free_expression_normalized,
                      NULL);
}

References expression_domain, free_expression_normalized(), gen_multi_recurse(), and gen_true().

Referenced by analyze_expression(), do_gather_all_expressions_perms(), do_outliner_smart_replacment(), do_scalar_renaming(), get_exp_schedule(), get_m_coef(), inline_expression_call(), my_adg_expressions_to_predicate(), nlc_linear_expression_p(), optimize_expressions(), partial_eval_expression(), perform_substitution(), rational_op_exp(), redundant_load_store_elimination(), rename_reference(), replace_entities_expression_walker(), sp_linear_expression_p(), splc_linear_expression_p(), try_reorder_expression_call(), and update_expression_syntax().

Here is the call graph for this function:

Here is the caller graph for this function: