norm_exp.c File Reference

#include "local.h"
#include "prettyprint.h"

Include dependency graph for norm_exp.c:

Go to the source code of this file.

Macros
#define	NLC_PREFIX   "NLC"
	– norm_exp.c More...
#define	ENTITY_NLC_P(e)   (strncmp(entity_local_name(e), NLC_PREFIX, 3) == 0)

Functions
void	normal_expression_of_expression (expression exp)
	=========================================================================== More...
void	normal_expression_of_statement (statement s)
	=========================================================================== More...
void	normal_expression_of_unstructured (unstructured u)
	=========================================================================== More...
int	get_nlc_number (entity nlc_ent)
	=========================================================================== More...
static Pvecteur	config_vecteur (Pvecteur Vvar)
	=========================================================================== More...
void	reconfig_expression (expression exp)
	=========================================================================== More...

Macro Definition Documentation

ENTITY_NLC_P

#define ENTITY_NLC_P

(

e

)

(strncmp(entity_local_name(e), NLC_PREFIX, 3) == 0)

Definition at line 49 of file norm_exp.c.

NLC_PREFIX

#define NLC_PREFIX   "NLC"

– norm_exp.c

package atomizer : Alexis Platonoff, aout 91

Functions for the normalization of expressions.

Before the atomization, all the expression of the Code are put in a normal form. This normal form gathers the NLCs variables in the innermost parenthesis with the constant term. The NLCs are sorted in order to have the innerloop counter in the inner parenthesis.

Thus, the following expression: (4*S + ( NLC1 + ((T + 7) + 3*NLC2))) + C) + 8*NLC3 is normalized in: 4*S + (T + (C + (8*NLC1 + (3*NLC2 + (NLC3 + 7)))))

For more information about NLCs, see loop_normalize package. include "loop_normalize.h"

Definition at line 48 of file norm_exp.c.

Function Documentation

config_vecteur()

static Pvecteur config_vecteur ( Pvecteur  Vvar )

static

===========================================================================

static Pvecteur config_vecteur(Pvecteur Vvar): returns a Pvecteur resulting of the configuration of the Pvecteur "Vvar".

Firstly, we put into three different Pvecteurs the constant term, the NLCs variables and the others variables (not NLCs). The NLCs variables are ordered from the greater to the smaller number.

Secondly, we concatenate these three Pvecteurs in the order: constant_term, nlc, not_nlc.

For example, with Pvecteur: 2*I 3*NLC2 1*NLC1 4*T 7 we could obtain: 7 3*NLC2 1*NLC1 4*T 2*I

"Vc" is the constant term.

"Vc" is a NLC.

"Vc" is not a NLC.

Definition at line 225 of file norm_exp.c.

{
Pvecteur Vnot_nlc, Vnlc, Vterm_cst, newV, Vc, Vaux;
 
Vterm_cst = VECTEUR_NUL;
Vnlc = VECTEUR_NUL;
Vnot_nlc = VECTEUR_NUL;
for(Vc = Vvar; !VECTEUR_NUL_P(Vc); Vc = Vc->succ)
  {
  /* "Vc" is the constant term. */
  if(term_cst(Vc))
    Vterm_cst = vect_new(Vc->var, Vc->val);
  else
    {
    entity var = (entity) Vc->var;
    Pvecteur new_vect = vect_new(Vc->var, Vc->val);
 
    /* "Vc" is a NLC. */
    if(ENTITY_NLC_P(var))
      {
      int num, crt_num = 0;
 
      if(VECTEUR_NUL_P(Vnlc))
        Vnlc = new_vect;
      else
        {
        num = get_nlc_number(var);
 
        crt_num = get_nlc_number((entity) Vnlc->var);
        if(num > crt_num)
          {
          new_vect->succ = Vnlc;
          Vnlc = new_vect;
          }
        else
          {
          bool not_fin = true;
          Pvecteur Vs = Vnlc, Vp;
          while(not_fin)
            {
            Vp = Vs;
            Vs = Vs->succ;
            if(!VECTEUR_NUL_P(Vs))
              {
              crt_num = get_nlc_number((entity) Vs->var);
              if(num > crt_num)
                {
                new_vect->succ = Vs;
                Vp->succ = new_vect;
                not_fin = false;
                }
              }
            else
              {
              Vp->succ = new_vect;
              not_fin = false;
              }
            }
          }
        }
      }
 
    /* "Vc" is not a NLC. */
    else
      {
      new_vect->succ = Vnot_nlc;
      Vnot_nlc = new_vect;
      }
    }
  }
 
newV = Vnot_nlc;
 
if(!VECTEUR_NUL_P(Vnlc))
  {
  Vc = Vnlc;
  while(!VECTEUR_NUL_P(Vc))
    {
    Vaux = Vc;
    Vc = Vc->succ;
    }
  Vaux->succ = newV;
  newV = Vnlc;
  }
 
if(!VECTEUR_NUL_P(Vterm_cst))
  {
  Vterm_cst->succ = newV;
  newV = Vterm_cst;
  }
 
return(newV);
}

References ENTITY_NLC_P, get_nlc_number(), num, Svecteur::succ, term_cst, Svecteur::val, Svecteur::var, vect_new(), VECTEUR_NUL, and VECTEUR_NUL_P.

Referenced by reconfig_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

get_nlc_number()

int get_nlc_number

(

entity

nlc_ent

)

===========================================================================

int get_nlc_number(entity nlc_ent): returns the number ending "nlc_ent" name. The local name is "NLC#", so we have to get the "#".

Parameters

nlc_ent

lc_ent

Definition at line 198 of file norm_exp.c.

{
const char* nlc_name = entity_local_name(nlc_ent);
const char* num = nlc_name+3;
 
return(atoi(num));
}

References entity_local_name(), and num.

Referenced by config_vecteur().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_expression_of_expression()

void normal_expression_of_expression

(

expression

exp

)

===========================================================================

norm_exp.c

void normal_expression_of_expression(expression exp): normalizes "exp".

There are three cases:

1. "exp" is a call to an intrinsic or external function.
2. "exp" is a reference.
3. "exp" is a range

In the case (1), if "exp" is linear (ie normalized), we call reconfig_expression(); it computes the normalization of "exp" with its Pvecteur. If "exp" is not integer linear, this function is called recursively upon the arguments of the call.

In case (2), we call this function upon each of the indices of "exp".

In case (3), we do nothing. Such a case may occur with a range argument in a call to a write or read procedure.

Parameters

exp

xp

Definition at line 72 of file norm_exp.c.

{
syntax sy = expression_syntax(exp);
if(syntax_tag(sy) == is_syntax_call)
  {
  call c = syntax_call(sy);
  if(! call_constant_p(c))
    {
    NORMALIZE_EXPRESSION(exp);
    if(normalized_tag(expression_normalized(exp)) == is_normalized_linear)
      {
      pips_debug(5, "Expression Linear : %s\n", expression_to_string(exp));
 
      reconfig_expression(exp);
      }
    else
      {
      list args = call_arguments(c);
 
      pips_debug(5, "Expression Complex : %s\n",
                 expression_to_string(exp));
 
      for(; args != NIL; args = CDR(args))
        normal_expression_of_expression(EXPRESSION(CAR(args)));
      }
    expression_normalized(exp) = normalized_undefined;
    }
  }
else if(syntax_tag(sy) == is_syntax_reference)
  {
  reference ref = syntax_reference(sy);
  list inds = reference_indices(ref);
  for(; inds != NIL; inds = CDR(inds))
    normal_expression_of_expression(EXPRESSION(CAR(inds)));
  }
else if(syntax_tag(sy) == is_syntax_range)
  {
   pips_debug(6, "Expression Range : %s\n",
              expression_to_string(exp));
  }
else
  pips_internal_error("Bad expression tag");
}

References call_arguments, call_constant_p, CAR, CDR, exp, EXPRESSION, expression_normalized, expression_syntax, expression_to_string(), is_normalized_linear, is_syntax_call, is_syntax_range, is_syntax_reference, NIL, normal_expression_of_expression(), NORMALIZE_EXPRESSION, normalized_tag, normalized_undefined, pips_debug, pips_internal_error, reconfig_expression(), ref, reference_indices, syntax_call, syntax_reference, and syntax_tag.

Referenced by normal_expression_of_expression(), and normal_expression_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_expression_of_statement()

void normal_expression_of_statement

(

statement

s

)

===========================================================================

void normal_expression_of_statement(statement s): normalizes the expressions contained in "s".

Definition at line 123 of file norm_exp.c.

{
instruction inst = statement_instruction(s);
 
debug(4, "normal_expression_of_statement", "begin STATEMENT\n");
 
switch(instruction_tag(inst))
  {
  case is_instruction_block :
  { list block = instruction_block(inst);
    for(; block != NIL ; block = CDR(block))
      normal_expression_of_statement(STATEMENT(CAR(block)));
    break; }
  case is_instruction_test :
  { test t = instruction_test(inst);
    normal_expression_of_expression(test_condition(t));
    normal_expression_of_statement(test_true(t));
    normal_expression_of_statement(test_false(t));
    break; }
  case is_instruction_loop :
  { loop l = instruction_loop(inst);
    range lr = loop_range(l);
    normal_expression_of_expression(range_lower(lr));
    normal_expression_of_expression(range_upper(lr));
    normal_expression_of_expression(range_increment(lr));
    normal_expression_of_statement(loop_body(l));
    break; }
  case is_instruction_call : 
  { call c = instruction_call(inst);
    list args = call_arguments(c);
 
    debug(4, "normal_expression_of_statement", "Stmt CALL: %s\n",
             entity_local_name(call_function(c)));
 
    for(; args != NIL; args = CDR(args))
      normal_expression_of_expression(EXPRESSION(CAR(args)));
    break; }
  case is_instruction_goto : break;
  case is_instruction_unstructured :
  { normal_expression_of_unstructured(instruction_unstructured(inst));
    break; }
  default : pips_internal_error("Bad instruction tag");
  }
debug(4, "normal_expression_of_statement", "end STATEMENT\n");
}

References call_arguments, call_function, CAR, CDR, debug(), entity_local_name(), EXPRESSION, instruction_block, instruction_call, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_body, loop_range, NIL, normal_expression_of_expression(), normal_expression_of_statement(), normal_expression_of_unstructured(), pips_internal_error, range_increment, range_lower, range_upper, STATEMENT, statement_instruction, test_condition, test_false, and test_true.

Referenced by atomizer(), normal_expression_of_statement(), and normal_expression_of_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_expression_of_unstructured()

void normal_expression_of_unstructured

(

unstructured

u

)

===========================================================================

void normal_expression_of_unstructured(unstructured u): normalizes the expressions of an unstructured instruction "u".

Definition at line 176 of file norm_exp.c.

{
list blocs = NIL;
 
debug(3, "normal_expression_of_unstructured", "begin UNSTRUCTURED\n");
 
CONTROL_MAP(c, { normal_expression_of_statement(control_statement(c)) ; },
                 unstructured_control( u ), blocs);
 
gen_free_list(blocs);
 
debug(3, "normal_expression_of_unstructured", "end UNSTRUCTURED\n");
}

References CONTROL_MAP, control_statement, debug(), gen_free_list(), NIL, normal_expression_of_statement(), and unstructured_control.

Referenced by normal_expression_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

reconfig_expression()

void reconfig_expression

(

expression

exp

)

===========================================================================

void reconfig_expression(expression exp): "exp" is reordered so as to gather all the NLCs in the innermost parenthesis. More, the NLC of the inner loop is in the innermost parenthesis with the TCST (constant term). For example, if we have: (4*S + ( NLC1 + ((T + 7) + 3*NLC2))) + C) + 8*NLC3 it is reordered in: 4*S + (T + (C + (8*NLC1 + (3*NLC2 + (NLC3 + 7)))))

Called functions: _ Pvecteur_to_expression() : loop_normalize/utils.c

We configurate the Pvecteur of "exp".

We build a new expression with the configurated Pvecteur.

We change the syntax of "exp".

Parameters

exp

xp

Definition at line 334 of file norm_exp.c.

{
Pvecteur vect, new_vect;
syntax sy = expression_syntax(exp);
normalized nor = NORMALIZE_EXPRESSION(exp);
expression new_exp;
 
if(normalized_tag(nor) != is_normalized_linear)
  return;
if(syntax_tag(sy) == is_syntax_reference)
  return;
if(call_constant_p(syntax_call(sy)))
  return;
 
vect = (Pvecteur) normalized_linear(nor);
 
/* We configurate the Pvecteur of "exp". */
new_vect = config_vecteur(vect);
 
/* We build a new expression with the configurated Pvecteur. */
new_exp = Pvecteur_to_expression(new_vect);
 
/* We change the syntax of "exp". */
if(new_exp != expression_undefined)
  expression_syntax(exp) = expression_syntax(new_exp);
}

References call_constant_p, config_vecteur(), exp, expression_syntax, expression_undefined, is_normalized_linear, is_syntax_reference, NORMALIZE_EXPRESSION, normalized_linear, normalized_tag, Pvecteur_to_expression(), syntax_call, and syntax_tag.

Referenced by normal_expression_of_expression().

Here is the call graph for this function:

Here is the caller graph for this function: